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