X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;ds=sidebyside;f=Kernel%2Farch%2Fx86%2Fproc.c;h=ceb80ad61964868c5f797987ad2702225487c385;hb=4ed0dbeaa387b3d04e7b2853ceac4e148d0f8ea9;hp=55b9b1704a0bab1d7b69ab6722d58944b7e5b3c4;hpb=e5e272c426a28f2f9e69ed2232469575c7409af1;p=tpg%2Facess2.git diff --git a/Kernel/arch/x86/proc.c b/Kernel/arch/x86/proc.c index 55b9b170..ceb80ad6 100644 --- a/Kernel/arch/x86/proc.c +++ b/Kernel/arch/x86/proc.c @@ -15,12 +15,17 @@ // === 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 @@ -40,6 +45,7 @@ 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 Uint GetEIP_Sched(void); // proc.asm extern int GetCPUNum(void); // start.asm extern Uint32 gaInitPageDir[1024]; // start.asm extern char Kernel_Stack_Top[]; @@ -47,9 +53,12 @@ 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, 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); @@ -57,12 +66,16 @@ void ArchThreads_Init(void); 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); + 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 === @@ -80,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 --- @@ -284,7 +294,6 @@ void ArchThreads_Init(void) #else giNumCPUs = 1; gTSSs = &gTSS0; - MM_FinishVirtualInit(); #endif #if !DEBUG_DISABLE_DOUBLEFAULT @@ -359,18 +368,12 @@ 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 if( !MM_Allocate(MM_PPD_CFG) ) { - Panic("OOM - No space for initiali Per-Process Config"); + Panic("OOM - No space for initial Per-Process Config"); } // Change Stacks @@ -448,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 @@ -471,7 +474,7 @@ void Proc_Start(void) if(Proc_Clone(0, 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 @@ -579,11 +582,7 @@ int Proc_Clone(Uint *Err, Uint Flags) 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(); @@ -616,7 +615,7 @@ int Proc_Clone(Uint *Err, Uint Flags) newThread->SavedState.EBP = ebp; eip = GetEIP(); if(eip == SWITCH_MAGIC) { - __asm__ __volatile__ ("mov %0, %%db0" : : "r" (newThread) ); + //__asm__ __volatile__ ("mov %0, %%db0" : : "r" (newThread) ); #if USE_MP // ACK the interrupt if( GetCPUNum() ) @@ -649,14 +648,11 @@ int Proc_SpawnWorker(void) cur = Proc_GetCurThread(); // 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(); @@ -672,7 +668,7 @@ int Proc_SpawnWorker(void) new->SavedState.EBP = ebp; eip = GetEIP(); if(eip == SWITCH_MAGIC) { - __asm__ __volatile__ ("mov %0, %%db0" : : "r"(new)); + //__asm__ __volatile__ ("mov %0, %%db0" : : "r"(new)); #if USE_MP // ACK the interrupt if(GetCPUNum()) @@ -851,6 +847,90 @@ void Proc_CallFaultHandler(tThread *Thread) 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 @@ -870,8 +950,13 @@ void Proc_Scheduler(int CPU) thread = gCurrentThread; #endif + // NOTE: + // 2011-04-05 + // Bug may be caused by DR0 not being maintained somewhere, hence + // login is getting loaded with the idle state. if( thread ) { + tRegs *regs; // Reduce remaining quantum and continue timeslice if non-zero if( thread->Remaining-- ) return; @@ -888,11 +973,24 @@ void Proc_Scheduler(int CPU) 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 @@ -903,6 +1001,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; @@ -910,28 +1019,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) { @@ -939,13 +1033,23 @@ void Proc_Scheduler(int CPU) } #endif + if( thread->bInstrTrace ) { + Log("%p Scheduled", thread); + } + + // Set thread pointer + __asm__ __volatile__("mov %0, %%db0\n\t" : : "r"(thread) ); // Switch threads __asm__ __volatile__ ( + "mov %4, %%cr3\n\t" // Set address space "mov %1, %%esp\n\t" // Restore ESP "mov %2, %%ebp\n\t" // and EBP + "or %5, 72(%%ebp)\n\t" // or trace flag to eflags (2+2+4+8+2)*4 "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) + "d"(thread->SavedState.EBP), "c"(thread->SavedState.EIP), + "r"(thread->MemState.CR3), + "r"(thread->bInstrTrace&&thread->SavedState.EIP==(Uint)&GetEIP_Sched_ret?0x100:0) ); for(;;); // Shouldn't reach here }