|
0
|
1 #include "types.h"
|
|
|
2 #include "defs.h"
|
|
|
3 #include "param.h"
|
|
|
4 #include "memlayout.h"
|
|
|
5 #include "mmu.h"
|
|
|
6 #include "proc.h"
|
|
|
7 #include "arm.h"
|
|
|
8 #include "syscall.h"
|
|
|
9
|
|
52
|
10 #define __ncode __code
|
|
|
11 #
|
|
0
|
12 // User code makes a system call with INT T_SYSCALL. System call number
|
|
|
13 // in r0. Arguments on the stack, from the user call to the C library
|
|
|
14 // system call function. The saved user sp points to the first argument.
|
|
|
15
|
|
|
16 // Fetch the int at addr from the current process.
|
|
|
17 int fetchint(uint addr, int *ip)
|
|
|
18 {
|
|
|
19 if(addr >= proc->sz || addr+4 > proc->sz) {
|
|
|
20 return -1;
|
|
|
21 }
|
|
|
22
|
|
|
23 *ip = *(int*)(addr);
|
|
|
24 return 0;
|
|
|
25 }
|
|
|
26
|
|
|
27 // Fetch the nul-terminated string at addr from the current process.
|
|
|
28 // Doesn't actually copy the string - just sets *pp to point at it.
|
|
|
29 // Returns length of string, not including nul.
|
|
|
30 int fetchstr(uint addr, char **pp)
|
|
|
31 {
|
|
|
32 char *s, *ep;
|
|
|
33
|
|
|
34 if(addr >= proc->sz) {
|
|
|
35 return -1;
|
|
|
36 }
|
|
|
37
|
|
|
38 *pp = (char*)addr;
|
|
|
39 ep = (char*)proc->sz;
|
|
|
40
|
|
|
41 for(s = *pp; s < ep; s++) {
|
|
|
42 if(*s == 0) {
|
|
|
43 return s - *pp;
|
|
|
44 }
|
|
|
45 }
|
|
|
46
|
|
|
47 return -1;
|
|
|
48 }
|
|
|
49
|
|
|
50 // Fetch the nth (starting from 0) 32-bit system call argument.
|
|
|
51 // In our ABI, r0 contains system call index, r1-r4 contain parameters.
|
|
|
52 // now we support system calls with at most 4 parameters.
|
|
|
53 int argint(int n, int *ip)
|
|
|
54 {
|
|
|
55 if (n > 3) {
|
|
|
56 panic ("too many system call parameters\n");
|
|
|
57 }
|
|
|
58
|
|
|
59 *ip = *(&proc->tf->r1 + n);
|
|
|
60
|
|
|
61 return 0;
|
|
|
62 }
|
|
|
63
|
|
|
64 // Fetch the nth word-sized system call argument as a pointer
|
|
|
65 // to a block of memory of size n bytes. Check that the pointer
|
|
|
66 // lies within the process address space.
|
|
|
67 int argptr(int n, char **pp, int size)
|
|
|
68 {
|
|
|
69 int i;
|
|
|
70
|
|
|
71 if(argint(n, &i) < 0) {
|
|
|
72 return -1;
|
|
|
73 }
|
|
|
74
|
|
|
75 if((uint)i >= proc->sz || (uint)i+size > proc->sz) {
|
|
|
76 return -1;
|
|
|
77 }
|
|
|
78
|
|
|
79 *pp = (char*)i;
|
|
|
80 return 0;
|
|
|
81 }
|
|
|
82
|
|
|
83 // Fetch the nth word-sized system call argument as a string pointer.
|
|
|
84 // Check that the pointer is valid and the string is nul-terminated.
|
|
|
85 // (There is no shared writable memory, so the string can't change
|
|
|
86 // between this check and being used by the kernel.)
|
|
|
87 int argstr(int n, char **pp)
|
|
|
88 {
|
|
|
89 int addr;
|
|
|
90
|
|
|
91 if(argint(n, &addr) < 0) {
|
|
|
92 return -1;
|
|
|
93 }
|
|
|
94
|
|
|
95 return fetchstr(addr, pp);
|
|
|
96 }
|
|
|
97
|
|
|
98 extern int sys_chdir(void);
|
|
|
99 extern int sys_close(void);
|
|
|
100 extern int sys_dup(void);
|
|
|
101 extern int sys_exec(void);
|
|
|
102 extern int sys_exit(void);
|
|
|
103 extern int sys_fork(void);
|
|
|
104 extern int sys_fstat(void);
|
|
|
105 extern int sys_getpid(void);
|
|
|
106 extern int sys_kill(void);
|
|
|
107 extern int sys_link(void);
|
|
|
108 extern int sys_mkdir(void);
|
|
|
109 extern int sys_mknod(void);
|
|
|
110 extern int sys_open(void);
|
|
|
111 extern int sys_pipe(void);
|
|
|
112 extern int sys_read(void);
|
|
|
113 extern int sys_sbrk(void);
|
|
|
114 extern int sys_sleep(void);
|
|
|
115 extern int sys_unlink(void);
|
|
|
116 extern int sys_wait(void);
|
|
|
117 extern int sys_write(void);
|
|
|
118 extern int sys_uptime(void);
|
|
|
119
|
|
29
|
120 extern __code cbc_read(__code(*)(int));
|
|
|
121
|
|
0
|
122 static int (*syscalls[])(void) = {
|
|
22
|
123 [SYS_fork] =sys_fork,
|
|
|
124 [SYS_exit] =sys_exit,
|
|
|
125 [SYS_wait] =sys_wait,
|
|
|
126 [SYS_pipe] =sys_pipe,
|
|
|
127 [SYS_read] =sys_read,
|
|
|
128 [SYS_kill] =sys_kill,
|
|
|
129 [SYS_exec] =sys_exec,
|
|
|
130 [SYS_fstat] =sys_fstat,
|
|
|
131 [SYS_chdir] =sys_chdir,
|
|
|
132 [SYS_dup] =sys_dup,
|
|
|
133 [SYS_getpid] =sys_getpid,
|
|
|
134 [SYS_sbrk] =sys_sbrk,
|
|
|
135 [SYS_sleep] =sys_sleep,
|
|
|
136 [SYS_uptime] =sys_uptime,
|
|
|
137 [SYS_open] =sys_open,
|
|
|
138 [SYS_write] =sys_write,
|
|
|
139 [SYS_mknod] =sys_mknod,
|
|
|
140 [SYS_unlink] =sys_unlink,
|
|
|
141 [SYS_link] =sys_link,
|
|
|
142 [SYS_mkdir] =sys_mkdir,
|
|
|
143 [SYS_close] =sys_close,
|
|
0
|
144 };
|
|
|
145
|
|
29
|
146 static __code (*cbccodes[])(__code (*)(int)) = {
|
|
24
|
147 [SYS_cbc_read] = cbc_read,
|
|
|
148 };
|
|
|
149
|
|
52
|
150 __ncode cbc_trap_return(){
|
|
31
|
151 return;
|
|
30
|
152 }
|
|
|
153
|
|
52
|
154 __ncode cbc_ret(int ret){
|
|
32
|
155 int num = proc->cbc_arg.cbc_console_arg.num;
|
|
|
156 if (num != SYS_exec) {
|
|
|
157 proc->tf->r0 = ret;
|
|
|
158 }
|
|
24
|
159 goto cbc_trap_return();
|
|
|
160 }
|
|
|
161
|
|
0
|
162 void syscall(void)
|
|
|
163 {
|
|
|
164 int num;
|
|
|
165 int ret;
|
|
|
166
|
|
|
167 num = proc->tf->r0;
|
|
|
168
|
|
31
|
169 if (num == 5)
|
|
|
170 num = 22;
|
|
0
|
171 //cprintf ("syscall(%d) from %s(%d)\n", num, proc->name, proc->pid);
|
|
|
172
|
|
31
|
173 if((num >= NELEM(syscalls)) && (num <= NELEM(cbccodes)) && cbccodes[num]) {
|
|
32
|
174 proc->cbc_arg.cbc_console_arg.num = num;
|
|
24
|
175 goto (cbccodes[num])(cbc_ret);
|
|
|
176 }
|
|
|
177
|
|
|
178
|
|
34
|
179 if((num > 0) && (num < NELEM(syscalls)) && syscalls[num]) {
|
|
0
|
180 ret = syscalls[num]();
|
|
|
181
|
|
|
182 // in ARM, parameters to main (argc, argv) are passed in r0 and r1
|
|
|
183 // do not set the return value if it is SYS_exec (the user program
|
|
|
184 // anyway does not expect us to return anything).
|
|
|
185 if (num != SYS_exec) {
|
|
|
186 proc->tf->r0 = ret;
|
|
|
187 }
|
|
|
188 } else {
|
|
|
189 cprintf("%d %s: unknown sys call %d\n", proc->pid, proc->name, num);
|
|
|
190 proc->tf->r0 = -1;
|
|
|
191 }
|
|
|
192 }
|
