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