#include "synch.h"
#include "interrupt.h"
#include "lib.h"
-#include "malloc.h"
#include "thread.h"
/* One thread in a list. */
atomically decrements it.
This function may sleep, so it must not be called within an
- interrupt handler. */
+ interrupt handler. This function may be called with
+ interrupts disabled, but interrupts will be turned back on if
+ we need to sleep. */
void
sema_down (struct semaphore *sema)
{
old_level = intr_disable ();
if (!list_empty (&sema->waiters))
- thread_ready (list_entry (list_pop_front (&sema->waiters),
- struct thread_elem, elem)->thread);
+ thread_wake (list_entry (list_pop_front (&sema->waiters),
+ struct thread_elem, elem)->thread);
sema->value++;
intr_set_level (old_level);
}
\f
/* Initializes LOCK and names it NAME (for debugging purposes).
A lock can be held by at most a single thread at any given
- time. Our locks are not "recursive", meaning that it is an
- error for a thread that holds a lock to attempt to reacquire
- it.
+ time. Our locks are not "recursive", that is, it is an error
+ for the thread currently holding a lock to try to acquire that
+ lock.
A lock is a specialization of a semaphore with an initial
value of 1. The difference between a lock and such a
thread.
This function may sleep, so it must not be called within an
- interrupt handler. */
+ interrupt handler. This function may be called with
+ interrupts disabled, but interrupts will be turned back on if
+ we need to sleep. */
void
lock_acquire (struct lock *lock)
{
from locks to condition variables.
This function may sleep, so it must not be called within an
- interrupt handler. */
+ interrupt handler. This function may be called with
+ interrupts disabled, but interrupts will be turned back on if
+ we need to sleep. */
void
cond_wait (struct condition *cond, struct lock *lock)
{