X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Kernel%2Fthreads.c;h=b9d59f3f00c14644f2678b4bcede04a43c614837;hb=3e11c7767641614fbb3fad38fffefa0da9e66919;hp=863b5e49d6fe9b8fa5c3b9779fd7ed456cbfaa9d;hpb=a4d4d4e851d88dcc0f421e35c00726d860d3d708;p=tpg%2Facess2.git diff --git a/Kernel/threads.c b/Kernel/threads.c index 863b5e49..b9d59f3f 100644 --- a/Kernel/threads.c +++ b/Kernel/threads.c @@ -36,7 +36,7 @@ tThread *Threads_CloneTCB(Uint *Err, Uint Flags); int Threads_WaitTID(int TID, int *status); tThread *Threads_GetThread(Uint TID); void Threads_AddToDelete(tThread *Thread); -tThread *Threads_int_GetPrev(tThread **List, tThread *Thread); +tThread *Threads_int_DelFromQueue(tThread **List, tThread *Thread); void Threads_Exit(int TID, int Status); void Threads_Kill(tThread *Thread, int Status); void Threads_Yield(void); @@ -51,6 +51,7 @@ tUID Threads_GetUID(void); tGID Threads_GetGID(void); int Threads_SetGID(Uint *Errno, tUID ID); void Threads_Dump(void); +void Threads_DumpActive(void); void Mutex_Acquire(tMutex *Mutex); void Mutex_Release(tMutex *Mutex); int Mutex_IsLocked(tMutex *Mutex); @@ -69,15 +70,16 @@ tThread gThreadZero = { // --- Locks --- tShortSpinlock glThreadListLock; ///\note NEVER use a heap function while locked // --- Current State --- -volatile int giNumActiveThreads = 0; -volatile int giFreeTickets = 0; -volatile Uint giNextTID = 1; +volatile int giNumActiveThreads = 0; // Number of threads on the active queue +volatile int giFreeTickets = 0; // Number of tickets held by non-scheduled threads +volatile Uint giNextTID = 1; // Next TID to allocate // --- Thread Lists --- tThread *gAllThreads = NULL; // All allocated threads tThread *gActiveThreads = NULL; // Currently Running Threads tThread *gSleepingThreads = NULL; // Sleeping Threads tThread *gDeleteThreads = NULL; // Threads to delete - int giNumCPUs = 1; + int giNumCPUs = 1; // Number of CPUs +BOOL gaThreads_NoTaskSwitch[MAX_CPUS]; // Disables task switches for each core (Pseudo-IF) // === CODE === /** @@ -108,6 +110,9 @@ int Threads_SetName(char *NewName) tThread *cur = Proc_GetCurThread(); char *oldname = cur->ThreadName; + // NOTE: There is a possibility of non-thread safety here + // A thread could read the current name pointer before it is zeroed + cur->ThreadName = NULL; if( IsHeap(oldname) ) free( oldname ); @@ -128,8 +133,7 @@ char *Threads_GetName(tTID ID) if(ID == -1) { return Proc_GetCurThread()->ThreadName; } - // TODO: Find a thread and get its name - return NULL; + return Threads_GetThread(ID)->ThreadName; } /** @@ -172,6 +176,7 @@ tThread *Threads_CloneTCB(Uint *Err, Uint Flags) int i; cur = Proc_GetCurThread(); + // Allocate and duplicate new = malloc(sizeof(tThread)); if(new == NULL) { *Err = -ENOMEM; @@ -182,7 +187,7 @@ tThread *Threads_CloneTCB(Uint *Err, Uint Flags) new->CurCPU = -1; new->Next = NULL; memset( &new->IsLocked, 0, sizeof(new->IsLocked)); - new->Status = THREAD_STAT_ACTIVE; + new->Status = THREAD_STAT_PREINIT; new->RetStatus = 0; // Get Thread ID @@ -237,7 +242,6 @@ tThread *Threads_CloneTCB(Uint *Err, Uint Flags) } /** - * \fn Uint *Threads_GetCfgPtr(int Id) * \brief Get a configuration pointer from the Per-Thread data area * \param ID Config slot ID * \return Pointer at ID @@ -253,7 +257,6 @@ Uint *Threads_GetCfgPtr(int ID) } /** - * \fn tTID Threads_WaitTID(int TID, int *Status) * \brief Wait for a task to change state * \param TID Thread ID to wait on (-1: Any child thread, 0: Any Child/Sibling, <-1: -PID) * \param Status Thread return status @@ -285,6 +288,7 @@ tTID Threads_WaitTID(int TID, int *Status) int initStatus = t->Status; tTID ret; + // Wait for the thread to die! if(initStatus != THREAD_STAT_ZOMBIE) { // TODO: Handle child also being suspended if wanted while(t->Status != THREAD_STAT_ZOMBIE) { @@ -294,6 +298,7 @@ tTID Threads_WaitTID(int TID, int *Status) } } + // Set return status Log_Debug("Threads", "%i waiting for %i, t->Status = %i", Threads_GetTID(), t->TID, t->Status); ret = t->TID; @@ -318,7 +323,6 @@ tTID Threads_WaitTID(int TID, int *Status) } /** - * \fn tThread *Threads_GetThread(Uint TID) * \brief Gets a thread given its TID * \param TID Thread ID * \return Thread pointer @@ -342,13 +346,13 @@ tThread *Threads_GetThread(Uint TID) } /** - * \fn void Threads_AddToDelete(tThread *Thread) * \brief Adds a thread to the delete queue * \param Thread Thread to delete */ void Threads_AddToDelete(tThread *Thread) { // Add to delete queue + // TODO: Is locking needed? if(gDeleteThreads) { Thread->Next = gDeleteThreads; gDeleteThreads = Thread; @@ -359,35 +363,39 @@ void Threads_AddToDelete(tThread *Thread) } /** - * \fn tThread *Threads_int_GetPrev(tThread **List, tThread *Thread) - * \brief Gets the previous entry in a thead linked list + * \brief Deletes an entry from a list * \param List Pointer to the list head * \param Thread Thread to find - * \return Thread before \a Thread on \a List + * \return \a Thread */ -tThread *Threads_int_GetPrev(tThread **List, tThread *Thread) +tThread *Threads_int_DelFromQueue(tThread **List, tThread *Thread) { - tThread *ret; - // First Entry - if(*List == Thread) { - return (tThread*)List; + tThread *ret, *prev = NULL; + + for(ret = *List; + ret && ret != Thread; + prev = ret, ret = ret->Next + ); + + // Is the thread on the list + if(!ret) { + //LogF("%p(%s) is not on list %p\n", Thread, Thread->ThreadName, List); + return NULL; + } + + if( !prev ) { + *List = Thread->Next; + //LogF("%p(%s) removed from head of %p\n", Thread, Thread->ThreadName, List); } - // Or not else { - for(ret = *List; - ret->Next && ret->Next != Thread; - ret = ret->Next - ); - // Error if the thread is not on the list - if(!ret->Next || ret->Next != Thread) { - return NULL; - } + prev->Next = Thread->Next; + //LogF("%p(%s) removed from %p (prev=%p)\n", Thread, Thread->ThreadName, List, prev); } - return ret; + + return Thread; } /** - * \fn void Threads_Exit(int TID, int Status) * \brief Exit the current process (or another?) * \param TID Thread ID to kill * \param Status Exit status @@ -398,9 +406,9 @@ void Threads_Exit(int TID, int Status) Threads_Kill( Proc_GetCurThread(), (Uint)Status & 0xFF ); else Threads_Kill( Threads_GetThread(TID), (Uint)Status & 0xFF ); + // Halt forever, just in case - for(;;) - HALT(); + for(;;) HALT(); } /** @@ -411,13 +419,13 @@ void Threads_Exit(int TID, int Status) */ void Threads_Kill(tThread *Thread, int Status) { - tThread *prev; tMsg *msg; // TODO: Kill all children #if 0 { tThread *child; + // TODO: I should keep a .Parent pointer, and a .Children list for(child = gActiveThreads; child; child = child->Next) @@ -433,30 +441,31 @@ void Threads_Kill(tThread *Thread, int Status) // Lock thread (stop us recieving messages) SHORTLOCK( &Thread->IsLocked ); + // Clear Message Queue + while( Thread->Messages ) + { + msg = Thread->Messages->Next; + free( Thread->Messages ); + Thread->Messages = msg; + } + // Lock thread list SHORTLOCK( &glThreadListLock ); - // Get previous thread on list - prev = Threads_int_GetPrev( &gActiveThreads, Thread ); - if(!prev) { + // Delete from active list + if( !Threads_int_DelFromQueue( &gActiveThreads, Thread ) ) + { Warning("Proc_Exit - Current thread is not on the active queue"); SHORTREL( &glThreadListLock ); SHORTREL( &Thread->IsLocked ); return; } - // Clear Message Queue - while( Thread->Messages ) - { - msg = Thread->Messages->Next; - free( Thread->Messages ); - Thread->Messages = msg; - } - + // Ensure that we are not rescheduled Thread->Remaining = 0; // Clear Remaining Quantum Thread->Quantum = 0; // Clear Quantum to indicate dead thread - prev->Next = Thread->Next; // Remove from active + // Update bookkeeping giNumActiveThreads --; if( Thread != Proc_GetCurThread() ) giFreeTickets -= Thread->NumTickets; @@ -464,7 +473,7 @@ void Threads_Kill(tThread *Thread, int Status) // Save exit status Thread->RetStatus = Status; - // Don't Zombie if we are being killed as part of a tree + // Don't Zombie if we are being killed because our parent is if(Status == -1) { Thread->Status = THREAD_STAT_DEAD; @@ -478,20 +487,25 @@ void Threads_Kill(tThread *Thread, int Status) Log("Thread %i went *hurk* (%i)", Thread->TID, Thread->Status); // Release spinlocks - SHORTREL( &Thread->IsLocked ); SHORTREL( &glThreadListLock ); + SHORTREL( &Thread->IsLocked ); // TODO: We may not actually be released... - if(Status != -1) HALT(); + // And, reschedule + if(Status != -1) { + for( ;; ) + HALT(); + } } /** - * \fn void Threads_Yield(void) * \brief Yield remainder of the current thread's timeslice */ void Threads_Yield(void) { - Proc_GetCurThread()->Remaining = 0; - HALT(); + tThread *thread = Proc_GetCurThread(); + thread->Remaining = 0; + //while(thread->Remaining == 0) + HALT(); } /** @@ -513,13 +527,13 @@ void Threads_Sleep(void) // Remove us from running queue Threads_RemActive(); + // Mark thread as sleeping + cur->Status = THREAD_STAT_SLEEPING; // Add to Sleeping List (at the top) cur->Next = gSleepingThreads; gSleepingThreads = cur; - // Mark thread as sleeping - cur->Status = THREAD_STAT_SLEEPING; #if DEBUG_TRACE_STATE Log("Threads_Sleep: %p (%i %s) sleeping", cur, cur->TID, cur->ThreadName); @@ -541,8 +555,6 @@ void Threads_Sleep(void) */ int Threads_Wake(tThread *Thread) { - tThread *prev; - if(!Thread) return -EINVAL; @@ -553,26 +565,16 @@ int Threads_Wake(tThread *Thread) return -EALREADY; case THREAD_STAT_SLEEPING: + SHORTLOCK( &glThreadListLock ); // Remove from sleeping queue - prev = Threads_int_GetPrev(&gSleepingThreads, Thread); - prev->Next = Thread->Next; - - // Add to active queue - Thread->Next = gActiveThreads; - gActiveThreads = Thread; + Threads_int_DelFromQueue(&gSleepingThreads, Thread); - // Update bookkeeping - giNumActiveThreads ++; - giFreeTickets += Thread->NumTickets; - #if DEBUG_TRACE_TICKETS - Log("Threads_Wake: new giFreeTickets = %i", giFreeTickets); - #endif + Threads_AddActive( Thread ); - Thread->CurCPU = -1; - Thread->Status = THREAD_STAT_ACTIVE; #if DEBUG_TRACE_STATE Log("Threads_Sleep: %p (%i %s) woken", Thread, Thread->TID, Thread->ThreadName); #endif + SHORTREL( &glThreadListLock ); return -EOK; case THREAD_STAT_WAITING: @@ -600,28 +602,50 @@ int Threads_WakeTID(tTID TID) int ret; if(!thread) return -ENOENT; - SHORTLOCK( &glThreadListLock ); ret = Threads_Wake( thread ); - SHORTREL( &glThreadListLock ); //Log_Debug("Threads", "TID %i woke %i (%p)", Threads_GetTID(), TID, thread); return ret; } /** - * \fn void Threads_AddActive(tThread *Thread) * \brief Adds a thread to the active queue */ void Threads_AddActive(tThread *Thread) { SHORTLOCK( &glThreadListLock ); + + #if 1 + { + tThread *t; + for( t = gActiveThreads; t; t = t->Next ) + { + if( t == Thread ) { + Panic("Threads_AddActive: Attempting a double add of TID %i (0x%x)", + Thread->TID, __builtin_return_address(0)); + } + + if(t->Status != THREAD_STAT_ACTIVE) { + Panic("Threads_AddActive: TID %i status != THREAD_STAT_ACTIVE", + Thread->TID); + } + } + } + #endif + + // Set state + Thread->Status = THREAD_STAT_ACTIVE; + Thread->CurCPU = -1; // Add to active list Thread->Next = gActiveThreads; gActiveThreads = Thread; + // Update bookkeeping giNumActiveThreads ++; giFreeTickets += Thread->NumTickets; + #if DEBUG_TRACE_TICKETS - Log("Threads_AddActive: new giFreeTickets = %i", giFreeTickets); + Log("Threads_AddActive: %p %i (%s) added, new giFreeTickets = %i", + Thread, Thread->TID, Thread->ThreadName, giFreeTickets); #endif SHORTREL( &glThreadListLock ); } @@ -634,12 +658,28 @@ void Threads_AddActive(tThread *Thread) tThread *Threads_RemActive(void) { tThread *ret = Proc_GetCurThread(); - tThread *prev = Threads_int_GetPrev(&gActiveThreads, ret); - if(!prev) return NULL; + + SHORTLOCK( &glThreadListLock ); + + // Delete from active queue + if( !Threads_int_DelFromQueue(&gActiveThreads, ret) ) { + SHORTREL( &glThreadListLock ); + return NULL; + } + ret->Remaining = 0; ret->CurCPU = -1; - prev->Next = ret->Next; + giNumActiveThreads --; + // no need to decrement tickets, scheduler did it for us + + #if DEBUG_TRACE_TICKETS + Log("Threads_RemActive: %p %i (%s) removed, giFreeTickets = %i", + ret, ret->TID, ret->ThreadName, giFreeTickets); + #endif + + SHORTREL( &glThreadListLock ); + return ret; } @@ -734,13 +774,14 @@ int Threads_SetGID(Uint *Errno, tGID ID) /** * \fn void Threads_Dump(void) - * \brief Dums a list of currently running threads + * \brief Dumps a list of currently running threads */ void Threads_Dump(void) { tThread *thread; - Log("Active Threads:"); + Log("--- Thread Dump ---"); + Log("Active Threads: (%i reported)", giNumActiveThreads); for(thread=gActiveThreads;thread;thread=thread->Next) { Log(" %i (%i) - %s (CPU %i)", @@ -761,9 +802,26 @@ void Threads_Dump(void) Log(" KStack 0x%x", thread->KernelStack); } } +/** + * \fn void Threads_Dump(void) + */ +void Threads_DumpActive(void) +{ + tThread *thread; + + Log("Active Threads:"); + for(thread=gActiveThreads;thread;thread=thread->Next) + { + Log(" %i (%i) - %s (CPU %i)", + thread->TID, thread->TGID, thread->ThreadName, thread->CurCPU); + if(thread->Status != THREAD_STAT_ACTIVE) + Log(" ERROR State (%i) != THREAD_STAT_ACTIVE (%i)", thread->Status, THREAD_STAT_ACTIVE); + Log(" %i Tickets, Quantum %i", thread->NumTickets, thread->Quantum); + Log(" KStack 0x%x", thread->KernelStack); + } +} /** - * \fn tThread *Threads_GetNextToRun(int CPU, tThread *Last) * \brief Gets the next thread to run * \param CPU Current CPU * \param Last The thread the CPU was running @@ -772,8 +830,17 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last) { tThread *thread; int ticket; - int number; + int number; + + // If this CPU has the lock, we must let it complete + if( CPU_HAS_LOCK( &glThreadListLock ) ) + return Last; + // Don't change threads if the current CPU has switches disabled + if( gaThreads_NoTaskSwitch[CPU] ) + return Last; + + // Lock thread list SHORTLOCK( &glThreadListLock ); @@ -811,9 +878,12 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last) if(giNumActiveThreads == 1) { if( gActiveThreads->CurCPU == -1 ) gActiveThreads->CurCPU = CPU; + SHORTREL( &glThreadListLock ); + if( gActiveThreads->CurCPU == CPU ) return gActiveThreads; + return NULL; // CPU has nothing to do } @@ -828,15 +898,27 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last) } #if DEBUG_TRACE_TICKETS else - LogF(" %p (%s)->Status = %i (Released)\n", Last, Last->ThreadName, Last->Status); + LogF(" CPU %i released %p (%i %s)->Status = %i (Released)\n", + CPU, Last, Last->TID, Last->ThreadName, Last->Status); #endif Last->CurCPU = -1; } + #if DEBUG_TRACE_TICKETS + //Threads_DumpActive(); + #endif + #if 1 number = 0; for(thread = gActiveThreads; thread; thread = thread->Next) { if(thread->CurCPU >= 0) continue; + if(thread->Status != THREAD_STAT_ACTIVE) + Panic("Bookkeeping fail - %p %i(%s) is on the active queue with a status of %i", + thread, thread->TID, thread->ThreadName, thread->Status); + if(thread->Next == thread) { + Panic("Bookkeeping fail - %p %i(%s) loops back on itself", + thread, thread->TID, thread->ThreadName, thread->Status); + } number += thread->NumTickets; } if(number != giFreeTickets) { @@ -925,7 +1007,7 @@ void Mutex_Acquire(tMutex *Mutex) if( Mutex->Owner ) { SHORTLOCK( &glThreadListLock ); // - Remove from active list - Threads_RemActive(); + us = Threads_RemActive(); // - Mark as sleeping us->Status = THREAD_STAT_OFFSLEEP; @@ -961,10 +1043,18 @@ void Mutex_Release(tMutex *Mutex) if( Mutex->Waiting ) { Mutex->Owner = Mutex->Waiting; // Set owner Mutex->Waiting = Mutex->Waiting->Next; // Next! + // Reset ->LastWaiting to NULL if we have just removed the last waiting thread + // 2010-10-02 21:50 - Comemerating the death of the longest single + // blocker in the Acess2 history. REMEMBER TO + // FUCKING MAINTAIN YOUR FUCKING LISTS DIPWIT + if( Mutex->LastWaiting == Mutex->Owner ) + Mutex->LastWaiting = NULL; + // Wake new owner - Mutex->Owner->Status = THREAD_STAT_ACTIVE; - Threads_AddActive(Mutex->Owner); - //Log("Mutex %p Woke %p", Mutex, Mutex->Owner); + SHORTLOCK( &glThreadListLock ); + if( Mutex->Owner->Status != THREAD_STAT_ACTIVE ) + Threads_AddActive(Mutex->Owner); + SHORTREL( &glThreadListLock ); } else { Mutex->Owner = NULL; @@ -983,6 +1073,7 @@ int Mutex_IsLocked(tMutex *Mutex) // === EXPORTS === EXPORT(Threads_GetUID); +EXPORT(Threads_GetGID); EXPORT(Mutex_Acquire); EXPORT(Mutex_Release); EXPORT(Mutex_IsLocked);