root/kernel/sysproc.c

DEFINITIONS

1. sys_exit
2. sys_getpid
3. sys_fork
4. sys_wait
5. sys_sbrk
6. sys_pause
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 #include "vm.h"
   9 
  10 uint64
  11 sys_exit(void)
  12 {
  13   int n;
  14   argint(0, &n);
  15   kexit(n);
  16   return 0;  // not reached
  17 }
  18 
  19 uint64
  20 sys_getpid(void)
  21 {
  22   return myproc()->pid;
  23 }
  24 
  25 uint64
  26 sys_fork(void)
  27 {
  28   return kfork();
  29 }
  30 
  31 uint64
  32 sys_wait(void)
  33 {
  34   uint64 p;
  35   argaddr(0, &p);
  36   return kwait(p);
  37 }
  38 
  39 uint64
  40 sys_sbrk(void)
  41 {
  42   uint64 addr;
  43   int t;
  44   int n;
  45 
  46   argint(0, &n);
  47   argint(1, &t);
  48   addr = myproc()->sz;
  49 
  50   if(t == SBRK_EAGER || n < 0) {
  51     if(growproc(n) < 0) {
  52       return -1;
  53     }
  54   } else {
  55     // Lazily allocate memory for this process: increase its memory
  56     // size but don't allocate memory. If the processes uses the
  57     // memory, vmfault() will allocate it.
  58     if(addr + n < addr)
  59       return -1;
  60     myproc()->sz += n;
  61   }
  62   return addr;
  63 }
  64 
  65 uint64
  66 sys_pause(void)
  67 {
  68   int n;
  69   uint ticks0;
  70 
  71   argint(0, &n);
  72   if(n < 0)
  73     n = 0;
  74   acquire(&tickslock);
  75   ticks0 = ticks;
  76   while(ticks - ticks0 < n){
  77     if(killed(myproc())){
  78       release(&tickslock);
  79       return -1;
  80     }
  81     sleep(&ticks, &tickslock);
  82   }
  83   release(&tickslock);
  84   return 0;
  85 }
  86 
  87 uint64
  88 sys_kill(void)
  89 {
  90   int pid;
  91 
  92   argint(0, &pid);
  93   return kkill(pid);
  94 }
  95 
  96 // return how many clock tick interrupts have occurred
  97 // since start.
  98 uint64
  99 sys_uptime(void)
 100 {
 101   uint xticks;
 102 
 103   acquire(&tickslock);
 104   xticks = ticks;
 105   release(&tickslock);
 106   return xticks;
 107 }