+ file_ofs = ehdr.e_phoff;
+ for (i = 0; i < ehdr.e_phnum; i++)
+ {
+ struct Elf32_Phdr 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)
+ {
+ case PT_NULL:
+ case PT_NOTE:
+ case PT_PHDR:
+ case PT_STACK:
+ /* Ignore this segment. */
+ break;
+ case PT_DYNAMIC:
+ case PT_INTERP:
+ case PT_SHLIB:
+ /* Reject the executable. */
+ LOAD_ERROR (("unsupported ELF segment type %d\n", phdr.p_type));
+ break;
+ default:
+ printk ("unknown ELF segment type %08x\n", phdr.p_type);
+ break;
+ case PT_LOAD:
+ if (!load_segment (t, &file, &phdr))
+ goto done;
+ break;
+ }
+ }
+
+ /* Set up stack. */
+ if (!setup_stack (t))
+ goto done;
+
+ /* Start address. */
+ *start = (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);
+ if (!success)
+ addrspace_destroy (t);
+ return success;
+}
+
+/* Destroys the user address space in T and frees all of its
+ resources. */
+void
+addrspace_destroy (struct thread *t)
+{
+ if (t->pagedir != NULL)
+ {
+ pagedir_destroy (t->pagedir);
+ t->pagedir = NULL;
+ }
+}
+
+/* Sets up the CPU for running user code in thread T, if any. */
+void
+addrspace_activate (struct thread *t)
+{
+ ASSERT (t != NULL);
+
+ /* Activate T's page tables. */
+ pagedir_activate (t->pagedir);
+
+ /* Set T's kernel stack for use in processing interrupts. */
+ tss_set_esp0 ((uint8_t *) t + PGSIZE);
+}
+\f
+/* addrspace_load() helpers. */
+
+static bool install_page (struct thread *, void *upage, void *kpage);
+
+/* Loads the segment described by PHDR from FILE into thread T's
+ user address space. Return true if successful, false
+ otherwise. */
+static bool
+load_segment (struct thread *t, struct file *file,
+ const struct Elf32_Phdr *phdr)
+{
+ void *start, *end; /* Page-rounded segment start and end. */
+ uint8_t *upage; /* Iterator from start to end. */
+ off_t filesz_left; /* Bytes left of file data (as opposed to
+ zero-initialized bytes). */
+
+ ASSERT (t != NULL);
+ ASSERT (file != NULL);
+ ASSERT (phdr != NULL);
+ ASSERT (phdr->p_type == PT_LOAD);
+
+ /* [ELF1] 2-2 says that p_offset and p_vaddr must be congruent
+ modulo PGSIZE. */
+ if (phdr->p_offset % PGSIZE != phdr->p_vaddr % PGSIZE)
+ {
+ printk ("%#08"PE32Ox" and %#08"PE32Ax" not congruent modulo %#x\n",
+ phdr->p_offset, phdr->p_vaddr, (unsigned) PGSIZE);
+ return false;
+ }
+
+ /* [ELF1] 2-3 says that p_memsz must be at least as big as
+ p_filesz. */
+ if (phdr->p_memsz < phdr->p_filesz)
+ {
+ printk ("p_memsz (%08"PE32Wx") < p_filesz (%08"PE32Wx")\n",
+ phdr->p_memsz, phdr->p_filesz);
+ return false;
+ }
+
+ /* Validate virtual memory region to be mapped.
+ The region must both start and end within the user address
+ space range starting at 0 and ending at PHYS_BASE (typically
+ 3 GB == 0xc0000000). */
+ start = pg_round_down ((void *) phdr->p_vaddr);
+ 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",
+ (unsigned long) start, (unsigned long) end);
+ return false;
+ }
+
+ /* Load the segment page-by-page into memory. */
+ filesz_left = phdr->p_filesz + (phdr->p_vaddr & PGMASK);
+ file_seek (file, ROUND_DOWN (phdr->p_offset, PGSIZE));
+ for (upage = start; upage < (uint8_t *) end; upage += PGSIZE)
+ {
+ /* We want to read min(PGSIZE, filesz_left) bytes from the
+ 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);
+ if (kpage == NULL)
+ return false;