mit6.828_Jos_lab4.rar_jos lab4

/* 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> #include <kern/cpu.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 Page *pages; // Physical page state array static struct Page *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 mem_init_mp(void); 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); static void boot_map_region(pde_t *pgdir, uintptr_t va, size_t size, physaddr_t pa, int perm); // 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); } //panic("this virtual address %x\n",nextfree); // 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. if(n == 0) return nextfree; result = nextfree; nextfree += (n/PGSIZE + 1)*PGSIZE; if((int)nextfree >= npages * PGSIZE + KERNBASE) panic("Run out of memory!!\n"); return result; } // 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 two lines.) // Permissions: kernel R, user R kern_pgdir[PDX(UVPT)] = PADDR(kern_pgdir) | PTE_U | PTE_P; ////////////////////////////////////////////////////////////////////// // Allocate an array of npages 'struct Page'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 Page in this // array. 'npages' is the number of physical pages in memory. // Your code goes here: pages = (struct Page *)boot_alloc(npages * sizeof(struct Page)); //int i = 0; //for(; i < npages; i++){ // struct Page *curn_p = pages + i; // curn_p -> pp_link = curn_p + 1; // curn_p -> pp_ref = 1; //} //panic("PDX(0)"); ////////////////////////////////////////////////////////////////////// // Make 'envs' point to an array of size 'NENV' of 'struct Env'. // LAB 3: Your code here. envs = (struct Env *)boot_alloc(NENV * sizeof(struct Env)); ////////////////////////////////////////////////////////////////////// // 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(); //panic("Lab2-Part1 complete!\n"); check_page(); //panic("Lab2-Part2 complete!\n"); ////////////////////////////////////////////////////////////////////// // 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: //pte_t *p = (pte_t *)0xf03fd000; boot_map_region(kern_pgdir,UPAGES, npages * sizeof(struct Page), PADDR(pages), PTE_U|PTE_P); //cprintf("##%x", PTE_ADDR(p[PTX(UPAGES)])); ////////////////////////////////////////////////////////////////////// // 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, NENV * sizeof(struct Env), PADDR(envs), 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: // cprintf("\n%x\n", KSTACKTOP - KSTKSIZE); boot_map_region(kern_pgdir, KSTACKTOP - KSTKSIZE, KSTKSIZE, PADDR(bootstack), PTE_P|PTE_W); ////////////////////////////////////////////////////////////////////// // Map all