X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Kernel%2Fthreads.c;h=610f7b5d3735e92271954f015d2b190bb27732e2;hb=2a05bcd81312a2885f824dac79e82c01a6e60c6c;hp=07653853f522f3e332f1e383d9cbd28a0d6ce92d;hpb=0f2a3f55fd68cb4edfd6f29e35b658c047152b20;p=tpg%2Facess2.git diff --git a/Kernel/threads.c b/Kernel/threads.c index 07653853..610f7b5d 100644 --- a/Kernel/threads.c +++ b/Kernel/threads.c @@ -3,70 +3,77 @@ * threads.c * - Common Thread Control */ -#include +#include #include +#include + +#define DEBUG_TRACE_TICKETS 0 // Trace ticket counts +#define DEBUG_TRACE_STATE 0 // Trace state changes (sleep/wake) // === 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 +}; // === IMPORTS === -extern void ArchThreads_Init(); -extern void Proc_Start(); -extern tThread *Proc_GetCurThread(); +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); // === PROTOTYPES === -void Threads_Init(); -void Threads_SetName(char *NewName); -void Threads_SetTickets(int Num); +void Threads_Init(void); + int Threads_SetName(char *NewName); +char *Threads_GetName(int ID); +void Threads_SetTickets(tThread *Thread, int Num); +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); void Threads_Exit(int TID, int Status); void Threads_Kill(tThread *Thread, int Status); -void Threads_Yield(); -void Threads_Sleep(); -void Threads_Wake(tThread *Thread); +void Threads_Yield(void); +void Threads_Sleep(void); + int Threads_Wake(tThread *Thread); void Threads_AddActive(tThread *Thread); - int Threads_GetPID(); - int Threads_GetTID(); - int Threads_GetUID(); - int Threads_GetGID(); -void Threads_Dump(); +tThread *Threads_RemActive(void); + 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_SetGID(Uint *Errno, tUID ID); +void Threads_Dump(void); +void Mutex_Acquire(tMutex *Mutex); +void Mutex_Release(tMutex *Mutex); + int Mutex_IsLocked(tMutex *Mutex); // === GLOBALS === // -- Core Thread -- +// Only used for the core kernel tThread gThreadZero = { - NULL, 0, // Next, Lock - THREAD_STAT_ACTIVE, // Status - 0, // Exit Status - 0, 0, // TID, TGID - 0, 0, // UID, GID - 0, // Parent Thread ID - "ThreadZero", // Name - - 0, // Kernel Stack - {0}, // Saved State - {0}, // VM State - - 0, {0}, {0}, // Signal State - - NULL, NULL, // Messages, Last Message - DEFAULT_QUANTUM, DEFAULT_QUANTUM, // Quantum, Remaining - DEFAULT_TICKETS, - {0} // Default config to zero + Status: THREAD_STAT_ACTIVE, // Status + ThreadName: "ThreadZero", // Name + Quantum: DEFAULT_QUANTUM, // Default Quantum + Remaining: DEFAULT_QUANTUM, // Current Quantum + NumTickets: DEFAULT_TICKETS // Number of tickets }; // -- Processes -- // --- Locks --- -volatile int giThreadListLock = 0; ///\note NEVER use a heap function while locked +tShortSpinlock glThreadListLock; ///\note NEVER use a heap function while locked // --- Current State --- volatile int giNumActiveThreads = 0; -volatile int giTotalTickets = 0; +volatile int giFreeTickets = 0; volatile Uint giNextTID = 1; // --- 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 @@ -74,33 +81,18 @@ tThread *gDeleteThreads = NULL; // Threads to delete // === CODE === /** - * \fn void Threads_Init() + * \fn void Threads_Init(void) * \brief Initialse the thread list */ -void Threads_Init() +void Threads_Init(void) { ArchThreads_Init(); // Create Initial Task gActiveThreads = &gThreadZero; - giTotalTickets = gThreadZero.NumTickets; + //giFreeTickets = gThreadZero.NumTickets; giNumActiveThreads = 1; - - #if 1 - // Create Idle Task - if(Proc_Clone(0, 0) == 0) - { - tThread *cur = Proc_GetCurThread(); - cur->ThreadName = "Idle Thread"; - Threads_SetTickets(0); // Never called randomly - cur->Quantum = 1; // 1 slice quantum - HALT(); - for(;;) { - HALT(); // Just yeilds - } - } - #endif - + Proc_Start(); } @@ -108,53 +100,161 @@ void Threads_Init() * \fn void Threads_SetName(char *NewName) * \brief Sets the current thread's name */ -void Threads_SetName(char *NewName) +int Threads_SetName(char *NewName) { tThread *cur = Proc_GetCurThread(); - if( IsHeap(cur->ThreadName) ) - free( cur->ThreadName ); - cur->ThreadName = malloc(strlen(NewName)+1); - strcpy(cur->ThreadName, NewName); + char *oldname = cur->ThreadName; + + cur->ThreadName = NULL; + + if( IsHeap(oldname) ) free( oldname ); + + cur->ThreadName = strdup(NewName); + return 0; } /** - * \fn void Threads_SetTickets(int Num) + * \fn char *Threads_GetName(int ID) + * \brief Gets a thread's name + */ +char *Threads_GetName(int ID) +{ + if(ID == -1) { + return Proc_GetCurThread()->ThreadName; + } + // TODO: Find a thread and get its name + return NULL; +} + +/** + * \fn void Threads_SetTickets(tThread *Thread, int Num) * \brief Sets the 'priority' of a task */ -void Threads_SetTickets(int Num) +void Threads_SetTickets(tThread *Thread, int Num) { - tThread *cur = Proc_GetCurThread(); + if(Thread == NULL) + Thread = Proc_GetCurThread(); if(Num < 0) return; if(Num > MAX_TICKETS) Num = MAX_TICKETS; - LOCK( &giThreadListLock ); - giTotalTickets -= cur->NumTickets; - cur->NumTickets = Num; - giTotalTickets += Num; - //LOG("giTotalTickets = %i", giTotalTickets); - RELEASE( &giThreadListLock ); + if( Thread != Proc_GetCurThread() ) { + SHORTLOCK( &glThreadListLock ); + giFreeTickets -= Thread->NumTickets - Num; + Thread->NumTickets = Num; + SHORTREL( &glThreadListLock ); + } + else + Thread->NumTickets = Num; } /** - * \fn void Threads_WaitTID(int TID, int *status) + * \fn tThread *Threads_CloneTCB(Uint *Err, Uint Flags) + */ +tThread *Threads_CloneTCB(Uint *Err, Uint Flags) +{ + tThread *cur, *new; + int i; + cur = Proc_GetCurThread(); + + new = malloc(sizeof(tThread)); + if(new == NULL) { + *Err = -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->RetStatus = 0; + + // Get Thread ID + new->TID = giNextTID++; + new->Parent = cur; + + // 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; + + // Messages are not inherited + new->Messages = NULL; + new->LastMessage = NULL; + + // Set State + new->Remaining = new->Quantum = cur->Quantum; + new->NumTickets = cur->NumTickets; + + // 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 = new; + SHORTREL( &glThreadListLock ); + + return new; +} + +/** + * \fn Uint *Threads_GetCfgPtr(int 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]; +} + +/** + * \fn tTID Threads_WaitTID(int TID, int *status) * \brief Wait for a task to change state + * \return TID of child that changed state */ int Threads_WaitTID(int TID, int *status) { // Any Child if(TID == -1) { - + Log_Error("Threads", "TODO: Threads_WaitTID(TID=-1) - Any Child"); return -1; } // Any peer/child thread if(TID == 0) { - + Log_Error("Threads", "TODO: Threads_WaitTID(TID=0) - Any Child/Sibling"); return -1; } // TGID = abs(TID) if(TID < -1) { + Log_Error("Threads", "TODO: Threads_WaitTID(TID<0) - TGID"); return -1; } @@ -163,13 +263,27 @@ int Threads_WaitTID(int TID, int *status) tThread *t = Threads_GetThread(TID); int initStatus = t->Status; int ret; - while(t->Status == initStatus) Threads_Yield(); + + 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); + } + } + + Log_Debug("Threads", "%i waiting for %i, t->Status = %i", + Threads_GetTID(), t->TID, t->Status); ret = t->RetStatus; switch(t->Status) { case THREAD_STAT_ZOMBIE: + // Kill the thread t->Status = THREAD_STAT_DEAD; + // TODO: Child return value? if(status) *status = 0; + // add to delete queue Threads_AddToDelete( t ); break; default: @@ -185,24 +299,16 @@ int Threads_WaitTID(int TID, int *status) /** * \fn tThread *Threads_GetThread(Uint TID) * \brief Gets a thread given its TID + * \param TID Thread ID */ tThread *Threads_GetThread(Uint TID) { tThread *thread; - // Search Active List - for(thread = gActiveThreads; + // Search global list + for(thread = gAllThreads; thread; - thread = thread->Next) - { - if(thread->TID == TID) - return thread; - } - - // Search Sleeping List - for(thread = gSleepingThreads; - thread; - thread = thread->Next) + thread = thread->GlobalNext) { if(thread->TID == TID) return thread; @@ -228,7 +334,7 @@ void Threads_AddToDelete(tThread *Thread) } /** - * \fn tThread *Threads_int_GetPrev(tThread *List, tThread *Thread) + * \fn tThread *Threads_int_GetPrev(tThread **List, tThread *Thread) * \brief Gets the previous entry in a thead linked list */ tThread *Threads_int_GetPrev(tThread **List, tThread *Thread) @@ -260,12 +366,16 @@ 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(); } /** * \fn void Threads_Kill(tThread *Thread, int Status) * \brief Kill a thread - * \param TID Thread ID (0 for current) + * \param Thread Thread to kill + * \param Status Status code to return to the parent */ void Threads_Kill(tThread *Thread, int Status) { @@ -286,18 +396,20 @@ void Threads_Kill(tThread *Thread, int Status) } #endif - ///\note Double lock is needed due to overlap of locks + ///\note Double lock is needed due to overlap of lock areas // Lock thread (stop us recieving messages) - LOCK( &Thread->IsLocked ); + SHORTLOCK( &Thread->IsLocked ); // Lock thread list - LOCK( &giThreadListLock ); + 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( &Thread->IsLocked ); + SHORTREL( &glThreadListLock ); return; } @@ -314,9 +426,10 @@ void Threads_Kill(tThread *Thread, int Status) prev->Next = Thread->Next; // Remove from active giNumActiveThreads --; - giTotalTickets -= Thread->NumTickets; + if( Thread != Proc_GetCurThread() ) + giFreeTickets -= Thread->NumTickets; - // Mark thread as a zombie + // Save exit status Thread->RetStatus = Status; // Don't Zombie if we are being killed as part of a tree @@ -326,255 +439,418 @@ void Threads_Kill(tThread *Thread, int Status) Threads_AddToDelete( Thread ); } else { Thread->Status = THREAD_STAT_ZOMBIE; + // Wake parent + Threads_Wake( Thread->Parent ); } + Log("Thread %i went *hurk* (%i)", Thread->TID, Thread->Status); + // Release spinlocks - RELEASE( &Thread->IsLocked ); // Released first so that it IS released - RELEASE( &giThreadListLock ); + SHORTREL( &Thread->IsLocked ); + SHORTREL( &glThreadListLock ); + if(Status != -1) HALT(); } /** - * \fn void Threads_Yield() + * \fn void Threads_Yield(void) * \brief Yield remainder of timeslice */ -void Threads_Yield() +void Threads_Yield(void) { Proc_GetCurThread()->Remaining = 0; HALT(); } /** - * \fn void Threads_Sleep() + * \fn void Threads_Sleep(void) * \brief Take the current process off the run queue */ -void Threads_Sleep() +void Threads_Sleep(void) { tThread *cur = Proc_GetCurThread(); - tThread *thread; - Log("Proc_Sleep: %i going to sleep", cur->TID); + //Log_Log("Threads", "%i going to sleep", cur->TID); // Acquire Spinlock - LOCK( &giThreadListLock ); - - // Get thread before current thread - thread = Threads_int_GetPrev( &gActiveThreads, cur ); - if(!thread) { - Warning("Proc_Sleep - Current thread is not on the active queue"); - return; - } + SHORTLOCK( &glThreadListLock ); // Don't sleep if there is a message waiting if( cur->Messages ) { - RELEASE( &giThreadListLock ); + SHORTREL( &glThreadListLock ); return; } - // Unset remaining timeslices (force a task switch on timer fire) - cur->Remaining = 0; - - // Remove from active list - thread->Next = cur->Next; + // Remove us from running queue + Threads_RemActive(); // Add to Sleeping List (at the top) cur->Next = gSleepingThreads; gSleepingThreads = cur; - // Reduce the active count & ticket count - giNumActiveThreads --; - giTotalTickets -= cur->NumTickets; - // 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); + #endif + // Release Spinlock - RELEASE( &giThreadListLock ); + SHORTREL( &glThreadListLock ); - HALT(); + while(cur->Status != THREAD_STAT_ACTIVE) HALT(); } /** - * \fn void Threads_Wake( tThread *Thread ) + * \fn int Threads_Wake( tThread *Thread ) * \brief Wakes a sleeping/waiting thread up + * \param Thread Thread to wake + * \return Boolean Failure (Returns ERRNO) + * \note Should be called with the scheduler lock held */ -void Threads_Wake(tThread *Thread) +int Threads_Wake(tThread *Thread) { tThread *prev; + + if(!Thread) + return -EINVAL; + switch(Thread->Status) { - case THREAD_STAT_ACTIVE: break; - case THREAD_STAT_SLEEPING: - LOCK( &giThreadListLock ); + case THREAD_STAT_ACTIVE: + Log("Thread_Wake: Waking awake thread (%i)", Thread->TID); + return -EALREADY; + + case THREAD_STAT_SLEEPING: // TODO: Comment better + // Remove from sleeping queue prev = Threads_int_GetPrev(&gSleepingThreads, Thread); - prev->Next = Thread->Next; // Remove from sleeping queue - Thread->Next = gActiveThreads; // Add to active queue + prev->Next = Thread->Next; + // Add to active queue + Thread->Next = gActiveThreads; gActiveThreads = Thread; + // Update bookkeeping + giNumActiveThreads ++; + giFreeTickets += Thread->NumTickets; + #if DEBUG_TRACE_TICKETS + Log("Threads_Wake: new giFreeTickets = %i", giFreeTickets); + #endif + Thread->CurCPU = -1; Thread->Status = THREAD_STAT_ACTIVE; - RELEASE( &giThreadListLock ); - break; + #if DEBUG_TRACE_STATE + Log("Threads_Sleep: %p (%i %s) woken", Thread, Thread->TID, Thread->ThreadName); + #endif + return -EOK; + case THREAD_STAT_WAITING: Warning("Thread_Wake - Waiting threads are not currently supported"); - break; + return -ENOTIMPL; + case THREAD_STAT_DEAD: Warning("Thread_Wake - Attempt to wake dead thread (%i)", Thread->TID); - break; + return -ENOTIMPL; + default: Warning("Thread_Wake - Unknown process status (%i)\n", Thread->Status); - break; + return -EINTERNAL; } } +/** + * \brief Wake a thread given the TID + * \param TID Thread ID to wake + * \return Boolean Faulure (errno) + */ +int Threads_WakeTID(tTID TID) +{ + tThread *thread = Threads_GetThread(TID); + int ret; + if(!thread) + return -ENOENT; + SHORTLOCK( &glThreadListLock ); + ret = Threads_Wake( thread ); + SHORTREL( &glThreadListLock ); + return ret; +} + /** * \fn void Threads_AddActive(tThread *Thread) * \brief Adds a thread to the active queue */ void Threads_AddActive(tThread *Thread) { - LOCK( &giThreadListLock ); + SHORTLOCK( &glThreadListLock ); + // Add to active list Thread->Next = gActiveThreads; gActiveThreads = Thread; + // Update bookkeeping giNumActiveThreads ++; - giTotalTickets += Thread->NumTickets; - //Log("Threads_AddActive: giNumActiveThreads = %i, giTotalTickets = %i", - // giNumActiveThreads, giTotalTickets); - RELEASE( &giThreadListLock ); + giFreeTickets += Thread->NumTickets; + #if DEBUG_TRACE_TICKETS + Log("Threads_AddActive: new giFreeTickets = %i", giFreeTickets); + #endif + SHORTREL( &glThreadListLock ); } -#if 0 /** - * \fn void Threads_SetSignalHandler(int Num, void *Handler) - * \brief Sets the signal handler for a signal + * \brief Removes the current thread from the active queue + * \warning This should ONLY be called with task switches disabled + * \return Current thread pointer */ -void Threads_SetSignalHandler(int Num, void *Handler) +tThread *Threads_RemActive(void) { - if(Num < 0 || Num >= NSIG) return; - - gCurrentThread->SignalHandlers[Num] = Handler; + tThread *ret = Proc_GetCurThread(); + tThread *prev = Threads_int_GetPrev(&gActiveThreads, ret); + if(!prev) return NULL; + ret->Remaining = 0; + ret->CurCPU = -1; + prev->Next = ret->Next; + giNumActiveThreads --; + return ret; +} + +/** + * \fn void Threads_SetFaultHandler(Uint Handler) + * \brief Sets the signal handler for a signal + */ +void Threads_SetFaultHandler(Uint Handler) +{ + //Log_Debug("Threads", "Threads_SetFaultHandler: Handler = %p", Handler); + Proc_GetCurThread()->FaultHandler = Handler; } /** - * \fn void Threads_SendSignal(int TID, int Num) - * \brief Send a signal to a thread + * \fn void Threads_Fault(int Num) + * \brief Calls a fault handler */ -void Threads_SendSignal(int TID, int Num) +void Threads_Fault(int Num) { - tThread *thread = Proc_GetThread(TID); - void *handler; + tThread *thread = Proc_GetCurThread(); + + Log_Log("Threads", "Threads_Fault: thread = %p", thread); if(!thread) return ; - handler = thread->SignalHandlers[Num]; + Log_Log("Threads", "Threads_Fault: thread->FaultHandler = %p", thread->FaultHandler); - // Panic? - if(handler == SIG_ERR) { - Proc_Kill(TID); + switch(thread->FaultHandler) + { + case 0: // Panic? + Threads_Kill(thread, -1); + HALT(); return ; - } - // Dump Core? - if(handler == -2) { - Proc_Kill(TID); + case 1: // Dump Core? + Threads_Kill(thread, -1); + HALT(); return ; } - // Ignore? - if(handler == -2) return; - // Check the type and handle if the thread is already in a signal - if(thread->CurSignal != 0) { - if(Num < _SIGTYPE_FATAL) - Proc_Kill(TID); - } else { - while(thread->CurSignal != 0) - Proc_Yield(); - } + // Double Fault? Oh, F**k + if(thread->CurFaultNum != 0) { + Threads_Kill(thread, -1); // For now, just kill + HALT(); } - //TODO: + thread->CurFaultNum = Num; + + Proc_CallFaultHandler(thread); } -#endif // --- Process Structure Access Functions --- -int Threads_GetPID() +tPID Threads_GetPID(void) { return Proc_GetCurThread()->TGID; } -int Threads_GetTID() +tTID Threads_GetTID(void) { return Proc_GetCurThread()->TID; } -int Threads_GetUID() +tUID Threads_GetUID(void) { return Proc_GetCurThread()->UID; } -int Threads_GetGID() +tGID Threads_GetGID(void) { return Proc_GetCurThread()->GID; } +int Threads_SetUID(Uint *Errno, tUID ID) +{ + tThread *t = Proc_GetCurThread(); + if( t->UID != 0 ) { + *Errno = -EACCES; + return -1; + } + Log_Debug("Threads", "TID %i's UID set to %i", t->TID, ID); + t->UID = ID; + return 0; +} + +int Threads_SetGID(Uint *Errno, tGID ID) +{ + tThread *t = Proc_GetCurThread(); + if( t->UID != 0 ) { + *Errno = -EACCES; + return -1; + } + Log_Debug("Threads", "TID %i's GID set to %i", t->TID, ID); + t->GID = ID; + return 0; +} + /** - * \fn void Threads_Dump() + * \fn void Threads_Dump(void) * \brief Dums a list of currently running threads */ -void Threads_Dump() +void Threads_Dump(void) { tThread *thread; Log("Active Threads:"); for(thread=gActiveThreads;thread;thread=thread->Next) { - Log(" %i (%i) - %s", thread->TID, thread->TGID, thread->ThreadName); + 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(" KStack 0x%x", thread->KernelStack); } - Log("Sleeping Threads:"); - for(thread=gSleepingThreads;thread;thread=thread->Next) + + Log("All Threads:"); + for(thread=gAllThreads;thread;thread=thread->GlobalNext) { - Log(" %i (%i) - %s", thread->TID, thread->TGID, thread->ThreadName); + 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(" KStack 0x%x", thread->KernelStack); } } /** - * \fn tThread *Threads_GetNextToRun(int CPU) + * \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 */ -tThread *Threads_GetNextToRun(int CPU) +tThread *Threads_GetNextToRun(int CPU, tThread *Last) { tThread *thread; int ticket; - int number; + int number; - // Special case: 1 thread - if(giNumActiveThreads == 1) + // Lock thread list + SHORTLOCK( &glThreadListLock ); + + // Clear Delete Queue + while(gDeleteThreads) { - return gActiveThreads; + 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; } - //Log(" Threads_GetNextToRun: giNumActiveThreads=%i,giTotalTickets=%i", - // giNumActiveThreads, giTotalTickets); - // Get the ticket number - ticket = number = rand() % giTotalTickets; + // No active threads, just take a nap + if(giNumActiveThreads == 0) { + SHORTREL( &glThreadListLock ); + #if DEBUG_TRACE_TICKETS + Log("No active threads"); + #endif + return NULL; + } + + // Special case: 1 thread + 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 + } + + // 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); + #endif + } + #if DEBUG_TRACE_TICKETS + else + LogF(" %p (%s)->Status = %i\n", Last, Last->ThreadName, Last->Status); + #endif + Last->CurCPU = -1; + } - //Log(" Threads_GetNextToRun: ticket = %i", ticket); + #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; + } + + // Get the ticket number + ticket = number = rand() % giFreeTickets; // Find the next thread for(thread=gActiveThreads;thread;thread=thread->Next) { + if(thread->CurCPU >= 0) continue; if(thread->NumTickets > number) break; number -= thread->NumTickets; } - // Error Check if(thread == NULL) { number = 0; - for(thread=gActiveThreads;thread;thread=thread->Next) + for(thread=gActiveThreads;thread;thread=thread->Next) { + if(thread->CurCPU >= 0) continue; number += thread->NumTickets; - Panic("Bookeeping Failed - giTotalTicketCount (%i) != true count (%i)", - giTotalTickets, number); + } + Panic("Bookeeping Failed - giFreeTickets(%i) > true count (%i)", + giFreeTickets, number); } + #if DEBUG_TRACE_TICKETS + LogF(" CPU%i giFreeTickets = %i\n", CPU, giFreeTickets); + #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 + + SHORTREL( &glThreadListLock ); return thread; } @@ -585,6 +861,92 @@ tThread *Threads_GetNextToRun(int CPU) */ void Threads_SegFault(tVAddr Addr) { - //Threads_SendSignal( Proc_GetCurThread()->TID, SIGSEGV ); - Threads_Kill( Proc_GetCurThread(), 0 ); + 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) HALT(); + // 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);