root/kernel/sysproc.c

DEFINITIONS

1. sys_exit
2. sys_getpid
3. sys_fork
4. sys_wait
5. sys_sbrk
6. sys_sleep
7. sys_kill
8. sys_uptime

   1 #include "types.h"
   2 #include "riscv.h"
   3 #include "defs.h"
   4 #include "param.h"
   5 #include "memlayout.h"
   6 #include "spinlock.h"
   7 #include "proc.h"
   8 
   9 uint64
  10 sys_exit(void)
  11 {
  12   int n;
  13   argint(0, &n);
  14   exit(n);
  15   return 0;  // not reached
  16 }
  17 
  18 uint64
  19 sys_getpid(void)
  20 {
  21   return myproc()->pid;
  22 }
  23 
  24 uint64
  25 sys_fork(void)
  26 {
  27   return fork();
  28 }
  29 
  30 uint64
  31 sys_wait(void)
  32 {
  33   uint64 p;
  34   argaddr(0, &p);
  35   return wait(p);
  36 }
  37 
  38 uint64
  39 sys_sbrk(void)
  40 {
  41   uint64 addr;
  42   int n;
  43 
  44   argint(0, &n);
  45   addr = myproc()->sz;
  46   if(growproc(n) < 0)
  47     return -1;
  48   return addr;
  49 }
  50 
  51 uint64
  52 sys_sleep(void)
  53 {
  54   int n;
  55   uint ticks0;
  56 
  57   argint(0, &n);
  58   acquire(&tickslock);
  59   ticks0 = ticks;
  60   while(ticks - ticks0 < n){
  61     if(killed(myproc())){
  62       release(&tickslock);
  63       return -1;
  64     }
  65     sleep(&ticks, &tickslock);
  66   }
  67   release(&tickslock);
  68   return 0;
  69 }
  70 
  71 uint64
  72 sys_kill(void)
  73 {
  74   int pid;
  75 
  76   argint(0, &pid);
  77   return kill(pid);
  78 }
  79 
  80 // return how many clock tick interrupts have occurred
  81 // since start.
  82 uint64
  83 sys_uptime(void)
  84 {
  85   uint xticks;
  86 
  87   acquire(&tickslock);
  88   xticks = ticks;
  89   release(&tickslock);
  90   return xticks;
  91 }