xv6 labs

sudo apt-get install git build-essential gdb-multiarch qemu-system-misc gcc-riscv64-linux-gnu binutils-riscv64-linux-gnu gcc-riscv64-unknown-elf

#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"

int
main(int argc, char *argv[])
{
  if (argc != 2)
    fprintf(2, "sleep: 2 args\n");

  sleep(atoi(argv[1]));
  exit(0);
}

#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"

void closeR(int *p) { close(p[0]); }
void closeW(int *p) { close(p[1]); }

int
main(int argc, char *argv[])
{
  int p2c[2], c2p[2];
  pipe(p2c), pipe(c2p);

  if (fork()) {
    int tmp = 0;
    closeR(p2c);
    closeW(c2p);
    write(p2c[1], &tmp, sizeof(int));
    read(c2p[0], &tmp, sizeof(int));
    printf("%d: received pong\n", getpid());
    closeW(p2c);
    closeR(c2p);
  } else {
    int tmp = 1;
    closeW(p2c);
    closeR(c2p);
    read(p2c[0], &tmp, sizeof(int));
    printf("%d: received ping\n", getpid());
    write(c2p[1], &tmp, sizeof(int));
    closeR(p2c);
    closeW(c2p);
  }
  exit(0);
}

#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"
#include "kernel/fs.h"

char* getFilename(char *path)
{
  char *start = path;
  int len = strlen(path);
  path += len;
  for(;path != start && *path != '/';path--) ;
  if (*path == '/')
    path++;
  return path;
}

int isSubstring(char* s1, char* s2)
{
    int M = strlen(s1);
    int N = strlen(s2);

    /* A loop to slide pat[] one by one */
    for (int i = 0; i <= N - M; i++) {
        int j;
        for (j = 0; j < M; j++)
            if (s2[i + j] != s1[j])
                break;

        if (j == M)
            return 1;
    }

    return 0;
}

int isNotDots(char* name) {
  int len = strlen(name);
  return len >= 3 || (len == 2 && name[0] != '.' && name[1] != '.') || (len == 1 && name[0] != '.');
}

void
find(char *path, char *pat, int has)
{
  char buf[512], *p;
  int fd;
  struct dirent de;
  struct stat st;

  if((fd = open(path, 0)) < 0){
    fprintf(2, "ls: cannot open %s\n", path);
    return;
  }

  if(fstat(fd, &st) < 0){
    fprintf(2, "ls: cannot stat %s\n", path);
    close(fd);
    return;
  }

  switch(st.type){
  case T_FILE:
    if (has)
      printf("%s\n", path);
    break;
  case T_DIR:
    if(strlen(path) + 1 + DIRSIZ + 1 > sizeof buf){
      printf("ls: path too long\n");
      break;
    }
    strcpy(buf, path);
    p = buf+strlen(buf);
    *p++ = '/';
    while(read(fd, &de, sizeof(de)) == sizeof(de)){
      if(de.inum == 0)
        continue;
      memmove(p, de.name, DIRSIZ);
      p[DIRSIZ] = 0;
      if(stat(buf, &st) < 0){
        printf("ls: cannot stat %s\n", buf);
        continue;
      }
      char* filename = getFilename(buf);

      if (isNotDots(filename)) {
        find(buf, pat, has || isSubstring(pat, filename));
      }

    }
    break;
  }
  close(fd);
}

int
main(int argc, char *argv[])
{
  find(argv[1], argv[2], 0);
  exit(0);
}

#include "kernel/types.h"
#include "kernel/stat.h"
#include "user/user.h"

char*
strncpy(char *s, const char *t, int n)
{
  char *os;

  os = s;
  while(n-- > 0 && (*s++ = *t++) != 0)
    ;
  while(n-- > 0)
    *s++ = 0;
  return os;
}

int
main(int argc, char *argv[])
{
  char buf[10][32];
  char tmp[32];
  char *cmd[10];
  for (int i=1;i<argc;i++)
     strncpy(buf[i-1], argv[i], strlen(argv[i]));

  while (read(0, tmp, 32) > 0) { // 虛假喚醒!!
    char *start = tmp;
    int end = argc-1;
    for(int len=strlen(tmp),i=0;i<len;i++)
      if (tmp[i] == ' ' || tmp[i] == '\n') {
        tmp[i] = 0;
        strcpy(buf[end++], start);
        start = tmp+i+1;
      }
    for (int i=0;i<end;i++)
      cmd[i] = (char*)&(buf[i]);
    if (fork())
      wait(0);
    else
      exec(buf[0], cmd);
  }

  exit(0);
}

// ...
extern uint64 sys_trace(void);
extern uint64 sys_sysinfo(void);

static uint64 (*syscalls[])(void) = {
    // ...
    [SYS_trace]   sys_trace,
    [SYS_sysinfo]   sys_sysinfo,
};

static char* syscallnames[24] = {
  "",
  "fork",
  "exit",
  "wait",
  "pipe",
  "read",
  "kill",
  "exec",
  "fstat",
  "chdir",
  "dup",
  "getpid",
  "sbrk",
  "sleep",
  "uptime",
  "open",
  "write",
  "mknod",
  "unlink",
  "link",
  "mkdir",
  "close",
  "trace",
  "sysinfo",
};

void
syscall(void)
{
  // ...
  struct proc *p = myproc();
  // ...
  if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
    p->trapframe->a0 = syscalls[num]();
    if ((1 << num) & p->tracemask)
      printf("%d: syscall %s -> %d\n", p->pid, syscallnames[num], p->trapframe->a0); // 
  } else {
    // ...
  }
}

int getAllocedProcsCount(void) {
  int ret = 0;
  for(struct proc *p = proc; p < &proc[NPROC]; p++)
    if (p->state != UNUSED)
      ret++;
  return ret;
}

int getFreeMemAmount(void) {
  int ret = 0;
  for(struct run* ptr = kmem.freelist; ptr; ptr=ptr->next)
    ret += 4096;
  return ret;
}

uint64
sys_sysinfo(void)
{
  uint64 infoAddr; // user pointer to struct stat
  if(argaddr(0, &infoAddr) < 0)
    return -1;
  struct sysinfo info = {
    .freemem = getFreeMemAmount(),
    .nproc = getAllocedProcsCount(),
  };
  struct proc* p = myproc();
  if(copyout(p->pagetable, infoAddr, (char *)&info, sizeof(info)) < 0)
    return -1;
  return 0;
} 

void            backtrace(void);

struct stk_frame
{
  void * prev_frame_plus_16;
  uint64 ret_addr;
};

static inline uint64
r_fp()
{
  uint64 x;
  asm volatile("mv %0, s0" : "=r" (x) );
  return x;
}

/*
riscv是小頭
所以addr越小，在c struct會被往上面放
stack是往下長 (addr-8)
所以寫struct要把下面的往struct的上面放 (stack倒著放)
*/

void backtrace(void) {
  struct stk_frame* now = (struct stk_frame*)(r_fp()-16);
  uint64 start = PGROUNDDOWN(now->ret_addr);
  for (struct stk_frame* now = (struct stk_frame*)(r_fp()-16); now->ret_addr > start; now=now->prev_frame_plus_16-16)
    printf("%p\n", now->ret_addr);
} 

uint64 sys_sigreturn(void) {
  struct proc * p = myproc();
  p->acc = 0;
  memmove(p->trapframe, p->trapframe2, sizeof(struct trapframe));
  return 0;
}

uint64 sys_sigalarm(void) {
  struct proc* p = myproc();
  if(argint(0, &p->cnt) < 0)
    return -1;
  if(argaddr(1, &p->cb) < 0)
    return -1;
  return 0;
}

// ...
  if(which_dev == 2) {
    if (p->cnt) {
      if (++p->acc == p->cnt) {
        memmove(p->trapframe2, p->trapframe, sizeof(struct trapframe));
        p->trapframe->epc = p->cb;
      }
    }
    yield();
  }
// ...

int inc(int i, int len) { return (i+1) % len; }

int
e1000_transmit(struct mbuf *m)
{
  acquire(&e1000_lock);
  int i = regs[E1000_TDT], ret;
  if ((tx_ring[i].status & E1000_TXD_STAT_DD) == 0) {
    printf("not ready for trasmit");
    ret = -1;
  } else {
    // free previous mbuf
    if (tx_mbufs[i])
      mbuffree(tx_mbufs[i]);
    tx_ring[i].addr = (uint64)m->head;
    tx_ring[i].length = m->len;
    tx_ring[i].cmd = E1000_TXD_CMD_EOP | E1000_TXD_CMD_RS;
    tx_mbufs[i] = m;
    regs[E1000_TDT] = inc(i, TX_RING_SIZE);
    ret = 0;
  }
  release(&e1000_lock);
  return ret;
}

// allocate mbuf for iface
static void
e1000_recv(void)
{
  for (int i = inc(regs[E1000_RDT], RX_RING_SIZE);rx_ring[i].status & E1000_RXD_STAT_DD;i = inc(regs[E1000_RDT], RX_RING_SIZE)) {
    acquire(&e1000_lock);
    struct mbuf* pkt = *(rx_mbufs+i);
    mbufput(pkt, rx_ring[i].length);
    rx_mbufs[i] = mbufalloc(0);
    // 從哪邊塞
    rx_ring[i].addr = (uint64)rx_mbufs[i]->head;
    rx_ring[i].status = 0;
    regs[E1000_RDT] = i;
    release(&e1000_lock);
    net_rx(pkt);
  } 
}

#define PA2PTE(pa) ((((uint64)pa) >> 12) << 10)
#define PTE2PA(pte) (((pte) >> 10) << 12)
#define PTE_FLAGS(pte) ((pte) & 0x3FF)

// extract the three 9-bit page table indices from a virtual address.
#define PXMASK          0x1FF // 9 bits
#define PXSHIFT(level)  (PGSHIFT+(9*(level)))
#define PX(level, va) ((((uint64) (va)) >> PXSHIFT(level)) & PXMASK)

// Return the address of the PTE in page table pagetable
// that corresponds to virtual address va.  If alloc!=0,
// create any required page-table pages.
//
// The risc-v Sv39 scheme has three levels of page-table
// pages. A page-table page contains 512 64-bit PTEs.
// A 64-bit virtual address is split into five fields:
//   39..63 -- must be zero.
//   30..38 -- 9 bits of level-2 index.
//   21..29 -- 9 bits of level-1 index.
//   12..20 -- 9 bits of level-0 index.
//    0..11 -- 12 bits of byte offset within the page.
pte_t *
walk(pagetable_t pagetable, uint64 va, int alloc)
{
  if(va >= MAXVA)
    panic("walk");

  for(int level = 2; level > 0; level--) {
    pte_t *pte = &pagetable[PX(level, va)];
    if(*pte & PTE_V) {
      pagetable = (pagetable_t)PTE2PA(*pte);
    } else {
      if(!alloc || (pagetable = (pde_t*)kalloc()) == 0)
        return 0;
      memset(pagetable, 0, PGSIZE);
      *pte = PA2PTE(pagetable) | PTE_V;
    }
  }
  return &pagetable[PX(0, va)];
}

void vmprint_dfs(pagetable_t pagetable, int dep) {
  if (*pagetable < MAXVA)
    for(int i = 0; i < 512; i++){
      pte_t pte = pagetable[i];
      if((pte & PTE_V) && pte < MAXVA){
        uint64 child = PTE2PA(pte);
        for (int j=0;j<dep;j++)
          printf(".. ");
        printf("..%d: ptr %p pa %p\n", i, pte, child);
        vmprint_dfs((pagetable_t)child, dep+1);
      }
    }
}

void vmprint(pagetable_t pagetable) {
  printf("page table %p\n", pagetable);
  vmprint_dfs(pagetable, 0);
}

void kpgtinit(pagetable_t t) {
  memset(t, 0, PGSIZE);

  // uart registers
  if (mappages(t, UART0, PGSIZE, UART0, PTE_R | PTE_W) < 0)
    panic("kpgtinit: uart0\n");

  // virtio mmio disk interface
  if (mappages(t, VIRTIO0, PGSIZE, VIRTIO0, PTE_R | PTE_W) < 0)
    panic("kpgtinit: virtio0\n");

  // CLINT
  if (mappages(t, CLINT, 0x10000, CLINT, PTE_R | PTE_W) < 0)
    panic("kpgtinit: clint\n");

  // PLIC
  if (mappages(t, PLIC, 0x400000, PLIC, PTE_R | PTE_W) < 0)
    panic("kpgtinit: plic\n");

  // map kernel text executable and read-only.
  if (mappages(t, KERNBASE, (uint64)etext-KERNBASE, KERNBASE, PTE_R | PTE_X) < 0)
    panic("kpgtinit: kernel base\n");

  // map kernel data and the physical RAM we'll make use of.
  if (mappages(t, (uint64)etext, PHYSTOP-(uint64)etext, (uint64)etext, PTE_R | PTE_W) < 0)
    panic("kpgtinit: kernel data\n");

  // map the trampoline for trap entry/exit to
  // the highest virtual address in the kernel.
  if (mappages(t, TRAMPOLINE, PGSIZE, (uint64)trampoline, PTE_R | PTE_X) < 0)
    panic("kpgtinit: trampoline\n");
}
void switchPGT(pagetable_t t) {
  w_satp(MAKE_SATP(t));
  sfence_vma();
}

static struct proc*
allocproc(void)
{
  // ...

  p->kpagetable = (pagetable_t) kalloc();
  kpgtinit(p->kpagetable);

  char *pa = kalloc();
  if(pa == 0)
    panic("kalloc");
  uint64 va = KSTACK(0);
  mappages(p->kpagetable, va, PGSIZE, (uint64)pa, PTE_R | PTE_W);
  p->kstack = va;

  // ...
}

void
includeInto(pagetable_t pagetable, pagetable_t kpagetable, uint64 oldsz, uint64 newsz)
{
  pte_t *pte_from, *pte_to;
  uint64 a, pa;
  uint flags;

  if (newsz < oldsz)
    return;

  oldsz = PGROUNDUP(oldsz);
  for (a = oldsz; a < newsz; a += PGSIZE)
  {
    if ((pte_from = walk(pagetable, a, 0)) == 0)
      panic("includeInto: pte should exist");
    if ((pte_to = walk(kpagetable, a, 1)) == 0)
      panic("includeInto: walk fails");
    pa = PTE2PA(*pte_from);
    flags = (PTE_FLAGS(*pte_from) & (~PTE_U));
    *pte_to = PA2PTE(pa) | flags;
  }
}

void
userinit(void)
{
  // ...
  includeInto(p->pagetable, p->kpagetable, 0, p->sz);
  // prepare for the very first "return" from kernel to user.
  p->trapframe->epc = 0;      // user program counter
  // ...
}
// Grow or shrink user memory by n bytes.
// Return 0 on success, -1 on failure.
int
growproc(int n)
{
  // ...
  if(n > 0){
    if (PGROUNDUP(sz + n) >= PLIC)
      return -1;
    // ...
    includeInto(p->pagetable, p->kpagetable, sz-n, sz);
  } else if(n < 0){
    sz = uvmdealloc(p->pagetable, sz, sz + n);
  }
  p->sz = sz;
  return 0;
}
// Create a new process, copying the parent.
// Sets up child kernel stack to return as if from fork() system call.
int
fork(void)
{
    // ...
  includeInto(np->pagetable, np->kpagetable, 0, np->sz);
  safestrcpy(np->name, p->name, sizeof(p->name));

  pid = np->pid;
  np->state = RUNNABLE;
  release(&np->lock);
  return pid;
}

void
freewalk_keepleaf(pagetable_t pagetable)
{
  // there are 2^9 = 512 PTEs in a page table.
  for(int i = 0; i < 512; i++){
    pte_t pte = pagetable[i];
    if((pte & PTE_V)) {
      pagetable[i] = 0;
      if((pte & (PTE_R|PTE_W|PTE_X)) == 0){
        // this PTE points to a lower-level page table.
        uint64 child = PTE2PA(pte);
        freewalk_keepleaf((pagetable_t)child);
      }
    }

  }
  kfree((void*)pagetable);
}

void 
proc_freekpt(pagetable_t pagetable)
{
  // there are 2^9 = 512 PTEs in a page table.
  for(int i = 0; i < 512; i++){
    pte_t pte = pagetable[i];
    if((pte & PTE_V)){
      pagetable[i] = 0;
      if ((pte & (PTE_R|PTE_W|PTE_X)) == 0)
      {
        uint64 child = PTE2PA(pte);
        proc_freekpt((pagetable_t)child);
      }
    } else if(pte & PTE_V){
      panic("proc free kpt: leaf");
    }
  }
  kfree((void*)pagetable);
}

static void
freeproc(struct proc *p)
{
  // ...
  if(p->pagetable)
    proc_freepagetable(p->pagetable, p->sz);
  if (p->kstack)
  {
    uvmunmap(p->kpagetable, p->kstack, 1,1);
    p->kstack = 0;
  }
  if(p->kpagetable)
    freewalk_keepleaf(p->kpagetable);
  p->kpagetable = 0;
  // ...
}

uint64
sys_sbrk(void)
{
  int addr;
  int n;
  if(argint(0, &n) < 0)
    return -1;
  addr = myproc()->sz;
   if(n < 0)
     growproc(n);
   else
     myproc()->sz += n;
  return addr; // !!!
}

int do_lazy(uint64 addr) {
  struct proc* p = myproc();
  int stkOverFlow = (addr < p->trapframe->sp);
  // page-faults on a virtual memory address higher than any allocated with sbrk()
  // this should be >= not > !!!
  int addrOutOfBound = (addr >= p->sz);
  void *mem;
  if (stkOverFlow)
    ;//printf("lazy: stack overflow\n");
  else if(addrOutOfBound)
    ;//printf("lazy: addr over of bound\n");
  else if((mem = kalloc()) == 0)
    ;//printf("out of pa\n");
  else {
    memset(mem, 0, PGSIZE);
    if (mappages(p->pagetable, PGROUNDDOWN(addr), PGSIZE, (uint64)mem, PTE_W|PTE_X|PTE_R|PTE_U) < 0)// ???
      kfree(mem);
    else 
      return 0;
  }
  return -1;
}

void
usertrap(void)
{
  // ...
  if(r_scause() == 8){
    // ...
    intr_on();

    syscall();
  } else if(r_scause() == 13 || r_scause() == 15) {
     if (do_lazy(r_stval()) < 0)
      p->killed = 1;
  } else if((which_dev = devintr()) != 0){
    // ok
  }
  // ...
}

struct __refcnt{
  struct spinlock lock;
  uint counter[(PHYSTOP - KERNBASE) / PGSIZE];
};

struct __refcnt refcnt;

void refcnt_lock() {
  acquire(&refcnt.lock);
}

void refcnt_unlock() {
  release(&refcnt.lock);
}

void refcnt_create() {
  initlock(&refcnt.lock, "refcnt");
  refcnt_lock();
  for(int i=0,goal=(PHYSTOP - KERNBASE) / PGSIZE;i<goal;i++)
    refcnt.counter[i] = 0;
  refcnt_unlock();
}

inline
uint64
refcnt_index(uint64 pa){
  return (pa - KERNBASE) / PGSIZE;
}

void refcnt_set(uint64 pa, int n) {
  refcnt.counter[refcnt_index(pa)] = n;
}

inline
uint
refcnt_get(uint64 pa){
  return refcnt.counter[refcnt_index(pa)];
}

void
refcnt_incr(uint64 pa){
  refcnt.counter[refcnt_index(pa)]++;
}

void
refcnt_desc(uint64 pa){
  if (refcnt.counter[refcnt_index(pa)] > 0)
    refcnt.counter[refcnt_index(pa)]--;
  else
    panic("wtf");
}

int page_fork(uint64 va) {
  int ret;
  pagetable_t pgt = myproc()->pagetable;
  va = PGROUNDDOWN(va);
  pte_t * pte = walk(pgt, va, 0);
  uint64 pa = PTE2PA(*pte);
  uint flags = PTE_FLAGS(*pte);
  if ((*pte) & PTE_COW) {
    refcnt_lock(); // MUST BE DONE TOGETHER!!
    if (refcnt_get(pa) > 1) {
      void *mem = kalloc_cow();
      if (mem != 0) {
        memmove(mem, (char*)pa, PGSIZE);
        if(mappages(pgt, va, PGSIZE, (uint64)mem, (flags & (~PTE_COW)) | PTE_W) != 0)
          ret = -1, kfree(mem);
        else
          ret = 0, refcnt_desc(pa);
      } else
        ret = -3;
    } else
      ret = 0, *pte = (*pte & ~PTE_COW) | PTE_W;
    refcnt_unlock();
  } else 
    ret = -2;
  return ret;
}

void
kfree(void *pa)
{
  struct run *r;

  refcnt_lock(); //premise: counter == 0  <=> this page is in freelist
  if (refcnt_get((uint64)pa) <= 1) {
    if(((uint64)pa % PGSIZE) != 0 || (char*)pa < end || (uint64)pa >= PHYSTOP)
        panic("kfree");

    // Fill with junk to catch dangling refs.
    memset(pa, 1, PGSIZE);
    refcnt_set((uint64)pa, 0);
    r = (struct run*)pa;

    acquire(&kmem.lock);
    r->next = kmem.freelist;
    kmem.freelist = r;
    release(&kmem.lock);
  } else
    refcnt_desc((uint64)pa);
  refcnt_unlock();
}

int
uvmcopy(pagetable_t old, pagetable_t new, uint64 sz)
{
  // 從copy變成map
  // ...

  for(i = 0; i < sz; i += PGSIZE){
    // ...
    *pte = ((*pte) & (~PTE_W)) | PTE_COW;
    if(mappages(new, i, PGSIZE, (uint64)pa, (flags & (~PTE_W)) | PTE_COW) != 0)
      goto err;
    else {
      refcnt_lock();
      refcnt_incr(pa);
      refcnt_unlock();
    }
  }
  return 0;
 err:
  uvmunmap(new, 0, i / PGSIZE, 1);
  return -1;
}

int
copyout(pagetable_t pagetable, uint64 dstva, char *src, uint64 len)
{
  uint64 n, va0, pa0;

  while(len > 0){
    // ...
    // 如果都指向同一個page要分開
    pte_t* pte = walk(pagetable, va0, 0);
    if (pte && (*pte & PTE_COW))
      if (page_fork(va0) != 0)
        return -1;
    // ...
  }
}

void
usertrap(void) {
    // ...
  } else if((r_scause() == 15)) {
    if (page_fork(r_stval()))
      p->killed = 1;
  } else {
    // ...
}

struct entry {
  uint64 va_end;
  int size;
  int prot;
  int flag;
  struct file* f;
};

#define VMA_SIZE 16
#define VMA_BASE (TRAPFRAME - PGSIZE)

struct proc {
    // ...
    struct entry vma[VMA_SIZE];
    uint64 vma_end;
};

struct entry* allocvma() {
  struct proc *p = myproc();
  struct entry* ret = 0;
  for (int i = 0;i<VMA_SIZE;i++) {
    if (p->vma[i].size == 0) {
      ret = &(p->vma[i]);
      break;
    }
  }
  return ret;
}

struct entry* getvma(uint64 addr) {
  int i;
  struct proc *p = myproc();
  for (i = 0;i<VMA_SIZE;i++)
    if (p->vma[i].size > 0 && p->vma[i].va_end > addr && addr >= p->vma[i].va_end-p->vma[i].size)
      break;
  return i < VMA_SIZE ? &(p->vma[i]) : 0;
}

uint64
sys_mmap(void)
{
  struct file* f;
  uint64 ret = -1;
  int size, prot, flags, fd;
  struct proc *p = myproc();
  int goodargs = (argint(1, &size) < 0 || argint(2, &prot) < 0 || argint(3, &flags) < 0 || argfd(4, &fd, &f) < 0);
  if(goodargs || (!f->writable && (prot & PROT_WRITE) && (flags & MAP_SHARED)))
    return ret;
  acquire(&p->lock);
  struct entry *vma = allocvma();
  if (vma) {
    int pte_prot = 0;
    if (prot & PROT_READ)
      pte_prot |= PTE_R;
    if (prot & PROT_WRITE)
      pte_prot |= PTE_W;
    filedup(f);
    vma->va_end = p->vma_end; // start在小 end在大 mmap回傳的addr是小的!!
    ret = vma->va_end-size;
    vma->size = size;
    vma->f = f;
    vma->prot = pte_prot;
    vma->flag = flags;
    p->vma_end -= size;
  }
  release(&p->lock);
  return ret;
}

uint64 do_mummap(uint64 addr, int len) {
  struct proc* p = myproc();
  struct entry *vma = getvma(addr);
  if (!vma || addr + len > vma->va_end) {
    return -1;
  }
  //printf("??: %d start:%p va:%p va_end:%p end:%p\n", vma->size, vma->va_end-vma->size, addr, addr+len, vma->va_end);
  for (uint64 va=addr,end=addr+len;va < end;va+=PGSIZE) {
      if (walkaddr(p->pagetable, va)) {
        if (vma->flag & MAP_SHARED)
          filewrite(vma->f, va, PGSIZE);
        uvmunmap(p->pagetable, va, 1, 1);
      }   
  }

  if (addr == vma->va_end-vma->size && addr+len == vma->va_end) {
    vma->size = 0;
    //fileclose(vma->f);
    vma->f->ref--;
  } else {
    vma->size -= len;
    if (addr+len == vma->va_end)
      vma->va_end -= len;
  }

  return 0;
}

uint64
sys_munmap(void)
{
  uint64 addr;
  int len;

  if (argaddr(0, &addr) < 0 || argint(1, &len) < 0)
    return -1;
  return do_mummap(addr, len);
}

int do_mmap(uint64 addr) {
  struct proc* p = myproc();
  uint64 base = PGROUNDDOWN(addr);
  void *mem;
  if((mem = kalloc()) == 0)
    printf("out of pa\n");
  else {
    struct entry* vma = getvma(addr);
    if (vma) {
      memset(mem, 0, PGSIZE);
      if (mappages(p->pagetable, base, PGSIZE, (uint64)mem, vma->prot|PTE_U|PTE_X) < 0)
        kfree(mem), printf("map fail\n");
      else {
        ilock(vma->f->ip);
        int offset = base - (vma->va_end-vma->size);
        readi(vma->f->ip, 1, base, offset, PGSIZE);
        iunlock(vma->f->ip);
        return 0;
      }
    } else {
      //printf("vma no found\n");
      kfree(mem);
    }
  }
  return -1;
}

void
usertrap(void) {
    // ...
    } else if(r_scause() == 13 || r_scause() == 15) {
        if (do_mmap(r_stval()) < 0)
            p->killed = 1;
    } else {
    // ...
}

#include <stdio.h>
#include <unistd.h>
#include <sys/mman.h>
#include <string.h>
#include <fcntl.h>

int main(int argc, char **argv)
{
    int fd;
    unsigned long *addr;

    fd = open("/dev/mem", O_RDWR);

    // 建立一個分頁 P1 映射到保留記憶體
    addr = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x34000000);

    // 修改 P1 的内容
    *addr = 0x1122334455667788;
    
    printf("address at: %p   content is: 0x%lx\n", addr, addr[0]);

    // 等待分頁交換
    getchar();
    
    printf("address at: %p   content is: 0x%lx\n", addr, addr[0]);

    close(fd);
    munmap(addr, 4096);
    return 1;
}