text: #include "types.h"
  #include "param.h"
  #include "memlayout.h"
  #include "riscv.h"
  #include "spinlock.h"
  #include "proc.h"
  #include "syscall.h"
  #include "defs.h"
  
  // movequeue from proc.c
  extern void movequeue(struct proc *obj, int priority, int opt);
  
  // Fetch the uint64 at addr from the current process.
  int fetchaddr(uint64 addr, uint64 *ip)
  {
    struct proc *p = myproc();
    if (addr >= p->sz || addr + sizeof(uint64) > p->sz)
      return -1;
    if (copyin(p->pagetable, (char *)ip, addr, sizeof(*ip)) != 0)
      return -1;
    return 0;
  }
  
  // Fetch the nul-terminated string at addr from the current process.
  // Returns length of string, not including nul, or -1 for error.
  int fetchstr(uint64 addr, char *buf, int max)
  {
    struct proc *p = myproc();
    int err = copyinstr(p->pagetable, buf, addr, max);
    if (err < 0)
      return err;
    return strlen(buf);
  }
  
  static uint64
  argraw(int n)
  {
    struct proc *p = myproc();
    switch (n)
    {
    case 0:
      return p->trapframe->a0;
    case 1:
      return p->trapframe->a1;
    case 2:
      return p->trapframe->a2;
    case 3:
      return p->trapframe->a3;
    case 4:
      return p->trapframe->a4;
    case 5:
      return p->trapframe->a5;
    }
    panic("argraw");
    return -1;
  }
  
  // Fetch the nth 32-bit system call argument.
  int argint(int n, int *ip)
  {
    *ip = argraw(n);
    return 0;
  }
  
  // Retrieve an argument as a pointer.
  // Doesn't check for legality, since
  // copyin/copyout will do that.
  int argaddr(int n, uint64 *ip)
  {
    *ip = argraw(n);
    return 0;
  }
  
  // Fetch the nth word-sized system call argument as a null-terminated string.
  // Copies into buf, at most max.
  // Returns string length if OK (including nul), -1 if error.
  int argstr(int n, char *buf, int max)
  {
    uint64 addr;
    if (argaddr(n, &addr) < 0)
      return -1;
    return fetchstr(addr, buf, max);
  }
  
  extern uint64 sys_chdir(void);
  extern uint64 sys_close(void);
  extern uint64 sys_dup(void);
  extern uint64 sys_exec(void);
  extern uint64 sys_exit(void);
  extern uint64 sys_fork(void);
  extern uint64 sys_fstat(void);
  extern uint64 sys_getpid(void);
  extern uint64 sys_kill(void);
  extern uint64 sys_link(void);
  extern uint64 sys_mkdir(void);
  extern uint64 sys_mknod(void);
  extern uint64 sys_open(void);
  extern uint64 sys_pipe(void);
  extern uint64 sys_read(void);
  extern uint64 sys_sbrk(void);
  extern uint64 sys_sleep(void);
  extern uint64 sys_unlink(void);
  extern uint64 sys_wait(void);
  extern uint64 sys_write(void);
  extern uint64 sys_uptime(void);
  
  static uint64 (*syscalls[])(void) = {
      [SYS_fork] sys_fork,
      [SYS_exit] sys_exit,
      [SYS_wait] sys_wait,
      [SYS_pipe] sys_pipe,
      [SYS_read] sys_read,
      [SYS_kill] sys_kill,
      [SYS_exec] sys_exec,
      [SYS_fstat] sys_fstat,
      [SYS_chdir] sys_chdir,
      [SYS_dup] sys_dup,
      [SYS_getpid] sys_getpid,
      [SYS_sbrk] sys_sbrk,
      [SYS_sleep] sys_sleep,
      [SYS_uptime] sys_uptime,
      [SYS_open] sys_open,
      [SYS_write] sys_write,
      [SYS_mknod] sys_mknod,
      [SYS_unlink] sys_unlink,
      [SYS_link] sys_link,
      [SYS_mkdir] sys_mkdir,
      [SYS_close] sys_close,
  };
  
  void syscall(void)
  {
    int num;
    struct proc *p = myproc();
  
    // Assignment 4
    // when syscall is invoked and
    // its priority was not 2,
    // move to Q2 process
    if (p->priority != 2) 
    {
      acquire(&p->lock);
      movequeue(p, 2, 0);
  
      // start Q2 timer, end Q1 timer
      p->Qinterval[2] = ticks;
      p->Qinterval[1] = ticks - p->Qinterval[1];
      p->Qtime[1] += p->Qinterval[1];
      
      release(&p->lock);
    }
  
    num = p->trapframe->a7;
    if (num > 0 && num < NELEM(syscalls) && syscalls[num])
    {
      p->trapframe->a0 = syscalls[num]();
    }
    else
    {
      printf("%d %s: unknown sys call %d\n",
             p->pid, p->name, num);
      p->trapframe->a0 = -1;
    }
  }
  
    