1 /* $NetBSD: trap.c,v 1.128 2025/09/19 18:06:37 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 * 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.128 2025/09/19 18:06:37 skrll 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 610 #ifdef DIAGNOSTIC 611 /* 612 * If we are on the emergency stack, then we either got 613 * a fault on the kernel stack, or we're just handling 614 * a trap for the machine check handler (which also 615 * runs on the emergency stack). 616 * 617 * We *very crudely* differentiate between the two cases 618 * by checking the faulting instruction: if it is the 619 * function prologue instruction that stores the old 620 * frame pointer and updates the stack pointer, we assume 621 * that we faulted on the kernel stack. 622 * 623 * In this case, not completing that instruction will 624 * probably confuse backtraces in kgdb/ddb. Completing 625 * it would be difficult, because we already faulted on 626 * that part of the stack, so instead we fix up the 627 * frame as if the function called has just returned. 628 * This has peculiar knowledge about what values are in 629 * what registers during the "normal gcc -g" prologue. 630 */ 631 if (&type >= &emergency_stack_start && 632 &type < &emergency_stack_end && 633 type != T_IBREAK && STWM_R1_D_SR0_SP(opcode)) { 634 /* Restore the caller's frame pointer. */ 635 frame->tf_r3 = frame->tf_r1; 636 /* Restore the caller's instruction offsets. */ 637 frame->tf_iioq_head = frame->tf_rp; 638 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 639 goto dead_end; 640 } 641 #endif /* DIAGNOSTIC */ 642 643 #ifdef DEBUG 644 frame_sanity_check(__func__, __LINE__, type, frame, l); 645 #endif /* DEBUG */ 646 647 if (frame->tf_flags & TFF_LAST) 648 l->l_md.md_regs = frame; 649 650 if (trapnum <= trap_types) 651 tts = trap_type[trapnum]; 652 653 #ifdef TRAPDEBUG 654 if (trapnum != T_INTERRUPT && trapnum != T_IBREAK) 655 printf("trap: %d, %s for %x:%lx at %x:%x, fp=%p, rp=%x\n", 656 type, tts, space, va, frame->tf_iisq_head, 657 frame->tf_iioq_head, frame, frame->tf_rp); 658 else if (trapnum == T_IBREAK) 659 printf("trap: break instruction %x:%x at %x:%x, fp=%p\n", 660 break5(opcode), break13(opcode), 661 frame->tf_iisq_head, frame->tf_iioq_head, frame); 662 663 { 664 extern int etext; 665 if (frame < (struct trapframe *)&etext) { 666 printf("trap: bogus frame ptr %p\n", frame); 667 goto dead_end; 668 } 669 } 670 #endif 671 672 pcb = lwp_getpcb(l); 673 674 /* If this is a trap, not an interrupt, reenable interrupts. */ 675 if (trapnum != T_INTERRUPT) { 676 curcpu()->ci_data.cpu_ntrap++; 677 mtctl(frame->tf_eiem, CR_EIEM); 678 } 679 680 const bool user = (type & T_USER) != 0; 681 switch (type) { 682 case T_NONEXIST: 683 case T_NONEXIST | T_USER: 684 #if !defined(DDB) && !defined(KGDB) 685 /* we've got screwed up by the central scrutinizer */ 686 panic ("trap: elvis has just left the building!"); 687 break; 688 #else 689 goto dead_end; 690 #endif 691 case T_RECOVERY | T_USER: 692 #ifdef USERTRACE 693 for (;;) { 694 if (frame->tf_iioq_head != rctr_next_iioq) 695 printf("-%08x\nr %08x", 696 rctr_next_iioq - 4, 697 frame->tf_iioq_head); 698 rctr_next_iioq = frame->tf_iioq_head + 4; 699 if (frame->tf_ipsw & PSW_N) { 700 /* Advance the program counter. */ 701 frame->tf_iioq_head = frame->tf_iioq_tail; 702 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 703 /* Clear flags. */ 704 frame->tf_ipsw &= ~(PSW_N|PSW_X|PSW_Y|PSW_Z|PSW_B|PSW_T|PSW_H|PSW_L); 705 /* Simulate another trap. */ 706 continue; 707 } 708 break; 709 } 710 frame->tf_rctr = 0; 711 break; 712 #endif /* USERTRACE */ 713 case T_RECOVERY: 714 #if !defined(DDB) && !defined(KGDB) 715 /* XXX will implement later */ 716 printf ("trap: handicapped"); 717 break; 718 #else 719 goto dead_end; 720 #endif 721 722 case T_EMULATION | T_USER: 723 hppa_fpu_emulate(frame, l, opcode); 724 break; 725 726 case T_DATALIGN: 727 onfault = pcb->pcb_onfault; 728 if (onfault) { 729 ret = EFAULT; 730 do_onfault: 731 frame->tf_iioq_head = onfault; 732 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 733 frame->tf_ret0 = ret; 734 break; 735 } 736 /*FALLTHROUGH*/ 737 738 #ifdef DIAGNOSTIC 739 /* these just can't happen ever */ 740 case T_PRIV_OP: 741 case T_PRIV_REG: 742 /* these just can't make it to the trap() ever */ 743 case T_HPMC: 744 case T_HPMC | T_USER: 745 case T_EMULATION: 746 case T_EXCEPTION: 747 #endif 748 case T_IBREAK: 749 case T_DBREAK: 750 dead_end: 751 if (type & T_USER) { 752 #ifdef DEBUG 753 user_backtrace(frame, l, type); 754 #endif 755 KSI_INIT_TRAP(&ksi); 756 ksi.ksi_signo = SIGILL; 757 ksi.ksi_code = ILL_ILLTRP; 758 ksi.ksi_trap = type; 759 ksi.ksi_addr = (void *)frame->tf_iioq_head; 760 trapsignal(l, &ksi); 761 break; 762 } 763 if (trap_kdebug(type, va, frame)) 764 return; 765 else if (type == T_DATALIGN) 766 panic ("trap: %s at 0x%x", tts, (u_int) va); 767 else 768 panic ("trap: no debugger for \"%s\" (%d)", tts, type); 769 break; 770 771 case T_IBREAK | T_USER: 772 case T_DBREAK | T_USER: 773 KSI_INIT_TRAP(&ksi); 774 ksi.ksi_signo = SIGTRAP; 775 ksi.ksi_code = TRAP_BRKPT; 776 ksi.ksi_trap = trapnum; 777 ksi.ksi_addr = (void *)(frame->tf_iioq_head & ~HPPA_PC_PRIV_MASK); 778 #ifdef PTRACE 779 ss_clear_breakpoints(l); 780 if (opcode == SSBREAKPOINT) 781 ksi.ksi_code = TRAP_TRACE; 782 #endif 783 /* pass to user debugger */ 784 trapsignal(l, &ksi); 785 break; 786 787 #ifdef PTRACE 788 case T_TAKENBR | T_USER: 789 ss_clear_breakpoints(l); 790 791 KSI_INIT_TRAP(&ksi); 792 ksi.ksi_signo = SIGTRAP; 793 ksi.ksi_code = TRAP_TRACE; 794 ksi.ksi_trap = trapnum; 795 ksi.ksi_addr = (void *)(frame->tf_iioq_head & ~HPPA_PC_PRIV_MASK); 796 797 /* pass to user debugger */ 798 trapsignal(l, &ksi); 799 break; 800 #endif 801 802 case T_EXCEPTION | T_USER: { /* co-proc assist trap */ 803 uint64_t *fpp; 804 uint32_t *pex, ex, inst; 805 int i; 806 807 hppa_fpu_flush(l); 808 fpp = (uint64_t *)pcb->pcb_fpregs; 809 810 /* skip the status register */ 811 pex = (uint32_t *)&fpp[0]; 812 pex++; 813 814 /* loop through the exception registers */ 815 for (i = 1; i < 8 && !*pex; i++, pex++) 816 ; 817 KASSERT(i < 8); 818 ex = *pex; 819 *pex = 0; 820 821 /* reset the trap flag, as if there was none */ 822 fpp[0] &= ~(((uint64_t)HPPA_FPU_T) << 32); 823 824 /* emulate the instruction */ 825 inst = ((uint32_t)fpopmap[ex >> 26] << 26) | (ex & 0x03ffffff); 826 hppa_fpu_emulate(frame, l, inst); 827 } 828 break; 829 830 case T_OVERFLOW | T_USER: 831 KSI_INIT_TRAP(&ksi); 832 ksi.ksi_signo = SIGFPE; 833 ksi.ksi_code = SI_NOINFO; 834 ksi.ksi_trap = type; 835 ksi.ksi_addr = (void *)va; 836 trapsignal(l, &ksi); 837 break; 838 839 case T_CONDITION | T_USER: 840 KSI_INIT_TRAP(&ksi); 841 ksi.ksi_signo = SIGFPE; 842 ksi.ksi_code = FPE_INTDIV; 843 ksi.ksi_trap = type; 844 ksi.ksi_addr = (void *)va; 845 trapsignal(l, &ksi); 846 break; 847 848 case T_ILLEGAL | T_USER: 849 #ifdef DEBUG 850 user_backtrace(frame, l, type); 851 #endif 852 KSI_INIT_TRAP(&ksi); 853 ksi.ksi_signo = SIGILL; 854 ksi.ksi_code = ILL_ILLOPC; 855 ksi.ksi_trap = type; 856 ksi.ksi_addr = (void *)va; 857 trapsignal(l, &ksi); 858 break; 859 860 case T_PRIV_OP | T_USER: 861 #ifdef DEBUG 862 user_backtrace(frame, l, type); 863 #endif 864 KSI_INIT_TRAP(&ksi); 865 ksi.ksi_signo = SIGILL; 866 ksi.ksi_code = ILL_PRVOPC; 867 ksi.ksi_trap = type; 868 ksi.ksi_addr = (void *)va; 869 trapsignal(l, &ksi); 870 break; 871 872 case T_PRIV_REG | T_USER: 873 #ifdef DEBUG 874 user_backtrace(frame, l, type); 875 #endif 876 KSI_INIT_TRAP(&ksi); 877 ksi.ksi_signo = SIGILL; 878 ksi.ksi_code = ILL_PRVREG; 879 ksi.ksi_trap = type; 880 ksi.ksi_addr = (void *)va; 881 trapsignal(l, &ksi); 882 break; 883 884 /* these should never got here */ 885 case T_HIGHERPL | T_USER: 886 case T_LOWERPL | T_USER: 887 KSI_INIT_TRAP(&ksi); 888 ksi.ksi_signo = SIGSEGV; 889 ksi.ksi_code = SEGV_ACCERR; 890 ksi.ksi_trap = type; 891 ksi.ksi_addr = (void *)va; 892 trapsignal(l, &ksi); 893 break; 894 895 case T_IPROT | T_USER: 896 case T_DPROT | T_USER: 897 KSI_INIT_TRAP(&ksi); 898 ksi.ksi_signo = SIGSEGV; 899 ksi.ksi_code = SEGV_ACCERR; 900 ksi.ksi_trap = type; 901 ksi.ksi_addr = (void *)va; 902 trapsignal(l, &ksi); 903 break; 904 905 case T_ITLBMISSNA: case T_USER | T_ITLBMISSNA: 906 case T_DTLBMISSNA: case T_USER | T_DTLBMISSNA: 907 vm = p->p_vmspace; 908 909 if (!vm) { 910 #ifdef TRAPDEBUG 911 printf("trap: no vm, p=%p\n", p); 912 #endif 913 goto dead_end; 914 } 915 916 /* 917 * it could be a kernel map for exec_map faults 918 */ 919 if (!user && space == HPPA_SID_KERNEL) 920 map = kernel_map; 921 else { 922 map = &vm->vm_map; 923 } 924 925 va = trunc_page(va); 926 927 if ((opcode & LPA_MASK) == LPA) { 928 /* lpa failure case */ 929 const u_int regno = 930 __SHIFTOUT(opcode, __PABITS(27, 31)); 931 tf_setregno(frame, regno, 0); 932 frame->tf_ipsw |= PSW_N; 933 } else if ((opcode & PROBE_MASK) == PROBE) { 934 u_int pl; 935 if ((opcode & PROBE_IMMED) != 0) { 936 pl = __SHIFTOUT(opcode, PROBE_PL) & PLMASK; 937 } else { 938 const u_int plreg = 939 __SHIFTOUT(opcode, PROBE_PL); 940 pl = tf_getregno(frame, plreg) & PLMASK; 941 } 942 943 bool ok = true; 944 if ((user && space == HPPA_SID_KERNEL) || 945 (frame->tf_iioq_head & HPPA_PC_PRIV_MASK) != pl || 946 (user && va >= VM_MAXUSER_ADDRESS)) { 947 ok = false; 948 } else { 949 /* Never call uvm_fault in interrupt context. */ 950 KASSERT(curcpu()->ci_intr_depth == 0); 951 952 const bool read = 953 __SHIFTOUT(opcode, PROBE_RW) == 0; 954 onfault = pcb->pcb_onfault; 955 pcb->pcb_onfault = 0; 956 ret = uvm_fault(map, va, read ? 957 VM_PROT_READ : VM_PROT_WRITE); 958 pcb->pcb_onfault = onfault; 959 960 if (ret) 961 ok = false; 962 } 963 if (!ok) { 964 const u_int regno = 965 __SHIFTOUT(opcode, __PABITS(27, 31)); 966 tf_setregno(frame, regno, 0); 967 frame->tf_ipsw |= PSW_N; 968 } 969 } 970 break; 971 972 case T_DATACC: case T_USER | T_DATACC: 973 case T_ITLBMISS: case T_USER | T_ITLBMISS: 974 case T_DTLBMISS: case T_USER | T_DTLBMISS: 975 case T_TLB_DIRTY: case T_USER | T_TLB_DIRTY: 976 vm = p->p_vmspace; 977 978 if (!vm) { 979 #ifdef TRAPDEBUG 980 printf("trap: no vm, p=%p\n", p); 981 #endif 982 goto dead_end; 983 } 984 985 /* 986 * it could be a kernel map for exec_map faults 987 */ 988 if (!(type & T_USER) && space == HPPA_SID_KERNEL) 989 map = kernel_map; 990 else { 991 map = &vm->vm_map; 992 } 993 994 va = trunc_page(va); 995 996 if (map->pmap->pm_space != space) { 997 #ifdef TRAPDEBUG 998 printf("trap: space mismatch %d != %d\n", 999 space, map->pmap->pm_space); 1000 #endif 1001 /* actually dump the user, crap the kernel */ 1002 goto dead_end; 1003 } 1004 1005 /* Never call uvm_fault in interrupt context. */ 1006 KASSERT(curcpu()->ci_intr_depth == 0); 1007 1008 onfault = pcb->pcb_onfault; 1009 pcb->pcb_onfault = 0; 1010 ret = uvm_fault(map, va, vftype); 1011 pcb->pcb_onfault = onfault; 1012 1013 #ifdef TRAPDEBUG 1014 printf("uvm_fault(%p, %x, %d)=%d\n", 1015 map, (u_int)va, vftype, ret); 1016 #endif 1017 1018 /* 1019 * If this was a stack access we keep track of the maximum 1020 * accessed stack size. Also, if uvm_fault gets a protection 1021 * failure it is due to accessing the stack region outside 1022 * the current limit and we need to reflect that as an access 1023 * error. 1024 */ 1025 if (map != kernel_map && va >= (vaddr_t)vm->vm_minsaddr) { 1026 if (ret == 0) 1027 uvm_grow(l->l_proc, va); 1028 else if (ret == EACCES) 1029 ret = EFAULT; 1030 } 1031 1032 if (ret != 0) { 1033 if (type & T_USER) { 1034 #ifdef DEBUG 1035 user_backtrace(frame, l, type); 1036 #endif 1037 KSI_INIT_TRAP(&ksi); 1038 switch (ret) { 1039 case EACCES: 1040 ksi.ksi_signo = SIGSEGV; 1041 ksi.ksi_code = SEGV_ACCERR; 1042 break; 1043 case ENOMEM: 1044 ksi.ksi_signo = SIGKILL; 1045 printf("UVM: pid %d (%s), uid %d " 1046 "killed: out of swap\n", 1047 p->p_pid, p->p_comm, 1048 l->l_cred ? 1049 kauth_cred_geteuid(l->l_cred) 1050 : -1); 1051 break; 1052 case EINVAL: 1053 ksi.ksi_signo = SIGBUS; 1054 ksi.ksi_code = BUS_ADRERR; 1055 break; 1056 default: 1057 ksi.ksi_signo = SIGSEGV; 1058 ksi.ksi_code = SEGV_MAPERR; 1059 break; 1060 } 1061 ksi.ksi_trap = type; 1062 ksi.ksi_addr = (void *)va; 1063 trapsignal(l, &ksi); 1064 } else { 1065 if (onfault) { 1066 goto do_onfault; 1067 } 1068 panic("trap: uvm_fault(%p, %lx, %d): %d", 1069 map, va, vftype, ret); 1070 } 1071 } 1072 break; 1073 1074 case T_DATALIGN | T_USER: 1075 #ifdef DEBUG 1076 user_backtrace(frame, l, type); 1077 #endif 1078 KSI_INIT_TRAP(&ksi); 1079 ksi.ksi_signo = SIGBUS; 1080 ksi.ksi_code = BUS_ADRALN; 1081 ksi.ksi_trap = type; 1082 ksi.ksi_addr = (void *)va; 1083 trapsignal(l, &ksi); 1084 break; 1085 1086 case T_INTERRUPT: 1087 case T_INTERRUPT | T_USER: 1088 hppa_intr(frame); 1089 mtctl(frame->tf_eiem, CR_EIEM); 1090 break; 1091 1092 case T_LOWERPL: 1093 case T_DPROT: 1094 case T_IPROT: 1095 case T_OVERFLOW: 1096 case T_CONDITION: 1097 case T_ILLEGAL: 1098 case T_HIGHERPL: 1099 case T_TAKENBR: 1100 case T_POWERFAIL: 1101 case T_LPMC: 1102 case T_PAGEREF: 1103 case T_DATAPID: case T_DATAPID | T_USER: 1104 if (0 /* T-chip */) { 1105 break; 1106 } 1107 /* FALLTHROUGH to unimplemented */ 1108 default: 1109 panic ("trap: unimplemented \'%s\' (%d)", tts, type); 1110 } 1111 1112 #ifdef DIAGNOSTIC 1113 if (ci->ci_cpl != oldcpl) 1114 printf("WARNING: SPL (%d) NOT LOWERED ON TRAP (%d) EXIT\n", 1115 ci->ci_cpl, trapnum); 1116 #endif 1117 1118 if (type & T_USER) 1119 userret(l, l->l_md.md_regs); 1120 1121 #ifdef DEBUG 1122 frame_sanity_check(__func__, __LINE__, type, frame, l); 1123 if (frame->tf_flags & TFF_LAST && (curlwp->l_flag & LW_IDLE) == 0) 1124 frame_sanity_check(__func__, __LINE__, type, 1125 curlwp->l_md.md_regs, curlwp); 1126 #endif /* DEBUG */ 1127 } 1128 1129 void 1130 md_child_return(struct lwp *l) 1131 { 1132 /* 1133 * Return values in the frame set by cpu_lwp_fork(). 1134 */ 1135 1136 userret(l, l->l_md.md_regs); 1137 #ifdef DEBUG 1138 frame_sanity_check(__func__, __LINE__, 0, l->l_md.md_regs, l); 1139 #endif /* DEBUG */ 1140 } 1141 1142 /* 1143 * Process the tail end of a posix_spawn() for the child. 1144 */ 1145 void 1146 cpu_spawn_return(struct lwp *l) 1147 { 1148 1149 userret(l, l->l_md.md_regs); 1150 #ifdef DEBUG 1151 frame_sanity_check(__func__, __LINE__, 0, l->l_md.md_regs, l); 1152 #endif /* DEBUG */ 1153 } 1154 1155 #ifdef PTRACE 1156 1157 #include <sys/ptrace.h> 1158 1159 int 1160 ss_get_value(struct lwp *l, vaddr_t addr, u_int *value) 1161 { 1162 struct uio uio; 1163 struct iovec iov; 1164 1165 iov.iov_base = (void *)value; 1166 iov.iov_len = sizeof(u_int); 1167 uio.uio_iov = &iov; 1168 uio.uio_iovcnt = 1; 1169 uio.uio_offset = (off_t)addr; 1170 uio.uio_resid = sizeof(u_int); 1171 uio.uio_rw = UIO_READ; 1172 UIO_SETUP_SYSSPACE(&uio); 1173 1174 return (process_domem(curlwp, l, &uio)); 1175 } 1176 1177 int 1178 ss_put_value(struct lwp *l, vaddr_t addr, u_int value) 1179 { 1180 struct uio uio; 1181 struct iovec iov; 1182 1183 iov.iov_base = (void *)&value; 1184 iov.iov_len = sizeof(u_int); 1185 uio.uio_iov = &iov; 1186 uio.uio_iovcnt = 1; 1187 uio.uio_offset = (off_t)addr; 1188 uio.uio_resid = sizeof(u_int); 1189 uio.uio_rw = UIO_WRITE; 1190 UIO_SETUP_SYSSPACE(&uio); 1191 1192 return (process_domem(curlwp, l, &uio)); 1193 } 1194 1195 void 1196 ss_clear_breakpoints(struct lwp *l) 1197 { 1198 /* Restore original instructions. */ 1199 if (l->l_md.md_bpva != 0) { 1200 ss_put_value(l, l->l_md.md_bpva, l->l_md.md_bpsave[0]); 1201 ss_put_value(l, l->l_md.md_bpva + 4, l->l_md.md_bpsave[1]); 1202 l->l_md.md_bpva = 0; 1203 } 1204 } 1205 1206 1207 int 1208 process_sstep(struct lwp *l, int sstep) 1209 { 1210 struct trapframe *tf = l->l_md.md_regs; 1211 int error; 1212 1213 ss_clear_breakpoints(l); 1214 1215 /* We're continuing... */ 1216 if (sstep == 0) { 1217 tf->tf_ipsw &= ~PSW_T; 1218 return 0; 1219 } 1220 1221 /* 1222 * Don't touch the syscall gateway page. Instead, insert a 1223 * breakpoint where we're supposed to return. 1224 */ 1225 if ((tf->tf_iioq_tail & ~PAGE_MASK) == SYSCALLGATE) 1226 l->l_md.md_bpva = tf->tf_r31 & ~HPPA_PC_PRIV_MASK; 1227 else 1228 l->l_md.md_bpva = tf->tf_iioq_tail & ~HPPA_PC_PRIV_MASK; 1229 1230 error = ss_get_value(l, l->l_md.md_bpva, &l->l_md.md_bpsave[0]); 1231 if (error) 1232 return error; 1233 error = ss_get_value(l, l->l_md.md_bpva + 4, &l->l_md.md_bpsave[1]); 1234 if (error) 1235 return error; 1236 1237 error = ss_put_value(l, l->l_md.md_bpva, SSBREAKPOINT); 1238 if (error) 1239 return error; 1240 error = ss_put_value(l, l->l_md.md_bpva + 4, SSBREAKPOINT); 1241 if (error) 1242 return error; 1243 1244 if ((tf->tf_iioq_tail & ~PAGE_MASK) == SYSCALLGATE) 1245 tf->tf_ipsw &= ~PSW_T; 1246 else 1247 tf->tf_ipsw |= PSW_T; 1248 1249 return 0; 1250 } 1251 #endif 1252 1253 1254 void 1255 syscall_intern(struct proc *p) 1256 { 1257 p->p_md.md_syscall = syscall; 1258 } 1259 1260 /* 1261 * call actual syscall routine 1262 * from the low-level syscall handler: 1263 * - all HPPA_FRAME_NARGS syscall's arguments supposed to be copied onto 1264 * our stack, this wins compared to copyin just needed amount anyway 1265 * - register args are copied onto stack too 1266 */ 1267 void 1268 syscall(struct trapframe *frame, int *args) 1269 { 1270 struct lwp *l; 1271 struct proc *p; 1272 const struct sysent *callp; 1273 size_t nargs64; 1274 int nsys, code, error; 1275 int tmp; 1276 int rval[2]; 1277 #ifdef DIAGNOSTIC 1278 struct cpu_info *ci = curcpu(); 1279 int oldcpl = ci->ci_cpl; 1280 #endif 1281 1282 curcpu()->ci_data.cpu_nsyscall++; 1283 1284 #ifdef DEBUG 1285 frame_sanity_check(__func__, __LINE__, 0, frame, curlwp); 1286 #endif /* DEBUG */ 1287 1288 if (!USERMODE(frame->tf_iioq_head)) 1289 panic("syscall"); 1290 1291 KASSERT(curlwp != NULL); 1292 l = curlwp; 1293 p = l->l_proc; 1294 l->l_md.md_regs = frame; 1295 nsys = p->p_emul->e_nsysent; 1296 callp = p->p_emul->e_sysent; 1297 code = frame->tf_t1; 1298 1299 /* 1300 * Restarting a system call is touchy on the HPPA, because syscall 1301 * arguments are passed in registers and the program counter of the 1302 * syscall "point" isn't easily divined. 1303 * 1304 * We handle the first problem by assuming that we will have to restart 1305 * this system call, so we stuff the first four words of the original 1306 * arguments back into the frame as arg0...arg3, which is where we 1307 * found them in the first place. Any further arguments are (still) on 1308 * the user's stack and the syscall code will fetch them from there 1309 * (again). 1310 * 1311 * The program counter problem is addressed below. 1312 */ 1313 frame->tf_arg0 = args[0]; 1314 frame->tf_arg1 = args[1]; 1315 frame->tf_arg2 = args[2]; 1316 frame->tf_arg3 = args[3]; 1317 1318 /* 1319 * Some special handling for the syscall(2) and 1320 * __syscall(2) system calls. 1321 */ 1322 switch (code) { 1323 case SYS_syscall: 1324 code = *args; 1325 args += 1; 1326 break; 1327 case SYS___syscall: 1328 if (callp != sysent) 1329 break; 1330 /* 1331 * NB: even though __syscall(2) takes a quad_t containing the 1332 * system call number, because our argument copying word-swaps 1333 * 64-bit arguments, the least significant word of that quad_t 1334 * is the first word in the argument array. 1335 */ 1336 code = *args; 1337 args += 2; 1338 } 1339 1340 /* 1341 * Stacks growing from lower addresses to higher addresses are not 1342 * really such a good idea, because it makes it impossible to overlay a 1343 * struct on top of C stack arguments (the arguments appear in 1344 * reversed order). 1345 * 1346 * You can do the obvious thing (as locore.S does) and copy argument 1347 * words one by one, laying them out in the "right" order in the dest- 1348 * ination buffer, but this ends up word-swapping multi-word arguments 1349 * (like off_t). 1350 * 1351 * FIXME - this works only on native binaries and 1352 * will probably screw up any and all emulation. 1353 * 1354 */ 1355 1356 if (code < 0 || code >= nsys) 1357 callp += p->p_emul->e_nosys; /* bad syscall # */ 1358 else 1359 callp += code; 1360 1361 nargs64 = SYCALL_NARGS64(callp); 1362 if (nargs64 != 0) { 1363 size_t nargs = callp->sy_narg; 1364 1365 for (size_t i = 0; i < nargs + nargs64;) { 1366 if (SYCALL_ARG_64_P(callp, i)) { 1367 tmp = args[i]; 1368 args[i] = args[i + 1]; 1369 args[i + 1] = tmp; 1370 i += 2; 1371 } else 1372 i++; 1373 } 1374 } 1375 1376 #ifdef USERTRACE 1377 if (0) { 1378 user_backtrace(frame, l, -1); 1379 frame->tf_ipsw |= PSW_R; 1380 frame->tf_rctr = 0; 1381 printf("r %08x", frame->tf_iioq_head); 1382 rctr_next_iioq = frame->tf_iioq_head + 4; 1383 } 1384 #endif 1385 1386 error = sy_invoke(callp, l, args, rval, code); 1387 1388 switch (error) { 1389 case 0: 1390 l = curlwp; /* changes on exec() */ 1391 frame = l->l_md.md_regs; 1392 frame->tf_ret0 = rval[0]; 1393 frame->tf_ret1 = rval[1]; 1394 frame->tf_t1 = 0; 1395 break; 1396 case ERESTART: 1397 /* 1398 * Now we have to wind back the instruction offset queue to the 1399 * point where the system call will be made again. This is 1400 * inherently tied to the SYSCALL macro. 1401 * 1402 * Currently, the part of the SYSCALL macro that we want to re- 1403 * run reads as: 1404 * 1405 * ldil L%SYSCALLGATE, r1 1406 * ble 4(srX, r1) 1407 * ldi __CONCAT(SYS_,x), t1 1408 * comb,<> %r0, %t1, __cerror 1409 * 1410 * And our offset queue head points to the comb instruction. 1411 * So we need to subtract twelve to reach the ldil. 1412 */ 1413 frame->tf_iioq_head -= 12; 1414 frame->tf_iioq_tail = frame->tf_iioq_head + 4; 1415 break; 1416 case EJUSTRETURN: 1417 p = curproc; 1418 break; 1419 default: 1420 if (p->p_emul->e_errno) 1421 error = p->p_emul->e_errno[error]; 1422 frame->tf_t1 = error; 1423 break; 1424 } 1425 1426 userret(l, frame); 1427 1428 #ifdef DIAGNOSTIC 1429 if (ci->ci_cpl != oldcpl) { 1430 printf("WARNING: SPL (0x%x) NOT LOWERED ON " 1431 "syscall(0x%x, 0x%x, 0x%x, 0x%x...) EXIT, PID %d\n", 1432 ci->ci_cpl, code, args[0], args[1], args[2], p->p_pid); 1433 ci->ci_cpl = oldcpl; 1434 } 1435 #endif 1436 1437 #ifdef DEBUG 1438 frame_sanity_check(__func__, __LINE__, 0, frame, l); 1439 #endif /* DEBUG */ 1440 } 1441 1442 /* 1443 * Start a new LWP 1444 */ 1445 void 1446 startlwp(void *arg) 1447 { 1448 ucontext_t *uc = arg; 1449 lwp_t *l = curlwp; 1450 int error __diagused; 1451 1452 error = cpu_setmcontext(l, &uc->uc_mcontext, uc->uc_flags); 1453 KASSERT(error == 0); 1454 1455 kmem_free(uc, sizeof(ucontext_t)); 1456 userret(l, l->l_md.md_regs); 1457 } 1458
Indexes created Sat Sep 27 14:09:57 GMT 2025