diff --git a/userprog/process.c~ b/userprog/process.c~
deleted file mode 100644
index d445549cb9c2cb921559873bc661497237b4e3ef..0000000000000000000000000000000000000000
--- a/userprog/process.c~
+++ /dev/null
@@ -1,660 +0,0 @@
-#include "userprog/process.h"
-#include <debug.h>
-#include <inttypes.h>
-#include <round.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "userprog/gdt.h"
-#include "userprog/pagedir.h"
-#include "userprog/tss.h"
-#include "filesys/directory.h"
-#include "filesys/file.h"
-#include "filesys/filesys.h"
-#include "threads/flags.h"
-#include "threads/init.h"
-#include "threads/interrupt.h"
-#include "threads/palloc.h"
-#include "threads/thread.h"
-#include "threads/vaddr.h"
-#if defined(BEN_MODS)
-#include "threads/malloc.h"
-#endif // BEN_MODS
-
-static thread_func start_process NO_RETURN;
-static bool load (const char *cmdline, void (**eip) (void), void **esp);
-
-#if defined(BEN_MODS)
-#define MAX_PROGRAM_NAME_SIZE 16 // including '\0'
-static void extract_program_name(const char *file_name_args, char * program_name);
-static void free_process_info (struct thread *t);
-static bool handle_cmd_arguments(const char *args, void **esp);
-#endif // BEN_MODS
-
-/* Starts a new thread running a user program loaded from
- FILENAME. 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)
-{
- char *fn_copy;
- tid_t tid;
-
- /* Make a copy of FILE_NAME.
- Otherwise there's a race between the caller and load(). */
- fn_copy = palloc_get_page (0);
- if (fn_copy == NULL)
- return TID_ERROR;
- strlcpy (fn_copy, file_name, PGSIZE);
-
-#if defined(BEN_MODS)
- char program_name[MAX_PROGRAM_NAME_SIZE];
- extract_program_name(file_name, program_name);
-#endif
-
- /* Create a new thread to execute FILE_NAME. */
-#if defined(BEN_MODS)
- tid = thread_create (program_name, PRI_DEFAULT, start_process, fn_copy);
-#else
- tid = thread_create (file_name, PRI_DEFAULT, start_process, fn_copy);
-#endif
-
- if (tid == TID_ERROR)
- palloc_free_page (fn_copy);
- return tid;
-}
-
-/* A thread function that loads a user process and starts it
- running. */
-static void
-start_process (void *file_name_)
-{
- char *file_name = file_name_;
- struct intr_frame if_;
- bool success;
-
- /* 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);
-
- /* If load failed, quit. */
- palloc_free_page (file_name);
- if (!success)
- thread_exit ();
-
- /* Start the user process by simulating a return from an
- interrupt, implemented by intr_exit (in
- threads/intr-stubs.S). Because intr_exit takes all of its
- arguments on the stack in the form of a `struct intr_frame',
- we just point the stack pointer (%esp) to our stack frame
- and jump to it. */
- asm volatile ("movl %0, %%esp; jmp intr_exit" : : "g" (&if_) : "memory");
- NOT_REACHED ();
-}
-
-/* Waits for thread TID to die and returns its exit status. If
- it was terminated by the kernel (i.e. killed due to an
- exception), returns -1. If TID is invalid or if it was not a
- child of the calling process, or if process_wait() has already
- been successfully called for the given TID, returns -1
- immediately, without waiting.
-
- This function will be implemented in problem 2-2. For now, it
- does nothing. */
-int
-process_wait (tid_t child_tid UNUSED)
-{
- // FIXME: @bgaster --- quick hack to make sure processes execute!
- for(;;) ;
-
- return -1;
-}
-
-/* Free the current process's resources. */
-void
-process_exit (void)
-{
- struct thread *cur = thread_current ();
- uint32_t *pd;
-
- /* Destroy the current process's page directory and switch back
- to the kernel-only page directory. */
- pd = cur->pagedir;
- if (pd != NULL)
- {
- /* Correct ordering here is crucial. We must set
- cur->pagedir to NULL before switching page directories,
- so that a timer interrupt can't switch back to the
- process page directory. We must activate the base page
- directory before destroying the process's page
- directory, or our active page directory will be one
- that's been freed (and cleared). */
- cur->pagedir = NULL;
- pagedir_activate (NULL);
- pagedir_destroy (pd);
- }
-#if defined(BEN_MODS)
- if (!cur->is_kernel) {
- printf ("%s: exit(%d)\n", thread_name(), cur->process_info->exit_status);
- free_process_info(cur);
- }
-#endif // BEN_MODS
-}
-
-/* Sets up the CPU for running user code in the current
- thread.
- This function is called on every context switch. */
-void
-process_activate (void)
-{
- struct thread *t = thread_current ();
-
- /* Activate thread's page tables. */
- pagedir_activate (t->pagedir);
-
- /* Set thread's kernel stack for use in processing
- interrupts. */
- tss_update ();
-}
-
-/* We load ELF binaries. The following definitions are taken
- from the ELF specification, [ELF1], more-or-less verbatim. */
-
-/* ELF types. See [ELF1] 1-2. */
-typedef uint32_t Elf32_Word, Elf32_Addr, Elf32_Off;
-typedef uint16_t Elf32_Half;
-
-/* For use with ELF types in printf(). */
-#define PE32Wx PRIx32 /* Print Elf32_Word in hexadecimal. */
-#define PE32Ax PRIx32 /* Print Elf32_Addr in hexadecimal. */
-#define PE32Ox PRIx32 /* Print Elf32_Off in hexadecimal. */
-#define PE32Hx PRIx16 /* Print Elf32_Half in hexadecimal. */
-
-/* Executable header. See [ELF1] 1-4 to 1-8.
- This appears at the very beginning of an ELF binary. */
-struct Elf32_Ehdr
- {
- unsigned char e_ident[16];
- Elf32_Half e_type;
- Elf32_Half e_machine;
- Elf32_Word e_version;
- Elf32_Addr e_entry;
- Elf32_Off e_phoff;
- Elf32_Off e_shoff;
- Elf32_Word e_flags;
- Elf32_Half e_ehsize;
- Elf32_Half e_phentsize;
- Elf32_Half e_phnum;
- Elf32_Half e_shentsize;
- Elf32_Half e_shnum;
- Elf32_Half e_shstrndx;
- };
-
-/* Program header. See [ELF1] 2-2 to 2-4.
- There are e_phnum of these, starting at file offset e_phoff
- (see [ELF1] 1-6). */
-struct Elf32_Phdr
- {
- Elf32_Word p_type;
- Elf32_Off p_offset;
- Elf32_Addr p_vaddr;
- Elf32_Addr p_paddr;
- Elf32_Word p_filesz;
- Elf32_Word p_memsz;
- Elf32_Word p_flags;
- Elf32_Word p_align;
- };
-
-/* Values for p_type. See [ELF1] 2-3. */
-#define PT_NULL 0 /* Ignore. */
-#define PT_LOAD 1 /* Loadable segment. */
-#define PT_DYNAMIC 2 /* Dynamic linking info. */
-#define PT_INTERP 3 /* Name of dynamic loader. */
-#define PT_NOTE 4 /* Auxiliary info. */
-#define PT_SHLIB 5 /* Reserved. */
-#define PT_PHDR 6 /* Program header table. */
-#define PT_STACK 0x6474e551 /* Stack segment. */
-
-/* Flags for p_flags. See [ELF3] 2-3 and 2-4. */
-#define PF_X 1 /* Executable. */
-#define PF_W 2 /* Writable. */
-#define PF_R 4 /* Readable. */
-
-static bool setup_stack (void **esp);
-static bool validate_segment (const struct Elf32_Phdr *, struct file *);
-static bool load_segment (struct file *file, off_t ofs, uint8_t *upage,
- uint32_t read_bytes, uint32_t zero_bytes,
- bool writable);
-
-/* Loads an ELF executable from FILE_NAME into the current thread.
- Stores the executable's entry point into *EIP
- and its initial stack pointer into *ESP.
- Returns true if successful, false otherwise. */
-bool
-load (const char *file_name, void (**eip) (void), void **esp)
-{
- struct thread *t = thread_current ();
- struct Elf32_Ehdr ehdr;
- struct file *file = NULL;
- off_t file_ofs;
- bool success = false;
- int i;
-
- /* Allocate and activate page directory. */
- t->pagedir = pagedir_create ();
- if (t->pagedir == NULL)
- goto done;
- process_activate ();
-
- /* Open executable file. */
-#if defined(BEN_MODS)
- char program_name[MAX_PROGRAM_NAME_SIZE];
- extract_program_name(file_name, program_name);
- file = filesys_open (program_name);
-#else
- file = filesys_open (file_name);
-#endif //BEN_MODS
-
- if (file == NULL)
- {
-#if defined(BEN_MODS)
- printf ("load: %s: open failed\n", program_name);
-#else
- printf ("load: %s: open failed\n", file_name);
-#endif // BEN_MODS
- goto done;
- }
-
- /* Read and verify executable header. */
- if (file_read (file, &ehdr, sizeof ehdr) != sizeof ehdr
- || memcmp (ehdr.e_ident, "\177ELF\1\1\1", 7)
- || ehdr.e_type != 2
- || ehdr.e_machine != 3
- || ehdr.e_version != 1
- || ehdr.e_phentsize != sizeof (struct Elf32_Phdr)
- || ehdr.e_phnum > 1024)
- {
- printf ("load: %s: error loading executable\n", file_name);
- goto done;
- }
-
- /* Read program headers. */
- file_ofs = ehdr.e_phoff;
- for (i = 0; i < ehdr.e_phnum; i++)
- {
- struct Elf32_Phdr phdr;
-
- if (file_ofs < 0 || file_ofs > file_length (file))
- goto done;
- file_seek (file, file_ofs);
-
- if (file_read (file, &phdr, sizeof phdr) != sizeof phdr)
- goto done;
- file_ofs += sizeof phdr;
- switch (phdr.p_type)
- {
- case PT_NULL:
- case PT_NOTE:
- case PT_PHDR:
- case PT_STACK:
- default:
- /* Ignore this segment. */
- break;
- case PT_DYNAMIC:
- case PT_INTERP:
- case PT_SHLIB:
- goto done;
- case PT_LOAD:
- if (validate_segment (&phdr, file))
- {
- bool writable = (phdr.p_flags & PF_W) != 0;
- uint32_t file_page = phdr.p_offset & ~PGMASK;
- uint32_t mem_page = phdr.p_vaddr & ~PGMASK;
- uint32_t page_offset = phdr.p_vaddr & PGMASK;
- uint32_t read_bytes, zero_bytes;
- if (phdr.p_filesz > 0)
- {
- /* Normal segment.
- Read initial part from disk and zero the rest. */
- read_bytes = page_offset + phdr.p_filesz;
- zero_bytes = (ROUND_UP (page_offset + phdr.p_memsz, PGSIZE)
- - read_bytes);
- }
- else
- {
- /* Entirely zero.
- Don't read anything from disk. */
- read_bytes = 0;
- zero_bytes = ROUND_UP (page_offset + phdr.p_memsz, PGSIZE);
- }
- if (!load_segment (file, file_page, (void *) mem_page,
- read_bytes, zero_bytes, writable))
- goto done;
- }
- else
- goto done;
- break;
- }
- }
-
- /* Set up stack. */
- if (!setup_stack (esp))
- goto done;
-
- /* Start address. */
- *eip = (void (*) (void)) ehdr.e_entry;
-
-#if defined(BEN_MODS)
- // Handle arguments
- if (!handle_cmd_arguments(file_name, esp)) {
- goto done;
- }
-#endif // BEN_MODS
- success = true;
-
- done:
- /* We arrive here whether the load is successful or not. */
- file_close (file);
- return success;
-}
-
-/* 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
-validate_segment (const struct Elf32_Phdr *phdr, struct file *file)
-{
- /* p_offset and p_vaddr must have the same page offset. */
- if ((phdr->p_offset & PGMASK) != (phdr->p_vaddr & PGMASK))
- return false;
-
- /* p_offset must point within FILE. */
- if (phdr->p_offset > (Elf32_Off) file_length (file))
- return false;
-
- /* p_memsz must be at least as big as p_filesz. */
- if (phdr->p_memsz < phdr->p_filesz)
- return false;
-
- /* The segment must not be empty. */
- if (phdr->p_memsz == 0)
- return false;
-
- /* The virtual memory region must both start and end within the
- user address space range. */
- if (!is_user_vaddr ((void *) phdr->p_vaddr))
- return false;
- if (!is_user_vaddr ((void *) (phdr->p_vaddr + phdr->p_memsz)))
- return false;
-
- /* The region cannot "wrap around" across the kernel virtual
- address space. */
- if (phdr->p_vaddr + phdr->p_memsz < phdr->p_vaddr)
- return false;
-
- /* Disallow mapping page 0.
- Not only is it a bad idea to map page 0, but if we allowed
- it then user code that passed a null pointer to system calls
- could quite likely panic the kernel by way of null pointer
- assertions in memcpy(), etc. */
- if (phdr->p_vaddr < PGSIZE)
- return false;
-
- /* It's okay. */
- return true;
-}
-
-/* Loads a segment starting at offset OFS in FILE at address
- UPAGE. In total, READ_BYTES + ZERO_BYTES bytes of virtual
- memory are initialized, as follows:
-
- - READ_BYTES bytes at UPAGE must be read from FILE
- starting at offset OFS.
-
- - ZERO_BYTES bytes at UPAGE + READ_BYTES must be zeroed.
-
- The pages initialized by this function must be writable by the
- user process if WRITABLE is true, read-only otherwise.
-
- Return true if successful, false if a memory allocation error
- or disk read error occurs. */
-static bool
-load_segment (struct file *file, off_t ofs, uint8_t *upage,
- uint32_t read_bytes, uint32_t zero_bytes, bool writable)
-{
- ASSERT ((read_bytes + zero_bytes) % PGSIZE == 0);
- ASSERT (pg_ofs (upage) == 0);
- ASSERT (ofs % PGSIZE == 0);
-
- file_seek (file, ofs);
- while (read_bytes > 0 || zero_bytes > 0)
- {
- /* Calculate how to fill this page.
- We will read PAGE_READ_BYTES bytes from FILE
- and zero the final PAGE_ZERO_BYTES bytes. */
- size_t page_read_bytes = read_bytes < PGSIZE ? read_bytes : PGSIZE;
- size_t page_zero_bytes = PGSIZE - page_read_bytes;
-
- /* Get a page of memory. */
- uint8_t *kpage = palloc_get_page (PAL_USER);
- if (kpage == NULL)
- return false;
-
- /* Load this page. */
- if (file_read (file, kpage, page_read_bytes) != (int) page_read_bytes)
- {
- palloc_free_page (kpage);
- return false;
- }
- memset (kpage + page_read_bytes, 0, page_zero_bytes);
-
- /* Add the page to the process's address space. */
- if (!install_page (upage, kpage, writable))
- {
- palloc_free_page (kpage);
- return false;
- }
-
- /* Advance. */
- read_bytes -= page_read_bytes;
- zero_bytes -= page_zero_bytes;
- upage += PGSIZE;
- }
- return true;
-}
-
-/* Create a minimal stack by mapping a zeroed page at the top of
- user virtual memory. */
-static bool
-setup_stack (void **esp)
-{
- uint8_t *kpage;
- bool success = false;
-
- kpage = palloc_get_page (PAL_USER | PAL_ZERO);
- if (kpage != NULL)
- {
- success = install_page (((uint8_t *) PHYS_BASE) - PGSIZE, kpage, true);
- if (success) {
- *esp = PHYS_BASE;
- } else
- palloc_free_page (kpage);
- }
- return success;
-}
-
-/* Adds a mapping from user virtual address UPAGE to kernel
- virtual address KPAGE to the page table.
- If WRITABLE is true, the user process may modify the page;
- otherwise, it is read-only.
- UPAGE must not already be mapped.
- KPAGE should probably be a page obtained from the user pool
- with palloc_get_page().
- Returns true on success, false if UPAGE is already mapped or
- if memory allocation fails. */
-static bool
-install_page (void *upage, void *kpage, bool writable)
-{
- struct thread *t = thread_current ();
-
- /* Verify that there's not already a page at that virtual
- address, then map our page there. */
- return (pagedir_get_page (t->pagedir, upage) == NULL
- && pagedir_set_page (t->pagedir, upage, kpage, writable));
-}
-
-//--------------------------------------------------------------------
-
-#if defined(BEN_MODS)
-static void extract_program_name(const char *file_name_args, char *program_name)
-{
- int pos = 0;
- for (; (pos < MAX_PROGRAM_NAME_SIZE) &&
- (*(file_name_args + pos) != ' ') &&
- (*(file_name_args + pos) != '\0');
- pos++) {
- *(program_name + pos) = *(file_name_args + pos);
- }
- *(program_name+pos) = '\0';
-}
-
-// Note we really should only free this once the parent is dead!
-// However, as we are not currenlty tracking this in the parent,
-// is clearly not actually a problem.
-static void
-free_process_info (struct thread *t)
-{
- // this is where we would track all the children processes
- // and kill them if necessary
-
- /* Free its own metadata if its parent process is dead */
-// if (!cur->process_info->parent_alive)
- free (t->process_info);
-}
-
-// Push 4 bytes onto the stack, after first checking
-// we have not over run the page
-inline
-static bool push_bytes4(char ** p_stack, void * val, void**esp)
-{
- // here we are assuming 32 bit!!!
- if ((int)*esp - (int)*p_stack + 4 > PGSIZE) {
- // over page limit so error
- return false;
- }
-
- *p_stack = *p_stack - 4;
- *((void **)*p_stack)=val;
-
- return true;
-}
-
-static bool handle_cmd_arguments(const char *args, void **esp)
-{
- // top of stack
- char * p_ustack_top = *esp;
-
- // scan args in reverse order and copy
- char * current; // current position
- char * wbegin; // begin position for current arg
- char * wend; // end position for current arg
- size_t wlength; // length of current argument
-
- current = (char*)args + strlen(args); // start at the end of args
-
- // push arguments onto stack
- while (current >= args) { // terminate once we read the beginning
- // skip delimiters (i.e. ' ' or '\0')
- for (; (current >= args) &&
- ((*current == ' ') || (*current == '\0')); current--) {
- }
- wend = current + 1; //set end position
-
- // skip non-delimiters, i.e. actual argument
- for (; (current >= args) &&
- ((*current != ' ') || (*current != '\0')); current--) {
- }
-
- wbegin = current + 1; // set begin position
-
- wlength = wend - wbegin;
-
- // check if stack will overflow
- // TODO: @bgaster --- add function to check stack overflow
- if (((int)*esp) - (int)(p_ustack_top + wlength + 1) > PGSIZE) {
- return false;
- }
-
- strlcpy(p_ustack_top - wlength - 1, wbegin, wlength + 1);
- *(p_ustack_top - 1) = '\0';
-
- p_ustack_top = p_ustack_top - (wlength -1);
- }
-
- // align stack to 32bits
- char * p_argv_begin = p_ustack_top; // save to use later for arg addresses
-
- // 1 if no align, otherwise 2
- int count_limit = (((int)p_ustack_top) % 4 == 3) ? 1 : 2;
- while(count_limit > 0) {
- // check for overflow
- if ((int)*esp - (int)p_ustack_top + 1 > PGSIZE) {
- return false;
- }
-
- p_ustack_top--;
- *p_ustack_top = 0;
-
- if ( ((int)p_ustack_top) % 4 == 0) {
- count_limit--;
- }
- }
-
- // push argv[argc-1 .. 0] onto the stack
- char * p = PHYS_BASE - 1; // scan stack for argument addresses
- int argc = 0;
- while (p >= p_argv_begin) {
- p--;
- // find argument terminator
- while ((p >= p_argv_begin) && (*p != '\0')) {
- p--;
- }
- if (!push_bytes4(&p_ustack_top, (void*)(p+1), esp)) {
- // run out of stack space
- return false;
- }
- argc++;
- }
-
- // push argv
- if (!push_bytes4(&p_ustack_top, (void*)(p_ustack_top), esp)) {
- // run out of stack space
- return false;
- }
-
- // push argc
- if (!push_bytes4(&p_ustack_top, (void*)(argc), esp)) {
- // run out of stack space
- return false;
- }
-
- // finally push fake return address
- if (!push_bytes4(&p_ustack_top, (void*)NULL, esp)) {
- // run out of stack space
- return false;
- }
-
- // we are done, so update stack pointer
- *esp = p_ustack_top;
-
- return true;
-}
-#endif // BEN_MODS