X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Kernel%2Farch%2Fx86_64%2Fproc.c;h=99fa7e60ffbbba1110098a93e746fff3ff8d571c;hb=717454930aa0e255517c68c837927deac49bd78e;hp=5bb66af9ad2a9655ef7cb29a1f3fa2d2a80817cc;hpb=43f12a083f112a410859597c5f45e78b1de2e7c8;p=tpg%2Facess2.git diff --git a/Kernel/arch/x86_64/proc.c b/Kernel/arch/x86_64/proc.c index 5bb66af9..99fa7e60 100644 --- a/Kernel/arch/x86_64/proc.c +++ b/Kernel/arch/x86_64/proc.c @@ -1,10 +1,11 @@ /* - * AcessOS Microkernel Version + * Acess2 x86_64 port * proc.c */ #include #include #include +#include #include #include #include @@ -20,39 +21,50 @@ // 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(); // 16-bit AP startup code -extern Uint GetRIP(); // start.asm -extern Uint64 gaInitPML4[512]; // start.asm -extern void Kernel_Stack_Top; -extern tSpinlock glThreadListLock; +extern void APStartup(void); // 16-bit AP startup code +extern Uint GetRIP(void); // start.asm +extern Uint64 gInitialPML4[512]; // start.asm +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(); -extern tThread *Threads_CloneTCB(Uint *Err, Uint Flags); -extern void Proc_AlterUserReturnAddr(); +extern void Threads_Dump(void); +extern void Proc_ReturnToUser(void); +extern int GetCPUNum(void); // === PROTOTYPES === -void ArchThreads_Init(); +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(); -tThread *Proc_GetCurThread(); -void Proc_ChangeStack(); - int Proc_Clone(Uint *Err, Uint Flags); +//void Proc_Start(void); +//tThread *Proc_GetCurThread(void); +void Proc_ChangeStack(void); +// 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); + int Proc_Demote(Uint *Err, int Dest, tRegs *Regs); void Proc_CallFaultHandler(tThread *Thread); -void Proc_Scheduler(); +void Proc_DumpThreadCPUState(tThread *Thread); +void Proc_Scheduler(int CPU); // === GLOBALS === // --- Multiprocessing --- @@ -61,10 +73,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 --- @@ -72,10 +82,10 @@ Uint32 gaDoubleFaultStack[1024]; // === CODE === /** - * \fn void ArchThreads_Init() + * \fn void ArchThreads_Init(void) * \brief Starts the process scheduler */ -void ArchThreads_Init() +void ArchThreads_Init(void) { Uint pos = 0; @@ -269,26 +279,28 @@ void ArchThreads_Init() pos = 0; #endif gTSSs[pos].RSP0 = 0; // Set properly by scheduler - gGDT[6+pos*2].BaseLow = ((Uint)(&gTSSs[pos])) & 0xFFFF; - gGDT[6+pos*2].BaseMid = ((Uint)(&gTSSs[pos])) >> 16; - gGDT[6+pos*2].BaseHi = ((Uint)(&gTSSs[pos])) >> 24; - gGDT[6+pos*2+1].DWord[0] = ((Uint)(&gTSSs[pos])) >> 32; + gGDT[7+pos*2].LimitLow = sizeof(tTSS) & 0xFFFF; + gGDT[7+pos*2].BaseLow = ((Uint)(&gTSSs[pos])) & 0xFFFF; + gGDT[7+pos*2].BaseMid = ((Uint)(&gTSSs[pos])) >> 16; + gGDT[7+pos*2].BaseHi = ((Uint)(&gTSSs[pos])) >> 24; + gGDT[7+pos*2+1].DWord[0] = ((Uint)(&gTSSs[pos])) >> 32; #if USE_MP } for(pos=0;pos>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 @@ -331,33 +348,86 @@ void MP_SendIPI(Uint8 APICID, int Vector, int DeliveryMode) #endif /** - * \fn void Proc_Start() + * \fn void Proc_Start(void) * \brief Start process scheduler */ -void Proc_Start() +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) == 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"); } /** - * \fn tThread *Proc_GetCurThread() + * \fn tThread *Proc_GetCurThread(void) * \brief Gets the current thread */ -tThread *Proc_GetCurThread() +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 } /** - * \fn void Proc_ChangeStack() + * \fn void Proc_ChangeStack(void) * \brief Swaps the current stack for a new one (in the proper stack reigon) */ -void Proc_ChangeStack() +void Proc_ChangeStack(void) { Uint rsp, rbp; Uint tmp_rbp, old_rsp; @@ -376,13 +446,13 @@ void Proc_ChangeStack() return; } - curBase = (Uint)&Kernel_Stack_Top; + curBase = (Uint)&gInitialKernelStack; - LOG("curBase = 0x%x, newBase = 0x%x", curBase, newBase); + Log("curBase = 0x%x, newBase = 0x%x", curBase, newBase); // Get ESP as a used size rsp = curBase - rsp; - LOG("memcpy( %p, %p, 0x%x )", (void*)(newBase - rsp), (void*)(curBase - rsp), rsp ); + Log("memcpy( %p, %p, 0x%x )", (void*)(newBase - rsp), (void*)(curBase - rsp), rsp ); // Copy used stack memcpy( (void*)(newBase - rsp), (void*)(curBase - rsp), rsp ); // Get ESP as an offset in the new stack @@ -390,16 +460,17 @@ void Proc_ChangeStack() // Adjust EBP rbp = newBase - (curBase - rbp); + Log("Update stack"); // Repair EBPs & Stack Addresses // Catches arguments also, but may trash stack-address-like values - for(tmp_rbp = rsp; tmp_rbp < newBase; tmp_rbp += 4) + for(tmp_rbp = rsp; tmp_rbp < newBase; tmp_rbp += sizeof(Uint)) { if(old_rsp < *(Uint*)tmp_rbp && *(Uint*)tmp_rbp < curBase) *(Uint*)tmp_rbp += newBase - curBase; } + Log("Applying Changes"); Proc_GetCurThread()->KernelStack = newBase; - __asm__ __volatile__ ("mov %0, %%rsp"::"r"(rsp)); __asm__ __volatile__ ("mov %0, %%rbp"::"r"(rbp)); } @@ -420,8 +491,11 @@ int Proc_Clone(Uint *Err, Uint Flags) newThread = Threads_CloneTCB(Err, Flags); if(!newThread) return -1; + Log("Proc_Clone: newThread = %p", newThread); + // Initialise Memory Space (New Addr space or kernel stack) if(Flags & CLONE_VM) { + Log("Proc_Clone: Cloning VM"); newThread->MemState.CR3 = MM_Clone(); newThread->KernelStack = cur->KernelStack; } else { @@ -432,6 +506,7 @@ int Proc_Clone(Uint *Err, Uint Flags) // Create new KStack newThread->KernelStack = MM_NewKStack(); + Log("Proc_Clone: newKStack = %p", newThread->KernelStack); // Check for errors if(newThread->KernelStack == 0) { free(newThread); @@ -453,7 +528,7 @@ int Proc_Clone(Uint *Err, Uint Flags) // Repair EBPs & Stack Addresses // Catches arguments also, but may trash stack-address-like values - for(tmp_rbp = rsp; tmp_rbp < newThread->KernelStack; tmp_rbp += 4) + for(tmp_rbp = rsp; tmp_rbp < newThread->KernelStack; tmp_rbp += sizeof(Uint)) { if(old_rsp < *(Uint*)tmp_rbp && *(Uint*)tmp_rbp < cur->KernelStack) *(Uint*)tmp_rbp += newThread->KernelStack - cur->KernelStack; @@ -479,10 +554,10 @@ int Proc_Clone(Uint *Err, Uint Flags) } /** - * \fn int Proc_SpawnWorker() + * \fn int Proc_SpawnWorker(void) * \brief Spawns a new worker thread */ -int Proc_SpawnWorker() +int Proc_SpawnWorker(void) { tThread *new, *cur; Uint rip, rsp, rbp; @@ -527,10 +602,10 @@ int Proc_SpawnWorker() } /** - * \fn Uint Proc_MakeUserStack() + * \fn Uint Proc_MakeUserStack(void) * \brief Creates a new user stack */ -Uint Proc_MakeUserStack() +Uint Proc_MakeUserStack(void) { int i; Uint base = USER_STACK_TOP - USER_STACK_SZ; @@ -543,8 +618,17 @@ Uint Proc_MakeUserStack() 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; } @@ -624,7 +708,7 @@ void Proc_StartProcess(Uint16 SS, Uint Stack, Uint Flags, Uint16 CS, Uint IP) */ int Proc_Demote(Uint *Err, int Dest, tRegs *Regs) { - int cpl = Regs->cs & 3; + int cpl = Regs->CS & 3; // Sanity Check if(Dest > 3 || Dest < 0) { *Err = -EINVAL; @@ -638,13 +722,8 @@ int Proc_Demote(Uint *Err, int Dest, tRegs *Regs) } // Change the Segment Registers - Regs->cs = (((Dest+1)<<4) | Dest) - 8; - Regs->ss = ((Dest+1)<<4) | Dest; - // Check if the GP Segs are GDT, then change them - if(!(Regs->ds & 4)) Regs->ds = ((Dest+1)<<4) | Dest; - if(!(Regs->es & 4)) Regs->es = ((Dest+1)<<4) | Dest; - if(!(Regs->fs & 4)) Regs->fs = ((Dest+1)<<4) | Dest; - if(!(Regs->gs & 4)) Regs->gs = ((Dest+1)<<4) | Dest; + Regs->CS = (((Dest+1)<<4) | Dest) - 8; + Regs->SS = ((Dest+1)<<4) | Dest; return 0; } @@ -657,10 +736,14 @@ void Proc_CallFaultHandler(tThread *Thread) { // Rewinds the stack and calls the user function // Never returns - __asm__ __volatile__ ("mov %0, %%rbp;\n\tcall Proc_AlterUserReturnAddr" :: "r"(Thread->FaultHandler)); + __asm__ __volatile__ ("mov %0, %%rbp;\n\tcall Proc_ReturnToUser" :: "r"(Thread->FaultHandler)); for(;;); } +void Proc_DumpThreadCPUState(tThread *Thread) +{ +} + /** * \fn void Proc_Scheduler(int CPU) * \brief Swap current thread and clears dead threads @@ -673,30 +756,8 @@ void Proc_Scheduler(int CPU) // 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; - #endif // Reduce remaining quantum and continue timeslice if non-zero if(thread->Remaining--) return; @@ -715,45 +776,35 @@ void Proc_Scheduler(int CPU) 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"); + thread = gaCPUs[CPU].IdleThread; + //Warning("Hmm... Threads_GetNextToRun returned NULL, I don't think this should happen.\n"); + //LogF("Zzzzz.\n"); return; } #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 + __asm__ __volatile__ ("mov %0, %%cr3"::"a"(thread->MemState.CR3)); // Switch threads __asm__ __volatile__ (