trap.c revision 1.44
1 /* $NetBSD: trap.c,v 1.44 2007/05/18 13:32:18 skrll Exp $ */ 2 3 /*- 4 * Copyright (c) 2001, 2002 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Matthew Fredette. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 /* $OpenBSD: trap.c,v 1.30 2001/09/19 20:50:56 mickey Exp $ */ 40 41 /* 42 * Copyright (c) 1998-2000 Michael Shalayeff 43 * All rights reserved. 44 * 45 * Redistribution and use in source and binary forms, with or without 46 * modification, are permitted provided that the following conditions 47 * are met: 48 * 1. Redistributions of source code must retain the above copyright 49 * notice, this list of conditions and the following disclaimer. 50 * 2. Redistributions in binary form must reproduce the above copyright 51 * notice, this list of conditions and the following disclaimer in the 52 * documentation and/or other materials provided with the distribution. 53 * 3. All advertising materials mentioning features or use of this software 54 * must display the following acknowledgement: 55 * This product includes software developed by Michael Shalayeff. 56 * 4. The name of the author may not be used to endorse or promote products 57 * derived from this software without specific prior written permission. 58 * 59 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 60 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 61 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 62 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 63 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 64 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 65 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 66 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 67 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 68 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 69 */ 70 71 #include <sys/cdefs.h> 72 __KERNEL_RCSID(0, "$NetBSD: trap.c,v 1.44 2007/05/18 13:32:18 skrll Exp $"); 73 74 /* #define INTRDEBUG */ 75 /* #define TRAPDEBUG */ 76 /* #define USERTRACE */ 77 78 #include "opt_kgdb.h" 79 #include "opt_ktrace.h" 80 81 #include <sys/param.h> 82 #include <sys/systm.h> 83 #include <sys/kernel.h> 84 #include <sys/syscall.h> 85 #include <sys/mutex.h> 86 #ifdef KTRACE 87 #include <sys/ktrace.h> 88 #endif 89 #include <sys/proc.h> 90 #include <sys/signalvar.h> 91 #include <sys/user.h> 92 #include <sys/acct.h> 93 #include <sys/signal.h> 94 #include <sys/device.h> 95 #include <sys/pool.h> 96 #include <sys/userret.h> 97 98 #include <net/netisr.h> 99 100 #ifdef KGDB 101 #include <sys/kgdb.h> 102 #endif 103 104 #include <uvm/uvm.h> 105 106 #include <machine/iomod.h> 107 #include <machine/cpufunc.h> 108 #include <machine/reg.h> 109 #include <machine/autoconf.h> 110 111 #include <machine/db_machdep.h> 112 113 #include <hppa/hppa/machdep.h> 114 115 #include <ddb/db_output.h> 116 #include <ddb/db_interface.h> 117 118 #if defined(DEBUG) || defined(DIAGNOSTIC) 119 /* 120 * 0x6fc1000 is a stwm r1, d(sr0, sp), which is the last 121 * instruction in the function prologue that gcc -O0 uses. 122 * When we have this instruction we know the relationship 123 * between the stack pointer and the gcc -O0 frame pointer 124 * (in r3, loaded with the initial sp) for the body of a 125 * function. 126 * 127 * If the given instruction is a stwm r1, d(sr0, sp) where 128 * d > 0, we evaluate to d, else we evaluate to zero. 129 */ 130 #define STWM_R1_D_SR0_SP(inst) \ 131 (((inst) & 0xffffc001) == 0x6fc10000 ? (((inst) & 0x00003ff) >> 1) : 0) 132 #endif /* DEBUG || DIAGNOSTIC */ 133 134 const char *trap_type[] = { 135 "invalid", 136 "HPMC", 137 "power failure", 138 "recovery counter", 139 "external interrupt", 140 "LPMC", 141 "ITLB miss fault", 142 "instruction protection", 143 "Illegal instruction", 144 "break instruction", 145 "privileged operation", 146 "privileged register", 147 "overflow", 148 "conditional", 149 "assist exception", 150 "DTLB miss", 151 "ITLB non-access miss", 152 "DTLB non-access miss", 153 "data protection/rights/alignment", 154 "data break", 155 "TLB dirty", 156 "page reference", 157 "assist emulation", 158 "higher-priv transfer", 159 "lower-priv transfer", 160 "taken branch", 161 "data access rights", 162 "data protection", 163 "unaligned data ref", 164 }; 165 int trap_types = sizeof(trap_type)/sizeof(trap_type[0]); 166 167 uint8_t fpopmap[] = { 168 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 169 0x00, 0x0c, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 170 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 171 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 172 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x00, 173 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 174 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 175 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 176 }; 177 178 int want_resched; 179 volatile int astpending; 180 181 void pmap_hptdump(void); 182 void syscall(struct trapframe *, int *); 183 184 #ifdef USERTRACE 185 /* 186 * USERTRACE is a crude facility that traces the PC of 187 * a single user process. This tracing is normally 188 * activated by the dispatching of a certain syscall 189 * with certain arguments - see the activation code in 190 * syscall(). 191 */ 192 u_int rctr_next_iioq; 193 #endif 194 195 static inline void 196 userret(struct lwp *l, register_t pc, u_quad_t oticks) 197 { 198 struct proc *p = l->l_proc; 199 200 l->l_priority = l->l_usrpri; 201 if (want_resched) { 202 preempt(); 203 } 204 205 mi_userret(l); 206 207 /* 208 * If profiling, charge recent system time to the trapped pc. 209 */ 210 if (p->p_stflag & PST_PROFIL) { 211 extern int psratio; 212 213 addupc_task(l, pc, (int)(p->p_sticks - oticks) * psratio); 214 } 215 216 curcpu()->ci_schedstate.spc_curpriority = l->l_priority; 217 } 218 219 /* 220 * This handles some messy kernel debugger details. 221 * It dispatches into either kgdb or DDB, and knows 222 * about some special things to do, like skipping over 223 * break instructions and how to really set up for 224 * a single-step. 225 */ 226 #if defined(KGDB) || defined(DDB) 227 static int 228 trap_kdebug(int type, int code, struct trapframe *frame) 229 { 230 int handled; 231 u_int tf_iioq_head_old; 232 u_int tf_iioq_tail_old; 233 234 for(;;) { 235 236 /* This trap has not been handled. */ 237 handled = 0; 238 239 /* Remember the instruction offset queue. */ 240 tf_iioq_head_old = frame->tf_iioq_head; 241 tf_iioq_tail_old = frame->tf_iioq_tail; 242 243 #ifdef KGDB 244 /* Let KGDB handle it (if connected) */ 245 if (!handled) 246 handled = kgdb_trap(type, frame); 247 #endif 248 #ifdef DDB 249 /* Let DDB handle it. */ 250 if (!handled) 251 handled = kdb_trap(type, code, frame); 252 #endif 253 254 /* If this trap wasn't handled, return now. */ 255 if (!handled) 256 return(0); 257 258 /* 259 * If the instruction offset queue head changed, 260 * but the offset queue tail didn't, assume that 261 * the user wants to jump to the head offset, and 262 * adjust the tail accordingly. This should fix 263 * the kgdb `jump' command, and can help DDB users 264 * who `set' the offset head but forget the tail. 265 */ 266 if (frame->tf_iioq_head != tf_iioq_head_old && 267 frame->tf_iioq_tail == tf_iioq_tail_old) 268 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 269 270 /* 271 * This is some single-stepping support. 272 * If we're trying to step through a nullified 273 * instruction, just advance by hand and trap 274 * again. Otherwise, load the recovery counter 275 * with zero. 276 */ 277 if (frame->tf_ipsw & PSW_R) { 278 #ifdef TRAPDEBUG 279 printf("(single stepping at head 0x%x tail 0x%x)\n", 280 frame->tf_iioq_head, frame->tf_iioq_tail); 281 #endif 282 if (frame->tf_ipsw & PSW_N) { 283 #ifdef TRAPDEBUG 284 printf("(single stepping past nullified)\n"); 285 #endif 286 287 /* Advance the program counter. */ 288 frame->tf_iioq_head = frame->tf_iioq_tail; 289 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 290 291 /* Clear flags. */ 292 frame->tf_ipsw &= ~(PSW_N|PSW_X|PSW_Y|PSW_Z|PSW_B|PSW_T|PSW_H|PSW_L); 293 294 /* Simulate another trap. */ 295 type = T_RECOVERY; 296 continue; 297 } 298 frame->tf_rctr = 0; 299 } 300 301 /* We handled this trap. */ 302 return (1); 303 } 304 /* NOTREACHED */ 305 } 306 #else /* !KGDB && !DDB */ 307 #define trap_kdebug(t, c, f) (0) 308 #endif /* !KGDB && !DDB */ 309 310 #if defined(DEBUG) || defined(USERTRACE) 311 /* 312 * These functions give a crude usermode backtrace. They 313 * really only work when code has been compiled without 314 * optimization, as they assume a certain function prologue 315 * sets up a frame pointer and stores the return pointer 316 * and arguments in it. 317 */ 318 static void user_backtrace_raw(u_int, u_int); 319 static void 320 user_backtrace_raw(u_int pc, u_int fp) 321 { 322 int frame_number; 323 int arg_number; 324 325 for (frame_number = 0; 326 frame_number < 100 && pc > HPPA_PC_PRIV_MASK && fp; 327 frame_number++) { 328 329 printf("%3d: pc=%08x%s fp=0x%08x", frame_number, 330 pc & ~HPPA_PC_PRIV_MASK, USERMODE(pc) ? " " : "**", fp); 331 for(arg_number = 0; arg_number < 4; arg_number++) 332 printf(" arg%d=0x%08x", arg_number, 333 (int) fuword(HPPA_FRAME_CARG(arg_number, fp))); 334 printf("\n"); 335 pc = fuword(((register_t *) fp) - 5); /* fetch rp */ 336 if (pc == -1) { 337 printf(" fuword for pc failed\n"); 338 break; 339 } 340 fp = fuword(((register_t *) fp) + 0); /* fetch previous fp */ 341 if (fp == -1) { 342 printf(" fuword for fp failed\n"); 343 break; 344 } 345 } 346 printf(" backtrace stopped with pc %08x fp 0x%08x\n", pc, fp); 347 } 348 349 static void user_backtrace(struct trapframe *, struct lwp *, int); 350 static void 351 user_backtrace(struct trapframe *tf, struct lwp *l, int type) 352 { 353 struct proc *p = l->l_proc; 354 u_int pc, fp, inst; 355 356 /* 357 * Display any trap type that we have. 358 */ 359 if (type >= 0) 360 printf("pid %d (%s) trap #%d\n", 361 p->p_pid, p->p_comm, type & ~T_USER); 362 363 /* 364 * Assuming that the frame pointer in r3 is valid, 365 * dump out a stack trace. 366 */ 367 fp = tf->tf_r3; 368 printf("pid %d (%s) backtrace, starting with fp 0x%08x\n", 369 p->p_pid, p->p_comm, fp); 370 user_backtrace_raw(tf->tf_iioq_head, fp); 371 372 /* 373 * In case the frame pointer in r3 is not valid, 374 * assuming the stack pointer is valid and the 375 * faulting function is a non-leaf, if we can 376 * find its prologue we can recover its frame 377 * pointer. 378 */ 379 pc = tf->tf_iioq_head; 380 fp = tf->tf_sp - HPPA_FRAME_SIZE; 381 printf("pid %d (%s) backtrace, starting with sp 0x%08x pc 0x%08x\n", 382 p->p_pid, p->p_comm, tf->tf_sp, pc); 383 for (pc &= ~HPPA_PC_PRIV_MASK; pc > 0; pc -= sizeof(inst)) { 384 inst = fuword((register_t *) pc); 385 if (inst == -1) { 386 printf(" fuword for inst at pc %08x failed\n", pc); 387 break; 388 } 389 /* Check for the prologue instruction that sets sp. */ 390 if (STWM_R1_D_SR0_SP(inst)) { 391 fp = tf->tf_sp - STWM_R1_D_SR0_SP(inst); 392 printf(" sp from fp at pc %08x: %08x\n", pc, inst); 393 break; 394 } 395 } 396 user_backtrace_raw(tf->tf_iioq_head, fp); 397 } 398 #endif /* DEBUG || USERTRACE */ 399 400 #ifdef DEBUG 401 /* 402 * This sanity-checks a trapframe. It is full of various 403 * assumptions about what a healthy CPU state should be, 404 * with some documented elsewhere, some not. 405 */ 406 struct trapframe *sanity_frame; 407 struct lwp *sanity_lwp; 408 int sanity_checked = 0; 409 void frame_sanity_check(int, int, struct trapframe *, struct lwp *); 410 void 411 frame_sanity_check(int where, int type, struct trapframe *tf, struct lwp *l) 412 { 413 extern int kernel_text; 414 extern int etext; 415 extern register_t kpsw; 416 extern vaddr_t hpt_base; 417 extern vsize_t hpt_mask; 418 #define SANITY(e) \ 419 do { \ 420 if (sanity_frame == NULL && !(e)) { \ 421 sanity_frame = tf; \ 422 sanity_lwp = l; \ 423 sanity_checked = __LINE__; \ 424 } \ 425 } while (/* CONSTCOND */ 0) 426 427 SANITY((tf->tf_ipsw & kpsw) == kpsw); 428 SANITY(tf->tf_hptm == hpt_mask && tf->tf_vtop == hpt_base); 429 SANITY((kpsw & PSW_I) == 0 || tf->tf_eiem != 0); 430 if (tf->tf_iisq_head == HPPA_SID_KERNEL) { 431 /* 432 * If the trap happened in the gateway 433 * page, we take the easy way out and 434 * assume that the trapframe is okay. 435 */ 436 if ((tf->tf_iioq_head & ~PAGE_MASK) != SYSCALLGATE) { 437 SANITY(!USERMODE(tf->tf_iioq_head)); 438 SANITY(!USERMODE(tf->tf_iioq_tail)); 439 SANITY(tf->tf_iioq_head >= (u_int) &kernel_text); 440 SANITY(tf->tf_iioq_head < (u_int) &etext); 441 SANITY(tf->tf_iioq_tail >= (u_int) &kernel_text); 442 SANITY(tf->tf_iioq_tail < (u_int) &etext); 443 if ((type & ~T_USER) != T_INTERRUPT) { 444 vaddr_t minsp, maxsp; 445 446 #ifdef HPPA_REDZONE 447 maxsp = (u_int)(l->l_addr) + 448 HPPA_REDZONE; 449 #else 450 maxsp = (u_int)(l->l_addr) + 451 USPACE; 452 #endif 453 minsp = (u_int)(l->l_addr) + PAGE_SIZE; 454 455 SANITY(l == NULL || 456 (tf->tf_sp >= minsp && tf->tf_sp < maxsp)); 457 } 458 } 459 } else { 460 SANITY(USERMODE(tf->tf_iioq_head)); 461 SANITY(USERMODE(tf->tf_iioq_tail)); 462 SANITY(l != NULL && tf->tf_cr30 == kvtop((void *)l->l_addr)); 463 } 464 #undef SANITY 465 if (sanity_frame == tf) { 466 printf("insanity: where 0x%x type 0x%x tf %p lwp %p line %d " 467 "sp 0x%x pc 0x%x\n", 468 where, type, sanity_frame, sanity_lwp, sanity_checked, 469 tf->tf_sp, tf->tf_iioq_head); 470 (void) trap_kdebug(T_IBREAK, 0, tf); 471 sanity_frame = NULL; 472 sanity_lwp = NULL; 473 sanity_checked = 0; 474 } 475 } 476 #endif /* DEBUG */ 477 478 void 479 trap(int type, struct trapframe *frame) 480 { 481 struct lwp *l; 482 struct proc *p; 483 struct pcb *pcbp; 484 vaddr_t va; 485 struct vm_map *map; 486 struct vmspace *vm; 487 vm_prot_t vftype; 488 pa_space_t space; 489 ksiginfo_t ksi; 490 u_int opcode, onfault; 491 int ret; 492 const char *tts; 493 int type_raw; 494 #ifdef DIAGNOSTIC 495 extern int emergency_stack_start, emergency_stack_end; 496 #endif 497 498 type_raw = type & ~T_USER; 499 opcode = frame->tf_iir; 500 if (type_raw == T_ITLBMISS || type_raw == T_ITLBMISSNA) { 501 va = frame->tf_iioq_head; 502 space = frame->tf_iisq_head; 503 vftype = VM_PROT_EXECUTE; 504 } else { 505 va = frame->tf_ior; 506 space = frame->tf_isr; 507 vftype = inst_store(opcode) ? VM_PROT_WRITE : VM_PROT_READ; 508 } 509 510 l = curlwp; 511 p = l ? l->l_proc : NULL; 512 if ((type & T_USER) != 0) 513 LWP_CACHE_CREDS(l, p); 514 515 tts = (type & ~T_USER) > trap_types ? "reserved" : 516 trap_type[type & ~T_USER]; 517 518 #ifdef DIAGNOSTIC 519 /* 520 * If we are on the emergency stack, then we either got 521 * a fault on the kernel stack, or we're just handling 522 * a trap for the machine check handler (which also 523 * runs on the emergency stack). 524 * 525 * We *very crudely* differentiate between the two cases 526 * by checking the faulting instruction: if it is the 527 * function prologue instruction that stores the old 528 * frame pointer and updates the stack pointer, we assume 529 * that we faulted on the kernel stack. 530 * 531 * In this case, not completing that instruction will 532 * probably confuse backtraces in kgdb/ddb. Completing 533 * it would be difficult, because we already faulted on 534 * that part of the stack, so instead we fix up the 535 * frame as if the function called has just returned. 536 * This has peculiar knowledge about what values are in 537 * what registers during the "normal gcc -g" prologue. 538 */ 539 if (&type >= &emergency_stack_start && 540 &type < &emergency_stack_end && 541 type != T_IBREAK && STWM_R1_D_SR0_SP(opcode)) { 542 /* Restore the caller's frame pointer. */ 543 frame->tf_r3 = frame->tf_r1; 544 /* Restore the caller's instruction offsets. */ 545 frame->tf_iioq_head = frame->tf_rp; 546 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 547 goto dead_end; 548 } 549 #endif /* DIAGNOSTIC */ 550 551 #ifdef DEBUG 552 frame_sanity_check(0xdead01, type, frame, l); 553 #endif /* DEBUG */ 554 555 /* If this is a trap, not an interrupt, reenable interrupts. */ 556 if (type_raw != T_INTERRUPT) 557 mtctl(frame->tf_eiem, CR_EIEM); 558 559 if (frame->tf_flags & TFF_LAST) 560 l->l_md.md_regs = frame; 561 562 #ifdef TRAPDEBUG 563 if (type_raw != T_INTERRUPT && type_raw != T_IBREAK) 564 printf("trap: %d, %s for %x:%x at %x:%x, fp=%p, rp=%x\n", 565 type, tts, space, (u_int)va, frame->tf_iisq_head, 566 frame->tf_iioq_head, frame, frame->tf_rp); 567 else if (type_raw == T_IBREAK) 568 printf("trap: break instruction %x:%x at %x:%x, fp=%p\n", 569 break5(opcode), break13(opcode), 570 frame->tf_iisq_head, frame->tf_iioq_head, frame); 571 572 { 573 extern int etext; 574 if (frame < (struct trapframe *)&etext) { 575 printf("trap: bogus frame ptr %p\n", frame); 576 goto dead_end; 577 } 578 } 579 #endif 580 switch (type) { 581 case T_NONEXIST: 582 case T_NONEXIST|T_USER: 583 #if !defined(DDB) && !defined(KGDB) 584 /* we've got screwed up by the central scrutinizer */ 585 panic ("trap: elvis has just left the building!"); 586 break; 587 #else 588 goto dead_end; 589 #endif 590 case T_RECOVERY|T_USER: 591 #ifdef USERTRACE 592 for(;;) { 593 if (frame->tf_iioq_head != rctr_next_iioq) 594 printf("-%08x\nr %08x", 595 rctr_next_iioq - 4, 596 frame->tf_iioq_head); 597 rctr_next_iioq = frame->tf_iioq_head + 4; 598 if (frame->tf_ipsw & PSW_N) { 599 /* Advance the program counter. */ 600 frame->tf_iioq_head = frame->tf_iioq_tail; 601 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 602 /* Clear flags. */ 603 frame->tf_ipsw &= ~(PSW_N|PSW_X|PSW_Y|PSW_Z|PSW_B|PSW_T|PSW_H|PSW_L); 604 /* Simulate another trap. */ 605 continue; 606 } 607 break; 608 } 609 frame->tf_rctr = 0; 610 break; 611 #endif /* USERTRACE */ 612 case T_RECOVERY: 613 #if !defined(DDB) && !defined(KGDB) 614 /* XXX will implement later */ 615 printf ("trap: handicapped"); 616 break; 617 #else 618 goto dead_end; 619 #endif 620 621 case T_EMULATION | T_USER: 622 #ifdef FPEMUL 623 hppa_fpu_emulate(frame, l, opcode); 624 #else /* !FPEMUL */ 625 /* 626 * We don't have FPU emulation, so signal the 627 * process with a SIGFPE. 628 */ 629 630 KSI_INIT_TRAP(&ksi); 631 ksi.ksi_signo = SIGFPE; 632 ksi.ksi_code = SI_NOINFO; 633 ksi.ksi_trap = type; 634 ksi.ksi_addr = (void *)frame->tf_iioq_head; 635 trapsignal(l, &ksi); 636 #endif /* !FPEMUL */ 637 break; 638 639 case T_DATALIGN: 640 if (l->l_addr->u_pcb.pcb_onfault) { 641 do_onfault: 642 pcbp = &l->l_addr->u_pcb; 643 frame->tf_iioq_tail = 4 + 644 (frame->tf_iioq_head = 645 pcbp->pcb_onfault); 646 pcbp->pcb_onfault = 0; 647 break; 648 } 649 /*FALLTHROUGH*/ 650 651 #ifdef DIAGNOSTIC 652 /* these just can't happen ever */ 653 case T_PRIV_OP: 654 case T_PRIV_REG: 655 /* these just can't make it to the trap() ever */ 656 case T_HPMC: 657 case T_HPMC | T_USER: 658 case T_EMULATION: 659 case T_EXCEPTION: 660 #endif 661 case T_IBREAK: 662 case T_DBREAK: 663 dead_end: 664 if (type & T_USER) { 665 #ifdef DEBUG 666 user_backtrace(frame, l, type); 667 #endif 668 KSI_INIT_TRAP(&ksi); 669 ksi.ksi_signo = SIGILL; 670 ksi.ksi_code = ILL_ILLTRP; 671 ksi.ksi_trap = type; 672 ksi.ksi_addr = (void *)frame->tf_iioq_head; 673 trapsignal(l, &ksi); 674 break; 675 } 676 if (trap_kdebug(type, va, frame)) 677 return; 678 else if (type == T_DATALIGN) 679 panic ("trap: %s at 0x%x", tts, (u_int) va); 680 else 681 panic ("trap: no debugger for \"%s\" (%d)", tts, type); 682 break; 683 684 case T_IBREAK | T_USER: 685 case T_DBREAK | T_USER: 686 /* pass to user debugger */ 687 break; 688 689 case T_EXCEPTION | T_USER: { /* co-proc assist trap */ 690 uint64_t *fpp; 691 uint32_t *pex, ex, inst; 692 int i; 693 694 hppa_fpu_flush(l); 695 fpp = l->l_addr->u_pcb.pcb_fpregs; 696 pex = (uint32_t *)&fpp[1]; 697 for (i = 1; i < 8 && !*pex; i++, pex++) 698 ; 699 KASSERT(i < 8); 700 ex = *pex; 701 *pex = 0; 702 703 /* reset the trap flag, as if there was none */ 704 fpp[0] &= ~(((uint64_t)HPPA_FPU_T) << 32); 705 706 /* emulate the instruction */ 707 inst = ((uint32_t)fpopmap[ex >> 26] << 26) | (ex & 0x03ffffff); 708 hppa_fpu_emulate(frame, l, inst); 709 } 710 break; 711 712 case T_OVERFLOW | T_USER: 713 KSI_INIT_TRAP(&ksi); 714 ksi.ksi_signo = SIGFPE; 715 ksi.ksi_code = SI_NOINFO; 716 ksi.ksi_trap = type; 717 ksi.ksi_addr = (void *)va; 718 trapsignal(l, &ksi); 719 break; 720 721 case T_CONDITION | T_USER: 722 KSI_INIT_TRAP(&ksi); 723 ksi.ksi_signo = SIGFPE; 724 ksi.ksi_code = FPE_INTDIV; 725 ksi.ksi_trap = type; 726 ksi.ksi_addr = (void *)va; 727 trapsignal(l, &ksi); 728 break; 729 730 case T_ILLEGAL | T_USER: 731 #ifdef DEBUG 732 user_backtrace(frame, l, type); 733 #endif 734 KSI_INIT_TRAP(&ksi); 735 ksi.ksi_signo = SIGILL; 736 ksi.ksi_code = ILL_ILLOPC; 737 ksi.ksi_trap = type; 738 ksi.ksi_addr = (void *)va; 739 trapsignal(l, &ksi); 740 break; 741 742 case T_PRIV_OP | T_USER: 743 #ifdef DEBUG 744 user_backtrace(frame, l, type); 745 #endif 746 KSI_INIT_TRAP(&ksi); 747 ksi.ksi_signo = SIGILL; 748 ksi.ksi_code = ILL_PRVOPC; 749 ksi.ksi_trap = type; 750 ksi.ksi_addr = (void *)va; 751 trapsignal(l, &ksi); 752 break; 753 754 case T_PRIV_REG | T_USER: 755 #ifdef DEBUG 756 user_backtrace(frame, l, type); 757 #endif 758 KSI_INIT_TRAP(&ksi); 759 ksi.ksi_signo = SIGILL; 760 ksi.ksi_code = ILL_PRVREG; 761 ksi.ksi_trap = type; 762 ksi.ksi_addr = (void *)va; 763 trapsignal(l, &ksi); 764 break; 765 766 /* these should never got here */ 767 case T_HIGHERPL | T_USER: 768 case T_LOWERPL | T_USER: 769 KSI_INIT_TRAP(&ksi); 770 ksi.ksi_signo = SIGSEGV; 771 ksi.ksi_code = SEGV_ACCERR; 772 ksi.ksi_trap = type; 773 ksi.ksi_addr = (void *)va; 774 trapsignal(l, &ksi); 775 break; 776 777 case T_IPROT | T_USER: 778 case T_DPROT | T_USER: 779 KSI_INIT_TRAP(&ksi); 780 ksi.ksi_signo = SIGSEGV; 781 ksi.ksi_code = SEGV_ACCERR; 782 ksi.ksi_trap = type; 783 ksi.ksi_addr = (void *)va; 784 trapsignal(l, &ksi); 785 break; 786 787 case T_DATACC: case T_USER | T_DATACC: 788 case T_ITLBMISS: case T_USER | T_ITLBMISS: 789 case T_DTLBMISS: case T_USER | T_DTLBMISS: 790 case T_ITLBMISSNA: case T_USER | T_ITLBMISSNA: 791 case T_DTLBMISSNA: case T_USER | T_DTLBMISSNA: 792 case T_TLB_DIRTY: case T_USER | T_TLB_DIRTY: 793 vm = p->p_vmspace; 794 795 if (!vm) { 796 #ifdef TRAPDEBUG 797 printf("trap: no vm, p=%p\n", p); 798 #endif 799 goto dead_end; 800 } 801 802 /* 803 * it could be a kernel map for exec_map faults 804 */ 805 if (!(type & T_USER) && space == HPPA_SID_KERNEL) 806 map = kernel_map; 807 else 808 map = &vm->vm_map; 809 810 va = trunc_page(va); 811 812 if (map->pmap->pmap_space != space) { 813 #ifdef TRAPDEBUG 814 printf("trap: space mismatch %d != %d\n", 815 space, map->pmap->pmap_space); 816 #endif 817 /* actually dump the user, crap the kernel */ 818 goto dead_end; 819 } 820 821 /* Never call uvm_fault in interrupt context. */ 822 KASSERT(hppa_intr_depth == 0); 823 824 onfault = l->l_addr->u_pcb.pcb_onfault; 825 l->l_addr->u_pcb.pcb_onfault = 0; 826 ret = uvm_fault(map, va, vftype); 827 l->l_addr->u_pcb.pcb_onfault = onfault; 828 829 #ifdef TRAPDEBUG 830 printf("uvm_fault(%p, %x, %d)=%d\n", 831 map, (u_int)va, vftype, ret); 832 #endif 833 834 /* 835 * If this was a stack access we keep track of the maximum 836 * accessed stack size. Also, if uvm_fault gets a protection 837 * failure it is due to accessing the stack region outside 838 * the current limit and we need to reflect that as an access 839 * error. 840 */ 841 if (map != kernel_map && va >= (vaddr_t)vm->vm_minsaddr) { 842 if (ret == 0) 843 uvm_grow(l->l_proc, va); 844 else if (ret == EACCES) 845 ret = EFAULT; 846 } 847 848 if (ret != 0) { 849 if (type & T_USER) { 850 #ifdef DEBUG 851 user_backtrace(frame, l, type); 852 #endif 853 KSI_INIT_TRAP(&ksi); 854 ksi.ksi_signo = SIGSEGV; 855 ksi.ksi_code = (ret == EACCES ? 856 SEGV_ACCERR : SEGV_MAPERR); 857 ksi.ksi_trap = type; 858 ksi.ksi_addr = (void *)va; 859 trapsignal(l, &ksi); 860 } else { 861 if (l->l_addr->u_pcb.pcb_onfault) { 862 goto do_onfault; 863 } 864 panic("trap: uvm_fault(%p, %lx, %d): %d", 865 map, va, vftype, ret); 866 } 867 } 868 break; 869 870 case T_DATALIGN | T_USER: 871 #ifdef DEBUG 872 user_backtrace(frame, l, type); 873 #endif 874 KSI_INIT_TRAP(&ksi); 875 ksi.ksi_signo = SIGBUS; 876 ksi.ksi_code = BUS_ADRALN; 877 ksi.ksi_trap = type; 878 ksi.ksi_addr = (void *)va; 879 trapsignal(l, &ksi); 880 break; 881 882 case T_INTERRUPT: 883 case T_INTERRUPT|T_USER: 884 hppa_intr(frame); 885 mtctl(frame->tf_eiem, CR_EIEM); 886 break; 887 888 case T_LOWERPL: 889 case T_DPROT: 890 case T_IPROT: 891 case T_OVERFLOW: 892 case T_CONDITION: 893 case T_ILLEGAL: 894 case T_HIGHERPL: 895 case T_TAKENBR: 896 case T_POWERFAIL: 897 case T_LPMC: 898 case T_PAGEREF: 899 case T_DATAPID: case T_DATAPID | T_USER: 900 if (0 /* T-chip */) { 901 break; 902 } 903 /* FALLTHROUGH to unimplemented */ 904 default: 905 panic ("trap: unimplemented \'%s\' (%d)", tts, type); 906 } 907 908 if (type & T_USER) 909 userret(l, l->l_md.md_regs->tf_iioq_head, 0); 910 911 #ifdef DEBUG 912 frame_sanity_check(0xdead02, type, frame, l); 913 if (frame->tf_flags & TFF_LAST && (curlwp->l_flag & LW_IDLE) == 0) 914 frame_sanity_check(0xdead03, type, curlwp->l_md.md_regs, 915 curlwp); 916 #endif /* DEBUG */ 917 } 918 919 void 920 child_return(void *arg) 921 { 922 struct lwp *l = arg; 923 #ifdef KTRACE 924 struct proc *p = l->l_proc; 925 #endif 926 927 userret(l, l->l_md.md_regs->tf_iioq_head, 0); 928 #ifdef KTRACE 929 if (KTRPOINT(p, KTR_SYSRET)) 930 ktrsysret(l, SYS_fork, 0, 0); 931 #endif 932 #ifdef DEBUG 933 frame_sanity_check(0xdead04, 0, l->l_md.md_regs, l); 934 #endif /* DEBUG */ 935 } 936 937 /* 938 * call actual syscall routine 939 * from the low-level syscall handler: 940 * - all HPPA_FRAME_NARGS syscall's arguments supposed to be copied onto 941 * our stack, this wins compared to copyin just needed amount anyway 942 * - register args are copied onto stack too 943 */ 944 void 945 syscall(struct trapframe *frame, int *args) 946 { 947 struct lwp *l; 948 struct proc *p; 949 const struct sysent *callp; 950 int nsys, code, argsize, error; 951 int tmp; 952 int rval[2]; 953 954 uvmexp.syscalls++; 955 956 #ifdef DEBUG 957 frame_sanity_check(0xdead04, 0, frame, curlwp); 958 #endif /* DEBUG */ 959 960 if (!USERMODE(frame->tf_iioq_head)) 961 panic("syscall"); 962 963 l = curlwp; 964 p = l->l_proc; 965 l->l_md.md_regs = frame; 966 nsys = p->p_emul->e_nsysent; 967 callp = p->p_emul->e_sysent; 968 code = frame->tf_t1; 969 LWP_CACHE_CREDS(l, p); 970 971 /* 972 * Restarting a system call is touchy on the HPPA, 973 * because syscall arguments are passed in registers 974 * and the program counter of the syscall "point" 975 * isn't easily divined. 976 * 977 * We handle the first problem by assuming that we 978 * will have to restart this system call, so we 979 * stuff the first four words of the original arguments 980 * back into the frame as arg0...arg3, which is where 981 * we found them in the first place. Any further 982 * arguments are (still) on the user's stack and the 983 * syscall code will fetch them from there (again). 984 * 985 * The program counter problem is addressed below. 986 */ 987 frame->tf_arg0 = args[0]; 988 frame->tf_arg1 = args[1]; 989 frame->tf_arg2 = args[2]; 990 frame->tf_arg3 = args[3]; 991 992 /* 993 * Some special handling for the syscall(2) and 994 * __syscall(2) system calls. 995 */ 996 switch (code) { 997 case SYS_syscall: 998 code = *args; 999 args += 1; 1000 break; 1001 case SYS___syscall: 1002 if (callp != sysent) 1003 break; 1004 /* 1005 * NB: even though __syscall(2) takes a quad_t 1006 * containing the system call number, because 1007 * our argument copying word-swaps 64-bit arguments, 1008 * the least significant word of that quad_t 1009 * is the first word in the argument array. 1010 */ 1011 code = *args; 1012 args += 2; 1013 } 1014 1015 /* 1016 * Stacks growing from lower addresses to higher 1017 * addresses are not really such a good idea, because 1018 * it makes it impossible to overlay a struct on top 1019 * of C stack arguments (the arguments appear in 1020 * reversed order). 1021 * 1022 * You can do the obvious thing (as locore.S does) and 1023 * copy argument words one by one, laying them out in 1024 * the "right" order in the destination buffer, but this 1025 * ends up word-swapping multi-word arguments (like off_t). 1026 * 1027 * To compensate, we have some automatically-generated 1028 * code that word-swaps these multi-word arguments. 1029 * Right now the script that generates this code is 1030 * in Perl, because I don't know awk. 1031 * 1032 * FIXME - this works only on native binaries and 1033 * will probably screw up any and all emulation. 1034 */ 1035 switch (code) { 1036 /* 1037 * BEGIN automatically generated 1038 * by /home/fredette/project/hppa/makescargfix.pl 1039 * do not edit! 1040 */ 1041 case SYS_pread: 1042 /* 1043 * syscallarg(int) fd; 1044 * syscallarg(void *) buf; 1045 * syscallarg(size_t) nbyte; 1046 * syscallarg(int) pad; 1047 * syscallarg(off_t) offset; 1048 */ 1049 tmp = args[4]; 1050 args[4] = args[4 + 1]; 1051 args[4 + 1] = tmp; 1052 break; 1053 case SYS_pwrite: 1054 /* 1055 * syscallarg(int) fd; 1056 * syscallarg(const void *) buf; 1057 * syscallarg(size_t) nbyte; 1058 * syscallarg(int) pad; 1059 * syscallarg(off_t) offset; 1060 */ 1061 tmp = args[4]; 1062 args[4] = args[4 + 1]; 1063 args[4 + 1] = tmp; 1064 break; 1065 case SYS_mmap: 1066 /* 1067 * syscallarg(void *) addr; 1068 * syscallarg(size_t) len; 1069 * syscallarg(int) prot; 1070 * syscallarg(int) flags; 1071 * syscallarg(int) fd; 1072 * syscallarg(long) pad; 1073 * syscallarg(off_t) pos; 1074 */ 1075 tmp = args[6]; 1076 args[6] = args[6 + 1]; 1077 args[6 + 1] = tmp; 1078 break; 1079 case SYS_lseek: 1080 /* 1081 * syscallarg(int) fd; 1082 * syscallarg(int) pad; 1083 * syscallarg(off_t) offset; 1084 */ 1085 tmp = args[2]; 1086 args[2] = args[2 + 1]; 1087 args[2 + 1] = tmp; 1088 break; 1089 case SYS_truncate: 1090 /* 1091 * syscallarg(const char *) path; 1092 * syscallarg(int) pad; 1093 * syscallarg(off_t) length; 1094 */ 1095 tmp = args[2]; 1096 args[2] = args[2 + 1]; 1097 args[2 + 1] = tmp; 1098 break; 1099 case SYS_ftruncate: 1100 /* 1101 * syscallarg(int) fd; 1102 * syscallarg(int) pad; 1103 * syscallarg(off_t) length; 1104 */ 1105 tmp = args[2]; 1106 args[2] = args[2 + 1]; 1107 args[2 + 1] = tmp; 1108 break; 1109 case SYS_preadv: 1110 /* 1111 * syscallarg(int) fd; 1112 * syscallarg(const struct iovec *) iovp; 1113 * syscallarg(int) iovcnt; 1114 * syscallarg(int) pad; 1115 * syscallarg(off_t) offset; 1116 */ 1117 tmp = args[4]; 1118 args[4] = args[4 + 1]; 1119 args[4 + 1] = tmp; 1120 break; 1121 case SYS_pwritev: 1122 /* 1123 * syscallarg(int) fd; 1124 * syscallarg(const struct iovec *) iovp; 1125 * syscallarg(int) iovcnt; 1126 * syscallarg(int) pad; 1127 * syscallarg(off_t) offset; 1128 */ 1129 tmp = args[4]; 1130 args[4] = args[4 + 1]; 1131 args[4 + 1] = tmp; 1132 break; 1133 default: 1134 break; 1135 /* 1136 * END automatically generated 1137 * by /home/fredette/project/hppa/makescargfix.pl 1138 * do not edit! 1139 */ 1140 } 1141 1142 #ifdef USERTRACE 1143 if (0) { 1144 user_backtrace(frame, l, -1); 1145 frame->tf_ipsw |= PSW_R; 1146 frame->tf_rctr = 0; 1147 printf("r %08x", frame->tf_iioq_head); 1148 rctr_next_iioq = frame->tf_iioq_head + 4; 1149 } 1150 #endif 1151 1152 if (code < 0 || code >= nsys) 1153 callp += p->p_emul->e_nosys; /* bad syscall # */ 1154 else 1155 callp += code; 1156 argsize = callp->sy_argsize; 1157 1158 if ((error = trace_enter(l, code, code, NULL, args)) != 0) 1159 goto out; 1160 1161 rval[0] = 0; 1162 rval[1] = 0; 1163 error = (*callp->sy_call)(l, args, rval); 1164 out: 1165 switch (error) { 1166 case 0: 1167 l = curlwp; /* changes on exec() */ 1168 frame = l->l_md.md_regs; 1169 frame->tf_ret0 = rval[0]; 1170 frame->tf_ret1 = rval[1]; 1171 frame->tf_t1 = 0; 1172 break; 1173 case ERESTART: 1174 /* 1175 * Now we have to wind back the instruction 1176 * offset queue to the point where the system 1177 * call will be made again. This is inherently 1178 * tied to the SYSCALL macro. 1179 * 1180 * Currently, the part of the SYSCALL macro 1181 * that we want to rerun reads as: 1182 * 1183 * ldil L%SYSCALLGATE, r1 1184 * ble 4(sr7, r1) 1185 * ldi __CONCAT(SYS_,x), t1 1186 * ldw HPPA_FRAME_ERP(sr0,sp), rp 1187 * 1188 * And our offset queue head points to the 1189 * final ldw instruction. So we need to 1190 * subtract twelve to reach the ldil. 1191 */ 1192 frame->tf_iioq_head -= 12; 1193 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 1194 break; 1195 case EJUSTRETURN: 1196 p = curproc; 1197 break; 1198 default: 1199 if (p->p_emul->e_errno) 1200 error = p->p_emul->e_errno[error]; 1201 frame->tf_t1 = error; 1202 break; 1203 } 1204 1205 trace_exit(l, code, args, rval, error); 1206 1207 userret(l, frame->tf_iioq_head, 0); 1208 #ifdef DEBUG 1209 frame_sanity_check(0xdead05, 0, frame, l); 1210 #endif /* DEBUG */ 1211 } 1212 1213 /* 1214 * Start a new LWP 1215 */ 1216 void 1217 startlwp(void *arg) 1218 { 1219 int err; 1220 ucontext_t *uc = arg; 1221 struct lwp *l = curlwp; 1222 1223 err = cpu_setmcontext(l, &uc->uc_mcontext, uc->uc_flags); 1224 #if DIAGNOSTIC 1225 if (err) { 1226 printf("Error %d from cpu_setmcontext.", err); 1227 } 1228 #endif 1229 pool_put(&lwp_uc_pool, uc); 1230 1231 userret(l, l->l_md.md_regs->tf_iioq_head, 0); 1232 } 1233
Indexes created Tue Sep 30 06:09:59 GMT 2025