X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;ds=inline;f=Kernel%2Fthreads.c;h=956eede82281ff1e3153bc6da1d090c22943d478;hb=a2495c6ea4f4cab16b5d339ae511428e92e89e73;hp=1393f54a380e946b0e071b4965de41c92f86d5d5;hpb=d069f04c4ae06ea7e0e71db144df338c1bd33ac2;p=tpg%2Facess2.git diff --git a/Kernel/threads.c b/Kernel/threads.c index 1393f54a..956eede8 100644 --- a/Kernel/threads.c +++ b/Kernel/threads.c @@ -7,14 +7,13 @@ #include #include #include -#include -#include #include +#include +#include // VFS Handle maintainence // Configuration #define DEBUG_TRACE_TICKETS 0 // Trace ticket counts #define DEBUG_TRACE_STATE 0 // Trace state changes (sleep/wake) -#define SEMAPHORE_DEBUG 0 // --- Schedulers --- #define SCHED_UNDEF 0 @@ -28,28 +27,31 @@ #define DEFAULT_QUANTUM 5 #define DEFAULT_PRIORITY 5 #define MIN_PRIORITY 10 -const enum eConfigTypes cCONFIG_TYPES[] = { - CFGT_HEAPSTR, // e.g. CFG_VFS_CWD - CFGT_INT, // e.g. CFG_VFS_MAXFILES - CFGT_NULL -}; // === IMPORTS === +// === TYPE === +typedef struct +{ + tThread *Head; + tThread *Tail; +} tThreadList; + // === PROTOTYPES === void Threads_Init(void); #if 0 +void Threads_Delete(tThread *Thread); int Threads_SetName(const char *NewName); #endif -char *Threads_GetName(int ID); +char *Threads_GetName(tTID ID); #if 0 void Threads_SetPriority(tThread *Thread, int Pri); tThread *Threads_CloneTCB(Uint *Err, Uint Flags); int Threads_WaitTID(int TID, int *status); tThread *Threads_GetThread(Uint TID); #endif -void Threads_AddToDelete(tThread *Thread); -tThread *Threads_int_DelFromQueue(tThread **List, tThread *Thread); +tThread *Threads_int_DelFromQueue(tThreadList *List, tThread *Thread); +void Threads_int_AddToList(tThreadList *List, tThread *Thread); #if 0 void Threads_Exit(int TID, int Status); void Threads_Kill(tThread *Thread, int Status); @@ -72,14 +74,11 @@ tGID Threads_GetGID(void); #endif void Threads_Dump(void); void Threads_DumpActive(void); -#if 0 - int Mutex_Acquire(tMutex *Mutex); -void Mutex_Release(tMutex *Mutex); - int Mutex_IsLocked(tMutex *Mutex); -#endif // === GLOBALS === // -- Core Thread -- +struct sProcess gProcessZero = { + }; // Only used for the core kernel tThread gThreadZero = { .Status = THREAD_STAT_ACTIVE, // Status @@ -96,19 +95,18 @@ volatile int giNumActiveThreads = 0; // Number of threads on the active queue volatile Uint giNextTID = 1; // Next TID to allocate // --- Thread Lists --- tThread *gAllThreads = NULL; // All allocated threads -tThread *gSleepingThreads = NULL; // Sleeping Threads -tThread *gDeleteThreads = NULL; // Threads to delete +tThreadList gSleepingThreads; // Sleeping Threads int giNumCPUs = 1; // Number of CPUs BOOL gaThreads_NoTaskSwitch[MAX_CPUS]; // Disables task switches for each core (Pseudo-IF) // --- Scheduler Types --- #if SCHEDULER_TYPE == SCHED_LOTTERY const int caiTICKET_COUNTS[MIN_PRIORITY+1] = {100,81,64,49,36,25,16,9,4,1,0}; volatile int giFreeTickets = 0; // Number of tickets held by non-scheduled threads -tThread *gActiveThreads = NULL; // Currently Running Threads +tThreadList gActiveThreads; // Currently Running Threads #elif SCHEDULER_TYPE == SCHED_RR_SIM -tThread *gActiveThreads = NULL; // Currently Running Threads +tThreadList gActiveThreads; // Currently Running Threads #elif SCHEDULER_TYPE == SCHED_RR_PRI -tThread *gaActiveThreads[MIN_PRIORITY+1]; // Active threads for each priority level +tThreadList gaActiveThreads[MIN_PRIORITY+1]; // Active threads for each priority level #else # error "Unkown scheduler type" #endif @@ -127,18 +125,60 @@ void Threads_Init(void) Log_Debug("Threads", ".KernelStack = %i", offsetof(tThread, KernelStack)); // Create Initial Task - #if SCHEDULER_TYPE == SCHED_RR_PRI - gaActiveThreads[gThreadZero.Priority] = &gThreadZero; - #else - gActiveThreads = &gThreadZero; - #endif +// #if SCHEDULER_TYPE == SCHED_RR_PRI +// gaActiveThreads[gThreadZero.Priority].Head = &gThreadZero; +// gaActiveThreads[gThreadZero.Priority].Tail = &gThreadZero; +// #else +// gActiveThreads.Head = &gThreadZero; +// gActiveThreads.Tail = &gThreadZero; +// #endif gAllThreads = &gThreadZero; giNumActiveThreads = 1; + gThreadZero.Process = &gProcessZero; Proc_Start(); } +void Threads_Delete(tThread *Thread) +{ + // Set to dead + Thread->Status = THREAD_STAT_BURIED; + + // Clear out process state + Proc_ClearThread(Thread); + + Thread->Process->nThreads --; + if( Thread->Process->nThreads == 0 ) + { + tProcess *proc = Thread->Process; + // VFS Cleanup + VFS_CloseAllUserHandles(); + // Architecture cleanup + Proc_ClearProcess( proc ); + // VFS Configuration strings + if( proc->CurrentWorkingDir) + free( proc->CurrentWorkingDir ); + if( proc->RootDir ) + free( proc->RootDir ); + // Process descriptor + free( proc ); + } + + // Free name + if( IsHeap(Thread->ThreadName) ) + free(Thread->ThreadName); + + // Remove from global list + // TODO: Lock this too + if( Thread == gAllThreads ) + gAllThreads = Thread->GlobalNext; + else + Thread->GlobalPrev->GlobalNext = Thread->GlobalNext; + + free(Thread); +} + /** * \fn void Threads_SetName(const char *NewName) * \brief Sets the current thread's name @@ -155,9 +195,11 @@ int Threads_SetName(const char *NewName) cur->ThreadName = NULL; - if( IsHeap(oldname) ) free( oldname ); - + if( IsHeap(oldname) ) free( oldname ); cur->ThreadName = strdup(NewName); + + Log_Debug("Threads", "Thread renamed to '%s'", NewName); + return 0; } @@ -196,14 +238,18 @@ void Threads_SetPriority(tThread *Thread, int Pri) if( Pri == Thread->Priority ) return; #if SCHEDULER_TYPE == SCHED_RR_PRI - SHORTLOCK( &glThreadListLock ); - // Remove from old priority - Threads_int_DelFromQueue( &gaActiveThreads[Thread->Priority], Thread ); - // And add to new - Thread->Next = gaActiveThreads[Pri]; - gaActiveThreads[Pri] = Thread; - Thread->Priority = Pri; - SHORTREL( &glThreadListLock ); + if( Thread != Proc_GetCurThread() ) + { + SHORTLOCK( &glThreadListLock ); + // Remove from old priority + Threads_int_DelFromQueue( &gaActiveThreads[Thread->Priority], Thread ); + // And add to new + Threads_int_AddToList( &gaActiveThreads[Pri], Thread ); + Thread->Priority = Pri; + SHORTREL( &glThreadListLock ); + } + else + Thread->Priority = Pri; #else // If this isn't the current thread, we need to lock if( Thread != Proc_GetCurThread() ) @@ -239,7 +285,6 @@ void Threads_SetPriority(tThread *Thread, int Pri) tThread *Threads_CloneTCB(Uint Flags) { tThread *cur, *new; - int i; cur = Proc_GetCurThread(); // Allocate and duplicate @@ -262,10 +307,30 @@ tThread *Threads_CloneTCB(Uint Flags) new->ThreadName = strdup(cur->ThreadName); // Set Thread Group ID (PID) - if(Flags & CLONE_VM) - new->TGID = new->TID; - else - new->TGID = cur->TGID; + if(Flags & CLONE_VM) { + tProcess *newproc, *oldproc; + oldproc = cur->Process; + new->Process = malloc( sizeof(struct sProcess) ); + newproc = new->Process; + newproc->PID = new->TID; + newproc->UID = oldproc->UID; + newproc->GID = oldproc->GID; + newproc->MaxFD = oldproc->MaxFD; + if( oldproc->CurrentWorkingDir ) + newproc->CurrentWorkingDir = strdup( oldproc->CurrentWorkingDir ); + else + newproc->CurrentWorkingDir = NULL; + if( oldproc->RootDir ) + newproc->RootDir = strdup( oldproc->RootDir ); + else + newproc->RootDir = NULL; + newproc->nThreads = 1; + // Reference all handles in the VFS + VFS_ReferenceUserHandles(); + } + else { + new->Process->nThreads ++; + } // Messages are not inherited new->Messages = NULL; @@ -274,27 +339,12 @@ tThread *Threads_CloneTCB(Uint Flags) // Set State new->Remaining = new->Quantum = cur->Quantum; new->Priority = cur->Priority; + new->_errno = 0; // Set Signal Handlers new->CurFaultNum = 0; new->FaultHandler = cur->FaultHandler; - for( i = 0; i < NUM_CFG_ENTRIES; i ++ ) - { - switch(cCONFIG_TYPES[i]) - { - default: - new->Config[i] = cur->Config[i]; - break; - case CFGT_HEAPSTR: - if(cur->Config[i]) - new->Config[i] = (Uint) strdup( (void*)cur->Config[i] ); - else - new->Config[i] = 0; - break; - } - } - // Maintain a global list of threads SHORTLOCK( &glThreadListLock ); new->GlobalPrev = NULL; // Protect against bugs @@ -312,7 +362,6 @@ tThread *Threads_CloneTCB(Uint Flags) tThread *Threads_CloneThreadZero(void) { tThread *new; - int i; // Allocate and duplicate new = malloc(sizeof(tThread)); @@ -320,6 +369,8 @@ tThread *Threads_CloneThreadZero(void) return NULL; } memcpy(new, &gThreadZero, sizeof(tThread)); + + new->Process->nThreads ++; new->CurCPU = -1; new->Next = NULL; @@ -347,11 +398,6 @@ tThread *Threads_CloneThreadZero(void) new->CurFaultNum = 0; new->FaultHandler = 0; - for( i = 0; i < NUM_CFG_ENTRIES; i ++ ) - { - new->Config[i] = 0; - } - // Maintain a global list of threads SHORTLOCK( &glThreadListLock ); new->GlobalPrev = NULL; // Protect against bugs @@ -363,21 +409,6 @@ tThread *Threads_CloneThreadZero(void) return new; } -/** - * \brief Get a configuration pointer from the Per-Thread data area - * \param ID Config slot ID - * \return Pointer at ID - */ -Uint *Threads_GetCfgPtr(int ID) -{ - if(ID < 0 || ID >= NUM_CFG_ENTRIES) { - Warning("Threads_GetCfgPtr: Index %i is out of bounds", ID); - return NULL; - } - - return &Proc_GetCurThread()->Config[ID]; -} - /** * \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) @@ -407,22 +438,17 @@ tTID Threads_WaitTID(int TID, int *Status) // Specific Thread if(TID > 0) { tThread *t = Threads_GetThread(TID); - 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) { - Threads_Sleep(); - Log_Debug("Threads", "%i waiting for %i, t->Status = %i", - Threads_GetTID(), t->TID, t->Status); - } + // 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 - Log_Debug("Threads", "%i waiting for %i, t->Status = %i", - Threads_GetTID(), t->TID, t->Status); ret = t->TID; switch(t->Status) { @@ -432,7 +458,7 @@ tTID Threads_WaitTID(int TID, int *Status) // TODO: Child return value? if(Status) *Status = t->RetStatus; // add to delete queue - Threads_AddToDelete( t ); + Threads_Delete( t ); break; default: if(Status) *Status = -1; @@ -467,34 +493,17 @@ tThread *Threads_GetThread(Uint TID) return NULL; } -/** - * \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; - } else { - Thread->Next = NULL; - gDeleteThreads = Thread; - } -} - /** * \brief Deletes an entry from a list * \param List Pointer to the list head * \param Thread Thread to find * \return \a Thread */ -tThread *Threads_int_DelFromQueue(tThread **List, tThread *Thread) +tThread *Threads_int_DelFromQueue(tThreadList *List, tThread *Thread) { tThread *ret, *prev = NULL; - for(ret = *List; + for(ret = List->Head; ret && ret != Thread; prev = ret, ret = ret->Next ); @@ -506,17 +515,29 @@ tThread *Threads_int_DelFromQueue(tThread **List, tThread *Thread) } if( !prev ) { - *List = Thread->Next; + List->Head = Thread->Next; //LogF("%p(%s) removed from head of %p\n", Thread, Thread->ThreadName, List); } else { prev->Next = Thread->Next; //LogF("%p(%s) removed from %p (prev=%p)\n", Thread, Thread->ThreadName, List, prev); } + if( Thread->Next == NULL ) + List->Tail = prev; return Thread; } +void Threads_int_AddToList(tThreadList *List, tThread *Thread) +{ + if( List->Head ) + List->Tail->Next = Thread; + else + List->Head = Thread; + List->Tail = Thread; + Thread->Next = NULL; +} + /** * \brief Exit the current process (or another?) * \param TID Thread ID to kill @@ -544,17 +565,17 @@ void Threads_Kill(tThread *Thread, int Status) tMsg *msg; int isCurThread = Thread == Proc_GetCurThread(); - // TODO: Kill all children + // TODO: Disown all children? #if 1 { tThread *child; - // TODO: I should keep a .Parent pointer, and a .Children list + // TODO: I should keep a .Children list for(child = gAllThreads; child; child = child->GlobalNext) { if(child->Parent == Thread) - Threads_Kill(child, -1); + child->Parent = &gThreadZero; } } #endif @@ -582,30 +603,33 @@ void Threads_Kill(tThread *Thread, int Status) // Currently active thread case THREAD_STAT_ACTIVE: - #if SCHEDULER_TYPE == SCHED_RR_PRI - if( Threads_int_DelFromQueue( &gaActiveThreads[Thread->Priority], Thread ) ) - #else - if( Threads_int_DelFromQueue( &gActiveThreads, Thread ) ) - #endif + if( Thread != Proc_GetCurThread() ) { - // Ensure that we are not rescheduled - Thread->Remaining = 0; // Clear Remaining Quantum - Thread->Quantum = 0; // Clear Quantum to indicate dead thread - - // Update bookkeeping - giNumActiveThreads --; + #if SCHEDULER_TYPE == SCHED_RR_PRI + tThreadList *list = &gaActiveThreads[Thread->Priority]; + #else + tThreadList *list = &gActiveThreads; + #endif + if( Threads_int_DelFromQueue( list, Thread ) ) + { + } + else + { + Log_Warning("Threads", + "Threads_Kill - Thread %p(%i,%s) marked as active, but not on list", + Thread, Thread->TID, Thread->ThreadName + ); + } #if SCHEDULER_TYPE == SCHED_LOTTERY - if( Thread != Proc_GetCurThread() ) - giFreeTickets -= caiTICKET_COUNTS[ Thread->Priority ]; + giFreeTickets -= caiTICKET_COUNTS[ Thread->Priority ]; #endif } - else - { - Log_Warning("Threads", - "Threads_Kill - Thread %p(%i,%s) marked as active, but not on list", - Thread, Thread->TID, Thread->ThreadName - ); - } + // Ensure that we are not rescheduled + Thread->Remaining = 0; // Clear Remaining Quantum + Thread->Quantum = 0; // Clear Quantum to indicate dead thread + + // Update bookkeeping + giNumActiveThreads --; break; // Kill it while it sleeps! case THREAD_STAT_SLEEPING: @@ -618,7 +642,7 @@ void Threads_Kill(tThread *Thread, int Status) } break; - // Brains!... You cannot kill + // Brains!... You cannot kill something that is already dead case THREAD_STAT_ZOMBIE: Log_Warning("Threads", "Threads_Kill - Thread %p(%i,%s) is undead, you cannot kill it", Thread, Thread->TID, Thread->ThreadName); @@ -635,24 +659,15 @@ void Threads_Kill(tThread *Thread, int Status) // Save exit status Thread->RetStatus = Status; - // Don't Zombie if we are being killed because our parent is - if(Status == -1) - { - Thread->Status = THREAD_STAT_DEAD; - Threads_AddToDelete( Thread ); - SHORTREL( &glThreadListLock ); - } else { - Thread->Status = THREAD_STAT_ZOMBIE; - SHORTREL( &glThreadListLock ); - // Wake parent - Threads_Wake( Thread->Parent ); - } + SHORTREL( &Thread->IsLocked ); + + Thread->Status = THREAD_STAT_ZOMBIE; + SHORTREL( &glThreadListLock ); + // TODO: Send something like SIGCHLD + Threads_Wake( Thread->Parent ); Log("Thread %i went *hurk* (%i)", Thread->TID, Status); - // Release spinlocks - SHORTREL( &Thread->IsLocked ); // TODO: We may not actually be released... - // And, reschedule if(isCurThread) { @@ -693,9 +708,7 @@ void Threads_Sleep(void) cur->Status = THREAD_STAT_SLEEPING; // Add to Sleeping List (at the top) - cur->Next = gSleepingThreads; - gSleepingThreads = cur; - + Threads_int_AddToList( &gSleepingThreads, cur ); #if DEBUG_TRACE_STATE Log("Threads_Sleep: %p (%i %s) sleeping", cur, cur->TID, cur->ThreadName); @@ -713,7 +726,6 @@ void Threads_Sleep(void) /** - * \fn int Threads_Wake( tThread *Thread ) * \brief Wakes a sleeping/waiting thread up * \param Thread Thread to wake * \return Boolean Failure (Returns ERRNO) @@ -783,6 +795,7 @@ int Threads_Wake(tThread *Thread) sem->LastSignaling = prev; } + Thread->RetStatus = 0; // It didn't get anything Threads_AddActive( Thread ); #if DEBUG_TRACE_STATE @@ -849,21 +862,12 @@ void Threads_AddActive(tThread *Thread) // Thread->CurCPU = -1; // Add to active list { - tThread *tmp, *prev = NULL; #if SCHEDULER_TYPE == SCHED_RR_PRI - for( tmp = gaActiveThreads[Thread->Priority]; tmp; prev = tmp, tmp = tmp->Next ); - if(prev) - prev->Next = Thread; - else - gaActiveThreads[Thread->Priority] = Thread; + tThreadList *list = &gaActiveThreads[Thread->Priority]; #else - for( tmp = gActiveThreads; tmp; prev = tmp, tmp = tmp->Next ); - if(prev) - prev->Next = Thread; - else - gActiveThreads = Thread; + tThreadList *list = &gActiveThreads; #endif - Thread->Next = NULL; + Threads_int_AddToList( list, Thread ); } // Update bookkeeping @@ -898,6 +902,7 @@ void Threads_AddActive(tThread *Thread) */ tThread *Threads_RemActive(void) { + #if 0 tThread *ret = Proc_GetCurThread(); if( !IS_LOCKED(&glThreadListLock) ) { @@ -912,7 +917,6 @@ tThread *Threads_RemActive(void) if( !Threads_int_DelFromQueue(&gActiveThreads, ret) ) #endif { - SHORTREL( &glThreadListLock ); Log_Warning("Threads", "Current thread %p(%i %s) is not on active queue", ret, ret->TID, ret->ThreadName ); @@ -931,6 +935,9 @@ tThread *Threads_RemActive(void) #endif return ret; + #else + return Proc_GetCurThread(); + #endif } /** @@ -996,7 +1003,7 @@ void Threads_SegFault(tVAddr Addr) // --- Process Structure Access Functions --- tPID Threads_GetPID(void) { - return Proc_GetCurThread()->TGID; + return Proc_GetCurThread()->Process->PID; } tTID Threads_GetTID(void) { @@ -1004,43 +1011,65 @@ tTID Threads_GetTID(void) } tUID Threads_GetUID(void) { - return Proc_GetCurThread()->UID; + return Proc_GetCurThread()->Process->UID; } tGID Threads_GetGID(void) { - return Proc_GetCurThread()->GID; + return Proc_GetCurThread()->Process->GID; } -int Threads_SetUID(Uint *Errno, tUID ID) +int Threads_SetUID(tUID ID) { tThread *t = Proc_GetCurThread(); - if( t->UID != 0 ) { - *Errno = -EACCES; + if( t->Process->UID != 0 ) { + errno = -EACCES; return -1; } - Log_Debug("Threads", "TID %i's UID set to %i", t->TID, ID); - t->UID = ID; + Log_Debug("Threads", "PID %i's UID set to %i", t->Process->PID, ID); + t->Process->UID = ID; return 0; } -int Threads_SetGID(Uint *Errno, tGID ID) +int Threads_SetGID(tGID ID) { tThread *t = Proc_GetCurThread(); - if( t->UID != 0 ) { - *Errno = -EACCES; + if( t->Process->UID != 0 ) { + errno = -EACCES; return -1; } - Log_Debug("Threads", "TID %i's GID set to %i", t->TID, ID); - t->GID = ID; + Log_Debug("Threads", "PID %i's GID set to %i", t->Process->PID, ID); + t->Process->GID = ID; return 0; } +// --- Per-thread storage --- +int *Threads_GetErrno(void) +{ + return &Proc_GetCurThread()->_errno; +} + +// --- Configuration --- +int *Threads_GetMaxFD(void) +{ + return &Proc_GetCurThread()->Process->MaxFD; +} +char **Threads_GetChroot(void) +{ + return &Proc_GetCurThread()->Process->RootDir; +} +char **Threads_GetCWD(void) +{ + return &Proc_GetCurThread()->Process->CurrentWorkingDir; +} +// --- + /** * \fn void Threads_Dump(void) */ void Threads_DumpActive(void) { tThread *thread; + tThreadList *list; #if SCHEDULER_TYPE == SCHED_RR_PRI int i; #endif @@ -1050,15 +1079,17 @@ void Threads_DumpActive(void) #if SCHEDULER_TYPE == SCHED_RR_PRI for( i = 0; i < MIN_PRIORITY+1; i++ ) { - for(thread=gaActiveThreads[i];thread;thread=thread->Next) + list = &gaActiveThreads[i]; #else - for(thread=gActiveThreads;thread;thread=thread->Next) + list = &gActiveThreads; #endif + for(thread=list->Head;thread;thread=thread->Next) { Log(" %p %i (%i) - %s (CPU %i)", - thread, thread->TID, thread->TGID, thread->ThreadName, thread->CurCPU); + thread, thread->TID, thread->Process->PID, thread->ThreadName, thread->CurCPU); if(thread->Status != THREAD_STAT_ACTIVE) - Log(" ERROR State (%i) != THREAD_STAT_ACTIVE (%i)", thread->Status, THREAD_STAT_ACTIVE); + Log(" ERROR State (%i) != THREAD_STAT_ACTIVE (%i)", + thread->Status, THREAD_STAT_ACTIVE); Log(" Priority %i, Quantum %i", thread->Priority, thread->Quantum); Log(" KStack 0x%x", thread->KernelStack); if( thread->bInstrTrace ) @@ -1086,7 +1117,7 @@ void Threads_Dump(void) for(thread=gAllThreads;thread;thread=thread->GlobalNext) { Log(" %p %i (%i) - %s (CPU %i)", - thread, thread->TID, thread->TGID, thread->ThreadName, thread->CurCPU); + thread, thread->TID, thread->Process->PID, thread->ThreadName, thread->CurCPU); Log(" State %i (%s)", thread->Status, casTHREAD_STAT[thread->Status]); switch(thread->Status) { @@ -1133,31 +1164,6 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last) // Lock thread list SHORTLOCK( &glThreadListLock ); - // Clear Delete Queue - // - I should probably put this in a worker thread to avoid calling free() in the scheduler - // DEFINITELY - free() can deadlock in this case - // I'll do it when it becomes an issue - while(gDeleteThreads) - { - thread = gDeleteThreads->Next; - // Only free if structure is unused - if( !IS_LOCKED(&gDeleteThreads->IsLocked) ) - { - // Set to dead - gDeleteThreads->Status = THREAD_STAT_BURIED; - // Free name - if( IsHeap(gDeleteThreads->ThreadName) ) - free(gDeleteThreads->ThreadName); - // Remove from global list - if( gDeleteThreads == gAllThreads ) - gAllThreads = gDeleteThreads->GlobalNext; - else - gDeleteThreads->GlobalPrev->GlobalNext = gDeleteThreads->GlobalNext; - free( gDeleteThreads ); - } - gDeleteThreads = thread; - } - // Make sure the current (well, old) thread is marked as de-scheduled if(Last) Last->CurCPU = -1; @@ -1169,25 +1175,28 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last) #endif return NULL; } - + + #if 0 #if SCHEDULER_TYPE != SCHED_RR_PRI // Special case: 1 thread if(giNumActiveThreads == 1) { - if( gActiveThreads->CurCPU == -1 ) - gActiveThreads->CurCPU = CPU; + if( gActiveThreads.Head->CurCPU == -1 ) + gActiveThreads.Head->CurCPU = CPU; SHORTREL( &glThreadListLock ); - if( gActiveThreads->CurCPU == CPU ) - return gActiveThreads; + if( gActiveThreads.Head->CurCPU == CPU ) + return gActiveThreads.Head; return NULL; // CPU has nothing to do } #endif - + #endif + // Allow the old thread to be scheduled again if( Last ) { if( Last->Status == THREAD_STAT_ACTIVE ) { + tThreadList *list; #if SCHEDULER_TYPE == SCHED_LOTTERY giFreeTickets += caiTICKET_COUNTS[ Last->Priority ]; # if DEBUG_TRACE_TICKETS @@ -1196,6 +1205,14 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last) caiTICKET_COUNTS[ Last->Priority ]); # endif #endif + + #if SCHEDULER_TYPE == SCHED_RR_PRI + list = &gaActiveThreads[ Last->Priority ]; + #else + list = &gActiveThreads; + #endif + // Add to end of list + Threads_int_AddToList( list, Last ); } #if SCHEDULER_TYPE == SCHED_LOTTERY && DEBUG_TRACE_TICKETS else @@ -1213,8 +1230,8 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last) int ticket, number; # if 1 number = 0; - for(thread = gActiveThreads; thread; thread = thread->Next) { - if(thread->CurCPU >= 0) continue; + for(thread = gActiveThreads.Head; thread; thread = thread->Next) + { 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); @@ -1240,9 +1257,8 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last) ticket = number = rand() % giFreeTickets; // Find the next thread - for(thread=gActiveThreads;thread;thread=thread->Next) + for(thread = gActiveThreads.Head; thread; prev = thread, thread = thread->Next ) { - if(thread->CurCPU >= 0) continue; if( caiTICKET_COUNTS[ thread->Priority ] > number) break; number -= caiTICKET_COUNTS[ thread->Priority ]; } @@ -1258,7 +1274,15 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last) Panic("Bookeeping Failed - giFreeTickets(%i) > true count (%i)", giFreeTickets, number); } - + + // Remove + if(prev) + prev->Next = thread->Next; + else + gActiveThreads.Head = thread->Next; + if(!thread->Next) + gActiveThreads.Tail = prev; + giFreeTickets -= caiTICKET_COUNTS[ thread->Priority ]; # if DEBUG_TRACE_TICKETS LogF("Log: CPU%i allocated %p (%i %s), (%i [-%i] tickets in pool), \n", @@ -1273,28 +1297,20 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last) #elif SCHEDULER_TYPE == SCHED_RR_PRI { int i; + thread = NULL; for( i = 0; i < MIN_PRIORITY + 1; i ++ ) { - for(thread = gaActiveThreads[i]; thread; thread = thread->Next) - { - if( thread->CurCPU == -1 ) break; - } - // If we fall onto the same queue again, special handling is - // needed - if( Last && Last->Status == THREAD_STAT_ACTIVE && i == Last->Priority ) { - tThread *savedThread = thread; - - // Find the next unscheduled thread in the list - for( thread = Last->Next; thread; thread = thread->Next ) - { - if( thread->CurCPU == -1 ) break; - } - // If we don't find anything after, just use the one - // found above. - if( !thread ) thread = savedThread; - } - // Found a thread? Schedule it! - if( thread ) break; + if( !gaActiveThreads[i].Head ) + continue ; + + thread = gaActiveThreads[i].Head; + + // Remove from head + gaActiveThreads[i].Head = thread->Next; + if(!thread->Next) + gaActiveThreads[i].Tail = NULL; + thread->Next = NULL; + break; } // Anything to do? @@ -1307,20 +1323,13 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last) } } #elif SCHEDULER_TYPE == SCHED_RR_SIM - { - // Find the next unscheduled thread in the list - for( thread = Last->Next; thread; thread = thread->Next ) - { - if( thread->CurCPU == -1 ) break; - } - // If we don't find anything after, search from the beginning - if( !thread ) - { - for(thread = gActiveThreads; thread; thread = thread->Next) - { - if( thread->CurCPU == -1 ) break; - } - } + { + // Get the next thread off the list + thread = gActiveThreads.Head; + gActiveThreads.Head = thread->Next; + if(!thread->Next) + gaActiveThreads.Tail = NULL; + thread->Next = NULL; // Anything to do? if( !thread ) { @@ -1341,352 +1350,6 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last) return thread; } -// Acquire mutex (see mutex.h for documentation) -int Mutex_Acquire(tMutex *Mutex) -{ - tThread *us = Proc_GetCurThread(); - - // Get protector - SHORTLOCK( &Mutex->Protector ); - - //Log("Mutex_Acquire: (%p)", Mutex); - - // Check if the lock is already held - if( Mutex->Owner ) { - SHORTLOCK( &glThreadListLock ); - // - Remove from active list - us = Threads_RemActive(); - us->Next = NULL; - // - Mark as sleeping - us->Status = THREAD_STAT_MUTEXSLEEP; - us->WaitPointer = Mutex; - - // - Add to waiting - if(Mutex->LastWaiting) { - Mutex->LastWaiting->Next = us; - Mutex->LastWaiting = us; - } - else { - Mutex->Waiting = us; - Mutex->LastWaiting = us; - } - - #if DEBUG_TRACE_STATE - Log("%p (%i %s) waiting on mutex %p", - us, us->TID, us->ThreadName, Mutex); - #endif - - #if 0 - { - int i = 0; - tThread *t; - for( t = Mutex->Waiting; t; t = t->Next, i++ ) - Log("[%i] (tMutex)%p->Waiting[%i] = %p (%i %s)", us->TID, Mutex, i, - t, t->TID, t->ThreadName); - } - #endif - - SHORTREL( &glThreadListLock ); - SHORTREL( &Mutex->Protector ); - while(us->Status == THREAD_STAT_MUTEXSLEEP) Threads_Yield(); - // We're only woken when we get the lock - us->WaitPointer = NULL; - } - // Ooh, let's take it! - else { - Mutex->Owner = us; - SHORTREL( &Mutex->Protector ); - } - - #if 0 - extern tMutex glPhysAlloc; - if( Mutex != &glPhysAlloc ) - LogF("Mutex %p taken by %i %p\n", Mutex, us->TID, __builtin_return_address(0)); - #endif - - return 0; -} - -// Release a mutex -void Mutex_Release(tMutex *Mutex) -{ - SHORTLOCK( &Mutex->Protector ); - //Log("Mutex_Release: (%p)", 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 - SHORTLOCK( &glThreadListLock ); - if( Mutex->Owner->Status != THREAD_STAT_ACTIVE ) - Threads_AddActive(Mutex->Owner); - SHORTREL( &glThreadListLock ); - } - else { - Mutex->Owner = NULL; - } - SHORTREL( &Mutex->Protector ); - - #if 0 - extern tMutex glPhysAlloc; - if( Mutex != &glPhysAlloc ) - LogF("Mutex %p released by %i %p\n", Mutex, Threads_GetTID(), __builtin_return_address(0)); - #endif -} - -// Check if a mutex is locked -int Mutex_IsLocked(tMutex *Mutex) -{ - return Mutex->Owner != NULL; -} - -// -// Initialise a semaphore -// -void Semaphore_Init(tSemaphore *Sem, int Value, int MaxValue, const char *Module, const char *Name) -{ - memset(Sem, 0, sizeof(tSemaphore)); - Sem->Value = Value; - Sem->ModName = Module; - Sem->Name = Name; - Sem->MaxValue = MaxValue; -} -// -// Wait for items to be avaliable -// -int Semaphore_Wait(tSemaphore *Sem, int MaxToTake) -{ - tThread *us; - int taken; - if( MaxToTake < 0 ) { - Log_Warning("Threads", "Semaphore_Wait: User bug - MaxToTake(%i) < 0, Sem=%p(%s)", - MaxToTake, Sem, Sem->Name); - } - - SHORTLOCK( &Sem->Protector ); - - // Check if there's already items avaliable - if( Sem->Value > 0 ) { - // Take what we need - if( MaxToTake && Sem->Value > MaxToTake ) - taken = MaxToTake; - else - taken = Sem->Value; - Sem->Value -= taken; - } - else - { - SHORTLOCK( &glThreadListLock ); - - // - Remove from active list - us = Threads_RemActive(); - us->Next = NULL; - // - Mark as sleeping - us->Status = THREAD_STAT_SEMAPHORESLEEP; - us->WaitPointer = Sem; - us->RetStatus = MaxToTake; // Use RetStatus as a temp variable - - // - Add to waiting - if(Sem->LastWaiting) { - Sem->LastWaiting->Next = us; - Sem->LastWaiting = us; - } - else { - Sem->Waiting = us; - Sem->LastWaiting = us; - } - - #if DEBUG_TRACE_STATE || SEMAPHORE_DEBUG - Log("%p (%i %s) waiting on semaphore %p %s:%s", - us, us->TID, us->ThreadName, - Sem, Sem->ModName, Sem->Name); - #endif - - SHORTREL( &Sem->Protector ); // Release first to make sure it is released - SHORTREL( &glThreadListLock ); - while(us->Status == THREAD_STAT_SEMAPHORESLEEP) Threads_Yield(); - // We're only woken when there's something avaliable (or a signal arrives) - us->WaitPointer = NULL; - - taken = us->RetStatus; - - // Get the lock again - SHORTLOCK( &Sem->Protector ); - } - - // While there is space, and there are thread waiting - // wake the first thread and give it what it wants (or what's left) - while( (Sem->MaxValue == 0 || Sem->Value < Sem->MaxValue) && Sem->Signaling ) - { - int given; - tThread *toWake = Sem->Signaling; - - Sem->Signaling = Sem->Signaling->Next; - // Reset ->LastWaiting to NULL if we have just removed the last waiting thread - if( Sem->Signaling == NULL ) - Sem->LastSignaling = NULL; - - // Figure out how much to give - if( toWake->RetStatus && Sem->Value + toWake->RetStatus < Sem->MaxValue ) - given = toWake->RetStatus; - else - given = Sem->MaxValue - Sem->Value; - Sem->Value -= given; - - - #if DEBUG_TRACE_STATE || SEMAPHORE_DEBUG - Log("%p (%i %s) woken by wait on %p %s:%s", - toWake, toWake->TID, toWake->ThreadName, - Sem, Sem->ModName, Sem->Name); - #endif - - // Save the number we gave to the thread's status - toWake->RetStatus = given; - - // Wake the sleeper - SHORTLOCK( &glThreadListLock ); - if( toWake->Status != THREAD_STAT_ACTIVE ) - Threads_AddActive(toWake); - SHORTREL( &glThreadListLock ); - } - SHORTREL( &Sem->Protector ); - - return taken; -} - -// -// Add items to a semaphore -// -int Semaphore_Signal(tSemaphore *Sem, int AmmountToAdd) -{ - int given; - int added; - - if( AmmountToAdd < 0 ) { - Log_Warning("Threads", "Semaphore_Signal: User bug - AmmountToAdd(%i) < 0, Sem=%p(%s)", - AmmountToAdd, Sem, Sem->Name); - } - SHORTLOCK( &Sem->Protector ); - - // Check if we have to block - if( Sem->MaxValue && Sem->Value == Sem->MaxValue ) - { - tThread *us; - #if 0 - Log_Debug("Threads", "Semaphore_Signal: IDLE Sem = %s:%s", Sem->ModName, Sem->Name); - Log_Debug("Threads", "Semaphore_Signal: Sem->Value(%i) == Sem->MaxValue(%i)", Sem->Value, Sem->MaxValue); - #endif - - SHORTLOCK( &glThreadListLock ); - // - Remove from active list - us = Threads_RemActive(); - us->Next = NULL; - // - Mark as sleeping - us->Status = THREAD_STAT_SEMAPHORESLEEP; - us->WaitPointer = Sem; - us->RetStatus = AmmountToAdd; // Use RetStatus as a temp variable - - // - Add to waiting - if(Sem->LastSignaling) { - Sem->LastSignaling->Next = us; - Sem->LastSignaling = us; - } - else { - Sem->Signaling = us; - Sem->LastSignaling = us; - } - - #if DEBUG_TRACE_STATE || SEMAPHORE_DEBUG - Log("%p (%i %s) signaling semaphore %p %s:%s", - us, us->TID, us->ThreadName, - Sem, Sem->ModName, Sem->Name); - #endif - - SHORTREL( &glThreadListLock ); - SHORTREL( &Sem->Protector ); - while(us->Status == THREAD_STAT_SEMAPHORESLEEP) Threads_Yield(); - // We're only woken when there's something avaliable - us->WaitPointer = NULL; - - added = us->RetStatus; - - // Get the lock again - SHORTLOCK( &Sem->Protector ); - } - // Non blocking - else - { - // Figure out how much we need to take off - if( Sem->MaxValue && Sem->Value + AmmountToAdd > Sem->MaxValue) - added = Sem->MaxValue - Sem->Value; - else - added = AmmountToAdd; - Sem->Value += added; - } - - // While there are items avaliable, and there are thread waiting - // wake the first thread and give it what it wants (or what's left) - while( Sem->Value && Sem->Waiting ) - { - tThread *toWake = Sem->Waiting; - - // Remove thread from list (double ended, so clear LastWaiting if needed) - Sem->Waiting = Sem->Waiting->Next; - if( Sem->Waiting == NULL ) - Sem->LastWaiting = NULL; - - // Figure out how much to give to woken thread - // - Requested count is stored in ->RetStatus - if( toWake->RetStatus && Sem->Value > toWake->RetStatus ) - given = toWake->RetStatus; - else - given = Sem->Value; - Sem->Value -= given; - - // Save the number we gave to the thread's status - toWake->RetStatus = given; - - if(toWake->bInstrTrace) - Log("%s(%i) given %i from %p", toWake->ThreadName, toWake->TID, given, Sem); - #if DEBUG_TRACE_STATE || SEMAPHORE_DEBUG - Log("%p (%i %s) woken by signal on %p %s:%s", - toWake, toWake->TID, toWake->ThreadName, - Sem, Sem->ModName, Sem->Name); - #endif - - // Wake the sleeper -// SHORTLOCK( &glThreadListLock ); - if( toWake->Status != THREAD_STAT_ACTIVE ) - Threads_AddActive(toWake); - else - Warning("Thread %p (%i %s) is already awake", toWake, toWake->TID, toWake->ThreadName); -// SHORTREL( &glThreadListLock ); - } - SHORTREL( &Sem->Protector ); - - return added; -} - -// -// Get the current value of a semaphore -// -int Semaphore_GetValue(tSemaphore *Sem) -{ - return Sem->Value; -} - // === EXPORTS === EXPORT(Threads_GetUID); EXPORT(Threads_GetGID); -EXPORT(Mutex_Acquire); -EXPORT(Mutex_Release); -EXPORT(Mutex_IsLocked); -EXPORT(Semaphore_Init); -EXPORT(Semaphore_Wait); -EXPORT(Semaphore_Signal);