Kernel/arch/x86/proc.c

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