static bool is_thread (struct thread *) UNUSED;
static void *alloc_frame (struct thread *, size_t size);
static void schedule (void);
-void schedule_tail (struct thread *prev);
+void thread_schedule_tail (struct thread *prev);
static tid_t allocate_tid (void);
/* Initializes the threading system by transforming the code
struct switch_entry_frame *ef;
struct switch_threads_frame *sf;
tid_t tid;
- enum intr_level old_level;
ASSERT (function != NULL);
init_thread (t, name, priority);
tid = t->tid = allocate_tid ();
- /* Prepare thread for first run by initializing its stack.
- Do this atomically so intermediate values for the 'stack'
- member cannot be observed. */
- old_level = intr_disable ();
-
/* Stack frame for kernel_thread(). */
kf = alloc_frame (t, sizeof *kf);
kf->eip = NULL;
sf->eip = switch_entry;
sf->ebp = 0;
- intr_set_level (old_level);
-
/* Add to run queue. */
thread_unblock (t);
/* Remove thread from all threads list, set our status to dying,
and schedule another process. That process will destroy us
- when it call schedule_tail(). */
+ when it calls thread_schedule_tail(). */
intr_disable ();
list_remove (&thread_current()->allelem);
thread_current ()->status = THREAD_DYING;
static void
init_thread (struct thread *t, const char *name, int priority)
{
+ enum intr_level old_level;
+
ASSERT (t != NULL);
ASSERT (PRI_MIN <= priority && priority <= PRI_MAX);
ASSERT (name != NULL);
t->stack = (uint8_t *) t + PGSIZE;
t->priority = priority;
t->magic = THREAD_MAGIC;
+
+ old_level = intr_disable ();
list_push_back (&all_list, &t->allelem);
+ intr_set_level (old_level);
}
/* Allocates a SIZE-byte frame at the top of thread T's stack and
After this function and its caller returns, the thread switch
is complete. */
void
-schedule_tail (struct thread *prev)
+thread_schedule_tail (struct thread *prev)
{
struct thread *cur = running_thread ();
running to some other state. This function finds another
thread to run and switches to it.
- It's not safe to call printf() until schedule_tail() has
- completed. */
+ It's not safe to call printf() until thread_schedule_tail()
+ has completed. */
static void
schedule (void)
{
if (cur != next)
prev = switch_threads (cur, next);
- schedule_tail (prev);
+ thread_schedule_tail (prev);
}
/* Returns a tid to use for a new thread. */