reorganize file structure to match the upstream requirements

1 files changed, 0 insertions, 563 deletions

diff --git a/pintos-progos/userprog/syscall.c b/pintos-progos/userprog/syscall.c
deleted file mode 100644
index f8e0197..0000000
--- a/pintos-progos/userprog/syscall.c
+++ /dev/null
@@ -1,563 +0,0 @@
-#include <stdio.h>
-#include <syscall-nr.h>
-#include "devices/input.h"
-#include "devices/shutdown.h"
-#include "filesys/file.h"
-#include "filesys/filesys.h"
-#include "filesys/inode.h"
-#include "lib/string.h"
-#include "threads/interrupt.h"
-#include "threads/palloc.h"
-#include "threads/synch.h"
-#include "threads/thread.h"
-#include "threads/vaddr.h"
-#include "userprog/pagedir.h"
-#include "userprog/process.h"
-#include "userprog/syscall.h"
-
-#define STACK_SLOT_SIZE sizeof(int)
-
-/* Prototypes for Utilities */
-static int get_user (const uint8_t *uaddr);
-static bool put_user (uint8_t *udst, uint8_t byte);
-static void* memcpy_from_user (void *kaddr, void *uaddr, size_t bytes);
-static void* memcpy_to_user (void *kaddr, void *addr, size_t bytes);
-static void* copy_string_arg  (void *usp, bool *segfault);
-static void free_string_arg_buf (void *kbuf);
-
-/* Reads a byte at user virtual address UADDR.
-   UADDR must be below PHYS_BASE.
-   Returns the byte value if successful, -1 if a segfault
-   occurred. */
-static int
-get_user (const uint8_t *uaddr)
-{
-  int result;
-  asm ("movl $1f, %0; "  /* save eip in eax */
-       "movzbl %1, %0; " /* read byte from user memory into eax */
-       "1:"              /* continue here on page fault, with eax set to -1 */
-       : "=&a" (result) : "m" (*uaddr));
-  return result;
-}
-
-/* Writes BYTE to user address UDST.
-   UDST must be below PHYS_BASE.
-   Returns true if successful, false if a segfault occurred. */
-static bool
-put_user (uint8_t *udst, uint8_t byte)
-{
-  int error_code;
-  asm ("movl $1f, %0;" /* save EIP in EAX */
-       "movb %b2, %1;" /* write byte to user memory  */
-       "1:"            /* continue here on page fault, with eax set to -1 */
-       : "=&a" (error_code), "=m" (*udst) : "q" (byte));
-  return error_code != -1;
-}
-
-/* Copy bytes from user space; returns NULL if a segfault
-   occured, and kaddr otherwise */
-static void*
-memcpy_from_user (void *kaddr, void *uaddr, size_t bytes)
-{
-  uint8_t* kp = kaddr;
-  size_t i;
-  if (! is_user_vaddr (uaddr) ||
-      ! is_user_vaddr (uaddr + bytes - 1))
-    return false;
-  for (i=0;i<bytes;i++) {
-    int b = get_user (uaddr+i);
-    if (b < 0)
-      break; /* segfault */
-    else
-      kp[i] = b;
-  }
-  if (i != bytes)
-    return NULL; /* segfault */
-  return kaddr;
-}
-
-/* Copy bytes to user space; returns NULL if a segfault
-   occured, and uaddr otherwise */
-static void*
-memcpy_to_user (void *uaddr, void *kaddr, size_t bytes)
-{
-  uint8_t* kp = kaddr;
-  size_t i;
-  if (! is_user_vaddr (uaddr) ||
-      ! is_user_vaddr (uaddr + bytes - 1))
-    return false;
-  for (i=0;i<bytes;i++) {
-    if (! put_user (uaddr+i, kp[i]))
-      break; /* segfault */
-  }
-  if (i != bytes)
-    return NULL; /* segfault */
-  return uaddr;
-}
-
-/* Copy string (at most cnt bytes) from user memory to the kernel address
-   `kaddr`. The number of bytes copied is returned; 0 indicates a segfault. */
-static size_t
-strncpy_from_user (void *kaddr, void *uaddr, size_t cnt)
-{  
-  uint8_t *kp = (uint8_t*) kaddr;
-  size_t i; 
-  int c = 1;
-  for (i = 0; i < cnt && c; i++) {
-    if (! is_user_vaddr (uaddr+i))
-      return 0; /* sefault */
-    c = get_user (uaddr+i);
-    if (c < 0)
-      return 0; /* segfault */
-    kp[i] = c;
-  }
-  return i;
-}
-
-/* Copy a value of scalar type `typeof(*kdst)` from user space pointer 
-  `usrc` to kernel space variable pointed to by `kdst`. Returns
-  false on segfault, and true otherwise. */
-#define copy_from_user(kdst, usrc) \
-    (memcpy_from_user (kdst, usrc, sizeof (*kdst)) != NULL)
-
-/* Takes user space stack pointer, which points to a string
-   in user space. Copies that string (at most PGSIZE bytes)
-   to a freshly allocated buffer in kernel space. Reurns NULL on
-   error; on a segfault, additionally sets `segfault` to true */
-static void*
-copy_string_arg (void *usp, bool *segfault)
-{
-  size_t bytes_copied;
-  char *uptr;
-  char *kpage;
-  if (! copy_from_user (&uptr, usp)) {
-    *segfault = true;
-    return NULL;
-  }
-  kpage = palloc_get_page (PAL_ZERO);
-  if (kpage == NULL)
-    return NULL;
-  bytes_copied = strncpy_from_user (kpage, uptr, PGSIZE);
-  if (bytes_copied == 0) {
-    *segfault = true;
-    palloc_free_page (kpage);
-    return NULL;
-  }
-  if (kpage[bytes_copied-1] != '\0') {
-    palloc_free_page (kpage);
-    return NULL;
-  };
-  return kpage;
-}
-
-/* free buffer allocated by `copy_string_arg` */
-static void free_string_arg_buf (void *kbuf)
-{
-  palloc_free_page (kbuf);
-}
-
-/* Stack slot address */
-#define STACK_ADDR(sp, slot) (sp + STACK_SLOT_SIZE*slot)
-
-/* syscall handler prototype */
-static void syscall_handler (struct intr_frame *);
-
-typedef int (handler)(void *sp, bool *segfault);
-
-/* Prototypes for syscall handlers */
-static handler
-  syscall_halt, 
-  syscall_exit,
-  syscall_write,
-  syscall_wait ,
-  syscall_exec,
-  syscall_create,
-  syscall_remove,
-  syscall_open,
-  syscall_filesize,
-  syscall_read,
-  syscall_seek,
-  syscall_tell,
-  syscall_close;
-
-/* Register syscall_handler for interrupt 0x30 */
-void
-syscall_init (void)
-{
-  intr_register_int (0x30, 3, INTR_ON, syscall_handler, "syscall");
-}
-
-/* Syscall handler, delegating known syscalls to the respective implementations */
-static void
-syscall_handler (struct intr_frame *f)
-{
-  int syscall_nr;
-  handler* fp;
-  bool segfault = false;
-  int result;
-  void *sp = f->esp;
-
-  /* The system call number and the arguments are on the stack */
-  if (! copy_from_user (&syscall_nr,sp))
-    goto fail;
-  switch (syscall_nr) {
-  case SYS_HALT: fp = syscall_halt; break;
-  case SYS_EXIT: fp = syscall_exit; break;
-  case SYS_EXEC: fp = syscall_exec; break;
-  case SYS_WAIT: fp = syscall_wait; break;
-  case SYS_CREATE: fp = syscall_create; break;
-  case SYS_REMOVE: fp = syscall_remove; break;
-  case SYS_OPEN: fp = syscall_open; break;
-  case SYS_FILESIZE: fp = syscall_filesize; break;
-  case SYS_READ: fp = syscall_read; break;
-  case SYS_WRITE: fp = syscall_write; break;
-  case SYS_SEEK: fp = syscall_seek; break;
-  case SYS_TELL: fp = syscall_tell; break;
-  case SYS_CLOSE: fp = syscall_close; break;
-  default:
-    goto fail;
-  }
-  result = fp (sp, &segfault);
-  if (segfault)
-    goto fail;
-  f->eax = result;
-  return;
-
-  fail:
-  process_current()->exit_status = -1;
-  thread_exit ();
-}
-
-/* Shutdown machine */
-static int
-syscall_halt (void *sp UNUSED, bool *segfault UNUSED)
-{
-  shutdown ();
-  NOT_REACHED ();
-}
-
-/* Exit current process with given exit code */
-static int
-syscall_exit (void *sp, bool *segfault)
-{
-  int exit_status;
-  if (! copy_from_user (&exit_status, STACK_ADDR (sp,1))) {
-    *segfault = true;
-    return -1;
-  }
-  process_current()->exit_status = exit_status;
-  thread_exit ();
-  NOT_REACHED ();
-}
-
-/* Spawn new process executing the supplied command */
-static int
-syscall_exec (void *sp, bool *segfault)
-{
-  char *kbuf;
-  int result = TID_ERROR;
-  if ((kbuf = copy_string_arg (STACK_ADDR (sp, 1), segfault)) != NULL) {
-    result = process_execute (kbuf);
-    free_string_arg_buf (kbuf);
-  }
-  return result;
-}
-
-/* Wait until specified process exits */
-static int
-syscall_wait (void *sp, bool *segfault)
-{
-  tid_t arg;
-  if (! copy_from_user (&arg, STACK_ADDR (sp,1))) {
-    *segfault = true;
-    return 0;
-  }
-  return process_wait (arg);
-}
-
-/* Create a new file with given initial size */
-static int
-syscall_create (void *sp, bool *segfault)
-{
-  bool success = false;
-  char *fname;
-  int initial_size;
-
-  if (! copy_from_user (&initial_size, STACK_ADDR (sp,2))) {
-    *segfault = true;
-    return false;
-  }
-  if ((fname = copy_string_arg (STACK_ADDR (sp, 1), segfault)) == NULL)
-    return false;
-
-  process_lock_filesys ();
-  success = filesys_create (fname, initial_size);
-  process_unlock_filesys ();
-  free_string_arg_buf (fname);
-  return success;
-}
-
-/* Remove name file, returns true if successful */
-static int
-syscall_remove (void *sp, bool *segfault)
-{
-  bool success;
-  char *fname;
-
-  if ((fname = copy_string_arg (STACK_ADDR (sp, 1), segfault)) == NULL)
-    return false;  
-  process_lock_filesys ();
-  success = filesys_remove (fname);
-  process_unlock_filesys ();
-  free_string_arg_buf (fname);
-  return (int)success;
-}
-
-/* Open file, returning non-negative file descriptor if successful */
-static int
-syscall_open (void *sp, bool *segfault)
-{
-  char *fname;
-  int fd;
-  if ((fname = copy_string_arg (STACK_ADDR (sp, 1), segfault)) == NULL)
-    return false;  
-  fd = process_open_file (fname);
-  free_string_arg_buf (fname);
-  return fd;
-}
-
-/* Return size of file described by file descriptor */
-static int
-syscall_filesize (void *sp, bool *segfault)
-{
-  int fd;
-  struct file *f;
-  int size;
-
-  if (! copy_from_user (&fd, STACK_ADDR (sp,1))) {
-    *segfault = true;
-    return -1;
-  }
-  if ((f = process_get_file (fd)) == NULL)
-    return -1;
-  process_lock_filesys ();
-  size = inode_length (file_get_inode (f));
-  process_unlock_filesys ();
-  return size;
-}
-
-/* Read bytes from the file referenced by the given file
-   descriptor into the supplied user space buffer, returning
-   number of bytes read. */
-static int
-syscall_read (void *sp, bool *segfault)
-{
-  int fd;
-  uint8_t *user_buffer;
-  size_t size, bytes_to_read;
-
-  /* get arguments */
-  if (! copy_from_user (&fd, STACK_ADDR (sp,1)) ||
-      ! copy_from_user (&user_buffer, STACK_ADDR (sp, 2)) ||
-      ! copy_from_user (&size, STACK_ADDR (sp,3))) {
-    *segfault = true;
-    return -1;
-  }
-
-  /* ensure buffer is in user space */
-  if (! is_user_vaddr (user_buffer) ||
-      ! is_user_vaddr (user_buffer + size - 1)) {
-    *segfault = true;
-    return -1;
-  }
-
-  bytes_to_read = size;
-  /* handle stdin */
-  if (fd == STDIN_FILENO) {
-    char c;
-    while (bytes_to_read--) {
-      c = input_getc ();
-      if (! put_user (user_buffer++, c)) {
-        *segfault = true;
-        return -1;
-      }
-    }
-    return size;
-  }
-  /* get file */
-  struct file *file = process_get_file (fd);
-  if (file == NULL)
-    return -1;
-
-  char *kbuf = palloc_get_page (0);
-  if (kbuf == NULL)
-    return -1;
-
-  /* read loop */
-  do {
-    int bytes_read;
-    int blocksize = bytes_to_read;
-    if (bytes_to_read > PGSIZE)
-      blocksize = PGSIZE;
-
-    /* read bytes */
-    process_lock_filesys ();
-    bytes_read = file_read (file, kbuf, blocksize);
-    process_unlock_filesys ();
-
-    /* Stop when EOF has been reached */
-    if (bytes_read == 0)
-      break;
-    bytes_to_read -= bytes_read;
-    if (! memcpy_to_user (user_buffer, kbuf, bytes_read)) {
-      *segfault = true;
-      break;
-    }
-    user_buffer += bytes_read;
-  } while (bytes_to_read > 0);
-
-  palloc_free_page (kbuf);
-  return size - bytes_to_read;
-}
-
-/* Write bytes from user buffer into the specified
-   file, returning number of bytes written. */
-static int
-syscall_write (void *sp, bool *segfault)
-{
-  int fd;
-  size_t size, bytes_to_write;
-  char *user_buffer;
-
-  /* get arguments */
-  if (! copy_from_user (&fd, STACK_ADDR (sp,1)) ||
-      ! copy_from_user (&user_buffer, STACK_ADDR (sp, 2)) ||
-      ! copy_from_user (&size, STACK_ADDR (sp,3))) {
-    *segfault = true;
-    return -1;
-  }
-
-  /* ensure buffer is in user space */
-  if (! is_user_vaddr (user_buffer) ||
-      ! is_user_vaddr (user_buffer + size - 1)) {
-    *segfault = true;
-    return -1;
-  }
-
-  /* get file handle */
-  struct file *file = NULL;
-  if (fd != STDOUT_FILENO) {
-    file = process_get_file (fd);
-    if (file == NULL)
-      return -1;
-  }
-
-  /* allocate kernel buffer */
-  char *kbuf = palloc_get_page (0);
-  if (kbuf == NULL)
-    return -1;
-
-  /* write loop */
-  bytes_to_write = size;
-  do {
-    int blocksize = bytes_to_write;
-    if (bytes_to_write > PGSIZE)
-      blocksize = PGSIZE;
-    if (memcpy_from_user (kbuf, user_buffer, blocksize) == NULL) {
-      *segfault = true;
-      break;
-    }
-    if (fd == STDOUT_FILENO) {
-      putbuf (kbuf, blocksize);
-      bytes_to_write -= blocksize;
-    } else {
-      int bytes_written = 0;
-      int bytes_left_filesys = blocksize;
-
-      process_lock_filesys ();
-      while (bytes_left_filesys > 0) {
-        bytes_written = file_write (file, kbuf, bytes_left_filesys);
-        if (bytes_written <= 0) {
-          break;
-        }
-        bytes_left_filesys -= bytes_written;
-      }
-      process_unlock_filesys ();
-
-      if (bytes_written <= 0)
-        break;
-      bytes_to_write -= blocksize;
-    }
-    user_buffer += blocksize;
-  } while (bytes_to_write > 0);
-
-  /* return bytes written */
-  palloc_free_page (kbuf);
-  return size - bytes_to_write;
-}
-
-/* Change the position where the next byte will be read or written */
-static int
-syscall_seek (void *sp, bool *segfault)
-{
-  int fd;
-  off_t new_pos;
-
-  /* get arguments */
-  if (! copy_from_user (&fd, STACK_ADDR (sp,1)) ||
-      ! copy_from_user (&new_pos, STACK_ADDR (sp, 2))) {
-    *segfault = true;
-    return 0;
-  }
-
-  /* no way to return something sensible (void function) */
-  struct file *file = process_get_file (fd);
-  if (file == NULL)
-    return 0;
-
-  process_lock_filesys ();
-  file_seek (file, new_pos);
-  process_unlock_filesys ();
-  return 0;
-}
-
-/* Returns the position of the next byte to be read or written */
-static int
-syscall_tell (void *sp, bool *segfault)
-{
-  int fd;
-  unsigned r = 0;
-
-  /* get arguments */
-  if (! copy_from_user (&fd, STACK_ADDR (sp,1))) {
-    *segfault = true;
-    return 0;
-  }
-
-  /* no way to return something sensible function */
-  struct file *file = process_get_file (fd);
-  if (file == NULL)
-    return 0;
-
-  process_lock_filesys ();
-  r = file_tell (file);
-  process_unlock_filesys ();
-  return r;
-}
-
-/* Close the given file */
-static int
-syscall_close (void *sp, bool *segfault)
-{
-  int fd;
-
-  /* get arguments */
-  if (! copy_from_user (&fd, STACK_ADDR (sp,1))) {
-    *segfault = true;
-    return 0;
-  }
-
-  /* no way to return something sensible function (void) */
-  (void) process_close_file (fd);
-  return 0;
-}