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