X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Kernel%2Fthreads.c;h=c62f72682c00c2dc375d9f5633a8799fdb02dd6d;hb=b98fbd4e9c71447d81fc9bd643fb174c76346e0f;hp=3e98e44817236f3ddde21d85a52a8196434d0d75;hpb=d3a46a7874a4d535d6cb9ef00c451d0bbbb65e9c;p=tpg%2Facess2.git diff --git a/Kernel/threads.c b/Kernel/threads.c index 3e98e448..c62f7268 100644 --- a/Kernel/threads.c +++ b/Kernel/threads.c @@ -3,24 +3,33 @@ * threads.c * - Common Thread Control */ -#include +#include #include +#include // === CONSTANTS === #define DEFAULT_QUANTUM 10 #define DEFAULT_TICKETS 5 #define MAX_TICKETS 10 +const enum eConfigTypes cCONFIG_TYPES[] = { + CFGT_HEAPSTR, // CFG_VFS_CWD + CFGT_INT, // CFG_VFS_MAXFILES + CFGT_NULL +}; // === IMPORTS === extern void ArchThreads_Init(); extern void Proc_Start(); extern tThread *Proc_GetCurThread(); extern int Proc_Clone(Uint *Err, Uint Flags); +extern void Proc_CallFaultHandler(tThread *Thread); // === PROTOTYPES === void Threads_Init(); -void Threads_SetName(char *NewName); + int Threads_SetName(char *NewName); +char *Threads_GetName(int ID); void Threads_SetTickets(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); @@ -33,8 +42,10 @@ void Threads_Wake(tThread *Thread); void Threads_AddActive(tThread *Thread); int Threads_GetPID(); int Threads_GetTID(); - int Threads_GetUID(); - int Threads_GetGID(); +tUID Threads_GetUID(); + int Threads_SetUID(Uint *Errno, tUID ID); +tGID Threads_GetGID(); + int Threads_SetGID(Uint *Errno, tUID ID); void Threads_Dump(); // === GLOBALS === @@ -52,7 +63,7 @@ tThread gThreadZero = { {0}, // Saved State {0}, // VM State - 0, {0}, {0}, // Signal State + 0, 0, // Current Fault, Fault Handler NULL, NULL, // Messages, Last Message DEFAULT_QUANTUM, DEFAULT_QUANTUM, // Quantum, Remaining @@ -96,8 +107,6 @@ void Threads_Init() cur->Quantum = 1; // 1 slice quantum HALT(); for(;;) { - //Log("---- Idle"); - //Threads_Dump(); HALT(); // Just yeilds } } @@ -110,13 +119,26 @@ 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); + return 0; +} + +/** + * \fn char *Threads_GetName(int ID) + * \brief Gets a thread's name + */ +char *Threads_GetName(int ID) +{ + if(ID == -1) { + return Proc_GetCurThread()->ThreadName; + } + return NULL; } /** @@ -137,14 +159,90 @@ void Threads_SetTickets(int Num) RELEASE( &giThreadListLock ); } +/** + * \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; + } + + new->Next = NULL; + new->IsLocked = 0; + new->Status = THREAD_STAT_ACTIVE; + new->RetStatus = 0; + + // Get Thread ID + new->TID = giNextTID++; + new->PTID = cur->TID; + + // Clone Name + new->ThreadName = malloc(strlen(cur->ThreadName)+1); + strcpy(new->ThreadName, 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; + } + } + + 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 void Threads_WaitTID(int TID, int *status) * \brief Wait for a task to change state */ int Threads_WaitTID(int TID, int *status) -{ - Threads_Dump(); - +{ // Any Child if(TID == -1) { @@ -167,7 +265,13 @@ 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) { + while(t->Status == initStatus) { + Threads_Yield(); + } + } + ret = t->RetStatus; switch(t->Status) { @@ -232,7 +336,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,13 +364,18 @@ tThread *Threads_int_GetPrev(tThread **List, tThread *Thread) */ void Threads_Exit(int TID, int Status) { - Threads_Kill( Proc_GetCurThread(), (Uint)Status & 0xFF ); + if( TID == 0 ) + Threads_Kill( Proc_GetCurThread(), (Uint)Status & 0xFF ); + else + Threads_Kill( Threads_GetThread(TID), (Uint)Status & 0xFF ); + for(;;) HALT(); // Just in case } /** * \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) { @@ -281,7 +390,7 @@ void Threads_Kill(tThread *Thread, int Status) child; child = child->Next) { - if(child->PTID == gCurrentThread->TID) + if(child->PTID == Thread->TID) Threads_Kill(child, -1); } } @@ -332,6 +441,9 @@ void Threads_Kill(tThread *Thread, int Status) // Release spinlocks RELEASE( &Thread->IsLocked ); // Released first so that it IS released RELEASE( &giThreadListLock ); + + //Log("Thread %i went *hurk*", Thread->TID); + if(Status != -1) HALT(); } @@ -354,7 +466,7 @@ void Threads_Sleep() 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 ); @@ -362,7 +474,8 @@ void Threads_Sleep() // Get thread before current thread thread = Threads_int_GetPrev( &gActiveThreads, cur ); if(!thread) { - Warning("Proc_Sleep - Current thread is not on the active queue"); + Warning("Threads_Sleep - Current thread is not on the active queue"); + Threads_Dump(); return; } @@ -392,7 +505,7 @@ void Threads_Sleep() // Release Spinlock RELEASE( &giThreadListLock ); - HALT(); + while(cur->Status != THREAD_STAT_ACTIVE) HALT(); } @@ -407,11 +520,14 @@ void Threads_Wake(tThread *Thread) { case THREAD_STAT_ACTIVE: break; case THREAD_STAT_SLEEPING: + //Log_Log("Threads", "Waking %i (%p) from sleeping", Thread->TID, Thread); LOCK( &giThreadListLock ); prev = Threads_int_GetPrev(&gSleepingThreads, Thread); prev->Next = Thread->Next; // Remove from sleeping queue Thread->Next = gActiveThreads; // Add to active queue gActiveThreads = Thread; + giNumActiveThreads ++; + giTotalTickets += Thread->NumTickets; Thread->Status = THREAD_STAT_ACTIVE; RELEASE( &giThreadListLock ); break; @@ -427,6 +543,11 @@ void Threads_Wake(tThread *Thread) } } +void Threads_WakeTID(tTID Thread) +{ + Threads_Wake( Threads_GetThread(Thread) ); +} + /** * \fn void Threads_AddActive(tThread *Thread) * \brief Adds a thread to the active queue @@ -443,75 +564,95 @@ void Threads_AddActive(tThread *Thread) RELEASE( &giThreadListLock ); } -#if 0 /** - * \fn void Threads_SetSignalHandler(int Num, void *Handler) + * \fn void Threads_SetFaultHandler(Uint Handler) * \brief Sets the signal handler for a signal */ -void Threads_SetSignalHandler(int Num, void *Handler) -{ - if(Num < 0 || Num >= NSIG) return; - - gCurrentThread->SignalHandlers[Num] = Handler; +void Threads_SetFaultHandler(Uint Handler) +{ + Log_Log("Threads", "Threads_SetFaultHandler: Handler = %p", Handler); + Proc_GetCurThread()->FaultHandler = Handler; } /** - * \fn void Threads_SendSignal(int TID, int Num) + * \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() { return Proc_GetCurThread()->TGID; } -int Threads_GetTID() +tTID Threads_GetTID() { return Proc_GetCurThread()->TID; } -int Threads_GetUID() +tUID Threads_GetUID() { return Proc_GetCurThread()->UID; } -int Threads_GetGID() +tGID Threads_GetGID() { return Proc_GetCurThread()->GID; } +int Threads_SetUID(Uint *Errno, tUID ID) +{ + tThread *t = Proc_GetCurThread(); + if( t->UID != 0 ) { + *Errno = -EACCES; + return -1; + } + Log("Threads_SetUID - Setting User ID to %i", 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("Threads_SetGID - Setting Group ID to %i", ID); + t->GID = ID; + return 0; +} + /** * \fn void Threads_Dump() * \brief Dums a list of currently running threads @@ -519,18 +660,23 @@ int Threads_GetGID() void Threads_Dump() { tThread *thread; + tThread *cur = Proc_GetCurThread(); Log("Active Threads:"); for(thread=gActiveThreads;thread;thread=thread->Next) { - Log(" %i (%i) - %s", thread->TID, thread->TGID, thread->ThreadName); + Log("%c%i (%i) - %s", + (thread==cur?'*':' '), + thread->TID, thread->TGID, thread->ThreadName); 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(" %i (%i) - %s", thread->TID, thread->TGID, thread->ThreadName); + Log("%c%i (%i) - %s", + (thread==cur?'*':' '), + thread->TID, thread->TGID, thread->ThreadName); Log(" %i Tickets, Quantum %i", thread->NumTickets, thread->Quantum); Log(" KStack 0x%x", thread->KernelStack); } @@ -546,9 +692,15 @@ tThread *Threads_GetNextToRun(int CPU) int ticket; int number; + if(giNumActiveThreads == 0) { + //Log_Debug("Threads", "CPU%i has no threads to run", CPU); + return NULL; + } + // Special case: 1 thread - if(giNumActiveThreads == 1) - { + if(giNumActiveThreads == 1) { + //Log_Debug("Threads", "CPU%i has only one thread %i %s", + // CPU, gActiveThreads->TID, gActiveThreads->ThreadName); return gActiveThreads; } @@ -576,5 +728,22 @@ tThread *Threads_GetNextToRun(int CPU) giTotalTickets, number); } + //Log_Debug("Threads", "Switching CPU%i to %p (%s)", + // CPU, thread, thread->ThreadName); + 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 ); +} + +// === EXPORTS === +EXPORT(Threads_GetUID);