X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Kernel%2Fthreads.c;h=b48383085daf8d2225dfbbca9107c986da48745b;hb=a2b49f92646ef666e17172faf72a9dcc0d18942a;hp=13914a85f2b2242b2c7a45d6650ba3c515bf3df2;hpb=e5e272c426a28f2f9e69ed2232469575c7409af1;p=tpg%2Facess2.git diff --git a/Kernel/threads.c b/Kernel/threads.c index 13914a85..b4838308 100644 --- a/Kernel/threads.c +++ b/Kernel/threads.c @@ -6,6 +6,7 @@ #include #include #include +#include // Configuration #define DEBUG_TRACE_TICKETS 0 // Trace ticket counts @@ -31,22 +32,25 @@ const enum eConfigTypes cCONFIG_TYPES[] = { // === 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); +extern void Proc_DumpThreadCPUState(tThread *Thread); extern int GetCPUNum(void); // === PROTOTYPES === void Threads_Init(void); +#if 0 int Threads_SetName(const char *NewName); +#endif char *Threads_GetName(int 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); +#if 0 void Threads_Exit(int TID, int Status); void Threads_Kill(tThread *Thread, int Status); void Threads_Yield(void); @@ -54,28 +58,35 @@ void Threads_Sleep(void); int Threads_Wake(tThread *Thread); void Threads_AddActive(tThread *Thread); tThread *Threads_RemActive(void); +#endif +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 Threads_DumpActive(void); -void Mutex_Acquire(tMutex *Mutex); +#if 0 + int Mutex_Acquire(tMutex *Mutex); void Mutex_Release(tMutex *Mutex); int Mutex_IsLocked(tMutex *Mutex); +#endif // === GLOBALS === // -- Core Thread -- // 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 - Priority: DEFAULT_PRIORITY // 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 --- @@ -286,6 +297,75 @@ tThread *Threads_CloneTCB(Uint *Err, Uint Flags) return new; } +/** + * \fn tThread *Threads_CloneTCB(Uint *Err, Uint Flags) + * \brief Clone the TCB of the current thread + */ +tThread *Threads_CloneThreadZero(void) +{ + tThread *cur, *new; + int i; + cur = Proc_GetCurThread(); + + // Allocate and duplicate + new = malloc(sizeof(tThread)); + if(new == NULL) { + return NULL; + } + memcpy(new, &gThreadZero, sizeof(tThread)); + + 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; + + // Clone Name + new->ThreadName = NULL; + + // Messages are not inherited + new->Messages = NULL; + new->LastMessage = NULL; + + // Set State + new->Remaining = new->Quantum = cur->Quantum; + new->Priority = cur->Priority; + + // 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 ); + + return new; +} + /** * \brief Get a configuration pointer from the Per-Thread data area * \param ID Config slot ID @@ -646,7 +726,7 @@ int Threads_Wake(tThread *Thread) 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: @@ -663,15 +743,15 @@ int Threads_Wake(tThread *Thread) 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; } } @@ -703,11 +783,12 @@ void Threads_AddActive(tThread *Thread) tThread *cur = Proc_GetCurThread(); Warning("WTF, CPU%i %p (%i %s) is adding %p (%i %s) when it is active", 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 #if SCHEDULER_TYPE == SCHED_RR_PRI Thread->Next = gaActiveThreads[Thread->Priority]; @@ -721,11 +802,22 @@ void Threads_AddActive(tThread *Thread) giNumActiveThreads ++; #if SCHEDULER_TYPE == SCHED_LOTTERY - giFreeTickets += caiTICKET_COUNTS[ Thread->Priority ]; - # if DEBUG_TRACE_TICKETS - Log("Threads_AddActive: CPU%i %p %i (%s) added, new giFreeTickets = %i", - GetCPUNum(), Thread, Thread->TID, Thread->ThreadName, giFreeTickets); - # endif + { + 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 ); @@ -755,13 +847,12 @@ tThread *Threads_RemActive(void) ret->Next = NULL; ret->Remaining = 0; - ret->CurCPU = -1; giNumActiveThreads --; // no need to decrement tickets, scheduler did it for us #if SCHEDULER_TYPE == SCHED_LOTTERY && DEBUG_TRACE_TICKETS - Log("Threads_RemActive: CPU%i %p %i (%s) removed, giFreeTickets = %i", + Log("CPU%i %p (%i %s) removed, giFreeTickets = %i [nc]", GetCPUNum(), ret, ret->TID, ret->ThreadName, giFreeTickets); #endif @@ -817,6 +908,17 @@ 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) +{ + Warning("Thread #%i committed a segfault at address %p", Proc_GetCurThread()->TID, Addr); + Threads_Fault( 1 ); + //Threads_Exit( 0, -1 ); +} + // --- Process Structure Access Functions --- tPID Threads_GetPID(void) { @@ -885,6 +987,7 @@ void Threads_DumpActive(void) 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); + Proc_DumpThreadCPUState(thread); } #if SCHEDULER_TYPE == SCHED_RR_PRI @@ -914,6 +1017,13 @@ void Threads_Dump(void) 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; @@ -947,6 +1057,7 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last) // 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 while(gDeleteThreads) { thread = gDeleteThreads->Next; @@ -998,14 +1109,15 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last) #if SCHEDULER_TYPE == SCHED_LOTTERY giFreeTickets += caiTICKET_COUNTS[ Last->Priority ]; # 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); + 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_LOTTERY && DEBUG_TRACE_TICKETS else - LogF(" CPU %i released %p (%i %s)->Status = %i (Released)\n", + LogF("Log: CPU%i released %p (%i %s)->Status = %i (Released)\n", CPU, Last, Last->TID, Last->ThreadName, Last->Status); #endif Last->CurCPU = -1; @@ -1064,12 +1176,13 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last) Panic("Bookeeping Failed - giFreeTickets(%i) > true count (%i)", giFreeTickets, number); } - # if DEBUG_TRACE_TICKETS - LogF(" CPU%i giFreeTickets = %i, running %p (%i %s CPU=%i)\n", - CPU, giFreeTickets, thread, thread->TID, thread->ThreadName, thread->CurCPU); - # endif 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 } // --- @@ -1142,17 +1255,6 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last) 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 @@ -1163,7 +1265,7 @@ void Threads_SegFault(tVAddr Addr) * the oldest thread (top thread) on the queue is given the lock and * restarted. */ -void Mutex_Acquire(tMutex *Mutex) +int Mutex_Acquire(tMutex *Mutex) { tThread *us = Proc_GetCurThread(); @@ -1218,11 +1320,14 @@ void Mutex_Acquire(tMutex *Mutex) if( Mutex != &glPhysAlloc ) LogF("Mutex %p taken by %i %p\n", Mutex, us->TID, __builtin_return_address(0)); #endif + + return 0; } /** * \brief Release a held mutex * \param Mutex Mutex to release + * \note Releasing a non-held mutex has no effect */ void Mutex_Release(tMutex *Mutex) { @@ -1265,84 +1370,210 @@ int Mutex_IsLocked(tMutex *Mutex) return Mutex->Owner != NULL; } -/** - * \brief Initialise the semaphore - * \param Value Initial value of the semaphore - * \param Label Symbolic name - */ -void Semaphore_Init(tSemaphore *Sem, int Value, const char *Label) +// +// 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->Name = Label; + Sem->ModName = Module; + Sem->Name = Name; + Sem->MaxValue = MaxValue; } - -/** - * \brief Acquire a "item" from the semaphore - */ -void Semaphore_Wait(tSemaphore *Sem) +// +// 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 ) { - Sem->Value --; + // Take what we need + if( MaxToTake && Sem->Value > MaxToTake ) + taken = MaxToTake; + else + taken = Sem->Value; + Sem->Value -= taken; SHORTREL( &Sem->Protector ); - return ; } - - SHORTLOCK( &glThreadListLock ); - - // - Remove from active list - us = Threads_RemActive(); - us->Next = NULL; - // - Mark as sleeping - us->Status = THREAD_STAT_SEMAPHORESLEEP; - us->WaitPointer = Sem; - - // - Add to waiting - if(Sem->LastWaiting) { - Sem->LastWaiting->Next = us; - Sem->LastWaiting = us; - } - else { - Sem->Waiting = us; - Sem->LastWaiting = us; + 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; + } + + 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; + + taken = us->RetStatus; + + // Get the lock again + SHORTLOCK( &Sem->Protector ); } - SHORTREL( &glThreadListLock ); + // 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; + + // 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 ); - while(us->Status == THREAD_STAT_MUTEXSLEEP) Threads_Yield(); - // We're only woken when there's something avaliable - us->WaitPointer = NULL; + + return taken; } -/** - * \brief Add an "item" to the semaphore - */ -void Semaphore_Signal(tSemaphore *Sem) +// +// 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 ); - Sem->Value ++; - if( Sem->Waiting ) + // 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; + } + + 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; - Sem->Waiting = Sem->Waiting->Next; // Next! + Sem->Waiting = Sem->Waiting->Next; // Reset ->LastWaiting to NULL if we have just removed the last waiting thread if( Sem->Waiting == NULL ) Sem->LastWaiting = NULL; - // Wake new owner + // Figure out how much to give + 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; + + // Wake the sleeper SHORTLOCK( &glThreadListLock ); if( toWake->Status != THREAD_STAT_ACTIVE ) Threads_AddActive(toWake); SHORTREL( &glThreadListLock ); - - // Decrement (the value is now "owned" by `toWake`) - Sem->Value --; } SHORTREL( &Sem->Protector ); + + return added; +} + +// +// Get the current value of a semaphore +// +int Semaphore_GetValue(tSemaphore *Sem) +{ + return Sem->Value; } // === EXPORTS === @@ -1351,3 +1582,6 @@ EXPORT(Threads_GetGID); EXPORT(Mutex_Acquire); EXPORT(Mutex_Release); EXPORT(Mutex_IsLocked); +EXPORT(Semaphore_Init); +EXPORT(Semaphore_Wait); +EXPORT(Semaphore_Signal);