FreeBSD/Linux Kernel Cross Reference
sys/bitsy/trap.c
1 #include "u.h"
2 #include "../port/lib.h"
3 #include "mem.h"
4 #include "dat.h"
5 #include "fns.h"
6 #include "io.h"
7 #include "ureg.h"
8 #include "../port/error.h"
9 #include "tos.h"
10
11 Intrregs *intrregs;
12
13 typedef struct Vctl {
14 Vctl* next; /* handlers on this vector */
15 char *name; /* of driver, xallocated */
16 void (*f)(Ureg*, void*); /* handler to call */
17 void* a; /* argument to call it with */
18 } Vctl;
19
20 static Lock vctllock;
21 static Vctl *vctl[32];
22 static Vctl *gpiovctl[27];
23 static int gpioirqref[12];
24
25 /*
26 * Layout at virtual address 0.
27 */
28 typedef struct Vpage0 {
29 void (*vectors[8])(void);
30 ulong vtable[8];
31 } Vpage0;
32 Vpage0 *vpage0;
33
34 static int irq(Ureg*);
35 static void gpiointr(Ureg*, void*);
36
37 /* recover state after power suspend
38 * NB: to help debugging bad suspend code,
39 * I changed some prints below to iprints,
40 * to avoid deadlocks when a panic is being
41 * issued during the suspend/resume handler.
42 */
43 void
44 trapresume(void)
45 {
46 vpage0 = (Vpage0*)EVECTORS;
47 memmove(vpage0->vectors, vectors, sizeof(vpage0->vectors));
48 memmove(vpage0->vtable, vtable, sizeof(vpage0->vtable));
49 wbflush();
50 mappedIvecEnable();
51 }
52
53 /*
54 * set up for exceptions
55 */
56 void
57 trapinit(void)
58 {
59 /* set up the exception vectors */
60 vpage0 = (Vpage0*)EVECTORS;
61 memmove(vpage0->vectors, vectors, sizeof(vpage0->vectors));
62 memmove(vpage0->vtable, vtable, sizeof(vpage0->vtable));
63
64 wbflush();
65
66 /* use exception vectors at 0xFFFF0000 */
67 mappedIvecEnable();
68
69 /* set up the stacks for the interrupt modes */
70 setr13(PsrMfiq, m->sfiq);
71 setr13(PsrMirq, m->sirq);
72 setr13(PsrMabt, m->sabt);
73 setr13(PsrMund, m->sund);
74
75 /* map in interrupt registers */
76 intrregs = mapspecial(INTRREGS, sizeof(*intrregs));
77
78 /* make all interrupts IRQ (i.e. not FIQ) and disable all interrupts */
79 intrregs->iclr = 0;
80 intrregs->icmr = 0;
81
82 /* turn off all gpio interrupts */
83 gpioregs->rising = 0;
84 gpioregs->falling = 0;
85 gpioregs->edgestatus = gpioregs->edgestatus;
86
87 /* allow all enabled interrupts to take processor out of sleep mode */
88 intrregs->iccr = 0;
89 }
90
91 void
92 trapdump(char *tag)
93 {
94 iprint("%s: icip %lux icmr %lux iclr %lux iccr %lux icfp %lux\n",
95 tag, intrregs->icip, intrregs->icmr, intrregs->iclr,
96 intrregs->iccr, intrregs->icfp);
97 }
98
99 void
100 warnregs(Ureg *ur, char *tag)
101 {
102 char buf[1024];
103 char *e = buf+sizeof(buf);
104 char *p;
105
106 p = seprint(buf, e, "%s:\n", tag);
107 p = seprint(p, e, "type 0x%.8lux psr 0x%.8lux pc 0x%.8lux\n",
108 ur->type, ur->psr, ur->pc);
109 p = seprint(p, e, "r0 0x%.8lux r1 0x%.8lux r2 0x%.8lux r3 0x%.8lux\n",
110 ur->r0, ur->r1, ur->r2, ur->r3);
111 p = seprint(p, e, "r4 0x%.8lux r5 0x%.8lux r6 0x%.8lux r7 0x%.8lux\n",
112 ur->r4, ur->r5, ur->r6, ur->r7);
113 p = seprint(p, e, "r8 0x%.8lux r9 0x%.8lux r10 0x%.8lux r11 0x%.8lux\n",
114 ur->r8, ur->r9, ur->r10, ur->r11);
115 seprint(p, e, "r12 0x%.8lux r13 0x%.8lux r14 0x%.8lux\n",
116 ur->r12, ur->r13, ur->r14);
117 iprint("%s", buf);
118 }
119
120 /*
121 * enable an irq interrupt
122 */
123 static void
124 irqenable(int irq, IntrHandler *f, void* a, char *name)
125 {
126 Vctl *v;
127
128 if(irq >= nelem(vctl) || irq < 0)
129 panic("intrenable");
130
131 v = malloc(sizeof(Vctl));
132 v->f = f;
133 v->a = a;
134 v->name = xalloc(strlen(name)+1);
135 strcpy(v->name, name);
136
137 lock(&vctllock);
138 v->next = vctl[irq];
139 vctl[irq] = v;
140 intrregs->icmr |= 1<<irq;
141 unlock(&vctllock);
142 }
143
144 /*
145 * disable an irq interrupt
146 */
147 static void
148 irqdisable(int irq, IntrHandler *f, void* a, char *name)
149 {
150 Vctl **vp, *v;
151
152 if(irq >= nelem(vctl) || irq < 0)
153 panic("intrdisable");
154
155 lock(&vctllock);
156 for(vp = &vctl[irq]; v = *vp; vp = &v->next)
157 if (v->f == f && v->a == a && strcmp(v->name, name) == 0){
158 print("irqdisable: remove %s\n", name);
159 *vp = v->next;
160 free(v);
161 break;
162 }
163 if (v == nil)
164 print("irqdisable: irq %d, name %s not enabled\n", irq, name);
165 if (vctl[irq] == nil){
166 print("irqdisable: clear icmr bit %d\n", irq);
167 intrregs->icmr &= ~(1<<irq);
168 }
169 unlock(&vctllock);
170 }
171
172 /*
173 * enable an interrupt
174 */
175 void
176 intrenable(int type, int which, IntrHandler *f, void* a, char *name)
177 {
178 int irq;
179 Vctl *v;
180
181 if(type == IRQ){
182 irqenable(which, f, a, name);
183 return;
184 }
185
186 /* from here down, it must be a GPIO edge interrupt */
187 irq = which;
188 if(which >= nelem(gpiovctl) || which < 0)
189 panic("intrenable");
190 if(which > 11)
191 irq = 11;
192
193 /* the pin had better be configured as input */
194 if((1<<which) & gpioregs->direction)
195 panic("intrenable of output pin %d", which);
196
197 /* create a second level vctl for the gpio edge interrupt */
198 v = malloc(sizeof(Vctl));
199 v->f = f;
200 v->a = a;
201 v->name = xalloc(strlen(name)+1);
202 strcpy(v->name, name);
203
204 lock(&vctllock);
205 v->next = gpiovctl[which];
206 gpiovctl[which] = v;
207
208 /* set edge register to enable interrupt */
209 switch(type){
210 case GPIOboth:
211 gpioregs->rising |= 1<<which;
212 gpioregs->falling |= 1<<which;
213 break;
214 case GPIOfalling:
215 gpioregs->falling |= 1<<which;
216 break;
217 case GPIOrising:
218 gpioregs->rising |= 1<<which;
219 break;
220 }
221 unlock(&vctllock);
222 /* point the irq to the gpio interrupt handler */
223 if(gpioirqref[irq]++ == 0)
224 irqenable(irq, gpiointr, nil, "gpio edge");
225 }
226
227 /*
228 * disable an interrupt
229 */
230 void
231 intrdisable(int type, int which, IntrHandler *f, void* a, char *name)
232 {
233 int irq;
234 Vctl **vp, *v;
235
236
237 if(type == IRQ){
238 irqdisable(which, f, a, name);
239 return;
240 }
241
242 /* from here down, it must be a GPIO edge interrupt */
243 irq = which;
244 if(which >= nelem(gpiovctl) || which < 0)
245 panic("intrdisable");
246 if(which > 11)
247 irq = 11;
248
249 lock(&vctllock);
250 for(vp = &gpiovctl[which]; v = *vp; vp = &v->next)
251 if (v->f == f && v->a == a && strcmp(v->name, name) == 0){
252 break;
253 }
254 if (gpiovctl[which] == nil){
255 /* set edge register to enable interrupt */
256 switch(type){
257 case GPIOboth:
258 print("intrdisable: gpio-rising+falling clear bit %d\n", which);
259 gpioregs->rising &= ~(1<<which);
260 gpioregs->falling &= ~(1<<which);
261 break;
262 case GPIOfalling:
263 print("intrdisable: gpio-falling clear bit %d\n", which);
264 gpioregs->falling &= ~(1<<which);
265 break;
266 case GPIOrising:
267 print("intrdisable: gpio-rising clear bit %d\n", which);
268 gpioregs->rising &= ~(1<<which);
269 break;
270 }
271
272 }
273 if (v) {
274 print("intrdisable: removing %s\n", name);
275 *vp = v->next;
276 }else
277 print("intrdisable: which %d, name %s not enabled\n", which, name);
278 unlock(&vctllock);
279 /* disable the gpio interrupt handler if necessary */
280 if(--gpioirqref[irq] == 0){
281 print("intrdisable: inrqdisable gpiointr\n");
282 irqdisable(irq, gpiointr, nil, "gpio edge");
283 }
284 free(v);
285 }
286
287 /*
288 * called by trap to handle access faults
289 */
290 static void
291 faultarm(Ureg *ureg, ulong va, int user, int read)
292 {
293 int n, insyscall;
294 char buf[ERRMAX];
295
296 if (up == nil) {
297 warnregs(ureg, "kernel fault");
298 panic("fault: nil up in faultarm, accessing 0x%lux", va);
299 }
300 insyscall = up->insyscall;
301 up->insyscall = 1;
302 n = fault(va, read);
303 if(n < 0){
304 if(!user){
305 warnregs(ureg, "kernel fault");
306 panic("fault: kernel accessing 0x%lux", va);
307 }
308 // warnregs(ureg, "user fault");
309 sprint(buf, "sys: trap: fault %s va=0x%lux", read ? "read" : "write", va);
310 postnote(up, 1, buf, NDebug);
311 }
312 up->insyscall = insyscall;
313 }
314
315 /*
316 * returns 1 if the instruction writes memory, 0 otherwise
317 */
318 int
319 writetomem(ulong inst)
320 {
321 /* swap always write memory */
322 if((inst & 0x0FC00000) == 0x01000000)
323 return 1;
324
325 /* loads and stores are distinguished by bit 20 */
326 if(inst & (1<<20))
327 return 0;
328
329 return 1;
330 }
331
332
333 /*
334 * here on all exceptions other than syscall (SWI)
335 */
336 void
337 trap(Ureg *ureg)
338 {
339 ulong inst;
340 int clockintr, user, x, rv;
341 ulong va, fsr;
342 char buf[ERRMAX];
343 int rem;
344
345 if(up != nil)
346 rem = ((char*)ureg)-up->kstack;
347 else
348 rem = ((char*)ureg)-((char*)(MACHADDR+sizeof(Mach)));
349 if(rem < 256) {
350 dumpstack();
351 panic("trap %d bytes remaining, up = %#p, ureg = %#p, at pc 0x%lux",
352 rem, up, ureg, ureg->pc);
353 }
354
355 user = (ureg->psr & PsrMask) == PsrMusr;
356
357 /*
358 * All interrupts/exceptions should be resumed at ureg->pc-4,
359 * except for Data Abort which resumes at ureg->pc-8.
360 */
361 if(ureg->type == (PsrMabt+1))
362 ureg->pc -= 8;
363 else
364 ureg->pc -= 4;
365
366 clockintr = 0;
367 switch(ureg->type){
368 default:
369 panic("unknown trap");
370 break;
371 case PsrMirq:
372 clockintr = irq(ureg);
373 break;
374 case PsrMabt: /* prefetch fault */
375 faultarm(ureg, ureg->pc, user, 1);
376 break;
377 case PsrMabt+1: /* data fault */
378 va = getfar();
379 inst = *(ulong*)(ureg->pc);
380 fsr = getfsr() & 0xf;
381 switch(fsr){
382 case 0x0:
383 panic("vector exception at %lux", ureg->pc);
384 break;
385 case 0x1:
386 case 0x3:
387 if(user){
388 snprint(buf, sizeof(buf), "sys: alignment: pc 0x%lux va 0x%lux\n",
389 ureg->pc, va);
390 postnote(up, 1, buf, NDebug);
391 } else
392 panic("kernel alignment: pc 0x%lux va 0x%lux", ureg->pc, va);
393 break;
394 case 0x2:
395 panic("terminal exception at %lux", ureg->pc);
396 break;
397 case 0x4:
398 case 0x6:
399 case 0x8:
400 case 0xa:
401 case 0xc:
402 case 0xe:
403 panic("external abort 0x%lux pc 0x%lux addr 0x%lux", fsr, ureg->pc, va);
404 break;
405 case 0x5:
406 case 0x7:
407 /* translation fault, i.e., no pte entry */
408 faultarm(ureg, va, user, !writetomem(inst));
409 break;
410 case 0x9:
411 case 0xb:
412 /* domain fault, accessing something we shouldn't */
413 if(user){
414 sprint(buf, "sys: access violation: pc 0x%lux va 0x%lux\n",
415 ureg->pc, va);
416 postnote(up, 1, buf, NDebug);
417 } else
418 panic("kernel access violation: pc 0x%lux va 0x%lux",
419 ureg->pc, va);
420 break;
421 case 0xd:
422 case 0xf:
423 /* permission error, copy on write or real permission error */
424 faultarm(ureg, va, user, !writetomem(inst));
425 break;
426 }
427 break;
428 case PsrMund: /* undefined instruction */
429 if (user) {
430 /* look for floating point instructions to interpret */
431 x = spllo();
432 rv = fpiarm(ureg);
433 splx(x);
434 if (rv == 0) {
435 sprint(buf, "undefined instruction: pc 0x%lux\n", ureg->pc);
436 postnote(up, 1, buf, NDebug);
437 }
438 }else{
439 iprint("undefined instruction: pc=0x%lux, inst=0x%lux, 0x%lux, 0x%lux, 0x%lux, 0x%lux\n", ureg->pc, ((ulong*)ureg->pc)[-2], ((ulong*)ureg->pc)[-1], ((ulong*)ureg->pc)[0], ((ulong*)ureg->pc)[1], ((ulong*)ureg->pc)[2]);
440 panic("undefined instruction");
441 }
442 break;
443 }
444 splhi();
445
446 /* delaysched set because we held a lock or because our quantum ended */
447 if(up && up->delaysched && clockintr){
448 sched();
449 splhi();
450 }
451
452 if(user){
453 if(up->procctl || up->nnote)
454 notify(ureg);
455 kexit(ureg);
456 }
457 }
458
459 /*
460 * here on irq's
461 */
462 static int
463 irq(Ureg *ur)
464 {
465 ulong va;
466 int clockintr, i;
467 Vctl *v;
468
469 va = intrregs->icip;
470
471 if(va & (1<<IRQtimer0))
472 clockintr = 1;
473 else
474 clockintr = 0;
475 for(i = 0; i < 32; i++){
476 if(((1<<i) & va) == 0)
477 continue;
478 for(v = vctl[i]; v != nil; v = v->next){
479 v->f(ur, v->a);
480 va &= ~(1<<i);
481 }
482 }
483 if(va)
484 print("unknown interrupt: %lux\n", va);
485
486 return clockintr;
487 }
488
489 /*
490 * here on gpio interrupts
491 */
492 static void
493 gpiointr(Ureg *ur, void*)
494 {
495 ulong va;
496 int i;
497 Vctl *v;
498
499 va = gpioregs->edgestatus;
500 gpioregs->edgestatus = va;
501
502 for(i = 0; i < 27; i++){
503 if(((1<<i) & va) == 0)
504 continue;
505 for(v = gpiovctl[i]; v != nil; v = v->next){
506 v->f(ur, v->a);
507 va &= ~(1<<i);
508 }
509 }
510 if(va)
511 print("unknown gpio interrupt: %lux\n", va);
512 }
513
514 /*
515 * system calls
516 */
517 #include "../port/systab.h"
518
519 /*
520 * Syscall is called directly from assembler without going through trap().
521 */
522 void
523 syscall(Ureg* ureg)
524 {
525 char *e;
526 ulong sp;
527 long ret;
528 int i, scallnr;
529
530 if((ureg->psr & PsrMask) != PsrMusr) {
531 panic("syscall: pc 0x%lux r14 0x%lux cs 0x%lux", ureg->pc, ureg->r14, ureg->psr);
532 }
533
534 m->syscall++;
535 up->insyscall = 1;
536 up->pc = ureg->pc;
537 up->dbgreg = ureg;
538
539 scallnr = ureg->r0;
540 up->scallnr = scallnr;
541 spllo();
542
543 sp = ureg->sp;
544 up->nerrlab = 0;
545 ret = -1;
546 if(!waserror()){
547 if(scallnr >= nsyscall){
548 pprint("bad sys call number %d pc %lux\n",
549 scallnr, ureg->pc);
550 postnote(up, 1, "sys: bad sys call", NDebug);
551 error(Ebadarg);
552 }
553
554 if(sp<(USTKTOP-BY2PG) || sp>(USTKTOP-sizeof(Sargs)-BY2WD))
555 validaddr(sp, sizeof(Sargs)+BY2WD, 0);
556
557 up->s = *((Sargs*)(sp+BY2WD));
558 up->psstate = sysctab[scallnr];
559
560 ret = systab[scallnr](up->s.args);
561 poperror();
562 }else{
563 /* failure: save the error buffer for errstr */
564 e = up->syserrstr;
565 up->syserrstr = up->errstr;
566 up->errstr = e;
567 }
568 if(up->nerrlab){
569 print("bad errstack [%d]: %d extra\n", scallnr, up->nerrlab);
570 for(i = 0; i < NERR; i++)
571 print("sp=%lux pc=%lux\n",
572 up->errlab[i].sp, up->errlab[i].pc);
573 panic("error stack");
574 }
575
576 up->insyscall = 0;
577 up->psstate = 0;
578
579 /*
580 * Put return value in frame. On the x86 the syscall is
581 * just another trap and the return value from syscall is
582 * ignored. On other machines the return value is put into
583 * the results register by caller of syscall.
584 */
585 ureg->r0 = ret;
586
587 if(scallnr == NOTED)
588 noted(ureg, *(ulong*)(sp+BY2WD));
589
590 if(up->delaysched)
591 sched();
592
593 splhi();
594 if(scallnr != RFORK && (up->procctl || up->nnote))
595 notify(ureg);
596 }
597
598 /*
599 * Return user to state before notify()
600 */
601 void
602 noted(Ureg* ureg, ulong arg0)
603 {
604 Ureg *nureg;
605 ulong oureg, sp;
606
607 qlock(&up->debug);
608 if(arg0!=NRSTR && !up->notified) {
609 qunlock(&up->debug);
610 pprint("call to noted() when not notified\n");
611 pexit("Suicide", 0);
612 }
613 up->notified = 0;
614
615 nureg = up->ureg; /* pointer to user returned Ureg struct */
616
617 /* sanity clause */
618 oureg = (ulong)nureg;
619 if(!okaddr((ulong)oureg-BY2WD, BY2WD+sizeof(Ureg), 0)){
620 pprint("bad ureg in noted or call to noted when not notified\n");
621 qunlock(&up->debug);
622 pexit("Suicide", 0);
623 }
624
625 /* don't let user change system flags */
626 nureg->psr = (ureg->psr & ~(PsrMask|PsrDfiq|PsrDirq)) |
627 (nureg->psr & (PsrMask|PsrDfiq|PsrDirq));
628
629 memmove(ureg, nureg, sizeof(Ureg));
630
631 switch(arg0){
632 case NCONT:
633 case NRSTR:
634 if(!okaddr(nureg->pc, 1, 0) || !okaddr(nureg->sp, BY2WD, 0)){
635 qunlock(&up->debug);
636 pprint("suicide: trap in noted\n");
637 pexit("Suicide", 0);
638 }
639 up->ureg = (Ureg*)(*(ulong*)(oureg-BY2WD));
640 qunlock(&up->debug);
641 break;
642
643 case NSAVE:
644 if(!okaddr(nureg->pc, BY2WD, 0)
645 || !okaddr(nureg->sp, BY2WD, 0)){
646 qunlock(&up->debug);
647 pprint("suicide: trap in noted\n");
648 pexit("Suicide", 0);
649 }
650 qunlock(&up->debug);
651 sp = oureg-4*BY2WD-ERRMAX;
652 splhi();
653 ureg->sp = sp;
654 ((ulong*)sp)[1] = oureg; /* arg 1 0(FP) is ureg* */
655 ((ulong*)sp)[0] = 0; /* arg 0 is pc */
656 break;
657
658 default:
659 pprint("unknown noted arg 0x%lux\n", arg0);
660 up->lastnote.flag = NDebug;
661 /* fall through */
662
663 case NDFLT:
664 if(up->lastnote.flag == NDebug){
665 qunlock(&up->debug);
666 pprint("suicide: %s\n", up->lastnote.msg);
667 } else
668 qunlock(&up->debug);
669 pexit(up->lastnote.msg, up->lastnote.flag!=NDebug);
670 }
671 }
672
673 /*
674 * Call user, if necessary, with note.
675 * Pass user the Ureg struct and the note on his stack.
676 */
677 int
678 notify(Ureg* ureg)
679 {
680 int l;
681 ulong s, sp;
682 Note *n;
683
684 if(up->procctl)
685 procctl(up);
686 if(up->nnote == 0)
687 return 0;
688
689 s = spllo();
690 qlock(&up->debug);
691 up->notepending = 0;
692 n = &up->note[0];
693 if(strncmp(n->msg, "sys:", 4) == 0){
694 l = strlen(n->msg);
695 if(l > ERRMAX-15) /* " pc=0x12345678\0" */
696 l = ERRMAX-15;
697 sprint(n->msg+l, " pc=0x%.8lux", ureg->pc);
698 }
699
700 if(n->flag!=NUser && (up->notified || up->notify==0)){
701 if(n->flag == NDebug)
702 pprint("suicide: %s\n", n->msg);
703 qunlock(&up->debug);
704 pexit(n->msg, n->flag!=NDebug);
705 }
706
707 if(up->notified) {
708 qunlock(&up->debug);
709 splhi();
710 return 0;
711 }
712
713 if(!up->notify){
714 qunlock(&up->debug);
715 pexit(n->msg, n->flag!=NDebug);
716 }
717 sp = ureg->sp;
718 sp -= sizeof(Ureg);
719
720 if(!okaddr((ulong)up->notify, 1, 0)
721 || !okaddr(sp-ERRMAX-4*BY2WD, sizeof(Ureg)+ERRMAX+4*BY2WD, 1)){
722 pprint("suicide: bad address in notify\n");
723 qunlock(&up->debug);
724 pexit("Suicide", 0);
725 }
726
727 up->ureg = (void*)sp;
728 memmove((Ureg*)sp, ureg, sizeof(Ureg));
729 *(Ureg**)(sp-BY2WD) = up->ureg; /* word under Ureg is old up->ureg */
730 up->ureg = (void*)sp;
731 sp -= BY2WD+ERRMAX;
732 memmove((char*)sp, up->note[0].msg, ERRMAX);
733 sp -= 3*BY2WD;
734 *(ulong*)(sp+2*BY2WD) = sp+3*BY2WD; /* arg 2 is string */
735 *(ulong*)(sp+1*BY2WD) = (ulong)up->ureg; /* arg 1 is ureg* */
736 *(ulong*)(sp+0*BY2WD) = 0; /* arg 0 is pc */
737 ureg->sp = sp;
738 ureg->pc = (ulong)up->notify;
739 up->notified = 1;
740 up->nnote--;
741 memmove(&up->lastnote, &up->note[0], sizeof(Note));
742 memmove(&up->note[0], &up->note[1], up->nnote*sizeof(Note));
743
744 qunlock(&up->debug);
745 splx(s);
746 return 1;
747 }
748
749 /* Give enough context in the ureg to produce a kernel stack for
750 * a sleeping process
751 */
752 void
753 setkernur(Ureg *ureg, Proc *p)
754 {
755 ureg->pc = p->sched.pc;
756 ureg->sp = p->sched.sp+4;
757 ureg->r14 = (ulong)sched;
758 }
759
760 /*
761 * return the userpc the last exception happened at
762 */
763 ulong
764 userpc(void)
765 {
766 Ureg *ureg;
767
768 ureg = (Ureg*)up->dbgreg;
769 return ureg->pc;
770 }
771
772 /* This routine must save the values of registers the user is not permitted
773 * to write from devproc and then restore the saved values before returning.
774 */
775 void
776 setregisters(Ureg* ureg, char* pureg, char* uva, int n)
777 {
778 USED(ureg, pureg, uva, n);
779 }
780
781 /*
782 * this is the body for all kproc's
783 */
784 static void
785 linkproc(void)
786 {
787 spllo();
788 up->kpfun(up->kparg);
789 pexit("kproc exiting", 0);
790 }
791
792 /*
793 * setup stack and initial PC for a new kernel proc. This is architecture
794 * dependent because of the starting stack location
795 */
796 void
797 kprocchild(Proc *p, void (*func)(void*), void *arg)
798 {
799 p->sched.pc = (ulong)linkproc;
800 p->sched.sp = (ulong)p->kstack+KSTACK;
801
802 p->kpfun = func;
803 p->kparg = arg;
804 }
805
806
807 /*
808 * Craft a return frame which will cause the child to pop out of
809 * the scheduler in user mode with the return register zero. Set
810 * pc to point to a l.s return function.
811 */
812 void
813 forkchild(Proc *p, Ureg *ureg)
814 {
815 Ureg *cureg;
816
817 //print("%lud setting up for forking child %lud\n", up->pid, p->pid);
818 p->sched.sp = (ulong)p->kstack+KSTACK-sizeof(Ureg);
819 p->sched.pc = (ulong)forkret;
820
821 cureg = (Ureg*)(p->sched.sp);
822 memmove(cureg, ureg, sizeof(Ureg));
823
824 /* syscall returns 0 for child */
825 cureg->r0 = 0;
826
827 /* Things from bottom of syscall which were never executed */
828 p->psstate = 0;
829 p->insyscall = 0;
830 }
831
832 /*
833 * setup stack, initial PC, and any arch dependent regs for an execing user proc.
834 */
835 long
836 execregs(ulong entry, ulong ssize, ulong nargs)
837 {
838 ulong *sp;
839 Ureg *ureg;
840
841 sp = (ulong*)(USTKTOP - ssize);
842 *--sp = nargs;
843
844 ureg = up->dbgreg;
845 memset(ureg, 0, 15*sizeof(ulong));
846 ureg->r13 = (ulong)sp;
847 ureg->pc = entry;
848 //print("%lud: EXECREGS pc 0x%lux sp 0x%lux\n", up->pid, ureg->pc, ureg->r13);
849 return USTKTOP-sizeof(Tos); /* address of kernel/user shared data */
850 }
851
852 /*
853 * Fill in enough of Ureg to get a stack trace, and call a function.
854 * Used by debugging interface rdb.
855 */
856 void
857 callwithureg(void (*fn)(Ureg*))
858 {
859 Ureg ureg;
860 ureg.pc = getcallerpc(&fn);
861 ureg.sp = (ulong)&fn;
862 fn(&ureg);
863 }
864
865 static void
866 _dumpstack(Ureg *ureg)
867 {
868 ulong l, v, i;
869 ulong *p;
870 extern ulong etext;
871
872 if(up == 0){
873 iprint("no current proc\n");
874 return;
875 }
876
877 iprint("ktrace /kernel/path %.8lux %.8lux %.8lux\n", ureg->pc, ureg->sp, ureg->r14);
878 i = 0;
879 for(l=(ulong)&l; l<(ulong)(up->kstack+KSTACK); l+=4){
880 v = *(ulong*)l;
881 if(KTZERO < v && v < (ulong)&etext && (v&3)==0){
882 v -= 4;
883 p = (ulong*)v;
884 if((*p & 0x0f000000) == 0x0b000000){
885 iprint("%.8lux=%.8lux ", l, v);
886 i++;
887 }
888 }
889 if(i == 4){
890 i = 0;
891 iprint("\n");
892 }
893 }
894 if(i)
895 iprint("\n");
896 }
897
898 void
899 dumpstack(void)
900 {
901 callwithureg(_dumpstack);
902 }
903
904 /*
905 * pc output by ps
906 */
907 ulong
908 dbgpc(Proc *p)
909 {
910 Ureg *ureg;
911
912 ureg = p->dbgreg;
913 if(ureg == 0)
914 return 0;
915
916 return ureg->pc;
917 }
918
919 /*
920 * called in sysfile.c
921 */
922 void
923 evenaddr(ulong addr)
924 {
925 if(addr & 3){
926 postnote(up, 1, "sys: odd address", NDebug);
927 error(Ebadarg);
928 }
929 }
Cache object: 61ccc26a41fddab4db042b360c564319
|