X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Kernel%2Fthreads.c;h=956eede82281ff1e3153bc6da1d090c22943d478;hb=a2495c6ea4f4cab16b5d339ae511428e92e89e73;hp=863b5e49d6fe9b8fa5c3b9779fd7ed456cbfaa9d;hpb=a4d4d4e851d88dcc0f421e35c00726d860d3d708;p=tpg%2Facess2.git diff --git a/Kernel/threads.c b/Kernel/threads.c index 863b5e49..956eede8 100644 --- a/Kernel/threads.c +++ b/Kernel/threads.c @@ -5,38 +5,54 @@ */ #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) +// --- Schedulers --- +#define SCHED_UNDEF 0 +#define SCHED_LOTTERY 1 // Lottery scheduler +#define SCHED_RR_SIM 2 // Single Queue Round Robin +#define SCHED_RR_PRI 3 // Multi Queue Round Robin +// Set scheduler type +#define SCHEDULER_TYPE SCHED_RR_PRI + // === CONSTANTS === -#define DEFAULT_QUANTUM 10 -#define DEFAULT_TICKETS 5 -#define MAX_TICKETS 10 -const enum eConfigTypes cCONFIG_TYPES[] = { - CFGT_HEAPSTR, // e.g. CFG_VFS_CWD - CFGT_INT, // e.g. CFG_VFS_MAXFILES - CFGT_NULL -}; +#define DEFAULT_QUANTUM 5 +#define DEFAULT_PRIORITY 5 +#define MIN_PRIORITY 10 // === IMPORTS === -extern void ArchThreads_Init(void); -extern void Proc_Start(void); -extern tThread *Proc_GetCurThread(void); -extern int Proc_Clone(Uint *Err, Uint Flags); -extern void Proc_CallFaultHandler(tThread *Thread); + +// === TYPE === +typedef struct +{ + tThread *Head; + tThread *Tail; +} tThreadList; // === PROTOTYPES === void Threads_Init(void); - int Threads_SetName(char *NewName); -char *Threads_GetName(int ID); -void Threads_SetTickets(tThread *Thread, int Num); +#if 0 +void Threads_Delete(tThread *Thread); + int Threads_SetName(const char *NewName); +#endif +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); -void Threads_AddToDelete(tThread *Thread); -tThread *Threads_int_GetPrev(tThread **List, tThread *Thread); +#endif +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); void Threads_Yield(void); @@ -44,40 +60,56 @@ void Threads_Sleep(void); int Threads_Wake(tThread *Thread); void Threads_AddActive(tThread *Thread); tThread *Threads_RemActive(void); +#endif +void Threads_ToggleTrace(int TID); +void Threads_Fault(int Num); +void Threads_SegFault(tVAddr Addr); +#if 0 int Threads_GetPID(void); int Threads_GetTID(void); tUID Threads_GetUID(void); - int Threads_SetUID(Uint *Errno, tUID ID); tGID Threads_GetGID(void); + int Threads_SetUID(Uint *Errno, tUID ID); int Threads_SetGID(Uint *Errno, tUID ID); +#endif void Threads_Dump(void); -void Mutex_Acquire(tMutex *Mutex); -void Mutex_Release(tMutex *Mutex); - int Mutex_IsLocked(tMutex *Mutex); +void Threads_DumpActive(void); // === GLOBALS === // -- Core Thread -- +struct sProcess gProcessZero = { + }; // Only used for the core kernel tThread gThreadZero = { - Status: THREAD_STAT_ACTIVE, // Status - ThreadName: "ThreadZero", // Name - Quantum: DEFAULT_QUANTUM, // Default Quantum - Remaining: DEFAULT_QUANTUM, // Current Quantum - NumTickets: DEFAULT_TICKETS // Number of tickets + .Status = THREAD_STAT_ACTIVE, // Status + .ThreadName = (char*)"ThreadZero", // Name + .Quantum = DEFAULT_QUANTUM, // Default Quantum + .Remaining = DEFAULT_QUANTUM, // Current Quantum + .Priority = DEFAULT_PRIORITY // Number of tickets }; // -- Processes -- // --- 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 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; +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 +tThreadList gActiveThreads; // Currently Running Threads +#elif SCHEDULER_TYPE == SCHED_RR_SIM +tThreadList gActiveThreads; // Currently Running Threads +#elif SCHEDULER_TYPE == SCHED_RR_PRI +tThreadList gaActiveThreads[MIN_PRIORITY+1]; // Active threads for each priority level +#else +# error "Unkown scheduler type" +#endif // === CODE === /** @@ -88,31 +120,86 @@ void Threads_Init(void) { ArchThreads_Init(); + Log_Debug("Threads", "Offsets of tThread"); + Log_Debug("Threads", ".Priority = %i", offsetof(tThread, Priority)); + Log_Debug("Threads", ".KernelStack = %i", offsetof(tThread, KernelStack)); + // Create Initial Task - gActiveThreads = &gThreadZero; +// #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; - //giFreeTickets = gThreadZero.NumTickets; // Not needed, as ThreadZero is scheduled 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(char *NewName) + * \fn void Threads_SetName(const char *NewName) * \brief Sets the current thread's name * \param NewName New name for the thread * \return Boolean Failure */ -int Threads_SetName(char *NewName) +int Threads_SetName(const char *NewName) { tThread *cur = Proc_GetCurThread(); char *oldname = cur->ThreadName; - cur->ThreadName = NULL; + // NOTE: There is a possibility of non-thread safety here + // A thread could read the current name pointer before it is zeroed - if( IsHeap(oldname) ) free( oldname ); + cur->ThreadName = NULL; + if( IsHeap(oldname) ) free( oldname ); cur->ThreadName = strdup(NewName); + + Log_Debug("Threads", "Thread renamed to '%s'", NewName); + return 0; } @@ -128,75 +215,122 @@ 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; } /** - * \fn void Threads_SetTickets(tThread *Thread, int Num) - * \brief Sets the 'priority' of a task + * \fn void Threads_SetPriority(tThread *Thread, int Pri) + * \brief Sets the priority of a task * \param Thread Thread to update ticket count (NULL means current thread) - * \param Num New ticket count (must be >= 0, clipped to \a MAX_TICKETS) + * \param Pri New priority */ -void Threads_SetTickets(tThread *Thread, int Num) +void Threads_SetPriority(tThread *Thread, int Pri) { // Get current thread if(Thread == NULL) Thread = Proc_GetCurThread(); // Bounds checking - if(Num < 0) return; - if(Num > MAX_TICKETS) Num = MAX_TICKETS; + // - If < 0, set to lowest priority + // - Minumum priority is actualy a high number, 0 is highest + if(Pri < 0) Pri = MIN_PRIORITY; + if(Pri > MIN_PRIORITY) Pri = MIN_PRIORITY; + // Do we actually have to do anything? + if( Pri == Thread->Priority ) return; + + #if SCHEDULER_TYPE == SCHED_RR_PRI + 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() ) { + if( Thread != Proc_GetCurThread() ) + { SHORTLOCK( &glThreadListLock ); - giFreeTickets -= Thread->NumTickets - Num; - Thread->NumTickets = Num; - #if DEBUG_TRACE_TICKETS - Log("Threads_SetTickets: new giFreeTickets = %i", giFreeTickets); + + #if SCHEDULER_TYPE == SCHED_LOTTERY + giFreeTickets -= caiTICKET_COUNTS[Thread->Priority] - caiTICKET_COUNTS[Pri]; + # if DEBUG_TRACE_TICKETS + Log("Threads_SetTickets: new giFreeTickets = %i [-%i+%i]", + giFreeTickets, + caiTICKET_COUNTS[Thread->Priority], caiTICKET_COUNTS[Pri]); + # endif #endif + Thread->Priority = Pri; SHORTREL( &glThreadListLock ); } else - Thread->NumTickets = Num; + Thread->Priority = Pri; + #endif + + #if DEBUG_TRACE_STATE + Log("Threads_SetPriority: %p(%i %s) pri set %i", + Thread, Thread->TID, Thread->ThreadName, + Pri); + #endif } /** - * \fn tThread *Threads_CloneTCB(Uint *Err, Uint Flags) * \brief Clone the TCB of the current thread - * \param Err Error pointer * \param Flags Flags for something... (What is this for?) */ -tThread *Threads_CloneTCB(Uint *Err, Uint Flags) +tThread *Threads_CloneTCB(Uint Flags) { tThread *cur, *new; - int i; cur = Proc_GetCurThread(); + // Allocate and duplicate new = malloc(sizeof(tThread)); - if(new == NULL) { - *Err = -ENOMEM; - return NULL; - } + if(new == NULL) { errno = -ENOMEM; return NULL; } memcpy(new, cur, sizeof(tThread)); 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 new->TID = giNextTID++; new->Parent = cur; + new->bInstrTrace = 0; // Clone Name 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; @@ -204,32 +338,18 @@ tThread *Threads_CloneTCB(Uint *Err, Uint Flags) // Set State new->Remaining = new->Quantum = cur->Quantum; - new->NumTickets = cur->NumTickets; + 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 new->GlobalNext = gAllThreads; + gAllThreads->GlobalPrev = new; gAllThreads = new; SHORTREL( &glThreadListLock ); @@ -237,23 +357,59 @@ 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 + * \brief Clone the TCB of the kernel thread */ -Uint *Threads_GetCfgPtr(int ID) +tThread *Threads_CloneThreadZero(void) { - if(ID < 0 || ID >= NUM_CFG_ENTRIES) { - Warning("Threads_GetCfgPtr: Index %i is out of bounds", ID); + tThread *new; + + // Allocate and duplicate + new = malloc(sizeof(tThread)); + if(new == NULL) { return NULL; } + memcpy(new, &gThreadZero, sizeof(tThread)); + + new->Process->nThreads ++; + + new->CurCPU = -1; + new->Next = NULL; + memset( &new->IsLocked, 0, sizeof(new->IsLocked)); + new->Status = THREAD_STAT_PREINIT; + new->RetStatus = 0; + + // Get Thread ID + new->TID = giNextTID++; + new->Parent = 0; - return &Proc_GetCurThread()->Config[ID]; + // Clone Name + new->ThreadName = NULL; + + // Messages are not inherited + new->Messages = NULL; + new->LastMessage = NULL; + + // Set State + new->Remaining = new->Quantum = DEFAULT_QUANTUM; + new->Priority = DEFAULT_PRIORITY; + new->bInstrTrace = 0; + + // Set Signal Handlers + new->CurFaultNum = 0; + new->FaultHandler = 0; + + // Maintain a global list of threads + SHORTLOCK( &glThreadListLock ); + new->GlobalPrev = NULL; // Protect against bugs + new->GlobalNext = gAllThreads; + gAllThreads->GlobalPrev = new; + gAllThreads = new; + SHORTREL( &glThreadListLock ); + + return new; } /** - * \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 @@ -282,20 +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; - 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); - } + // 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); } - 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) { @@ -305,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; @@ -318,7 +471,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,52 +494,51 @@ 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 - if(gDeleteThreads) { - Thread->Next = gDeleteThreads; - gDeleteThreads = Thread; - } else { - Thread->Next = NULL; - gDeleteThreads = 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(tThreadList *List, tThread *Thread) { - tThread *ret; - // First Entry - if(*List == Thread) { - return (tThread*)List; + tThread *ret, *prev = NULL; + + for(ret = List->Head; + 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->Head = 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; + 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; } /** - * \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 +549,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,19 +562,20 @@ void Threads_Exit(int TID, int Status) */ void Threads_Kill(tThread *Thread, int Status) { - tThread *prev; tMsg *msg; + int isCurThread = Thread == Proc_GetCurThread(); - // TODO: Kill all children - #if 0 + // TODO: Disown all children? + #if 1 { tThread *child; - for(child = gActiveThreads; + // TODO: I should keep a .Children list + for(child = gAllThreads; child; - child = child->Next) + child = child->GlobalNext) { - if(child->PTID == Thread->TID) - Threads_Kill(child, -1); + if(child->Parent == Thread) + child->Parent = &gThreadZero; } } #endif @@ -433,18 +585,6 @@ void Threads_Kill(tThread *Thread, int Status) // Lock thread (stop us recieving messages) SHORTLOCK( &Thread->IsLocked ); - // Lock thread list - SHORTLOCK( &glThreadListLock ); - - // Get previous thread on list - prev = Threads_int_GetPrev( &gActiveThreads, Thread ); - if(!prev) { - Warning("Proc_Exit - Current thread is not on the active queue"); - SHORTREL( &glThreadListLock ); - SHORTREL( &Thread->IsLocked ); - return; - } - // Clear Message Queue while( Thread->Messages ) { @@ -453,45 +593,96 @@ void Threads_Kill(tThread *Thread, int Status) Thread->Messages = msg; } - Thread->Remaining = 0; // Clear Remaining Quantum - Thread->Quantum = 0; // Clear Quantum to indicate dead thread - prev->Next = Thread->Next; // Remove from active + // Lock thread list + SHORTLOCK( &glThreadListLock ); - giNumActiveThreads --; - if( Thread != Proc_GetCurThread() ) - giFreeTickets -= Thread->NumTickets; + switch(Thread->Status) + { + case THREAD_STAT_PREINIT: // Only on main list + break; - // Save exit status - Thread->RetStatus = Status; + // Currently active thread + case THREAD_STAT_ACTIVE: + if( Thread != Proc_GetCurThread() ) + { + #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 + giFreeTickets -= caiTICKET_COUNTS[ Thread->Priority ]; + #endif + } + // 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: + if( !Threads_int_DelFromQueue( &gSleepingThreads, Thread ) ) + { + Log_Warning("Threads", + "Threads_Kill - Thread %p(%i,%s) marked as sleeping, but not on list", + Thread, Thread->TID, Thread->ThreadName + ); + } + break; - // Don't Zombie if we are being killed as part of a tree - if(Status == -1) - { - Thread->Status = THREAD_STAT_DEAD; - Threads_AddToDelete( Thread ); - } else { - Thread->Status = THREAD_STAT_ZOMBIE; - // Wake parent - Threads_Wake( Thread->Parent ); - } + // 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); + SHORTREL( &glThreadListLock ); + SHORTREL( &Thread->IsLocked ); + return ; - Log("Thread %i went *hurk* (%i)", Thread->TID, Thread->Status); + default: + Log_Warning("Threads", "Threads_Kill - BUG Un-checked status (%i)", + Thread->Status); + break; + } - // Release spinlocks + // Save exit status + Thread->RetStatus = Status; + 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); - if(Status != -1) HALT(); + // And, reschedule + if(isCurThread) + { + for( ;; ) + Proc_Reschedule(); + } } /** - * \fn void Threads_Yield(void) * \brief Yield remainder of the current thread's timeslice */ void Threads_Yield(void) { - Proc_GetCurThread()->Remaining = 0; - HALT(); +// Log("Threads_Yield: by %p", __builtin_return_address(0)); + Proc_Reschedule(); } /** @@ -513,27 +704,28 @@ void Threads_Sleep(void) // Remove us from running queue Threads_RemActive(); - - // Add to Sleeping List (at the top) - cur->Next = gSleepingThreads; - gSleepingThreads = cur; - // Mark thread as sleeping cur->Status = THREAD_STAT_SLEEPING; + // Add to Sleeping List (at the top) + Threads_int_AddToList( &gSleepingThreads, cur ); + #if DEBUG_TRACE_STATE Log("Threads_Sleep: %p (%i %s) sleeping", cur, cur->TID, cur->ThreadName); #endif // Release Spinlock SHORTREL( &glThreadListLock ); - - while(cur->Status != THREAD_STAT_ACTIVE) HALT(); + + while(cur->Status != THREAD_STAT_ACTIVE) { + Proc_Reschedule(); + if( cur->Status != THREAD_STAT_ACTIVE ) + Log("%i - Huh? why am I up? zzzz...", cur->TID); + } } /** - * \fn int Threads_Wake( tThread *Thread ) * \brief Wakes a sleeping/waiting thread up * \param Thread Thread to wake * \return Boolean Failure (Returns ERRNO) @@ -541,50 +733,87 @@ void Threads_Sleep(void) */ int Threads_Wake(tThread *Thread) { - tThread *prev; - if(!Thread) return -EINVAL; switch(Thread->Status) { case THREAD_STAT_ACTIVE: - Log("Thread_Wake: Waking awake thread (%i)", Thread->TID); + Log("Threads_Wake - Waking awake thread (%i)", Thread->TID); 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 + SHORTREL( &glThreadListLock ); + 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 return -EOK; + case THREAD_STAT_SEMAPHORESLEEP: { + tSemaphore *sem; + tThread *th, *prev=NULL; + + sem = Thread->WaitPointer; + + SHORTLOCK( &sem->Protector ); + + // Remove from sleeping queue + for( th = sem->Waiting; th; prev = th, th = th->Next ) + if( th == Thread ) break; + if( th ) + { + if(prev) + prev->Next = Thread->Next; + else + sem->Waiting = Thread->Next; + if(sem->LastWaiting == Thread) + sem->LastWaiting = prev; + } + else + { + prev = NULL; + for( th = sem->Signaling; th; prev = th, th = th->Next ) + if( th == Thread ) break; + if( !th ) { + Log_Warning("Threads", "Thread %p(%i %s) is not on semaphore %p(%s:%s)", + Thread, Thread->TID, Thread->ThreadName, + sem, sem->ModName, sem->Name); + return -EINTERNAL; + } + + if(prev) + prev->Next = Thread->Next; + else + sem->Signaling = Thread->Next; + if(sem->LastSignaling == Thread) + sem->LastSignaling = prev; + } + + Thread->RetStatus = 0; // It didn't get anything + Threads_AddActive( Thread ); + + #if DEBUG_TRACE_STATE + Log("Threads_Sleep: %p(%i %s) woken from semaphore", Thread, Thread->TID, Thread->ThreadName); + #endif + SHORTREL( &sem->Protector ); + } return -EOK; + case THREAD_STAT_WAITING: - Warning("Thread_Wake - Waiting threads are not currently supported"); + Warning("Threads_Wake - Waiting threads are not currently supported"); return -ENOTIMPL; case THREAD_STAT_DEAD: - Warning("Thread_Wake - Attempt to wake dead thread (%i)", Thread->TID); + Warning("Threads_Wake - Attempt to wake dead thread (%i)", Thread->TID); return -ENOTIMPL; default: - Warning("Thread_Wake - Unknown process status (%i)\n", Thread->Status); + Warning("Threads_Wake - Unknown process status (%i)\n", Thread->Status); return -EINTERNAL; } } @@ -600,47 +829,115 @@ 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; } +void Threads_ToggleTrace(int TID) +{ + tThread *thread = Threads_GetThread(TID); + if(!thread) return ; + thread->bInstrTrace = !thread->bInstrTrace; +} + /** - * \fn void Threads_AddActive(tThread *Thread) * \brief Adds a thread to the active queue */ void Threads_AddActive(tThread *Thread) { SHORTLOCK( &glThreadListLock ); + + if( Thread->Status == THREAD_STAT_ACTIVE ) { + tThread *cur = Proc_GetCurThread(); + Log_Warning("Threads", "WTF, %p CPU%i %p (%i %s) is adding %p (%i %s) when it is active", + __builtin_return_address(0), + GetCPUNum(), cur, cur->TID, cur->ThreadName, Thread, Thread->TID, Thread->ThreadName); + SHORTREL( &glThreadListLock ); + return ; + } + + // Set state + Thread->Status = THREAD_STAT_ACTIVE; +// Thread->CurCPU = -1; // Add to active list - Thread->Next = gActiveThreads; - gActiveThreads = Thread; + { + #if SCHEDULER_TYPE == SCHED_RR_PRI + tThreadList *list = &gaActiveThreads[Thread->Priority]; + #else + tThreadList *list = &gActiveThreads; + #endif + Threads_int_AddToList( list, Thread ); + } + // Update bookkeeping giNumActiveThreads ++; - giFreeTickets += Thread->NumTickets; - #if DEBUG_TRACE_TICKETS - Log("Threads_AddActive: new giFreeTickets = %i", giFreeTickets); + + #if SCHEDULER_TYPE == SCHED_LOTTERY + { + int delta; + // Only change the ticket count if the thread is un-scheduled + if(Thread->CurCPU != -1) + delta = 0; + else + delta = caiTICKET_COUNTS[ Thread->Priority ]; + + giFreeTickets += delta; + # if DEBUG_TRACE_TICKETS + Log("CPU%i %p (%i %s) added, new giFreeTickets = %i [+%i]", + GetCPUNum(), Thread, Thread->TID, Thread->ThreadName, + giFreeTickets, delta + ); + # endif + } #endif + SHORTREL( &glThreadListLock ); } /** * \brief Removes the current thread from the active queue - * \warning This should ONLY be called with task switches disabled + * \warning This should ONLY be called with the lock held * \return Current thread pointer */ tThread *Threads_RemActive(void) { + #if 0 tThread *ret = Proc_GetCurThread(); - tThread *prev = Threads_int_GetPrev(&gActiveThreads, ret); - if(!prev) return NULL; + + if( !IS_LOCKED(&glThreadListLock) ) { + Log_KernelPanic("Threads", "Threads_RemActive called without lock held"); + return NULL; + } + + // Delete from active queue + #if SCHEDULER_TYPE == SCHED_RR_PRI + if( !Threads_int_DelFromQueue(&gaActiveThreads[ret->Priority], ret) ) + #else + if( !Threads_int_DelFromQueue(&gActiveThreads, ret) ) + #endif + { + Log_Warning("Threads", "Current thread %p(%i %s) is not on active queue", + ret, ret->TID, ret->ThreadName + ); + return NULL; + } + + ret->Next = NULL; ret->Remaining = 0; - ret->CurCPU = -1; - prev->Next = ret->Next; + giNumActiveThreads --; + // no need to decrement tickets, scheduler did it for us + + #if SCHEDULER_TYPE == SCHED_LOTTERY && DEBUG_TRACE_TICKETS + Log("CPU%i %p (%i %s) removed, giFreeTickets = %i [nc]", + GetCPUNum(), ret, ret->TID, ret->ThreadName, giFreeTickets); + #endif + return ret; + #else + return Proc_GetCurThread(); + #endif } /** @@ -661,8 +958,6 @@ void Threads_Fault(int Num) { tThread *thread = Proc_GetCurThread(); - Log_Log("Threads", "Threads_Fault: thread = %p", thread); - if(!thread) return ; Log_Log("Threads", "Threads_Fault: thread->FaultHandler = %p", thread->FaultHandler); @@ -681,6 +976,7 @@ void Threads_Fault(int Num) // Double Fault? Oh, F**k if(thread->CurFaultNum != 0) { + Log_Warning("Threads", "Threads_Fault: Double fault on %i", thread->TID); Threads_Kill(thread, -1); // For now, just kill HALT(); } @@ -690,10 +986,24 @@ void Threads_Fault(int Num) Proc_CallFaultHandler(thread); } +/** + * \fn void Threads_SegFault(tVAddr Addr) + * \brief Called when a Segment Fault occurs + */ +void Threads_SegFault(tVAddr Addr) +{ + tThread *cur = Proc_GetCurThread(); + cur->bInstrTrace = 0; + Log_Warning("Threads", "Thread #%i committed a segfault at address %p", cur->TID, Addr); + MM_DumpTables(0, USER_MAX); + Threads_Fault( 1 ); + //Threads_Exit( 0, -1 ); +} + // --- Process Structure Access Functions --- tPID Threads_GetPID(void) { - return Proc_GetCurThread()->TGID; + return Proc_GetCurThread()->Process->PID; } tTID Threads_GetTID(void) { @@ -701,69 +1011,140 @@ 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) - * \brief Dums a list of currently running threads */ -void Threads_Dump(void) +void Threads_DumpActive(void) { tThread *thread; + tThreadList *list; + #if SCHEDULER_TYPE == SCHED_RR_PRI + int i; + #endif + + Log("Active Threads: (%i reported)", giNumActiveThreads); - Log("Active Threads:"); - for(thread=gActiveThreads;thread;thread=thread->Next) + #if SCHEDULER_TYPE == SCHED_RR_PRI + for( i = 0; i < MIN_PRIORITY+1; i++ ) { - 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); + list = &gaActiveThreads[i]; + #else + list = &gActiveThreads; + #endif + for(thread=list->Head;thread;thread=thread->Next) + { + Log(" %p %i (%i) - %s (CPU %i)", + 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(" Priority %i, Quantum %i", thread->Priority, thread->Quantum); + Log(" KStack 0x%x", thread->KernelStack); + if( thread->bInstrTrace ) + Log(" Tracing Enabled"); + Proc_DumpThreadCPUState(thread); + } + + #if SCHEDULER_TYPE == SCHED_RR_PRI } + #endif +} + +/** + * \fn void Threads_Dump(void) + * \brief Dumps a list of currently running threads + */ +void Threads_Dump(void) +{ + tThread *thread; + + Log("--- Thread Dump ---"); + Threads_DumpActive(); Log("All Threads:"); for(thread=gAllThreads;thread;thread=thread->GlobalNext) { - Log(" %i (%i) - %s (CPU %i)", - thread->TID, thread->TGID, thread->ThreadName, thread->CurCPU); - Log(" State %i", thread->Status); - Log(" %i Tickets, Quantum %i", thread->NumTickets, thread->Quantum); + Log(" %p %i (%i) - %s (CPU %i)", + thread, thread->TID, thread->Process->PID, thread->ThreadName, thread->CurCPU); + Log(" State %i (%s)", thread->Status, casTHREAD_STAT[thread->Status]); + switch(thread->Status) + { + case THREAD_STAT_MUTEXSLEEP: + Log(" Mutex Pointer: %p", thread->WaitPointer); + break; + case THREAD_STAT_SEMAPHORESLEEP: + Log(" Semaphore Pointer: %p", thread->WaitPointer); + Log(" Semaphore Name: %s:%s", + ((tSemaphore*)thread->WaitPointer)->ModName, + ((tSemaphore*)thread->WaitPointer)->Name + ); + 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); + if( thread->bInstrTrace ) + Log(" Tracing Enabled"); + Proc_DumpThreadCPUState(thread); } } /** - * \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 @@ -771,33 +1152,21 @@ void Threads_Dump(void) tThread *Threads_GetNextToRun(int CPU, tThread *Last) { tThread *thread; - int ticket; - 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 ); - // Clear Delete Queue - // - I should probably put this in a worker thread to avoid calling free() in the scheduler - while(gDeleteThreads) - { - thread = gDeleteThreads->Next; - if( IS_LOCKED(&gDeleteThreads->IsLocked) ) { // Only free if structure is unused - // Set to dead - gDeleteThreads->Status = THREAD_STAT_DEAD; - // 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; + // No active threads, just take a nap if(giNumActiveThreads == 0) { SHORTREL( &glThreadListLock ); @@ -806,183 +1175,181 @@ 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 ) { - giFreeTickets += Last->NumTickets; - #if DEBUG_TRACE_TICKETS - LogF(" CPU %i released %p (%i %s) into the pool (%i tickets in pool)\n", - CPU, Last, Last->TID, Last->ThreadName, giFreeTickets); + tThreadList *list; + #if SCHEDULER_TYPE == SCHED_LOTTERY + giFreeTickets += caiTICKET_COUNTS[ Last->Priority ]; + # if DEBUG_TRACE_TICKETS + LogF("Log: CPU%i released %p (%i %s) into the pool (%i [+%i] tickets in pool)\n", + CPU, Last, Last->TID, Last->ThreadName, giFreeTickets, + 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 DEBUG_TRACE_TICKETS + #if SCHEDULER_TYPE == SCHED_LOTTERY && DEBUG_TRACE_TICKETS else - LogF(" %p (%s)->Status = %i (Released)\n", Last, Last->ThreadName, Last->Status); + LogF("Log: CPU%i released %p (%i %s)->Status = %i (Released,not in pool)\n", + CPU, Last, Last->TID, Last->ThreadName, Last->Status); #endif Last->CurCPU = -1; } - #if 1 - number = 0; - for(thread = gActiveThreads; thread; thread = thread->Next) { - if(thread->CurCPU >= 0) continue; - number += thread->NumTickets; - } - if(number != giFreeTickets) { - Panic("Bookkeeping fail (giFreeTickets(%i) != number(%i)) - CPU%i", - giFreeTickets, number, CPU); - } - #endif - - // No free tickets (all tasks delegated to cores) - if( giFreeTickets == 0 ) { - SHORTREL(&glThreadListLock); - return NULL; + // --- + // Lottery Scheduler + // --- + #if SCHEDULER_TYPE == SCHED_LOTTERY + { + int ticket, number; + # if 1 + number = 0; + 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); + if(thread->Next == thread) { + Panic("Bookkeeping fail - %p %i(%s) loops back on itself", + thread, thread->TID, thread->ThreadName, thread->Status); + } + number += caiTICKET_COUNTS[ thread->Priority ]; + } + if(number != giFreeTickets) { + Panic("Bookkeeping fail (giFreeTickets(%i) != number(%i)) - CPU%i", + giFreeTickets, number, CPU); + } + # endif + + // No free tickets (all tasks delegated to cores) + if( giFreeTickets == 0 ) { + SHORTREL(&glThreadListLock); + return NULL; + } + + // Get the ticket number + ticket = number = rand() % giFreeTickets; + + // Find the next thread + for(thread = gActiveThreads.Head; thread; prev = thread, thread = thread->Next ) + { + if( caiTICKET_COUNTS[ thread->Priority ] > number) break; + number -= caiTICKET_COUNTS[ thread->Priority ]; + } + + // If we didn't find a thread, something went wrong + if(thread == NULL) + { + number = 0; + for(thread=gActiveThreads;thread;thread=thread->Next) { + if(thread->CurCPU >= 0) continue; + number += caiTICKET_COUNTS[ thread->Priority ]; + } + 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", + CPU, thread, thread->TID, thread->ThreadName, + giFreeTickets, caiTICKET_COUNTS[ thread->Priority ]); + # endif } - // Get the ticket number - ticket = number = rand() % giFreeTickets; - - // Find the next thread - for(thread=gActiveThreads;thread;thread=thread->Next) + // --- + // Priority based round robin scheduler + // --- + #elif SCHEDULER_TYPE == SCHED_RR_PRI { - if(thread->CurCPU >= 0) continue; - if(thread->NumTickets > number) break; - number -= thread->NumTickets; + int i; + thread = NULL; + for( i = 0; i < MIN_PRIORITY + 1; i ++ ) + { + 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? + if( !thread ) { + SHORTREL(&glThreadListLock); + return NULL; + } + if( thread->Status != THREAD_STAT_ACTIVE ) { + LogF("Oops, Thread %i (%s) is not active\n", thread->TID, thread->ThreadName); + } } - // Error Check - if(thread == NULL) + #elif SCHEDULER_TYPE == SCHED_RR_SIM { - number = 0; - for(thread=gActiveThreads;thread;thread=thread->Next) { - if(thread->CurCPU >= 0) continue; - number += thread->NumTickets; + // 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 ) { + SHORTREL(&glThreadListLock); + return NULL; } - Panic("Bookeeping Failed - giFreeTickets(%i) > true count (%i)", - giFreeTickets, number); } - #if DEBUG_TRACE_TICKETS - LogF(" CPU%i giFreeTickets = %i\n", CPU, giFreeTickets); + #else + # error "Unimplemented scheduling algorithm" #endif // Make the new thread non-schedulable - giFreeTickets -= thread->NumTickets; thread->CurCPU = CPU; - - //Threads_Dump(); - #if DEBUG_TRACE_TICKETS - LogF(" CPU%i giFreeTickets = %i, giving %p (%i %s CPU=%i)\n", - CPU, giFreeTickets, thread, thread->TID, thread->ThreadName, thread->CurCPU); - #endif + thread->Remaining = thread->Quantum; SHORTREL( &glThreadListLock ); return thread; } -/** - * \fn void Threads_SegFault(tVAddr Addr) - * \brief Called when a Segment Fault occurs - */ -void Threads_SegFault(tVAddr Addr) -{ - Warning("Thread #%i committed a segfault at address %p", Proc_GetCurThread()->TID, Addr); - Threads_Fault( 1 ); - //Threads_Exit( 0, -1 ); -} - -/** - * \brief Acquire a heavy mutex - * \param Mutex Mutex to acquire - * - * This type of mutex checks if the mutex is avaliable, and acquires it - * if it is. Otherwise, the current thread is added to the mutex's wait - * queue and the thread suspends. When the holder of the mutex completes, - * the oldest thread (top thread) on the queue is given the lock and - * restarted. - */ -void 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 - Threads_RemActive(); - // - Mark as sleeping - us->Status = THREAD_STAT_OFFSLEEP; - - // - Add to waiting - if(Mutex->LastWaiting) { - Mutex->LastWaiting->Next = us; - Mutex->LastWaiting = us; - } - else { - Mutex->Waiting = us; - Mutex->LastWaiting = us; - } - SHORTREL( &glThreadListLock ); - SHORTREL( &Mutex->Protector ); - while(us->Status == THREAD_STAT_OFFSLEEP) Threads_Yield(); - // We're only woken when we get the lock - } - // Ooh, let's take it! - else { - Mutex->Owner = us; - SHORTREL( &Mutex->Protector ); - } -} - -/** - * \brief Release a held mutex - * \param Mutex Mutex to release - */ -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! - // Wake new owner - Mutex->Owner->Status = THREAD_STAT_ACTIVE; - Threads_AddActive(Mutex->Owner); - //Log("Mutex %p Woke %p", Mutex, Mutex->Owner); - } - else { - Mutex->Owner = NULL; - } - SHORTREL( &Mutex->Protector ); -} - -/** - * \brief Is this mutex locked? - * \param Mutex Mutex pointer - */ -int Mutex_IsLocked(tMutex *Mutex) -{ - return Mutex->Owner != NULL; -} - // === EXPORTS === EXPORT(Threads_GetUID); -EXPORT(Mutex_Acquire); -EXPORT(Mutex_Release); -EXPORT(Mutex_IsLocked); +EXPORT(Threads_GetGID);