X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Kernel%2Farch%2Fx86%2Fproc.c;h=6e9440091e1addc0cd93bb6d5d3bf10b150139ee;hb=df1d534cfe822903fc38e1cc13c4b18941c91908;hp=043312136ca45947be4b597f811ff70cac1e1dc5;hpb=a506fc15c09f7d8f178a7c7d9658b5bf45778128;p=tpg%2Facess2.git diff --git a/Kernel/arch/x86/proc.c b/Kernel/arch/x86/proc.c index 04331213..6e944009 100644 --- a/Kernel/arch/x86/proc.c +++ b/Kernel/arch/x86/proc.c @@ -13,13 +13,14 @@ #endif // === FLAGS === -#define DEBUG_TRACE_SWITCH 0 +#define DEBUG_TRACE_SWITCH 1 +#define DEBUG_DISABLE_DOUBLEFAULT 1 // === CONSTANTS === -#define SWITCH_MAGIC 0xFFFACE55 // There is no code in this area +#define SWITCH_MAGIC 0xFF5317C8 // FF SWITCH - There is no code in this area // Base is 1193182 #define TIMER_BASE 1193182 -#define TIMER_DIVISOR 11931 //~100Hz +#define TIMER_DIVISOR 11932 //~100Hz // === TYPES === #if USE_MP @@ -29,6 +30,7 @@ typedef struct sCPU Uint8 State; // 0: Unavaliable, 1: Idle, 2: Active Uint16 Resvd; tThread *Current; + tThread *IdleThread; } tCPU; #endif @@ -38,22 +40,20 @@ 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 void Kernel_Stack_Top; -extern tSpinlock glThreadListLock; +extern char Kernel_Stack_Top[]; +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 void Threads_Dump(void); -extern tThread *Threads_CloneTCB(Uint *Err, Uint Flags); extern void Isr8(void); // Double Fault -extern void Proc_ReturnToUser(void); +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); @@ -61,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 === @@ -82,6 +86,7 @@ tTSS gaTSSs[MAX_CPUS]; // TSS Array int giProc_BootProcessorID = 0; #else tThread *gCurrentThread = NULL; +tThread *gpIdleThread = NULL; #endif #if USE_PAE Uint32 *gPML4s[4] = NULL; @@ -287,10 +292,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; @@ -308,6 +312,11 @@ void ArchThreads_Init(void) outb(0x40, TIMER_DIVISOR&0xFF); // Low Byte of Divisor outb(0x40, (TIMER_DIVISOR>>8)&0xFF); // High Byte + Log("Timer Frequency %i.%03i Hz", + TIMER_BASE/TIMER_DIVISOR, + ((Uint64)TIMER_BASE*1000/TIMER_DIVISOR)%1000 + ); + #if USE_MP // Get the count setting for APIC timer Log("Determining APIC Count"); @@ -338,7 +347,7 @@ void ArchThreads_Init(void) gTSSs[pos].SS0 = 0x10; gTSSs[pos].ESP0 = 0; // Set properly by scheduler gGDT[6+pos].BaseLow = ((Uint)(&gTSSs[pos])) & 0xFFFF; - gGDT[6+pos].BaseMid = ((Uint)(&gTSSs[pos])) >> 16; + gGDT[6+pos].BaseMid = ((Uint)(&gTSSs[pos]) >> 16) & 0xFFFF; gGDT[6+pos].BaseHi = ((Uint)(&gTSSs[pos])) >> 24; #if USE_MP } @@ -346,6 +355,9 @@ void ArchThreads_Init(void) // Load the BSP's TSS __asm__ __volatile__ ("ltr %%ax"::"a"(0x30)); + // Set Current Thread and CPU Number in DR0 and DR1 + __asm__ __volatile__ ("mov %0, %%db0"::"r"(&gThreadZero)); + __asm__ __volatile__ ("mov %0, %%db1"::"r"(0)); #if USE_MP gaCPUs[0].Current = &gThreadZero; @@ -363,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(); @@ -377,7 +392,7 @@ void MP_StartAP(int CPU) // Set location of AP startup code and mark for a warm restart *(Uint16*)(KERNEL_BASE|0x467) = (Uint)&APWait - (KERNEL_BASE|0xFFFF0); *(Uint16*)(KERNEL_BASE|0x469) = 0xFFFF; - outb(0x70, 0x0F); outb(0x71, 0x0A); // Warm Reset + outb(0x70, 0x0F); outb(0x71, 0x0A); // Set warm reset flag MP_SendIPI(gaCPUs[CPU].APICID, 0, 5); // Init IPI // Delay @@ -427,24 +442,55 @@ void Proc_Start(void) int i; #endif - // Start Interrupts (and hence scheduler) - __asm__ __volatile__("sti"); - #if USE_MP // Start APs for( i = 0; i < giNumCPUs; i ++ ) { - gaCPUs[i].Current = NULL; + 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 = (char*)"Idle Thread"; + Threads_SetPriority( gaCPUs[i].IdleThread, -1 ); // 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"); + __asm__ __volatile__ ("sti"); while( giNumInitingCPUs ) __asm__ __volatile__ ("hlt"); - MM_FinishVirtualInit(); + #else + // Create Idle Task + if(Proc_Clone(0, 0) == 0) + { + gpIdleThread = Proc_GetCurThread(); + gpIdleThread->ThreadName = strdup("Idle Thread"); + Threads_SetPriority( gpIdleThread, -1 ); // Never called randomly + gpIdleThread->Quantum = 1; // 1 slice quantum + for(;;) HALT(); // Just yeilds + } + + // Set current task + gCurrentThread = &gThreadZero; + + // Start Interrupts (and hence scheduler) + __asm__ __volatile__("sti"); #endif + MM_FinishVirtualInit(); } /** @@ -454,7 +500,6 @@ 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; @@ -531,18 +576,27 @@ 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; // 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; } @@ -569,7 +623,14 @@ int Proc_Clone(Uint *Err, Uint Flags) newThread->SavedState.EBP = ebp; eip = GetEIP(); if(eip == SWITCH_MAGIC) { - outb(0x20, 0x20); // ACK Timer and return as child + //__asm__ __volatile__ ("mov %0, %%db0" : : "r" (newThread) ); + #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; } @@ -595,16 +656,13 @@ 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 code + // - The stack is relocated by this function new->KernelStack = MM_NewWorkerStack(); // Get ESP and EBP based in the new stack @@ -618,14 +676,21 @@ int Proc_SpawnWorker(void) new->SavedState.EBP = ebp; eip = GetEIP(); if(eip == SWITCH_MAGIC) { - outb(0x20, 0x20); // ACK Timer and return as child + //__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; } // Set EIP as parent new->SavedState.EIP = eip; // Mark as active - new->Status = THREAD_STAT_ACTIVE; Threads_AddActive( new ); return new->TID; @@ -649,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; } @@ -780,10 +851,94 @@ void Proc_CallFaultHandler(tThread *Thread) { // Rewinds the stack and calls the user function // Never returns - __asm__ __volatile__ ("mov %0, %%ebp;\n\tcall Proc_ReturnToUser" :: "r"(Thread->FaultHandler)); + 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 @@ -796,32 +951,6 @@ 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) { - #if 0 - Log("No Active threads, sleeping"); - #endif - #if USE_MP - if(CPU) - gpMP_LocalAPIC->EOI.Val = 0; - else - #endif - outb(0x20, 0x20); - __asm__ __volatile__ ("hlt"); - return; - } - // Get current thread #if USE_MP thread = gaCPUs[CPU].Current; @@ -829,60 +958,82 @@ void Proc_Scheduler(int CPU) thread = gCurrentThread; #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 %%esp, %0":"=r"(esp)); - __asm__ __volatile__ ("mov %%ebp, %0":"=r"(ebp)); - eip = GetEIP(); - if(eip == SWITCH_MAGIC) return; // Check if a switch happened - - // Save machine state - thread->SavedState.ESP = esp; - thread->SavedState.EBP = ebp; - thread->SavedState.EIP = eip; + // 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; + // Reset quantum for next call + thread->Remaining = thread->Quantum; + + // Get machine state + __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 + + // 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); - // Error Check - if(thread == NULL) { - Warning("Hmm... Threads_GetNextToRun returned NULL, I don't think this should happen.\n"); - return; - } #if DEBUG_TRACE_SWITCH - Log("Switching to task %i, CR3 = 0x%x, EIP = %p", - thread->TID, - thread->MemState.CR3, - thread->SavedState.EIP - ); + 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 + thread = gaCPUs[CPU].IdleThread; + Log("CPU %i Running Idle Thread", CPU); + #else + thread = gpIdleThread; + #endif + } + // Set current thread #if USE_MP - gaCPUs[CPU].Current->bIsRunning = 0; gaCPUs[CPU].Current = thread; - thread->bIsRunning = 1; #else gCurrentThread = thread; #endif - //Log("CPU = %i", CPU); + #if USE_MP // MP Debug +// 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) { @@ -890,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 }