Kernel/arch/x86_64/proc.c

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