1 #include "u.h"
2 #include "../port/lib.h"
3 #include "mem.h"
4 #include "dat.h"
5 #include "fns.h"
6 #include "../port/error.h"
7 #include "../port/systab.h"
8
9 #include <tos.h>
10 #include "ureg.h"
11
12 #include "arm.h"
13
14 typedef struct {
15 uintptr ip;
16 Ureg* arg0;
17 char* arg1;
18 char msg[ERRMAX];
19 Ureg* old;
20 Ureg ureg;
21 } NFrame;
22
23 /*
24 * Return user to state before notify()
25 */
26 static void
noted(Ureg * cur,uintptr arg0)27 noted(Ureg* cur, uintptr arg0)
28 {
29 NFrame *nf;
30 Ureg *nur;
31
32 qlock(&up->debug);
33 if(arg0 != NRSTR && !up->notified){
34 qunlock(&up->debug);
35 pprint("call to noted() when not notified\n");
36 pexit("Suicide", 0);
37 }
38 up->notified = 0;
39 fpunoted();
40
41 nf = up->ureg;
42
43 /* sanity clause */
44 if(!okaddr(PTR2UINT(nf), sizeof(NFrame), 0)){
45 qunlock(&up->debug);
46 pprint("bad ureg in noted %#p\n", nf);
47 pexit("Suicide", 0);
48 }
49
50 /* don't let user change system flags */
51 nur = &nf->ureg;
52 nur->psr &= PsrMask|PsrDfiq|PsrDirq;
53 nur->psr |= (cur->psr & ~(PsrMask|PsrDfiq|PsrDirq));
54
55 memmove(cur, nur, sizeof(Ureg));
56
57 switch((int)arg0){
58 case NCONT:
59 case NRSTR:
60 if(!okaddr(nur->pc, BY2WD, 0) || !okaddr(nur->sp, BY2WD, 0)){
61 qunlock(&up->debug);
62 pprint("suicide: trap in noted\n");
63 pexit("Suicide", 0);
64 }
65 up->ureg = nf->old;
66 qunlock(&up->debug);
67 break;
68 case NSAVE:
69 if(!okaddr(nur->pc, BY2WD, 0) || !okaddr(nur->sp, BY2WD, 0)){
70 qunlock(&up->debug);
71 pprint("suicide: trap in noted\n");
72 pexit("Suicide", 0);
73 }
74 qunlock(&up->debug);
75
76 splhi();
77 nf->arg1 = nf->msg;
78 nf->arg0 = &nf->ureg;
79 nf->ip = 0;
80 cur->sp = PTR2UINT(nf);
81 cur->r0 = PTR2UINT(nf->arg0);
82 break;
83 default:
84 pprint("unknown noted arg %#p\n", arg0);
85 up->lastnote.flag = NDebug;
86 /*FALLTHROUGH*/
87 case NDFLT:
88 if(up->lastnote.flag == NDebug){
89 qunlock(&up->debug);
90 pprint("suicide: %s\n", up->lastnote.msg);
91 }
92 else
93 qunlock(&up->debug);
94 pexit(up->lastnote.msg, up->lastnote.flag != NDebug);
95 }
96 }
97
98 /*
99 * Call user, if necessary, with note.
100 * Pass user the Ureg struct and the note on his stack.
101 */
102 int
notify(Ureg * ureg)103 notify(Ureg* ureg)
104 {
105 int l;
106 Note *n;
107 u32int s;
108 uintptr sp;
109 NFrame *nf;
110
111 if(up->procctl)
112 procctl(up);
113 if(up->nnote == 0)
114 return 0;
115
116 fpunotify(ureg);
117
118 s = spllo();
119 qlock(&up->debug);
120
121 up->notepending = 0;
122 n = &up->note[0];
123 if(strncmp(n->msg, "sys:", 4) == 0){
124 l = strlen(n->msg);
125 if(l > ERRMAX-23) /* " pc=0x0123456789abcdef\0" */
126 l = ERRMAX-23;
127 snprint(n->msg + l, sizeof n->msg - l, " pc=%#lux", ureg->pc);
128 }
129
130 if(n->flag != NUser && (up->notified || up->notify == 0)){
131 if(n->flag == NDebug)
132 pprint("suicide: %s\n", n->msg);
133 qunlock(&up->debug);
134 pexit(n->msg, n->flag != NDebug);
135 }
136
137 if(up->notified){
138 qunlock(&up->debug);
139 splhi();
140 return 0;
141 }
142
143 if(up->notify == nil){
144 qunlock(&up->debug);
145 pexit(n->msg, n->flag != NDebug);
146 }
147 if(!okaddr(PTR2UINT(up->notify), 1, 0)){
148 pprint("suicide: notify function address %#p\n", up->notify);
149 qunlock(&up->debug);
150 pexit("Suicide", 0);
151 }
152
153 sp = ureg->sp - sizeof(NFrame);
154 if(!okaddr(sp, sizeof(NFrame), 1)){
155 qunlock(&up->debug);
156 pprint("suicide: notify stack address %#p\n", sp);
157 pexit("Suicide", 0);
158 }
159
160 nf = UINT2PTR(sp);
161 memmove(&nf->ureg, ureg, sizeof(Ureg));
162 nf->old = up->ureg;
163 up->ureg = nf;
164 memmove(nf->msg, up->note[0].msg, ERRMAX);
165 nf->arg1 = nf->msg;
166 nf->arg0 = &nf->ureg;
167 ureg->r0 = PTR2UINT(nf->arg0);
168 nf->ip = 0;
169
170 ureg->sp = sp;
171 ureg->pc = PTR2UINT(up->notify);
172 up->notified = 1;
173 up->nnote--;
174 memmove(&up->lastnote, &up->note[0], sizeof(Note));
175 memmove(&up->note[0], &up->note[1], up->nnote*sizeof(Note));
176
177 qunlock(&up->debug);
178 splx(s);
179
180 return 1;
181 }
182
183 void
syscall(Ureg * ureg)184 syscall(Ureg* ureg)
185 {
186 char *e;
187 u32int s;
188 ulong sp;
189 long ret;
190 int i, scallnr;
191 vlong startns, stopns;
192
193 if(!userureg(ureg))
194 panic("syscall: from kernel: pc %#lux r14 %#lux psr %#lux",
195 ureg->pc, ureg->r14, ureg->psr);
196
197 cycles(&up->kentry);
198
199 m->syscall++;
200 up->insyscall = 1;
201 up->pc = ureg->pc;
202 up->dbgreg = ureg;
203
204 scallnr = ureg->r0;
205 up->scallnr = scallnr;
206 if(scallnr == RFORK)
207 fpusysrfork(ureg);
208 spllo();
209 sp = ureg->sp;
210
211 if(up->procctl == Proc_tracesyscall){
212 /*
213 * Redundant validaddr. Do we care?
214 * Tracing syscalls is not exactly a fast path...
215 * Beware, validaddr currently does a pexit rather
216 * than an error if there's a problem; that might
217 * change in the future.
218 */
219 if(sp < (USTKTOP-BY2PG) || sp > (USTKTOP-sizeof(Sargs)-BY2WD))
220 validaddr(sp, sizeof(Sargs)+BY2WD, 0);
221
222 syscallfmt(scallnr, ureg->pc, (va_list)(sp+BY2WD));
223 up->procctl = Proc_stopme;
224 procctl(up);
225 if (up->syscalltrace)
226 free(up->syscalltrace);
227 up->syscalltrace = nil;
228 }
229
230 up->nerrlab = 0;
231 ret = -1;
232 startns = todget(nil);
233 if(!waserror()){
234 if(scallnr >= nsyscall){
235 pprint("bad sys call number %d pc %#lux\n",
236 scallnr, ureg->pc);
237 postnote(up, 1, "sys: bad sys call", NDebug);
238 error(Ebadarg);
239 }
240
241 if(sp < (USTKTOP-BY2PG) || sp > (USTKTOP-sizeof(Sargs)-BY2WD))
242 validaddr(sp, sizeof(Sargs)+BY2WD, 0);
243
244 up->s = *((Sargs*)(sp+BY2WD));
245 up->psstate = sysctab[scallnr];
246
247 /* iprint("%s: syscall %s\n", up->text, sysctab[scallnr]?sysctab[scallnr]:"huh?"); */
248
249 ret = systab[scallnr](up->s.args);
250 poperror();
251 }else{
252 /* failure: save the error buffer for errstr */
253 e = up->syserrstr;
254 up->syserrstr = up->errstr;
255 up->errstr = e;
256 }
257 if(up->nerrlab){
258 print("bad errstack [%d]: %d extra\n", scallnr, up->nerrlab);
259 for(i = 0; i < NERR; i++)
260 print("sp=%#p pc=%#p\n",
261 up->errlab[i].sp, up->errlab[i].pc);
262 panic("error stack");
263 }
264
265 /*
266 * Put return value in frame. On the x86 the syscall is
267 * just another trap and the return value from syscall is
268 * ignored. On other machines the return value is put into
269 * the results register by caller of syscall.
270 */
271 ureg->r0 = ret;
272
273 if(up->procctl == Proc_tracesyscall){
274 stopns = todget(nil);
275 up->procctl = Proc_stopme;
276 sysretfmt(scallnr, (va_list)(sp+BY2WD), ret, startns, stopns);
277 s = splhi();
278 procctl(up);
279 splx(s);
280 if(up->syscalltrace)
281 free(up->syscalltrace);
282 up->syscalltrace = nil;
283 }
284
285 up->insyscall = 0;
286 up->psstate = 0;
287
288 if(scallnr == NOTED)
289 noted(ureg, *(ulong*)(sp+BY2WD));
290
291 splhi();
292 if(scallnr != RFORK && (up->procctl || up->nnote))
293 notify(ureg);
294
295 /* if we delayed sched because we held a lock, sched now */
296 if(up->delaysched){
297 sched();
298 splhi();
299 }
300 kexit(ureg);
301 }
302
303 long
execregs(ulong entry,ulong ssize,ulong nargs)304 execregs(ulong entry, ulong ssize, ulong nargs)
305 {
306 ulong *sp;
307 Ureg *ureg;
308
309 sp = (ulong*)(USTKTOP - ssize);
310 *--sp = nargs;
311
312 ureg = up->dbgreg;
313 // memset(ureg, 0, 15*sizeof(ulong));
314 ureg->r13 = (ulong)sp;
315 ureg->pc = entry;
316 //print("%lud: EXECREGS pc %#ux sp %#ux nargs %ld\n", up->pid, ureg->pc, ureg->r13, nargs);
317
318 /*
319 * return the address of kernel/user shared data
320 * (e.g. clock stuff)
321 */
322 return USTKTOP-sizeof(Tos);
323 }
324
325 void
sysprocsetup(Proc * p)326 sysprocsetup(Proc* p)
327 {
328 fpusysprocsetup(p);
329 }
330
331 /*
332 * Craft a return frame which will cause the child to pop out of
333 * the scheduler in user mode with the return register zero. Set
334 * pc to point to a l.s return function.
335 */
336 void
forkchild(Proc * p,Ureg * ureg)337 forkchild(Proc *p, Ureg *ureg)
338 {
339 Ureg *cureg;
340
341 //print("%lud setting up for forking child %lud\n", up->pid, p->pid);
342 p->sched.sp = (ulong)p->kstack+KSTACK-sizeof(Ureg);
343 p->sched.pc = (ulong)forkret;
344
345 cureg = (Ureg*)(p->sched.sp);
346 memmove(cureg, ureg, sizeof(Ureg));
347
348 /* syscall returns 0 for child */
349 cureg->r0 = 0;
350
351 /* Things from bottom of syscall which were never executed */
352 p->psstate = 0;
353 p->insyscall = 0;
354
355 fpusysrforkchild(p, cureg, up);
356 }
357