ch4

Author: rcy17

os/const.h

@@ -9,4 +9,28 @@ enum {
 	STDERR = 2,
 };
 
+// memory layout
+
+// the kernel expects there to be RAM
+// for use by the kernel and user pages
+// from physical address 0x80000000 to PHYSTOP.
+#define KERNBASE 0x80200000L
+#define PHYSTOP (0x80000000 + 128 * 1024 * 1024) // we have 128M memroy
+
+// one beyond the highest possible virtual address.
+// MAXVA is actually one bit less than the max allowed by
+// Sv39, to avoid having to sign-extend virtual addresses
+// that have the high bit set.
+#define MAXVA (1L << (9 + 9 + 9 + 12 - 1))
+
+// map the trampoline page to the highest address,
+// in both user and kernel space.
+#define USER_TOP (MAXVA)
+#define TRAMPOLINE (USER_TOP - PGSIZE)
+#define TRAPFRAME (TRAMPOLINE - PGSIZE)
+
+// memory layout end
+
+#define MAX_STR_LEN (200)
+
 #endif // CONST_H

os/defs.h

@@ -2,13 +2,15 @@
 #define DEFS_H
 
 #include "const.h"
+#include "kalloc.h"
 #include "log.h"
 #include "printf.h"
 #include "proc.h"
 #include "riscv.h"
 #include "sbi.h"
 #include "string.h"
 #include "types.h"
+#include "vm.h"
 
 // number of elements in fixed-size array
 #define NELEM(x) (sizeof(x) / sizeof((x)[0]))

os/kalloc.c

@@ -0,0 +1,57 @@
+#include "kalloc.h"
+#include "defs.h"
+#include "riscv.h"
+
+extern char ekernel[];
+
+struct linklist {
+	struct linklist *next;
+};
+
+struct {
+	struct linklist *freelist;
+} kmem;
+
+void freerange(void *pa_start, void *pa_end)
+{
+	char *p;
+	p = (char *)PGROUNDUP((uint64)pa_start);
+	for (; p + PGSIZE <= (char *)pa_end; p += PGSIZE)
+		kfree(p);
+}
+
+void kinit()
+{
+	freerange(ekernel, (void *)PHYSTOP);
+}
+
+// Free the page of physical memory pointed at by v,
+// which normally should have been returned by a
+// call to kalloc().  (The exception is when
+// initializing the allocator; see kinit above.)
+void kfree(void *pa)
+{
+	struct linklist *l;
+	if (((uint64)pa % PGSIZE) != 0 || (char *)pa < ekernel ||
+	    (uint64)pa >= PHYSTOP)
+		panic("kfree");
+	// Fill with junk to catch dangling refs.
+	memset(pa, 1, PGSIZE);
+	l = (struct linklist *)pa;
+	l->next = kmem.freelist;
+	kmem.freelist = l;
+}
+
+// Allocate one 4096-byte page of physical memory.
+// Returns a pointer that the kernel can use.
+// Returns 0 if the memory cannot be allocated.
+void *kalloc(void)
+{
+	struct linklist *l;
+	l = kmem.freelist;
+	if (l) {
+		kmem.freelist = l->next;
+		memset((char *)l, 5, PGSIZE); // fill with junk
+	}
+	return (void *)l;
+}

os/kalloc.h

@@ -0,0 +1,8 @@
+#ifndef KALLOC_H
+#define KALLOC_H
+
+void *kalloc(void);
+void kfree(void *);
+void kinit(void);
+
+#endif // KALLOC_H

os/loader.c

@@ -2,9 +2,9 @@
 #include "defs.h"
 #include "trap.h"
 
-static uint64 app_num;
+static int app_num;
 static uint64 *app_info_ptr;
-extern char _app_num[], ekernel[];
+extern char _app_num[];
 
 // Count finished programs. If all apps exited, shutdown.
 int finished()
@@ -18,35 +18,54 @@ int finished()
 // Get user progs' infomation through pre-defined symbol in `link_app.S`
 void loader_init()
 {
-	if ((uint64)ekernel >= BASE_ADDRESS) {
-		panic("kernel too large...\n");
-	}
 	app_info_ptr = (uint64 *)_app_num;
 	app_num = *app_info_ptr;
 	app_info_ptr++;
 }
 
-// Load nth user app at
-// [BASE_ADDRESS + n * MAX_APP_SIZE, BASE_ADDRESS + (n+1) * MAX_APP_SIZE)
-int load_app(int n, uint64 *info)
+pagetable_t bin_loader(uint64 start, uint64 end, struct proc *p)
 {
-	uint64 start = info[n], end = info[n + 1], length = end - start;
-	memset((void *)BASE_ADDRESS + n * MAX_APP_SIZE, 0, MAX_APP_SIZE);
-	memmove((void *)BASE_ADDRESS + n * MAX_APP_SIZE, (void *)start, length);
-	return length;
+	pagetable_t pg = uvmcreate();
+	if (mappages(pg, TRAPFRAME, PGSIZE, (uint64)p->trapframe,
+		     PTE_R | PTE_W) < 0) {
+		panic("mappages fail");
+	}
+	if (!PGALIGNED(start)) {
+		panic("user program not aligned, start = %p", start);
+	}
+	if (!PGALIGNED(end)) {
+		// Fix in ch5
+		warnf("Some kernel data maybe mapped to user, start = %p, end = %p",
+		      start, end);
+	}
+	end = PGROUNDUP(end);
+	uint64 length = end - start;
+	if (mappages(pg, BASE_ADDRESS, length, start,
+		     PTE_U | PTE_R | PTE_W | PTE_X) != 0) {
+		panic("mappages fail");
+	}
+	p->pagetable = pg;
+	uint64 ustack_bottom_vaddr = BASE_ADDRESS + length + PAGE_SIZE;
+	if (USTACK_SIZE != PAGE_SIZE) {
+		// Fix in ch5
+		panic("Unsupported");
+	}
+	mappages(pg, ustack_bottom_vaddr, USTACK_SIZE, (uint64)kalloc(),
+		 PTE_U | PTE_R | PTE_W | PTE_X);
+	p->ustack = ustack_bottom_vaddr;
+	p->trapframe->epc = BASE_ADDRESS;
+	p->trapframe->sp = p->ustack + USTACK_SIZE;
+	p->max_page = PGROUNDUP(p->ustack + USTACK_SIZE - 1) / PAGE_SIZE;
+	return pg;
 }
 
 // load all apps and init the corresponding `proc` structure.
 int run_all_app()
 {
 	for (int i = 0; i < app_num; ++i) {
 		struct proc *p = allocproc();
-		struct trapframe *trapframe = p->trapframe;
-		load_app(i, app_info_ptr);
-		uint64 entry = BASE_ADDRESS + i * MAX_APP_SIZE;
-		tracef("load app %d at %p", i, entry);
-		trapframe->epc = entry;
-		trapframe->sp = (uint64)p->ustack + USER_STACK_SIZE;
+		tracef("load app %d", i);
+		bin_loader(app_info_ptr[i], app_info_ptr[i + 1], p);
 		p->state = RUNNABLE;
 	}
 	return 0;

os/loader.h

@@ -8,9 +8,9 @@ int finished();
 void loader_init();
 int run_all_app();
 
-#define BASE_ADDRESS (0x80400000)
-#define MAX_APP_SIZE (0x20000)
-#define USER_STACK_SIZE (PAGE_SIZE)
+#define BASE_ADDRESS (0x1000)
+#define USTACK_SIZE (PAGE_SIZE)
+#define KSTACK_SIZE (PAGE_SIZE)
 #define TRAP_PAGE_SIZE (PAGE_SIZE)
 
 #endif // LOADER_H

os/main.c

@@ -14,11 +14,14 @@ void clean_bss()
 void main()
 {
 	clean_bss();
+	printf("hello world!\n");
 	proc_init();
+	kinit();
+	kvm_init();
 	loader_init();
 	trap_init();
 	timer_init();
 	run_all_app();
 	infof("start scheduler!");
 	scheduler();
-}
+}

os/proc.c

@@ -2,11 +2,11 @@
 #include "defs.h"
 #include "loader.h"
 #include "trap.h"
+#include "vm.h"
 
 struct proc pool[NPROC];
-char kstack[NPROC][PAGE_SIZE];
-__attribute__((aligned(4096))) char ustack[NPROC][PAGE_SIZE];
-__attribute__((aligned(4096))) char trapframe[NPROC][PAGE_SIZE];
+__attribute__((aligned(16))) char kstack[NPROC][PAGE_SIZE];
+__attribute__((aligned(4096))) char trapframe[NPROC][TRAP_PAGE_SIZE];
 
 extern char boot_stack_top[];
 struct proc *current_proc;
@@ -29,7 +29,6 @@ void proc_init(void)
 	for (p = pool; p < &pool[NPROC]; p++) {
 		p->state = UNUSED;
 		p->kstack = (uint64)kstack[p - pool];
-		p->ustack = (uint64)ustack[p - pool];
 		p->trapframe = (struct trapframe *)trapframe[p - pool];
 	}
 	idle.kstack = (uint64)boot_stack_top;
@@ -59,11 +58,14 @@ struct proc *allocproc(void)
 found:
 	p->pid = allocpid();
 	p->state = USED;
+	p->pagetable = 0;
+	p->ustack = 0;
+	p->max_page = 0;
 	memset(&p->context, 0, sizeof(p->context));
-	memset(p->trapframe, 0, PAGE_SIZE);
-	memset((void *)p->kstack, 0, PAGE_SIZE);
+	memset((void *)p->kstack, 0, KSTACK_SIZE);
+	memset((void *)p->trapframe, 0, TRAP_PAGE_SIZE);
 	p->context.ra = (uint64)usertrapret;
-	p->context.sp = p->kstack + PAGE_SIZE;
+	p->context.sp = p->kstack + KSTACK_SIZE;
 	return p;
 }
 
@@ -108,12 +110,18 @@ void yield(void)
 	sched();
 }
 
+void freeproc(struct proc *p)
+{
+	p->state = UNUSED;
+	// uvmfree(p->pagetable, p->max_page);
+}
+
 // Exit the current process.
 void exit(int code)
 {
 	struct proc *p = curr_proc();
 	infof("proc %d exit with %d", p->pid, code);
-	p->state = UNUSED;
+	freeproc(p);
 	finished();
 	sched();
 }

os/proc.h

@@ -1,6 +1,7 @@
 #ifndef PROC_H
 #define PROC_H
 
+#include "riscv.h"
 #include "types.h"
 
 #define NPROC (16)
@@ -31,10 +32,12 @@ enum procstate { UNUSED, USED, SLEEPING, RUNNABLE, RUNNING, ZOMBIE };
 struct proc {
 	enum procstate state; // Process state
 	int pid; // Process ID
-	uint64 ustack; // Virtual address of user stack
+	pagetable_t pagetable; // User page table
+	uint64 ustack;
 	uint64 kstack; // Virtual address of kernel stack
 	struct trapframe *trapframe; // data page for trampoline.S
 	struct context context; // swtch() here to run process
+	uint64 max_page;
 };
 
 struct proc *curr_proc();

os/riscv.h

@@ -291,6 +291,7 @@ static inline void sfence_vma()
 
 #define PGROUNDUP(sz) (((sz) + PGSIZE - 1) & ~(PGSIZE - 1))
 #define PGROUNDDOWN(a) (((a)) & ~(PGSIZE - 1))
+#define PGALIGNED(a) (((a) & (PGSIZE - 1)) == 0)
 
 #define PTE_V (1L << 0) // valid
 #define PTE_R (1L << 1)
@@ -317,6 +318,7 @@ static inline void sfence_vma()
 #define MAXVA (1L << (9 + 9 + 9 + 12 - 1))
 
 typedef uint64 pte_t;
+typedef uint64 pde_t;
 typedef uint64 *pagetable_t; // 512 PTEs
 
 #endif // RISCV_H