#include "synch.h"
#include "interrupt.h"
#include "lib.h"
-#include "malloc.h"
#include "thread.h"
/* One thread in a list. */
struct thread_elem
{
- struct list_elem elem;
+ list_elem elem;
struct thread *thread;
};
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)
{
- enum if_level old_level;
+ enum intr_level old_level;
ASSERT (sema != NULL);
ASSERT (!intr_context ());
struct thread_elem te;
te.thread = thread_current ();
list_push_back (&sema->waiters, &te.elem);
- thread_sleep ();
+ thread_block ();
}
sema->value--;
intr_set_level (old_level);
void
sema_up (struct semaphore *sema)
{
- enum if_level old_level;
+ enum intr_level old_level;
ASSERT (sema != NULL);
old_level = intr_disable ();
if (!list_empty (&sema->waiters))
- thread_ready (list_entry (list_pop_front (&sema->waiters),
- struct thread_elem, elem)->thread);
+ thread_unblock (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)
{
- enum if_level old_level;
+ enum intr_level old_level;
ASSERT (lock != NULL);
ASSERT (!intr_context ());
void
lock_release (struct lock *lock)
{
- enum if_level old_level;
+ enum intr_level old_level;
ASSERT (lock != NULL);
ASSERT (lock_held_by_current_thread (lock));
/* One semaphore in a list. */
struct semaphore_elem
{
- struct list_elem elem;
+ list_elem elem;
struct semaphore semaphore;
};
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)
{