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