trap.c revision 1.35
1 /* $NetBSD: trap.c,v 1.35 2006/07/07 09:38:47 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.35 2006/07/07 09:38:47 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/sa.h> 86 #include <sys/savar.h> 87 #ifdef KTRACE 88 #include <sys/ktrace.h> 89 #endif 90 #include <sys/proc.h> 91 #include <sys/signalvar.h> 92 #include <sys/user.h> 93 #include <sys/acct.h> 94 #include <sys/signal.h> 95 #include <sys/device.h> 96 #include <sys/pool.h> 97 #include <sys/userret.h> 98 99 #include <net/netisr.h> 100 101 #ifdef KGDB 102 #include <sys/kgdb.h> 103 #endif 104 105 #include <uvm/uvm.h> 106 107 #include <machine/iomod.h> 108 #include <machine/cpufunc.h> 109 #include <machine/reg.h> 110 #include <machine/autoconf.h> 111 112 #include <machine/db_machdep.h> 113 114 #include <hppa/hppa/machdep.h> 115 116 #include <ddb/db_output.h> 117 #include <ddb/db_interface.h> 118 119 #if defined(DEBUG) || defined(DIAGNOSTIC) 120 /* 121 * 0x6fc1000 is a stwm r1, d(sr0, sp), which is the last 122 * instruction in the function prologue that gcc -O0 uses. 123 * When we have this instruction we know the relationship 124 * between the stack pointer and the gcc -O0 frame pointer 125 * (in r3, loaded with the initial sp) for the body of a 126 * function. 127 * 128 * If the given instruction is a stwm r1, d(sr0, sp) where 129 * d > 0, we evaluate to d, else we evaluate to zero. 130 */ 131 #define STWM_R1_D_SR0_SP(inst) \ 132 (((inst) & 0xffffc001) == 0x6fc10000 ? (((inst) & 0x00003ff) >> 1) : 0) 133 #endif /* DEBUG || DIAGNOSTIC */ 134 135 const char *trap_type[] = { 136 "invalid", 137 "HPMC", 138 "power failure", 139 "recovery counter", 140 "external interrupt", 141 "LPMC", 142 "ITLB miss fault", 143 "instruction protection", 144 "Illegal instruction", 145 "break instruction", 146 "privileged operation", 147 "privileged register", 148 "overflow", 149 "conditional", 150 "assist exception", 151 "DTLB miss", 152 "ITLB non-access miss", 153 "DTLB non-access miss", 154 "data protection/rights/alignment", 155 "data break", 156 "TLB dirty", 157 "page reference", 158 "assist emulation", 159 "higher-priv transfer", 160 "lower-priv transfer", 161 "taken branch", 162 "data access rights", 163 "data protection", 164 "unaligned data ref", 165 }; 166 int trap_types = sizeof(trap_type)/sizeof(trap_type[0]); 167 168 uint8_t fpopmap[] = { 169 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 170 0x00, 0x0c, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 171 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 172 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 173 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x00, 174 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 175 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 176 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 177 }; 178 179 int want_resched; 180 volatile int astpending; 181 182 void pmap_hptdump(void); 183 void syscall(struct trapframe *, int *); 184 185 #ifdef USERTRACE 186 /* 187 * USERTRACE is a crude facility that traces the PC of 188 * a single user process. This tracing is normally 189 * activated by the dispatching of a certain syscall 190 * with certain arguments - see the activation code in 191 * syscall(). 192 */ 193 u_int rctr_next_iioq; 194 #endif 195 196 static inline void 197 userret(struct lwp *l, register_t pc, u_quad_t oticks) 198 { 199 struct proc *p = l->l_proc; 200 201 l->l_priority = l->l_usrpri; 202 if (want_resched) { 203 preempt(0); 204 } 205 206 mi_userret(l); 207 208 /* 209 * If profiling, charge recent system time to the trapped pc. 210 */ 211 if (p->p_flag & P_PROFIL) { 212 extern int psratio; 213 214 addupc_task(p, pc, (int)(p->p_sticks - oticks) * psratio); 215 } 216 217 curcpu()->ci_schedstate.spc_curpriority = l->l_priority; 218 } 219 220 /* 221 * This handles some messy kernel debugger details. 222 * It dispatches into either kgdb or DDB, and knows 223 * about some special things to do, like skipping over 224 * break instructions and how to really set up for 225 * a single-step. 226 */ 227 #if defined(KGDB) || defined(DDB) 228 static int 229 trap_kdebug(int type, int code, struct trapframe *frame) 230 { 231 int handled; 232 u_int tf_iioq_head_old; 233 u_int tf_iioq_tail_old; 234 235 for(;;) { 236 237 /* This trap has not been handled. */ 238 handled = 0; 239 240 /* Remember the instruction offset queue. */ 241 tf_iioq_head_old = frame->tf_iioq_head; 242 tf_iioq_tail_old = frame->tf_iioq_tail; 243 244 #ifdef KGDB 245 /* Let KGDB handle it (if connected) */ 246 if (!handled) 247 handled = kgdb_trap(type, frame); 248 #endif 249 #ifdef DDB 250 /* Let DDB handle it. */ 251 if (!handled) 252 handled = kdb_trap(type, code, frame); 253 #endif 254 255 /* If this trap wasn't handled, return now. */ 256 if (!handled) 257 return(0); 258 259 /* 260 * If the instruction offset queue head changed, 261 * but the offset queue tail didn't, assume that 262 * the user wants to jump to the head offset, and 263 * adjust the tail accordingly. This should fix 264 * the kgdb `jump' command, and can help DDB users 265 * who `set' the offset head but forget the tail. 266 */ 267 if (frame->tf_iioq_head != tf_iioq_head_old && 268 frame->tf_iioq_tail == tf_iioq_tail_old) 269 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 270 271 /* 272 * This is some single-stepping support. 273 * If we're trying to step through a nullified 274 * instruction, just advance by hand and trap 275 * again. Otherwise, load the recovery counter 276 * with zero. 277 */ 278 if (frame->tf_ipsw & PSW_R) { 279 #ifdef TRAPDEBUG 280 printf("(single stepping at head 0x%x tail 0x%x)\n", 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 vsize_t uspace_size; 419 #define SANITY(e) \ 420 do { \ 421 if (sanity_frame == NULL && !(e)) { \ 422 sanity_frame = tf; \ 423 sanity_lwp = l; \ 424 sanity_checked = __LINE__; \ 425 } \ 426 } while (/* CONSTCOND */ 0) 427 428 SANITY((tf->tf_ipsw & kpsw) == kpsw); 429 SANITY(tf->tf_hptm == hpt_mask && tf->tf_vtop == hpt_base); 430 SANITY((kpsw & PSW_I) == 0 || tf->tf_eiem != 0); 431 if (tf->tf_iisq_head == HPPA_SID_KERNEL) { 432 /* 433 * If the trap happened in the gateway 434 * page, we take the easy way out and 435 * assume that the trapframe is okay. 436 */ 437 if ((tf->tf_iioq_head & ~PAGE_MASK) != SYSCALLGATE) { 438 SANITY(!USERMODE(tf->tf_iioq_head)); 439 SANITY(!USERMODE(tf->tf_iioq_tail)); 440 SANITY(tf->tf_iioq_head >= (u_int) &kernel_text); 441 SANITY(tf->tf_iioq_head < (u_int) &etext); 442 SANITY(tf->tf_iioq_tail >= (u_int) &kernel_text); 443 SANITY(tf->tf_iioq_tail < (u_int) &etext); 444 #ifdef HPPA_REDZONE 445 uspace_size = HPPA_REDZONE; 446 #else 447 uspace_size = USPACE; 448 #endif 449 SANITY(l == NULL || 450 ((tf->tf_sp >= (u_int)(l->l_addr) + PAGE_SIZE && 451 tf->tf_sp < (u_int)(l->l_addr) + uspace_size))); 452 } 453 } else { 454 SANITY(USERMODE(tf->tf_iioq_head)); 455 SANITY(USERMODE(tf->tf_iioq_tail)); 456 SANITY(l != NULL && tf->tf_cr30 == kvtop((caddr_t)l->l_addr)); 457 } 458 #undef SANITY 459 if (sanity_frame == tf) { 460 printf("insanity: where 0x%x type 0x%x tf %p lwp %p line %d " 461 "sp 0x%x pc 0x%x\n", 462 where, type, sanity_frame, sanity_lwp, sanity_checked, 463 tf->tf_sp, tf->tf_iioq_head); 464 (void) trap_kdebug(T_IBREAK, 0, tf); 465 sanity_frame = NULL; 466 sanity_lwp = NULL; 467 sanity_checked = 0; 468 } 469 } 470 #endif /* DEBUG */ 471 472 void 473 trap(int type, struct trapframe *frame) 474 { 475 struct lwp *l; 476 struct proc *p; 477 struct pcb *pcbp; 478 vaddr_t va; 479 struct vm_map *map; 480 struct vmspace *vm; 481 vm_prot_t vftype; 482 pa_space_t space; 483 ksiginfo_t ksi; 484 u_int opcode, onfault; 485 int ret; 486 const char *tts; 487 int type_raw; 488 #ifdef DIAGNOSTIC 489 extern int emergency_stack_start, emergency_stack_end; 490 #endif 491 492 type_raw = type & ~T_USER; 493 opcode = frame->tf_iir; 494 if (type_raw == T_ITLBMISS || type_raw == T_ITLBMISSNA) { 495 va = frame->tf_iioq_head; 496 space = frame->tf_iisq_head; 497 vftype = VM_PROT_EXECUTE; 498 } else { 499 va = frame->tf_ior; 500 space = frame->tf_isr; 501 vftype = inst_store(opcode) ? VM_PROT_WRITE : VM_PROT_READ; 502 } 503 504 l = curlwp; 505 p = l ? l->l_proc : NULL; 506 507 tts = (type & ~T_USER) > trap_types ? "reserved" : 508 trap_type[type & ~T_USER]; 509 510 #ifdef DIAGNOSTIC 511 /* 512 * If we are on the emergency stack, then we either got 513 * a fault on the kernel stack, or we're just handling 514 * a trap for the machine check handler (which also 515 * runs on the emergency stack). 516 * 517 * We *very crudely* differentiate between the two cases 518 * by checking the faulting instruction: if it is the 519 * function prologue instruction that stores the old 520 * frame pointer and updates the stack pointer, we assume 521 * that we faulted on the kernel stack. 522 * 523 * In this case, not completing that instruction will 524 * probably confuse backtraces in kgdb/ddb. Completing 525 * it would be difficult, because we already faulted on 526 * that part of the stack, so instead we fix up the 527 * frame as if the function called has just returned. 528 * This has peculiar knowledge about what values are in 529 * what registers during the "normal gcc -g" prologue. 530 */ 531 if (&type >= &emergency_stack_start && 532 &type < &emergency_stack_end && 533 type != T_IBREAK && STWM_R1_D_SR0_SP(opcode)) { 534 /* Restore the caller's frame pointer. */ 535 frame->tf_r3 = frame->tf_r1; 536 /* Restore the caller's instruction offsets. */ 537 frame->tf_iioq_head = frame->tf_rp; 538 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 539 goto dead_end; 540 } 541 #endif /* DIAGNOSTIC */ 542 543 #ifdef DEBUG 544 frame_sanity_check(0xdead01, type, frame, l); 545 #endif /* DEBUG */ 546 547 /* If this is a trap, not an interrupt, reenable interrupts. */ 548 if (type_raw != T_INTERRUPT) 549 mtctl(frame->tf_eiem, CR_EIEM); 550 551 if (frame->tf_flags & TFF_LAST) 552 l->l_md.md_regs = frame; 553 554 #ifdef TRAPDEBUG 555 if (type_raw != T_INTERRUPT && type_raw != T_IBREAK) 556 printf("trap: %d, %s for %x:%x at %x:%x, fp=%p, rp=%x\n", 557 type, tts, space, (u_int)va, frame->tf_iisq_head, 558 frame->tf_iioq_head, frame, frame->tf_rp); 559 else if (type_raw == T_IBREAK) 560 printf("trap: break instruction %x:%x at %x:%x, fp=%p\n", 561 break5(opcode), break13(opcode), 562 frame->tf_iisq_head, frame->tf_iioq_head, frame); 563 564 { 565 extern int etext; 566 if (frame < (struct trapframe *)&etext) { 567 printf("trap: bogus frame ptr %p\n", frame); 568 goto dead_end; 569 } 570 } 571 #endif 572 switch (type) { 573 case T_NONEXIST: 574 case T_NONEXIST|T_USER: 575 #if !defined(DDB) && !defined(KGDB) 576 /* we've got screwed up by the central scrutinizer */ 577 panic ("trap: elvis has just left the building!"); 578 break; 579 #else 580 goto dead_end; 581 #endif 582 case T_RECOVERY|T_USER: 583 #ifdef USERTRACE 584 for(;;) { 585 if (frame->tf_iioq_head != rctr_next_iioq) 586 printf("-%08x\nr %08x", 587 rctr_next_iioq - 4, 588 frame->tf_iioq_head); 589 rctr_next_iioq = frame->tf_iioq_head + 4; 590 if (frame->tf_ipsw & PSW_N) { 591 /* Advance the program counter. */ 592 frame->tf_iioq_head = frame->tf_iioq_tail; 593 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 594 /* Clear flags. */ 595 frame->tf_ipsw &= ~(PSW_N|PSW_X|PSW_Y|PSW_Z|PSW_B|PSW_T|PSW_H|PSW_L); 596 /* Simulate another trap. */ 597 continue; 598 } 599 break; 600 } 601 frame->tf_rctr = 0; 602 break; 603 #endif /* USERTRACE */ 604 case T_RECOVERY: 605 #if !defined(DDB) && !defined(KGDB) 606 /* XXX will implement later */ 607 printf ("trap: handicapped"); 608 break; 609 #else 610 goto dead_end; 611 #endif 612 613 case T_EMULATION | T_USER: 614 #ifdef FPEMUL 615 hppa_fpu_emulate(frame, l, opcode); 616 #else /* !FPEMUL */ 617 /* 618 * We don't have FPU emulation, so signal the 619 * process with a SIGFPE. 620 */ 621 622 KSI_INIT_TRAP(&ksi); 623 ksi.ksi_signo = SIGFPE; 624 ksi.ksi_code = SI_NOINFO; 625 ksi.ksi_trap = type; 626 ksi.ksi_addr = (void *)frame->tf_iioq_head; 627 trapsignal(l, &ksi); 628 #endif /* !FPEMUL */ 629 break; 630 631 case T_DATALIGN: 632 if (l->l_addr->u_pcb.pcb_onfault) { 633 do_onfault: 634 pcbp = &l->l_addr->u_pcb; 635 frame->tf_iioq_tail = 4 + 636 (frame->tf_iioq_head = 637 pcbp->pcb_onfault); 638 pcbp->pcb_onfault = 0; 639 break; 640 } 641 /*FALLTHROUGH*/ 642 643 #ifdef DIAGNOSTIC 644 /* these just can't happen ever */ 645 case T_PRIV_OP: 646 case T_PRIV_REG: 647 /* these just can't make it to the trap() ever */ 648 case T_HPMC: 649 case T_HPMC | T_USER: 650 case T_EMULATION: 651 case T_EXCEPTION: 652 #endif 653 case T_IBREAK: 654 case T_DBREAK: 655 dead_end: 656 if (type & T_USER) { 657 #ifdef DEBUG 658 user_backtrace(frame, l, type); 659 #endif 660 KSI_INIT_TRAP(&ksi); 661 ksi.ksi_signo = SIGILL; 662 ksi.ksi_code = ILL_ILLTRP; 663 ksi.ksi_trap = type; 664 ksi.ksi_addr = (void *)frame->tf_iioq_head; 665 trapsignal(l, &ksi); 666 break; 667 } 668 if (trap_kdebug(type, va, frame)) 669 return; 670 else if (type == T_DATALIGN) 671 panic ("trap: %s at 0x%x", tts, (u_int) va); 672 else 673 panic ("trap: no debugger for \"%s\" (%d)", tts, type); 674 break; 675 676 case T_IBREAK | T_USER: 677 case T_DBREAK | T_USER: 678 /* pass to user debugger */ 679 break; 680 681 case T_EXCEPTION | T_USER: { /* co-proc assist trap */ 682 uint64_t *fpp; 683 uint32_t *pex, ex, inst; 684 int i; 685 686 hppa_fpu_flush(l); 687 fpp = l->l_addr->u_pcb.pcb_fpregs; 688 pex = (uint32_t *)&fpp[1]; 689 for (i = 1; i < 8 && !*pex; i++, pex++) 690 ; 691 KASSERT(i < 8); 692 ex = *pex; 693 *pex = 0; 694 695 /* reset the trap flag, as if there was none */ 696 fpp[0] &= ~(((uint64_t)HPPA_FPU_T) << 32); 697 698 /* emulate the instruction */ 699 inst = ((uint32_t)fpopmap[ex >> 26] << 26) | (ex & 0x03ffffff); 700 hppa_fpu_emulate(frame, l, inst); 701 } 702 break; 703 704 case T_OVERFLOW | T_USER: 705 KSI_INIT_TRAP(&ksi); 706 ksi.ksi_signo = SIGFPE; 707 ksi.ksi_code = SI_NOINFO; 708 ksi.ksi_trap = type; 709 ksi.ksi_addr = (void *)va; 710 trapsignal(l, &ksi); 711 break; 712 713 case T_CONDITION | T_USER: 714 KSI_INIT_TRAP(&ksi); 715 ksi.ksi_signo = SIGFPE; 716 ksi.ksi_code = FPE_INTDIV; 717 ksi.ksi_trap = type; 718 ksi.ksi_addr = (void *)va; 719 trapsignal(l, &ksi); 720 break; 721 722 case T_ILLEGAL | T_USER: 723 #ifdef DEBUG 724 user_backtrace(frame, l, type); 725 #endif 726 KSI_INIT_TRAP(&ksi); 727 ksi.ksi_signo = SIGILL; 728 ksi.ksi_code = ILL_ILLOPC; 729 ksi.ksi_trap = type; 730 ksi.ksi_addr = (void *)va; 731 trapsignal(l, &ksi); 732 break; 733 734 case T_PRIV_OP | T_USER: 735 #ifdef DEBUG 736 user_backtrace(frame, l, type); 737 #endif 738 KSI_INIT_TRAP(&ksi); 739 ksi.ksi_signo = SIGILL; 740 ksi.ksi_code = ILL_PRVOPC; 741 ksi.ksi_trap = type; 742 ksi.ksi_addr = (void *)va; 743 trapsignal(l, &ksi); 744 break; 745 746 case T_PRIV_REG | T_USER: 747 #ifdef DEBUG 748 user_backtrace(frame, l, type); 749 #endif 750 KSI_INIT_TRAP(&ksi); 751 ksi.ksi_signo = SIGILL; 752 ksi.ksi_code = ILL_PRVREG; 753 ksi.ksi_trap = type; 754 ksi.ksi_addr = (void *)va; 755 trapsignal(l, &ksi); 756 break; 757 758 /* these should never got here */ 759 case T_HIGHERPL | T_USER: 760 case T_LOWERPL | T_USER: 761 KSI_INIT_TRAP(&ksi); 762 ksi.ksi_signo = SIGSEGV; 763 ksi.ksi_code = SEGV_ACCERR; 764 ksi.ksi_trap = type; 765 ksi.ksi_addr = (void *)va; 766 trapsignal(l, &ksi); 767 break; 768 769 case T_IPROT | T_USER: 770 case T_DPROT | T_USER: 771 KSI_INIT_TRAP(&ksi); 772 ksi.ksi_signo = SIGSEGV; 773 ksi.ksi_code = SEGV_ACCERR; 774 ksi.ksi_trap = type; 775 ksi.ksi_addr = (void *)va; 776 trapsignal(l, &ksi); 777 break; 778 779 case T_DATACC: case T_USER | T_DATACC: 780 case T_ITLBMISS: case T_USER | T_ITLBMISS: 781 case T_DTLBMISS: case T_USER | T_DTLBMISS: 782 case T_ITLBMISSNA: case T_USER | T_ITLBMISSNA: 783 case T_DTLBMISSNA: case T_USER | T_DTLBMISSNA: 784 case T_TLB_DIRTY: case T_USER | T_TLB_DIRTY: 785 vm = p->p_vmspace; 786 787 if (!vm) { 788 #ifdef TRAPDEBUG 789 printf("trap: no vm, p=%p\n", p); 790 #endif 791 goto dead_end; 792 } 793 794 /* 795 * it could be a kernel map for exec_map faults 796 */ 797 if (!(type & T_USER) && space == HPPA_SID_KERNEL) 798 map = kernel_map; 799 else { 800 map = &vm->vm_map; 801 if (l->l_flag & L_SA) { 802 l->l_savp->savp_faultaddr = va; 803 l->l_flag |= L_SA_PAGEFAULT; 804 } 805 } 806 807 va = hppa_trunc_page(va); 808 809 if (map->pmap->pmap_space != space) { 810 #ifdef TRAPDEBUG 811 printf("trap: space missmatch %d != %d\n", 812 space, map->pmap->pmap_space); 813 #endif 814 /* actually dump the user, crap the kernel */ 815 goto dead_end; 816 } 817 818 /* Never call uvm_fault in interrupt context. */ 819 KASSERT(hppa_intr_depth == 0); 820 821 onfault = l->l_addr->u_pcb.pcb_onfault; 822 l->l_addr->u_pcb.pcb_onfault = 0; 823 ret = uvm_fault(map, va, vftype); 824 l->l_addr->u_pcb.pcb_onfault = onfault; 825 826 #ifdef TRAPDEBUG 827 printf("uvm_fault(%p, %x, %d)=%d\n", 828 map, (u_int)va, vftype, ret); 829 #endif 830 831 if (map != kernel_map) 832 l->l_flag &= ~L_SA_PAGEFAULT; 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 (va >= (vaddr_t)vm->vm_maxsaddr + vm->vm_ssize) { 842 if (ret == 0) { 843 vsize_t nss = btoc(va - USRSTACK + PAGE_SIZE); 844 if (nss > vm->vm_ssize) 845 vm->vm_ssize = nss; 846 } else if (ret == EACCES) 847 ret = EFAULT; 848 } 849 850 if (ret != 0) { 851 if (type & T_USER) { 852 #ifdef DEBUG 853 user_backtrace(frame, l, type); 854 #endif 855 KSI_INIT_TRAP(&ksi); 856 ksi.ksi_signo = SIGSEGV; 857 ksi.ksi_code = (ret == EACCES ? 858 SEGV_ACCERR : SEGV_MAPERR); 859 ksi.ksi_trap = type; 860 ksi.ksi_addr = (void *)va; 861 trapsignal(l, &ksi); 862 } else { 863 if (l->l_addr->u_pcb.pcb_onfault) { 864 goto do_onfault; 865 } 866 panic("trap: uvm_fault(%p, %lx, %d): %d", 867 map, va, vftype, ret); 868 } 869 } 870 break; 871 872 case T_DATALIGN | T_USER: 873 #ifdef DEBUG 874 user_backtrace(frame, l, type); 875 #endif 876 KSI_INIT_TRAP(&ksi); 877 ksi.ksi_signo = SIGBUS; 878 ksi.ksi_code = BUS_ADRALN; 879 ksi.ksi_trap = type; 880 ksi.ksi_addr = (void *)va; 881 trapsignal(l, &ksi); 882 break; 883 884 case T_INTERRUPT: 885 case T_INTERRUPT|T_USER: 886 hppa_intr(frame); 887 mtctl(frame->tf_eiem, CR_EIEM); 888 break; 889 890 case T_LOWERPL: 891 case T_DPROT: 892 case T_IPROT: 893 case T_OVERFLOW: 894 case T_CONDITION: 895 case T_ILLEGAL: 896 case T_HIGHERPL: 897 case T_TAKENBR: 898 case T_POWERFAIL: 899 case T_LPMC: 900 case T_PAGEREF: 901 case T_DATAPID: case T_DATAPID | T_USER: 902 if (0 /* T-chip */) { 903 break; 904 } 905 /* FALLTHROUGH to unimplemented */ 906 default: 907 panic ("trap: unimplemented \'%s\' (%d)", tts, type); 908 } 909 910 if (type & T_USER) 911 userret(l, l->l_md.md_regs->tf_iioq_head, 0); 912 913 #ifdef DEBUG 914 frame_sanity_check(0xdead02, type, frame, l); 915 if (frame->tf_flags & TFF_LAST && curlwp != NULL) 916 frame_sanity_check(0xdead03, type, curlwp->l_md.md_regs, 917 curlwp); 918 #endif /* DEBUG */ 919 } 920 921 void 922 child_return(void *arg) 923 { 924 struct lwp *l = arg; 925 struct proc *p = l->l_proc; 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 970 /* 971 * Restarting a system call is touchy on the HPPA, 972 * because syscall arguments are passed in registers 973 * and the program counter of the syscall "point" 974 * isn't easily divined. 975 * 976 * We handle the first problem by assuming that we 977 * will have to restart this system call, so we 978 * stuff the first four words of the original arguments 979 * back into the frame as arg0...arg3, which is where 980 * we found them in the first place. Any further 981 * arguments are (still) on the user's stack and the 982 * syscall code will fetch them from there (again). 983 * 984 * The program counter problem is addressed below. 985 */ 986 frame->tf_arg0 = args[0]; 987 frame->tf_arg1 = args[1]; 988 frame->tf_arg2 = args[2]; 989 frame->tf_arg3 = args[3]; 990 991 /* 992 * Some special handling for the syscall(2) and 993 * __syscall(2) system calls. 994 */ 995 switch (code) { 996 case SYS_syscall: 997 code = *args; 998 args += 1; 999 break; 1000 case SYS___syscall: 1001 if (callp != sysent) 1002 break; 1003 /* 1004 * NB: even though __syscall(2) takes a quad_t 1005 * containing the system call number, because 1006 * our argument copying word-swaps 64-bit arguments, 1007 * the least significant word of that quad_t 1008 * is the first word in the argument array. 1009 */ 1010 code = *args; 1011 args += 2; 1012 } 1013 1014 /* 1015 * Stacks growing from lower addresses to higher 1016 * addresses are not really such a good idea, because 1017 * it makes it impossible to overlay a struct on top 1018 * of C stack arguments (the arguments appear in 1019 * reversed order). 1020 * 1021 * You can do the obvious thing (as locore.S does) and 1022 * copy argument words one by one, laying them out in 1023 * the "right" order in the destination buffer, but this 1024 * ends up word-swapping multi-word arguments (like off_t). 1025 * 1026 * To compensate, we have some automatically-generated 1027 * code that word-swaps these multi-word arguments. 1028 * Right now the script that generates this code is 1029 * in Perl, because I don't know awk. 1030 * 1031 * FIXME - this works only on native binaries and 1032 * will probably screw up any and all emulation. 1033 */ 1034 switch (code) { 1035 /* 1036 * BEGIN automatically generated 1037 * by /home/fredette/project/hppa/makescargfix.pl 1038 * do not edit! 1039 */ 1040 case SYS_pread: 1041 /* 1042 * syscallarg(int) fd; 1043 * syscallarg(void *) buf; 1044 * syscallarg(size_t) nbyte; 1045 * syscallarg(int) pad; 1046 * syscallarg(off_t) offset; 1047 */ 1048 tmp = args[4]; 1049 args[4] = args[4 + 1]; 1050 args[4 + 1] = tmp; 1051 break; 1052 case SYS_pwrite: 1053 /* 1054 * syscallarg(int) fd; 1055 * syscallarg(const void *) buf; 1056 * syscallarg(size_t) nbyte; 1057 * syscallarg(int) pad; 1058 * syscallarg(off_t) offset; 1059 */ 1060 tmp = args[4]; 1061 args[4] = args[4 + 1]; 1062 args[4 + 1] = tmp; 1063 break; 1064 case SYS_mmap: 1065 /* 1066 * syscallarg(void *) addr; 1067 * syscallarg(size_t) len; 1068 * syscallarg(int) prot; 1069 * syscallarg(int) flags; 1070 * syscallarg(int) fd; 1071 * syscallarg(long) pad; 1072 * syscallarg(off_t) pos; 1073 */ 1074 tmp = args[6]; 1075 args[6] = args[6 + 1]; 1076 args[6 + 1] = tmp; 1077 break; 1078 case SYS_lseek: 1079 /* 1080 * syscallarg(int) fd; 1081 * syscallarg(int) pad; 1082 * syscallarg(off_t) offset; 1083 */ 1084 tmp = args[2]; 1085 args[2] = args[2 + 1]; 1086 args[2 + 1] = tmp; 1087 break; 1088 case SYS_truncate: 1089 /* 1090 * syscallarg(const char *) path; 1091 * syscallarg(int) pad; 1092 * syscallarg(off_t) length; 1093 */ 1094 tmp = args[2]; 1095 args[2] = args[2 + 1]; 1096 args[2 + 1] = tmp; 1097 break; 1098 case SYS_ftruncate: 1099 /* 1100 * syscallarg(int) fd; 1101 * syscallarg(int) pad; 1102 * syscallarg(off_t) length; 1103 */ 1104 tmp = args[2]; 1105 args[2] = args[2 + 1]; 1106 args[2 + 1] = tmp; 1107 break; 1108 case SYS_preadv: 1109 /* 1110 * syscallarg(int) fd; 1111 * syscallarg(const struct iovec *) iovp; 1112 * syscallarg(int) iovcnt; 1113 * syscallarg(int) pad; 1114 * syscallarg(off_t) offset; 1115 */ 1116 tmp = args[4]; 1117 args[4] = args[4 + 1]; 1118 args[4 + 1] = tmp; 1119 break; 1120 case SYS_pwritev: 1121 /* 1122 * syscallarg(int) fd; 1123 * syscallarg(const struct iovec *) iovp; 1124 * syscallarg(int) iovcnt; 1125 * syscallarg(int) pad; 1126 * syscallarg(off_t) offset; 1127 */ 1128 tmp = args[4]; 1129 args[4] = args[4 + 1]; 1130 args[4 + 1] = tmp; 1131 break; 1132 default: 1133 break; 1134 /* 1135 * END automatically generated 1136 * by /home/fredette/project/hppa/makescargfix.pl 1137 * do not edit! 1138 */ 1139 } 1140 1141 #ifdef USERTRACE 1142 if (0) { 1143 user_backtrace(frame, l, -1); 1144 frame->tf_ipsw |= PSW_R; 1145 frame->tf_rctr = 0; 1146 printf("r %08x", frame->tf_iioq_head); 1147 rctr_next_iioq = frame->tf_iioq_head + 4; 1148 } 1149 #endif 1150 1151 if (code < 0 || code >= nsys) 1152 callp += p->p_emul->e_nosys; /* bad syscall # */ 1153 else 1154 callp += code; 1155 argsize = callp->sy_argsize; 1156 1157 if ((error = trace_enter(l, code, code, NULL, args)) != 0) 1158 goto out; 1159 1160 rval[0] = 0; 1161 rval[1] = 0; 1162 error = (*callp->sy_call)(l, args, rval); 1163 out: 1164 switch (error) { 1165 case 0: 1166 l = curlwp; /* changes on exec() */ 1167 frame = l->l_md.md_regs; 1168 frame->tf_ret0 = rval[0]; 1169 frame->tf_ret1 = rval[1]; 1170 frame->tf_t1 = 0; 1171 break; 1172 case ERESTART: 1173 /* 1174 * Now we have to wind back the instruction 1175 * offset queue to the point where the system 1176 * call will be made again. This is inherently 1177 * tied to the SYSCALL macro. 1178 * 1179 * Currently, the part of the SYSCALL macro 1180 * that we want to rerun reads as: 1181 * 1182 * ldil L%SYSCALLGATE, r1 1183 * ble 4(sr7, r1) 1184 * ldi __CONCAT(SYS_,x), t1 1185 * ldw HPPA_FRAME_ERP(sr0,sp), rp 1186 * 1187 * And our offset queue head points to the 1188 * final ldw instruction. So we need to 1189 * subtract twelve to reach the ldil. 1190 */ 1191 frame->tf_iioq_head -= 12; 1192 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 1193 break; 1194 case EJUSTRETURN: 1195 p = curproc; 1196 break; 1197 default: 1198 if (p->p_emul->e_errno) 1199 error = p->p_emul->e_errno[error]; 1200 frame->tf_t1 = error; 1201 break; 1202 } 1203 1204 trace_exit(l, code, args, rval, error); 1205 1206 userret(l, frame->tf_iioq_head, 0); 1207 #ifdef DEBUG 1208 frame_sanity_check(0xdead05, 0, frame, l); 1209 #endif /* DEBUG */ 1210 } 1211 1212 /* 1213 * Start a new LWP 1214 */ 1215 void 1216 startlwp(void *arg) 1217 { 1218 int err; 1219 ucontext_t *uc = arg; 1220 struct lwp *l = curlwp; 1221 1222 err = cpu_setmcontext(l, &uc->uc_mcontext, uc->uc_flags); 1223 #if DIAGNOSTIC 1224 if (err) { 1225 printf("Error %d from cpu_setmcontext.", err); 1226 } 1227 #endif 1228 pool_put(&lwp_uc_pool, uc); 1229 1230 userret(l, l->l_md.md_regs->tf_iioq_head, 0); 1231 } 1232 1233 /* 1234 * XXX This is a terrible name. 1235 */ 1236 void 1237 upcallret(struct lwp *l) 1238 { 1239 userret(l, l->l_md.md_regs->tf_iioq_head, 0); 1240 } 1241
Indexes created Mon Sep 29 21:09:56 GMT 2025