Kernel/arch/x86_64/proc.c

   1 /*
   2  * Acess2 x86_64 port
   3  * proc.c
   4  */
   5 #include <acess.h>
   6 #include <proc.h>
   7 #include <threads.h>
   8 #include <threads_int.h>
   9 #include <desctab.h>
  10 #include <mm_virt.h>
  11 #include <errno.h>
  12 #if USE_MP
  13 # include <mp.h>
  14 #endif
  15 #include <arch_config.h>
  16 #include <hal_proc.h>
  17
  18 // === FLAGS ===
  19 #define DEBUG_TRACE_SWITCH      0
  20 //#define BREAK_ON_SWITCH       1       // Break into bochs debugger on a task switch
  21
  22 // === CONSTANTS ===
  23 #define SWITCH_MAGIC    0x55ECAFFF##FFFACE55    // There is no code in this area
  24
  25 // === TYPES ===
  26 typedef struct sCPU
  27 {
  28         Uint8   APICID;
  29         Uint8   State;  // 0: Unavaliable, 1: Idle, 2: Active
  30         Uint16  Resvd;
  31         tThread *Current;
  32         tThread *IdleThread;
  33 }       tCPU;
  34
  35 // === IMPORTS ===
  36 extern tGDT     gGDT[];
  37 extern void     APStartup(void);        // 16-bit AP startup code
  38 extern Uint     GetRIP(void);   // start.asm
  39 extern Uint64   gInitialPML4[512];      // start.asm
  40 extern char     gInitialKernelStack[];
  41 extern tShortSpinlock   glThreadListLock;
  42 extern int      giNumCPUs;
  43 extern int      giNextTID;
  44 extern int      giTotalTickets;
  45 extern int      giNumActiveThreads;
  46 extern tThread  gThreadZero;
  47 extern void     Threads_Dump(void);
  48 extern void     Proc_ReturnToUser(void);
  49 extern void     Time_UpdateTimestamp(void);
  50
  51 // === PROTOTYPES ===
  52 //void  ArchThreads_Init(void);
  53 #if USE_MP
  54 void    MP_StartAP(int CPU);
  55 void    MP_SendIPI(Uint8 APICID, int Vector, int DeliveryMode);
  56 #endif
  57 //void  Proc_Start(void);
  58 //tThread       *Proc_GetCurThread(void);
  59 void    Proc_ChangeStack(void);
  60 // int  Proc_Clone(Uint *Err, Uint Flags);
  61 // int  Proc_SpawnWorker(void);
  62 Uint    Proc_MakeUserStack(void);
  63 //void  Proc_StartUser(Uint Entrypoint, Uint *Bases, int ArgC, char **ArgV, char **EnvP, int DataSize);
  64 void    Proc_StartProcess(Uint16 SS, Uint Stack, Uint Flags, Uint16 CS, Uint IP);
  65  int    Proc_Demote(Uint *Err, int Dest, tRegs *Regs);
  66 //void  Proc_CallFaultHandler(tThread *Thread);
  67 //void  Proc_DumpThreadCPUState(tThread *Thread);
  68 void    Proc_Scheduler(int CPU);
  69
  70 // === GLOBALS ===
  71 //!\brief Used by desctab.asm in SyscallStub
  72 const int ci_offsetof_tThread_KernelStack = offsetof(tThread, KernelStack);
  73 // --- Multiprocessing ---
  74 #if USE_MP
  75 volatile int    giNumInitingCPUs = 0;
  76 tMPInfo *gMPFloatPtr = NULL;
  77 tAPIC   *gpMP_LocalAPIC = NULL;
  78 Uint8   gaAPIC_to_CPU[256] = {0};
  79 #endif
  80 tCPU    gaCPUs[MAX_CPUS];
  81 tTSS    *gTSSs = NULL;
  82 tTSS    gTSS0 = {0};
  83 // --- Error Recovery ---
  84 Uint32  gaDoubleFaultStack[1024];
  85
  86 // === CODE ===
  87 /**
  88  * \fn void ArchThreads_Init(void)
  89  * \brief Starts the process scheduler
  90  */
  91 void ArchThreads_Init(void)
  92 {
  93         Uint    pos = 0;
  94
  95         #if USE_MP
  96         tMPTable        *mptable;
  97
  98         // Mark BSP as active
  99         gaCPUs[0].State = 2;
 100
 101         // -- Initialise Multiprocessing
 102         // Find MP Floating Table
 103         // - EBDA/Last 1Kib (640KiB)
 104         for(pos = KERNEL_BASE|0x9F000; pos < (KERNEL_BASE|0xA0000); pos += 16) {
 105                 if( *(Uint*)(pos) == MPPTR_IDENT ) {
 106                         Log("Possible %p", pos);
 107                         if( ByteSum((void*)pos, sizeof(tMPInfo)) != 0 ) continue;
 108                         gMPFloatPtr = (void*)pos;
 109                         break;
 110                 }
 111         }
 112         // - Last KiB (512KiB base mem)
 113         if(!gMPFloatPtr) {
 114                 for(pos = KERNEL_BASE|0x7F000; pos < (KERNEL_BASE|0x80000); pos += 16) {
 115                         if( *(Uint*)(pos) == MPPTR_IDENT ) {
 116                                 Log("Possible %p", pos);
 117                                 if( ByteSum((void*)pos, sizeof(tMPInfo)) != 0 ) continue;
 118                                 gMPFloatPtr = (void*)pos;
 119                                 break;
 120                         }
 121                 }
 122         }
 123         // - BIOS ROM
 124         if(!gMPFloatPtr) {
 125                 for(pos = KERNEL_BASE|0xE0000; pos < (KERNEL_BASE|0x100000); pos += 16) {
 126                         if( *(Uint*)(pos) == MPPTR_IDENT ) {
 127                                 Log("Possible %p", pos);
 128                                 if( ByteSum((void*)pos, sizeof(tMPInfo)) != 0 ) continue;
 129                                 gMPFloatPtr = (void*)pos;
 130                                 break;
 131                         }
 132                 }
 133         }
 134
 135         // If the MP Table Exists, parse it
 136         if(gMPFloatPtr)
 137         {
 138                  int    i;
 139                 tMPTable_Ent    *ents;
 140                 Log("gMPFloatPtr = %p", gMPFloatPtr);
 141                 Log("*gMPFloatPtr = {");
 142                 Log("\t.Sig = 0x%08x", gMPFloatPtr->Sig);
 143                 Log("\t.MPConfig = 0x%08x", gMPFloatPtr->MPConfig);
 144                 Log("\t.Length = 0x%02x", gMPFloatPtr->Length);
 145                 Log("\t.Version = 0x%02x", gMPFloatPtr->Version);
 146                 Log("\t.Checksum = 0x%02x", gMPFloatPtr->Checksum);
 147                 Log("\t.Features = [0x%02x,0x%02x,0x%02x,0x%02x,0x%02x]",
 148                         gMPFloatPtr->Features[0],       gMPFloatPtr->Features[1],
 149                         gMPFloatPtr->Features[2],       gMPFloatPtr->Features[3],
 150                         gMPFloatPtr->Features[4]
 151                         );
 152                 Log("}");
 153
 154                 mptable = (void*)( KERNEL_BASE|gMPFloatPtr->MPConfig );
 155                 Log("mptable = %p", mptable);
 156                 Log("*mptable = {");
 157                 Log("\t.Sig = 0x%08x", mptable->Sig);
 158                 Log("\t.BaseTableLength = 0x%04x", mptable->BaseTableLength);
 159                 Log("\t.SpecRev = 0x%02x", mptable->SpecRev);
 160                 Log("\t.Checksum = 0x%02x", mptable->Checksum);
 161                 Log("\t.OEMID = '%8c'", mptable->OemID);
 162                 Log("\t.ProductID = '%8c'", mptable->ProductID);
 163                 Log("\t.OEMTablePtr = %p'", mptable->OEMTablePtr);
 164                 Log("\t.OEMTableSize = 0x%04x", mptable->OEMTableSize);
 165                 Log("\t.EntryCount = 0x%04x", mptable->EntryCount);
 166                 Log("\t.LocalAPICMemMap = 0x%08x", mptable->LocalAPICMemMap);
 167                 Log("\t.ExtendedTableLen = 0x%04x", mptable->ExtendedTableLen);
 168                 Log("\t.ExtendedTableChecksum = 0x%02x", mptable->ExtendedTableChecksum);
 169                 Log("}");
 170
 171                 gpMP_LocalAPIC = (void*)MM_MapHWPage(mptable->LocalAPICMemMap, 1);
 172
 173                 ents = mptable->Entries;
 174                 giNumCPUs = 0;
 175
 176                 for( i = 0; i < mptable->EntryCount; i ++ )
 177                 {
 178                          int    entSize = 0;
 179                         switch( ents->Type )
 180                         {
 181                         case 0: // Processor
 182                                 entSize = 20;
 183                                 Log("%i: Processor", i);
 184                                 Log("\t.APICID = %i", ents->Proc.APICID);
 185                                 Log("\t.APICVer = 0x%02x", ents->Proc.APICVer);
 186                                 Log("\t.CPUFlags = 0x%02x", ents->Proc.CPUFlags);
 187                                 Log("\t.CPUSignature = 0x%08x", ents->Proc.CPUSignature);
 188                                 Log("\t.FeatureFlags = 0x%08x", ents->Proc.FeatureFlags);
 189
 190
 191                                 if( !(ents->Proc.CPUFlags & 1) ) {
 192                                         Log("DISABLED");
 193                                         break;
 194                                 }
 195
 196                                 // Check if there is too many processors
 197                                 if(giNumCPUs >= MAX_CPUS) {
 198                                         giNumCPUs ++;   // If `giNumCPUs` > MAX_CPUS later, it will be clipped
 199                                         break;
 200                                 }
 201
 202                                 // Initialise CPU Info
 203                                 gaAPIC_to_CPU[ents->Proc.APICID] = giNumCPUs;
 204                                 gaCPUs[giNumCPUs].APICID = ents->Proc.APICID;
 205                                 gaCPUs[giNumCPUs].State = 0;
 206                                 giNumCPUs ++;
 207
 208                                 // Send IPI
 209                                 if( !(ents->Proc.CPUFlags & 2) )
 210                                 {
 211                                         MP_StartAP( giNumCPUs-1 );
 212                                 }
 213
 214                                 break;
 215                         case 1: // Bus
 216                                 entSize = 8;
 217                                 Log("%i: Bus", i);
 218                                 Log("\t.ID = %i", ents->Bus.ID);
 219                                 Log("\t.TypeString = '%6c'", ents->Bus.TypeString);
 220                                 break;
 221                         case 2: // I/O APIC
 222                                 entSize = 8;
 223                                 Log("%i: I/O APIC", i);
 224                                 Log("\t.ID = %i", ents->IOAPIC.ID);
 225                                 Log("\t.Version = 0x%02x", ents->IOAPIC.Version);
 226                                 Log("\t.Flags = 0x%02x", ents->IOAPIC.Flags);
 227                                 Log("\t.Addr = 0x%08x", ents->IOAPIC.Addr);
 228                                 break;
 229                         case 3: // I/O Interrupt Assignment
 230                                 entSize = 8;
 231                                 Log("%i: I/O Interrupt Assignment", i);
 232                                 Log("\t.IntType = %i", ents->IOInt.IntType);
 233                                 Log("\t.Flags = 0x%04x", ents->IOInt.Flags);
 234                                 Log("\t.SourceBusID = 0x%02x", ents->IOInt.SourceBusID);
 235                                 Log("\t.SourceBusIRQ = 0x%02x", ents->IOInt.SourceBusIRQ);
 236                                 Log("\t.DestAPICID = 0x%02x", ents->IOInt.DestAPICID);
 237                                 Log("\t.DestAPICIRQ = 0x%02x", ents->IOInt.DestAPICIRQ);
 238                                 break;
 239                         case 4: // Local Interrupt Assignment
 240                                 entSize = 8;
 241                                 Log("%i: Local Interrupt Assignment", i);
 242                                 Log("\t.IntType = %i", ents->LocalInt.IntType);
 243                                 Log("\t.Flags = 0x%04x", ents->LocalInt.Flags);
 244                                 Log("\t.SourceBusID = 0x%02x", ents->LocalInt.SourceBusID);
 245                                 Log("\t.SourceBusIRQ = 0x%02x", ents->LocalInt.SourceBusIRQ);
 246                                 Log("\t.DestLocalAPICID = 0x%02x", ents->LocalInt.DestLocalAPICID);
 247                                 Log("\t.DestLocalAPICIRQ = 0x%02x", ents->LocalInt.DestLocalAPICIRQ);
 248                                 break;
 249                         default:
 250                                 Log("%i: Unknown (%i)", i, ents->Type);
 251                                 break;
 252                         }
 253                         ents = (void*)( (Uint)ents + entSize );
 254                 }
 255
 256                 if( giNumCPUs > MAX_CPUS ) {
 257                         Warning("Too many CPUs detected (%i), only using %i of them", giNumCPUs, MAX_CPUS);
 258                         giNumCPUs = MAX_CPUS;
 259                 }
 260
 261                 while( giNumInitingCPUs )
 262                         MM_FinishVirtualInit();
 263
 264                 Panic("Uh oh... MP Table Parsing is unimplemented\n");
 265         }
 266         else {
 267                 Log("No MP Table was found, assuming uniprocessor\n");
 268                 giNumCPUs = 1;
 269                 gTSSs = &gTSS0;
 270         }
 271         #else
 272         giNumCPUs = 1;
 273         gTSSs = &gTSS0;
 274         MM_FinishVirtualInit();
 275         #endif
 276
 277         #if USE_MP
 278         // Initialise Normal TSS(s)
 279         for(pos=0;pos<giNumCPUs;pos++)
 280         {
 281         #else
 282         pos = 0;
 283         #endif
 284                 gTSSs[pos].RSP0 = 0;    // Set properly by scheduler
 285                 gGDT[7+pos*2].LimitLow = sizeof(tTSS) & 0xFFFF;
 286                 gGDT[7+pos*2].BaseLow = ((Uint)(&gTSSs[pos])) & 0xFFFF;
 287                 gGDT[7+pos*2].BaseMid = ((Uint)(&gTSSs[pos])) >> 16;
 288                 gGDT[7+pos*2].BaseHi = ((Uint)(&gTSSs[pos])) >> 24;
 289                 gGDT[7+pos*2+1].DWord[0] = ((Uint)(&gTSSs[pos])) >> 32;
 290         #if USE_MP
 291         }
 292         for(pos=0;pos<giNumCPUs;pos++) {
 293                 __asm__ __volatile__ ("ltr %%ax"::"a"(0x38+pos*16));
 294         }
 295         #else
 296         __asm__ __volatile__ ("ltr %%ax"::"a"(0x38));
 297         #endif
 298
 299         // Set Debug registers
 300         __asm__ __volatile__ ("mov %0, %%db0" : : "r"(&gThreadZero));
 301         __asm__ __volatile__ ("mov %%rax, %%db1" : : "a"(0));
 302
 303         gaCPUs[0].Current = &gThreadZero;
 304
 305         gThreadZero.MemState.CR3 = (Uint)gInitialPML4 - KERNEL_BASE;
 306         gThreadZero.CurCPU = 0;
 307
 308         // Set timer frequency
 309         outb(0x43, 0x34);       // Set Channel 0, Low/High, Rate Generator
 310         outb(0x40, PIT_TIMER_DIVISOR&0xFF);     // Low Byte of Divisor
 311         outb(0x40, (PIT_TIMER_DIVISOR>>8)&0xFF);        // High Byte
 312
 313         // Create Per-Process Data Block
 314         if( !MM_Allocate(MM_PPD_CFG) )
 315         {
 316                 Warning("Oh, hell, Unable to allocate PPD for Thread#0");
 317         }
 318
 319         // Change Stacks
 320         Proc_ChangeStack();
 321
 322         Log("Multithreading initialised");
 323 }
 324
 325 #if USE_MP
 326 void MP_StartAP(int CPU)
 327 {
 328         Log("Starting AP %i (APIC %i)", CPU, gaCPUs[CPU].APICID);
 329         // Set location of AP startup code and mark for a warm restart
 330         *(Uint16*)(KERNEL_BASE|0x467) = (Uint)&APStartup - (KERNEL_BASE|0xFFFF0);
 331         *(Uint16*)(KERNEL_BASE|0x469) = 0xFFFF;
 332         outb(0x70, 0x0F);       outb(0x71, 0x0A);       // Warm Reset
 333         MP_SendIPI(gaCPUs[CPU].APICID, 0, 5);
 334         giNumInitingCPUs ++;
 335 }
 336
 337 void MP_SendIPI(Uint8 APICID, int Vector, int DeliveryMode)
 338 {
 339         Uint32  addr = (Uint)gpMP_LocalAPIC + 0x300;
 340         Uint32  val;
 341
 342         // High
 343         val = (Uint)APICID << 24;
 344         Log("*%p = 0x%08x", addr+0x10, val);
 345         *(Uint32*)(addr+0x10) = val;
 346         // Low (and send)
 347         val = ((DeliveryMode & 7) << 8) | (Vector & 0xFF);
 348         Log("*%p = 0x%08x", addr, val);
 349         *(Uint32*)addr = val;
 350 }
 351 #endif
 352
 353 /**
 354  * \fn void Proc_Start(void)
 355  * \brief Start process scheduler
 356  */
 357 void Proc_Start(void)
 358 {
 359         #if USE_MP
 360          int    i;
 361         #endif
 362
 363         #if USE_MP
 364         // Start APs
 365         for( i = 0; i < giNumCPUs; i ++ )
 366         {
 367                  int    tid;
 368                 if(i)   gaCPUs[i].Current = NULL;
 369
 370                 // Create Idle Task
 371                 if( (tid = Proc_Clone(0, 0)) == 0)
 372                 {
 373                         for(;;) HALT(); // Just yeilds
 374                 }
 375                 gaCPUs[i].IdleThread = Threads_GetThread(tid);
 376                 gaCPUs[i].IdleThread->ThreadName = "Idle Thread";
 377                 Threads_SetTickets( gaCPUs[i].IdleThread, 0 );  // Never called randomly
 378                 gaCPUs[i].IdleThread->Quantum = 1;      // 1 slice quantum
 379
 380
 381                 // Start the AP
 382                 if( i != giProc_BootProcessorID ) {
 383                         MP_StartAP( i );
 384                 }
 385         }
 386
 387         // BSP still should run the current task
 388         gaCPUs[0].Current = &gThreadZero;
 389
 390         // Start interrupts and wait for APs to come up
 391         Log("Waiting for APs to come up\n");
 392         __asm__ __volatile__ ("sti");
 393         while( giNumInitingCPUs )       __asm__ __volatile__ ("hlt");
 394         #else
 395         // Create Idle Task
 396         if(Proc_Clone(0) == 0)
 397         {
 398                 gaCPUs[0].IdleThread = Proc_GetCurThread();
 399                 gaCPUs[0].IdleThread->ThreadName = (char*)"Idle Thread";
 400                 Threads_SetPriority( gaCPUs[0].IdleThread, -1 );        // Never called randomly
 401                 gaCPUs[0].IdleThread->Quantum = 1;      // 1 slice quantum
 402                 for(;;) HALT(); // Just yeilds
 403         }
 404
 405         // Set current task
 406         gaCPUs[0].Current = &gThreadZero;
 407         gaCPUs[0].Current->CurCPU = 0;
 408
 409         // Start Interrupts (and hence scheduler)
 410         __asm__ __volatile__("sti");
 411         #endif
 412         MM_FinishVirtualInit();
 413         Log("Multithreading started");
 414 }
 415
 416 /**
 417  * \fn tThread *Proc_GetCurThread(void)
 418  * \brief Gets the current thread
 419  */
 420 tThread *Proc_GetCurThread(void)
 421 {
 422         #if USE_MP
 423         return gaCPUs[ GetCPUNum() ].Current;
 424         #else
 425         return gaCPUs[ 0 ].Current;
 426         #endif
 427 }
 428
 429 /**
 430  * \fn void Proc_ChangeStack(void)
 431  * \brief Swaps the current stack for a new one (in the proper stack reigon)
 432  */
 433 void Proc_ChangeStack(void)
 434 {
 435         Uint    rsp, rbp;
 436         Uint    tmp_rbp, old_rsp;
 437         Uint    curBase, newBase;
 438
 439         __asm__ __volatile__ ("mov %%rsp, %0":"=r"(rsp));
 440         __asm__ __volatile__ ("mov %%rbp, %0":"=r"(rbp));
 441
 442         old_rsp = rsp;
 443
 444         // Create new KStack
 445         newBase = MM_NewKStack();
 446         // Check for errors
 447         if(newBase == 0) {
 448                 Panic("What the?? Unable to allocate space for initial kernel stack");
 449                 return;
 450         }
 451
 452         curBase = (Uint)&gInitialKernelStack;
 453
 454         Log("curBase = 0x%x, newBase = 0x%x", curBase, newBase);
 455
 456         // Get ESP as a used size
 457         rsp = curBase - rsp;
 458         Log("memcpy( %p, %p, 0x%x )", (void*)(newBase - rsp), (void*)(curBase - rsp), rsp );
 459         // Copy used stack
 460         memcpy( (void*)(newBase - rsp), (void*)(curBase - rsp), rsp );
 461         // Get ESP as an offset in the new stack
 462         rsp = newBase - rsp;
 463         // Adjust EBP
 464         rbp = newBase - (curBase - rbp);
 465
 466         Log("Update stack");
 467         // Repair EBPs & Stack Addresses
 468         // Catches arguments also, but may trash stack-address-like values
 469         for(tmp_rbp = rsp; tmp_rbp < newBase; tmp_rbp += sizeof(Uint))
 470         {
 471                 if(old_rsp < *(Uint*)tmp_rbp && *(Uint*)tmp_rbp < curBase)
 472                         *(Uint*)tmp_rbp += newBase - curBase;
 473         }
 474
 475         Log("Applying Changes");
 476         Proc_GetCurThread()->KernelStack = newBase;
 477         __asm__ __volatile__ ("mov %0, %%rsp"::"r"(rsp));
 478         __asm__ __volatile__ ("mov %0, %%rbp"::"r"(rbp));
 479 }
 480
 481 /**
 482  * \fn int Proc_Clone(Uint Flags)
 483  * \brief Clone the current process
 484  */
 485 int Proc_Clone(Uint Flags)
 486 {
 487         tThread *newThread;
 488         tThread *cur = Proc_GetCurThread();
 489         Uint    rip, rsp, rbp;
 490
 491         __asm__ __volatile__ ("mov %%rsp, %0": "=r"(rsp));
 492         __asm__ __volatile__ ("mov %%rbp, %0": "=r"(rbp));
 493
 494         newThread = Threads_CloneTCB(NULL, Flags);
 495         if(!newThread)  return -1;
 496
 497         Log("Proc_Clone: newThread = %p", newThread);
 498
 499         // Initialise Memory Space (New Addr space or kernel stack)
 500         if(Flags & CLONE_VM) {
 501                 Log("Proc_Clone: Cloning VM");
 502                 newThread->MemState.CR3 = MM_Clone();
 503                 newThread->KernelStack = cur->KernelStack;
 504 //              MAGIC_BREAK();
 505         } else {
 506                 Uint    tmp_rbp, old_rsp = rsp;
 507
 508                 // Set CR3
 509                 newThread->MemState.CR3 = cur->MemState.CR3;
 510
 511                 // Create new KStack
 512                 newThread->KernelStack = MM_NewKStack();
 513                 Log("Proc_Clone: newKStack = %p", newThread->KernelStack);
 514                 // Check for errors
 515                 if(newThread->KernelStack == 0) {
 516                         free(newThread);
 517                         return -1;
 518                 }
 519
 520                 // Get ESP as a used size
 521                 rsp = cur->KernelStack - rsp;
 522                 // Copy used stack
 523                 memcpy(
 524                         (void*)(newThread->KernelStack - rsp),
 525                         (void*)(cur->KernelStack - rsp),
 526                         rsp
 527                         );
 528                 // Get ESP as an offset in the new stack
 529                 rsp = newThread->KernelStack - rsp;
 530                 // Adjust EBP
 531                 rbp = newThread->KernelStack - (cur->KernelStack - rbp);
 532
 533                 // Repair EBPs & Stack Addresses
 534                 // Catches arguments also, but may trash stack-address-like values
 535                 for(tmp_rbp = rsp; tmp_rbp < newThread->KernelStack; tmp_rbp += sizeof(Uint))
 536                 {
 537                         if(old_rsp < *(Uint*)tmp_rbp && *(Uint*)tmp_rbp < cur->KernelStack)
 538                                 *(Uint*)tmp_rbp += newThread->KernelStack - cur->KernelStack;
 539                 }
 540         }
 541
 542         // Save core machine state
 543         newThread->SavedState.RSP = rsp;
 544         newThread->SavedState.RBP = rbp;
 545         rip = GetRIP();
 546         if(rip == SWITCH_MAGIC) {
 547                 outb(0x20, 0x20);       // ACK Timer and return as child
 548                 __asm__ __volatile__ ("sti");
 549 //              MAGIC_BREAK();
 550                 return 0;
 551         }
 552
 553         // Set EIP as parent
 554         newThread->SavedState.RIP = rip;
 555
 556         // Lock list and add to active
 557         Threads_AddActive(newThread);
 558
 559         return newThread->TID;
 560 }
 561
 562 /**
 563  * \fn int Proc_SpawnWorker(void)
 564  * \brief Spawns a new worker thread
 565  */
 566 int Proc_SpawnWorker(void)
 567 {
 568         tThread *new, *cur;
 569         Uint    rip, rsp, rbp;
 570
 571         cur = Proc_GetCurThread();
 572
 573         // Create new thread
 574         new = malloc( sizeof(tThread) );
 575         if(!new) {
 576                 Warning("Proc_SpawnWorker - Out of heap space!\n");
 577                 return -1;
 578         }
 579         memcpy(new, &gThreadZero, sizeof(tThread));
 580         // Set Thread ID
 581         new->TID = giNextTID++;
 582         // Create a new worker stack (in PID0's address space)
 583         // The stack is relocated by this code
 584         new->KernelStack = MM_NewWorkerStack();
 585
 586         // Get ESP and EBP based in the new stack
 587         __asm__ __volatile__ ("mov %%rsp, %0": "=r"(rsp));
 588         __asm__ __volatile__ ("mov %%rbp, %0": "=r"(rbp));
 589         rsp = new->KernelStack - (cur->KernelStack - rsp);
 590         rbp = new->KernelStack - (cur->KernelStack - rbp);
 591
 592         // Save core machine state
 593         new->SavedState.RSP = rsp;
 594         new->SavedState.RBP = rbp;
 595         rip = GetRIP();
 596         if(rip == SWITCH_MAGIC) {
 597                 outb(0x20, 0x20);       // ACK Timer and return as child
 598                 __asm__ __volatile__ ("sti");
 599                 return 0;
 600         }
 601
 602         // Set EIP as parent
 603         new->SavedState.RIP = rip;
 604         // Mark as active
 605         new->Status = THREAD_STAT_PREINIT;
 606         Threads_AddActive( new );
 607
 608         return new->TID;
 609 }
 610
 611 /**
 612  * \fn Uint Proc_MakeUserStack(void)
 613  * \brief Creates a new user stack
 614  */
 615 Uint Proc_MakeUserStack(void)
 616 {
 617          int    i;
 618         Uint    base = USER_STACK_TOP - USER_STACK_SZ;
 619
 620         // Check Prospective Space
 621         for( i = USER_STACK_SZ >> 12; i--; )
 622                 if( MM_GetPhysAddr( base + (i<<12) ) != 0 )
 623                         break;
 624
 625         if(i != -1)     return 0;
 626
 627         // Allocate Stack - Allocate incrementally to clean up MM_Dump output
 628         for( i = 0; i < USER_STACK_SZ/0x1000; i++ )
 629         {
 630                 if( !MM_Allocate( base + (i<<12) ) )
 631                 {
 632                         // Error
 633                         Log_Error("Proc", "Unable to allocate user stack (%i pages requested)", USER_STACK_SZ/0x1000);
 634                         while( i -- )
 635                                 MM_Deallocate( base + (i<<12) );
 636                         return 0;
 637                 }
 638         }
 639
 640         return base + USER_STACK_SZ;
 641 }
 642
 643
 644 /**
 645  * \fn void Proc_StartUser(Uint Entrypoint, Uint *Bases, int ArgC, char **ArgV, char **EnvP, int DataSize)
 646  * \brief Starts a user task
 647  */
 648 void Proc_StartUser(Uint Entrypoint, Uint *Bases, int ArgC, char **ArgV, char **EnvP, int DataSize)
 649 {
 650         Uint    *stack = (void*)Proc_MakeUserStack();
 651          int    i;
 652         Uint    delta;
 653         Uint16  ss, cs;
 654
 655         LOG("stack = 0x%x", stack);
 656
 657         // Copy Arguments
 658         stack = (void*)( (Uint)stack - DataSize );
 659         memcpy( stack, ArgV, DataSize );
 660
 661         // Adjust Arguments and environment
 662         delta = (Uint)stack - (Uint)ArgV;
 663         ArgV = (char**)stack;
 664         for( i = 0; ArgV[i]; i++ )      ArgV[i] += delta;
 665         i ++;
 666         EnvP = &ArgV[i];
 667         for( i = 0; EnvP[i]; i++ )      EnvP[i] += delta;
 668
 669         // User Mode Segments
 670         ss = 0x23;      cs = 0x1B;
 671
 672         // Arguments
 673         *--stack = (Uint)EnvP;
 674         *--stack = (Uint)ArgV;
 675         *--stack = (Uint)ArgC;
 676         while(*Bases)
 677                 *--stack = *Bases++;
 678         *--stack = 0;   // Return Address
 679
 680         Proc_StartProcess(ss, (Uint)stack, 0x202, cs, Entrypoint);
 681 }
 682
 683 void Proc_StartProcess(Uint16 SS, Uint Stack, Uint Flags, Uint16 CS, Uint IP)
 684 {
 685         Uint    *stack = (void*)Stack;
 686         *--stack = SS;          //Stack Segment
 687         *--stack = Stack;       //Stack Pointer
 688         *--stack = Flags;       //EFLAGS (Resvd (0x2) and IF (0x20))
 689         *--stack = CS;          //Code Segment
 690         *--stack = IP;  //EIP
 691         //PUSHAD
 692 //      *--stack = 0xAAAAAAAA;  // rax
 693 //      *--stack = 0xCCCCCCCC;  // rcx
 694 //      *--stack = 0xDDDDDDDD;  // rdx
 695 //      *--stack = 0xBBBBBBBB;  // rbx
 696 //      *--stack = 0xD1D1D1D1;  // rdi
 697 //      *--stack = 0x54545454;  // rsp - NOT POPED
 698 //      *--stack = 0x51515151;  // rsi
 699 //      *--stack = 0xB4B4B4B4;  // rbp
 700         //Individual PUSHs
 701 //      *--stack = SS;  // ds
 702
 703         MAGIC_BREAK();
 704         __asm__ __volatile__ (
 705                 "mov %%rax,%%rsp;\n\t"  // Set stack pointer
 706                 "iretq;\n\t" : : "a" (stack)
 707                 );
 708         for(;;);
 709 }
 710
 711 /**
 712  * \fn int Proc_Demote(Uint *Err, int Dest, tRegs *Regs)
 713  * \brief Demotes a process to a lower permission level
 714  * \param Err   Pointer to user's errno
 715  * \param Dest  New Permission Level
 716  * \param Regs  Pointer to user's register structure
 717  */
 718 int Proc_Demote(Uint *Err, int Dest, tRegs *Regs)
 719 {
 720          int    cpl = Regs->CS & 3;
 721         // Sanity Check
 722         if(Dest > 3 || Dest < 0) {
 723                 *Err = -EINVAL;
 724                 return -1;
 725         }
 726
 727         // Permission Check
 728         if(cpl > Dest) {
 729                 *Err = -EACCES;
 730                 return -1;
 731         }
 732
 733         // Change the Segment Registers
 734         Regs->CS = (((Dest+1)<<4) | Dest) - 8;
 735         Regs->SS = ((Dest+1)<<4) | Dest;
 736
 737         return 0;
 738 }
 739
 740 /**
 741  * \brief Calls a signal handler in user mode
 742  * \note Used for signals
 743  */
 744 void Proc_CallFaultHandler(tThread *Thread)
 745 {
 746         // Rewinds the stack and calls the user function
 747         // Never returns
 748         __asm__ __volatile__ ("mov %0, %%rbp;\n\tcall Proc_ReturnToUser" :: "r"(Thread->FaultHandler));
 749         for(;;);
 750 }
 751
 752 void Proc_DumpThreadCPUState(tThread *Thread)
 753 {
 754         Log("  At %04x:%016llx", Thread->SavedState.UserCS, Thread->SavedState.UserRIP);
 755 }
 756
 757 /**
 758  * \fn void Proc_Scheduler(int CPU)
 759  * \brief Swap current thread and clears dead threads
 760  */
 761 void Proc_Scheduler(int CPU)
 762 {
 763         Uint    rsp, rbp, rip;
 764         tThread *thread;
 765
 766         if( CPU == 0 )
 767                 Time_UpdateTimestamp();
 768
 769         // If the spinlock is set, let it complete
 770         if(IS_LOCKED(&glThreadListLock))        return;
 771
 772         // Get current thread
 773         thread = gaCPUs[CPU].Current;
 774
 775         if( thread )
 776         {
 777                 tRegs   *regs;
 778                 // Reduce remaining quantum and continue timeslice if non-zero
 779                 if(thread->Remaining--) return;
 780                 // Reset quantum for next call
 781                 thread->Remaining = thread->Quantum;
 782
 783                 // Get machine state
 784                 __asm__ __volatile__ ("mov %%rsp, %0":"=r"(rsp));
 785                 __asm__ __volatile__ ("mov %%rbp, %0":"=r"(rbp));
 786                 rip = GetRIP();
 787                 if(rip == SWITCH_MAGIC) return; // Check if a switch happened
 788
 789                 // Save machine state
 790                 thread->SavedState.RSP = rsp;
 791                 thread->SavedState.RBP = rbp;
 792                 thread->SavedState.RIP = rip;
 793
 794                 // TODO: Make this more stable somehow
 795                 regs = (tRegs*)(rbp+(2+1)*8);   // RBP,Ret + CurThread
 796                 thread->SavedState.UserCS = regs->CS;
 797                 thread->SavedState.UserRIP = regs->RIP;
 798         }
 799
 800         #if BREAK_ON_SWITCH
 801         {
 802         tThread *oldthread = thread;
 803         #endif
 804
 805         // Get next thread
 806         thread = Threads_GetNextToRun(CPU, thread);
 807
 808         // Error Check
 809         if(thread == NULL) {
 810                 thread = gaCPUs[CPU].IdleThread;
 811                 //Warning("Hmm... Threads_GetNextToRun returned NULL, I don't think this should happen.\n");
 812 //              LogF("Zzzzz.\n");
 813                 //return;
 814         }
 815         if(thread == NULL ) {
 816                 return ;
 817         }
 818         #if BREAK_ON_SWITCH
 819         if( thread != oldthread ) {
 820                 MAGIC_BREAK();
 821         }
 822         }
 823         #endif
 824
 825         #if DEBUG_TRACE_SWITCH
 826         LogF("Switching to task %i, CR3 = 0x%x, RIP = %p",
 827                 thread->TID,
 828                 thread->MemState.CR3,
 829                 thread->SavedState.RIP
 830                 );
 831         #endif
 832
 833
 834         if(CPU > MAX_CPUS)
 835                 LogF("CPU = %i", CPU);
 836         // Set current thread
 837         gaCPUs[CPU].Current = thread;
 838
 839         // Update Kernel Stack pointer
 840         gTSSs[CPU].RSP0 = thread->KernelStack-4;
 841
 842         // Switch threads
 843         __asm__ __volatile__ (
 844                 "mov %4, %%cr3\n\t"
 845                 "mov %1, %%rsp\n\t"     // Restore RSP
 846                 "mov %2, %%rbp\n\t"     // and RBP
 847                 "jmp *%3" : :   // And return to where we saved state (Proc_Clone or Proc_Scheduler)
 848                 "a"(SWITCH_MAGIC), "r"(thread->SavedState.RSP),
 849                 "r"(thread->SavedState.RBP), "r"(thread->SavedState.RIP),
 850                 "r"(thread->MemState.CR3)
 851                 );
 852         for(;;);        // Shouldn't reach here
 853 }
 854
 855 // === EXPORTS ===
 856 EXPORT(Proc_SpawnWorker);