X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=KernelLand%2FKernel%2Fthreads.c;h=67a2f637462e5b86252c40978b9cecee18cb21de;hb=8394ad407646ea68f17c29e9899936e0906c4725;hp=956eede82281ff1e3153bc6da1d090c22943d478;hpb=48743e39650eb1ef988380e9d95f27fd40d3a9ce;p=tpg%2Facess2.git

diff --git a/KernelLand/Kernel/threads.c b/KernelLand/Kernel/threads.c
index 956eede8..67a2f637 100644
--- a/KernelLand/Kernel/threads.c
+++ b/KernelLand/Kernel/threads.c
@@ -1,5 +1,6 @@
 /*
- * Acess2
+ * Acess2 Kernel
+ * - By John Hodge (thePowersGang)
  * threads.c
  * - Common Thread Control
  */
@@ -10,6 +11,7 @@
 #include <hal_proc.h>
 #include <semaphore.h>
 #include <vfs_threads.h>	// VFS Handle maintainence
+#include <events.h>
 
 // Configuration
 #define DEBUG_TRACE_TICKETS	0	// Trace ticket counts
@@ -64,6 +66,10 @@ tThread	*Threads_RemActive(void);
 void	Threads_ToggleTrace(int TID);
 void	Threads_Fault(int Num);
 void	Threads_SegFault(tVAddr Addr);
+void	Threads_PostSignal(int SignalNum);
+ int	Threads_GetPendingSignal(void);
+void	Threads_SetSignalHandler(int SignalNum, void *Handler);
+void	*Threads_GetSignalHandler(int SignalNum);
 #if 0
  int	Threads_GetPID(void);
  int	Threads_GetTID(void);
@@ -72,6 +78,7 @@ tGID	Threads_GetGID(void);
  int	Threads_SetUID(Uint *Errno, tUID ID);
  int	Threads_SetGID(Uint *Errno, tUID ID);
 #endif
+void	Threads_int_DumpThread(tThread *thread);
 void	Threads_Dump(void);
 void	Threads_DumpActive(void);
 
@@ -125,14 +132,6 @@ void Threads_Init(void)
 	Log_Debug("Threads", ".KernelStack = %i", offsetof(tThread, KernelStack));
 	
 	// Create Initial Task
-//	#if SCHEDULER_TYPE == SCHED_RR_PRI
-//	gaActiveThreads[gThreadZero.Priority].Head = &gThreadZero;
-//	gaActiveThreads[gThreadZero.Priority].Tail = &gThreadZero;
-//	#else
-//	gActiveThreads.Head = &gThreadZero;
-//	gActiveThreads.Tail = &gThreadZero;
-//	#endif
-	
 	gAllThreads = &gThreadZero;
 	giNumActiveThreads = 1;
 	gThreadZero.Process = &gProcessZero;
@@ -149,6 +148,25 @@ void Threads_Delete(tThread *Thread)
 	Proc_ClearThread(Thread);			
 
 	Thread->Process->nThreads --;
+
+	if( Thread->Process->FirstThread == Thread )
+	{
+		Thread->Process->FirstThread = Thread->ProcessNext;
+	}
+	else
+	{
+		tThread	*prev = Thread->Process->FirstThread;
+		while(prev && prev->ProcessNext != Thread)
+			prev = prev->ProcessNext;
+		if( !prev )
+			Log_Error("Threads", "Thread %p(%i %s) is not on the process's list",
+				Thread, Thread->TID, Thread->ThreadName
+				);
+		else
+			prev->ProcessNext = Thread->ProcessNext;
+	}
+
+	// If the final thread is being terminated, clean up the process
 	if( Thread->Process->nThreads == 0 )
 	{
 		tProcess	*proc = Thread->Process;
@@ -313,6 +331,10 @@ tThread *Threads_CloneTCB(Uint Flags)
 		new->Process = malloc( sizeof(struct sProcess) );
 		newproc = new->Process;
 		newproc->PID = new->TID;
+		if( Flags & CLONE_PGID )
+			newproc->PGID = oldproc->PGID;
+		else
+			newproc->PGID = newproc->PID;
 		newproc->UID = oldproc->UID;
 		newproc->GID = oldproc->GID;
 		newproc->MaxFD = oldproc->MaxFD;
@@ -327,9 +349,16 @@ tThread *Threads_CloneTCB(Uint Flags)
 		newproc->nThreads = 1;
 		// Reference all handles in the VFS
 		VFS_ReferenceUserHandles();
+
+		newproc->FirstThread = new;
+		new->ProcessNext = NULL;
 	}
 	else {
 		new->Process->nThreads ++;
+		new->Process = cur->Process;
+		// TODO: Locking
+		new->ProcessNext = new->Process->FirstThread;
+		new->Process->FirstThread = new;
 	}
 	
 	// Messages are not inherited
@@ -418,9 +447,30 @@ tThread *Threads_CloneThreadZero(void)
 tTID Threads_WaitTID(int TID, int *Status)
 {	
 	// Any Child
-	if(TID == -1) {
-		Log_Error("Threads", "TODO: Threads_WaitTID(TID=-1) - Any Child");
-		return -1;
+	if(TID == -1)
+	{
+		Uint32 ev = Threads_WaitEvents(THREAD_EVENT_DEADCHILD);
+		tTID	ret = -1;
+		if( ev & THREAD_EVENT_DEADCHILD )
+		{
+			// A child died, get the TID
+			tThread	*us = Proc_GetCurThread();
+			ASSERT(us->LastDeadChild);
+			ret = us->LastDeadChild->TID;
+			// - Mark as dead (as opposed to undead)
+			ASSERT(us->LastDeadChild->Status == THREAD_STAT_ZOMBIE);
+			us->LastDeadChild->Status = THREAD_STAT_DEAD;
+			// - Set return status
+			if(Status)
+				*Status = us->LastDeadChild->RetStatus;
+			us->LastDeadChild = NULL;
+			Mutex_Release(&us->DeadChildLock);
+		}
+		else
+		{
+			Log_Error("Threads", "TODO: Threads_WaitTID(TID=-1) - Any Child");
+		}
+		return ret;
 	}
 	
 	// Any peer/child thread
@@ -436,33 +486,14 @@ tTID Threads_WaitTID(int TID, int *Status)
 	}
 	
 	// Specific Thread
-	if(TID > 0) {
-		tThread	*t = Threads_GetThread(TID);
+	if(TID > 0)
+	{
 		tTID	ret;
-		
-		// 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);
-		}
-		
-		// Set return status
-		ret = t->TID;
-		switch(t->Status)
+		// NOTE: Race condition - Other child dies, desired child dies, first death is 'lost'
+		while( (ret = Threads_WaitTID(-1, Status)) != TID )
 		{
-		case THREAD_STAT_ZOMBIE:
-			// Kill the thread
-			t->Status = THREAD_STAT_DEAD;
-			// TODO: Child return value?
-			if(Status)	*Status = t->RetStatus;
-			// add to delete queue
-			Threads_Delete( t );
-			break;
-		default:
-			if(Status)	*Status = -1;
-			break;
+			if( ret == -1 )
+				break;
 		}
 		return ret;
 	}
@@ -480,15 +511,13 @@ tThread *Threads_GetThread(Uint TID)
 	tThread *thread;
 	
 	// Search global list
-	for(thread = gAllThreads;
-		thread;
-		thread = thread->GlobalNext)
+	for( thread = gAllThreads; thread; thread = thread->GlobalNext )
 	{
 		if(thread->TID == TID)
 			return thread;
 	}
 
-	Log("Unable to find TID %i on main list\n", TID);
+	Log_Notice("Threads", "Unable to find TID %i on main list\n", TID);
 	
 	return NULL;
 }
@@ -663,8 +692,10 @@ void Threads_Kill(tThread *Thread, int Status)
 
 	Thread->Status = THREAD_STAT_ZOMBIE;
 	SHORTREL( &glThreadListLock );
-	// TODO: Send something like SIGCHLD
-	Threads_Wake( Thread->Parent );
+	// TODO: It's possible that we could be timer-preempted here, should disable that... somehow
+	Mutex_Acquire( &Thread->Parent->DeadChildLock );	// released by parent
+	Thread->Parent->LastDeadChild = Thread;
+	Threads_PostEvent( Thread->Parent, THREAD_EVENT_DEADCHILD );
 	
 	Log("Thread %i went *hurk* (%i)", Thread->TID, Status);
 	
@@ -685,6 +716,22 @@ void Threads_Yield(void)
 	Proc_Reschedule();
 }
 
+/**
+ * \breif Wait for the thread status to not be a specified value
+ */
+void Threads_int_WaitForStatusEnd(enum eThreadStatus Status)
+{
+	tThread	*us = Proc_GetCurThread();
+	ASSERT(Status != THREAD_STAT_ACTIVE);
+	ASSERT(Status != THREAD_STAT_DEAD);
+	while( us->Status == Status )
+	{
+		Proc_Reschedule();
+		if( us->Status == Status )
+			Debug("Thread %p(%i %s) rescheduled while in %s state", casTHREAD_STAT[Status]);
+	}
+}
+
 /**
  * \fn void Threads_Sleep(void)
  * \brief Take the current process off the run queue
@@ -716,12 +763,7 @@ void Threads_Sleep(void)
 	
 	// Release Spinlock
 	SHORTREL( &glThreadListLock );
-
-	while(cur->Status != THREAD_STAT_ACTIVE) {
-		Proc_Reschedule();
-		if( cur->Status != THREAD_STAT_ACTIVE )
-			Log("%i - Huh? why am I up? zzzz...", cur->TID);
-	}
+	Threads_int_WaitForStatusEnd(THREAD_STAT_SLEEPING);
 }
 
 
@@ -743,11 +785,11 @@ int Threads_Wake(tThread *Thread)
 		return -EALREADY;
 	
 	case THREAD_STAT_SLEEPING:
-		SHORTLOCK( &glThreadListLock );
 		// Remove from sleeping queue
+		SHORTLOCK( &glThreadListLock );
 		Threads_int_DelFromQueue(&gSleepingThreads, Thread);
-		
 		SHORTREL( &glThreadListLock );
+		
 		Threads_AddActive( Thread );
 		
 		#if DEBUG_TRACE_STATE
@@ -813,7 +855,7 @@ int Threads_Wake(tThread *Thread)
 		return -ENOTIMPL;
 	
 	default:
-		Warning("Threads_Wake - Unknown process status (%i)\n", Thread->Status);
+		Log_Warning("Threads", "Threads_Wake - Unknown process status (%i)", Thread->Status);
 		return -EINTERNAL;
 	}
 }
@@ -902,42 +944,8 @@ void Threads_AddActive(tThread *Thread)
  */
 tThread *Threads_RemActive(void)
 {
-	#if 0
-	tThread	*ret = Proc_GetCurThread();
-
-	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;
-	
 	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
 }
 
 /**
@@ -1000,7 +1008,67 @@ void Threads_SegFault(tVAddr Addr)
 	//Threads_Exit( 0, -1 );
 }
 
+
+void Threads_PostSignal(int SignalNum)
+{
+	tThread *cur = Proc_GetCurThread();
+	cur->PendingSignal = SignalNum;
+	Threads_PostEvent(cur, THREAD_EVENT_SIGNAL);
+}
+
+/**
+ */
+int Threads_GetPendingSignal(void)
+{
+	tThread *cur = Proc_GetCurThread();
+	
+	// Atomic AND with 0 fetches and clears in one operation
+	return __sync_fetch_and_and( &cur->PendingSignal, 0 );
+}
+
+/*
+ * \brief Update the current thread's signal handler
+ */
+void Threads_SetSignalHandler(int SignalNum, void *Handler)
+{
+	if( SignalNum <= 0 || SignalNum >= NSIGNALS )
+		return ;
+	if( !MM_IsUser(Handler) )
+		return ;
+	Proc_GetCurThread()->Process->SignalHandlers[SignalNum] = Handler;
+}
+
+/**
+ * \return 0  Ignore
+ */
+void *Threads_GetSignalHandler(int SignalNum)
+{
+	if( SignalNum <= 0 || SignalNum >= NSIGNALS )
+		return NULL;
+	void *ret = Proc_GetCurThread()->Process->SignalHandlers[SignalNum];
+	if( !ret )
+	{
+		// Defaults
+		switch(SignalNum)
+		{
+		case SIGINT:
+		case SIGKILL:
+		case SIGSEGV:
+//			ret = User_Signal_Kill;
+			break;
+		default:
+			ret = NULL;
+			break;
+		}
+	}
+	return ret;
+}
+
 // --- Process Structure Access Functions ---
+tPGID Threads_GetPGID(void)
+{
+	return Proc_GetCurThread()->Process->PGID;
+}
 tPID Threads_GetPID(void)
 {
 	return Proc_GetCurThread()->Process->PID;
@@ -1063,6 +1131,50 @@ char **Threads_GetCWD(void)
 }
 // ---
 
+void Threads_int_DumpThread(tThread *thread)
+{
+	if( !thread ) {
+		Log(" %p NULL", thread);
+		return ;
+	}
+	if( !CheckMem(thread, sizeof(tThread)) ) {
+		Log(" %p INVAL", thread);
+		return ;
+	}
+	tPID	pid = (thread->Process ? thread->Process->PID : -1);
+	const char	*statstr = (thread->Status < sizeof(casTHREAD_STAT)/sizeof(casTHREAD_STAT[0])
+		? casTHREAD_STAT[thread->Status] : "");
+	Log(" %p %i (%i) - %s (CPU %i) - %i (%s)",
+		thread, thread->TID, pid, thread->ThreadName, thread->CurCPU,
+		thread->Status, statstr
+		);
+	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_EVENTSLEEP:
+		// TODO: Event mask
+		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 %p", thread->KernelStack);
+	if( thread->bInstrTrace )
+		Log("  Tracing Enabled");
+	Proc_DumpThreadCPUState(thread);
+}
+
 /**
  * \fn void Threads_Dump(void)
  */
@@ -1085,16 +1197,10 @@ void Threads_DumpActive(void)
 	#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);
+			Threads_int_DumpThread(thread);
 			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
@@ -1108,39 +1214,13 @@ void Threads_DumpActive(void)
  */
 void Threads_Dump(void)
 {
-	tThread	*thread;
-	
 	Log("--- Thread Dump ---");
 	Threads_DumpActive();
 	
 	Log("All Threads:");
-	for(thread=gAllThreads;thread;thread=thread->GlobalNext)
+	for(tThread *thread = gAllThreads; thread; thread = thread->GlobalNext)
 	{
-		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);
+		Threads_int_DumpThread(thread);
 	}
 }