trap.c revision 1.121.4.1
1 /* $NetBSD: trap.c,v 1.121.4.1 2025/09/23 12:50:45 martin 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 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* $OpenBSD: trap.c,v 1.30 2001/09/19 20:50:56 mickey Exp $ */ 33 34 /* 35 * Copyright (c) 1998-2004 Michael Shalayeff 36 * All rights reserved. 37 * 38 * Redistribution and use in source and binary forms, with or without 39 * modification, are permitted provided that the following conditions 40 * are met: 41 * 1. Redistributions of source code must retain the above copyright 42 * notice, this list of conditions and the following disclaimer. 43 * 2. Redistributions in binary form must reproduce the above copyright 44 * notice, this list of conditions and the following disclaimer in the 45 * documentation and/or other materials provided with the distribution. 46 * 47 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 48 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 49 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 50 * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT, 51 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 52 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 53 * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 54 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 55 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 56 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 57 * THE POSSIBILITY OF SUCH DAMAGE. 58 */ 59 60 #include <sys/cdefs.h> 61 __KERNEL_RCSID(0, "$NetBSD: trap.c,v 1.121.4.1 2025/09/23 12:50:45 martin Exp $"); 62 63 /* #define INTRDEBUG */ 64 /* #define TRAPDEBUG */ 65 /* #define USERTRACE */ 66 67 #include "opt_kgdb.h" 68 #include "opt_ptrace.h" 69 70 #include <sys/param.h> 71 #include <sys/systm.h> 72 #include <sys/kernel.h> 73 #include <sys/syscall.h> 74 #include <sys/syscallvar.h> 75 #include <sys/mutex.h> 76 #include <sys/ktrace.h> 77 #include <sys/proc.h> 78 #include <sys/signalvar.h> 79 #include <sys/acct.h> 80 #include <sys/signal.h> 81 #include <sys/device.h> 82 #include <sys/kauth.h> 83 #include <sys/kmem.h> 84 #include <sys/userret.h> 85 86 #ifdef KGDB 87 #include <sys/kgdb.h> 88 #endif 89 90 #include <uvm/uvm.h> 91 92 #include <machine/iomod.h> 93 #include <machine/cpufunc.h> 94 #include <machine/reg.h> 95 #include <machine/autoconf.h> 96 97 #include <machine/db_machdep.h> 98 99 #include <hppa/hppa/machdep.h> 100 101 #include <ddb/db_output.h> 102 #include <ddb/db_interface.h> 103 104 #ifdef PTRACE 105 void ss_clear_breakpoints(struct lwp *l); 106 int ss_put_value(struct lwp *, vaddr_t, u_int); 107 int ss_get_value(struct lwp *, vaddr_t, u_int *); 108 109 /* single-step breakpoint */ 110 #define SSBREAKPOINT (HPPA_BREAK_KERNEL | (HPPA_BREAK_SS << 13)) 111 112 #endif 113 114 #if defined(DEBUG) || defined(DIAGNOSTIC) 115 /* 116 * 0x6fc1000 is a stwm r1, d(sr0, sp), which is the last 117 * instruction in the function prologue that gcc -O0 uses. 118 * When we have this instruction we know the relationship 119 * between the stack pointer and the gcc -O0 frame pointer 120 * (in r3, loaded with the initial sp) for the body of a 121 * function. 122 * 123 * If the given instruction is a stwm r1, d(sr0, sp) where 124 * d > 0, we evaluate to d, else we evaluate to zero. 125 */ 126 #define STWM_R1_D_SR0_SP(inst) \ 127 (((inst) & 0xffffc001) == 0x6fc10000 ? (((inst) & 0x00003ff) >> 1) : 0) 128 #endif /* DEBUG || DIAGNOSTIC */ 129 130 const char *trap_type[] = { 131 "invalid", 132 "HPMC", 133 "power failure", 134 "recovery counter", 135 "external interrupt", 136 "LPMC", 137 "ITLB miss fault", 138 "instruction protection", 139 "Illegal instruction", 140 "break instruction", 141 "privileged operation", 142 "privileged register", 143 "overflow", 144 "conditional", 145 "assist exception", 146 "DTLB miss", 147 "ITLB non-access miss", 148 "DTLB non-access miss", 149 "data protection/rights/alignment", 150 "data break", 151 "TLB dirty", 152 "page reference", 153 "assist emulation", 154 "higher-priv transfer", 155 "lower-priv transfer", 156 "taken branch", 157 "data access rights", 158 "data protection", 159 "unaligned data ref", 160 }; 161 int trap_types = __arraycount(trap_type); 162 163 uint8_t fpopmap[] = { 164 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 165 0x00, 0x0c, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 166 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 167 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 168 0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x00, 0x00, 169 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 170 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 171 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 172 }; 173 174 void pmap_hptdump(void); 175 void syscall(struct trapframe *, int *); 176 177 #if defined(DEBUG) 178 struct trapframe *sanity_frame; 179 struct lwp *sanity_lwp; 180 const char *sanity_string; 181 void frame_sanity_check(const char *, int, int, struct trapframe *, 182 struct lwp *); 183 #endif 184 185 186 #ifdef USERTRACE 187 /* 188 * USERTRACE is a crude facility that traces the PC of a single user process. 189 * This tracing is normally activated by the dispatching of a certain syscall 190 * with certain arguments - see the activation code in syscall(). 191 */ 192 static void user_backtrace(struct trapframe *, struct lwp *, int); 193 static void user_backtrace_raw(u_int, u_int); 194 195 u_int rctr_next_iioq; 196 #endif 197 198 static inline void 199 userret(struct lwp *l, struct trapframe *tf) 200 { 201 struct proc *p = l->l_proc; 202 int oticks = 0; /* XXX why zero? */ 203 204 do { 205 l->l_md.md_astpending = 0; 206 //curcpu()->ci_data.cpu_nast++; 207 mi_userret(l); 208 } while (l->l_md.md_astpending); 209 210 /* 211 * If profiling, charge recent system time to the trapped pc. 212 */ 213 if (p->p_stflag & PST_PROFIL) { 214 extern int psratio; 215 216 addupc_task(l, tf->tf_iioq_head, 217 (int)(p->p_sticks - oticks) * psratio); 218 } 219 } 220 221 /* 222 * This handles some messy kernel debugger details. 223 * It dispatches into either kgdb or DDB, and knows 224 * about some special things to do, like skipping over 225 * break instructions and how to really set up for 226 * a single-step. 227 */ 228 #if defined(KGDB) || defined(DDB) 229 static int 230 trap_kdebug(int type, int code, struct trapframe *frame) 231 { 232 int handled; 233 u_int tf_iioq_head_old; 234 u_int tf_iioq_tail_old; 235 236 for (;;) { 237 238 /* This trap has not been handled. */ 239 handled = 0; 240 241 /* Remember the instruction offset queue. */ 242 tf_iioq_head_old = frame->tf_iioq_head; 243 tf_iioq_tail_old = frame->tf_iioq_tail; 244 245 #ifdef KGDB 246 /* Let KGDB handle it (if connected) */ 247 if (!handled) 248 handled = kgdb_trap(type, frame); 249 #endif 250 #ifdef DDB 251 /* Let DDB handle it. */ 252 if (!handled) 253 handled = kdb_trap(type, code, frame); 254 #endif 255 256 /* If this trap wasn't handled, return now. */ 257 if (!handled) 258 return(0); 259 260 /* 261 * If the instruction offset queue head changed, but the offset 262 * queue tail didn't, assume that the user wants to jump to the 263 * head offset, and adjust the tail accordingly. This should 264 * fix the kgdb `jump' command, and can help DDB users who `set' 265 * 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. If we're trying to 273 * step through a nullified instruction, just advance by hand 274 * and trap again. Otherwise, load the recovery counter with 275 * 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 really only work when 313 * code has been compiled without optimization, as they assume a certain func- 314 * tion prologue sets up a frame pointer and stores the return pointer and arg- 315 * uments in it. 316 */ 317 static void 318 user_backtrace_raw(u_int pc, u_int fp) 319 { 320 int frame_number; 321 int arg_number; 322 uint32_t val; 323 324 for (frame_number = 0; 325 frame_number < 100 && pc > HPPA_PC_PRIV_MASK && fp; 326 frame_number++) { 327 328 printf("%3d: pc=%08x%s fp=0x%08x", frame_number, 329 pc & ~HPPA_PC_PRIV_MASK, USERMODE(pc) ? " " : "**", fp); 330 for (arg_number = 0; arg_number < 4; arg_number++) { 331 if (ufetch_32(HPPA_FRAME_CARG(arg_number, fp), 332 &val) == 0) { 333 printf(" arg%d=0x%08x", arg_number, val); 334 } else { 335 printf(" arg%d=<bad address>", arg_number); 336 } 337 } 338 printf("\n"); 339 if (ufetch_int((((uint32_t *) fp) - 5), &pc) != 0) { 340 printf(" ufetch for pc failed\n"); 341 break; 342 } 343 if (ufetch_int((((uint32_t *) fp) + 0), &fp) != 0) { 344 printf(" ufetch for fp failed\n"); 345 break; 346 } 347 } 348 printf(" backtrace stopped with pc %08x fp 0x%08x\n", pc, fp); 349 } 350 351 static void 352 user_backtrace(struct trapframe *tf, struct lwp *l, int type) 353 { 354 struct proc *p = l->l_proc; 355 u_int pc, fp, inst; 356 357 /* 358 * Display any trap type that we have. 359 */ 360 if (type >= 0) 361 printf("pid %d (%s) trap #%d\n", 362 p->p_pid, p->p_comm, type & ~T_USER); 363 364 /* 365 * Assuming that the frame pointer in r3 is valid, 366 * dump out a stack trace. 367 */ 368 fp = tf->tf_r3; 369 printf("pid %d (%s) backtrace, starting with fp 0x%08x\n", 370 p->p_pid, p->p_comm, fp); 371 user_backtrace_raw(tf->tf_iioq_head, fp); 372 373 /* 374 * In case the frame pointer in r3 is not valid, assuming the stack 375 * pointer is valid and the faulting function is a non-leaf, if we can 376 * find its prologue we can recover its frame pointer. 377 */ 378 pc = tf->tf_iioq_head; 379 fp = tf->tf_sp - HPPA_FRAME_SIZE; 380 printf("pid %d (%s) backtrace, starting with sp 0x%08x pc 0x%08x\n", 381 p->p_pid, p->p_comm, tf->tf_sp, pc); 382 for (pc &= ~HPPA_PC_PRIV_MASK; pc > 0; pc -= sizeof(inst)) { 383 if (ufetch_int((u_int *) pc, &inst) != 0) { 384 printf(" ufetch for inst at pc %08x failed\n", pc); 385 break; 386 } 387 /* Check for the prologue instruction that sets sp. */ 388 if (STWM_R1_D_SR0_SP(inst)) { 389 fp = tf->tf_sp - STWM_R1_D_SR0_SP(inst); 390 printf(" sp from fp at pc %08x: %08x\n", pc, inst); 391 break; 392 } 393 } 394 user_backtrace_raw(tf->tf_iioq_head, fp); 395 } 396 #endif /* DEBUG || USERTRACE */ 397 398 #ifdef DEBUG 399 /* 400 * This sanity-checks a trapframe. It is full of various assumptions about 401 * what a healthy CPU state should be, with some documented elsewhere, some not. 402 */ 403 void 404 frame_sanity_check(const char *func, int line, int type, struct trapframe *tf, 405 struct lwp *l) 406 { 407 #if 0 408 extern int kernel_text; 409 extern int etext; 410 #endif 411 struct cpu_info *ci = curcpu(); 412 413 #define SANITY(e) \ 414 do { \ 415 if (sanity_frame == NULL && !(e)) { \ 416 sanity_frame = tf; \ 417 sanity_lwp = l; \ 418 sanity_string = #e; \ 419 } \ 420 } while (/* CONSTCOND */ 0) 421 422 KASSERT(l != NULL); 423 SANITY((tf->tf_ipsw & ci->ci_psw) == ci->ci_psw); 424 SANITY((ci->ci_psw & PSW_I) == 0 || tf->tf_eiem != 0); 425 if (tf->tf_iisq_head == HPPA_SID_KERNEL) { 426 vaddr_t minsp, maxsp, uv; 427 428 uv = uvm_lwp_getuarea(l); 429 430 /* 431 * If the trap happened in the gateway page, we take the easy 432 * way out and assume that the trapframe is okay. 433 */ 434 if ((tf->tf_iioq_head & ~PAGE_MASK) == SYSCALLGATE) 435 goto out; 436 437 SANITY(!USERMODE(tf->tf_iioq_head)); 438 SANITY(!USERMODE(tf->tf_iioq_tail)); 439 440 /* 441 * Don't check the instruction queues or stack on interrupts 442 * as we could be in the sti code (outside normal kernel 443 * text) or switching LWPs (curlwp and sp are not in sync) 444 */ 445 if ((type & ~T_USER) == T_INTERRUPT) 446 goto out; 447 #if 0 448 SANITY(tf->tf_iioq_head >= (u_int) &kernel_text); 449 SANITY(tf->tf_iioq_head < (u_int) &etext); 450 SANITY(tf->tf_iioq_tail >= (u_int) &kernel_text); 451 SANITY(tf->tf_iioq_tail < (u_int) &etext); 452 #endif 453 454 maxsp = uv + USPACE + PAGE_SIZE; 455 minsp = uv + PAGE_SIZE; 456 457 SANITY(tf->tf_sp >= minsp && tf->tf_sp < maxsp); 458 } else { 459 struct pcb *pcb = lwp_getpcb(l); 460 461 SANITY(USERMODE(tf->tf_iioq_head)); 462 SANITY(USERMODE(tf->tf_iioq_tail)); 463 SANITY(tf->tf_cr30 == (u_int)pcb->pcb_fpregs); 464 } 465 #undef SANITY 466 out: 467 if (sanity_frame == tf) { 468 printf("insanity: '%s' at %s:%d type 0x%x tf %p lwp %p " 469 "sp 0x%x pc 0x%x\n", 470 sanity_string, func, line, type, sanity_frame, sanity_lwp, 471 tf->tf_sp, tf->tf_iioq_head); 472 (void) trap_kdebug(T_IBREAK, 0, tf); 473 sanity_frame = NULL; 474 sanity_lwp = NULL; 475 } 476 } 477 #endif /* DEBUG */ 478 479 480 #define __PABITS(x, y) __BITS(31 - (x), 31 - (y)) 481 #define __PABIT(x) __BIT(31 - (x)) 482 483 #define LPA_MASK \ 484 ( __PABITS(0, 5) | \ 485 __PABITS(18, 25)) 486 #define LPA \ 487 (__SHIFTIN(1, __PABITS(0, 5)) | \ 488 __SHIFTIN(0x4d, __PABITS(18, 25))) 489 490 491 #define PROBE_ENCS (0x46 | 0xc6 | 0x47 | 0xc7) 492 #define PROBE_PL __PABITS(11, 15) 493 #define PROBE_IMMED __PABIT(18) 494 #define PROBE_RW __PABIT(25) 495 496 #define PROBE_MASK \ 497 (( __PABITS(0, 5) | \ 498 __PABITS(18, 25) | \ 499 __PABIT(26)) ^ \ 500 (PROBE_IMMED | PROBE_RW)) 501 502 #define PROBE \ 503 ((__SHIFTIN(1, __PABITS(0, 5)) | \ 504 __SHIFTIN(PROBE_ENCS, __PABITS(18, 25)) | \ 505 __SHIFTIN(0, __PABIT(26))) ^ \ 506 (PROBE_IMMED | PROBE_RW)) 507 508 #define PLMASK __BITS(1, 0) 509 510 511 /* for hppa64 */ 512 CTASSERT(sizeof(register_t) == sizeof(u_int)); 513 size_t hppa_regmap[] = { 514 0, /* r0 is special case */ 515 offsetof(struct trapframe, tf_r1 ) / sizeof(register_t), 516 offsetof(struct trapframe, tf_rp ) / sizeof(register_t), 517 offsetof(struct trapframe, tf_r3 ) / sizeof(register_t), 518 offsetof(struct trapframe, tf_r4 ) / sizeof(register_t), 519 offsetof(struct trapframe, tf_r5 ) / sizeof(register_t), 520 offsetof(struct trapframe, tf_r6 ) / sizeof(register_t), 521 offsetof(struct trapframe, tf_r7 ) / sizeof(register_t), 522 offsetof(struct trapframe, tf_r8 ) / sizeof(register_t), 523 offsetof(struct trapframe, tf_r9 ) / sizeof(register_t), 524 offsetof(struct trapframe, tf_r10 ) / sizeof(register_t), 525 offsetof(struct trapframe, tf_r11 ) / sizeof(register_t), 526 offsetof(struct trapframe, tf_r12 ) / sizeof(register_t), 527 offsetof(struct trapframe, tf_r13 ) / sizeof(register_t), 528 offsetof(struct trapframe, tf_r14 ) / sizeof(register_t), 529 offsetof(struct trapframe, tf_r15 ) / sizeof(register_t), 530 offsetof(struct trapframe, tf_r16 ) / sizeof(register_t), 531 offsetof(struct trapframe, tf_r17 ) / sizeof(register_t), 532 offsetof(struct trapframe, tf_r18 ) / sizeof(register_t), 533 offsetof(struct trapframe, tf_t4 ) / sizeof(register_t), 534 offsetof(struct trapframe, tf_t3 ) / sizeof(register_t), 535 offsetof(struct trapframe, tf_t2 ) / sizeof(register_t), 536 offsetof(struct trapframe, tf_t1 ) / sizeof(register_t), 537 offsetof(struct trapframe, tf_arg3) / sizeof(register_t), 538 offsetof(struct trapframe, tf_arg2) / sizeof(register_t), 539 offsetof(struct trapframe, tf_arg1) / sizeof(register_t), 540 offsetof(struct trapframe, tf_arg0) / sizeof(register_t), 541 offsetof(struct trapframe, tf_dp ) / sizeof(register_t), 542 offsetof(struct trapframe, tf_ret0) / sizeof(register_t), 543 offsetof(struct trapframe, tf_ret1) / sizeof(register_t), 544 offsetof(struct trapframe, tf_sp ) / sizeof(register_t), 545 offsetof(struct trapframe, tf_r31 ) / sizeof(register_t), 546 }; 547 548 549 static inline register_t 550 tf_getregno(struct trapframe *tf, u_int regno) 551 { 552 register_t *tf_reg = (register_t *)tf; 553 if (regno == 0) 554 return 0; 555 else 556 return tf_reg[hppa_regmap[regno]]; 557 } 558 559 static inline void 560 tf_setregno(struct trapframe *tf, u_int regno, register_t val) 561 { 562 register_t *tf_reg = (register_t *)tf; 563 if (regno == 0) 564 return; 565 else 566 tf_reg[hppa_regmap[regno]] = val; 567 } 568 569 void 570 trap(int type, struct trapframe *frame) 571 { 572 struct lwp *l; 573 struct proc *p; 574 struct pcb *pcb; 575 vaddr_t va; 576 struct vm_map *map; 577 struct vmspace *vm; 578 vm_prot_t vftype; 579 pa_space_t space; 580 ksiginfo_t ksi; 581 u_int opcode, onfault; 582 int ret; 583 const char *tts = "reserved"; 584 int trapnum; 585 #ifdef DIAGNOSTIC 586 extern int emergency_stack_start, emergency_stack_end; 587 struct cpu_info *ci = curcpu(); 588 int oldcpl = ci->ci_cpl; 589 #endif 590 591 trapnum = type & ~T_USER; 592 opcode = frame->tf_iir; 593 594 if (trapnum <= T_EXCEPTION || trapnum == T_HIGHERPL || 595 trapnum == T_LOWERPL || trapnum == T_TAKENBR || 596 trapnum == T_IDEBUG || trapnum == T_PERFMON) { 597 va = frame->tf_iioq_head; 598 space = frame->tf_iisq_head; 599 vftype = VM_PROT_EXECUTE; 600 } else { 601 va = frame->tf_ior; 602 space = frame->tf_isr; 603 vftype = inst_store(opcode) ? VM_PROT_WRITE : VM_PROT_READ; 604 } 605 606 KASSERT(curlwp != NULL); 607 l = curlwp; 608 p = l->l_proc; 609 if ((type & T_USER) != 0) 610 LWP_CACHE_CREDS(l, p); 611 612 #ifdef DIAGNOSTIC 613 /* 614 * If we are on the emergency stack, then we either got 615 * a fault on the kernel stack, or we're just handling 616 * a trap for the machine check handler (which also 617 * runs on the emergency stack). 618 * 619 * We *very crudely* differentiate between the two cases 620 * by checking the faulting instruction: if it is the 621 * function prologue instruction that stores the old 622 * frame pointer and updates the stack pointer, we assume 623 * that we faulted on the kernel stack. 624 * 625 * In this case, not completing that instruction will 626 * probably confuse backtraces in kgdb/ddb. Completing 627 * it would be difficult, because we already faulted on 628 * that part of the stack, so instead we fix up the 629 * frame as if the function called has just returned. 630 * This has peculiar knowledge about what values are in 631 * what registers during the "normal gcc -g" prologue. 632 */ 633 if (&type >= &emergency_stack_start && 634 &type < &emergency_stack_end && 635 type != T_IBREAK && STWM_R1_D_SR0_SP(opcode)) { 636 /* Restore the caller's frame pointer. */ 637 frame->tf_r3 = frame->tf_r1; 638 /* Restore the caller's instruction offsets. */ 639 frame->tf_iioq_head = frame->tf_rp; 640 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 641 goto dead_end; 642 } 643 #endif /* DIAGNOSTIC */ 644 645 #ifdef DEBUG 646 frame_sanity_check(__func__, __LINE__, type, frame, l); 647 #endif /* DEBUG */ 648 649 if (frame->tf_flags & TFF_LAST) 650 l->l_md.md_regs = frame; 651 652 if (trapnum <= trap_types) 653 tts = trap_type[trapnum]; 654 655 #ifdef TRAPDEBUG 656 if (trapnum != T_INTERRUPT && trapnum != T_IBREAK) 657 printf("trap: %d, %s for %x:%lx at %x:%x, fp=%p, rp=%x\n", 658 type, tts, space, va, frame->tf_iisq_head, 659 frame->tf_iioq_head, frame, frame->tf_rp); 660 else if (trapnum == T_IBREAK) 661 printf("trap: break instruction %x:%x at %x:%x, fp=%p\n", 662 break5(opcode), break13(opcode), 663 frame->tf_iisq_head, frame->tf_iioq_head, frame); 664 665 { 666 extern int etext; 667 if (frame < (struct trapframe *)&etext) { 668 printf("trap: bogus frame ptr %p\n", frame); 669 goto dead_end; 670 } 671 } 672 #endif 673 674 pcb = lwp_getpcb(l); 675 676 /* If this is a trap, not an interrupt, reenable interrupts. */ 677 if (trapnum != T_INTERRUPT) { 678 curcpu()->ci_data.cpu_ntrap++; 679 mtctl(frame->tf_eiem, CR_EIEM); 680 } 681 682 const bool user = (type & T_USER) != 0; 683 switch (type) { 684 case T_NONEXIST: 685 case T_NONEXIST | T_USER: 686 #if !defined(DDB) && !defined(KGDB) 687 /* we've got screwed up by the central scrutinizer */ 688 panic ("trap: elvis has just left the building!"); 689 break; 690 #else 691 goto dead_end; 692 #endif 693 case T_RECOVERY | T_USER: 694 #ifdef USERTRACE 695 for (;;) { 696 if (frame->tf_iioq_head != rctr_next_iioq) 697 printf("-%08x\nr %08x", 698 rctr_next_iioq - 4, 699 frame->tf_iioq_head); 700 rctr_next_iioq = frame->tf_iioq_head + 4; 701 if (frame->tf_ipsw & PSW_N) { 702 /* Advance the program counter. */ 703 frame->tf_iioq_head = frame->tf_iioq_tail; 704 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 705 /* Clear flags. */ 706 frame->tf_ipsw &= ~(PSW_N|PSW_X|PSW_Y|PSW_Z|PSW_B|PSW_T|PSW_H|PSW_L); 707 /* Simulate another trap. */ 708 continue; 709 } 710 break; 711 } 712 frame->tf_rctr = 0; 713 break; 714 #endif /* USERTRACE */ 715 case T_RECOVERY: 716 #if !defined(DDB) && !defined(KGDB) 717 /* XXX will implement later */ 718 printf ("trap: handicapped"); 719 break; 720 #else 721 goto dead_end; 722 #endif 723 724 case T_EMULATION | T_USER: 725 hppa_fpu_emulate(frame, l, opcode); 726 break; 727 728 case T_DATALIGN: 729 onfault = pcb->pcb_onfault; 730 if (onfault) { 731 ret = EFAULT; 732 do_onfault: 733 frame->tf_iioq_head = onfault; 734 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 735 frame->tf_ret0 = ret; 736 break; 737 } 738 /*FALLTHROUGH*/ 739 740 #ifdef DIAGNOSTIC 741 /* these just can't happen ever */ 742 case T_PRIV_OP: 743 case T_PRIV_REG: 744 /* these just can't make it to the trap() ever */ 745 case T_HPMC: 746 case T_HPMC | T_USER: 747 case T_EMULATION: 748 case T_EXCEPTION: 749 #endif 750 case T_IBREAK: 751 case T_DBREAK: 752 dead_end: 753 if (type & T_USER) { 754 #ifdef DEBUG 755 user_backtrace(frame, l, type); 756 #endif 757 KSI_INIT_TRAP(&ksi); 758 ksi.ksi_signo = SIGILL; 759 ksi.ksi_code = ILL_ILLTRP; 760 ksi.ksi_trap = type; 761 ksi.ksi_addr = (void *)frame->tf_iioq_head; 762 trapsignal(l, &ksi); 763 break; 764 } 765 if (trap_kdebug(type, va, frame)) 766 return; 767 else if (type == T_DATALIGN) 768 panic ("trap: %s at 0x%x", tts, (u_int) va); 769 else 770 panic ("trap: no debugger for \"%s\" (%d)", tts, type); 771 break; 772 773 case T_IBREAK | T_USER: 774 case T_DBREAK | T_USER: 775 KSI_INIT_TRAP(&ksi); 776 ksi.ksi_signo = SIGTRAP; 777 ksi.ksi_code = TRAP_BRKPT; 778 ksi.ksi_trap = trapnum; 779 ksi.ksi_addr = (void *)(frame->tf_iioq_head & ~HPPA_PC_PRIV_MASK); 780 #ifdef PTRACE 781 ss_clear_breakpoints(l); 782 if (opcode == SSBREAKPOINT) 783 ksi.ksi_code = TRAP_TRACE; 784 #endif 785 /* pass to user debugger */ 786 trapsignal(l, &ksi); 787 break; 788 789 #ifdef PTRACE 790 case T_TAKENBR | T_USER: 791 ss_clear_breakpoints(l); 792 793 KSI_INIT_TRAP(&ksi); 794 ksi.ksi_signo = SIGTRAP; 795 ksi.ksi_code = TRAP_TRACE; 796 ksi.ksi_trap = trapnum; 797 ksi.ksi_addr = (void *)(frame->tf_iioq_head & ~HPPA_PC_PRIV_MASK); 798 799 /* pass to user debugger */ 800 trapsignal(l, &ksi); 801 break; 802 #endif 803 804 case T_EXCEPTION | T_USER: { /* co-proc assist trap */ 805 uint64_t *fpp; 806 uint32_t *pex, ex, inst; 807 int i; 808 809 hppa_fpu_flush(l); 810 fpp = (uint64_t *)pcb->pcb_fpregs; 811 812 /* skip the status register */ 813 pex = (uint32_t *)&fpp[0]; 814 pex++; 815 816 /* loop through the exception registers */ 817 for (i = 1; i < 8 && !*pex; i++, pex++) 818 ; 819 KASSERT(i < 8); 820 ex = *pex; 821 *pex = 0; 822 823 /* reset the trap flag, as if there was none */ 824 fpp[0] &= ~(((uint64_t)HPPA_FPU_T) << 32); 825 826 /* emulate the instruction */ 827 inst = ((uint32_t)fpopmap[ex >> 26] << 26) | (ex & 0x03ffffff); 828 hppa_fpu_emulate(frame, l, inst); 829 } 830 break; 831 832 case T_OVERFLOW | T_USER: 833 KSI_INIT_TRAP(&ksi); 834 ksi.ksi_signo = SIGFPE; 835 ksi.ksi_code = SI_NOINFO; 836 ksi.ksi_trap = type; 837 ksi.ksi_addr = (void *)va; 838 trapsignal(l, &ksi); 839 break; 840 841 case T_CONDITION | T_USER: 842 KSI_INIT_TRAP(&ksi); 843 ksi.ksi_signo = SIGFPE; 844 ksi.ksi_code = FPE_INTDIV; 845 ksi.ksi_trap = type; 846 ksi.ksi_addr = (void *)va; 847 trapsignal(l, &ksi); 848 break; 849 850 case T_ILLEGAL | T_USER: 851 #ifdef DEBUG 852 user_backtrace(frame, l, type); 853 #endif 854 KSI_INIT_TRAP(&ksi); 855 ksi.ksi_signo = SIGILL; 856 ksi.ksi_code = ILL_ILLOPC; 857 ksi.ksi_trap = type; 858 ksi.ksi_addr = (void *)va; 859 trapsignal(l, &ksi); 860 break; 861 862 case T_PRIV_OP | T_USER: 863 #ifdef DEBUG 864 user_backtrace(frame, l, type); 865 #endif 866 KSI_INIT_TRAP(&ksi); 867 ksi.ksi_signo = SIGILL; 868 ksi.ksi_code = ILL_PRVOPC; 869 ksi.ksi_trap = type; 870 ksi.ksi_addr = (void *)va; 871 trapsignal(l, &ksi); 872 break; 873 874 case T_PRIV_REG | T_USER: 875 #ifdef DEBUG 876 user_backtrace(frame, l, type); 877 #endif 878 KSI_INIT_TRAP(&ksi); 879 ksi.ksi_signo = SIGILL; 880 ksi.ksi_code = ILL_PRVREG; 881 ksi.ksi_trap = type; 882 ksi.ksi_addr = (void *)va; 883 trapsignal(l, &ksi); 884 break; 885 886 /* these should never got here */ 887 case T_HIGHERPL | T_USER: 888 case T_LOWERPL | T_USER: 889 KSI_INIT_TRAP(&ksi); 890 ksi.ksi_signo = SIGSEGV; 891 ksi.ksi_code = SEGV_ACCERR; 892 ksi.ksi_trap = type; 893 ksi.ksi_addr = (void *)va; 894 trapsignal(l, &ksi); 895 break; 896 897 case T_IPROT | T_USER: 898 case T_DPROT | T_USER: 899 KSI_INIT_TRAP(&ksi); 900 ksi.ksi_signo = SIGSEGV; 901 ksi.ksi_code = SEGV_ACCERR; 902 ksi.ksi_trap = type; 903 ksi.ksi_addr = (void *)va; 904 trapsignal(l, &ksi); 905 break; 906 907 case T_ITLBMISSNA: case T_USER | T_ITLBMISSNA: 908 case T_DTLBMISSNA: case T_USER | T_DTLBMISSNA: 909 vm = p->p_vmspace; 910 911 if (!vm) { 912 #ifdef TRAPDEBUG 913 printf("trap: no vm, p=%p\n", p); 914 #endif 915 goto dead_end; 916 } 917 918 /* 919 * it could be a kernel map for exec_map faults 920 */ 921 if (!user && space == HPPA_SID_KERNEL) 922 map = kernel_map; 923 else { 924 map = &vm->vm_map; 925 } 926 927 va = trunc_page(va); 928 929 if ((opcode & LPA_MASK) == LPA) { 930 /* lpa failure case */ 931 const u_int regno = 932 __SHIFTOUT(opcode, __PABITS(27, 31)); 933 tf_setregno(frame, regno, 0); 934 frame->tf_ipsw |= PSW_N; 935 } else if ((opcode & PROBE_MASK) == PROBE) { 936 u_int pl; 937 if ((opcode & PROBE_IMMED) != 0) { 938 pl = __SHIFTOUT(opcode, PROBE_PL) & PLMASK; 939 } else { 940 const u_int plreg = 941 __SHIFTOUT(opcode, PROBE_PL); 942 pl = tf_getregno(frame, plreg) & PLMASK; 943 } 944 945 bool ok = true; 946 if ((user && space == HPPA_SID_KERNEL) || 947 (frame->tf_iioq_head & HPPA_PC_PRIV_MASK) != pl || 948 (user && va >= VM_MAXUSER_ADDRESS)) { 949 ok = false; 950 } else { 951 /* Never call uvm_fault in interrupt context. */ 952 KASSERT(curcpu()->ci_intr_depth == 0); 953 954 const bool read = 955 __SHIFTOUT(opcode, PROBE_RW) == 0; 956 onfault = pcb->pcb_onfault; 957 pcb->pcb_onfault = 0; 958 ret = uvm_fault(map, va, read ? 959 VM_PROT_READ : VM_PROT_WRITE); 960 pcb->pcb_onfault = onfault; 961 962 if (ret) 963 ok = false; 964 } 965 if (!ok) { 966 const u_int regno = 967 __SHIFTOUT(opcode, __PABITS(27, 31)); 968 tf_setregno(frame, regno, 0); 969 frame->tf_ipsw |= PSW_N; 970 } 971 } 972 break; 973 974 case T_DATACC: case T_USER | T_DATACC: 975 case T_ITLBMISS: case T_USER | T_ITLBMISS: 976 case T_DTLBMISS: case T_USER | T_DTLBMISS: 977 case T_TLB_DIRTY: case T_USER | T_TLB_DIRTY: 978 vm = p->p_vmspace; 979 980 if (!vm) { 981 #ifdef TRAPDEBUG 982 printf("trap: no vm, p=%p\n", p); 983 #endif 984 goto dead_end; 985 } 986 987 /* 988 * it could be a kernel map for exec_map faults 989 */ 990 if (!(type & T_USER) && space == HPPA_SID_KERNEL) 991 map = kernel_map; 992 else { 993 map = &vm->vm_map; 994 } 995 996 va = trunc_page(va); 997 998 if (map->pmap->pm_space != space) { 999 #ifdef TRAPDEBUG 1000 printf("trap: space mismatch %d != %d\n", 1001 space, map->pmap->pm_space); 1002 #endif 1003 /* actually dump the user, crap the kernel */ 1004 goto dead_end; 1005 } 1006 1007 /* Never call uvm_fault in interrupt context. */ 1008 KASSERT(curcpu()->ci_intr_depth == 0); 1009 1010 onfault = pcb->pcb_onfault; 1011 pcb->pcb_onfault = 0; 1012 ret = uvm_fault(map, va, vftype); 1013 pcb->pcb_onfault = onfault; 1014 1015 #ifdef TRAPDEBUG 1016 printf("uvm_fault(%p, %x, %d)=%d\n", 1017 map, (u_int)va, vftype, ret); 1018 #endif 1019 1020 /* 1021 * If this was a stack access we keep track of the maximum 1022 * accessed stack size. Also, if uvm_fault gets a protection 1023 * failure it is due to accessing the stack region outside 1024 * the current limit and we need to reflect that as an access 1025 * error. 1026 */ 1027 if (map != kernel_map && va >= (vaddr_t)vm->vm_minsaddr) { 1028 if (ret == 0) 1029 uvm_grow(l->l_proc, va); 1030 else if (ret == EACCES) 1031 ret = EFAULT; 1032 } 1033 1034 if (ret != 0) { 1035 if (type & T_USER) { 1036 #ifdef DEBUG 1037 user_backtrace(frame, l, type); 1038 #endif 1039 KSI_INIT_TRAP(&ksi); 1040 switch (ret) { 1041 case EACCES: 1042 ksi.ksi_signo = SIGSEGV; 1043 ksi.ksi_code = SEGV_ACCERR; 1044 break; 1045 case ENOMEM: 1046 ksi.ksi_signo = SIGKILL; 1047 printf("UVM: pid %d (%s), uid %d " 1048 "killed: out of swap\n", 1049 p->p_pid, p->p_comm, 1050 l->l_cred ? 1051 kauth_cred_geteuid(l->l_cred) 1052 : -1); 1053 break; 1054 case EINVAL: 1055 ksi.ksi_signo = SIGBUS; 1056 ksi.ksi_code = BUS_ADRERR; 1057 break; 1058 default: 1059 ksi.ksi_signo = SIGSEGV; 1060 ksi.ksi_code = SEGV_MAPERR; 1061 break; 1062 } 1063 ksi.ksi_trap = type; 1064 ksi.ksi_addr = (void *)va; 1065 trapsignal(l, &ksi); 1066 } else { 1067 if (onfault) { 1068 goto do_onfault; 1069 } 1070 panic("trap: uvm_fault(%p, %lx, %d): %d", 1071 map, va, vftype, ret); 1072 } 1073 } 1074 break; 1075 1076 case T_DATALIGN | T_USER: 1077 #ifdef DEBUG 1078 user_backtrace(frame, l, type); 1079 #endif 1080 KSI_INIT_TRAP(&ksi); 1081 ksi.ksi_signo = SIGBUS; 1082 ksi.ksi_code = BUS_ADRALN; 1083 ksi.ksi_trap = type; 1084 ksi.ksi_addr = (void *)va; 1085 trapsignal(l, &ksi); 1086 break; 1087 1088 case T_INTERRUPT: 1089 case T_INTERRUPT | T_USER: 1090 hppa_intr(frame); 1091 mtctl(frame->tf_eiem, CR_EIEM); 1092 break; 1093 1094 case T_LOWERPL: 1095 case T_DPROT: 1096 case T_IPROT: 1097 case T_OVERFLOW: 1098 case T_CONDITION: 1099 case T_ILLEGAL: 1100 case T_HIGHERPL: 1101 case T_TAKENBR: 1102 case T_POWERFAIL: 1103 case T_LPMC: 1104 case T_PAGEREF: 1105 case T_DATAPID: case T_DATAPID | T_USER: 1106 if (0 /* T-chip */) { 1107 break; 1108 } 1109 /* FALLTHROUGH to unimplemented */ 1110 default: 1111 panic ("trap: unimplemented \'%s\' (%d)", tts, type); 1112 } 1113 1114 #ifdef DIAGNOSTIC 1115 if (ci->ci_cpl != oldcpl) 1116 printf("WARNING: SPL (%d) NOT LOWERED ON TRAP (%d) EXIT\n", 1117 ci->ci_cpl, trapnum); 1118 #endif 1119 1120 if (type & T_USER) 1121 userret(l, l->l_md.md_regs); 1122 1123 #ifdef DEBUG 1124 frame_sanity_check(__func__, __LINE__, type, frame, l); 1125 if (frame->tf_flags & TFF_LAST && (curlwp->l_flag & LW_IDLE) == 0) 1126 frame_sanity_check(__func__, __LINE__, type, 1127 curlwp->l_md.md_regs, curlwp); 1128 #endif /* DEBUG */ 1129 } 1130 1131 void 1132 md_child_return(struct lwp *l) 1133 { 1134 /* 1135 * Return values in the frame set by cpu_lwp_fork(). 1136 */ 1137 1138 userret(l, l->l_md.md_regs); 1139 #ifdef DEBUG 1140 frame_sanity_check(__func__, __LINE__, 0, l->l_md.md_regs, l); 1141 #endif /* DEBUG */ 1142 } 1143 1144 /* 1145 * Process the tail end of a posix_spawn() for the child. 1146 */ 1147 void 1148 cpu_spawn_return(struct lwp *l) 1149 { 1150 1151 userret(l, l->l_md.md_regs); 1152 #ifdef DEBUG 1153 frame_sanity_check(__func__, __LINE__, 0, l->l_md.md_regs, l); 1154 #endif /* DEBUG */ 1155 } 1156 1157 #ifdef PTRACE 1158 1159 #include <sys/ptrace.h> 1160 1161 int 1162 ss_get_value(struct lwp *l, vaddr_t addr, u_int *value) 1163 { 1164 struct uio uio; 1165 struct iovec iov; 1166 1167 iov.iov_base = (void *)value; 1168 iov.iov_len = sizeof(u_int); 1169 uio.uio_iov = &iov; 1170 uio.uio_iovcnt = 1; 1171 uio.uio_offset = (off_t)addr; 1172 uio.uio_resid = sizeof(u_int); 1173 uio.uio_rw = UIO_READ; 1174 UIO_SETUP_SYSSPACE(&uio); 1175 1176 return (process_domem(curlwp, l, &uio)); 1177 } 1178 1179 int 1180 ss_put_value(struct lwp *l, vaddr_t addr, u_int value) 1181 { 1182 struct uio uio; 1183 struct iovec iov; 1184 1185 iov.iov_base = (void *)&value; 1186 iov.iov_len = sizeof(u_int); 1187 uio.uio_iov = &iov; 1188 uio.uio_iovcnt = 1; 1189 uio.uio_offset = (off_t)addr; 1190 uio.uio_resid = sizeof(u_int); 1191 uio.uio_rw = UIO_WRITE; 1192 UIO_SETUP_SYSSPACE(&uio); 1193 1194 return (process_domem(curlwp, l, &uio)); 1195 } 1196 1197 void 1198 ss_clear_breakpoints(struct lwp *l) 1199 { 1200 /* Restore original instructions. */ 1201 if (l->l_md.md_bpva != 0) { 1202 ss_put_value(l, l->l_md.md_bpva, l->l_md.md_bpsave[0]); 1203 ss_put_value(l, l->l_md.md_bpva + 4, l->l_md.md_bpsave[1]); 1204 l->l_md.md_bpva = 0; 1205 } 1206 } 1207 1208 1209 int 1210 process_sstep(struct lwp *l, int sstep) 1211 { 1212 struct trapframe *tf = l->l_md.md_regs; 1213 int error; 1214 1215 ss_clear_breakpoints(l); 1216 1217 /* We're continuing... */ 1218 if (sstep == 0) { 1219 tf->tf_ipsw &= ~PSW_T; 1220 return 0; 1221 } 1222 1223 /* 1224 * Don't touch the syscall gateway page. Instead, insert a 1225 * breakpoint where we're supposed to return. 1226 */ 1227 if ((tf->tf_iioq_tail & ~PAGE_MASK) == SYSCALLGATE) 1228 l->l_md.md_bpva = tf->tf_r31 & ~HPPA_PC_PRIV_MASK; 1229 else 1230 l->l_md.md_bpva = tf->tf_iioq_tail & ~HPPA_PC_PRIV_MASK; 1231 1232 error = ss_get_value(l, l->l_md.md_bpva, &l->l_md.md_bpsave[0]); 1233 if (error) 1234 return error; 1235 error = ss_get_value(l, l->l_md.md_bpva + 4, &l->l_md.md_bpsave[1]); 1236 if (error) 1237 return error; 1238 1239 error = ss_put_value(l, l->l_md.md_bpva, SSBREAKPOINT); 1240 if (error) 1241 return error; 1242 error = ss_put_value(l, l->l_md.md_bpva + 4, SSBREAKPOINT); 1243 if (error) 1244 return error; 1245 1246 if ((tf->tf_iioq_tail & ~PAGE_MASK) == SYSCALLGATE) 1247 tf->tf_ipsw &= ~PSW_T; 1248 else 1249 tf->tf_ipsw |= PSW_T; 1250 1251 return 0; 1252 } 1253 #endif 1254 1255 1256 /* 1257 * call actual syscall routine 1258 * from the low-level syscall handler: 1259 * - all HPPA_FRAME_NARGS syscall's arguments supposed to be copied onto 1260 * our stack, this wins compared to copyin just needed amount anyway 1261 * - register args are copied onto stack too 1262 */ 1263 void 1264 syscall(struct trapframe *frame, int *args) 1265 { 1266 struct lwp *l; 1267 struct proc *p; 1268 const struct sysent *callp; 1269 size_t nargs64; 1270 int nsys, code, error; 1271 int tmp; 1272 int rval[2]; 1273 #ifdef DIAGNOSTIC 1274 struct cpu_info *ci = curcpu(); 1275 int oldcpl = ci->ci_cpl; 1276 #endif 1277 1278 curcpu()->ci_data.cpu_nsyscall++; 1279 1280 #ifdef DEBUG 1281 frame_sanity_check(__func__, __LINE__, 0, frame, curlwp); 1282 #endif /* DEBUG */ 1283 1284 if (!USERMODE(frame->tf_iioq_head)) 1285 panic("syscall"); 1286 1287 KASSERT(curlwp != NULL); 1288 l = curlwp; 1289 p = l->l_proc; 1290 l->l_md.md_regs = frame; 1291 nsys = p->p_emul->e_nsysent; 1292 callp = p->p_emul->e_sysent; 1293 code = frame->tf_t1; 1294 LWP_CACHE_CREDS(l, p); 1295 1296 /* 1297 * Restarting a system call is touchy on the HPPA, because syscall 1298 * arguments are passed in registers and the program counter of the 1299 * syscall "point" isn't easily divined. 1300 * 1301 * We handle the first problem by assuming that we will have to restart 1302 * this system call, so we stuff the first four words of the original 1303 * arguments back into the frame as arg0...arg3, which is where we 1304 * found them in the first place. Any further arguments are (still) on 1305 * the user's stack and the syscall code will fetch them from there 1306 * (again). 1307 * 1308 * The program counter problem is addressed below. 1309 */ 1310 frame->tf_arg0 = args[0]; 1311 frame->tf_arg1 = args[1]; 1312 frame->tf_arg2 = args[2]; 1313 frame->tf_arg3 = args[3]; 1314 1315 /* 1316 * Some special handling for the syscall(2) and 1317 * __syscall(2) system calls. 1318 */ 1319 switch (code) { 1320 case SYS_syscall: 1321 code = *args; 1322 args += 1; 1323 break; 1324 case SYS___syscall: 1325 if (callp != sysent) 1326 break; 1327 /* 1328 * NB: even though __syscall(2) takes a quad_t containing the 1329 * system call number, because our argument copying word-swaps 1330 * 64-bit arguments, the least significant word of that quad_t 1331 * is the first word in the argument array. 1332 */ 1333 code = *args; 1334 args += 2; 1335 } 1336 1337 /* 1338 * Stacks growing from lower addresses to higher addresses are not 1339 * really such a good idea, because it makes it impossible to overlay a 1340 * struct on top of C stack arguments (the arguments appear in 1341 * reversed order). 1342 * 1343 * You can do the obvious thing (as locore.S does) and copy argument 1344 * words one by one, laying them out in the "right" order in the dest- 1345 * ination buffer, but this ends up word-swapping multi-word arguments 1346 * (like off_t). 1347 * 1348 * FIXME - this works only on native binaries and 1349 * will probably screw up any and all emulation. 1350 * 1351 */ 1352 1353 if (code < 0 || code >= nsys) 1354 callp += p->p_emul->e_nosys; /* bad syscall # */ 1355 else 1356 callp += code; 1357 1358 nargs64 = SYCALL_NARGS64(callp); 1359 if (nargs64 != 0) { 1360 size_t nargs = callp->sy_narg; 1361 1362 for (size_t i = 0; i < nargs + nargs64;) { 1363 if (SYCALL_ARG_64_P(callp, i)) { 1364 tmp = args[i]; 1365 args[i] = args[i + 1]; 1366 args[i + 1] = tmp; 1367 i += 2; 1368 } else 1369 i++; 1370 } 1371 } 1372 1373 #ifdef USERTRACE 1374 if (0) { 1375 user_backtrace(frame, l, -1); 1376 frame->tf_ipsw |= PSW_R; 1377 frame->tf_rctr = 0; 1378 printf("r %08x", frame->tf_iioq_head); 1379 rctr_next_iioq = frame->tf_iioq_head + 4; 1380 } 1381 #endif 1382 1383 error = sy_invoke(callp, l, args, rval, code); 1384 1385 switch (error) { 1386 case 0: 1387 l = curlwp; /* changes on exec() */ 1388 frame = l->l_md.md_regs; 1389 frame->tf_ret0 = rval[0]; 1390 frame->tf_ret1 = rval[1]; 1391 frame->tf_t1 = 0; 1392 break; 1393 case ERESTART: 1394 /* 1395 * Now we have to wind back the instruction offset queue to the 1396 * point where the system call will be made again. This is 1397 * inherently tied to the SYSCALL macro. 1398 * 1399 * Currently, the part of the SYSCALL macro that we want to re- 1400 * run reads as: 1401 * 1402 * ldil L%SYSCALLGATE, r1 1403 * ble 4(srX, r1) 1404 * ldi __CONCAT(SYS_,x), t1 1405 * comb,<> %r0, %t1, __cerror 1406 * 1407 * And our offset queue head points to the comb instruction. 1408 * So we need to subtract twelve to reach the ldil. 1409 */ 1410 frame->tf_iioq_head -= 12; 1411 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 1412 break; 1413 case EJUSTRETURN: 1414 p = curproc; 1415 break; 1416 default: 1417 if (p->p_emul->e_errno) 1418 error = p->p_emul->e_errno[error]; 1419 frame->tf_t1 = error; 1420 break; 1421 } 1422 1423 userret(l, frame); 1424 1425 #ifdef DIAGNOSTIC 1426 if (ci->ci_cpl != oldcpl) { 1427 printf("WARNING: SPL (0x%x) NOT LOWERED ON " 1428 "syscall(0x%x, 0x%x, 0x%x, 0x%x...) EXIT, PID %d\n", 1429 ci->ci_cpl, code, args[0], args[1], args[2], p->p_pid); 1430 ci->ci_cpl = oldcpl; 1431 } 1432 #endif 1433 1434 #ifdef DEBUG 1435 frame_sanity_check(__func__, __LINE__, 0, frame, l); 1436 #endif /* DEBUG */ 1437 } 1438 1439 /* 1440 * Start a new LWP 1441 */ 1442 void 1443 startlwp(void *arg) 1444 { 1445 ucontext_t *uc = arg; 1446 lwp_t *l = curlwp; 1447 int error __diagused; 1448 1449 error = cpu_setmcontext(l, &uc->uc_mcontext, uc->uc_flags); 1450 KASSERT(error == 0); 1451 1452 kmem_free(uc, sizeof(ucontext_t)); 1453 userret(l, l->l_md.md_regs); 1454 } 1455
Indexes created Mon Oct 20 20:10:13 GMT 2025