Rewrite page allocator to support multi-page allocations.

[pintos-anon] / src / threads / thread.c

diff --git a/src/threads/thread.c b/src/threads/thread.c
index fc358de69a4fe6a3cab2dff5dc594d43515d242c..e85bc164d172094839124f6e818f23c7946957e9 100644 (file)
--- a/src/threads/thread.c
+++ b/src/threads/thread.c
@@ -12,8 +12,7 @@
 #include "threads/switch.h"
 #include "threads/synch.h"
 #ifdef USERPROG
-#include "userprog/addrspace.h"
-#include "userprog/gdt.h"
+#include "userprog/process.h"
 #endif
 
 /* Random value for struct thread's `magic' member.
@@ -47,11 +46,9 @@ static void kernel_thread (thread_func *, void *aux);
 static void idle (void *aux UNUSED);
 static struct thread *running_thread (void);
 static struct thread *next_thread_to_run (void);
-static struct thread *new_thread (const char *name, int priority);
 static void init_thread (struct thread *, const char *name, int priority);
 static bool is_thread (struct thread *);
 static void *alloc_frame (struct thread *, size_t size);
-static void destroy_thread (struct thread *);
 static void schedule (void);
 void schedule_tail (struct thread *prev);
 static tid_t allocate_tid (void);
@@ -71,15 +68,13 @@ thread_init (void)
   ASSERT (intr_get_level () == INTR_OFF);
 
   lock_init (&tid_lock, "tid");
+  list_init (&ready_list);
 
   /* Set up a thread structure for the running thread. */
   initial_thread = running_thread ();
   init_thread (initial_thread, "main", PRI_DEFAULT);
   initial_thread->status = THREAD_RUNNING;
   initial_thread->tid = allocate_tid ();
-
-  /* Initialize run queue. */
-  list_init (&ready_list);
 }
 
 /* Starts preemptive thread scheduling by enabling interrupts.
@@ -116,10 +111,14 @@ thread_create (const char *name, int priority,
 
   ASSERT (function != NULL);
 
-  t = new_thread (name, priority);
+  /* Allocate thread. */
+  t = palloc_get_page (PAL_ZERO);
   if (t == NULL)
     return TID_ERROR;
-  tid = t->tid;
+
+  /* Initialize thread. */
+  init_thread (t, name, priority);
+  tid = t->tid = allocate_tid ();
 
   /* Stack frame for kernel_thread(). */
   kf = alloc_frame (t, sizeof *kf);
@@ -198,6 +197,10 @@ thread_exit (void)
 {
   ASSERT (!intr_context ());
 
+#ifdef USERPROG
+  process_exit ();
+#endif
+
   /* Just set our status to dying and schedule another process.
      We will be destroyed during the call to schedule_tail(). */
   intr_disable ();
@@ -289,22 +292,6 @@ is_thread (struct thread *t)
   return t != NULL && t->magic == THREAD_MAGIC;
 }
 
-/* Creates a new thread named NAME as a child of the running
-   thread.  Returns the new thread if successful or a null
-   pointer on failure. */
-static struct thread *
-new_thread (const char *name, int priority)
-{
-  struct thread *t = palloc_get (PAL_ZERO);
-  if (t != NULL) 
-    {
-      init_thread (t, name, priority);
-      t->tid = allocate_tid ();
-    }
-
-  return t;
-}
-
 /* Does basic initialization of T as a blocked thread named
    NAME. */
 static void
@@ -349,20 +336,6 @@ next_thread_to_run (void)
     return list_entry (list_pop_front (&ready_list), struct thread, elem);
 }
 
-/* Destroys T, which must not be the running thread. */
-static void
-destroy_thread (struct thread *t) 
-{
-  ASSERT (is_thread (t));
-  ASSERT (t != thread_current ());
-
-#ifdef USERPROG
-  addrspace_destroy (t);
-#endif
-  if (t != initial_thread)
-    palloc_free (t);
-}
-
 /* Completes a thread switch by activating the new thread's page
    tables, and, if the previous thread is dying, destroying it.
 
@@ -387,14 +360,18 @@ schedule_tail (struct thread *prev)
 
 #ifdef USERPROG
   /* Activate the new address space. */
-  addrspace_activate ();
+  process_activate ();
 #endif
 
-  /* If the thread we switched from is dying, destroy it.
-     This must happen late because it's not a good idea to
-     e.g. destroy the page table you're currently using. */
+  /* If the thread we switched from is dying, destroy its struct
+     thread.  This must happen late so that thread_exit() doesn't
+     pull out the rug under itself. */
   if (prev != NULL && prev->status == THREAD_DYING) 
-    destroy_thread (prev);
+    {
+      ASSERT (prev != cur);
+      if (prev != initial_thread)
+        palloc_free_page (prev);
+    }
 }
 
 /* Schedules a new process.  At entry, interrupts must be off and