trap.c revision 1.38.2.1.2.1
1 /* $NetBSD: trap.c,v 1.38.2.1.2.1 2007/09/03 07:03:30 wrstuden 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.38.2.1.2.1 2007/09/03 07:03:30 wrstuden 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 #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 vaddr_t minsp, maxsp; 432 433 /* 434 * If the trap happened in the gateway 435 * page, we take the easy way out and 436 * assume that the trapframe is okay. 437 */ 438 if ((tf->tf_iioq_head & ~PAGE_MASK) != SYSCALLGATE) 439 goto out; 440 441 if ((type & ~T_USER) == T_INTERRUPT) 442 goto out; 443 444 SANITY(!USERMODE(tf->tf_iioq_head)); 445 SANITY(!USERMODE(tf->tf_iioq_tail)); 446 SANITY(tf->tf_iioq_head >= (u_int) &kernel_text); 447 SANITY(tf->tf_iioq_head < (u_int) &etext); 448 SANITY(tf->tf_iioq_tail >= (u_int) &kernel_text); 449 SANITY(tf->tf_iioq_tail < (u_int) &etext); 450 #ifdef HPPA_REDZONE 451 maxsp = (u_int)(l->l_addr) + HPPA_REDZONE; 452 #else 453 maxsp = (u_int)(l->l_addr) + USPACE; 454 #endif 455 minsp = (u_int)(l->l_addr) + PAGE_SIZE; 456 457 SANITY(l != NULL || (tf->tf_sp >= minsp && tf->tf_sp < maxsp)); 458 } else { 459 SANITY(USERMODE(tf->tf_iioq_head)); 460 SANITY(USERMODE(tf->tf_iioq_tail)); 461 SANITY(l != NULL && tf->tf_cr30 == kvtop((caddr_t)l->l_addr)); 462 } 463 #undef SANITY 464 out: 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 if (l->l_flag & L_SA) { 810 l->l_savp->savp_faultaddr = va; 811 l->l_flag |= L_SA_PAGEFAULT; 812 } 813 } 814 815 va = hppa_trunc_page(va); 816 817 if (map->pmap->pmap_space != space) { 818 #ifdef TRAPDEBUG 819 printf("trap: space mismatch %d != %d\n", 820 space, map->pmap->pmap_space); 821 #endif 822 /* actually dump the user, crap the kernel */ 823 goto dead_end; 824 } 825 826 /* Never call uvm_fault in interrupt context. */ 827 KASSERT(hppa_intr_depth == 0); 828 829 onfault = l->l_addr->u_pcb.pcb_onfault; 830 l->l_addr->u_pcb.pcb_onfault = 0; 831 ret = uvm_fault(map, va, vftype); 832 l->l_addr->u_pcb.pcb_onfault = onfault; 833 834 #ifdef TRAPDEBUG 835 printf("uvm_fault(%p, %x, %d)=%d\n", 836 map, (u_int)va, vftype, ret); 837 #endif 838 839 if (map != kernel_map) 840 l->l_flag &= ~L_SA_PAGEFAULT; 841 842 /* 843 * If this was a stack access we keep track of the maximum 844 * accessed stack size. Also, if uvm_fault gets a protection 845 * failure it is due to accessing the stack region outside 846 * the current limit and we need to reflect that as an access 847 * error. 848 */ 849 if (map != kernel_map && va >= (vaddr_t)vm->vm_minsaddr) { 850 if (ret == 0) 851 uvm_grow(l->l_proc, va); 852 else if (ret == EACCES) 853 ret = EFAULT; 854 } 855 856 if (ret != 0) { 857 if (type & T_USER) { 858 #ifdef DEBUG 859 user_backtrace(frame, l, type); 860 #endif 861 KSI_INIT_TRAP(&ksi); 862 ksi.ksi_signo = SIGSEGV; 863 ksi.ksi_code = (ret == EACCES ? 864 SEGV_ACCERR : SEGV_MAPERR); 865 ksi.ksi_trap = type; 866 ksi.ksi_addr = (void *)va; 867 trapsignal(l, &ksi); 868 } else { 869 if (l->l_addr->u_pcb.pcb_onfault) { 870 goto do_onfault; 871 } 872 panic("trap: uvm_fault(%p, %lx, %d): %d", 873 map, va, vftype, ret); 874 } 875 } 876 break; 877 878 case T_DATALIGN | T_USER: 879 #ifdef DEBUG 880 user_backtrace(frame, l, type); 881 #endif 882 KSI_INIT_TRAP(&ksi); 883 ksi.ksi_signo = SIGBUS; 884 ksi.ksi_code = BUS_ADRALN; 885 ksi.ksi_trap = type; 886 ksi.ksi_addr = (void *)va; 887 trapsignal(l, &ksi); 888 break; 889 890 case T_INTERRUPT: 891 case T_INTERRUPT|T_USER: 892 hppa_intr(frame); 893 mtctl(frame->tf_eiem, CR_EIEM); 894 break; 895 896 case T_LOWERPL: 897 case T_DPROT: 898 case T_IPROT: 899 case T_OVERFLOW: 900 case T_CONDITION: 901 case T_ILLEGAL: 902 case T_HIGHERPL: 903 case T_TAKENBR: 904 case T_POWERFAIL: 905 case T_LPMC: 906 case T_PAGEREF: 907 case T_DATAPID: case T_DATAPID | T_USER: 908 if (0 /* T-chip */) { 909 break; 910 } 911 /* FALLTHROUGH to unimplemented */ 912 default: 913 panic ("trap: unimplemented \'%s\' (%d)", tts, type); 914 } 915 916 if (type & T_USER) 917 userret(l, l->l_md.md_regs->tf_iioq_head, 0); 918 919 #ifdef DEBUG 920 frame_sanity_check(0xdead02, type, frame, l); 921 if (frame->tf_flags & TFF_LAST && curlwp != NULL) 922 frame_sanity_check(0xdead03, type, curlwp->l_md.md_regs, 923 curlwp); 924 #endif /* DEBUG */ 925 } 926 927 void 928 child_return(void *arg) 929 { 930 struct lwp *l = arg; 931 #ifdef KTRACE 932 struct proc *p = l->l_proc; 933 #endif 934 935 userret(l, l->l_md.md_regs->tf_iioq_head, 0); 936 #ifdef KTRACE 937 if (KTRPOINT(p, KTR_SYSRET)) 938 ktrsysret(l, SYS_fork, 0, 0); 939 #endif 940 #ifdef DEBUG 941 frame_sanity_check(0xdead04, 0, l->l_md.md_regs, l); 942 #endif /* DEBUG */ 943 } 944 945 /* 946 * call actual syscall routine 947 * from the low-level syscall handler: 948 * - all HPPA_FRAME_NARGS syscall's arguments supposed to be copied onto 949 * our stack, this wins compared to copyin just needed amount anyway 950 * - register args are copied onto stack too 951 */ 952 void 953 syscall(struct trapframe *frame, int *args) 954 { 955 struct lwp *l; 956 struct proc *p; 957 const struct sysent *callp; 958 int nsys, code, argsize, error; 959 int tmp; 960 int rval[2]; 961 962 uvmexp.syscalls++; 963 964 #ifdef DEBUG 965 frame_sanity_check(0xdead04, 0, frame, curlwp); 966 #endif /* DEBUG */ 967 968 if (!USERMODE(frame->tf_iioq_head)) 969 panic("syscall"); 970 971 l = curlwp; 972 p = l->l_proc; 973 l->l_md.md_regs = frame; 974 nsys = p->p_emul->e_nsysent; 975 callp = p->p_emul->e_sysent; 976 code = frame->tf_t1; 977 LWP_CACHE_CREDS(l, p); 978 979 /* 980 * Restarting a system call is touchy on the HPPA, 981 * because syscall arguments are passed in registers 982 * and the program counter of the syscall "point" 983 * isn't easily divined. 984 * 985 * We handle the first problem by assuming that we 986 * will have to restart this system call, so we 987 * stuff the first four words of the original arguments 988 * back into the frame as arg0...arg3, which is where 989 * we found them in the first place. Any further 990 * arguments are (still) on the user's stack and the 991 * syscall code will fetch them from there (again). 992 * 993 * The program counter problem is addressed below. 994 */ 995 frame->tf_arg0 = args[0]; 996 frame->tf_arg1 = args[1]; 997 frame->tf_arg2 = args[2]; 998 frame->tf_arg3 = args[3]; 999 1000 /* 1001 * Some special handling for the syscall(2) and 1002 * __syscall(2) system calls. 1003 */ 1004 switch (code) { 1005 case SYS_syscall: 1006 code = *args; 1007 args += 1; 1008 break; 1009 case SYS___syscall: 1010 if (callp != sysent) 1011 break; 1012 /* 1013 * NB: even though __syscall(2) takes a quad_t 1014 * containing the system call number, because 1015 * our argument copying word-swaps 64-bit arguments, 1016 * the least significant word of that quad_t 1017 * is the first word in the argument array. 1018 */ 1019 code = *args; 1020 args += 2; 1021 } 1022 1023 /* 1024 * Stacks growing from lower addresses to higher 1025 * addresses are not really such a good idea, because 1026 * it makes it impossible to overlay a struct on top 1027 * of C stack arguments (the arguments appear in 1028 * reversed order). 1029 * 1030 * You can do the obvious thing (as locore.S does) and 1031 * copy argument words one by one, laying them out in 1032 * the "right" order in the destination buffer, but this 1033 * ends up word-swapping multi-word arguments (like off_t). 1034 * 1035 * To compensate, we have some automatically-generated 1036 * code that word-swaps these multi-word arguments. 1037 * Right now the script that generates this code is 1038 * in Perl, because I don't know awk. 1039 * 1040 * FIXME - this works only on native binaries and 1041 * will probably screw up any and all emulation. 1042 */ 1043 switch (code) { 1044 /* 1045 * BEGIN automatically generated 1046 * by /home/fredette/project/hppa/makescargfix.pl 1047 * do not edit! 1048 */ 1049 case SYS_pread: 1050 /* 1051 * syscallarg(int) fd; 1052 * syscallarg(void *) buf; 1053 * syscallarg(size_t) nbyte; 1054 * syscallarg(int) pad; 1055 * syscallarg(off_t) offset; 1056 */ 1057 tmp = args[4]; 1058 args[4] = args[4 + 1]; 1059 args[4 + 1] = tmp; 1060 break; 1061 case SYS_pwrite: 1062 /* 1063 * syscallarg(int) fd; 1064 * syscallarg(const void *) buf; 1065 * syscallarg(size_t) nbyte; 1066 * syscallarg(int) pad; 1067 * syscallarg(off_t) offset; 1068 */ 1069 tmp = args[4]; 1070 args[4] = args[4 + 1]; 1071 args[4 + 1] = tmp; 1072 break; 1073 case SYS_mmap: 1074 /* 1075 * syscallarg(void *) addr; 1076 * syscallarg(size_t) len; 1077 * syscallarg(int) prot; 1078 * syscallarg(int) flags; 1079 * syscallarg(int) fd; 1080 * syscallarg(long) pad; 1081 * syscallarg(off_t) pos; 1082 */ 1083 tmp = args[6]; 1084 args[6] = args[6 + 1]; 1085 args[6 + 1] = tmp; 1086 break; 1087 case SYS_lseek: 1088 /* 1089 * syscallarg(int) fd; 1090 * syscallarg(int) pad; 1091 * syscallarg(off_t) offset; 1092 */ 1093 tmp = args[2]; 1094 args[2] = args[2 + 1]; 1095 args[2 + 1] = tmp; 1096 break; 1097 case SYS_truncate: 1098 /* 1099 * syscallarg(const char *) path; 1100 * syscallarg(int) pad; 1101 * syscallarg(off_t) length; 1102 */ 1103 tmp = args[2]; 1104 args[2] = args[2 + 1]; 1105 args[2 + 1] = tmp; 1106 break; 1107 case SYS_ftruncate: 1108 /* 1109 * syscallarg(int) fd; 1110 * syscallarg(int) pad; 1111 * syscallarg(off_t) length; 1112 */ 1113 tmp = args[2]; 1114 args[2] = args[2 + 1]; 1115 args[2 + 1] = tmp; 1116 break; 1117 case SYS_preadv: 1118 /* 1119 * syscallarg(int) fd; 1120 * syscallarg(const struct iovec *) iovp; 1121 * syscallarg(int) iovcnt; 1122 * syscallarg(int) pad; 1123 * syscallarg(off_t) offset; 1124 */ 1125 tmp = args[4]; 1126 args[4] = args[4 + 1]; 1127 args[4 + 1] = tmp; 1128 break; 1129 case SYS_pwritev: 1130 /* 1131 * syscallarg(int) fd; 1132 * syscallarg(const struct iovec *) iovp; 1133 * syscallarg(int) iovcnt; 1134 * syscallarg(int) pad; 1135 * syscallarg(off_t) offset; 1136 */ 1137 tmp = args[4]; 1138 args[4] = args[4 + 1]; 1139 args[4 + 1] = tmp; 1140 break; 1141 default: 1142 break; 1143 /* 1144 * END automatically generated 1145 * by /home/fredette/project/hppa/makescargfix.pl 1146 * do not edit! 1147 */ 1148 } 1149 1150 #ifdef USERTRACE 1151 if (0) { 1152 user_backtrace(frame, l, -1); 1153 frame->tf_ipsw |= PSW_R; 1154 frame->tf_rctr = 0; 1155 printf("r %08x", frame->tf_iioq_head); 1156 rctr_next_iioq = frame->tf_iioq_head + 4; 1157 } 1158 #endif 1159 1160 if (code < 0 || code >= nsys) 1161 callp += p->p_emul->e_nosys; /* bad syscall # */ 1162 else 1163 callp += code; 1164 argsize = callp->sy_argsize; 1165 1166 if ((error = trace_enter(l, code, code, NULL, args)) != 0) 1167 goto out; 1168 1169 rval[0] = 0; 1170 rval[1] = 0; 1171 error = (*callp->sy_call)(l, args, rval); 1172 out: 1173 switch (error) { 1174 case 0: 1175 l = curlwp; /* changes on exec() */ 1176 frame = l->l_md.md_regs; 1177 frame->tf_ret0 = rval[0]; 1178 frame->tf_ret1 = rval[1]; 1179 frame->tf_t1 = 0; 1180 break; 1181 case ERESTART: 1182 /* 1183 * Now we have to wind back the instruction 1184 * offset queue to the point where the system 1185 * call will be made again. This is inherently 1186 * tied to the SYSCALL macro. 1187 * 1188 * Currently, the part of the SYSCALL macro 1189 * that we want to rerun reads as: 1190 * 1191 * ldil L%SYSCALLGATE, r1 1192 * ble 4(sr7, r1) 1193 * ldi __CONCAT(SYS_,x), t1 1194 * ldw HPPA_FRAME_ERP(sr0,sp), rp 1195 * 1196 * And our offset queue head points to the 1197 * final ldw instruction. So we need to 1198 * subtract twelve to reach the ldil. 1199 */ 1200 frame->tf_iioq_head -= 12; 1201 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 1202 break; 1203 case EJUSTRETURN: 1204 p = curproc; 1205 break; 1206 default: 1207 if (p->p_emul->e_errno) 1208 error = p->p_emul->e_errno[error]; 1209 frame->tf_t1 = error; 1210 break; 1211 } 1212 1213 trace_exit(l, code, args, rval, error); 1214 1215 userret(l, frame->tf_iioq_head, 0); 1216 #ifdef DEBUG 1217 frame_sanity_check(0xdead05, 0, frame, l); 1218 #endif /* DEBUG */ 1219 } 1220 1221 /* 1222 * Start a new LWP 1223 */ 1224 void 1225 startlwp(void *arg) 1226 { 1227 int err; 1228 ucontext_t *uc = arg; 1229 struct lwp *l = curlwp; 1230 1231 err = cpu_setmcontext(l, &uc->uc_mcontext, uc->uc_flags); 1232 #if DIAGNOSTIC 1233 if (err) { 1234 printf("Error %d from cpu_setmcontext.", err); 1235 } 1236 #endif 1237 pool_put(&lwp_uc_pool, uc); 1238 1239 userret(l, l->l_md.md_regs->tf_iioq_head, 0); 1240 } 1241 1242 /* 1243 * XXX This is a terrible name. 1244 */ 1245 void 1246 upcallret(struct lwp *l) 1247 { 1248 userret(l, l->l_md.md_regs->tf_iioq_head, 0); 1249 } 1250
Indexes created Mon Oct 20 20:10:13 GMT 2025