X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Kernel%2Farch%2Fx86%2Fproc.c;h=badeaec91a7969146f58ca69b1cef49dab3b8229;hb=17aac974ab83a3521f2b49b8de33ae05a00fbe07;hp=5e9d1bbc2246c67c9b3704b673b7874ffca2036a;hpb=25f7e9ab0f31ca486c0c981a406d381e160637a4;p=tpg%2Facess2.git diff --git a/Kernel/arch/x86/proc.c b/Kernel/arch/x86/proc.c index 5e9d1bbc..badeaec9 100644 --- a/Kernel/arch/x86/proc.c +++ b/Kernel/arch/x86/proc.c @@ -11,15 +11,21 @@ #if USE_MP # include #endif +#include // === FLAGS === #define DEBUG_TRACE_SWITCH 0 +#define DEBUG_DISABLE_DOUBLEFAULT 1 +#define DEBUG_VERY_SLOW_SWITCH 0 // === CONSTANTS === -#define SWITCH_MAGIC 0xFF5317C8 // FF SWITCH - There is no code in this area // Base is 1193182 #define TIMER_BASE 1193182 -#define TIMER_DIVISOR 11932 //~100Hz +#if DEBUG_VERY_SLOW_PERIOD +# define TIMER_DIVISOR 1193 //~10Hz switch, with 10 quantum = 1s per thread +#else +# define TIMER_DIVISOR 11932 //~100Hz +#endif // === TYPES === #if USE_MP @@ -39,29 +45,37 @@ extern tIDT gIDT[]; extern void APWait(void); // 16-bit AP pause code extern void APStartup(void); // 16-bit AP startup code extern Uint GetEIP(void); // start.asm -extern int GetCPUNum(void); // start.asm +extern Uint GetEIP_Sched(void); // proc.asm +extern void NewTaskHeader(tThread *Thread, void *Fcn, int nArgs, ...); // Actually takes cdecl args extern Uint32 gaInitPageDir[1024]; // start.asm extern char Kernel_Stack_Top[]; extern tShortSpinlock glThreadListLock; extern int giNumCPUs; extern int giNextTID; extern tThread gThreadZero; -extern tThread *Threads_CloneTCB(Uint *Err, Uint Flags); extern void Isr8(void); // Double Fault -extern void Proc_ReturnToUser(tVAddr Handler, Uint Argument); +extern void Proc_ReturnToUser(tVAddr Handler, Uint Argument, tVAddr KernelStack); +extern void scheduler_return; // Return address in SchedulerBase +extern void IRQCommon; // Common IRQ handler code +extern void IRQCommon_handled; // IRQCommon call return location +extern void GetEIP_Sched_ret; // GetEIP call return location // === 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); +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 === @@ -79,9 +93,6 @@ tTSS gaTSSs[MAX_CPUS]; // TSS Array tThread *gCurrentThread = NULL; tThread *gpIdleThread = NULL; #endif -#if USE_PAE -Uint32 *gPML4s[4] = NULL; -#endif tTSS *gTSSs = NULL; // Pointer to TSS array tTSS gTSS0 = {0}; // --- Error Recovery --- @@ -283,10 +294,9 @@ void ArchThreads_Init(void) #else giNumCPUs = 1; gTSSs = &gTSS0; - MM_FinishVirtualInit(); #endif - #if 0 + #if !DEBUG_DISABLE_DOUBLEFAULT // Initialise Double Fault TSS gGDT[5].BaseLow = (Uint)&gDoubleFault_TSS & 0xFFFF; gGDT[5].BaseMid = (Uint)&gDoubleFault_TSS >> 16; @@ -358,16 +368,13 @@ void ArchThreads_Init(void) #endif gThreadZero.CurCPU = 0; - #if USE_PAE - gThreadZero.MemState.PDP[0] = 0; - gThreadZero.MemState.PDP[1] = 0; - gThreadZero.MemState.PDP[2] = 0; - #else gThreadZero.MemState.CR3 = (Uint)gaInitPageDir - KERNEL_BASE; - #endif // Create Per-Process Data Block - MM_Allocate(MM_PPD_CFG); + if( !MM_Allocate(MM_PPD_CFG) ) + { + Panic("OOM - No space for initial Per-Process Config"); + } // Change Stacks Proc_ChangeStack(); @@ -444,7 +451,7 @@ void Proc_Start(void) for(;;) HALT(); // Just yeilds } gaCPUs[i].IdleThread = Threads_GetThread(tid); - gaCPUs[i].IdleThread->ThreadName = "Idle Thread"; + gaCPUs[i].IdleThread->ThreadName = (char*)"Idle Thread"; Threads_SetPriority( gaCPUs[i].IdleThread, -1 ); // Never called randomly gaCPUs[i].IdleThread->Quantum = 1; // 1 slice quantum @@ -464,10 +471,10 @@ void Proc_Start(void) while( giNumInitingCPUs ) __asm__ __volatile__ ("hlt"); #else // Create Idle Task - if(Proc_Clone(0, 0) == 0) + if(Proc_Clone(0) == 0) { gpIdleThread = Proc_GetCurThread(); - gpIdleThread->ThreadName = "Idle Thread"; + gpIdleThread->ThreadName = strdup("Idle Thread"); Threads_SetPriority( gpIdleThread, -1 ); // Never called randomly gpIdleThread->Quantum = 1; // 1 slice quantum for(;;) HALT(); // Just yeilds @@ -550,7 +557,7 @@ void Proc_ChangeStack(void) * \fn int Proc_Clone(Uint *Err, 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(); @@ -559,28 +566,29 @@ int Proc_Clone(Uint *Err, Uint Flags) __asm__ __volatile__ ("mov %%esp, %0": "=r"(esp)); __asm__ __volatile__ ("mov %%ebp, %0": "=r"(ebp)); - newThread = Threads_CloneTCB(Err, Flags); + newThread = Threads_CloneTCB(NULL, Flags); if(!newThread) return -1; // Initialise Memory Space (New Addr space or kernel stack) if(Flags & CLONE_VM) { newThread->MemState.CR3 = MM_Clone(); + // Check for errors + if(newThread->MemState.CR3 == 0) { + Threads_Kill(newThread, -2); + return -1; + } newThread->KernelStack = cur->KernelStack; } else { Uint tmpEbp, oldEsp = esp; // Set CR3 - #if USE_PAE - # warning "PAE Unimplemented" - #else newThread->MemState.CR3 = cur->MemState.CR3; - #endif // Create new KStack newThread->KernelStack = MM_NewKStack(); // Check for errors if(newThread->KernelStack == 0) { - free(newThread); + Threads_Kill(newThread, -2); return -1; } @@ -606,8 +614,8 @@ int Proc_Clone(Uint *Err, Uint Flags) newThread->SavedState.ESP = esp; newThread->SavedState.EBP = ebp; eip = GetEIP(); - if(eip == SWITCH_MAGIC) { - __asm__ __volatile__ ("mov %0, %%db0" : : "r" (newThread) ); + if(eip == 0) { + //__asm__ __volatile__ ("mov %0, %%db0" : : "r" (newThread) ); #if USE_MP // ACK the interrupt if( GetCPUNum() ) @@ -632,52 +640,34 @@ int Proc_Clone(Uint *Err, Uint Flags) * \fn int Proc_SpawnWorker(void) * \brief Spawns a new worker thread */ -int Proc_SpawnWorker(void) +int Proc_SpawnWorker(void (*Fcn)(void*), void *Data) { - tThread *new, *cur; - Uint eip, esp, ebp; - - cur = Proc_GetCurThread(); + tThread *new; + Uint stack_contents[4]; // Create new thread - new = malloc( sizeof(tThread) ); + new = Threads_CloneThreadZero(); if(!new) { Warning("Proc_SpawnWorker - Out of heap space!\n"); return -1; } - memcpy(new, &gThreadZero, sizeof(tThread)); - // Set Thread ID - new->TID = giNextTID++; - // Create a new worker stack (in PID0's address space) - // - The stack is relocated by this function - new->KernelStack = MM_NewWorkerStack(); - // Get ESP and EBP based in the new stack - __asm__ __volatile__ ("mov %%esp, %0": "=r"(esp)); - __asm__ __volatile__ ("mov %%ebp, %0": "=r"(ebp)); - esp = new->KernelStack - (cur->KernelStack - esp); - ebp = new->KernelStack - (cur->KernelStack - ebp); + // Create the stack contents + stack_contents[3] = (Uint)Data; + stack_contents[2] = 1; + stack_contents[1] = (Uint)Fcn; + stack_contents[0] = (Uint)new; + // Create a new worker stack (in PID0's address space) + new->KernelStack = MM_NewWorkerStack(stack_contents, sizeof(stack_contents)); + // Save core machine state - new->SavedState.ESP = esp; - new->SavedState.EBP = ebp; - eip = GetEIP(); - if(eip == SWITCH_MAGIC) { - __asm__ __volatile__ ("mov %0, %%db0" : : "r"(new)); - #if USE_MP - // ACK the interrupt - if(GetCPUNum()) - gpMP_LocalAPIC->EOI.Val = 0; - else - #endif - outb(0x20, 0x20); // ACK Timer and return as child - __asm__ __volatile__ ("sti"); // Restart interrupts - return 0; - } + new->SavedState.ESP = new->KernelStack - sizeof(stack_contents); + new->SavedState.EBP = 0; + new->SavedState.EIP = (Uint)NewTaskHeader; - // Set EIP as parent - new->SavedState.EIP = eip; // Mark as active + new->Status = THREAD_STAT_PREINIT; Threads_AddActive( new ); return new->TID; @@ -701,7 +691,13 @@ Uint Proc_MakeUserStack(void) // Allocate Stack - Allocate incrementally to clean up MM_Dump output for( i = 0; i < USER_STACK_SZ/0x1000; i++ ) - MM_Allocate( base + (i<<12) ); + { + if( !MM_Allocate( base + (i<<12) ) ) + { + Warning("OOM: Proc_MakeUserStack"); + return 0; + } + } return base + USER_STACK_SZ; } @@ -832,10 +828,94 @@ void Proc_CallFaultHandler(tThread *Thread) { // Rewinds the stack and calls the user function // Never returns - Proc_ReturnToUser( Thread->FaultHandler, Thread->CurFaultNum ); + Proc_ReturnToUser( Thread->FaultHandler, Thread->CurFaultNum, Thread->KernelStack ); for(;;); } +void Proc_DumpThreadCPUState(tThread *Thread) +{ + if( Thread->CurCPU > -1 ) + { + int maxBacktraceDistance = 6; + tRegs *regs = NULL; + Uint32 *stack; + + if( Thread->CurCPU != GetCPUNum() ) { + Log(" Currently running"); + return ; + } + + // Backtrace to find the IRQ entrypoint + // - This will usually only be called by an IRQ, so this should + // work + __asm__ __volatile__ ("mov %%ebp, %0" : "=r" (stack)); + while( maxBacktraceDistance -- ) + { + // [ebp] = oldEbp + // [ebp+4] = retaddr + + if( stack[1] == (tVAddr)&IRQCommon_handled ) { + regs = (void*)stack[2]; + break; + } + + stack = (void*)stack[0]; + } + + if( !regs ) { + Log(" Unable to find IRQ Entry"); + return ; + } + + Log(" at %04x:%08x", regs->cs, regs->eip); + return ; + } + + #if 1 + tVAddr diffFromScheduler = Thread->SavedState.EIP - (tVAddr)Proc_Scheduler; + tVAddr diffFromClone = Thread->SavedState.EIP - (tVAddr)Proc_Clone; + tVAddr diffFromSpawn = Thread->SavedState.EIP - (tVAddr)Proc_SpawnWorker; + + if( diffFromClone > 0 && diffFromClone < 512 ) // When I last checked, GetEIP was at .+0x183 + { + Log(" Creating full thread"); + return ; + } + + if( diffFromSpawn > 0 && diffFromSpawn < 512 ) // When I last checked, GetEIP was at .+0x99 + { + Log(" Creating worker thread"); + return ; + } + + if( diffFromScheduler > 0 && diffFromScheduler < 256 ) // When I last checked, GetEIP was at .+0x60 + #else + Uint32 data[3]; + MM_ReadFromAddrSpace(Thread->MemState.CR3, Thread->SavedState.EBP, data, 12); + if( data[1] == (Uint32)&IRQCommon + 25 ) + { + tRegs *regs = (void *) data[2]; + Log(" oldebp = 0x%08x, ret = 0x%08x, regs = 0x%x", + data[0], data[1], data[2] + ); + // [EBP] = old EBP + // [EBP+0x04] = Return Addr + // [EBP+0x08] = Arg 1 (CPU Number) + // [EBP+0x0C] = Arg 2 (Thread) + // [EBP+0x10] = GS (start of tRegs) + Log(" IRQ%i from %02x:%08x", regs->int_num regs->cs, regs->eip); + } + if( stack[1] == (Uint32)&scheduler_return ) + #endif + { + // Scheduled out + Log(" At %04x:%08x", Thread->SavedState.UserCS, Thread->SavedState.UserEIP); + return ; + } + + Log(" Just created (unknow %p)", Thread->SavedState.EIP); +} + /** * \fn void Proc_Scheduler(int CPU) * \brief Swap current thread and clears dead threads @@ -857,6 +937,7 @@ void Proc_Scheduler(int CPU) if( thread ) { + tRegs *regs; // Reduce remaining quantum and continue timeslice if non-zero if( thread->Remaining-- ) return; @@ -867,17 +948,47 @@ void Proc_Scheduler(int CPU) __asm__ __volatile__ ( "mov %%esp, %0" : "=r" (esp) ); __asm__ __volatile__ ( "mov %%ebp, %0" : "=r" (ebp) ); eip = GetEIP(); - if(eip == SWITCH_MAGIC) return; // Check if a switch happened + if(eip == 0) { + __asm__ __volatile__ ( "nop" : : : "eax","ebx","ecx","edx","edi","esi"); + regs = (tRegs*)(ebp+(2+2)*4); // EBP,Ret + CPU,CurThread + #if USE_MP + thread = gaCPUs[CPU].Current; + #else + thread = gCurrentThread; + #endif + if(thread->bInstrTrace) { + regs->eflags |= 0x100; // Set TF +// LogF("Tracing enabled\n"); + Log("%p Scheduled (EIP = %p)", thread, thread->SavedState.EIP); + } + else + regs->eflags &= ~0x100; + + return; // Check if a switch happened + } // Save machine state thread->SavedState.ESP = esp; thread->SavedState.EBP = ebp; thread->SavedState.EIP = eip; + + // TODO: Make this more stable somehow + regs = (tRegs*)(ebp+(2+2)*4); // EBP,Ret + CPU,CurThread + thread->SavedState.UserCS = regs->cs; + thread->SavedState.UserEIP = regs->eip; + + if(thread->bInstrTrace) { + regs->eflags |= 0x100; // Set TF + Log("%p De-scheduled", thread); + } + else + regs->eflags &= ~0x100; // Clear TF } // Get next thread to run thread = Threads_GetNextToRun(CPU, thread); + // No avaliable tasks, just go into low power mode (idle thread) if(thread == NULL) { #if USE_MP @@ -888,6 +999,17 @@ void Proc_Scheduler(int CPU) #endif } + #if DEBUG_TRACE_SWITCH + if(thread && thread != Proc_GetCurThread() ) { + Log("Switching to task %i(%s), CR3 = 0x%x, EIP = %p", + thread->TID, + thread->ThreadName, + thread->MemState.CR3, + thread->SavedState.EIP + ); + } + #endif + // Set current thread #if USE_MP gaCPUs[CPU].Current = thread; @@ -895,28 +1017,13 @@ void Proc_Scheduler(int CPU) gCurrentThread = thread; #endif - #if DEBUG_TRACE_SWITCH - Log("Switching to task %i, CR3 = 0x%x, EIP = %p", - thread->TID, - thread->MemState.CR3, - thread->SavedState.EIP - ); - #endif - #if USE_MP // MP Debug - Log("CPU = %i, Thread %p", CPU, thread); +// Log("CPU = %i, Thread %p", CPU, thread); #endif // Update Kernel Stack pointer gTSSs[CPU].ESP0 = 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.ESP > 0xC0000000 && thread->SavedState.ESP < thread->KernelStack-0x2000) { @@ -924,13 +1031,28 @@ void Proc_Scheduler(int CPU) } #endif + if( thread->bInstrTrace ) { + Log("%p Scheduled (EIP = %p)", thread, thread->SavedState.EIP); + } + + // Set thread pointer + __asm__ __volatile__("mov %0, %%db0\n\t" : : "r"(thread) ); // Switch threads __asm__ __volatile__ ( - "mov %1, %%esp\n\t" // Restore ESP - "mov %2, %%ebp\n\t" // and EBP - "jmp *%3" : : // And return to where we saved state (Proc_Clone or Proc_Scheduler) - "a"(SWITCH_MAGIC), "b"(thread->SavedState.ESP), - "d"(thread->SavedState.EBP), "c"(thread->SavedState.EIP) + "mov %3, %%cr3\n\t" // Set address space + "mov %0, %%esp\n\t" // Restore ESP + "mov %1, %%ebp\n\t" // and EBP + "test %4, %4\n\t" + "jz 1f\n\t" + "or %4, 72(%%ebp)\n\t" // or trace flag to eflags (2+2+4+8+2)*4 + "1:" + "xor %%eax, %%eax\n\t" + "jmp *%2" : : // And return to where we saved state (Proc_Clone or Proc_Scheduler) + "r"(thread->SavedState.ESP), + "r"(thread->SavedState.EBP), + "r"(thread->SavedState.EIP), + "r"(thread->MemState.CR3), + "r"(thread->bInstrTrace&&thread->SavedState.EIP==(Uint)&GetEIP_Sched_ret?0x100:0) ); for(;;); // Shouldn't reach here }