X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=KernelLand%2FKernel%2Fthreads.c;h=67a2f637462e5b86252c40978b9cecee18cb21de;hb=8394ad407646ea68f17c29e9899936e0906c4725;hp=6099621166818402fba6238ef8dab9b1c149769e;hpb=a3ef890d4f4e213f69c04dba3fb1df3e1dd8fb54;p=tpg%2Facess2.git diff --git a/KernelLand/Kernel/threads.c b/KernelLand/Kernel/threads.c index 60996211..67a2f637 100644 --- a/KernelLand/Kernel/threads.c +++ b/KernelLand/Kernel/threads.c @@ -11,6 +11,7 @@ #include #include #include // VFS Handle maintainence +#include // Configuration #define DEBUG_TRACE_TICKETS 0 // Trace ticket counts @@ -65,6 +66,10 @@ tThread *Threads_RemActive(void); void Threads_ToggleTrace(int TID); void Threads_Fault(int Num); void Threads_SegFault(tVAddr Addr); +void Threads_PostSignal(int SignalNum); + int Threads_GetPendingSignal(void); +void Threads_SetSignalHandler(int SignalNum, void *Handler); +void *Threads_GetSignalHandler(int SignalNum); #if 0 int Threads_GetPID(void); int Threads_GetTID(void); @@ -211,7 +216,7 @@ int Threads_SetName(const char *NewName) if( IsHeap(oldname) ) free( oldname ); cur->ThreadName = strdup(NewName); -// Log_Debug("Threads", "Thread renamed to '%s'", NewName); + Log_Debug("Threads", "Thread renamed to '%s'", NewName); return 0; } @@ -442,9 +447,30 @@ tThread *Threads_CloneThreadZero(void) tTID Threads_WaitTID(int TID, int *Status) { // Any Child - if(TID == -1) { - Log_Error("Threads", "TODO: Threads_WaitTID(TID=-1) - Any Child"); - return -1; + if(TID == -1) + { + Uint32 ev = Threads_WaitEvents(THREAD_EVENT_DEADCHILD); + tTID ret = -1; + if( ev & THREAD_EVENT_DEADCHILD ) + { + // A child died, get the TID + tThread *us = Proc_GetCurThread(); + ASSERT(us->LastDeadChild); + ret = us->LastDeadChild->TID; + // - Mark as dead (as opposed to undead) + ASSERT(us->LastDeadChild->Status == THREAD_STAT_ZOMBIE); + us->LastDeadChild->Status = THREAD_STAT_DEAD; + // - Set return status + if(Status) + *Status = us->LastDeadChild->RetStatus; + us->LastDeadChild = NULL; + Mutex_Release(&us->DeadChildLock); + } + else + { + Log_Error("Threads", "TODO: Threads_WaitTID(TID=-1) - Any Child"); + } + return ret; } // Any peer/child thread @@ -460,33 +486,14 @@ tTID Threads_WaitTID(int TID, int *Status) } // Specific Thread - if(TID > 0) { - tThread *t = Threads_GetThread(TID); + if(TID > 0) + { tTID ret; - - // Wait for the thread to die! - // TODO: Handle child also being suspended if wanted - while(t->Status != THREAD_STAT_ZOMBIE) { - Threads_Sleep(); - Log_Debug("Threads", "%i waiting for %i, t->Status = %i", - Threads_GetTID(), t->TID, t->Status); - } - - // Set return status - ret = t->TID; - switch(t->Status) + // NOTE: Race condition - Other child dies, desired child dies, first death is 'lost' + while( (ret = Threads_WaitTID(-1, Status)) != TID ) { - case THREAD_STAT_ZOMBIE: - // Kill the thread - t->Status = THREAD_STAT_DEAD; - // TODO: Child return value? - if(Status) *Status = t->RetStatus; - // add to delete queue - Threads_Delete( t ); - break; - default: - if(Status) *Status = -1; - break; + if( ret == -1 ) + break; } return ret; } @@ -504,15 +511,13 @@ tThread *Threads_GetThread(Uint TID) tThread *thread; // Search global list - for(thread = gAllThreads; - thread; - thread = thread->GlobalNext) + for( thread = gAllThreads; thread; thread = thread->GlobalNext ) { if(thread->TID == TID) return thread; } - Log("Unable to find TID %i on main list\n", TID); + Log_Notice("Threads", "Unable to find TID %i on main list\n", TID); return NULL; } @@ -687,8 +692,10 @@ void Threads_Kill(tThread *Thread, int Status) Thread->Status = THREAD_STAT_ZOMBIE; SHORTREL( &glThreadListLock ); - // TODO: Send something like SIGCHLD - Threads_Wake( Thread->Parent ); + // TODO: It's possible that we could be timer-preempted here, should disable that... somehow + Mutex_Acquire( &Thread->Parent->DeadChildLock ); // released by parent + Thread->Parent->LastDeadChild = Thread; + Threads_PostEvent( Thread->Parent, THREAD_EVENT_DEADCHILD ); Log("Thread %i went *hurk* (%i)", Thread->TID, Status); @@ -709,6 +716,22 @@ void Threads_Yield(void) Proc_Reschedule(); } +/** + * \breif Wait for the thread status to not be a specified value + */ +void Threads_int_WaitForStatusEnd(enum eThreadStatus Status) +{ + tThread *us = Proc_GetCurThread(); + ASSERT(Status != THREAD_STAT_ACTIVE); + ASSERT(Status != THREAD_STAT_DEAD); + while( us->Status == Status ) + { + Proc_Reschedule(); + if( us->Status == Status ) + Debug("Thread %p(%i %s) rescheduled while in %s state", casTHREAD_STAT[Status]); + } +} + /** * \fn void Threads_Sleep(void) * \brief Take the current process off the run queue @@ -740,12 +763,7 @@ void Threads_Sleep(void) // Release Spinlock SHORTREL( &glThreadListLock ); - - while(cur->Status != THREAD_STAT_ACTIVE) { - Proc_Reschedule(); - if( cur->Status != THREAD_STAT_ACTIVE ) - Log("%i - Huh? why am I up? zzzz...", cur->TID); - } + Threads_int_WaitForStatusEnd(THREAD_STAT_SLEEPING); } @@ -767,11 +785,11 @@ int Threads_Wake(tThread *Thread) return -EALREADY; case THREAD_STAT_SLEEPING: - SHORTLOCK( &glThreadListLock ); // Remove from sleeping queue + SHORTLOCK( &glThreadListLock ); Threads_int_DelFromQueue(&gSleepingThreads, Thread); - SHORTREL( &glThreadListLock ); + Threads_AddActive( Thread ); #if DEBUG_TRACE_STATE @@ -837,7 +855,7 @@ int Threads_Wake(tThread *Thread) return -ENOTIMPL; default: - Warning("Threads_Wake - Unknown process status (%i)\n", Thread->Status); + Log_Warning("Threads", "Threads_Wake - Unknown process status (%i)", Thread->Status); return -EINTERNAL; } } @@ -990,6 +1008,62 @@ void Threads_SegFault(tVAddr Addr) //Threads_Exit( 0, -1 ); } + +void Threads_PostSignal(int SignalNum) +{ + tThread *cur = Proc_GetCurThread(); + cur->PendingSignal = SignalNum; + Threads_PostEvent(cur, THREAD_EVENT_SIGNAL); +} + +/** + */ +int Threads_GetPendingSignal(void) +{ + tThread *cur = Proc_GetCurThread(); + + // Atomic AND with 0 fetches and clears in one operation + return __sync_fetch_and_and( &cur->PendingSignal, 0 ); +} + +/* + * \brief Update the current thread's signal handler + */ +void Threads_SetSignalHandler(int SignalNum, void *Handler) +{ + if( SignalNum <= 0 || SignalNum >= NSIGNALS ) + return ; + if( !MM_IsUser(Handler) ) + return ; + Proc_GetCurThread()->Process->SignalHandlers[SignalNum] = Handler; +} + +/** + * \return 0 Ignore + */ +void *Threads_GetSignalHandler(int SignalNum) +{ + if( SignalNum <= 0 || SignalNum >= NSIGNALS ) + return NULL; + void *ret = Proc_GetCurThread()->Process->SignalHandlers[SignalNum]; + if( !ret ) + { + // Defaults + switch(SignalNum) + { + case SIGINT: + case SIGKILL: + case SIGSEGV: +// ret = User_Signal_Kill; + break; + default: + ret = NULL; + break; + } + } + return ret; +} + // --- Process Structure Access Functions --- tPGID Threads_GetPGID(void) { @@ -1059,9 +1133,20 @@ char **Threads_GetCWD(void) void Threads_int_DumpThread(tThread *thread) { + if( !thread ) { + Log(" %p NULL", thread); + return ; + } + if( !CheckMem(thread, sizeof(tThread)) ) { + Log(" %p INVAL", thread); + return ; + } + tPID pid = (thread->Process ? thread->Process->PID : -1); + const char *statstr = (thread->Status < sizeof(casTHREAD_STAT)/sizeof(casTHREAD_STAT[0]) + ? casTHREAD_STAT[thread->Status] : ""); Log(" %p %i (%i) - %s (CPU %i) - %i (%s)", - thread, thread->TID, thread->Process->PID, thread->ThreadName, thread->CurCPU, - thread->Status, casTHREAD_STAT[thread->Status] + thread, thread->TID, pid, thread->ThreadName, thread->CurCPU, + thread->Status, statstr ); switch(thread->Status) { @@ -1075,13 +1160,16 @@ void Threads_int_DumpThread(tThread *thread) ((tSemaphore*)thread->WaitPointer)->Name ); break; + case THREAD_STAT_EVENTSLEEP: + // TODO: Event mask + break; case THREAD_STAT_ZOMBIE: Log(" Return Status: %i", thread->RetStatus); break; default: break; } Log(" Priority %i, Quantum %i", thread->Priority, thread->Quantum); - Log(" KStack 0x%x", thread->KernelStack); + Log(" KStack %p", thread->KernelStack); if( thread->bInstrTrace ) Log(" Tracing Enabled"); Proc_DumpThreadCPUState(thread); @@ -1126,13 +1214,11 @@ void Threads_DumpActive(void) */ void Threads_Dump(void) { - tThread *thread; - Log("--- Thread Dump ---"); Threads_DumpActive(); Log("All Threads:"); - for(thread=gAllThreads;thread;thread=thread->GlobalNext) + for(tThread *thread = gAllThreads; thread; thread = thread->GlobalNext) { Threads_int_DumpThread(thread); }