/*
* Wake up one thread waiting on the given condition.
* The mutex guarding the condition should be held!
*/
void Cond_Signal(struct Condition* cond)
{
KASSERT(Interrupts_Enabled());
Disable_Interrupts(); /* prevent scheduling */
Wake_Up_One(&cond->waitQueue);
Enable_Interrupts(); /* resume scheduling */
}
/* Verhogen */
int V(int sid)
{
if (!validateSID(sid)) {
return EINVALID;
}
bool atomic = Begin_Int_Atomic();
g_Semaphores[sid].resources++;
if (g_Semaphores[sid].resources == 1) {
/* from 0 to 1 we might wake up one */
Wake_Up_One(&g_Semaphores[sid].waitingThreads);
}
End_Int_Atomic(atomic);
return 0;
}
/*
* Unlock given mutex.
* Preemption must be disabled.
*/
static __inline__ void Mutex_Unlock_Imp(struct Mutex* mutex)
{
KASSERT(g_preemptionDisabled);
/* Make sure mutex was actually acquired by this thread. */
KASSERT(IS_HELD(mutex));
/* Unlock the mutex. */
mutex->state = MUTEX_UNLOCKED;
mutex->owner = 0;
/*
* If there are threads waiting to acquire the mutex,
* wake one of them up. Note that it is legal to inspect
* the queue with interrupts enabled because preemption
* is disabled, and therefore we know that no thread can
* concurrently add itself to the queue.
*/
if (!Is_Thread_Queue_Empty(&mutex->waitQueue)) {
Disable_Interrupts();
Wake_Up_One(&mutex->waitQueue);
Enable_Interrupts();
}
}