-#include "addrspace.h"
+#include "userprog/addrspace.h"
+#include <debug.h>
#include <inttypes.h>
-#include "tss.h"
+#include <round.h>
+#include <stdio.h>
+#include <string.h>
+#include "userprog/pagedir.h"
+#include "userprog/tss.h"
+#include "filesys/directory.h"
#include "filesys/file.h"
#include "filesys/filesys.h"
-#include "lib/debug.h"
-#include "lib/lib.h"
#include "threads/init.h"
#include "threads/mmu.h"
-#include "threads/paging.h"
#include "threads/palloc.h"
#include "threads/thread.h"
typedef uint32_t Elf32_Word, Elf32_Addr, Elf32_Off;
typedef uint16_t Elf32_Half;
-/* For use with ELF types in printk(). */
+/* 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. */
static bool load_segment (struct thread *, struct file *,
const struct Elf32_Phdr *);
-static bool setup_stack (struct thread *);
+static bool setup_stack (struct thread *, void **esp);
/* Aborts loading an executable, with an error message. */
#define LOAD_ERROR(MSG) \
do { \
- printk ("addrspace_load: %s: ", filename); \
- printk MSG; \
- printk ("\n"); \
+ printf ("addrspace_load: %s: ", filename); \
+ printf MSG; \
+ printf ("\n"); \
goto done; \
} while (0)
/* Loads an ELF executable from FILENAME into T,
- and stores the executable's entry point into *START.
+ Stores the executable's entry point into *EIP
+ and its initial stack pointer into *ESP.
Returns true if successful, false otherwise. */
bool
-addrspace_load (struct thread *t, const char *filename, void (**start) (void))
+addrspace_load (struct thread *t, const char *filename,
+ void (**eip) (void), void **esp)
{
struct Elf32_Ehdr ehdr;
- struct file file;
- bool file_open = false;
+ struct file *file = NULL;
off_t file_ofs;
bool success = false;
int i;
LOAD_ERROR (("page directory allocation failed"));
/* Open executable file. */
- file_open = filesys_open (filename, &file);
- if (!file_open)
+ file = filesys_open (filename);
+ if (file == NULL)
LOAD_ERROR (("open failed"));
/* Read and verify executable header. */
- if (file_read (&file, &ehdr, sizeof ehdr) != sizeof ehdr)
+ if (file_read (file, &ehdr, sizeof ehdr) != sizeof ehdr)
LOAD_ERROR (("error reading executable header"));
if (memcmp (ehdr.e_ident, "\177ELF\1\1\1", 7) != 0)
LOAD_ERROR (("file is not ELF"));
{
struct Elf32_Phdr phdr;
- file_seek (&file, file_ofs);
- if (file_read (&file, &phdr, sizeof phdr) != sizeof phdr)
+ file_seek (file, file_ofs);
+ if (file_read (file, &phdr, sizeof phdr) != sizeof phdr)
LOAD_ERROR (("error reading program header"));
file_ofs += sizeof phdr;
switch (phdr.p_type)
LOAD_ERROR (("unsupported ELF segment type %d\n", phdr.p_type));
break;
default:
- printk ("unknown ELF segment type %08x\n", phdr.p_type);
+ printf ("unknown ELF segment type %08x\n", phdr.p_type);
break;
case PT_LOAD:
- if (!load_segment (t, &file, &phdr))
+ if (!load_segment (t, file, &phdr))
goto done;
break;
}
}
/* Set up stack. */
- if (!setup_stack (t))
+ if (!setup_stack (t, esp))
goto done;
/* Start address. */
- *start = (void (*) (void)) ehdr.e_entry;
+ *eip = (void (*) (void)) ehdr.e_entry;
success = true;
done:
/* We arrive here whether the load is successful or not.
We can distinguish based on `success'. */
- if (file_open)
- file_close (&file);
+ file_close (file);
if (!success)
addrspace_destroy (t);
return success;
off_t filesz_left; /* Bytes left of file data (as opposed to
zero-initialized bytes). */
+ /* Is this a read-only segment? Not currently used, so it's
+ commented out. You'll want to use it when implementing VM
+ to decide whether to page the segment from its executable or
+ from swap. */
+ //bool read_only = (phdr->p_flags & PF_W) == 0;
+
ASSERT (t != NULL);
ASSERT (file != NULL);
ASSERT (phdr != NULL);
modulo PGSIZE. */
if (phdr->p_offset % PGSIZE != phdr->p_vaddr % PGSIZE)
{
- printk ("%#08"PE32Ox" and %#08"PE32Ax" not congruent modulo %#x\n",
+ printf ("%#08"PE32Ox" and %#08"PE32Ax" not congruent modulo %#x\n",
phdr->p_offset, phdr->p_vaddr, (unsigned) PGSIZE);
return false;
}
p_filesz. */
if (phdr->p_memsz < phdr->p_filesz)
{
- printk ("p_memsz (%08"PE32Wx") < p_filesz (%08"PE32Wx")\n",
+ printf ("p_memsz (%08"PE32Wx") < p_filesz (%08"PE32Wx")\n",
phdr->p_memsz, phdr->p_filesz);
return false;
}
end = pg_round_up ((void *) (phdr->p_vaddr + phdr->p_memsz));
if (start >= PHYS_BASE || end >= PHYS_BASE || end < start)
{
- printk ("bad virtual region %08lx...%08lx\n",
+ printf ("bad virtual region %08lx...%08lx\n",
(unsigned long) start, (unsigned long) end);
return false;
}
file into the page and zero the rest. */
size_t read_bytes = filesz_left >= PGSIZE ? PGSIZE : filesz_left;
size_t zero_bytes = PGSIZE - read_bytes;
- uint8_t *kpage = palloc_get (0);
+ uint8_t *kpage = palloc_get (PAL_USER);
if (kpage == NULL)
return false;
/* Create a minimal stack for T by mapping a zeroed page at the
top of user virtual memory. */
static bool
-setup_stack (struct thread *t)
+setup_stack (struct thread *t, void **esp)
{
uint8_t *kpage;
bool success = false;
- kpage = palloc_get (PAL_ZERO);
+ kpage = palloc_get (PAL_USER | PAL_ZERO);
if (kpage != NULL)
{
success = install_page (t, ((uint8_t *) PHYS_BASE) - PGSIZE, kpage);
- if (!success)
+ if (success)
+ *esp = PHYS_BASE;
+ else
palloc_free (kpage);
}
else
- printk ("failed to allocate process stack\n");
+ printf ("failed to allocate process stack\n");
return success;
}