KernelLand/Kernel/arch/x86/proc.c

   1 /*
   2  * AcessOS Microkernel Version
   3  * proc.c
   4  */
   5 #include <acess.h>
   6 #include <threads.h>
   7 #include <proc.h>
   8 #include <desctab.h>
   9 #include <mm_virt.h>
  10 #include <errno.h>
  11 #if USE_MP
  12 # include <mp.h>
  13 #endif
  14 #include <hal_proc.h>
  15 #include <arch_int.h>
  16
  17 // === FLAGS ===
  18 #define DEBUG_TRACE_SWITCH      0
  19 #define DEBUG_DISABLE_DOUBLEFAULT       1
  20 #define DEBUG_VERY_SLOW_PERIOD  0
  21 #define DEBUG_NOPREEMPT 1
  22
  23 // === CONSTANTS ===
  24 // Base is 1193182
  25 #define TIMER_BASE      1193182
  26 #if DEBUG_VERY_SLOW_PERIOD
  27 # define TIMER_DIVISOR  1193    //~10Hz switch, with 10 quantum = 1s per thread
  28 #else
  29 # define TIMER_DIVISOR  11932   //~100Hz
  30 #endif
  31
  32 // === TYPES ===
  33 typedef struct sCPU
  34 {
  35         Uint8   APICID;
  36         Uint8   State;  // 0: Unavaliable, 1: Idle, 2: Active
  37         Uint16  Resvd;
  38         tThread *Current;
  39         tThread *LastTimerThread;       // Used to do preeemption
  40 }       tCPU;
  41
  42 // === IMPORTS ===
  43 extern tGDT     gGDT[];
  44 extern tIDT     gIDT[];
  45 extern void     APWait(void);   // 16-bit AP pause code
  46 extern void     APStartup(void);        // 16-bit AP startup code
  47 extern Uint     GetEIP(void);   // start.asm
  48 extern Uint     GetEIP_Sched(void);     // proc.asm
  49 extern void     NewTaskHeader(tThread *Thread, void *Fcn, int nArgs, ...);      // Actually takes cdecl args
  50 extern Uint     Proc_CloneInt(Uint *ESP, Uint32 *CR3, int bNoUserClone);
  51 extern Uint32   gaInitPageDir[1024];    // start.asm
  52 extern char     Kernel_Stack_Top[];
  53 extern int      giNumCPUs;
  54 extern int      giNextTID;
  55 extern tThread  gThreadZero;
  56 extern tProcess gProcessZero;
  57 extern void     Isr8(void);     // Double Fault
  58 extern void     Proc_ReturnToUser(tVAddr Handler, Uint Argument, tVAddr KernelStack);
  59 extern char     scheduler_return[];     // Return address in SchedulerBase
  60 extern char     IRQCommon[];    // Common IRQ handler code
  61 extern char     IRQCommon_handled[];    // IRQCommon call return location
  62 extern char     GetEIP_Sched_ret[];     // GetEIP call return location
  63 extern void     SwitchTasks(Uint NewSP, Uint *OldSP, Uint NewIP, Uint *OldIO, Uint CR3);
  64 extern void     Proc_InitialiseSSE(void);
  65 extern void     Proc_SaveSSE(Uint DestPtr);
  66 extern void     Proc_DisableSSE(void);
  67
  68 // === PROTOTYPES ===
  69 //void  ArchThreads_Init(void);
  70 #if USE_MP
  71 void    MP_StartAP(int CPU);
  72 void    MP_SendIPIVector(int CPU, Uint8 Vector);
  73 void    MP_SendIPI(Uint8 APICID, int Vector, int DeliveryMode);
  74 #endif
  75 void    Proc_IdleThread(void *Ptr);
  76 //void  Proc_Start(void);
  77 //tThread       *Proc_GetCurThread(void);
  78 void    Proc_ChangeStack(void);
  79 // int  Proc_NewKThread(void (*Fcn)(void*), void *Data);
  80 // int  Proc_Clone(Uint *Err, Uint Flags);
  81 Uint    Proc_MakeUserStack(void);
  82 //void  Proc_StartUser(Uint Entrypoint, Uint *Bases, int ArgC, char **ArgV, char **EnvP, int DataSize);
  83 void    Proc_StartProcess(Uint16 SS, Uint Stack, Uint Flags, Uint16 CS, Uint IP) NORETURN;
  84  int    Proc_Demote(Uint *Err, int Dest, tRegs *Regs);
  85 //void  Proc_CallFaultHandler(tThread *Thread);
  86 //void  Proc_DumpThreadCPUState(tThread *Thread);
  87 void    Proc_Scheduler(int CPU);
  88
  89 // === GLOBALS ===
  90 // --- Multiprocessing ---
  91 #if USE_MP
  92 volatile int    giNumInitingCPUs = 0;
  93 tMPInfo *gMPFloatPtr = NULL;
  94 volatile Uint32 giMP_TimerCount;        // Start Count for Local APIC Timer
  95 tAPIC   *gpMP_LocalAPIC = NULL;
  96 Uint8   gaAPIC_to_CPU[256] = {0};
  97  int    giProc_BootProcessorID = 0;
  98 tTSS    gaTSSs[MAX_CPUS];       // TSS Array
  99 #endif
 100 tCPU    gaCPUs[MAX_CPUS] = {
 101         {.Current = &gThreadZero}
 102         };
 103 tTSS    *gTSSs = NULL;  // Pointer to TSS array
 104 tTSS    gTSS0 = {0};
 105 // --- Error Recovery ---
 106 char    gaDoubleFaultStack[1024] __attribute__ ((section(".padata")));
 107 tTSS    gDoubleFault_TSS = {
 108         .ESP0 = (Uint)&gaDoubleFaultStack[1024],
 109         .SS0 = 0x10,
 110         .CR3 = (Uint)gaInitPageDir - KERNEL_BASE,
 111         .EIP = (Uint)Isr8,
 112         .ESP = (Uint)&gaDoubleFaultStack[1024],
 113         .CS = 0x08,     .SS = 0x10,
 114         .DS = 0x10,     .ES = 0x10,
 115         .FS = 0x10,     .GS = 0x10,
 116 };
 117
 118 // === CODE ===
 119 /**
 120  * \fn void ArchThreads_Init(void)
 121  * \brief Starts the process scheduler
 122  */
 123 void ArchThreads_Init(void)
 124 {
 125         Uint    pos = 0;
 126
 127         #if USE_MP
 128         tMPTable        *mptable;
 129
 130         // Mark BSP as active
 131         gaCPUs[0].State = 2;
 132
 133         // -- Initialise Multiprocessing
 134         // Find MP Floating Table
 135         // - EBDA/Last 1Kib (640KiB)
 136         for(pos = KERNEL_BASE|0x9F000; pos < (KERNEL_BASE|0xA0000); pos += 16) {
 137                 if( *(Uint*)(pos) == MPPTR_IDENT ) {
 138                         Log("Possible %p", pos);
 139                         if( ByteSum((void*)pos, sizeof(tMPInfo)) != 0 ) continue;
 140                         gMPFloatPtr = (void*)pos;
 141                         break;
 142                 }
 143         }
 144         // - Last KiB (512KiB base mem)
 145         if(!gMPFloatPtr) {
 146                 for(pos = KERNEL_BASE|0x7F000; pos < (KERNEL_BASE|0x80000); pos += 16) {
 147                         if( *(Uint*)(pos) == MPPTR_IDENT ) {
 148                                 Log("Possible %p", pos);
 149                                 if( ByteSum((void*)pos, sizeof(tMPInfo)) != 0 ) continue;
 150                                 gMPFloatPtr = (void*)pos;
 151                                 break;
 152                         }
 153                 }
 154         }
 155         // - BIOS ROM
 156         if(!gMPFloatPtr) {
 157                 for(pos = KERNEL_BASE|0xE0000; pos < (KERNEL_BASE|0x100000); pos += 16) {
 158                         if( *(Uint*)(pos) == MPPTR_IDENT ) {
 159                                 Log("Possible %p", pos);
 160                                 if( ByteSum((void*)pos, sizeof(tMPInfo)) != 0 ) continue;
 161                                 gMPFloatPtr = (void*)pos;
 162                                 break;
 163                         }
 164                 }
 165         }
 166
 167         // If the MP Table Exists, parse it
 168         if(gMPFloatPtr)
 169         {
 170                  int    i;
 171                 tMPTable_Ent    *ents;
 172                 #if DUMP_MP_TABLE
 173                 Log("gMPFloatPtr = %p", gMPFloatPtr);
 174                 Log("*gMPFloatPtr = {");
 175                 Log("\t.Sig = 0x%08x", gMPFloatPtr->Sig);
 176                 Log("\t.MPConfig = 0x%08x", gMPFloatPtr->MPConfig);
 177                 Log("\t.Length = 0x%02x", gMPFloatPtr->Length);
 178                 Log("\t.Version = 0x%02x", gMPFloatPtr->Version);
 179                 Log("\t.Checksum = 0x%02x", gMPFloatPtr->Checksum);
 180                 Log("\t.Features = [0x%02x,0x%02x,0x%02x,0x%02x,0x%02x]",
 181                         gMPFloatPtr->Features[0],       gMPFloatPtr->Features[1],
 182                         gMPFloatPtr->Features[2],       gMPFloatPtr->Features[3],
 183                         gMPFloatPtr->Features[4]
 184                         );
 185                 Log("}");
 186                 #endif
 187
 188                 mptable = (void*)( KERNEL_BASE|gMPFloatPtr->MPConfig );
 189                 #if DUMP_MP_TABLE
 190                 Log("mptable = %p", mptable);
 191                 Log("*mptable = {");
 192                 Log("\t.Sig = 0x%08x", mptable->Sig);
 193                 Log("\t.BaseTableLength = 0x%04x", mptable->BaseTableLength);
 194                 Log("\t.SpecRev = 0x%02x", mptable->SpecRev);
 195                 Log("\t.Checksum = 0x%02x", mptable->Checksum);
 196                 Log("\t.OEMID = '%8c'", mptable->OemID);
 197                 Log("\t.ProductID = '%8c'", mptable->ProductID);
 198                 Log("\t.OEMTablePtr = %p'", mptable->OEMTablePtr);
 199                 Log("\t.OEMTableSize = 0x%04x", mptable->OEMTableSize);
 200                 Log("\t.EntryCount = 0x%04x", mptable->EntryCount);
 201                 Log("\t.LocalAPICMemMap = 0x%08x", mptable->LocalAPICMemMap);
 202                 Log("\t.ExtendedTableLen = 0x%04x", mptable->ExtendedTableLen);
 203                 Log("\t.ExtendedTableChecksum = 0x%02x", mptable->ExtendedTableChecksum);
 204                 Log("}");
 205                 #endif
 206
 207                 gpMP_LocalAPIC = (void*)MM_MapHWPages(mptable->LocalAPICMemMap, 1);
 208
 209                 ents = mptable->Entries;
 210                 giNumCPUs = 0;
 211
 212                 for( i = 0; i < mptable->EntryCount; i ++ )
 213                 {
 214                          int    entSize = 0;
 215                         switch( ents->Type )
 216                         {
 217                         case 0: // Processor
 218                                 entSize = 20;
 219                                 #if DUMP_MP_TABLE
 220                                 Log("%i: Processor", i);
 221                                 Log("\t.APICID = %i", ents->Proc.APICID);
 222                                 Log("\t.APICVer = 0x%02x", ents->Proc.APICVer);
 223                                 Log("\t.CPUFlags = 0x%02x", ents->Proc.CPUFlags);
 224                                 Log("\t.CPUSignature = 0x%08x", ents->Proc.CPUSignature);
 225                                 Log("\t.FeatureFlags = 0x%08x", ents->Proc.FeatureFlags);
 226                                 #endif
 227
 228                                 if( !(ents->Proc.CPUFlags & 1) ) {
 229                                         Log("DISABLED");
 230                                         break;
 231                                 }
 232
 233                                 // Check if there is too many processors
 234                                 if(giNumCPUs >= MAX_CPUS) {
 235                                         giNumCPUs ++;   // If `giNumCPUs` > MAX_CPUS later, it will be clipped
 236                                         break;
 237                                 }
 238
 239                                 // Initialise CPU Info
 240                                 gaAPIC_to_CPU[ents->Proc.APICID] = giNumCPUs;
 241                                 gaCPUs[giNumCPUs].APICID = ents->Proc.APICID;
 242                                 gaCPUs[giNumCPUs].State = 0;
 243                                 giNumCPUs ++;
 244
 245                                 // Set BSP Variable
 246                                 if( ents->Proc.CPUFlags & 2 ) {
 247                                         giProc_BootProcessorID = giNumCPUs-1;
 248                                 }
 249
 250                                 break;
 251
 252                         #if DUMP_MP_TABLE >= 2
 253                         case 1: // Bus
 254                                 entSize = 8;
 255                                 Log("%i: Bus", i);
 256                                 Log("\t.ID = %i", ents->Bus.ID);
 257                                 Log("\t.TypeString = '%6C'", ents->Bus.TypeString);
 258                                 break;
 259                         case 2: // I/O APIC
 260                                 entSize = 8;
 261                                 Log("%i: I/O APIC", i);
 262                                 Log("\t.ID = %i", ents->IOAPIC.ID);
 263                                 Log("\t.Version = 0x%02x", ents->IOAPIC.Version);
 264                                 Log("\t.Flags = 0x%02x", ents->IOAPIC.Flags);
 265                                 Log("\t.Addr = 0x%08x", ents->IOAPIC.Addr);
 266                                 break;
 267                         case 3: // I/O Interrupt Assignment
 268                                 entSize = 8;
 269                                 Log("%i: I/O Interrupt Assignment", i);
 270                                 Log("\t.IntType = %i", ents->IOInt.IntType);
 271                                 Log("\t.Flags = 0x%04x", ents->IOInt.Flags);
 272                                 Log("\t.SourceBusID = 0x%02x", ents->IOInt.SourceBusID);
 273                                 Log("\t.SourceBusIRQ = 0x%02x", ents->IOInt.SourceBusIRQ);
 274                                 Log("\t.DestAPICID = 0x%02x", ents->IOInt.DestAPICID);
 275                                 Log("\t.DestAPICIRQ = 0x%02x", ents->IOInt.DestAPICIRQ);
 276                                 break;
 277                         case 4: // Local Interrupt Assignment
 278                                 entSize = 8;
 279                                 Log("%i: Local Interrupt Assignment", i);
 280                                 Log("\t.IntType = %i", ents->LocalInt.IntType);
 281                                 Log("\t.Flags = 0x%04x", ents->LocalInt.Flags);
 282                                 Log("\t.SourceBusID = 0x%02x", ents->LocalInt.SourceBusID);
 283                                 Log("\t.SourceBusIRQ = 0x%02x", ents->LocalInt.SourceBusIRQ);
 284                                 Log("\t.DestLocalAPICID = 0x%02x", ents->LocalInt.DestLocalAPICID);
 285                                 Log("\t.DestLocalAPICIRQ = 0x%02x", ents->LocalInt.DestLocalAPICIRQ);
 286                                 break;
 287                         default:
 288                                 Log("%i: Unknown (%i)", i, ents->Type);
 289                                 break;
 290                         #endif
 291                         }
 292                         ents = (void*)( (Uint)ents + entSize );
 293                 }
 294
 295                 if( giNumCPUs > MAX_CPUS ) {
 296                         Warning("Too many CPUs detected (%i), only using %i of them", giNumCPUs, MAX_CPUS);
 297                         giNumCPUs = MAX_CPUS;
 298                 }
 299                 gTSSs = gaTSSs;
 300         }
 301         else {
 302                 Log("No MP Table was found, assuming uniprocessor\n");
 303                 giNumCPUs = 1;
 304                 gTSSs = &gTSS0;
 305         }
 306         #else
 307         giNumCPUs = 1;
 308         gTSSs = &gTSS0;
 309         #endif
 310
 311         #if !DEBUG_DISABLE_DOUBLEFAULT
 312         // Initialise Double Fault TSS
 313         gGDT[5].BaseLow = (Uint)&gDoubleFault_TSS & 0xFFFF;
 314         gGDT[5].BaseMid = (Uint)&gDoubleFault_TSS >> 16;
 315         gGDT[5].BaseHi = (Uint)&gDoubleFault_TSS >> 24;
 316
 317         // Set double fault IDT to use the new TSS
 318         gIDT[8].OffsetLo = 0;
 319         gIDT[8].CS = 5<<3;
 320         gIDT[8].Flags = 0x8500;
 321         gIDT[8].OffsetHi = 0;
 322         #endif
 323
 324         // Set timer frequency
 325         outb(0x43, 0x34);       // Set Channel 0, Low/High, Rate Generator
 326         outb(0x40, TIMER_DIVISOR&0xFF); // Low Byte of Divisor
 327         outb(0x40, (TIMER_DIVISOR>>8)&0xFF);    // High Byte
 328
 329         Log_Debug("Proc", "PIT Frequency %i.%03i Hz",
 330                 TIMER_BASE/TIMER_DIVISOR,
 331                 ((Uint64)TIMER_BASE*1000/TIMER_DIVISOR)%1000
 332                 );
 333
 334         #if USE_MP
 335         // Get the count setting for APIC timer
 336         Log("Determining APIC Count");
 337         __asm__ __volatile__ ("sti");
 338         while( giMP_TimerCount == 0 )   __asm__ __volatile__ ("hlt");
 339         __asm__ __volatile__ ("cli");
 340         Log("APIC Count %i", giMP_TimerCount);
 341         {
 342                 Uint64  freq = giMP_TimerCount;
 343                 freq *= TIMER_BASE;
 344                 freq /= TIMER_DIVISOR;
 345                 if( (freq /= 1000) < 2*1000)
 346                         Log("Bus Frequency %i KHz", freq);
 347                 else if( (freq /= 1000) < 2*1000)
 348                         Log("Bus Frequency %i MHz", freq);
 349                 else if( (freq /= 1000) < 2*1000)
 350                         Log("Bus Frequency %i GHz", freq);
 351                 else
 352                         Log("Bus Frequency %i THz", freq);
 353         }
 354
 355         // Initialise Normal TSS(s)
 356         for(pos=0;pos<giNumCPUs;pos++)
 357         {
 358         #else
 359         pos = 0;
 360         #endif
 361                 gTSSs[pos].SS0 = 0x10;
 362                 gTSSs[pos].ESP0 = 0;    // Set properly by scheduler
 363                 gGDT[6+pos].BaseLow = ((Uint)(&gTSSs[pos])) & 0xFFFF;
 364                 gGDT[6+pos].BaseMid = ((Uint)(&gTSSs[pos]) >> 16) & 0xFFFF;
 365                 gGDT[6+pos].BaseHi = ((Uint)(&gTSSs[pos])) >> 24;
 366         #if USE_MP
 367         }
 368         #endif
 369
 370         // Load the BSP's TSS
 371         __asm__ __volatile__ ("ltr %%ax"::"a"(0x30));
 372         // Set Current Thread and CPU Number in DR0 and DR1
 373         __asm__ __volatile__ ("mov %0, %%db0"::"r"(&gThreadZero));
 374         __asm__ __volatile__ ("mov %0, %%db1"::"r"(0));
 375
 376         gaCPUs[0].Current = &gThreadZero;
 377         gThreadZero.CurCPU = 0;
 378
 379         gProcessZero.MemState.CR3 = (Uint)gaInitPageDir - KERNEL_BASE;
 380
 381         // Create Per-Process Data Block
 382         if( !MM_Allocate(MM_PPD_CFG) )
 383         {
 384                 Panic("OOM - No space for initial Per-Process Config");
 385         }
 386
 387         // Initialise SSE support
 388         Proc_InitialiseSSE();
 389
 390         // Change Stacks
 391         Proc_ChangeStack();
 392 }
 393
 394 #if USE_MP
 395 /**
 396  * \brief Start an AP
 397  */
 398 void MP_StartAP(int CPU)
 399 {
 400         Log_Log("Proc", "Starting AP %i (APIC %i)", CPU, gaCPUs[CPU].APICID);
 401
 402         // Set location of AP startup code and mark for a warm restart
 403         *(Uint16*)(KERNEL_BASE|0x467) = (Uint)&APWait - (KERNEL_BASE|0xFFFF0);
 404         *(Uint16*)(KERNEL_BASE|0x469) = 0xFFFF;
 405         outb(0x70, 0x0F);       outb(0x71, 0x0A);       // Set warm reset flag
 406         MP_SendIPI(gaCPUs[CPU].APICID, 0, 5);   // Init IPI
 407
 408         // Take a quick nap (20ms)
 409         Time_Delay(20);
 410
 411         // TODO: Use a better address, preferably registered with the MM
 412         // - MM_AllocDMA mabye?
 413         // Create a far jump
 414         *(Uint8*)(KERNEL_BASE|0x11000) = 0xEA;  // Far JMP
 415         *(Uint16*)(KERNEL_BASE|0x11001) = (Uint16)&APStartup + 0x10;    // IP
 416         *(Uint16*)(KERNEL_BASE|0x11003) = 0xFFFF;       // CS
 417
 418         giNumInitingCPUs ++;
 419
 420         // Send a Startup-IPI to make the CPU execute at 0x11000 (which we
 421         // just filled)
 422         MP_SendIPI(gaCPUs[CPU].APICID, 0x11, 6);        // StartupIPI
 423
 424         tTime   timeout = now() + 2;
 425         while( giNumInitingCPUs && now() > timeout )
 426                 HALT();
 427
 428         if( giNumInitingCPUs == 0 )
 429                 return ;
 430
 431         // First S-IPI failed, send again
 432         MP_SendIPI(gaCPUs[CPU].APICID, 0x11, 6);
 433         timeout = now() + 2;
 434         while( giNumInitingCPUs && now() > timeout )
 435                 HALT();
 436         if( giNumInitingCPUs == 0 )
 437                 return ;
 438
 439         Log_Notice("Proc", "CPU %i (APIC %x) didn't come up", CPU, gaCPUs[CPU].APICID);
 440
 441         // Oh dammit.
 442         giNumInitingCPUs = 0;
 443 }
 444
 445 void MP_SendIPIVector(int CPU, Uint8 Vector)
 446 {
 447         MP_SendIPI(gaCPUs[CPU].APICID, Vector, 0);
 448 }
 449
 450 /**
 451  * \brief Send an Inter-Processor Interrupt
 452  * \param APICID        Processor's Local APIC ID
 453  * \param Vector        Argument of some kind
 454  * \param DeliveryMode  Type of signal
 455  * \note 3A 10.5 "APIC/Handling Local Interrupts"
 456  */
 457 void MP_SendIPI(Uint8 APICID, int Vector, int DeliveryMode)
 458 {
 459         Uint32  val;
 460
 461         // Hi
 462         val = (Uint)APICID << 24;
 463         gpMP_LocalAPIC->ICR[1].Val = val;
 464         // Low (and send)
 465         val = ((DeliveryMode & 7) << 8) | (Vector & 0xFF);
 466         gpMP_LocalAPIC->ICR[0].Val = val;
 467 }
 468 #endif
 469
 470 void Proc_IdleThread(void *Ptr)
 471 {
 472         tCPU    *cpu = &gaCPUs[GetCPUNum()];
 473         cpu->Current->ThreadName = strdup("Idle Thread");
 474         Threads_SetPriority( cpu->Current, -1 );        // Never called randomly
 475         cpu->Current->Quantum = 1;      // 1 slice quantum
 476         for(;;) {
 477                 __asm__ __volatile__ ("sti");   // Make sure interrupts are enabled
 478                 __asm__ __volatile__ ("hlt");   // Make sure interrupts are enabled
 479                 Proc_Reschedule();
 480         }
 481 }
 482
 483 /**
 484  * \fn void Proc_Start(void)
 485  * \brief Start process scheduler
 486  */
 487 void Proc_Start(void)
 488 {
 489         #if USE_MP
 490         // BSP still should run the current task
 491         gaCPUs[giProc_BootProcessorID].Current = &gThreadZero;
 492
 493         __asm__ __volatile__ ("sti");
 494
 495         // Start APs
 496         for( int i = 0; i < giNumCPUs; i ++ )
 497         {
 498                 if(i != giProc_BootProcessorID)
 499                         gaCPUs[i].Current = NULL;
 500
 501                 // Create Idle Task
 502                 Proc_NewKThread(Proc_IdleThread, &gaCPUs[i]);
 503
 504                 // Start the AP
 505                 if( i != giProc_BootProcessorID ) {
 506                         MP_StartAP( i );
 507                 }
 508         }
 509         #else
 510         // Create Idle Task
 511         Proc_NewKThread(Proc_IdleThread, &gaCPUs[0]);
 512
 513         // Set current task
 514         gaCPUs[0].Current = &gThreadZero;
 515
 516         // Start Interrupts (and hence scheduler)
 517         __asm__ __volatile__("sti");
 518         #endif
 519         MM_FinishVirtualInit();
 520 }
 521
 522 /**
 523  * \fn tThread *Proc_GetCurThread(void)
 524  * \brief Gets the current thread
 525  */
 526 tThread *Proc_GetCurThread(void)
 527 {
 528         #if USE_MP
 529         return gaCPUs[ GetCPUNum() ].Current;
 530         #else
 531         return gaCPUs[ 0 ].Current;
 532         #endif
 533 }
 534
 535 /**
 536  * \fn void Proc_ChangeStack(void)
 537  * \brief Swaps the current stack for a new one (in the proper stack reigon)
 538  */
 539 void Proc_ChangeStack(void)
 540 {
 541         Uint    esp, ebp;
 542         Uint    tmpEbp, oldEsp;
 543         Uint    curBase, newBase;
 544
 545         __asm__ __volatile__ ("mov %%esp, %0":"=r"(esp));
 546         __asm__ __volatile__ ("mov %%ebp, %0":"=r"(ebp));
 547
 548         oldEsp = esp;
 549
 550         // Create new KStack
 551         newBase = MM_NewKStack();
 552         // Check for errors
 553         if(newBase == 0) {
 554                 Panic("What the?? Unable to allocate space for initial kernel stack");
 555                 return;
 556         }
 557
 558         curBase = (Uint)&Kernel_Stack_Top;
 559
 560         LOG("curBase = 0x%x, newBase = 0x%x", curBase, newBase);
 561
 562         // Get ESP as a used size
 563         esp = curBase - esp;
 564         LOG("memcpy( %p, %p, 0x%x )", (void*)(newBase - esp), (void*)(curBase - esp), esp );
 565         // Copy used stack
 566         memcpy( (void*)(newBase - esp), (void*)(curBase - esp), esp );
 567         // Get ESP as an offset in the new stack
 568         esp = newBase - esp;
 569         // Adjust EBP
 570         ebp = newBase - (curBase - ebp);
 571
 572         // Repair EBPs & Stack Addresses
 573         // Catches arguments also, but may trash stack-address-like values
 574         for(tmpEbp = esp; tmpEbp < newBase; tmpEbp += 4)
 575         {
 576                 if(oldEsp < *(Uint*)tmpEbp && *(Uint*)tmpEbp < curBase)
 577                         *(Uint*)tmpEbp += newBase - curBase;
 578         }
 579
 580         Proc_GetCurThread()->KernelStack = newBase;
 581
 582         __asm__ __volatile__ ("mov %0, %%esp"::"r"(esp));
 583         __asm__ __volatile__ ("mov %0, %%ebp"::"r"(ebp));
 584 }
 585
 586 void Proc_ClearProcess(tProcess *Process)
 587 {
 588         MM_ClearSpace(Process->MemState.CR3);
 589 }
 590
 591 void Proc_ClearThread(tThread *Thread)
 592 {
 593         if(Thread->SavedState.SSE) {
 594                 free(Thread->SavedState.SSE);
 595                 Thread->SavedState.SSE = NULL;
 596         }
 597 }
 598
 599 tTID Proc_NewKThread(void (*Fcn)(void*), void *Data)
 600 {
 601         Uint    esp;
 602         tThread *newThread;
 603
 604         newThread = Threads_CloneTCB(0);
 605         if(!newThread)  return -1;
 606
 607         // Create new KStack
 608         newThread->KernelStack = MM_NewKStack();
 609         // Check for errors
 610         if(newThread->KernelStack == 0) {
 611                 free(newThread);
 612                 return -1;
 613         }
 614
 615         esp = newThread->KernelStack;
 616         *(Uint*)(esp-=4) = (Uint)Data;  // Data (shadowed)
 617         *(Uint*)(esp-=4) = 1;   // Number of params
 618         *(Uint*)(esp-=4) = (Uint)Fcn;   // Function to call
 619         *(Uint*)(esp-=4) = (Uint)newThread;     // Thread ID
 620
 621         newThread->SavedState.ESP = esp;
 622         newThread->SavedState.EIP = (Uint)&NewTaskHeader;
 623         newThread->SavedState.SSE = NULL;
 624 //      Log("New (KThread) %p, esp = %p", newThread->SavedState.EIP, newThread->SavedState.ESP);
 625
 626 //      MAGIC_BREAK();
 627         Threads_AddActive(newThread);
 628
 629         return newThread->TID;
 630 }
 631
 632 /**
 633  * \fn int Proc_Clone(Uint *Err, Uint Flags)
 634  * \brief Clone the current process
 635  */
 636 tPID Proc_Clone(Uint Flags)
 637 {
 638         tThread *newThread;
 639         tThread *cur = Proc_GetCurThread();
 640         Uint    eip;
 641
 642         // Sanity, please
 643         if( !(Flags & CLONE_VM) ) {
 644                 Log_Error("Proc", "Proc_Clone: Don't leave CLONE_VM unset, use Proc_NewKThread instead");
 645                 return -1;
 646         }
 647
 648         // New thread
 649         newThread = Threads_CloneTCB(Flags);
 650         if(!newThread)  return -1;
 651
 652         newThread->KernelStack = cur->KernelStack;
 653
 654         // Clone state
 655         eip = Proc_CloneInt(&newThread->SavedState.ESP, &newThread->Process->MemState.CR3, Flags & CLONE_NOUSER);
 656         if( eip == 0 ) {
 657                 return 0;
 658         }
 659         newThread->SavedState.EIP = eip;
 660         newThread->SavedState.SSE = NULL;
 661         newThread->SavedState.bSSEModified = 0;
 662
 663         // Check for errors
 664         if( newThread->Process->MemState.CR3 == 0 ) {
 665                 Log_Error("Proc", "Proc_Clone: MM_Clone failed");
 666                 Threads_Delete(newThread);
 667                 return -1;
 668         }
 669
 670         // Add the new thread to the run queue
 671         Threads_AddActive(newThread);
 672         return newThread->TID;
 673 }
 674
 675 /**
 676  * \fn int Proc_SpawnWorker(void)
 677  * \brief Spawns a new worker thread
 678  */
 679 tThread *Proc_SpawnWorker(void (*Fcn)(void*), void *Data)
 680 {
 681         tThread *new;
 682         Uint    stack_contents[4];
 683
 684         // Create new thread
 685         new = Threads_CloneThreadZero();
 686         if(!new) {
 687                 Warning("Proc_SpawnWorker - Out of heap space!\n");
 688                 return NULL;
 689         }
 690
 691         // Create the stack contents
 692         stack_contents[3] = (Uint)Data;
 693         stack_contents[2] = 1;
 694         stack_contents[1] = (Uint)Fcn;
 695         stack_contents[0] = (Uint)new;
 696
 697         // Create a new worker stack (in PID0's address space)
 698         new->KernelStack = MM_NewWorkerStack(stack_contents, sizeof(stack_contents));
 699
 700         // Save core machine state
 701         new->SavedState.ESP = new->KernelStack - sizeof(stack_contents);
 702         new->SavedState.EIP = (Uint)NewTaskHeader;
 703         new->SavedState.SSE = NULL;
 704         new->SavedState.bSSEModified = 0;
 705
 706         // Mark as active
 707         new->Status = THREAD_STAT_PREINIT;
 708         Threads_AddActive( new );
 709
 710         return new;
 711 }
 712
 713 /**
 714  * \fn Uint Proc_MakeUserStack(void)
 715  * \brief Creates a new user stack
 716  */
 717 Uint Proc_MakeUserStack(void)
 718 {
 719          int    i;
 720         Uint    base = USER_STACK_TOP - USER_STACK_SZ;
 721
 722         // Check Prospective Space
 723         for( i = USER_STACK_SZ >> 12; i--; )
 724                 if( MM_GetPhysAddr( (void*)(base + (i<<12)) ) != 0 )
 725                         break;
 726
 727         if(i != -1)     return 0;
 728
 729         // Allocate Stack - Allocate incrementally to clean up MM_Dump output
 730         for( i = 0; i < USER_STACK_SZ/0x1000; i++ )
 731         {
 732                 if( !MM_Allocate( base + (i<<12) ) )
 733                 {
 734                         Warning("OOM: Proc_MakeUserStack");
 735                         return 0;
 736                 }
 737         }
 738
 739         return base + USER_STACK_SZ;
 740 }
 741
 742 void Proc_StartUser(Uint Entrypoint, Uint Base, int ArgC, const char **ArgV, int DataSize)
 743 {
 744         Uint    *stack;
 745          int    i;
 746         const char      **envp = NULL;
 747         Uint16  ss, cs;
 748
 749         // Copy data to the user stack and free original buffer
 750         stack = (void*)Proc_MakeUserStack();
 751         stack -= (DataSize+sizeof(*stack)-1)/sizeof(*stack);
 752         memcpy( stack, ArgV, DataSize );
 753         free(ArgV);
 754
 755         // Adjust Arguments and environment
 756         if( DataSize )
 757         {
 758                 Uint delta = (Uint)stack - (Uint)ArgV;
 759                 ArgV = (const char**)stack;
 760                 for( i = 0; ArgV[i]; i++ )      ArgV[i] += delta;
 761                 envp = &ArgV[i+1];
 762                 for( i = 0; envp[i]; i++ )      envp[i] += delta;
 763         }
 764
 765         // User Mode Segments
 766         ss = 0x23;      cs = 0x1B;
 767
 768         // Arguments
 769         *--stack = (Uint)envp;
 770         *--stack = (Uint)ArgV;
 771         *--stack = (Uint)ArgC;
 772         *--stack = Base;
 773
 774         Proc_StartProcess(ss, (Uint)stack, 0x202, cs, Entrypoint);
 775 }
 776
 777 void Proc_StartProcess(Uint16 SS, Uint Stack, Uint Flags, Uint16 CS, Uint IP)
 778 {
 779         Uint    *stack = (void*)Stack;
 780         *--stack = SS;          //Stack Segment
 781         *--stack = Stack;       //Stack Pointer
 782         *--stack = Flags;       //EFLAGS (Resvd (0x2) and IF (0x20))
 783         *--stack = CS;          //Code Segment
 784         *--stack = IP;  //EIP
 785         //PUSHAD
 786         *--stack = 0xAAAAAAAA;  // eax
 787         *--stack = 0xCCCCCCCC;  // ecx
 788         *--stack = 0xDDDDDDDD;  // edx
 789         *--stack = 0xBBBBBBBB;  // ebx
 790         *--stack = 0xD1D1D1D1;  // edi
 791         *--stack = 0x54545454;  // esp - NOT POPED
 792         *--stack = 0x51515151;  // esi
 793         *--stack = 0xB4B4B4B4;  // ebp
 794         //Individual PUSHs
 795         *--stack = SS;  // ds
 796         *--stack = SS;  // es
 797         *--stack = SS;  // fs
 798         *--stack = SS;  // gs
 799
 800         __asm__ __volatile__ (
 801         "mov %%eax,%%esp;\n\t"  // Set stack pointer
 802         "pop %%gs;\n\t"
 803         "pop %%fs;\n\t"
 804         "pop %%es;\n\t"
 805         "pop %%ds;\n\t"
 806         "popa;\n\t"
 807         "iret;\n\t" : : "a" (stack));
 808         for(;;);
 809 }
 810
 811 /**
 812  * \fn int Proc_Demote(Uint *Err, int Dest, tRegs *Regs)
 813  * \brief Demotes a process to a lower permission level
 814  * \param Err   Pointer to user's errno
 815  * \param Dest  New Permission Level
 816  * \param Regs  Pointer to user's register structure
 817  */
 818 int Proc_Demote(Uint *Err, int Dest, tRegs *Regs)
 819 {
 820          int    cpl = Regs->cs & 3;
 821         // Sanity Check
 822         if(Dest > 3 || Dest < 0) {
 823                 *Err = -EINVAL;
 824                 return -1;
 825         }
 826
 827         // Permission Check
 828         if(cpl > Dest) {
 829                 *Err = -EACCES;
 830                 return -1;
 831         }
 832
 833         // Change the Segment Registers
 834         Regs->cs = (((Dest+1)<<4) | Dest) - 8;
 835         Regs->ss = ((Dest+1)<<4) | Dest;
 836         // Check if the GP Segs are GDT, then change them
 837         if(!(Regs->ds & 4))     Regs->ds = ((Dest+1)<<4) | Dest;
 838         if(!(Regs->es & 4))     Regs->es = ((Dest+1)<<4) | Dest;
 839         if(!(Regs->fs & 4))     Regs->fs = ((Dest+1)<<4) | Dest;
 840         if(!(Regs->gs & 4))     Regs->gs = ((Dest+1)<<4) | Dest;
 841
 842         return 0;
 843 }
 844
 845 /**
 846  * \brief Calls a signal handler in user mode
 847  * \note Used for signals
 848  */
 849 void Proc_CallFaultHandler(tThread *Thread)
 850 {
 851         // Rewinds the stack and calls the user function
 852         // Never returns
 853         Proc_ReturnToUser( Thread->FaultHandler, Thread->CurFaultNum, Thread->KernelStack );
 854         for(;;);
 855 }
 856
 857 void Proc_DumpThreadCPUState(tThread *Thread)
 858 {
 859         if( Thread->CurCPU > -1 )
 860         {
 861                  int    maxBacktraceDistance = 6;
 862                 tRegs   *regs = NULL;
 863                 Uint32  *stack;
 864
 865                 if( Thread->CurCPU != GetCPUNum() ) {
 866                         Log("  Currently running");
 867                         return ;
 868                 }
 869
 870                 // Backtrace to find the IRQ entrypoint
 871                 // - This will usually only be called by an IRQ, so this should
 872                 //   work
 873                 __asm__ __volatile__ ("mov %%ebp, %0" : "=r" (stack));
 874                 while( maxBacktraceDistance -- )
 875                 {
 876                         if( !CheckMem(stack, 8) ) {
 877                                 regs = NULL;
 878                                 break;
 879                         }
 880                         // [ebp] = oldEbp
 881                         // [ebp+4] = retaddr
 882
 883                         if( stack[1] == (tVAddr)&IRQCommon_handled ) {
 884                                 regs = (void*)stack[2];
 885                                 break;
 886                         }
 887
 888                         stack = (void*)stack[0];
 889                 }
 890
 891                 if( !regs ) {
 892                         Log("  Unable to find IRQ Entry");
 893                         return ;
 894                 }
 895
 896                 Log("  at %04x:%08x", regs->cs, regs->eip);
 897                 return ;
 898         }
 899
 900         tVAddr  diffFromScheduler = Thread->SavedState.EIP - (tVAddr)SwitchTasks;
 901         tVAddr  diffFromClone = Thread->SavedState.EIP - (tVAddr)Proc_CloneInt;
 902         tVAddr  diffFromSpawn = Thread->SavedState.EIP - (tVAddr)NewTaskHeader;
 903
 904         if( diffFromClone > 0 && diffFromClone < 40 )   // When I last checked, .newTask was at .+27
 905         {
 906                 Log("  Creating process");
 907                 return ;
 908         }
 909
 910         if( diffFromSpawn == 0 )
 911         {
 912                 Log("  Creating thread");
 913                 return ;
 914         }
 915
 916         if( diffFromScheduler > 0 && diffFromScheduler < 128 )  // When I last checked, GetEIP was at .+0x30
 917         {
 918                 // Scheduled out
 919                 Log("  At %04x:%08x", Thread->SavedState.UserCS, Thread->SavedState.UserEIP);
 920                 return ;
 921         }
 922
 923         Log("  Just created (unknown %p)", Thread->SavedState.EIP);
 924 }
 925
 926 void Proc_Reschedule(void)
 927 {
 928         tThread *nextthread, *curthread;
 929          int    cpu = GetCPUNum();
 930
 931         // TODO: Wait for the lock?
 932         if(IS_LOCKED(&glThreadListLock))        return;
 933
 934         curthread = Proc_GetCurThread();
 935
 936         nextthread = Threads_GetNextToRun(cpu, curthread);
 937
 938         if(!nextthread || nextthread == curthread)
 939                 return ;
 940
 941         #if DEBUG_TRACE_SWITCH
 942         // HACK: Ignores switches to the idle threads
 943         if( nextthread->TID == 0 || nextthread->TID > giNumCPUs )
 944         {
 945                 LogF("\nSwitching CPU %i to %p (%i %s) - CR3 = 0x%x, EIP = %p, ESP = %p\n",
 946                         GetCPUNum(),
 947                         nextthread, nextthread->TID, nextthread->ThreadName,
 948                         nextthread->Process->MemState.CR3,
 949                         nextthread->SavedState.EIP,
 950                         nextthread->SavedState.ESP
 951                         );
 952                 LogF("OldCR3 = %P\n", curthread->Process->MemState.CR3);
 953         }
 954         #endif
 955
 956         // Update CPU state
 957         gaCPUs[cpu].Current = nextthread;
 958         gaCPUs[cpu].LastTimerThread = NULL;
 959         gTSSs[cpu].ESP0 = nextthread->KernelStack-4;
 960         __asm__ __volatile__("mov %0, %%db0\n\t" : : "r"(nextthread) );
 961
 962         // Save FPU/MMX/XMM/SSE state
 963         if( curthread && curthread->SavedState.SSE )
 964         {
 965                 Proc_SaveSSE( ((Uint)curthread->SavedState.SSE + 0xF) & ~0xF );
 966                 curthread->SavedState.bSSEModified = 0;
 967                 Proc_DisableSSE();
 968         }
 969
 970         if( curthread )
 971         {
 972                 SwitchTasks(
 973                         nextthread->SavedState.ESP, &curthread->SavedState.ESP,
 974                         nextthread->SavedState.EIP, &curthread->SavedState.EIP,
 975                         nextthread->Process->MemState.CR3
 976                         );
 977         }
 978         else
 979         {
 980                 SwitchTasks(
 981                         nextthread->SavedState.ESP, 0,
 982                         nextthread->SavedState.EIP, 0,
 983                         nextthread->Process->MemState.CR3
 984                         );
 985         }
 986
 987         return ;
 988 }
 989
 990 /**
 991  * \fn void Proc_Scheduler(int CPU)
 992  * \brief Swap current thread and clears dead threads
 993  */
 994 void Proc_Scheduler(int CPU)
 995 {
 996         #if USE_MP
 997         if( GetCPUNum() )
 998                 gpMP_LocalAPIC->EOI.Val = 0;
 999         else
1000         #endif
1001                 outb(0x20, 0x20);
1002         __asm__ __volatile__ ("sti");
1003
1004         // Call the timer update code
1005         Timer_CallTimers();
1006
1007         #if !DEBUG_NOPREEMPT
1008         // If two ticks happen within the same task, and it's not an idle task, swap
1009         if( gaCPUs[CPU].Current->TID > giNumCPUs && gaCPUs[CPU].Current == gaCPUs[CPU].LastTimerThread )
1010         {
1011                 Proc_Reschedule();
1012         }
1013
1014         gaCPUs[CPU].LastTimerThread = gaCPUs[CPU].Current;
1015         #endif
1016 }
1017
1018 // === EXPORTS ===
1019 EXPORT(Proc_SpawnWorker);