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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
#include "types.h"
#include "fcntl.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;
}
uint64
sys_mmap(void)
{
uint64 addr, len, offset;
int prot, flags, fd;
struct file* file;
argaddr(0, &addr);
argaddr(1, &len);
argint(2, &prot);
argint(3, &flags);
if(argfd(4, &fd, &file) == -1)
return 0xffffffffffffffff;
argaddr(5, &offset);
if(!(fileperm(file) & PROT_WRITE) && (prot & PROT_WRITE) && (flags == MAP_SHARED))
return 0xffffffffffffffff;
return mmap(addr, len, prot, flags, fd, file, offset);
}
uint64
sys_munmap(void)
{
uint64 addr, len;
argaddr(0, &addr);
argaddr(1, &len);
return munmap(addr, len);
}
|
