==========================================================================
Copyright License
==========================================================================
The PKE software is:

Copyright (c) 2021, Zhiyuan Shao (zyshao@hust.edu.cn), 
                    Yi Gui (gy163email@163.com), 
                    Yan Jiao (773709579@qq.com),
                    Ziming Yuan (1223962053@qq.com),
                    Yixin Song (yixinsong@hust.edu.cn),
                    Boyang Li (liboyang_hust@163.com),
                   Huazhong University of Science and Technology

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

* The above copyright notice and this permission notice shall be
  included in all copies or substantial portions of the Software.

* Neither the name of the Huazhong University of Science and Technology
  nor the names of its contributors may be used to endorse or promote 
  products derived from this software without specific prior written 
  permission.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

$ spike ./obj/riscv-pke ./obj/app_helloworld

 10 // the maximum memory space that PKE is allowed to manage
 11 #define PKE_MAX_ALLOWABLE_RAM 128 * 1024 * 1024
 12
 13 // the ending physical address that PKE observes
 14 #define PHYS_TOP (DRAM_BASE + PKE_MAX_ALLOWABLE_RAM)

 62 void pmm_init() {
 63   // start of kernel program segment
 64   uint64 g_kernel_start = KERN_BASE;
 65   uint64 g_kernel_end = (uint64)&_end;
 66
 67   uint64 pke_kernel_size = g_kernel_end - g_kernel_start;
 68   sprint("PKE kernel start 0x%lx, PKE kernel end: 0x%lx, PKE kernel size: 0x%lx .\n",
 69     g_kernel_start, g_kernel_end, pke_kernel_size);
 70
 71   // free memory starts from the end of PKE kernel and must be page-aligined
 72   free_mem_start_addr = ROUNDUP(g_kernel_end , PGSIZE);
 73
 74   // recompute g_mem_size to limit the physical memory space that PKE kernel
 75   // needs to manage
 76   g_mem_size = MIN(PKE_MAX_ALLOWABLE_RAM, g_mem_size);
 77   if( g_mem_size < pke_kernel_size )
 78     panic( "Error when recomputing physical memory size (g_mem_size).\n" );
 79
 80   free_mem_end_addr = g_mem_size + DRAM_BASE;
 81   sprint("free physical memory address: [0x%lx, 0x%lx] \n", free_mem_start_addr,
 82     free_mem_end_addr - 1);
 83
 84   sprint("kernel memory manager is initializing ...\n");
 85   // create the list of free pages
 86   create_freepage_list(free_mem_start_addr, free_mem_end_addr);
 87 }

119 void kern_vm_init(void) {
120   pagetable_t t_page_dir;
121
122   // allocate a page (t_page_dir) to be the page directory for kernel
123   t_page_dir = (pagetable_t)alloc_page();
124   memset(t_page_dir, 0, PGSIZE);
125
126   // map virtual address [KERN_BASE, _etext] to physical address [DRAM_BASE, DRAM_BASE+(_etext - KERN_BASE)],
127   // to maintain (direct) text section kernel address mapping.
128   kern_vm_map(t_page_dir, KERN_BASE, DRAM_BASE, (uint64)_etext - KERN_BASE,
129          prot_to_type(PROT_READ | PROT_EXEC, 0));
130
131   sprint("KERN_BASE 0x%lx\n", lookup_pa(t_page_dir, KERN_BASE));
132
133   // also (direct) map remaining address space, to make them accessable from kernel.
134   // this is important when kernel needs to access the memory content of user's app
135   // without copying pages between kernel and user spaces.
136   kern_vm_map(t_page_dir, (uint64)_etext, (uint64)_etext, PHYS_TOP - (uint64)_etext,
137          prot_to_type(PROT_READ | PROT_WRITE, 0));
138
139   sprint("physical address of _etext is: 0x%lx\n", lookup_pa(t_page_dir, (uint64)_etext));
140
141   g_kernel_pagetable = t_page_dir;
142 }

// 切换到lab2_1_pagetable分支
$ git checkout lab2_1_pagetable
// 构造内核和应用
$ make
// 显示应用程序中将被加载的程序段
$ riscv64-unknown-elf-readelf -l ./obj/app_helloworld_no_lds

Elf file type is EXEC (Executable file)
Entry point 0x100f6
There is 1 program header, starting at offset 64

Program Headers:
  Type           Offset             VirtAddr           PhysAddr
                 FileSiz            MemSiz              Flags  Align
  LOAD           0x0000000000000000 0x0000000000010000 0x0000000000010000
                 0x0000000000000360 0x0000000000000360  R E    0x1000

 Section to Segment mapping:
  Segment Sections...
   00     .text .rodata

 37 void load_user_program(process *proc) {
 38   sprint("User application is loading.\n");
 39   proc->trapframe = (trapframe *)alloc_page();  //trapframe
 40   memset(proc->trapframe, 0, sizeof(trapframe));
 41
 42   //user pagetable
 43   proc->pagetable = (pagetable_t)alloc_page();
 44   memset((void *)proc->pagetable, 0, PGSIZE);
 45
 46   proc->kstack = (uint64)alloc_page() + PGSIZE;   //user kernel stack top
 47   uint64 user_stack = (uint64)alloc_page();       //phisical address of user stack bottom
 48   proc->trapframe->regs.sp = USER_STACK_TOP;  //virtual address of user stack top
 49
 50   sprint("user frame 0x%lx, user stack 0x%lx, user kstack 0x%lx \n", proc->trapframe,
 51          proc->trapframe->regs.sp, proc->kstack);
 52
 53   load_bincode_from_host_elf(proc);
 54
 55   // map user stack in userspace
 56   user_vm_map((pagetable_t)proc->pagetable, USER_STACK_TOP - PGSIZE, PGSIZE, user_stack,
 57          prot_to_type(PROT_WRITE | PROT_READ, 1));
 58
 59   // map trapframe in user space (direct mapping as in kernel space).
 60   user_vm_map((pagetable_t)proc->pagetable, (uint64)proc->trapframe, PGSIZE, (uint64)proc->trapframe,
 61          prot_to_type(PROT_WRITE | PROT_READ, 0));
 62
 63   // map S-mode trap vector section in user space (direct mapping as in kernel space)
 64   // we assume that the size of usertrap.S is smaller than a page.
 65   user_vm_map((pagetable_t)proc->pagetable, (uint64)trap_sec_start, PGSIZE, (uint64)trap_sec_start,
 66          prot_to_type(PROT_READ | PROT_EXEC, 0));
 67 }

  1 /*
  2  * Below is the given application for lab2_1.
  3  * This app runs in its own address space, in contrast with in direct mapping.
  4  */
  5
  6 #include "user_lib.h"
  7 #include "util/types.h"
  8
  9 int main(void) {
 10   printu("Hello world!\n");
 11   exit(0);
 12 }

//切换到lab2_1
$ git checkout lab2_1_pagetable

//继承lab1_3以及之前的答案
$ git merge lab1_3_irq -m "continue to work on lab2_1"

//重新构造
$ make clean; make

//运行构造结果
$ spike ./obj/riscv-pke ./obj/app_helloworld_no_lds
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 2048 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x000000008000e000, PKE kernel size: 0x000000000000e000 .
free physical memory address: [0x000000008000e000, 0x0000000087ffffff]
kernel memory manager is initializing ...
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080004000
kernel page table is on
User application is loading.
user frame 0x0000000087fbc000, user stack 0x000000007ffff000, user kstack 0x0000000087fbb000
Application: ./obj/app_helloworld_no_lds
Application program entry point (virtual address): 0x00000000000100f6
Switching to user mode...
You have to implement user_va_to_pa (convert user va to pa) to print messages in lab2_1.

System is shutting down with exit code -1.

$ spike ./obj/riscv-pke ./obj/app_helloworld_no_lds
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 2048 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x000000008000e000, PKE kernel size: 0x000000000000e000 .
free physical memory address: [0x000000008000e000, 0x0000000087ffffff]
kernel memory manager is initializing ...
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080004000
kernel page table is on
User application is loading.
user frame 0x0000000087fbc000, user stack 0x000000007ffff000, user kstack 0x0000000087fbb000
Application: ./obj/app_helloworld_no_lds
Application program entry point (virtual address): 0x00000000000100f6
Switching to user mode...
Hello world!
User exit with code:0.
System is shutting down with exit code 0.

 21 ssize_t sys_user_print(const char* buf, size_t n) {
 22   //buf is an address in user space on user stack,
 23   //so we have to transfer it into phisical address (kernel is running in direct mapping).
 24   assert( current );
 25   char* pa = (char*)user_va_to_pa((pagetable_t)(current->pagetable), (void*)buf);
 26   sprint(pa);
 27   return 0;
 28 }

150 void *user_va_to_pa(pagetable_t page_dir, void *va) {
151   // TODO (lab2_1): implement user_va_to_pa to convert a given user virtual address "va"
152   // to its corresponding physical address, i.e., "pa". To do it, we need to walk
153   // through the page table, starting from its directory "page_dir", to locate the PTE
154   // that maps "va". If found, returns the "pa" by using:
155   // pa = PYHS_ADDR(PTE) + (va - va & (1<<PGSHIFT -1))
156   // Here, PYHS_ADDR() means retrieving the starting address (4KB aligned), and
157   // (va - va & (1<<PGSHIFT -1)) means computing the offset of "va" in its page.
158   // Also, it is possible that "va" is not mapped at all. in such case, we can find
159   // invalid PTE, and should return NULL.
160   panic( "You have to implement user_va_to_pa (convert user va to pa) to print messages in lab2_1.\n" );
161
162 }

//将地址转换为uint类型
  uint va0 = (uint64)va;
  //获取虚拟地址对应的PTE页表项
  pte_t * PTE = page_walk(page_dir, va0, 0);
  uint64 pa = 0;
  //如果返回的PTE不为空，计算pa物理地址
  if(PTE)
  {
    //PTE2PA(*PTE)取44位PPN，va0 & ((1 << PGSHIFT) - 1)计算偏移地址
    pa = PTE2PA(*PTE) + (va0 & ((1 << PGSHIFT) - 1));
  }
  return (void*)pa;

$ git commit -a -m "my work on lab2_1 is done."

  1 /*
  2  * Below is the given application for lab2_2.
  3  */
  4
  5 #include "user_lib.h"
  6 #include "util/types.h"
  7
  8 struct my_structure {
  9   char c;
 10   int n;
 11 };
 12
 13 int main(void) {
 14   struct my_structure* s = (struct my_structure*)naive_malloc();
 15   s->c = 'a';
 16   s->n = 1;
 17
 18   printu("s: %lx, {%c %d}\n", s, s->c, s->n);
 19
 20   naive_free(s);
 21
 22   exit(0);
 23 }

//切换到lab2_2
$ git checkout lab2_2_allocatepage

//继承lab2_1以及之前的答案
$ git merge lab2_1_pagetable -m "continue to work on lab2_2"

//重新构造
$ make clean; make

//运行构造结果
$ spike ./obj/riscv-pke ./obj/app_naive_malloc
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 2048 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x000000008000e000, PKE kernel size: 0x000000000000e000 .
free physical memory address: [0x000000008000e000, 0x0000000087ffffff]
kernel memory manager is initializing ...
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080004000
kernel page table is on
User application is loading.
user frame 0x0000000087fbc000, user stack 0x000000007ffff000, user kstack 0x0000000087fbb000
Application: ./obj/app_naive_malloc
Application program entry point (virtual address): 0x0000000000010078
Switching to user mode...
s: 0000000000400000, {a 1}
You have to implement user_vm_unmap to free pages using naive_free in lab2_2.

System is shutting down with exit code -1.

$ spike ./obj/riscv-pke ./obj/app_naive_malloc
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 2048 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x000000008000e000, PKE kernel size: 0x000000000000e000 .
free physical memory address: [0x000000008000e000, 0x0000000087ffffff]
kernel memory manager is initializing ...
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080004000
kernel page table is on
User application is loading.
user frame 0x0000000087fbc000, user stack 0x000000007ffff000, user kstack 0x0000000087fbb000
Application: ./obj/app_naive_malloc
Application program entry point (virtual address): 0x0000000000010078
Switching to user mode...
s: 0000000000400000, {a 1}
User exit with code:0.
System is shutting down with exit code 0.

 43 uint64 sys_user_allocate_page() {
 44   void* pa = alloc_page();
 45   uint64 va = g_ufree_page;
 46   g_ufree_page += PGSIZE;
 47   user_vm_map((pagetable_t)current->pagetable, va, PGSIZE, (uint64)pa,
 48          prot_to_type(PROT_WRITE | PROT_READ, 1));
 49
 50   return va;
 51 }

 27 // start virtual address of our simple heap.
 28 uint64 g_ufree_page = USER_FREE_ADDRESS_START;

 17 // simple heap bottom, virtual address starts from 4MB
 18 #define USER_FREE_ADDRESS_START 0x00000000 + PGSIZE * 1024

if(free)
  {
    pte_t * PTE = page_walk(page_dir, va, 0);
    if(PTE){
      free_page((void*)user_va_to_pa(page_dir, (void*)va));
      *PTE = *PTE & (~PTE_V);//let valid to be 0
    }
    
  }

$ git commit -a -m "my work on lab2_2 is done."

  1 /*
  2  * The application of lab2_3.
  3  */
  4
  5 #include "user_lib.h"
  6 #include "util/types.h"
  7
  8 //
  9 // compute the summation of an arithmetic sequence. for a given "n", compute
 10 // result = n + (n-1) + (n-2) + ... + 0
 11 // sum_sequence() calls itself recursively till 0. The recursive call, however,
 12 // may consume more memory (from stack) than a physical 4KB page, leading to a page fault.
 13 // PKE kernel needs to improved to handle such page fault by expanding the stack.
 14 //
 15 uint64 sum_sequence(uint64 n) {
 16   if (n == 0)
 17     return 0;
 18   else
 19     return sum_sequence( n-1 ) + n;
 20 }
 21
 22 int main(void) {
 23   // we need a large enough "n" to trigger pagefaults in the user stack
 24   uint64 n = 1000;
 25
 26   printu("Summation of an arithmetic sequence from 0 to %ld is: %ld \n", n, sum_sequence(1000) );
 27   exit(0);
 28 }

//切换到lab2_3
$ git checkout lab2_3_pagefault

//继承lab2_2以及之前的答案
$ git merge lab2_2_allocatepage -m "continue to work on lab2_3"

//重新构造
$ make clean; make

//运行构造结果
$ spike ./obj/riscv-pke ./obj/app_sum_sequence
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 2048 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x000000008000e000, PKE kernel size: 0x000000000000e000 .
free physical memory address: [0x000000008000e000, 0x0000000087ffffff]
kernel memory manager is initializing ...
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080004000
kernel page table is on
User application is loading.
user frame 0x0000000087fbc000, user stack 0x000000007ffff000, user kstack 0x0000000087fbb000
Application: ./obj/app_sum_sequence
Application program entry point (virtual address): 0x0000000000010096
Switching to user mode...
handle_page_fault: 000000007fffdff8
You need to implement the operations that actually handle the page fault in lab2_3.

System is shutting down with exit code -1.

$ spike ./obj/riscv-pke ./obj/app_sum_sequence
In m_start, hartid:0
HTIF is available!
(Emulated) memory size: 2048 MB
Enter supervisor mode...
PKE kernel start 0x0000000080000000, PKE kernel end: 0x000000008000e000, PKE kernel size: 0x000000000000e000 .
free physical memory address: [0x000000008000e000, 0x0000000087ffffff]
kernel memory manager is initializing ...
KERN_BASE 0x0000000080000000
physical address of _etext is: 0x0000000080004000
kernel page table is on
User application is loading.
user frame 0x0000000087fbc000, user stack 0x000000007ffff000, user kstack 0x0000000087fbb000
Application: ./obj/app_sum_sequence
Application program entry point (virtual address): 0x0000000000010096
Switching to user mode...
handle_page_fault: 000000007fffdff8
handle_page_fault: 000000007fffcff8
handle_page_fault: 000000007fffbff8
Summation of an arithmetic sequence from 0 to 1000 is: 500500
User exit with code:0.
System is shutting down with exit code 0.

 51 static void delegate_traps() {
 52   if (!supports_extension('S')) {
 53     // confirm that our processor supports supervisor mode. abort if not.
 54     sprint("s mode is not supported.\n");
 55     return;
 56   }
 57
 58   uintptr_t interrupts = MIP_SSIP | MIP_STIP | MIP_SEIP;
 59   uintptr_t exceptions = (1U << CAUSE_MISALIGNED_FETCH) | (1U << CAUSE_FETCH_PAGE_FAULT) |
 60                          (1U << CAUSE_BREAKPOINT) | (1U << CAUSE_LOAD_PAGE_FAULT) |
 61                          (1U << CAUSE_STORE_PAGE_FAULT) | (1U << CAUSE_USER_ECALL);
 62
 63   write_csr(mideleg, interrupts);
 64   write_csr(medeleg, exceptions);
 65   assert(read_csr(mideleg) == interrupts);
 66   assert(read_csr(medeleg) == exceptions);
 67 }

 49 void handle_user_page_fault(uint64 mcause, uint64 sepc, uint64 stval) {
 50   sprint("handle_page_fault: %lx\n", stval);
 51   switch (mcause) {
 52     case CAUSE_STORE_PAGE_FAULT:
 53       // TODO (lab2_3): implement the operations that solve the page fault to
 54       // dynamically increase application stack.
 55       // hint: first allocate a new physical page, and then, maps the new page to the
 56       // virtual address that causes the page fault.
 57       panic( "You need to implement the operations that actually handle the page fault in lab2_3.\n" );
 58
 59       break;
 60     default:
 61       sprint("unknown page fault.\n");
 62       break;
 63   }
 64 }

if(stval>USER_STACK_TOP&&(USER_STACK_TOP-stval)>=20*(STACK_SIZE)){
        user_vm_map((pagetable_t)current->pagetable, stval - stval%PGSIZE, PGSIZE, (uint64)alloc_page(), prot_to_type(PROT_WRITE | PROT_READ, 1));
      }

$ git commit -a -m "my work on lab2_3 is done."