Fix bug where size of file name buffer was less than maximum file name size

Add support for some basic system calls and args handling correctly.

See merge request lab2425_autumn/pintos_22!29

src/filesys/file.h

@@ -4,6 +4,9 @@
 #include "filesys/off_t.h"
 #include <stdbool.h>
 
+/* The maximum length of a file name in PintOS. */
+#define FNAME_MAX_LEN 14
+
 struct inode;
 
 /* Opening and closing files. */

src/lib/user/syscall.c

@@ -166,7 +166,7 @@ mkdir (const char *dir)
 }
 
 bool
-readdir (int fd, char name[READDIR_MAX_LEN + 1]) 
+readdir (int fd, char name[FNAME_MAX_LEN + 1]) 
 {
   return syscall2 (SYS_READDIR, fd, name);
 }

src/lib/user/syscall.h

@@ -3,6 +3,7 @@
 
 #include <stdbool.h>
 #include <debug.h>
+#include "../../filesys/file.h"
 
 /* Process identifier. */
 typedef int pid_t;
@@ -12,9 +13,6 @@ typedef int pid_t;
 typedef int mapid_t;
 #define MAP_FAILED ((mapid_t) -1)
 
-/* Maximum characters in a filename written by readdir(). */
-#define READDIR_MAX_LEN 14
-
 /* Typical return values from main() and arguments to exit(). */
 #define EXIT_SUCCESS 0          /* Successful execution. */
 #define EXIT_FAILURE 1          /* Unsuccessful execution. */
@@ -41,7 +39,7 @@ void munmap (mapid_t);
 /* Task 4 only. */
 bool chdir (const char *dir);
 bool mkdir (const char *dir);
-bool readdir (int fd, char name[READDIR_MAX_LEN + 1]);
+bool readdir (int fd, char name[FNAME_MAX_LEN + 1]);
 bool isdir (int fd);
 int inumber (int fd);
 

src/threads/synch.c

@@ -113,28 +113,33 @@ void
 sema_up (struct semaphore *sema)
 {
   enum intr_level old_level;
+  bool thread_unblocked = false; /* Flag to track if any thread was woken up. */
 
   ASSERT (sema != NULL);
 
   old_level = intr_disable ();
   if (!list_empty (&sema->waiters))
-    {
-      /* Enforces wake-up of the highest priority thread waiting for the
-         semaphore. */
-      struct list_elem *e = list_max (&sema->waiters, priority_less, NULL);
-      list_remove (e);
-      thread_unblock (list_entry (e, struct thread, elem));
-    }
+  {
+    /* Enforces wake-up of the highest priority thread waiting for the
+       semaphore. */
+    struct list_elem *e = list_max (&sema->waiters, priority_less, NULL);
+    list_remove (e);
+    thread_unblock (list_entry (e, struct thread, elem));
+    thread_unblocked = true;
+  }
   sema->value++;
   intr_set_level (old_level);
 
   /* Yields the CPU in case the thread that has been woken up has a higher
      priority that the current running thread, including the case when called
      within an interrupt handler. */
-  if (intr_context ())
-    intr_yield_on_return ();
-  else
-    thread_yield ();
+  if (thread_unblocked)
+  {
+    if (intr_context ())
+      intr_yield_on_return ();
+    else
+      thread_yield ();
+  }
 }
 
 static void sema_test_helper (void *sema_);
@@ -347,7 +352,6 @@ lock_release (struct lock *lock)
 
   lock->holder = NULL;
   sema_up (&lock->semaphore);
-  thread_yield ();
 }
 
 /* Returns true if the current thread holds LOCK, false

src/threads/thread.c

@@ -659,6 +659,8 @@ init_thread (struct thread *t, const char *name, int nice, int priority,
   t->recent_cpu = recent_cpu;
   t->priority = t->base_priority;
 
+  t->exit_status = -1;
+
   old_level = intr_disable ();
   list_push_back (&all_list, &t->allelem);
   intr_set_level (old_level);

src/threads/thread.h

@@ -111,6 +111,7 @@ struct thread
     /* Shared between thread.c and synch.c. */
     struct list_elem elem;              /* List element. */
 
+    int exit_status;                    /* Exit Status: 0 = successful exit. */
 
 #ifdef USERPROG
     /* Owned by userprog/process.c. */

src/userprog/process.c

@@ -14,57 +14,127 @@
 #include "threads/flags.h"
 #include "threads/init.h"
 #include "threads/interrupt.h"
+#include "threads/synch.h"
 #include "threads/palloc.h"
+#include "threads/malloc.h"
 #include "threads/thread.h"
 #include "threads/vaddr.h"
+#include "threads/synch.h"
+#include "devices/timer.h"
+
+/* Defines the native number of bytes processed by the processor
+   (for the purposes of alignment). */
+#define WORD_SIZE 4
+
+/* Keeps track of the position of pointers to user program arguments
+   within a linked list. */
+struct arg_elem
+  {
+    char* arg;
+    struct list_elem elem;
+  };
+
+/* Holds the data required to be passed from a kernel thread to a thread
+   that executes process_start for the purpose of starting a user process. */
+struct process_start_data
+  {
+    char *cmd; /* Pointer to a copy of the command used to execute the process.
+                  Allocated a page that must be freed by process_start. */
+    char *cmd_saveptr; /* Value pointed to by 'saveptr' argument used by
+                          successive calls to strtok_r to split 'cmd' into
+                          tokens while maintaining state. */
+    char file_name[FNAME_MAX_LEN + 1]; /* Name of the file of the process to
+                                      be started. */
+  };
 
 static thread_func start_process NO_RETURN;
 static bool load (const char *cmdline, void (**eip) (void), void **esp);
 
-/* Starts a new thread running a user program loaded from
-   FILENAME.  The new thread may be scheduled (and may even exit)
+/* Starts a new thread running a user program executed via
+   CMD.  The new thread may be scheduled (and may even exit)
    before process_execute() returns.  Returns the new process's
    thread id, or TID_ERROR if the thread cannot be created. */
 tid_t
-process_execute (const char *file_name) 
+process_execute (const char *cmd) 
 {
-  char *fn_copy;
+  char *cmd_copy;
   tid_t tid;
+  
+  struct process_start_data *data = malloc (sizeof (struct process_start_data));
+  if (data == NULL)
+    {
+      return TID_ERROR;
+    }
 
-  /* Make a copy of FILE_NAME.
+  /* Make a copy of command.
      Otherwise there's a race between the caller and load(). */
-  fn_copy = palloc_get_page (0);
-  if (fn_copy == NULL)
+  cmd_copy = palloc_get_page (0);
+  if (cmd_copy == NULL)
     return TID_ERROR;
-  strlcpy (fn_copy, file_name, PGSIZE);
 
-  /* Create a new thread to execute FILE_NAME. */
-  tid = thread_create (file_name, PRI_DEFAULT, start_process, fn_copy);
+  /* Imposing implicit limit that the command line arguments
+    including the user program name fit within a single page. */
+  strlcpy (cmd_copy, cmd, PGSIZE);
+
+  /* Retrieve first argument of command, which is the file name
+     of the process. */
+  char *file_name = strtok_r (cmd_copy, " ", &data->cmd_saveptr);
+
+  /* Create a new thread to execute the command, by initializing
+     it running the function 'start_process' with the appropriate
+     arguments. For details of arguments, see 'start_process'. */
+  data->cmd = cmd_copy;
+  strlcpy (data->file_name, file_name, FNAME_MAX_LEN + 1);
+
+  tid = thread_create (file_name, PRI_DEFAULT, start_process, data);
   if (tid == TID_ERROR)
-    palloc_free_page (fn_copy); 
+    palloc_free_page (cmd_copy); 
   return tid;
 }
 
-/* A thread function that loads a user process and starts it
-   running. */
+static bool install_page (void *upage, void *kpage, bool writable);
+static bool process_init_stack (char *cmd_saveptr, void **esp, char *file_name);
+static void *push_to_stack (void **esp, void *data, size_t data_size);
+#define push_var_to_stack(esp, var) (push_to_stack (esp, &var, sizeof (var)))
+
+/* Make the current thread execute 'cmd', passing in a copy of the
+   command string used for processing, the saveptr used by strtok_r
+   (in order to further tokenize the same command and retrieve its
+   arguments), as well as the name of the file being executed. This
+   involves loading the specified file and starting it running. */
 static void
-start_process (void *file_name_)
+start_process (void *proc_start_data)
 {
-  char *file_name = file_name_;
   struct intr_frame if_;
   bool success;
 
+  struct process_start_data *data = proc_start_data;
+
   /* Initialize interrupt frame and load executable. */
   memset (&if_, 0, sizeof if_);
   if_.gs = if_.fs = if_.es = if_.ds = if_.ss = SEL_UDSEG;
   if_.cs = SEL_UCSEG;
   if_.eflags = FLAG_IF | FLAG_MBS;
-  success = load (file_name, &if_.eip, &if_.esp);
+  success = load (data->file_name, &if_.eip, &if_.esp);
 
   /* If load failed, quit. */
-  palloc_free_page (file_name);
   if (!success) 
-    thread_exit ();
+    {
+      palloc_free_page (data->cmd);
+      goto fail;
+    }
+
+  /* Initialize user process stack and free page used to store the
+     command that executed the process. */
+  success = process_init_stack (data->cmd_saveptr, &if_.esp, data->file_name);
+  palloc_free_page (data->cmd);
+  
+  /* If stack initialization failed, free resources and quit. */
+  if (!success)
+    {
+      process_exit ();
+      goto fail;
+    }
 
   /* Start the user process by simulating a return from an
      interrupt, implemented by intr_exit (in
@@ -74,6 +144,109 @@ start_process (void *file_name_)
      and jump to it. */
   asm volatile ("movl %0, %%esp; jmp intr_exit" : : "g" (&if_) : "memory");
   NOT_REACHED ();
+
+/* If starting the process failed, free its common resources and exit. */
+ fail:
+  free (data);
+  thread_exit ();
+}
+
+/* Helper function that initializes the stack of a newly created 
+   user process. Returns true if successful, false otherwise. */
+static bool
+process_init_stack (char *cmd_saveptr, void **esp, char *file_name)
+  {
+    /* Load command line argument *data* to user process stack.
+       This can't cause overflow due to enforcing that the size of
+       command line input must fit in a page. Also keep track
+       of pointers to the argument data within a linked list. */
+    struct list arg_list;
+    list_init (&arg_list);
+
+    char *arg = file_name;
+    int arg_count = 0;
+    while (arg != NULL)
+      {
+        push_to_stack (esp, arg, (strlen (arg) + 1) * sizeof (char));
+        
+        struct arg_elem *arg_elem = malloc (sizeof (struct arg_elem));
+        if (arg_elem == NULL)
+          {
+            printf("ERROR: Couldn't allocate argument pointer memory for %s!\n",
+                   thread_current ()->name);
+            return false;
+          }
+
+        arg_elem->arg = *esp;
+        list_push_front (&arg_list, &arg_elem->elem);
+
+        arg_count++;
+        arg = strtok_r (NULL, " ", &cmd_saveptr);
+      }
+
+    /* Calculate the remaining number of bytes that need to be written
+       to the user process stack in order to check for possible overflow. */
+    size_t align_size = ((unsigned int) *esp % WORD_SIZE) * sizeof (uint8_t);
+    size_t argv_data_size = (arg_count + 1) * sizeof (char *);
+    size_t argv_size = sizeof (char **);
+    size_t argc_size = sizeof (int);
+    size_t return_addr_size = sizeof (void *);
+    size_t remaining_size = align_size + argv_data_size + argv_size + argc_size
+                            + return_addr_size;
+
+    /* If pushing the rest of the data required for the stack would cause
+       overflow, allocate an extra page that is contiguous within the
+       virtual address space (below the current address range). */ 
+    if (PHYS_BASE - *esp + remaining_size > PGSIZE)
+      {
+        uint8_t *kpage = palloc_get_page (PAL_USER | PAL_ZERO);
+        if (!install_page (((uint8_t *) PHYS_BASE) - PGSIZE * 2, kpage, true))
+          return false;
+      }
+
+    /* Align stack pointer to word size before pushing argv elements for
+       performance. */
+    *esp -= align_size;
+    
+    /* Push a null pointer sentinel inside argv. */
+    char *null_sentinel = NULL;
+    push_var_to_stack (esp, null_sentinel); 
+
+    /* Push pointers to process arguments from argument linked list */
+    struct list_elem *e = list_begin (&arg_list);
+    struct list_elem *tail = list_tail (&arg_list);
+    while (e != tail)
+      {
+        struct arg_elem *arg_elem = list_entry (e, struct arg_elem, elem);
+        
+        push_var_to_stack(esp, arg_elem->arg);
+        
+        e = list_next (e);
+        free (arg_elem);
+      }
+
+    /* Push pointer to the start of argv array. */
+    char **argv = *esp;
+    push_var_to_stack(esp, argv);
+
+    /* Push the number of arguments to the stack. */
+    push_var_to_stack(esp, arg_count);
+
+    /* Push fake return address (null pointer). */
+    push_var_to_stack (esp, null_sentinel); 
+
+    return true;
+ }
+
+/* Helper function that pushes the first 'data_size' bytes stored
+   in the address '*data' into the stack given a pointer to the
+   stack pointer '**esp'. */
+static void *
+push_to_stack (void **esp, void *data, size_t data_size)
+{
+  *esp -= data_size;
+  memcpy (*esp, data, data_size);
+  return *esp;
 }
 
 /* Waits for thread TID to die and returns its exit status. 
@@ -88,7 +261,12 @@ start_process (void *file_name_)
 int
 process_wait (tid_t child_tid UNUSED) 
 {
-  return -1;
+  /* As a temporary wait, waiting will just put the thread to sleep for one
+     second (TIMER_FREQ = 100 ticks ~ 1 second). */
+  /* TODO: Implement process_wait () correctly. Remove the next line. */
+  timer_sleep (TIMER_FREQ);
+
+  return 0; /* TODO: Change this too */
 }
 
 /* Free the current process's resources. */
@@ -98,6 +276,8 @@ process_exit (void)
   struct thread *cur = thread_current ();
   uint32_t *pd;
 
+  printf ("%s: exit(%d)\n", cur->name, cur->exit_status);
+
   /* Destroy the current process's page directory and switch back
      to the kernel-only page directory. */
   pd = cur->pagedir;
@@ -318,8 +498,6 @@ load (const char *file_name, void (**eip) (void), void **esp)
 
 /* load() helpers. */
 
-static bool install_page (void *upage, void *kpage, bool writable);
-
 /* Checks whether PHDR describes a valid, loadable segment in
    FILE and returns true if so, false otherwise. */
 static bool

src/userprog/syscall.c

@@ -1,11 +1,68 @@
 #include "userprog/syscall.h"
-#include <stdio.h>
-#include <syscall-nr.h>
+#include "devices/shutdown.h"
+#include "devices/input.h"
+#include "threads/vaddr.h"
 #include "threads/interrupt.h"
 #include "threads/thread.h"
+#include "userprog/process.h"
+#include <stdio.h>
+#include <syscall-nr.h>
 
 static void syscall_handler (struct intr_frame *);
 
+/* A syscall_function is a function that receives up to 3 arguments, the
+   arguments to the functions are either ints or pointers taking up to 32 bits
+   in size. */
+typedef uintptr_t (*syscall_function) (uintptr_t, uintptr_t, uintptr_t);
+
+/* System call function prototypes */
+static void syscall_halt (void);
+static void syscall_exit (int status);
+static pid_t syscall_exec (const char *cmd_line);
+static int syscall_wait (pid_t pid);
+static bool syscall_create (const char *file, unsigned initial_size);
+static bool syscall_remove (const char *file);
+static int syscall_open (const char *file);
+static int syscall_filesize (int fd);
+static int syscall_read (int fd, void *buffer, unsigned size);
+static int syscall_write (int fd, const void *buffer, unsigned size);
+static void syscall_seek (int fd, unsigned position);
+static unsigned syscall_tell (int fd);
+static void syscall_close (int fd);
+
+static void *validate_user_pointer (const void *ptr, size_t size);
+
+/* A struct defining a syscall_function pointer along with its arity. */
+typedef struct
+  {
+    syscall_function function;    /* Function pointer. */
+    int arity;                    /* Number of arguments of the function. */
+  } syscall_arguments;
+
+/* A look-up table mapping numbers to system call functions with their number of
+   arguments. */
+static const syscall_arguments syscall_lookup[] =
+{
+  [SYS_HALT] = {(syscall_function) syscall_halt, 0},
+  [SYS_EXIT] = {(syscall_function) syscall_exit, 1},
+  [SYS_EXEC] = {(syscall_function) syscall_exec, 1},
+  [SYS_WAIT] = {(syscall_function) syscall_wait, 1},
+  [SYS_CREATE] = {(syscall_function) syscall_create, 2},
+  [SYS_REMOVE] = {(syscall_function) syscall_remove, 1},
+  [SYS_OPEN] = {(syscall_function) syscall_open, 1},
+  [SYS_FILESIZE] = {(syscall_function) syscall_filesize, 1},
+  [SYS_READ] = {(syscall_function) syscall_read, 3},
+  [SYS_WRITE] = {(syscall_function) syscall_write, 3},
+  [SYS_SEEK] = {(syscall_function) syscall_seek, 2},
+  [SYS_TELL] = {(syscall_function) syscall_tell, 1},
+  [SYS_CLOSE] = {(syscall_function) syscall_close, 1},
+};
+
+/* The number of syscall functions (i.e, number of elements) within the
+   syscall_lookup table. */
+static const int LOOKUP_SIZE
+  = sizeof (syscall_lookup) / sizeof (syscall_arguments);
+
 void
 syscall_init (void) 
 {
@@ -13,8 +70,165 @@ syscall_init (void)
 }
 
 static void
-syscall_handler (struct intr_frame *f UNUSED) 
+syscall_handler (struct intr_frame *f)
 {
-  printf ("system call!\n");
+  /* First, read the system call number from the stack. */
+  validate_user_pointer (f->esp, 1);
+  unsigned syscall_number = *(int *) f->esp;
+
+  /* Ensures the number corresponds to a system call that can be handled. */
+  if (syscall_number >= LOOKUP_SIZE)
+    thread_exit ();
+
+  syscall_arguments syscall = syscall_lookup[syscall_number];
+
+  /* Next, read and copy the arguments from the stack pointer. */
+  validate_user_pointer (f->esp + sizeof (uintptr_t),
+                         syscall.arity * sizeof (uintptr_t));
+  uintptr_t args[3] = {0};
+  for (int i=0; i < syscall.arity; i++)
+      args[i] = *(uintptr_t *) (f->esp + sizeof (uintptr_t) * (i + 1));
+
+  /* Call the function that handles this system call with the arguments. When
+     there is a return value it is stored in f->eax. */
+  f->eax = syscall.function (args[0], args[1], args[2]);
+}
+
+static void
+syscall_halt (void)
+{
+  shutdown_power_off ();
+}
+
+static void
+syscall_exit (int status)
+{
+  /* Sets exit_status of the thread to status. thread_exit () will call
+     process_exit () if user programs are allowed. */
+  thread_current ()->exit_status = status;
   thread_exit ();
 }
+
+static pid_t
+syscall_exec (const char *cmd_line UNUSED)
+{
+  //TODO
+  return 0;
+}
+
+static int
+syscall_wait (pid_t pid)
+{
+  return process_wait (pid);
+}
+
+static bool
+syscall_create (const char *file UNUSED, unsigned initial_size UNUSED)
+{
+  //TODO
+  return 0;
+}
+
+static bool
+syscall_remove (const char *file UNUSED)
+{
+  //TODO
+  return 0;
+}
+
+static int
+syscall_open (const char *file UNUSED)
+{
+  //TODO
+  return 0;
+}
+
+static int
+syscall_filesize (int fd UNUSED)
+{
+  //TODO
+  return 0;
+}
+
+static int
+syscall_read (int fd, void *buffer, unsigned size)
+{
+  /* Only console (fd = 0) or other files, not including STDOUT, (fd > 1) are
+     allowed. */
+  if (fd < 0 && fd != STDOUT_FILENO)
+    return -1;
+
+  validate_user_pointer (buffer, size);
+
+  if (fd == STDIN_FILENO)
+    {
+      /* Reading from the console. */
+      char *write_buffer = buffer;
+      for (int i = 0; i < size; i++)
+        write_buffer[i] = input_getc ();
+
+      return size;
+    }
+  else
+    {
+      /* Reading from a file. */
+      return 0; // TODO: Implement Write to Files
+    }
+}
+
+static int
+syscall_write (int fd, const void *buffer, unsigned size)
+{
+  /* Only console (fd = 1) or other files, not including STDIN, (fd > 1) are
+     allowed. */
+  if (fd <= 0)
+    return 0;
+
+  validate_user_pointer (buffer, size);
+
+  if (fd == STDOUT_FILENO)
+    {
+      /* Writing to the console. */
+      putbuf (buffer, size);
+      return size;
+    }
+  else
+    {
+      /* Writing to a file. */
+      return 0; // TODO: Implement Write to Files
+    }
+}
+
+static void
+syscall_seek (int fd UNUSED, unsigned position UNUSED)
+{
+  //TODO
+}
+
+static unsigned
+syscall_tell (int fd UNUSED)
+{
+  //TODO
+  return 0;
+}
+
+static void
+syscall_close (int fd UNUSED)
+{
+  //TODO
+}
+
+/* Validates if a block of memory starting at PTR and of size SIZE bytes is
+   fully contained within user virtual memory. Kills the thread (by calling
+   thread_exit) if the memory is invalid. Otherwise, returns the PTR given.
+   If the size is 0, the function does no checks and returns PTR.*/
+static void *
+validate_user_pointer (const void *ptr, size_t size)
+{
+  if (size > 0 && (ptr == NULL ||
+                   !is_user_vaddr (ptr) ||
+                   !is_user_vaddr (ptr + size - 1)))
+    thread_exit ();
+
+  return ptr;
+}

src/userprog/syscall.h

@@ -1,6 +1,8 @@
 #ifndef USERPROG_SYSCALL_H
 #define USERPROG_SYSCALL_H
 
+typedef int pid_t;
+
 void syscall_init (void);
 
 #endif /* userprog/syscall.h */