X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;ds=sidebyside;f=Kernel%2Fthreads.c;h=610f7b5d3735e92271954f015d2b190bb27732e2;hb=2a05bcd81312a2885f824dac79e82c01a6e60c6c;hp=53756edbfb70d9e838f1f99db602bb264b90d95e;hpb=6488590bbc291c99612e1efee0070b73109a1b3c;p=tpg%2Facess2.git

diff --git a/Kernel/threads.c b/Kernel/threads.c
index 53756edb..610f7b5d 100644
--- a/Kernel/threads.c
+++ b/Kernel/threads.c
@@ -7,6 +7,9 @@
 #include <threads.h>
 #include <errno.h>
 
+#define DEBUG_TRACE_TICKETS	0	// Trace ticket counts
+#define DEBUG_TRACE_STATE	0	// Trace state changes (sleep/wake)
+
 // === CONSTANTS ===
 #define	DEFAULT_QUANTUM	10
 #define	DEFAULT_TICKETS	5
@@ -28,7 +31,7 @@ extern void	Proc_CallFaultHandler(tThread *Thread);
 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);
@@ -38,8 +41,9 @@ void	Threads_Exit(int TID, int Status);
 void	Threads_Kill(tThread *Thread, int Status);
 void	Threads_Yield(void);
 void	Threads_Sleep(void);
-void	Threads_Wake(tThread *Thread);
+ int	Threads_Wake(tThread *Thread);
 void	Threads_AddActive(tThread *Thread);
+tThread	*Threads_RemActive(void);
  int	Threads_GetPID(void);
  int	Threads_GetTID(void);
 tUID	Threads_GetUID(void);
@@ -47,6 +51,9 @@ tUID	Threads_GetUID(void);
 tGID	Threads_GetGID(void);
  int	Threads_SetGID(Uint *Errno, tUID ID);
 void	Threads_Dump(void);
+void	Mutex_Acquire(tMutex *Mutex);
+void	Mutex_Release(tMutex *Mutex);
+ int	Mutex_IsLocked(tMutex *Mutex);
 
 // === GLOBALS ===
 // -- Core Thread --
@@ -54,18 +61,19 @@ void	Threads_Dump(void);
 tThread	gThreadZero = {
 	Status: THREAD_STAT_ACTIVE,	// Status
 	ThreadName:	"ThreadZero",	// Name
-	Quantum: DEFAULT_QUANTUM, Remaining:	DEFAULT_QUANTUM,	// Quantum, Remaining
-	NumTickets:	DEFAULT_TICKETS
+	Quantum: DEFAULT_QUANTUM,	// Default Quantum
+	Remaining:	DEFAULT_QUANTUM,	// Current Quantum
+	NumTickets:	DEFAULT_TICKETS	// Number of tickets
 	};
 // -- Processes --
 // --- Locks ---
-tSpinlock	glThreadListLock = 0;	///\note NEVER use a heap function while locked
+tShortSpinlock	glThreadListLock;	///\note NEVER use a heap function while locked
 // --- Current State ---
 volatile int	giNumActiveThreads = 0;
-//volatile int	giTotalTickets = 0;
 volatile int	giFreeTickets = 0;
 volatile Uint	giNextTID = 1;
 // --- Thread Lists ---
+tThread	*gAllThreads = NULL;		// All allocated threads
 tThread	*gActiveThreads = NULL;		// Currently Running Threads
 tThread	*gSleepingThreads = NULL;	// Sleeping Threads
 tThread	*gDeleteThreads = NULL;		// Threads to delete
@@ -119,16 +127,24 @@ char *Threads_GetName(int ID)
 }
 
 /**
- * \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;
 	
-	cur->NumTickets = Num;
+	if( Thread != Proc_GetCurThread() ) {
+		SHORTLOCK( &glThreadListLock );
+		giFreeTickets -= Thread->NumTickets - Num;
+		Thread->NumTickets = Num;
+		SHORTREL( &glThreadListLock );
+	}
+	else
+		Thread->NumTickets = Num;
 }
 
 /**
@@ -149,16 +165,15 @@ tThread *Threads_CloneTCB(Uint *Err, Uint Flags)
 	
 	new->CurCPU = -1;
 	new->Next = NULL;
-	new->IsLocked = 0;
+	memset( &new->IsLocked, 0, sizeof(new->IsLocked));
 	new->Status = THREAD_STAT_ACTIVE;
 	new->RetStatus = 0;
 	
 	// Get Thread ID
 	new->TID = giNextTID++;
-	new->PTID = cur->TID;
+	new->Parent = cur;
 	
 	// Clone Name
-	Log("Threads_CloneTCB: cur (%p) ->ThreadName = %p", cur, cur->ThreadName);
 	new->ThreadName = strdup(cur->ThreadName);
 	
 	// Set Thread Group ID (PID)
@@ -195,6 +210,13 @@ tThread *Threads_CloneTCB(Uint *Err, Uint Flags)
 		}
 	}
 	
+	// Maintain a global list of threads
+	SHORTLOCK( &glThreadListLock );
+	new->GlobalPrev = NULL;	// Protect against bugs
+	new->GlobalNext = gAllThreads;
+	gAllThreads = new;
+	SHORTREL( &glThreadListLock );
+	
 	return new;
 }
 
@@ -212,25 +234,27 @@ Uint *Threads_GetCfgPtr(int Id)
 }
 
 /**
- * \fn void Threads_WaitTID(int TID, int *status)
+ * \fn tTID Threads_WaitTID(int TID, int *status)
  * \brief Wait for a task to change state
+ * \return TID of child that changed state
  */
 int Threads_WaitTID(int TID, int *status)
 {	
 	// Any Child
 	if(TID == -1) {
-		
+		Log_Error("Threads", "TODO: Threads_WaitTID(TID=-1) - Any Child");
 		return -1;
 	}
 	
 	// Any peer/child thread
 	if(TID == 0) {
-		
+		Log_Error("Threads", "TODO: Threads_WaitTID(TID=0) - Any Child/Sibling");
 		return -1;
 	}
 	
 	// TGID = abs(TID)
 	if(TID < -1) {
+		Log_Error("Threads", "TODO: Threads_WaitTID(TID<0) - TGID");
 		return -1;
 	}
 	
@@ -241,17 +265,25 @@ int Threads_WaitTID(int TID, int *status)
 		 int	ret;
 		
 		if(initStatus != THREAD_STAT_ZOMBIE) {
-			while(t->Status == initStatus) {
-				Threads_Yield();
+			// 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);
 			}
 		}
 		
+		Log_Debug("Threads", "%i waiting for %i, t->Status = %i",
+			Threads_GetTID(), t->TID, t->Status);
 		ret = t->RetStatus;
 		switch(t->Status)
 		{
 		case THREAD_STAT_ZOMBIE:
+			// Kill the thread
 			t->Status = THREAD_STAT_DEAD;
+			// TODO: Child return value?
 			if(status)	*status = 0;
+			// add to delete queue
 			Threads_AddToDelete( t );
 			break;
 		default:
@@ -273,19 +305,10 @@ tThread *Threads_GetThread(Uint TID)
 {
 	tThread *thread;
 	
-	// Search Active List
-	for(thread = gActiveThreads;
+	// Search global list
+	for(thread = gAllThreads;
 		thread;
-		thread = thread->Next)
-	{
-		if(thread->TID == TID)
-			return thread;
-	}
-	
-	// Search Sleeping List
-	for(thread = gSleepingThreads;
-		thread;
-		thread = thread->Next)
+		thread = thread->GlobalNext)
 	{
 		if(thread->TID == TID)
 			return thread;
@@ -376,15 +399,17 @@ void Threads_Kill(tThread *Thread, int Status)
 	///\note Double lock is needed due to overlap of lock areas
 	
 	// Lock thread (stop us recieving messages)
-	LOCK( &Thread->IsLocked );
+	SHORTLOCK( &Thread->IsLocked );
 	
 	// Lock thread list
-	LOCK( &glThreadListLock );
+	SHORTLOCK( &glThreadListLock );
 	
 	// Get previous thread on list
 	prev = Threads_int_GetPrev( &gActiveThreads, Thread );
 	if(!prev) {
 		Warning("Proc_Exit - Current thread is not on the active queue");
+		SHORTREL( &Thread->IsLocked );
+		SHORTREL( &glThreadListLock );
 		return;
 	}
 	
@@ -404,7 +429,7 @@ void Threads_Kill(tThread *Thread, int Status)
 	if( Thread != Proc_GetCurThread() )
 		giFreeTickets -= Thread->NumTickets;
 	
-	// Mark thread as a zombie
+	// Save exit status
 	Thread->RetStatus = Status;
 	
 	// Don't Zombie if we are being killed as part of a tree
@@ -414,13 +439,15 @@ void Threads_Kill(tThread *Thread, int Status)
 		Threads_AddToDelete( Thread );
 	} else {
 		Thread->Status = THREAD_STAT_ZOMBIE;
+		// Wake parent
+		Threads_Wake( Thread->Parent );
 	}
 	
-	// Release spinlocks
-	RELEASE( &Thread->IsLocked );	// Released first so that it IS released
-	RELEASE( &glThreadListLock );
+	Log("Thread %i went *hurk* (%i)", Thread->TID, Thread->Status);
 	
-	//Log("Thread %i went *hurk*", Thread->TID);
+	// Release spinlocks
+	SHORTREL( &Thread->IsLocked );
+	SHORTREL( &glThreadListLock );
 	
 	if(Status != -1)	HALT();
 }
@@ -442,93 +469,108 @@ void Threads_Yield(void)
 void Threads_Sleep(void)
 {
 	tThread *cur = Proc_GetCurThread();
-	tThread *thread;
 	
 	//Log_Log("Threads", "%i going to sleep", cur->TID);
 	
 	// Acquire Spinlock
-	LOCK( &glThreadListLock );
-	
-	// Get thread before current thread
-	thread = Threads_int_GetPrev( &gActiveThreads, cur );
-	if(!thread) {
-		Warning("Threads_Sleep - Current thread is not on the active queue");
-		Threads_Dump();
-		RELEASE( &glThreadListLock );
-		return;
-	}
+	SHORTLOCK( &glThreadListLock );
 	
 	// Don't sleep if there is a message waiting
 	if( cur->Messages ) {
-		RELEASE( &glThreadListLock );
+		SHORTREL( &glThreadListLock );
 		return;
 	}
 	
-	// Unset remaining timeslices (force a task switch on timer fire)
-	cur->Remaining = 0;
-	
-	// Remove from active list
-	thread->Next = cur->Next;
+	// Remove us from running queue
+	Threads_RemActive();
 	
 	// Add to Sleeping List (at the top)
 	cur->Next = gSleepingThreads;
 	gSleepingThreads = cur;
 	
-	// Reduce the active count & ticket count
-	giNumActiveThreads --;
-	//giTotalTickets -= cur->NumTickets;
-	
 	// Mark thread as sleeping
 	cur->Status = THREAD_STAT_SLEEPING;
 	
+	#if DEBUG_TRACE_STATE
+	Log("Threads_Sleep: %p (%i %s) sleeping", cur, cur->TID, cur->ThreadName);
+	#endif
+	
 	// Release Spinlock
-	RELEASE( &glThreadListLock );
+	SHORTREL( &glThreadListLock );
 	
 	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)
+ * \note Should be called with the scheduler lock held
  */
-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_SLEEPING:
-		//Log_Log("Threads", "Waking %i (%p) from sleeping", Thread->TID, Thread);
-		LOCK( &glThreadListLock );
+	case THREAD_STAT_ACTIVE:
+		Log("Thread_Wake: Waking awake thread (%i)", Thread->TID);
+		return -EALREADY;
+	
+	case THREAD_STAT_SLEEPING:	// TODO: Comment better
+		// Remove from sleeping queue
 		prev = Threads_int_GetPrev(&gSleepingThreads, Thread);
-		prev->Next = Thread->Next;	// Remove from sleeping queue
-		Thread->Next = gActiveThreads;	// Add to active queue
+		prev->Next = Thread->Next;
+		// Add to active queue
+		Thread->Next = gActiveThreads;
 		gActiveThreads = Thread;
+		// Update bookkeeping
 		giNumActiveThreads ++;
-		// Thread can't be the current, so no need to check
 		giFreeTickets += Thread->NumTickets;
+		#if DEBUG_TRACE_TICKETS
+		Log("Threads_Wake: new giFreeTickets = %i", giFreeTickets);
+		#endif
+		Thread->CurCPU = -1;
 		Thread->Status = THREAD_STAT_ACTIVE;
-		RELEASE( &glThreadListLock );
-		break;
+		#if DEBUG_TRACE_STATE
+		Log("Threads_Sleep: %p (%i %s) woken", Thread, Thread->TID, Thread->ThreadName);
+		#endif
+		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)
  */
-void Threads_WakeTID(tTID Thread)
+int Threads_WakeTID(tTID TID)
 {
-	Threads_Wake( Threads_GetThread(Thread) );
+	tThread	*thread = Threads_GetThread(TID);
+	 int	ret;
+	if(!thread)
+		return -ENOENT;
+	SHORTLOCK( &glThreadListLock );
+	ret = Threads_Wake( thread );
+	SHORTREL( &glThreadListLock );
+	return ret;
 }
 
 /**
@@ -537,15 +579,34 @@ void Threads_WakeTID(tTID Thread)
  */
 void Threads_AddActive(tThread *Thread)
 {
-	LOCK( &glThreadListLock );
+	SHORTLOCK( &glThreadListLock );
+	// Add to active list
 	Thread->Next = gActiveThreads;
 	gActiveThreads = Thread;
+	// Update bookkeeping
 	giNumActiveThreads ++;
-	// Thread can't be the current, so no need to check
 	giFreeTickets += Thread->NumTickets;
-	//Log("Threads_AddActive: giNumActiveThreads = %i, giTotalTickets = %i",
-	//	giNumActiveThreads, giTotalTickets);
-	RELEASE( &glThreadListLock );
+	#if DEBUG_TRACE_TICKETS
+	Log("Threads_AddActive: new giFreeTickets = %i", giFreeTickets);
+	#endif
+	SHORTREL( &glThreadListLock );
+}
+
+/**
+ * \brief Removes the current thread from the active queue
+ * \warning This should ONLY be called with task switches disabled
+ * \return Current thread pointer
+ */
+tThread *Threads_RemActive(void)
+{
+	tThread	*ret = Proc_GetCurThread();
+	tThread	*prev = Threads_int_GetPrev(&gActiveThreads, ret);
+	if(!prev)	return NULL;
+	ret->Remaining = 0;
+	ret->CurCPU = -1;
+	prev->Next = ret->Next;
+	giNumActiveThreads --;
+	return ret;
 }
 
 /**
@@ -554,7 +615,7 @@ void Threads_AddActive(tThread *Thread)
  */
 void Threads_SetFaultHandler(Uint Handler)
 {	
-	Log_Log("Threads", "Threads_SetFaultHandler: Handler = %p", Handler);
+	//Log_Debug("Threads", "Threads_SetFaultHandler: Handler = %p", Handler);
 	Proc_GetCurThread()->FaultHandler = Handler;
 }
 
@@ -620,7 +681,7 @@ int Threads_SetUID(Uint *Errno, tUID ID)
 		*Errno = -EACCES;
 		return -1;
 	}
-	Log("Threads_SetUID - Setting User ID to %i", ID);
+	Log_Debug("Threads", "TID %i's UID set to %i", t->TID, ID);
 	t->UID = ID;
 	return 0;
 }
@@ -632,7 +693,7 @@ int Threads_SetGID(Uint *Errno, tGID ID)
 		*Errno = -EACCES;
 		return -1;
 	}
-	Log("Threads_SetGID - Setting Group ID to %i", ID);
+	Log_Debug("Threads", "TID %i's GID set to %i", t->TID, ID);
 	t->GID = ID;
 	return 0;
 }
@@ -644,22 +705,23 @@ int Threads_SetGID(Uint *Errno, tGID ID)
 void Threads_Dump(void)
 {
 	tThread	*thread;
-	tThread	*cur = Proc_GetCurThread();
 	
 	Log("Active Threads:");
 	for(thread=gActiveThreads;thread;thread=thread->Next)
 	{
 		Log(" %i (%i) - %s (CPU %i)",
 			thread->TID, thread->TGID, thread->ThreadName, thread->CurCPU);
+		Log("  State: %i", thread->Status);
 		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("All Threads:");
+	for(thread=gAllThreads;thread;thread=thread->GlobalNext)
 	{
-		Log("%c%i (%i) - %s",
-			(thread==cur?'*':' '),
-			thread->TID, thread->TGID, thread->ThreadName);
+		Log(" %i (%i) - %s (CPU %i)",
+			thread->TID, thread->TGID, thread->ThreadName, thread->CurCPU);
+		Log("  State: %i", thread->Status);
 		Log("  %i Tickets, Quantum %i", thread->NumTickets, thread->Quantum);
 		Log("  KStack 0x%x", thread->KernelStack);
 	}
@@ -675,33 +737,45 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last)
 {
 	tThread	*thread;
 	 int	ticket;
-	 int	number;
+	 int	number;	
 	
-	// Note: Enable the code to tell if the switch code has the lock, or
-	// if it's the other code.
+	// Lock thread list
+	SHORTLOCK( &glThreadListLock );
 	
-	// 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( IS_LOCKED(&gDeleteThreads->IsLocked) ) {	// Only free if structure is unused
+			// Set to dead
+			gDeleteThreads->Status = THREAD_STAT_DEAD;
+			// Free name
+			if( IsHeap(gDeleteThreads->ThreadName) )
+				free(gDeleteThreads->ThreadName);
+			// Remove from global list
+			if( gDeleteThreads == gAllThreads )
+				gAllThreads = gDeleteThreads->GlobalNext;
+			else
+				gDeleteThreads->GlobalPrev->GlobalNext = gDeleteThreads->GlobalNext;
+			free( gDeleteThreads );
+		}
+		gDeleteThreads = thread;
+	}
 	
 	// No active threads, just take a nap
 	if(giNumActiveThreads == 0) {
+		SHORTREL( &glThreadListLock );
+		#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 );
+		SHORTREL( &glThreadListLock );
 		if( gActiveThreads->CurCPU == CPU )
 			return gActiveThreads;
 		return NULL;	// CPU has nothing to do
@@ -709,14 +783,35 @@ tThread *Threads_GetNextToRun(int CPU, tThread *Last)
 	
 	// Allow the old thread to be scheduled again
 	if( Last ) {
-		if( Last->Status == THREAD_STAT_ACTIVE )
+		if( Last->Status == THREAD_STAT_ACTIVE ) {
 			giFreeTickets += Last->NumTickets;
+			#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);
+			#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);
+		SHORTREL(&glThreadListLock);
 		return NULL;
 	}
 	
@@ -741,12 +836,21 @@ 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\n", CPU, giFreeTickets);
+	#endif
 	
 	// Make the new thread non-schedulable
 	giFreeTickets -= thread->NumTickets;	
 	thread->CurCPU = CPU;
 	
-	RELEASE( &glThreadListLock );
+	//Threads_Dump();
+	#if DEBUG_TRACE_TICKETS
+	LogF(" CPU%i giFreeTickets = %i, giving %p (%i %s CPU=%i)\n",
+		CPU, giFreeTickets, thread, thread->TID, thread->ThreadName, thread->CurCPU);
+	#endif
+	
+	SHORTREL( &glThreadListLock );
 	
 	return thread;
 }
@@ -762,5 +866,87 @@ void Threads_SegFault(tVAddr Addr)
 	//Threads_Exit( 0, -1 );
 }
 
+/**
+ * \brief Acquire a heavy mutex
+ * \param Mutex	Mutex to acquire
+ * 
+ * This type of mutex checks if the mutex is avaliable, and acquires it
+ * if it is. Otherwise, the current thread is added to the mutex's wait
+ * queue and the thread suspends. When the holder of the mutex completes,
+ * the oldest thread (top thread) on the queue is given the lock and
+ * restarted.
+ */
+void Mutex_Acquire(tMutex *Mutex)
+{
+	tThread	*us = Proc_GetCurThread();
+	
+	// Get protector
+	SHORTLOCK( &Mutex->Protector );
+	
+	//Log("Mutex_Acquire: (%p)", Mutex);
+	
+	// Check if the lock is already held
+	if( Mutex->Owner ) {
+		SHORTLOCK( &glThreadListLock );
+		// - Remove from active list
+		Threads_RemActive();
+		// - Mark as sleeping
+		us->Status = THREAD_STAT_OFFSLEEP;
+		
+		// - Add to waiting
+		if(Mutex->LastWaiting) {
+			Mutex->LastWaiting->Next = us;
+			Mutex->LastWaiting = us;
+		}
+		else {
+			Mutex->Waiting = us;
+			Mutex->LastWaiting = us;
+		}
+		SHORTREL( &glThreadListLock );
+		SHORTREL( &Mutex->Protector );
+		while(us->Status == THREAD_STAT_OFFSLEEP)	HALT();
+		// We're only woken when we get the lock
+	}
+	// Ooh, let's take it!
+	else {
+		Mutex->Owner = us;
+		SHORTREL( &Mutex->Protector );
+	}
+}
+
+/**
+ * \brief Release a held mutex
+ * \param Mutex	Mutex to release
+ */
+void Mutex_Release(tMutex *Mutex)
+{
+	SHORTLOCK( &Mutex->Protector );
+	//Log("Mutex_Release: (%p)", Mutex);
+	if( Mutex->Waiting ) {
+		Mutex->Owner = Mutex->Waiting;	// Set owner
+		Mutex->Waiting = Mutex->Waiting->Next;	// Next!
+		// Wake new owner
+		Mutex->Owner->Status = THREAD_STAT_ACTIVE;
+		Threads_AddActive(Mutex->Owner);
+		//Log("Mutex %p Woke %p", Mutex, Mutex->Owner);
+	}
+	else {
+		Mutex->Owner = NULL;
+	}
+	SHORTREL( &Mutex->Protector );
+}
+
+/**
+ * \brief Is this mutex locked?
+ * \param Mutex	Mutex pointer
+ */
+int Mutex_IsLocked(tMutex *Mutex)
+{
+	return Mutex->Owner != NULL;
+}
+
 // === EXPORTS ===
 EXPORT(Threads_GetUID);
+EXPORT(Mutex_Acquire);
+EXPORT(Mutex_Release);
+EXPORT(Mutex_IsLocked);