Mit os Lab 3. User Environmen

1 Exercise 1. Modify mem_init() in kern/pmap.c to allocate and map the envs array. This array consists of exactly NENV instances of the Env structure allocated much like how you allocated the pages array. 
Also like the pages array, the memory backing envs should also be mapped user read-only at UENVS (defined in inc/memlayout.h) so user processes can read from this array. 
You should run your code and make sure check_kern_pgdir() succeeds.

1     // Make ‘envs‘ point to an array of size ‘NENV‘ of ‘struct Env‘.
2     // LAB 3: Your code here.
3     envs = (struct Env*)boot_alloc(ROUNDUP(NENV * sizeof(struct Env), PGSIZE));
4     memset(envs, 0, sizeof(struct Env) * NENV);
5     cprintf("alloc envs buffer: start=%08x, len=%08x\n", envs, NENV * sizeof(struct Env));

 1     //////////////////////////////////////////////////////////////////////
 2     // Map the ‘envs‘ array read-only by the user at linear address UENVS
 3     // (ie. perm = PTE_U | PTE_P).
 4     // Permissions:
 5     //    - the new image at UENVS  -- kernel R, user R
 6     //    - envs itself -- kernel RW, user NONE
 7     // LAB 3: Your code here.
 8     boot_map_region(kern_pgdir,
 9                 UENVS, 
10                 ROUNDUP((sizeof(struct Env) * NENV) , PGSIZE),
11                 PADDR(envs),
12                 (PTE_U | PTE_P));

Exercise 2. In the file env.c, finish coding the following functions:

env_init()
Initialize all of the Env structures in the envs array and add them to the env_free_list. Also calls env_init_percpu, which configures the segmentation hardware with separate segments for privilege level 0 (kernel) and privilege level 3 (user).
env_setup_vm()
Allocate a page directory for a new environment and initialize the kernel portion of the new environment‘s address space.
region_alloc()
Allocates and maps physical memory for an environment
load_icode()
You will need to parse an ELF binary image, much like the boot loader already does, and load its contents into the user address space of a new environment.
env_create()
Allocate an environment with env_alloc and call load_icode load an ELF binary into it.
env_run()
Start a given environment running in user mode.
As you write these functions, you might find the new cprintf verb %e useful -- it prints a description corresponding to an error code. For example,

    r = -E_NO_MEM;
    panic("env_alloc: %e", r);
will panic with the message "env_alloc: out of memory".

 1 // Mark all environments in ‘envs‘ as free, set their env_ids to 0,
 2 // and insert them into the env_free_list.
 3 // Make sure the environments are in the free list in the same order
 4 // they are in the envs array (i.e., so that the first call to
 5 // env_alloc() returns envs[0]).
 6 //
 7 void
 8 env_init(void)
 9 {
10     // Set up envs array
11     // LAB 3: Your code here.
12 
13     int i = 0;
14     env_free_list = NULL;
15     cprintf("NENV -1 : %u\n", NENV -1);
16 
17     for (i = NENV -1; i >= 0; i--)
18     {
19         envs[i].env_id = 0;
20         envs[i].env_parent_id = 0;
21         envs[i].env_type = ENV_TYPE_USER;
22         envs[i].env_status = ENV_FREE;
23         envs[i].env_runs = 0;
24         envs[i].env_pgdir = NULL;
25         envs[i].env_link = env_free_list;
26         env_free_list = &envs[i];
27     }
28 
29     cprintf("env_free_list : 0x%08x, & envs[i]: 0x%08x\n", env_free_list, &envs[i]);
30 
31     // Per-CPU part of the initialization
32     env_init_percpu();
33 }

 1 static int
 2 env_setup_vm(struct Env *e)
 3 {
 4     int i;
 5     struct PageInfo *p = NULL;
 6 
 7     // Allocate a page for the page directory
 8     if (!(p = page_alloc(ALLOC_ZERO)))
 9         return -E_NO_MEM;
10 
11     // Now, set e->env_pgdir and initialize the page directory.
12     //
13     // Hint:
14     //    - The VA space of all envs is identical above UTOP
15     //    (except at UVPT, which we‘ve set below).
16     //    See inc/memlayout.h for permissions and layout.
17     //    Can you use kern_pgdir as a template?  Hint: Yes.
18     //    (Make sure you got the permissions right in Lab 2.)
19     //    - The initial VA below UTOP is empty.
20     //    - You do not need to make any more calls to page_alloc.
21     //    - Note: In general, pp_ref is not maintained for
22     //    physical pages mapped only above UTOP, but env_pgdir
23     //    is an exception -- you need to increment env_pgdir‘s
24     //    pp_ref for env_free to work correctly.
25     //    - The functions in kern/pmap.h are handy.
26 
27     // LAB 3: Your code here.
28     (p->pp_ref)++;
29     pde_t* page_dir = page2kva(p);
30     memcpy(page_dir, kern_pgdir, PGSIZE);
31     e->env_pgdir = page_dir;
32 
33     // UVPT maps the env‘s own page table read-only.
34     // Permissions: kernel R, user R
35     e->env_pgdir[PDX(UVPT)] = PADDR(e->env_pgdir) | PTE_P | PTE_U;
36 
37     return 0;
38 }

 1 static void
 2 region_alloc(struct Env *e, void *va, size_t len)
 3 {
 4     // LAB 3: Your code here.
 5     // (But only if you need it for load_icode.)
 6     //
 7     // Hint: It is easier to use region_alloc if the caller can pass
 8     //   ‘va‘ and ‘len‘ values that are not page-aligned.
 9     //   You should round va down, and round (va + len) up.
10     //   (Watch out for corner-cases!)
11 
12     va = ROUNDDOWN(va, PGSIZE);
13     len = ROUNDUP(len, PGSIZE);
14 
15     struct PageInfo *pp;
16     int ret = 0;
17 
18     for(; len > 0; len -= PGSIZE, va += PGSIZE)
19     {
20         pp = page_alloc(0);
21 
22         if(!pp)
23         {
24             panic("region_alloc failed\n");
25         }
26 
27         ret = page_insert(e->env_pgdir, pp, va, PTE_U | PTE_W | PTE_P);
28 
29         if(ret)
30         {
31             panic("region_alloc failed\n");
32         }
33     }
34 }

 1 static void
 2 load_icode(struct Env *e, uint8_t * binary)
 3 {
 4     // Hints:
 5     //  Load each program segment into virtual memory
 6     //  at the address specified in the ELF section header.
 7     //  You should only load segments with ph->p_type == ELF_PROG_LOAD.
 8     //  Each segment‘s virtual address can be found in ph->p_va
 9     //  and its size in memory can be found in ph->p_memsz.
10     //  The ph->p_filesz bytes from the ELF binary, starting at
11     //  ‘binary + ph->p_offset‘, should be copied to virtual address
12     //  ph->p_va.  Any remaining memory bytes should be cleared to zero.
13     //  (The ELF header should have ph->p_filesz <= ph->p_memsz.)
14     //  Use functions from the previous lab to allocate and map pages.
15     //
16     //  All page protection bits should be user read/write for now.
17     //  ELF segments are not necessarily page-aligned, but you can
18     //  assume for this function that no two segments will touch
19     //  the same virtual page.
20     //
21     //  You may find a function like region_alloc useful.
22     //
23     //  Loading the segments is much simpler if you can move data
24     //  directly into the virtual addresses stored in the ELF binary.
25     //  So which page directory should be in force during
26     //  this function?
27     //
28     //  You must also do something with the program‘s entry point,
29     //  to make sure that the environment starts executing there.
30     //  What?  (See env_run() and env_pop_tf() below.)
31 
32     // LAB 3: Your code here.
33 
34     struct Elf* elfhdr = (struct Elf *)binary;
35     struct Proghdr *ph, *eph;
36     
37     if(elfhdr->e_magic != ELF_MAGIC)
38     {
39         panic("elf header‘s magic is not correct\n");
40     }
41 
42     ph = (struct Proghdr *)((uint8_t *)elfhdr + elfhdr->e_phoff);
43 
44     eph = ph + elfhdr->e_phnum;
45 
46     lcr3(PADDR(e->env_pgdir));
47 
48     for(;ph < eph; ph++)
49     {
50         if(ph->p_type != ELF_PROG_LOAD)
51         {
52             continue;
53         }
54 
55         if(ph->p_filesz > ph->p_memsz)
56         {
57             panic("file size is great than memory size\n");
58         }
59 
60         region_alloc(e, (void *)ph->p_va, ph->p_memsz);
61         memmove((void *)ph->p_va, binary + ph->p_offset, ph->p_filesz);
62 
63         memset((void *)ph->p_va + ph->p_filesz, 0, (ph->p_memsz - ph->p_filesz));
64     }
65 
66     // Now map one page for the program‘s initial stack
67     // at virtual address USTACKTOP - PGSIZE.
68 
69     // LAB 3: Your code here.
70 
71     lcr3(PADDR(kern_pgdir));
72 
73     e->env_tf.tf_eip = elfhdr->e_entry;
74 
75     region_alloc(e, (void *)(USTACKTOP - PGSIZE), PGSIZE);
76 }

 1 void
 2 env_create(uint8_t *binary, enum EnvType type)
 3 {
 4     // LAB 3: Your code here.
 5     int ret = 0;
 6     struct Env *e = NULL;
 7     ret = env_alloc(&e, 0);
 8 
 9     if(ret < 0)
10     {
11         panic("env_create: %e\n", ret);
12     }
13 
14     load_icode(e, binary);
15     e->env_type = type;
16 }

 1 void
 2 env_run(struct Env *e)
 3 {
 4     // Step 1: If this is a context switch (a new environment is running):
 5     //       1. Set the current environment (if any) back to
 6     //          ENV_RUNNABLE if it is ENV_RUNNING (think about
 7     //          what other states it can be in),
 8     //       2. Set ‘curenv‘ to the new environment,
 9     //       3. Set its status to ENV_RUNNING,
10     //       4. Update its ‘env_runs‘ counter,
11     //       5. Use lcr3() to switch to its address space.
12     // Step 2: Use env_pop_tf() to restore the environment‘s
13     //       registers and drop into user mode in the
14     //       environment.
15 
16     // Hint: This function loads the new environment‘s state from
17     //    e->env_tf.  Go back through the code you wrote above
18     //    and make sure you have set the relevant parts of
19     //    e->env_tf to sensible values.
20 
21     // LAB 3: Your code here.
22 
23     //panic("env_run not yet implemented");
24 
25     if(curenv && curenv->env_status == ENV_RUNNING)
26     {
27         curenv->env_status = ENV_RUNNABLE;
28     }
29 
30     curenv = e;
31     e->env_status = ENV_RUNNING;
32     e->env_runs++;
33 
34     lcr3(PADDR(e->env_pgdir));
35 
36     env_pop_tf(&(e->env_tf));
37 }