Kernel/arch/x86/proc.c

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