X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Kernel%2Farch%2Fx86%2Fproc.c;h=6e9440091e1addc0cd93bb6d5d3bf10b150139ee;hb=df1d534cfe822903fc38e1cc13c4b18941c91908;hp=ad83c9919fb4159bc61f49f6b03ab6d9a855b06d;hpb=8051546ad5894e093211d2ec69dde6b99cdaa71d;p=tpg%2Facess2.git diff --git a/Kernel/arch/x86/proc.c b/Kernel/arch/x86/proc.c index ad83c991..6e944009 100644 --- a/Kernel/arch/x86/proc.c +++ b/Kernel/arch/x86/proc.c @@ -13,7 +13,7 @@ #endif // === FLAGS === -#define DEBUG_TRACE_SWITCH 0 +#define DEBUG_TRACE_SWITCH 1 #define DEBUG_DISABLE_DOUBLEFAULT 1 // === CONSTANTS === @@ -40,6 +40,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 +48,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); +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 +61,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 === @@ -284,7 +292,6 @@ void ArchThreads_Init(void) #else giNumCPUs = 1; gTSSs = &gTSS0; - MM_FinishVirtualInit(); #endif #if !DEBUG_DISABLE_DOUBLEFAULT @@ -368,7 +375,10 @@ void ArchThreads_Init(void) #endif // Create Per-Process Data Block - MM_Allocate(MM_PPD_CFG); + if( !MM_Allocate(MM_PPD_CFG) ) + { + Panic("OOM - No space for initiali Per-Process Config"); + } // Change Stacks Proc_ChangeStack(); @@ -445,7 +455,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 @@ -468,7 +478,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 @@ -566,6 +576,11 @@ int Proc_Clone(Uint *Err, Uint Flags) // 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; @@ -581,7 +596,7 @@ int Proc_Clone(Uint *Err, Uint Flags) newThread->KernelStack = MM_NewKStack(); // Check for errors if(newThread->KernelStack == 0) { - free(newThread); + Threads_Kill(newThread, -2); return -1; } @@ -608,7 +623,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() ) @@ -641,14 +656,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(); @@ -664,7 +676,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()) @@ -702,7 +714,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; } @@ -833,10 +851,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 @@ -856,8 +958,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; @@ -874,11 +981,35 @@ 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); + + #if DEBUG_TRACE_SWITCH + if(thread) { + Log("Switching to task %i(%s), CR3 = 0x%x, EIP = %p", + thread->TID, + thread->ThreadName, + thread->MemState.CR3, + thread->SavedState.EIP + ); + } + #endif + // No avaliable tasks, just go into low power mode (idle thread) if(thread == NULL) { #if USE_MP @@ -896,28 +1027,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) { @@ -925,14 +1041,28 @@ void Proc_Scheduler(int CPU) } #endif + if( thread->bInstrTrace ) { + Log("%p Scheduled", thread); + } + + #if USE_PAE + # error "Todo: Implement PAE Address space switching" + #else + // 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) ); + #endif for(;;); // Shouldn't reach here }