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