MIT 6.828 lab3 完整代码

/* See COPYRIGHT for copyright information. */ #include <inc/x86.h> #include <inc/mmu.h> #include <inc/error.h> #include <inc/string.h> #include <inc/assert.h> #include <kern/pmap.h> #include <kern/kclock.h> #include <kern/env.h> // These variables are set by i386_detect_memory() size_t npages; // Amount of physical memory (in pages) static size_t npages_basemem; // Amount of base memory (in pages) // These variables are set in mem_init() pde_t *kern_pgdir; // Kernel's initial page directory struct PageInfo *pages; // Physical page state array static struct PageInfo *page_free_list; // Free list of physical pages // -------------------------------------------------------------- // Detect machine's physical memory setup. // -------------------------------------------------------------- static int nvram_read(int r) { return mc146818_read(r) | (mc146818_read(r + 1) << 8); } static void i386_detect_memory(void) { size_t npages_extmem; // Use CMOS calls to measure available base & extended memory. // (CMOS calls return results in kilobytes.) npages_basemem = (nvram_read(NVRAM_BASELO) * 1024) / PGSIZE; npages_extmem = (nvram_read(NVRAM_EXTLO) * 1024) / PGSIZE; // Calculate the number of physical pages available in both base // and extended memory. if (npages_extmem) npages = (EXTPHYSMEM / PGSIZE) + npages_extmem; else npages = npages_basemem; cprintf("Physical memory: %uK available, base = %uK, extended = %uK\n", npages * PGSIZE / 1024, npages_basemem * PGSIZE / 1024, npages_extmem * PGSIZE / 1024); } // -------------------------------------------------------------- // Set up memory mappings above UTOP. // -------------------------------------------------------------- static void boot_map_region(pde_t *pgdir, uintptr_t va, size_t size, physaddr_t pa, int perm); static void check_page_free_list(bool only_low_memory); static void check_page_alloc(void); static void check_kern_pgdir(void); static physaddr_t check_va2pa(pde_t *pgdir, uintptr_t va); static void check_page(void); static void check_page_installed_pgdir(void); // This simple physical memory allocator is used only while JOS is setting // up its virtual memory system. page_alloc() is the real allocator. // // If n>0, allocates enough pages of contiguous physical memory to hold 'n' // bytes. Doesn't initialize the memory. Returns a kernel virtual address. // // If n==0, returns the address of the next free page without allocating // anything. // // If we're out of memory, boot_alloc should panic. // This function may ONLY be used during initialization, // before the page_free_list list has been set up. 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 = 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. cprintf("boot_alloc memory at %x\n", nextfree); cprintf("Next memory at %x\n", ROUNDUP((char *) (nextfree+n), PGSIZE)); if (n != 0) { char *next = nextfree; nextfree = ROUNDUP((char *) (nextfree+n), PGSIZE); return next; } else return nextfree; return NULL; } // Set up a two-level page table: // kern_pgdir is its linear (virtual) address of the root // // This function only sets up the kernel part of the address space // (ie. addresses >= UTOP). The user part of the address space // will be setup later. // // From UTOP to ULIM, the user is allowed to read but not write. // Above ULIM the user cannot read or write. void mem_init(void) { uint32_t cr0; size_t n; // Find out how much memory the machine has (npages & npages_basemem). i386_detect_memory(); // Remove this line when you're ready to test this function. // panic("mem_init: This function is not finished\n"); ////////////////////////////////////////////////////////////////////// // create initial page directory. kern_pgdir = (pde_t *) boot_alloc(PGSIZE); memset(kern_pgdir, 0, PGSIZE); ////////////////////////////////////////////////////////////////////// // Recursively insert PD in itself as a page table, to form // a virtual page table at virtual address UVPT. // (For now, you don't have understand the greater purpose of the // following line.) // Permissions: kernel R, user R kern_pgdir[PDX(UVPT)] = PADDR(kern_pgdir) | PTE_U | PTE_P; ////////////////////////////////////////////////////////////////////// // 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. // Your code goes here: pages = (struct PageInfo *) boot_alloc(sizeof(struct PageInfo) * npages); cprintf("npages: %d\n", npages); cprintf("npages_basemem: %d\n", npages_basemem); cprintf("pages: %x\n", pages); ////////////////////////////////////////////////////////////////////// // Make 'envs' point to an array of size 'NENV' of 'struct Env'. // LAB 3: Your code here. envs = (struct Env *) boot_alloc(sizeof(struct Env) * NENV); ////////////////////////////////////////////////////////////////////// // Now that we've allocated the initial kernel data structures, we set // up the list of free physical pages. Once we've done so, all further // memory management will go through the page_* functions. In // particular, we can now map memory using boot_map_region // or page_insert page_init(); check_page_free_list(1); check_page_alloc(); cprintf("so far so good\n"); check_page(); ////////////////////////////////////////////////////////////////////// // Now we set up virtual memory ////////////////////////////////////////////////////////////////////// // 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, PTSIZE, PADDR(pages), PTE_U); cprintf("PADDR(pages) %x\n", PADDR(pages)); ////////////////////////////////////////////////////////////////////// // Map the 'envs' array read-only by the user at linear address UENVS // (ie. perm = PTE_U | PTE_P). // Permissions: // - the new image at UENVS -- kernel R, user R // - envs itself -- kernel RW, user NONE // LAB 3: Your code here. boot_map_region(kern_pgdir, UENVS, PTSIZE, PADDR(envs), PTE_U); ////////////////////////////////////////////////////////////////////// // 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); cprintf("PADDR(bootstack) %x\n", PADDR(bootstack)); ////////////////////////////////////////////////////////////////////// // Map all of physical memory at KERNBASE. // Ie. the VA range [KERNBASE, 2^32) should map to // the PA range [0, 2^32 - KERNBASE)