X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=Kernel%2Fthreads.c;h=297470cdbc5bc2d741ec04a978bed7be361acfda;hb=6f1c621ed4d24ddbdc863cd5ef684e919c8f8b55;hp=fb14f4d7f07117cf226d189e7725a7301335cfdc;hpb=f119d0e5b18b7286d04fc536a94e0f96e3c51714;p=tpg%2Facess2.git

diff --git a/Kernel/threads.c b/Kernel/threads.c
index fb14f4d7..297470cd 100644
--- a/Kernel/threads.c
+++ b/Kernel/threads.c
@@ -3,65 +3,70 @@
  * 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,	// e.g. CFG_VFS_CWD
+	CFGT_INT,	// e.g. CFG_VFS_MAXFILES
+	CFGT_NULL
+};
 
 // === IMPORTS ===
-extern void	ArchThreads_Init();
-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);
- int	Threads_GetPID();
- int	Threads_GetTID();
- int	Threads_GetUID();
- int	Threads_GetGID();
-void	Threads_Dump();
+void	Threads_Yield(void);
+void	Threads_Sleep(void);
+ int	Threads_Wake(tThread *Thread);
+void	Threads_AddActive(tThread *Thread);
+ 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
@@ -71,60 +76,149 @@ 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
-		for(;;)	__asm__ __volatile__ ("hlt");	// Just yeilds
-	}
-	#endif
+		
+	Proc_Start();
 }
 
 /**
  * \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() ) {
+		LOCK( &glThreadListLock );
+		giFreeTickets -= Thread->NumTickets - Num;
+		Thread->NumTickets = Num;
+		RELEASE( &glThreadListLock );
+	}
+	else
+		Thread->NumTickets = Num;
+}
+
+/**
+ * \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;
+	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 = 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;
+		}
+	}
+	
+	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];
 }
 
 /**
@@ -132,7 +226,7 @@ void Threads_SetTickets(int Num)
  * \brief Wait for a task to change state
  */
 int Threads_WaitTID(int TID, int *status)
-{
+{	
 	// Any Child
 	if(TID == -1) {
 		
@@ -155,16 +249,23 @@ 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)
 		{
 		case THREAD_STAT_ZOMBIE:
 			t->Status = THREAD_STAT_DEAD;
-			*status = 0;
+			if(status)	*status = 0;
+			Threads_AddToDelete( t );
 			break;
 		default:
-			*status = -1;
+			if(status)	*status = -1;
 			break;
 		}
 		return ret;
@@ -176,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)
 {
@@ -203,7 +305,23 @@ tThread *Threads_GetThread(Uint TID)
 }
 
 /**
- * \fn tThread *Threads_int_GetPrev(tThread *List, tThread *Thread)
+ * \fn void Threads_AddToDelete(tThread *Thread)
+ * \brief Adds a thread to the delete queue
+ */
+void Threads_AddToDelete(tThread *Thread)
+{
+	// Add to delete queue
+	if(gDeleteThreads) {
+		Thread->Next = gDeleteThreads;
+		gDeleteThreads = Thread;
+	} else {
+		Thread->Next = NULL;
+		gDeleteThreads = 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)
@@ -231,13 +349,20 @@ 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 );
+	// 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)
 {
@@ -252,19 +377,19 @@ 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);
 		}
 	}
 	#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 );
@@ -286,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;
@@ -295,58 +422,56 @@ void Threads_Kill(tThread *Thread, int Status)
 	if(Status == -1)
 	{
 		Thread->Status = THREAD_STAT_DEAD;
-		// Add to delete queue
-		if(gDeleteThreads) {
-			Thread->Next = gDeleteThreads;
-			gDeleteThreads = Thread;
-		} else {
-			Thread->Next = NULL;
-			gDeleteThreads = Thread;
-		}
+		Threads_AddToDelete( Thread );
 	} else {
 		Thread->Status = THREAD_STAT_ZOMBIE;
 	}
 	
 	// 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()->Quantum = 0;
+	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", gCurrentThread->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;
 	}
 	
@@ -362,87 +487,351 @@ 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();
 }
 
 
 /**
- * \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( &glThreadListLock );
+	Thread->Next = gActiveThreads;
+	gActiveThreads = Thread;
+	giNumActiveThreads ++;
+	// 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 );
+}
+
+/**
+ * \fn void Threads_SetFaultHandler(Uint Handler)
+ * \brief Sets the signal handler for a signal
+ */
+void Threads_SetFaultHandler(Uint Handler)
+{	
+	Log_Log("Threads", "Threads_SetFaultHandler: Handler = %p", Handler);
+	Proc_GetCurThread()->FaultHandler = Handler;
+}
+
+/**
+ * \fn void Threads_Fault(int Num)
+ * \brief Calls a fault handler
+ */
+void Threads_Fault(int Num)
+{
+	tThread	*thread = Proc_GetCurThread();
+	
+	Log_Log("Threads", "Threads_Fault: thread = %p", thread);
+	
+	if(!thread)	return ;
+	
+	Log_Log("Threads", "Threads_Fault: thread->FaultHandler = %p", thread->FaultHandler);
+	
+	switch(thread->FaultHandler)
+	{
+	case 0:	// Panic?
+		Threads_Kill(thread, -1);
+		HALT();
+		return ;
+	case 1:	// Dump Core?
+		Threads_Kill(thread, -1);
+		HALT();
+		return ;
 	}
+	
+	// Double Fault? Oh, F**k
+	if(thread->CurFaultNum != 0) {
+		Threads_Kill(thread, -1);	// For now, just kill
+		HALT();
+	}
+	
+	thread->CurFaultNum = Num;
+	
+	Proc_CallFaultHandler(thread);
 }
 
 // --- 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, 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 *Last)
+{
+	tThread	*thread;
+	 int	ticket;
+	 int	number;
+	
+	// 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) {
+		if( gActiveThreads->CurCPU == -1 )
+			gActiveThreads->CurCPU = CPU;
+		RELEASE( &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 (%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;
+	}
+	
+	#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) {
+			if(thread->CurCPU >= 0)	continue;
+			number += thread->NumTickets;
+		}
+		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;
+}
+
+/**
+ * \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);