X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Kernel%2Fthreads.c;h=297470cdbc5bc2d741ec04a978bed7be361acfda;hb=3064ee4a12abf17bc88eea5f1b2bb5ad419889f6;hp=5f2e3d7fc0354cde3b736d66c53dc23e39fc11b1;hpb=9d3800f60f2212432e550a4e003ae65b498a4d36;p=tpg%2Facess2.git

diff --git a/Kernel/threads.c b/Kernel/threads.c
index 5f2e3d7f..297470cd 100644
--- a/Kernel/threads.c
+++ b/Kernel/threads.c
@@ -3,31 +3,34 @@
  * threads.c
  * - Common Thread Control
  */
-#include <common.h>
+#include <acess.h>
 #include <threads.h>
 #include <errno.h>
 
+#define DEBUG_TRACE_TICKETS	0
+
 // === 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_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_Init(void);
+ int	Threads_SetName(char *NewName);
 char	*Threads_GetName(int ID);
-void	Threads_SetTickets(int Num);
+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);
@@ -35,44 +38,35 @@ 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();
+ 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);
 
 // === 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
+tSpinlock	glThreadListLock = 0;	///\note NEVER use a heap function while locked
 // --- Current State ---
 volatile int	giNumActiveThreads = 0;
-volatile int	giTotalTickets = 0;
+//volatile int	giTotalTickets = 0;
+volatile int	giFreeTickets = 0;
 volatile Uint	giNextTID = 1;
 // --- Thread Lists ---
 tThread	*gActiveThreads = NULL;		// Currently Running Threads
@@ -82,33 +76,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();
 }
 
@@ -116,13 +95,17 @@ 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;
 }
 
 /**
@@ -134,25 +117,29 @@ 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(int Num)
+ * \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() ) {
+		LOCK( &glThreadListLock );
+		giFreeTickets -= Thread->NumTickets - Num;
+		Thread->NumTickets = Num;
+		RELEASE( &glThreadListLock );
+	}
+	else
+		Thread->NumTickets = Num;
 }
 
 /**
@@ -169,7 +156,9 @@ tThread *Threads_CloneTCB(Uint *Err, Uint Flags)
 		*Err = -ENOMEM;
 		return NULL;
 	}
+	memcpy(new, cur, sizeof(tThread));
 	
+	new->CurCPU = -1;
 	new->Next = NULL;
 	new->IsLocked = 0;
 	new->Status = THREAD_STAT_ACTIVE;
@@ -180,8 +169,7 @@ tThread *Threads_CloneTCB(Uint *Err, Uint Flags)
 	new->PTID = cur->TID;
 	
 	// Clone Name
-	new->ThreadName = malloc(strlen(cur->ThreadName)+1);
-	strcpy(new->ThreadName, cur->ThreadName);
+	new->ThreadName = strdup(cur->ThreadName);
 	
 	// Set Thread Group ID (PID)
 	if(Flags & CLONE_VM)
@@ -198,12 +186,8 @@ tThread *Threads_CloneTCB(Uint *Err, Uint Flags)
 	new->NumTickets = cur->NumTickets;
 	
 	// Set Signal Handlers
-	new->CurSignal = 0;
-	if(Flags & CLONE_VM)
-		memset(new->SignalHandlers, 0, sizeof(new->SignalHandlers));
-	else
-		memcpy(new->SignalHandlers, cur->SignalHandlers, sizeof(new->SignalHandlers));
-	memset(&new->SignalState, 0, sizeof(tTaskState));
+	new->CurFaultNum = 0;
+	new->FaultHandler = cur->FaultHandler;
 	
 	for( i = 0; i < NUM_CFG_ENTRIES; i ++ )
 	{
@@ -265,7 +249,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)
 		{
@@ -287,6 +277,7 @@ 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)
 {
@@ -330,7 +321,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)
@@ -362,12 +353,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)
 {
@@ -388,13 +383,13 @@ 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 );
 	
 	// Lock thread list
-	LOCK( &giThreadListLock );
+	LOCK( &glThreadListLock );
 	
 	// Get previous thread on list
 	prev = Threads_int_GetPrev( &gActiveThreads, Thread );
@@ -416,7 +411,9 @@ 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;
+	//Log("Threads_Kill: giFreeTickets = %i", giFreeTickets);
 	
 	// Mark thread as a zombie
 	Thread->RetStatus = Status;
@@ -432,44 +429,49 @@ void Threads_Kill(tThread *Thread, int Status)
 	
 	// Release spinlocks
 	RELEASE( &Thread->IsLocked );	// Released first so that it IS released
-	RELEASE( &giThreadListLock );
+	RELEASE( &glThreadListLock );
+	
+	//Log("Thread %i went *hurk*", Thread->TID);
+	
 	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 );
+	LOCK( &glThreadListLock );
 	
 	// 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();
+		RELEASE( &glThreadListLock );
 		return;
 	}
 	
 	// Don't sleep if there is a message waiting
 	if( cur->Messages ) {
-		RELEASE( &giThreadListLock );
+		RELEASE( &glThreadListLock );
 		return;
 	}
 	
@@ -485,199 +487,337 @@ void Threads_Sleep()
 	
 	// Reduce the active count & ticket count
 	giNumActiveThreads --;
-	giTotalTickets -= cur->NumTickets;
 	
 	// Mark thread as sleeping
 	cur->Status = THREAD_STAT_SLEEPING;
 	
 	// Release Spinlock
-	RELEASE( &giThreadListLock );
+	RELEASE( &glThreadListLock );
 	
-	HALT();
+	while(cur->Status != THREAD_STAT_ACTIVE)	HALT();
 }
 
 
-/**c0108919:
- * \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)
  */
-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_ACTIVE:
+		Log("Thread_Wake: Waking awake thread (%i)", Thread->TID);
+		return -EALREADY;
 	case THREAD_STAT_SLEEPING:
-		LOCK( &giThreadListLock );
+		//Log_Log("Threads", "Waking %i (%p) from sleeping (CPU=%i)",
+		//	Thread->TID, Thread, Thread->CurCPU);
+		LOCK( &glThreadListLock );
 		prev = Threads_int_GetPrev(&gSleepingThreads, Thread);
 		prev->Next = Thread->Next;	// Remove from sleeping queue
 		Thread->Next = gActiveThreads;	// Add to active queue
 		gActiveThreads = Thread;
+		giNumActiveThreads ++;
+		// Thread can't be the current, so no need to check
+		Thread->CurCPU = -1;
+		giFreeTickets += Thread->NumTickets;
+		#if DEBUG_TRACE_TICKETS
+		Log("Threads_Wake: giFreeTickets = %i", giFreeTickets);
+		#endif
 		Thread->Status = THREAD_STAT_ACTIVE;
-		RELEASE( &giThreadListLock );
-		break;
+		RELEASE( &glThreadListLock );
+		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);
+	if(!thread)
+		return -ENOENT;
+	return Threads_Wake( thread );
+}
+
 /**
  * \fn void Threads_AddActive(tThread *Thread)
  * \brief Adds a thread to the active queue
  */
 void Threads_AddActive(tThread *Thread)
 {
-	LOCK( &giThreadListLock );
+	LOCK( &glThreadListLock );
 	Thread->Next = gActiveThreads;
 	gActiveThreads = Thread;
 	giNumActiveThreads ++;
-	giTotalTickets += Thread->NumTickets;
-	//Log("Threads_AddActive: giNumActiveThreads = %i, giTotalTickets = %i",
-	//	giNumActiveThreads, giTotalTickets);
-	RELEASE( &giThreadListLock );
+	// Thread can't be the current, so no need to check
+	giFreeTickets += Thread->NumTickets;
+	#if DEBUG_TRACE_TICKETS
+	Log("Threads_AddActive: giFreeTickets = %i", giFreeTickets);
+	#endif
+	RELEASE( &glThreadListLock );
 }
 
-#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)
- * \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("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()
+ * \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("  %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(" %i (%i) - %s",
+			thread->TID, thread->TGID, thread->ThreadName);
 		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;
 	
-	if(giNumActiveThreads == 0)	return NULL;
+	// TODO: Enable the code to tell if the current CPU has the lock or
+	//       another does.
+	
+	// Check if the thread list is locked by other code
+	// - If so, don't switch (give it a chance to complete)
+	if( IS_LOCKED(&glThreadListLock) )
+		return Last;
+	
+	// Clear Delete Queue
+	while(gDeleteThreads)
+	{
+		thread = gDeleteThreads->Next;
+		if(gDeleteThreads->IsLocked) {	// Only free if structure is unused
+			gDeleteThreads->Status = THREAD_STAT_NULL;
+			free( gDeleteThreads );
+		}
+		gDeleteThreads = thread;
+	}
+	
+	// No active threads, just take a nap
+	if(giNumActiveThreads == 0) {
+		#if DEBUG_TRACE_TICKETS
+		Log("No active threads");
+		#endif
+		return NULL;
+	}
+	
+	// Lock thread list
+	// - HLT lock (Used because only another CPU can obtain the lock,
+	//   but it has a potentially long lock period)
+	// - Well, this CPU can obtain the lock, but that is aliveviated by
+	//   the above.
+	TIGHTLOCK( &glThreadListLock );
 	
 	// Special case: 1 thread
 	if(giNumActiveThreads == 1) {
-		return gActiveThreads;
+		if( gActiveThreads->CurCPU == -1 )
+			gActiveThreads->CurCPU = CPU;
+		RELEASE( &glThreadListLock );
+		if( gActiveThreads->CurCPU == CPU )
+			return gActiveThreads;
+		return NULL;	// CPU has nothing to do
 	}
 	
-	//Log(" Threads_GetNextToRun: giNumActiveThreads=%i,giTotalTickets=%i",
-	//	giNumActiveThreads, giTotalTickets);
-	// Get the ticket number
-	ticket = number = rand() % giTotalTickets;
+	// 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 (%s) into the pool (%i tickets in pool)\n",
+				CPU, Last, Last->ThreadName, Last->NumTickets);
+			#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 ) {
+		RELEASE(&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 (%s CPU=%i)\n",
+		CPU, giFreeTickets, thread, thread->ThreadName, thread->CurCPU);
+	#endif
+	
+	RELEASE( &glThreadListLock );
 	
 	return thread;
 }
@@ -688,7 +828,10 @@ tThread *Threads_GetNextToRun(int CPU)
  */
 void Threads_SegFault(tVAddr Addr)
 {
-	//Threads_SendSignal( Proc_GetCurThread()->TID, SIGSEGV );
-	Log("Thread #%i committed a segfault at address %p\n", Proc_GetCurThread()->TID, Addr);
-	Threads_Exit( 0, 0 );
+	Warning("Thread #%i committed a segfault at address %p", Proc_GetCurThread()->TID, Addr);
+	Threads_Fault( 1 );
+	//Threads_Exit( 0, -1 );
 }
+
+// === EXPORTS ===
+EXPORT(Threads_GetUID);