Zhiyuan Shao
3 years ago
parent
9c8cbfaa3b
commit
769c280d05
@ -0,0 +1,16 @@
|
||||
#ifndef _MEMLAYOUT_H
|
||||
#define _MEMLAYOUT_H
|
||||
|
||||
// RISC-V machine places its physical memory above DRAM_BASE
|
||||
#define DRAM_BASE 0x80000000
|
||||
|
||||
// the beginning virtual address of PKE kernel
|
||||
#define KERN_BASE 0x80000000
|
||||
|
||||
// default stack size
|
||||
#define STACK_SIZE 4096
|
||||
|
||||
// virtual address of stack top of user process
|
||||
#define USER_STACK_TOP 0x7ffff000
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,88 @@
|
||||
#include "pmm.h"
|
||||
#include "util/functions.h"
|
||||
#include "riscv.h"
|
||||
#include "config.h"
|
||||
#include "util/string.h"
|
||||
#include "memlayout.h"
|
||||
#include "spike_interface/spike_utils.h"
|
||||
|
||||
// _end is defined in kernel/kernel.lds, it marks the ending (virtual) address of PKE kernel
|
||||
extern char _end[];
|
||||
// g_mem_size is defined in spike_interface/spike_memory.c, it indicates the size of our
|
||||
// (emulated) spike machine. g_mem_size's value is obtained when initializing HTIF.
|
||||
extern uint64 g_mem_size;
|
||||
|
||||
static uint64 free_mem_start_addr; //beginning address of free memory
|
||||
static uint64 free_mem_end_addr; //end address of free memory (not included)
|
||||
|
||||
typedef struct node {
|
||||
struct node *next;
|
||||
} list_node;
|
||||
|
||||
// g_free_mem_list is the head of the list of free physical memory pages
|
||||
static list_node g_free_mem_list;
|
||||
|
||||
//
|
||||
// actually creates the freepage list. each page occupies 4KB (PGSIZE), i.e., small page.
|
||||
// PGSIZE is defined in kernel/riscv.h, ROUNDUP is defined in util/functions.h.
|
||||
//
|
||||
static void create_freepage_list(uint64 start, uint64 end) {
|
||||
g_free_mem_list.next = 0;
|
||||
for (uint64 p = ROUNDUP(start, PGSIZE); p + PGSIZE < end; p += PGSIZE)
|
||||
free_page( (void *)p );
|
||||
}
|
||||
|
||||
//
|
||||
// place a physical page at *pa to the free list of g_free_mem_list (to reclaim the page)
|
||||
//
|
||||
void free_page(void *pa) {
|
||||
if (((uint64)pa % PGSIZE) != 0 || (uint64)pa < free_mem_start_addr || (uint64)pa >= free_mem_end_addr)
|
||||
panic("free_page 0x%lx \n", pa);
|
||||
|
||||
// insert a physical page to g_free_mem_list
|
||||
list_node *n = (list_node *)pa;
|
||||
n->next = g_free_mem_list.next;
|
||||
g_free_mem_list.next = n;
|
||||
}
|
||||
|
||||
//
|
||||
// takes the first free page from g_free_mem_list, and returns (allocates) it.
|
||||
// Allocates only ONE page!
|
||||
//
|
||||
void *alloc_page(void) {
|
||||
list_node *n = g_free_mem_list.next;
|
||||
if (n) g_free_mem_list.next = n->next;
|
||||
|
||||
return (void *)n;
|
||||
}
|
||||
|
||||
//
|
||||
// pmm_init() establishes the list of free physical pages according to available
|
||||
// physical memory space.
|
||||
//
|
||||
void pmm_init() {
|
||||
// start of kernel program segment
|
||||
uint64 g_kernel_start = KERN_BASE;
|
||||
uint64 g_kernel_end = (uint64)&_end;
|
||||
|
||||
uint64 pke_kernel_size = g_kernel_end - g_kernel_start;
|
||||
sprint("PKE kernel start 0x%lx, PKE kernel end: 0x%lx, PKE kernel size: 0x%lx .\n",
|
||||
g_kernel_start, g_kernel_end, pke_kernel_size);
|
||||
|
||||
// free memory starts from the end of PKE kernel and must be page-aligined
|
||||
free_mem_start_addr = ROUNDUP(g_kernel_end , PGSIZE);
|
||||
|
||||
// recompute g_mem_size to limit the physical memory space that our riscv-pke kernel
|
||||
// needs to manage
|
||||
g_mem_size = MIN(PKE_MAX_ALLOWABLE_RAM, g_mem_size);
|
||||
if( g_mem_size < pke_kernel_size )
|
||||
panic( "Error when recomputing physical memory size (g_mem_size).\n" );
|
||||
|
||||
free_mem_end_addr = g_mem_size + DRAM_BASE;
|
||||
sprint("free physical memory address: [0x%lx, 0x%lx] \n", free_mem_start_addr,
|
||||
free_mem_end_addr - 1);
|
||||
|
||||
sprint("kernel memory manager is initializing ...\n");
|
||||
// create the list of free pages
|
||||
create_freepage_list(free_mem_start_addr, free_mem_end_addr);
|
||||
}
|
||||
@ -0,0 +1,11 @@
|
||||
#ifndef _PMM_H_
|
||||
#define _PMM_H_
|
||||
|
||||
// Initialize phisical memeory manager
|
||||
void pmm_init();
|
||||
// Allocate a free phisical page
|
||||
void* alloc_page();
|
||||
// Free an allocated page
|
||||
void free_page(void* pa);
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,173 @@
|
||||
/*
|
||||
* virtual address mapping related functions.
|
||||
*/
|
||||
|
||||
#include "vmm.h"
|
||||
#include "riscv.h"
|
||||
#include "pmm.h"
|
||||
#include "util/types.h"
|
||||
#include "memlayout.h"
|
||||
#include "util/string.h"
|
||||
#include "spike_interface/spike_utils.h"
|
||||
#include "util/functions.h"
|
||||
|
||||
/* --- utility functions for virtual address mapping --- */
|
||||
//
|
||||
// establish mapping of virtual address [va, va+size] to phyiscal address [pa, pa+size]
|
||||
// with the permission of "perm".
|
||||
//
|
||||
int map_pages(pagetable_t page_dir, uint64 va, uint64 size, uint64 pa, int perm) {
|
||||
uint64 first, last;
|
||||
pte_t *pte;
|
||||
|
||||
for (first = ROUNDDOWN(va, PGSIZE), last = ROUNDDOWN(va + size - 1, PGSIZE);
|
||||
first <= last; first += PGSIZE, pa += PGSIZE) {
|
||||
if ((pte = page_walk(page_dir, first, 1)) == 0) return -1;
|
||||
if (*pte & PTE_V)
|
||||
panic("map_pages fails on mapping va (0x%lx) to pa (0x%lx)", first, pa);
|
||||
*pte = PA2PTE(pa) | perm | PTE_V;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
//
|
||||
// convert permission code to permission types of PTE
|
||||
//
|
||||
uint64 prot_to_type(int prot, int user) {
|
||||
uint64 perm = 0;
|
||||
if (prot & PROT_READ) perm |= PTE_R | PTE_A;
|
||||
if (prot & PROT_WRITE) perm |= PTE_W | PTE_D;
|
||||
if (prot & PROT_EXEC) perm |= PTE_X | PTE_A;
|
||||
if (perm == 0) perm = PTE_R;
|
||||
if (user) perm |= PTE_U;
|
||||
return perm;
|
||||
}
|
||||
|
||||
//
|
||||
// traverse the page table (starting from page_dir) to find the corresponding pte of va.
|
||||
// returns: PTE (page table entry) pointing to va.
|
||||
//
|
||||
pte_t *page_walk(pagetable_t page_dir, uint64 va, int alloc) {
|
||||
if (va >= MAXVA) panic("page_walk");
|
||||
|
||||
// starting from the page directory
|
||||
pagetable_t pt = page_dir;
|
||||
|
||||
// traverse from page directory to page table.
|
||||
// as we use risc-v sv39 paging scheme, there will be 3 layers: page dir,
|
||||
// page medium dir, and page table.
|
||||
for (int level = 2; level > 0; level--) {
|
||||
// macro "PX" gets the PTE index in page table of current level
|
||||
// "pte" points to the entry of current level
|
||||
pte_t *pte = pt + PX(level, va);
|
||||
|
||||
// now, we need to know if above pte is valid (established mapping to a phyiscal page)
|
||||
// or not.
|
||||
if (*pte & PTE_V) { //PTE valid
|
||||
// phisical address of pagetable of next level
|
||||
pt = (pagetable_t)PTE2PA(*pte);
|
||||
} else { //PTE invalid (not exist).
|
||||
// allocate a page (to be the new pagetable), if alloc == 1
|
||||
if( alloc && ((pt = (pte_t *)alloc_page(1)) != 0) ){
|
||||
memset(pt, 0, PGSIZE);
|
||||
// writes the physical address of newly allocated page to pte, to establish the
|
||||
// page table tree.
|
||||
*pte = PA2PTE(pt) | PTE_V;
|
||||
}else //returns NULL, if alloc == 0, or no more physical page remains
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
// return a PTE which contains phisical address of a page
|
||||
return pt + PX(0, va);
|
||||
}
|
||||
|
||||
//
|
||||
// look up a virtual page address, return the physical page address or 0 if not mapped.
|
||||
//
|
||||
uint64 lookup_pa(pagetable_t pagetable, uint64 va) {
|
||||
pte_t *pte;
|
||||
uint64 pa;
|
||||
|
||||
if (va >= MAXVA) return 0;
|
||||
|
||||
pte = page_walk(pagetable, va, 0);
|
||||
if (pte == 0 || (*pte & PTE_V) == 0 || ((*pte & PTE_R) == 0 && (*pte & PTE_W) == 0))
|
||||
return 0;
|
||||
pa = PTE2PA(*pte);
|
||||
|
||||
return pa;
|
||||
}
|
||||
|
||||
/* --- kernel page table part --- */
|
||||
// _etext is defined in kernel.lds, it points to the address after text and rodata segments.
|
||||
extern char _etext[];
|
||||
|
||||
// pointer to kernel page director
|
||||
pagetable_t g_kernel_pagetable;
|
||||
|
||||
//
|
||||
// maps virtual address [va, va+sz] to [pa, pa+sz] (for kernel).
|
||||
//
|
||||
void kern_vm_map(pagetable_t page_dir, uint64 va, uint64 pa, uint64 sz, int perm) {
|
||||
// map_pages is defined in kernel/vmm.c
|
||||
if (map_pages(page_dir, va, sz, pa, perm) != 0) panic("kern_vm_map");
|
||||
}
|
||||
|
||||
//
|
||||
// kern_vm_init() constructs the kernel page table.
|
||||
//
|
||||
void kern_vm_init(void) {
|
||||
// pagetable_t is defined in kernel/riscv.h. it's actually uint64*
|
||||
pagetable_t t_page_dir;
|
||||
|
||||
// allocate a page (t_page_dir) to be the page directory for kernel. alloc_page is defined in kernel/pmm.c
|
||||
t_page_dir = (pagetable_t)alloc_page();
|
||||
// memset is defined in util/string.c
|
||||
memset(t_page_dir, 0, PGSIZE);
|
||||
|
||||
// map virtual address [KERN_BASE, _etext] to physical address [DRAM_BASE, DRAM_BASE+(_etext - KERN_BASE)],
|
||||
// to maintain (direct) text section kernel address mapping.
|
||||
kern_vm_map(t_page_dir, KERN_BASE, DRAM_BASE, (uint64)_etext - KERN_BASE,
|
||||
prot_to_type(PROT_READ | PROT_EXEC, 0));
|
||||
|
||||
sprint("KERN_BASE 0x%lx\n", lookup_pa(t_page_dir, KERN_BASE));
|
||||
|
||||
// also (direct) map remaining address space, to make them accessable from kernel.
|
||||
// this is important when kernel needs to access the memory content of user's app
|
||||
// without copying pages between kernel and user spaces.
|
||||
kern_vm_map(t_page_dir, (uint64)_etext, (uint64)_etext, PHYS_TOP - (uint64)_etext,
|
||||
prot_to_type(PROT_READ | PROT_WRITE, 0));
|
||||
|
||||
sprint("physical address of _etext is: 0x%lx\n", lookup_pa(t_page_dir, (uint64)_etext));
|
||||
|
||||
g_kernel_pagetable = t_page_dir;
|
||||
}
|
||||
|
||||
/* --- user page table part --- */
|
||||
//
|
||||
// convert and return the corresponding physical address of a virtual address (va) of
|
||||
// application.
|
||||
//
|
||||
void *user_va_to_pa(pagetable_t page_dir, void *va) {
|
||||
// TODO (lab2_1): implement user_va_to_pa to convert a given user virtual address "va"
|
||||
// to its corresponding physical address, i.e., "pa". To do it, we need to walk
|
||||
// through the page table, starting from its directory "page_dir", to locate the PTE
|
||||
// that maps "va". If found, returns the "pa" by using:
|
||||
// pa = PYHS_ADDR(PTE) + (va & (1<<PGSHIFT -1))
|
||||
// Here, PYHS_ADDR() means retrieving the starting address (4KB aligned), and
|
||||
// (va & (1<<PGSHIFT -1)) means computing the offset of "va" inside its page.
|
||||
// Also, it is possible that "va" is not mapped at all. in such case, we can find
|
||||
// invalid PTE, and should return NULL.
|
||||
panic( "You have to implement user_va_to_pa (convert user va to pa) to print messages in lab2_1.\n" );
|
||||
|
||||
}
|
||||
|
||||
//
|
||||
// maps virtual address [va, va+sz] to [pa, pa+sz] (for user application).
|
||||
//
|
||||
void user_vm_map(pagetable_t page_dir, uint64 va, uint64 size, uint64 pa, int perm) {
|
||||
if (map_pages(page_dir, va, size, pa, perm) != 0) {
|
||||
panic("fail to user_vm_map .\n");
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,33 @@
|
||||
#ifndef _VMM_H_
|
||||
#define _VMM_H_
|
||||
|
||||
#include "riscv.h"
|
||||
|
||||
/* --- utility functions for virtual address mapping --- */
|
||||
int map_pages(pagetable_t pagetable, uint64 va, uint64 size, uint64 pa, int perm);
|
||||
// permission codes.
|
||||
enum VMPermision {
|
||||
PROT_NONE = 0,
|
||||
PROT_READ = 1,
|
||||
PROT_WRITE = 2,
|
||||
PROT_EXEC = 4,
|
||||
};
|
||||
|
||||
uint64 prot_to_type(int prot, int user);
|
||||
pte_t *page_walk(pagetable_t pagetable, uint64 va, int alloc);
|
||||
uint64 lookup_pa(pagetable_t pagetable, uint64 va);
|
||||
|
||||
/* --- kernel page table --- */
|
||||
// pointer to kernel page directory
|
||||
extern pagetable_t g_kernel_pagetable;
|
||||
|
||||
void kern_vm_map(pagetable_t page_dir, uint64 va, uint64 pa, uint64 sz, int perm);
|
||||
|
||||
// Initialize the kernel pagetable
|
||||
void kern_vm_init(void);
|
||||
|
||||
/* --- user page table --- */
|
||||
void *user_va_to_pa(pagetable_t page_dir, void *va);
|
||||
void user_vm_map(pagetable_t page_dir, uint64 va, uint64 size, uint64 pa, int perm);
|
||||
|
||||
#endif
|
||||
@ -0,0 +1,12 @@
|
||||
/*
|
||||
* Below is the given application for lab2_1.
|
||||
* This app runs in its own address space, in contrast with in direct mapping.
|
||||
*/
|
||||
|
||||
#include "user_lib.h"
|
||||
#include "util/types.h"
|
||||
|
||||
int main(void) {
|
||||
printu("Hello world!\n");
|
||||
exit(0);
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
/*
|
||||
* Below is the given application for lab1_3.
|
||||
* This app performs a long loop, during which, timers are
|
||||
* generated and pop messages to our screen.
|
||||
*/
|
||||
|
||||
#include "user_lib.h"
|
||||
#include "util/types.h"
|
||||
|
||||
int main(void) {
|
||||
printu("Hello world!\n");
|
||||
int i;
|
||||
for (i = 0; i < 100000000; ++i) {
|
||||
if (i % 5000000 == 0) printu("wait %d\n", i);
|
||||
}
|
||||
|
||||
exit(0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1,14 +0,0 @@
|
||||
OUTPUT_ARCH( "riscv" )
|
||||
|
||||
ENTRY(main)
|
||||
|
||||
SECTIONS
|
||||
{
|
||||
. = 0x81000000;
|
||||
. = ALIGN(0x1000);
|
||||
.text : { *(.text) }
|
||||
. = ALIGN(16);
|
||||
.data : { *(.data) }
|
||||
. = ALIGN(16);
|
||||
.bss : { *(.bss) }
|
||||
}
|
||||
Loading…
Reference in new issue