Mit os Lab 2. Memory Management

Exercise 1. In the file kern/pmap.c, you must implement code for the following functions (probably in the order given).

boot_alloc()
mem_init() (only up to the call to check_page_free_list(1))
page_init()
page_alloc()
page_free()

check_page_free_list() and check_page_alloc() test your physical page allocator. You should boot JOS and see whether check_page_alloc() reports success. Fix your code so that it passes. You may find it helpful to add your own assert()s to verify that your assumptions are correct.

 1 static void *
 2 boot_alloc(uint32_t n)
 3 {
 4     static char *nextfree;    // virtual address of next byte of free memory
 5     char *result;
 6 
 7     // Initialize nextfree if this is the first time.
 8     // ‘end‘ is a magic symbol automatically generated by the linker,
 9     // which points to the end of the kernel‘s bss segment:
10     // the first virtual address that the linker did *not* assign
11     // to any kernel code or global variables.
12     if (!nextfree) {
13         extern char end[];
14         nextfree = (char *)ROUNDUP((char *) end, PGSIZE);
15     }
16 
17     // Allocate a chunk large enough to hold ‘n‘ bytes, then update
18     // nextfree.  Make sure nextfree is kept aligned
19     // to a multiple of PGSIZE.
20     //
21     // LAB 2: Your code here.
22     cprintf("boot_alloc memory at line_addr [%08x, %08x + %08x]\n", nextfree, nextfree, ROUNDUP(n, PGSIZE));
23     result = nextfree;
24     nextfree += ROUNDUP(n, PGSIZE);
25 
26     return result;
27 }

 1     //////////////////////////////////////////////////////////////////////
 2     // Allocate an array of npages ‘struct PageInfo‘s and store it in ‘pages‘.
 3     // The kernel uses this array to keep track of physical pages: for
 4     // each physical page, there is a corresponding struct PageInfo in this
 5     // array.  ‘npages‘ is the number of physical pages in memory.  Use memset
 6     // to initialize all fields of each struct PageInfo to 0.
 7     // Your code goes here:
 8     pages = (struct PageInfo* )boot_alloc(npages * sizeof(struct PageInfo));
 9     memset(pages, 0, npages * sizeof(struct PageInfo));
10     cprintf("npages:%d, npages_basemem:%d, pages_addr:%08x\n", npages, npages_basemem, pages);

 1 void
 2 page_init(void)
 3 {
 4     // The example code here marks all physical pages as free.
 5     // However this is not truly the case.  What memory is free?
 6     //  1) Mark physical page 0 as in use.
 7     //     This way we preserve the real-mode IDT and BIOS structures
 8     //     in case we ever need them.  (Currently we don‘t, but...)
 9     //  2) The rest of base memory, [PGSIZE, npages_basemem * PGSIZE)
10     //     is free.
11     //  3) Then comes the IO hole [IOPHYSMEM, EXTPHYSMEM), which must
12     //     never be allocated.
13     //  4) Then extended memory [EXTPHYSMEM, ...).
14     //     Some of it is in use, some is free. Where is the kernel
15     //     in physical memory?  Which pages are already in use for
16     //     page tables and other data structures?
17     //
18     // Change the code to reflect this.
19     // NB: DO NOT actually touch the physical memory corresponding to
20     // free pages!
21     size_t i;
22     pages[0].pp_ref = 1;
23     pages[0].pp_link = NULL;
24 
25     uint32_t nextfree = (uint32_t)boot_alloc(0);
26     cprintf("NPAGES: %d NPAGES_BASE_MEM: %d\n", npages, npages_basemem);
27     cprintf("NEXTFREE: %08x IOPHY: %08x  EXT: %08x\n", nextfree - KERNBASE, IOPHYSMEM, EXTPHYSMEM);
28     for (i = 1; i < npages; i++) 
29     {
30         if ((i >= (IOPHYSMEM / PGSIZE)) && (i < ((nextfree - KERNBASE)/ PGSIZE))) 
31         {
32             pages[i].pp_ref = 1;
33             pages[i].pp_link = NULL;
34         }
35         else 
36         {
37             pages[i].pp_ref = 0;
38             pages[i].pp_link = page_free_list;
39             page_free_list = &pages[i];
40         }
41     }
42 }

 1 struct PageInfo *
 2 page_alloc(int alloc_flags)
 3 {
 4     // Fill this function in
 5     struct PageInfo* pginfo = NULL;
 6     if (!page_free_list)
 7     {
 8         return NULL;
 9     }
10 
11     pginfo = page_free_list;
12     page_free_list = pginfo->pp_link;
13     if (alloc_flags & ALLOC_ZERO)
14     {
15         memset(page2kva(pginfo), 0, PGSIZE);
16     }
17 
18     return pginfo;
19 }

 1 void
 2 page_free(struct PageInfo *pp)
 3 {
 4     // Fill this function in
 5     // Hint: You may want to panic if pp->pp_ref is nonzero or
 6     // pp->pp_link is not NULL.
 7 
 8     assert(pp->pp_ref == 0 || pp->pp_link == NULL);
 9 
10     pp->pp_link = page_free_list;
11     page_free_list = pp;
12 }