X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Kernel%2Farch%2Fx86_64%2Fproc.c;h=31dd80e373e4b321ff44ccf2a6823455be2ec393;hb=5255c9f07cb2e0e43cf283e256c964eaa7970c8e;hp=4d50210069a01f6392492541f51d208121e42ff2;hpb=dea6bcf35a3f52396724d74e47f71cb3afade37c;p=tpg%2Facess2.git diff --git a/Kernel/arch/x86_64/proc.c b/Kernel/arch/x86_64/proc.c index 4d502100..31dd80e3 100644 --- a/Kernel/arch/x86_64/proc.c +++ b/Kernel/arch/x86_64/proc.c @@ -5,54 +5,66 @@ #include #include #include +#include #include #include #include #if USE_MP # include #endif +#include +#include // === FLAGS === #define DEBUG_TRACE_SWITCH 0 +//#define BREAK_ON_SWITCH 1 // Break into bochs debugger on a task switch // === CONSTANTS === #define SWITCH_MAGIC 0x55ECAFFF##FFFACE55 // There is no code in this area -// Base is 1193182 -#define TIMER_DIVISOR 11931 //~100Hz + +// === TYPES === +typedef struct sCPU +{ + Uint8 APICID; + Uint8 State; // 0: Unavaliable, 1: Idle, 2: Active + Uint16 Resvd; + tThread *Current; + tThread *IdleThread; +} tCPU; // === IMPORTS === extern tGDT gGDT[]; -extern void APStartup(void); // 16-bit AP startup code +extern void APStartup(void); // 16-bit AP startup code extern Uint GetRIP(void); // start.asm extern Uint64 gInitialPML4[512]; // start.asm -extern void gInitialKernelStack; -extern tSpinlock glThreadListLock; +extern char gInitialKernelStack[]; +extern tShortSpinlock glThreadListLock; extern int giNumCPUs; extern int giNextTID; extern int giTotalTickets; extern int giNumActiveThreads; extern tThread gThreadZero; -extern tThread *gActiveThreads; -extern tThread *gSleepingThreads; -extern tThread *gDeleteThreads; -extern tThread *Threads_GetNextToRun(int CPU); extern void Threads_Dump(void); -extern tThread *Threads_CloneTCB(Uint *Err, Uint Flags); extern void Proc_ReturnToUser(void); -extern void GetCPUNum(void); +extern void Time_UpdateTimestamp(void); // === PROTOTYPES === -void ArchThreads_Init(void); +//void ArchThreads_Init(void); #if USE_MP void MP_StartAP(int CPU); void MP_SendIPI(Uint8 APICID, int Vector, int DeliveryMode); #endif -void Proc_Start(void); -tThread *Proc_GetCurThread(void); +//void Proc_Start(void); +//tThread *Proc_GetCurThread(void); void Proc_ChangeStack(void); - int Proc_Clone(Uint *Err, Uint Flags); +// int Proc_Clone(Uint *Err, Uint Flags); +// int Proc_SpawnWorker(void); +Uint Proc_MakeUserStack(void); +//void Proc_StartUser(Uint Entrypoint, Uint *Bases, int ArgC, char **ArgV, char **EnvP, int DataSize); void Proc_StartProcess(Uint16 SS, Uint Stack, Uint Flags, Uint16 CS, Uint IP); -void Proc_CallFaultHandler(tThread *Thread); + int Proc_Demote(Uint *Err, int Dest, tRegs *Regs); +//void Proc_CallFaultHandler(tThread *Thread); +//void Proc_DumpThreadCPUState(tThread *Thread); void Proc_Scheduler(int CPU); // === GLOBALS === @@ -62,10 +74,8 @@ volatile int giNumInitingCPUs = 0; tMPInfo *gMPFloatPtr = NULL; tAPIC *gpMP_LocalAPIC = NULL; Uint8 gaAPIC_to_CPU[256] = {0}; -tCPU gaCPUs[MAX_CPUS]; -#else -tThread *gCurrentThread = NULL; #endif +tCPU gaCPUs[MAX_CPUS]; tTSS *gTSSs = NULL; tTSS gTSS0 = {0}; // --- Error Recovery --- @@ -278,30 +288,36 @@ void ArchThreads_Init(void) #if USE_MP } for(pos=0;pos>8)&0xFF); // High Byte + outb(0x40, PIT_TIMER_DIVISOR&0xFF); // Low Byte of Divisor + outb(0x40, (PIT_TIMER_DIVISOR>>8)&0xFF); // High Byte // Create Per-Process Data Block - MM_Allocate(MM_PPD_CFG); + if( !MM_Allocate(MM_PPD_CFG) ) + { + Warning("Oh, hell, Unable to allocate PPD for Thread#0"); + } // Change Stacks Proc_ChangeStack(); + + Log("Multithreading initialised"); } #if USE_MP @@ -338,8 +354,61 @@ void MP_SendIPI(Uint8 APICID, int Vector, int DeliveryMode) */ void Proc_Start(void) { + #if USE_MP + int i; + #endif + + #if USE_MP + // Start APs + for( i = 0; i < giNumCPUs; i ++ ) + { + int tid; + if(i) gaCPUs[i].Current = NULL; + + // Create Idle Task + if( (tid = Proc_Clone(0, 0)) == 0) + { + for(;;) HALT(); // Just yeilds + } + gaCPUs[i].IdleThread = Threads_GetThread(tid); + gaCPUs[i].IdleThread->ThreadName = "Idle Thread"; + Threads_SetTickets( gaCPUs[i].IdleThread, 0 ); // Never called randomly + gaCPUs[i].IdleThread->Quantum = 1; // 1 slice quantum + + + // Start the AP + if( i != giProc_BootProcessorID ) { + MP_StartAP( i ); + } + } + + // BSP still should run the current task + gaCPUs[0].Current = &gThreadZero; + + // Start interrupts and wait for APs to come up + Log("Waiting for APs to come up\n"); + __asm__ __volatile__ ("sti"); + while( giNumInitingCPUs ) __asm__ __volatile__ ("hlt"); + #else + // Create Idle Task + if(Proc_Clone(0) == 0) + { + gaCPUs[0].IdleThread = Proc_GetCurThread(); + gaCPUs[0].IdleThread->ThreadName = (char*)"Idle Thread"; + Threads_SetPriority( gaCPUs[0].IdleThread, -1 ); // Never called randomly + gaCPUs[0].IdleThread->Quantum = 1; // 1 slice quantum + for(;;) HALT(); // Just yeilds + } + + // Set current task + gaCPUs[0].Current = &gThreadZero; + gaCPUs[0].Current->CurCPU = 0; + // Start Interrupts (and hence scheduler) __asm__ __volatile__("sti"); + #endif + MM_FinishVirtualInit(); + Log("Multithreading started"); } /** @@ -349,10 +418,9 @@ void Proc_Start(void) tThread *Proc_GetCurThread(void) { #if USE_MP - //return gaCPUs[ gaAPIC_to_CPU[gpMP_LocalAPIC->ID.Val&0xFF] ].Current; return gaCPUs[ GetCPUNum() ].Current; #else - return gCurrentThread; + return gaCPUs[ 0 ].Current; #endif } @@ -409,10 +477,10 @@ void Proc_ChangeStack(void) } /** - * \fn int Proc_Clone(Uint *Err, Uint Flags) + * \fn int Proc_Clone(Uint Flags) * \brief Clone the current process */ -int Proc_Clone(Uint *Err, Uint Flags) +int Proc_Clone(Uint Flags) { tThread *newThread; tThread *cur = Proc_GetCurThread(); @@ -421,7 +489,7 @@ int Proc_Clone(Uint *Err, Uint Flags) __asm__ __volatile__ ("mov %%rsp, %0": "=r"(rsp)); __asm__ __volatile__ ("mov %%rbp, %0": "=r"(rbp)); - newThread = Threads_CloneTCB(Err, Flags); + newThread = Threads_CloneTCB(NULL, Flags); if(!newThread) return -1; Log("Proc_Clone: newThread = %p", newThread); @@ -431,6 +499,7 @@ int Proc_Clone(Uint *Err, Uint Flags) Log("Proc_Clone: Cloning VM"); newThread->MemState.CR3 = MM_Clone(); newThread->KernelStack = cur->KernelStack; +// MAGIC_BREAK(); } else { Uint tmp_rbp, old_rsp = rsp; @@ -474,6 +543,8 @@ int Proc_Clone(Uint *Err, Uint Flags) rip = GetRIP(); if(rip == SWITCH_MAGIC) { outb(0x20, 0x20); // ACK Timer and return as child + __asm__ __volatile__ ("sti"); +// MAGIC_BREAK(); return 0; } @@ -522,13 +593,14 @@ int Proc_SpawnWorker(void) rip = GetRIP(); if(rip == SWITCH_MAGIC) { outb(0x20, 0x20); // ACK Timer and return as child + __asm__ __volatile__ ("sti"); return 0; } // Set EIP as parent new->SavedState.RIP = rip; // Mark as active - new->Status = THREAD_STAT_ACTIVE; + new->Status = THREAD_STAT_PREINIT; Threads_AddActive( new ); return new->TID; @@ -551,8 +623,17 @@ Uint Proc_MakeUserStack(void) if(i != -1) return 0; // Allocate Stack - Allocate incrementally to clean up MM_Dump output - for( i = 0; i < USER_STACK_SZ/4069; i++ ) - MM_Allocate( base + (i<<12) ); + for( i = 0; i < USER_STACK_SZ/0x1000; i++ ) + { + if( !MM_Allocate( base + (i<<12) ) ) + { + // Error + Log_Error("Proc", "Unable to allocate user stack (%i pages requested)", USER_STACK_SZ/0x1000); + while( i -- ) + MM_Deallocate( base + (i<<12) ); + return 0; + } + } return base + USER_STACK_SZ; } @@ -664,6 +745,11 @@ void Proc_CallFaultHandler(tThread *Thread) for(;;); } +void Proc_DumpThreadCPUState(tThread *Thread) +{ + Log(" At %04x:%016llx", Thread->SavedState.UserCS, Thread->SavedState.UserRIP); +} + /** * \fn void Proc_Scheduler(int CPU) * \brief Swap current thread and clears dead threads @@ -672,99 +758,92 @@ void Proc_Scheduler(int CPU) { Uint rsp, rbp, rip; tThread *thread; + + if( CPU == 0 ) + Time_UpdateTimestamp(); // If the spinlock is set, let it complete if(IS_LOCKED(&glThreadListLock)) return; - // Clear Delete Queue - while(gDeleteThreads) - { - thread = gDeleteThreads->Next; - if(gDeleteThreads->IsLocked) { // Only free if structure is unused - gDeleteThreads->Status = THREAD_STAT_NULL; - free( gDeleteThreads ); - } - gDeleteThreads = thread; - } - - // Check if there is any tasks running - if(giNumActiveThreads == 0) { - Log("No Active threads, sleeping"); - __asm__ __volatile__ ("hlt"); - return; - } - // Get current thread - #if USE_MP thread = gaCPUs[CPU].Current; - #else - thread = gCurrentThread; + + if( thread ) + { + tRegs *regs; + // Reduce remaining quantum and continue timeslice if non-zero + if(thread->Remaining--) return; + // Reset quantum for next call + thread->Remaining = thread->Quantum; + + // Get machine state + __asm__ __volatile__ ("mov %%rsp, %0":"=r"(rsp)); + __asm__ __volatile__ ("mov %%rbp, %0":"=r"(rbp)); + rip = GetRIP(); + if(rip == SWITCH_MAGIC) return; // Check if a switch happened + + // Save machine state + thread->SavedState.RSP = rsp; + thread->SavedState.RBP = rbp; + thread->SavedState.RIP = rip; + + // TODO: Make this more stable somehow + regs = (tRegs*)(rbp+(2+1)*8); // RBP,Ret + CurThread + thread->SavedState.UserCS = regs->CS; + thread->SavedState.UserRIP = regs->RIP; + } + + #if BREAK_ON_SWITCH + { + tThread *oldthread = thread; #endif - - // Reduce remaining quantum and continue timeslice if non-zero - if(thread->Remaining--) return; - // Reset quantum for next call - thread->Remaining = thread->Quantum; - - // Get machine state - __asm__ __volatile__ ("mov %%rsp, %0":"=r"(rsp)); - __asm__ __volatile__ ("mov %%rbp, %0":"=r"(rbp)); - rip = GetRIP(); - if(rip == SWITCH_MAGIC) return; // Check if a switch happened - - // Save machine state - thread->SavedState.RSP = rsp; - thread->SavedState.RBP = rbp; - thread->SavedState.RIP = rip; - + // Get next thread - thread = Threads_GetNextToRun(CPU); + thread = Threads_GetNextToRun(CPU, thread); // Error Check if(thread == NULL) { - Warning("Hmm... Threads_GetNextToRun returned NULL, I don't think this should happen.\n"); - return; + thread = gaCPUs[CPU].IdleThread; + //Warning("Hmm... Threads_GetNextToRun returned NULL, I don't think this should happen.\n"); +// LogF("Zzzzz.\n"); + //return; + } + if(thread == NULL ) { + return ; + } + #if BREAK_ON_SWITCH + if( thread != oldthread ) { + MAGIC_BREAK(); } + } + #endif #if DEBUG_TRACE_SWITCH - Log("Switching to task %i, CR3 = 0x%x, RIP = %p", + LogF("Switching to task %i, CR3 = 0x%x, RIP = %p", thread->TID, thread->MemState.CR3, thread->SavedState.RIP ); #endif + + if(CPU > MAX_CPUS) + LogF("CPU = %i", CPU); // Set current thread - #if USE_MP gaCPUs[CPU].Current = thread; - #else - gCurrentThread = thread; - #endif // Update Kernel Stack pointer gTSSs[CPU].RSP0 = thread->KernelStack-4; - // Set address space - #if USE_PAE - # error "Todo: Implement PAE Address space switching" - #else - __asm__ __volatile__ ("mov %0, %%cr3"::"a"(thread->MemState.CR3)); - #endif - - #if 0 - if(thread->SavedState.RSP > 0xC0000000 - && thread->SavedState.RSP < thread->KernelStack-0x2000) { - Log_Warning("Proc", "Possible bad ESP %p (PID %i)", thread->SavedState.ESP); - } - #endif - // Switch threads __asm__ __volatile__ ( + "mov %4, %%cr3\n\t" "mov %1, %%rsp\n\t" // Restore RSP "mov %2, %%rbp\n\t" // and RBP "jmp *%3" : : // And return to where we saved state (Proc_Clone or Proc_Scheduler) - "a"(SWITCH_MAGIC), "b"(thread->SavedState.RSP), - "d"(thread->SavedState.RBP), "c"(thread->SavedState.RIP) + "a"(SWITCH_MAGIC), "r"(thread->SavedState.RSP), + "r"(thread->SavedState.RBP), "r"(thread->SavedState.RIP), + "r"(thread->MemState.CR3) ); for(;;); // Shouldn't reach here }