Mit os Lab 2. Memory Management

Part 1: Physical Page 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.

在lab1中，内存布局如下：

kernel是0xF0100000 - end 部分， 剩下4K大小是页目录表：

需要由函数boot_alloc填补。

这部分的地址都是线性地址，即line_addr: 0xF0100000 ==> phy_addr: 0x00100000

PADDR: 线性地址转物理地址， kva-KERNBASE

KADDR: 物理地址转线性地址，pva+KERNBASE

page2pa: 页表项转物理地址，全局变量pages表示页表项的起始地址， pp-pages表示第k个页， 则(pp-pages)<<PAGE_SHIFT则为页表项pp的物理地址。

1) boot_alloc

static void *
boot_alloc(uint32_t n)
{
    static char *nextfree;    // virtual address of next byte of free memory
    char *result;

    // Initialize nextfree if this is the first time.
    // 'end' is a magic symbol automatically generated by the linker,
    // which points to the end of the kernel's bss segment:
    // the first virtual address that the linker did *not* assign
    // to any kernel code or global variables.
    if (!nextfree) {
        extern char end[];
        nextfree = (char *)ROUNDUP((char *) end, PGSIZE);
    }

    // Allocate a chunk large enough to hold 'n' bytes, then update
    // nextfree.  Make sure nextfree is kept aligned
    // to a multiple of PGSIZE.
    //
    // LAB 2: Your code here.
22     cprintf("boot_alloc memory at line_addr [%08x, %08x + %08x]
", nextfree, nextfree, ROUNDUP(n, PGSIZE));
23     result = nextfree;
24     nextfree += ROUNDUP(n, PGSIZE);

    return result;
}

这里有个技巧，局部静态变量nextfree未初始化时默认为0，第一次会执行12-15行，再次调用则不会。

2) 完善mem_init

这里需要分配页表项，内存布局如下：

在mem_init中，已经通过kern_pgdir = (pde_t *) boot_alloc(PGSIZE);分配了页目录表，完善分配页表项PagesInfo：

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

3) page_init

通过全局变量page_free_list，将所有的页表项PageInfo和4K大小的页一一映射。

内存分配 [PAGE0][PGSIZE, npages_basemem * PGSIZE)[IOPHYSMEM, EXTPHYSMEM)[EXTPHYSMEM, ...)

PAGE0留作BIOS和IDT等，PAGE1-npages_basemem可以分配，IOmem到EXTmem用于IO， 之后是EXTPHYSMEM，

EXTPHYSMEM的起始部分到nextfree会用作kernel、页目录、页表项等，应该从nextfree再开始分配。

void
page_init(void)
{
    // The example code here marks all physical pages as free.
    // However this is not truly the case.  What memory is free?
    //  1) Mark physical page 0 as in use.
    //     This way we preserve the real-mode IDT and BIOS structures
    //     in case we ever need them.  (Currently we don't, but...)
    //  2) The rest of base memory, [PGSIZE, npages_basemem * PGSIZE)
    //     is free.
    //  3) Then comes the IO hole [IOPHYSMEM, EXTPHYSMEM), which must
    //     never be allocated.
    //  4) Then extended memory [EXTPHYSMEM, ...).
    //     Some of it is in use, some is free. Where is the kernel
    //     in physical memory?  Which pages are already in use for
    //     page tables and other data structures?
    //
    // Change the code to reflect this.
    // NB: DO NOT actually touch the physical memory corresponding to
    // free pages!
    size_t i;
    pages[0].pp_ref = 1;
    pages[0].pp_link = NULL;

    uint32_t nextfree = (uint32_t)boot_alloc(0);
    cprintf("NPAGES: %d NPAGES_BASE_MEM: %d
", npages, npages_basemem);
    cprintf("NEXTFREE: %08x IOPHY: %08x  EXT: %08x
", nextfree - KERNBASE, IOPHYSMEM, EXTPHYSMEM);
    for (i = 1; i < npages; i++) 
    {
        if ((i >= (IOPHYSMEM / PGSIZE)) && (i < ((nextfree - KERNBASE)/ PGSIZE))) 
        {
            pages[i].pp_ref = 1;
            pages[i].pp_link = NULL;
        }
        else 
        {
            pages[i].pp_ref = 0;
            pages[i].pp_link = page_free_list;
            page_free_list = &pages[i];
        }
    }
}

4) page_alloc

page_alloc函数的实现. 就是把当前free list中的空闲页释放一个，然后更新page_free_list，让ta指向下一个空闲页即可

如果传入ALLOC_ZERO的flag，则用memset清零。

struct PageInfo *
page_alloc(int alloc_flags)
{
    // Fill this function in
    struct PageInfo* pginfo = NULL;
    if (!page_free_list)
    {
        return NULL;
    }

    pginfo = page_free_list;
    page_free_list = pginfo->pp_link;
    if (alloc_flags & ALLOC_ZERO)
    {
        memset(page2kva(pginfo), 0, PGSIZE);
    }

    return pginfo;
}

5) page_free

对应的page_free就是把pp描述的page加入到free list当中去，使得pp成为最新的page_free_list.

void
page_free(struct PageInfo *pp)
{
    // Fill this function in
    // Hint: You may want to panic if pp->pp_ref is nonzero or
    // pp->pp_link is not NULL.

    assert(pp->pp_ref == 0 || pp->pp_link == NULL);

    pp->pp_link = page_free_list;
    page_free_list = pp;
}

Part 2: Virtual Memory

在Linux下, 每个进程都有自己独立的地址空间, 32bit的系统下位4GB. 所以, 每个地址的长度都是四字节, 也正好是一个指针的大小. 在了解了Linux的分页机制之后, 可以看到一个Virtual address其实是由如下3个部分组成:

// A linear address 'la' has a three-part structure as follows:
//
// +--------10------+-------10-------+---------12----------+
// | Page Directory |   Page Table   | Offset within Page  |
// |      Index     |      Index     |                     |
// +----------------+----------------+---------------------+
//  --- PDX(la) --/ --- PTX(la) --/ ---- PGOFF(la) ----/
//  ---------- PGNUM(la) ----------/

页目录(Page directory)其实是一个长度为1024的整形数组, 里面的每个元素是指向每一个页表(Page table)的指针. 每个页表也是个长度为1024的整形数组, 里边的元素则是物理地址的值.

然一个虚拟地址的高10位是该地址对应的页目录索引, 用于获取页目录中指向该地址的页表的地址.

通过10~20位, 能够得到该地址在页表项的索引, 然后就能够得到该地址对应的物理地址, 最后, 虚拟地址的低12位加上物理地址的基地址. 就完成了由虚拟地址到物理地址的转换.

 如图所示：

1) pgdir_walk

pgdir_walk 根据全局pgdir和虚拟地址va，获取va所在的页表项pte。

pte_t *
pgdir_walk(pde_t *pgdir, const void *va, int create)
{
    // Fill this function in
    int pd_idx = PDX(va);
    int pte_idx = PTX(va);
    if (pgdir[pd_idx] & PTE_P) // if pde exist
    {
        pte_t *ptebase = KADDR(PTE_ADDR(pgdir[pd_idx]));  // 这里ptebase指向上图中的Page Table基地址
        return ptebase + pte_idx; 
    }
    // pde not exist
    if (!create)
        return NULL;
    struct PageInfo* pg = page_alloc(ALLOC_ZERO);
    if (!pg)
        return NULL;
    pg->pp_ref++;
    pgdir[pd_idx] = page2pa(pg) | PTE_P | PTE_U | PTE_W;  // 初始化PageDirectory中的pd_idx项

    pte_t *ptebase = KADDR(PTE_ADDR(pgdir[pd_idx]));
    return ptebase + pte_idx;
}

2) boot_map_region

boot_map_region函数将虚拟地址[va,va+size)的区域映射到物理地址pa开始的物理内存中。

static void
boot_map_region(pde_t *pgdir, uintptr_t va, size_t size, physaddr_t pa, int perm)
{
    // Fill this function in
    int i;
    cprintf("start: VA %08x mapped to PA %08x, size:%08x
", va, pa, size);
    for (i = 0; i < size / PGSIZE; i++)
    {
        pte_t* pte = pgdir_walk(pgdir, (void* )va, 1); //create
        if (!pte)
            panic("boot_map_region panic: out of memory!
");
        *pte = pa | perm | PTE_P;   // 初始化pte
        va += PGSIZE;
        pa += PGSIZE;
    }
    cprintf("end: VA %08x mapped to PA %08x, size:%08x
", va, pa, size);
}

3) page_lookup

page_lookup函数检测va虚拟地址的虚拟页是否存在不存在返回NULL，

存在返回描述该虚拟地址关联物理内存页的描述结构体PageInfo的指针

struct PageInfo *
page_lookup(pde_t *pgdir, void *va, pte_t **pte_store)
{
    // Fill this function in
    pte_t * pte = pgdir_walk(pgdir, va, 0);

    if(!pte)
    {
        return NULL;
    }

    *pte_store = pte;

    return pa2page(PTE_ADDR(*pte));
}

4) page_remove

void
page_remove(pde_t *pgdir, void *va)
{
    // Fill this function in
    pte_t* pte;
    struct PageInfo* pp = page_lookup(pgdir, va, &pte);
    if (!pp)
        return;

    page_decref(pp);
    *pte = 0;
    tlb_invalidate(pgdir, va);
}

5) page_insert

page_insert 把pp描述的物理页与虚拟地址va关联起来

如果va所在的虚拟内存页不存在，那么pgdir_walk的create为1,创建这个虚拟页

如果va所在的虚拟内存页存在，那么取消当前va的虚拟内存页也和之前物理页的关联，并且为va建立新的物理页联系——pp所描述的物理页

int
page_insert(pde_t *pgdir, struct PageInfo *pp, void *va, int perm)
{
    // Fill this function in
    
    pte_t *pte = pgdir_walk(pgdir, va, 0);
    physaddr_t ppa = page2pa(pp);

    if(pte)
    {
        if(*pte & PTE_P)
        {
            page_remove(pgdir, va);  // 取消va与之前物理页的映射
        }

        if(page_free_list == pp)
        {
            page_free_list = page_free_list->pp_link;
        }
    }
    else
    {
        pte = pgdir_walk(pgdir, va, 1);
        if(!pte)
        {
            return -E_NO_MEM;
        }

    }

    *pte = page2pa(pp) | PTE_P | perm; // 创建pp与va的映射

    pp->pp_ref++;
    tlb_invalidate(pgdir, va);
    return 0;
}

 

Part 3: Kernel Address Space

nitializing the Kernel Address Space 已经差不多了, 接下来我们需要初始化内存空间.

Exercise 5. Fill in the missing code in mem_init() after the call to check_page().

Your code should now pass the check_kern_pgdir() and check_page_installed_pgdir() checks.

注意下面ULIM是分界线，ULIM以上是内核地址空间，以下是用户空间

这个页面布局代表的是启用地址转换以后,无论是操作系统还是用户程序,看到的虚拟内存布局，这也就是说,操
操作系统和用户程序使用的是同一套页目录和页表。

    //////////////////////////////////////////////////////////////////////
    // Map 'pages' read-only by the user at linear address UPAGES
    // Permissions:
    //    - the new image at UPAGES -- kernel R, user R
    //      (ie. perm = PTE_U | PTE_P)
    //    - pages itself -- kernel RW, user NONE
    // Your code goes here:

    boot_map_region(kern_pgdir,
                    UPAGES,
                    ROUNDUP((sizeof(struct PageInfo) * npages), PGSIZE),
                    PADDR(pages),
                    (PTE_U | PTE_P));

    //////////////////////////////////////////////////////////////////////
    // Use the physical memory that 'bootstack' refers to as the kernel
    // stack.  The kernel stack grows down from virtual address KSTACKTOP.
    // We consider the entire range from [KSTACKTOP-PTSIZE, KSTACKTOP)
    // to be the kernel stack, but break this into two pieces:
    //     * [KSTACKTOP-KSTKSIZE, KSTACKTOP) -- backed by physical memory
    //     * [KSTACKTOP-PTSIZE, KSTACKTOP-KSTKSIZE) -- not backed; so if
    //       the kernel overflows its stack, it will fault rather than
    //       overwrite memory.  Known as a "guard page".
    //     Permissions: kernel RW, user NONE
    // Your code goes here:
    
    boot_map_region(kern_pgdir,
                (KSTACKTOP - KSTKSIZE),
                KSTKSIZE,
                PADDR(bootstack),
                (PTE_W | PTE_P));

    //////////////////////////////////////////////////////////////////////
    // Map all of physical memory at KERNBASE.
    // Ie.  the VA range [KERNBASE, 2^32) should map to
    //      the PA range [0, 2^32 - KERNBASE)
    // We might not have 2^32 - KERNBASE bytes of physical memory, but
    // we just set up the mapping anyway.
    // Permissions: kernel RW, user NONE
    // Your code goes here:
    boot_map_region(kern_pgdir,
                KERNBASE,
                ROUNDUP((0xFFFFFFFF - KERNBASE), PGSIZE),
                0,
                (PTE_W) | (PTE_P));

    // Check that the initial page directory has been set up correctly.
    check_kern_pgdir();
    cprintf("so far, exercise 5 works well :)
");