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