Kernel/arch/x86/proc.c

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