1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
#include "types.h"
#include "riscv.h"
#include "param.h"
#include "defs.h"
#include "memlayout.h"
#include "spinlock.h"
#include "proc.h"
uint64
sys_exit(void)
{
int n;
argint(0, &n);
exit(n);
return 0; // not reached
}
uint64
sys_getpid(void)
{
return myproc()->pid;
}
uint64
sys_fork(void)
{
return fork();
}
uint64
sys_wait(void)
{
uint64 p;
argaddr(0, &p);
return wait(p);
}
uint64
sys_sbrk(void)
{
uint64 addr;
int n;
argint(0, &n);
addr = myproc()->sz;
if(growproc(n) < 0)
return -1;
return addr;
}
uint64
sys_sleep(void)
{
int n;
uint ticks0;
argint(0, &n);
acquire(&tickslock);
ticks0 = ticks;
while(ticks - ticks0 < n){
if(killed(myproc())){
release(&tickslock);
return -1;
}
sleep(&ticks, &tickslock);
}
// backtrace();
release(&tickslock);
return 0;
}
#ifdef LAB_PGTBL
int
sys_pgaccess(void)
{
uint64 base, mask;
int len;
argaddr(0, &base);
argint(1, &len);
argaddr(2, &mask);
return pgaccess(base, len, mask);
}
#endif
uint64
sys_kill(void)
{
int pid;
argint(0, &pid);
return kill(pid);
}
// return how many clock tick interrupts have occurred
// since start.
uint64
sys_uptime(void)
{
uint xticks;
acquire(&tickslock);
xticks = ticks;
release(&tickslock);
return xticks;
}
uint64
sys_trace(void)
{
argint(0, &myproc()->trace_mask);
return -(myproc()->trace_mask <= 1);
}
uint64
sys_sysinfo(void)
{
uint64 si; // user pointer to struct sysinfo
argaddr(0, &si);
return sys_info(si);
}
uint64
sys_sigalarm(void)
{
struct proc *p = myproc();
uint64 handler;
argint(0, &p->alarm_interval);
argaddr(1, &handler);
p->alarm_handler = handler;
return 0;
}
uint64 sys_sigreturn(void)
{
struct proc *p = myproc();
// retore saved trapframe to resume
memmove(p->trapframe, p->atpfm, sizeof(struct trapframe));
p->alarm_tickspassed = 0;
p->alarm_caninvoke = 1;
// make sure return the original a0 in trapframe to pass test3
return p->trapframe->a0;
}
|
