sys/arm64/arm64/trap.c

   1 /*-
   2  * Copyright (c) 2014 Andrew Turner
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  */
  27
  28 #include "opt_ddb.h"
  29
  30 #include <sys/param.h>
  31 #include <sys/systm.h>
  32 #include <sys/asan.h>
  33 #include <sys/kernel.h>
  34 #include <sys/ktr.h>
  35 #include <sys/lock.h>
  36 #include <sys/msan.h>
  37 #include <sys/mutex.h>
  38 #include <sys/proc.h>
  39 #include <sys/ptrace.h>
  40 #include <sys/syscall.h>
  41 #include <sys/sysent.h>
  42 #ifdef KDB
  43 #include <sys/kdb.h>
  44 #endif
  45
  46 #include <vm/vm.h>
  47 #include <vm/pmap.h>
  48 #include <vm/vm_kern.h>
  49 #include <vm/vm_map.h>
  50 #include <vm/vm_param.h>
  51 #include <vm/vm_extern.h>
  52
  53 #include <machine/frame.h>
  54 #include <machine/md_var.h>
  55 #include <machine/pcb.h>
  56 #include <machine/pcpu.h>
  57 #include <machine/undefined.h>
  58
  59 #ifdef KDTRACE_HOOKS
  60 #include <sys/dtrace_bsd.h>
  61 #endif
  62
  63 #ifdef VFP
  64 #include <machine/vfp.h>
  65 #endif
  66
  67 #ifdef KDB
  68 #include <machine/db_machdep.h>
  69 #endif
  70
  71 #ifdef DDB
  72 #include <ddb/ddb.h>
  73 #include <ddb/db_sym.h>
  74 #endif
  75
  76 /* Called from exception.S */
  77 void do_el1h_sync(struct thread *, struct trapframe *);
  78 void do_el0_sync(struct thread *, struct trapframe *);
  79 void do_el0_error(struct trapframe *);
  80 void do_serror(struct trapframe *);
  81 void unhandled_exception(struct trapframe *);
  82
  83 static void print_gp_register(const char *name, uint64_t value);
  84 static void print_registers(struct trapframe *frame);
  85
  86 int (*dtrace_invop_jump_addr)(struct trapframe *);
  87
  88 typedef void (abort_handler)(struct thread *, struct trapframe *, uint64_t,
  89     uint64_t, int);
  90
  91 static abort_handler align_abort;
  92 static abort_handler data_abort;
  93 static abort_handler external_abort;
  94
  95 static abort_handler *abort_handlers[] = {
  96         [ISS_DATA_DFSC_TF_L0] = data_abort,
  97         [ISS_DATA_DFSC_TF_L1] = data_abort,
  98         [ISS_DATA_DFSC_TF_L2] = data_abort,
  99         [ISS_DATA_DFSC_TF_L3] = data_abort,
 100         [ISS_DATA_DFSC_AFF_L1] = data_abort,
 101         [ISS_DATA_DFSC_AFF_L2] = data_abort,
 102         [ISS_DATA_DFSC_AFF_L3] = data_abort,
 103         [ISS_DATA_DFSC_PF_L1] = data_abort,
 104         [ISS_DATA_DFSC_PF_L2] = data_abort,
 105         [ISS_DATA_DFSC_PF_L3] = data_abort,
 106         [ISS_DATA_DFSC_ALIGN] = align_abort,
 107         [ISS_DATA_DFSC_EXT] =  external_abort,
 108         [ISS_DATA_DFSC_EXT_L0] =  external_abort,
 109         [ISS_DATA_DFSC_EXT_L1] =  external_abort,
 110         [ISS_DATA_DFSC_EXT_L2] =  external_abort,
 111         [ISS_DATA_DFSC_EXT_L3] =  external_abort,
 112         [ISS_DATA_DFSC_ECC] =  external_abort,
 113         [ISS_DATA_DFSC_ECC_L0] =  external_abort,
 114         [ISS_DATA_DFSC_ECC_L1] =  external_abort,
 115         [ISS_DATA_DFSC_ECC_L2] =  external_abort,
 116         [ISS_DATA_DFSC_ECC_L3] =  external_abort,
 117 };
 118
 119 static __inline void
 120 call_trapsignal(struct thread *td, int sig, int code, void *addr, int trapno)
 121 {
 122         ksiginfo_t ksi;
 123
 124         ksiginfo_init_trap(&ksi);
 125         ksi.ksi_signo = sig;
 126         ksi.ksi_code = code;
 127         ksi.ksi_addr = addr;
 128         ksi.ksi_trapno = trapno;
 129         trapsignal(td, &ksi);
 130 }
 131
 132 int
 133 cpu_fetch_syscall_args(struct thread *td)
 134 {
 135         struct proc *p;
 136         syscallarg_t *ap, *dst_ap;
 137         struct syscall_args *sa;
 138
 139         p = td->td_proc;
 140         sa = &td->td_sa;
 141         ap = td->td_frame->tf_x;
 142         dst_ap = &sa->args[0];
 143
 144         sa->code = td->td_frame->tf_x[8];
 145         sa->original_code = sa->code;
 146
 147         if (__predict_false(sa->code == SYS_syscall || sa->code == SYS___syscall)) {
 148                 sa->code = *ap++;
 149         } else {
 150                 *dst_ap++ = *ap++;
 151         }
 152
 153         if (__predict_false(sa->code >= p->p_sysent->sv_size))
 154                 sa->callp = &nosys_sysent;
 155         else
 156                 sa->callp = &p->p_sysent->sv_table[sa->code];
 157
 158         KASSERT(sa->callp->sy_narg <= nitems(sa->args),
 159             ("Syscall %d takes too many arguments", sa->code));
 160
 161         memcpy(dst_ap, ap, (nitems(sa->args) - 1) * sizeof(*dst_ap));
 162
 163         td->td_retval[0] = 0;
 164         td->td_retval[1] = 0;
 165
 166         return (0);
 167 }
 168
 169 #include "../../kern/subr_syscall.c"
 170
 171 /*
 172  * Test for fault generated by given access instruction in
 173  * bus_peek_<foo> or bus_poke_<foo> bus function.
 174  */
 175 extern uint32_t generic_bs_peek_1f, generic_bs_peek_2f;
 176 extern uint32_t generic_bs_peek_4f, generic_bs_peek_8f;
 177 extern uint32_t generic_bs_poke_1f, generic_bs_poke_2f;
 178 extern uint32_t generic_bs_poke_4f, generic_bs_poke_8f;
 179
 180 static bool
 181 test_bs_fault(void *addr)
 182 {
 183         return (addr == &generic_bs_peek_1f ||
 184             addr == &generic_bs_peek_2f ||
 185             addr == &generic_bs_peek_4f ||
 186             addr == &generic_bs_peek_8f ||
 187             addr == &generic_bs_poke_1f ||
 188             addr == &generic_bs_poke_2f ||
 189             addr == &generic_bs_poke_4f ||
 190             addr == &generic_bs_poke_8f);
 191 }
 192
 193 static void
 194 svc_handler(struct thread *td, struct trapframe *frame)
 195 {
 196
 197         if ((frame->tf_esr & ESR_ELx_ISS_MASK) == 0) {
 198                 syscallenter(td);
 199                 syscallret(td);
 200         } else {
 201                 call_trapsignal(td, SIGILL, ILL_ILLOPN, (void *)frame->tf_elr,
 202                     ESR_ELx_EXCEPTION(frame->tf_esr));
 203                 userret(td, frame);
 204         }
 205 }
 206
 207 static void
 208 align_abort(struct thread *td, struct trapframe *frame, uint64_t esr,
 209     uint64_t far, int lower)
 210 {
 211         if (!lower) {
 212                 print_registers(frame);
 213                 print_gp_register("far", far);
 214                 printf(" esr: 0x%.16lx\n", esr);
 215                 panic("Misaligned access from kernel space!");
 216         }
 217
 218         call_trapsignal(td, SIGBUS, BUS_ADRALN, (void *)frame->tf_elr,
 219             ESR_ELx_EXCEPTION(frame->tf_esr));
 220         userret(td, frame);
 221 }
 222
 223
 224 static void
 225 external_abort(struct thread *td, struct trapframe *frame, uint64_t esr,
 226     uint64_t far, int lower)
 227 {
 228         if (lower) {
 229                 call_trapsignal(td, SIGBUS, BUS_OBJERR, (void *)far,
 230                     ESR_ELx_EXCEPTION(frame->tf_esr));
 231                 userret(td, frame);
 232                 return;
 233         }
 234
 235         /*
 236          * Try to handle synchronous external aborts caused by
 237          * bus_space_peek() and/or bus_space_poke() functions.
 238          */
 239         if (test_bs_fault((void *)frame->tf_elr)) {
 240                 frame->tf_elr = (uint64_t)generic_bs_fault;
 241                 return;
 242         }
 243
 244         print_registers(frame);
 245         print_gp_register("far", far);
 246         panic("Unhandled external data abort");
 247 }
 248
 249 /*
 250  * It is unsafe to access the stack canary value stored in "td" until
 251  * kernel map translation faults are handled, see the pmap_klookup() call below.
 252  * Thus, stack-smashing detection with per-thread canaries must be disabled in
 253  * this function.
 254  */
 255 static void NO_PERTHREAD_SSP
 256 data_abort(struct thread *td, struct trapframe *frame, uint64_t esr,
 257     uint64_t far, int lower)
 258 {
 259         struct vm_map *map;
 260         struct pcb *pcb;
 261         vm_prot_t ftype;
 262         int error, sig, ucode;
 263 #ifdef KDB
 264         bool handled;
 265 #endif
 266
 267         /*
 268          * According to the ARMv8-A rev. A.g, B2.10.5 "Load-Exclusive
 269          * and Store-Exclusive instruction usage restrictions", state
 270          * of the exclusive monitors after data abort exception is unknown.
 271          */
 272         clrex();
 273
 274 #ifdef KDB
 275         if (kdb_active) {
 276                 kdb_reenter();
 277                 return;
 278         }
 279 #endif
 280
 281         if (lower) {
 282                 map = &td->td_proc->p_vmspace->vm_map;
 283         } else if (!ADDR_IS_CANONICAL(far)) {
 284                 /* We received a TBI/PAC/etc. fault from the kernel */
 285                 error = KERN_INVALID_ADDRESS;
 286                 pcb = td->td_pcb;
 287                 goto bad_far;
 288         } else if (ADDR_IS_KERNEL(far)) {
 289                 /*
 290                  * Handle a special case: the data abort was caused by accessing
 291                  * a thread structure while its mapping was being promoted or
 292                  * demoted, as a consequence of the break-before-make rule.  It
 293                  * is not safe to enable interrupts or dereference "td" before
 294                  * this case is handled.
 295                  *
 296                  * In principle, if pmap_klookup() fails, there is no need to
 297                  * call pmap_fault() below, but avoiding that call is not worth
 298                  * the effort.
 299                  */
 300                 if (ESR_ELx_EXCEPTION(esr) == EXCP_DATA_ABORT) {
 301                         switch (esr & ISS_DATA_DFSC_MASK) {
 302                         case ISS_DATA_DFSC_TF_L0:
 303                         case ISS_DATA_DFSC_TF_L1:
 304                         case ISS_DATA_DFSC_TF_L2:
 305                         case ISS_DATA_DFSC_TF_L3:
 306                                 if (pmap_klookup(far, NULL))
 307                                         return;
 308                                 break;
 309                         }
 310                 }
 311                 intr_enable();
 312                 map = kernel_map;
 313         } else {
 314                 intr_enable();
 315                 map = &td->td_proc->p_vmspace->vm_map;
 316                 if (map == NULL)
 317                         map = kernel_map;
 318         }
 319         pcb = td->td_pcb;
 320
 321         /*
 322          * Try to handle translation, access flag, and permission faults.
 323          * Translation faults may occur as a result of the required
 324          * break-before-make sequence used when promoting or demoting
 325          * superpages.  Such faults must not occur while holding the pmap lock,
 326          * or pmap_fault() will recurse on that lock.
 327          */
 328         if ((lower || map == kernel_map || pcb->pcb_onfault != 0) &&
 329             pmap_fault(map->pmap, esr, far) == KERN_SUCCESS)
 330                 return;
 331
 332 #ifdef INVARIANTS
 333         if (td->td_md.md_spinlock_count != 0) {
 334                 print_registers(frame);
 335                 print_gp_register("far", far);
 336                 printf(" esr: 0x%.16lx\n", esr);
 337                 panic("data abort with spinlock held (spinlock count %d != 0)",
 338                     td->td_md.md_spinlock_count);
 339         }
 340 #endif
 341         if (td->td_critnest != 0 || WITNESS_CHECK(WARN_SLEEPOK |
 342             WARN_GIANTOK, NULL, "Kernel page fault") != 0) {
 343                 print_registers(frame);
 344                 print_gp_register("far", far);
 345                 printf(" esr: 0x%.16lx\n", esr);
 346                 panic("data abort in critical section or under mutex");
 347         }
 348
 349         switch (ESR_ELx_EXCEPTION(esr)) {
 350         case EXCP_INSN_ABORT:
 351         case EXCP_INSN_ABORT_L:
 352                 ftype = VM_PROT_EXECUTE;
 353                 break;
 354         default:
 355                 /*
 356                  * If the exception was because of a read or cache operation
 357                  * pass a read fault type into the vm code. Cache operations
 358                  * need read permission but will set the WnR flag when the
 359                  * memory is unmapped.
 360                  */
 361                 if ((esr & ISS_DATA_WnR) == 0 || (esr & ISS_DATA_CM) != 0)
 362                         ftype = VM_PROT_READ;
 363                 else
 364                         ftype = VM_PROT_WRITE;
 365                 break;
 366         }
 367
 368         /* Fault in the page. */
 369         error = vm_fault_trap(map, far, ftype, VM_FAULT_NORMAL, &sig, &ucode);
 370         if (error != KERN_SUCCESS) {
 371                 if (lower) {
 372                         call_trapsignal(td, sig, ucode, (void *)far,
 373                             ESR_ELx_EXCEPTION(esr));
 374                 } else {
 375 bad_far:
 376                         if (td->td_intr_nesting_level == 0 &&
 377                             pcb->pcb_onfault != 0) {
 378                                 frame->tf_x[0] = error;
 379                                 frame->tf_elr = pcb->pcb_onfault;
 380                                 return;
 381                         }
 382
 383                         printf("Fatal data abort:\n");
 384                         print_registers(frame);
 385                         print_gp_register("far", far);
 386                         printf(" esr: 0x%.16lx\n", esr);
 387
 388 #ifdef KDB
 389                         if (debugger_on_trap) {
 390                                 kdb_why = KDB_WHY_TRAP;
 391                                 handled = kdb_trap(ESR_ELx_EXCEPTION(esr), 0,
 392                                     frame);
 393                                 kdb_why = KDB_WHY_UNSET;
 394                                 if (handled)
 395                                         return;
 396                         }
 397 #endif
 398                         panic("vm_fault failed: 0x%lx error %d",
 399                             frame->tf_elr, error);
 400                 }
 401         }
 402
 403         if (lower)
 404                 userret(td, frame);
 405 }
 406
 407 static void
 408 print_gp_register(const char *name, uint64_t value)
 409 {
 410 #if defined(DDB)
 411         c_db_sym_t sym;
 412         const char *sym_name;
 413         db_expr_t sym_value;
 414         db_expr_t offset;
 415 #endif
 416
 417         printf(" %s: 0x%.16lx", name, value);
 418 #if defined(DDB)
 419         /* If this looks like a kernel address try to find the symbol */
 420         if (value >= VM_MIN_KERNEL_ADDRESS) {
 421                 sym = db_search_symbol(value, DB_STGY_ANY, &offset);
 422                 if (sym != C_DB_SYM_NULL) {
 423                         db_symbol_values(sym, &sym_name, &sym_value);
 424                         printf(" (%s + 0x%lx)", sym_name, offset);
 425                 }
 426         }
 427 #endif
 428         printf("\n");
 429 }
 430
 431 static void
 432 print_registers(struct trapframe *frame)
 433 {
 434         char name[4];
 435         u_int reg;
 436
 437         for (reg = 0; reg < nitems(frame->tf_x); reg++) {
 438                 snprintf(name, sizeof(name), "%sx%d", (reg < 10) ? " " : "",
 439                     reg);
 440                 print_gp_register(name, frame->tf_x[reg]);
 441         }
 442         printf("  sp: 0x%.16lx\n", frame->tf_sp);
 443         print_gp_register(" lr", frame->tf_lr);
 444         print_gp_register("elr", frame->tf_elr);
 445         printf("spsr: 0x%.16lx\n", frame->tf_spsr);
 446 }
 447
 448 #ifdef VFP
 449 static void
 450 fpe_trap(struct thread *td, void *addr, uint32_t exception)
 451 {
 452         int code;
 453
 454         code = FPE_FLTIDO;
 455         if ((exception & ISS_FP_TFV) != 0) {
 456                 if ((exception & ISS_FP_IOF) != 0)
 457                         code = FPE_FLTINV;
 458                 else if ((exception & ISS_FP_DZF) != 0)
 459                         code = FPE_FLTDIV;
 460                 else if ((exception & ISS_FP_OFF) != 0)
 461                         code = FPE_FLTOVF;
 462                 else if ((exception & ISS_FP_UFF) != 0)
 463                         code = FPE_FLTUND;
 464                 else if ((exception & ISS_FP_IXF) != 0)
 465                         code = FPE_FLTRES;
 466         }
 467         call_trapsignal(td, SIGFPE, code, addr, exception);
 468 }
 469 #endif
 470
 471 /*
 472  * See the comment above data_abort().
 473  */
 474 void NO_PERTHREAD_SSP
 475 do_el1h_sync(struct thread *td, struct trapframe *frame)
 476 {
 477         uint32_t exception;
 478         uint64_t esr, far;
 479         int dfsc;
 480
 481         kasan_mark(frame, sizeof(*frame), sizeof(*frame), 0);
 482         kmsan_mark(frame, sizeof(*frame), KMSAN_STATE_INITED);
 483
 484         far = frame->tf_far;
 485         /* Read the esr register to get the exception details */
 486         esr = frame->tf_esr;
 487         exception = ESR_ELx_EXCEPTION(esr);
 488
 489 #ifdef KDTRACE_HOOKS
 490         if (dtrace_trap_func != NULL && (*dtrace_trap_func)(frame, exception))
 491                 return;
 492 #endif
 493
 494         CTR4(KTR_TRAP, "%s: exception=%lu, elr=0x%lx, esr=0x%lx",
 495             __func__, exception, frame->tf_elr, esr);
 496
 497         /*
 498          * Enable debug exceptions if we aren't already handling one. They will
 499          * be masked again in the exception handler's epilogue.
 500          */
 501         if (exception != EXCP_BRK && exception != EXCP_WATCHPT_EL1 &&
 502             exception != EXCP_SOFTSTP_EL1)
 503                 dbg_enable();
 504
 505         switch (exception) {
 506         case EXCP_FP_SIMD:
 507         case EXCP_TRAP_FP:
 508 #ifdef VFP
 509                 if ((td->td_pcb->pcb_fpflags & PCB_FP_KERN) != 0) {
 510                         vfp_restore_state();
 511                 } else
 512 #endif
 513                 {
 514                         print_registers(frame);
 515                         printf(" esr: 0x%.16lx\n", esr);
 516                         panic("VFP exception in the kernel");
 517                 }
 518                 break;
 519         case EXCP_INSN_ABORT:
 520         case EXCP_DATA_ABORT:
 521                 dfsc = esr & ISS_DATA_DFSC_MASK;
 522                 if (dfsc < nitems(abort_handlers) &&
 523                     abort_handlers[dfsc] != NULL) {
 524                         abort_handlers[dfsc](td, frame, esr, far, 0);
 525                 } else {
 526                         print_registers(frame);
 527                         print_gp_register("far", far);
 528                         printf(" esr: 0x%.16lx\n", esr);
 529                         panic("Unhandled EL1 %s abort: 0x%x",
 530                             exception == EXCP_INSN_ABORT ? "instruction" :
 531                             "data", dfsc);
 532                 }
 533                 break;
 534         case EXCP_BRK:
 535 #ifdef KDTRACE_HOOKS
 536                 if ((esr & ESR_ELx_ISS_MASK) == 0x40d && \
 537                     dtrace_invop_jump_addr != 0) {
 538                         dtrace_invop_jump_addr(frame);
 539                         break;
 540                 }
 541 #endif
 542 #ifdef KDB
 543                 kdb_trap(exception, 0, frame);
 544 #else
 545                 panic("No debugger in kernel.");
 546 #endif
 547                 break;
 548         case EXCP_WATCHPT_EL1:
 549         case EXCP_SOFTSTP_EL1:
 550 #ifdef KDB
 551                 kdb_trap(exception, 0, frame);
 552 #else
 553                 panic("No debugger in kernel.");
 554 #endif
 555                 break;
 556         case EXCP_FPAC:
 557                 /* We can see this if the authentication on PAC fails */
 558                 print_registers(frame);
 559                 print_gp_register("far", far);
 560                 panic("FPAC kernel exception");
 561                 break;
 562         case EXCP_UNKNOWN:
 563                 if (undef_insn(1, frame))
 564                         break;
 565                 print_registers(frame);
 566                 print_gp_register("far", far);
 567                 panic("Undefined instruction: %08x",
 568                     *(uint32_t *)frame->tf_elr);
 569                 break;
 570         case EXCP_BTI:
 571                 print_registers(frame);
 572                 print_gp_register("far", far);
 573                 panic("Branch Target exception");
 574                 break;
 575         default:
 576                 print_registers(frame);
 577                 print_gp_register("far", far);
 578                 panic("Unknown kernel exception 0x%x esr_el1 0x%lx", exception,
 579                     esr);
 580         }
 581 }
 582
 583 void
 584 do_el0_sync(struct thread *td, struct trapframe *frame)
 585 {
 586         pcpu_bp_harden bp_harden;
 587         uint32_t exception;
 588         uint64_t esr, far;
 589         int dfsc;
 590
 591         /* Check we have a sane environment when entering from userland */
 592         KASSERT((uintptr_t)get_pcpu() >= VM_MIN_KERNEL_ADDRESS,
 593             ("Invalid pcpu address from userland: %p (tpidr 0x%lx)",
 594              get_pcpu(), READ_SPECIALREG(tpidr_el1)));
 595
 596         kasan_mark(frame, sizeof(*frame), sizeof(*frame), 0);
 597         kmsan_mark(frame, sizeof(*frame), KMSAN_STATE_INITED);
 598
 599         far = frame->tf_far;
 600         esr = frame->tf_esr;
 601         exception = ESR_ELx_EXCEPTION(esr);
 602         if (exception == EXCP_INSN_ABORT_L && far > VM_MAXUSER_ADDRESS) {
 603                 /*
 604                  * Userspace may be trying to train the branch predictor to
 605                  * attack the kernel. If we are on a CPU affected by this
 606                  * call the handler to clear the branch predictor state.
 607                  */
 608                 bp_harden = PCPU_GET(bp_harden);
 609                 if (bp_harden != NULL)
 610                         bp_harden();
 611         }
 612         intr_enable();
 613
 614         CTR4(KTR_TRAP, "%s: exception=%lu, elr=0x%lx, esr=0x%lx",
 615             __func__, exception, frame->tf_elr, esr);
 616
 617         switch (exception) {
 618         case EXCP_FP_SIMD:
 619 #ifdef VFP
 620                 vfp_restore_state();
 621 #else
 622                 panic("VFP exception in userland");
 623 #endif
 624                 break;
 625         case EXCP_TRAP_FP:
 626 #ifdef VFP
 627                 fpe_trap(td, (void *)frame->tf_elr, esr);
 628                 userret(td, frame);
 629 #else
 630                 panic("VFP exception in userland");
 631 #endif
 632                 break;
 633         case EXCP_SVE:
 634                 call_trapsignal(td, SIGILL, ILL_ILLTRP, (void *)frame->tf_elr,
 635                     exception);
 636                 userret(td, frame);
 637                 break;
 638         case EXCP_SVC32:
 639         case EXCP_SVC64:
 640                 svc_handler(td, frame);
 641                 break;
 642         case EXCP_INSN_ABORT_L:
 643         case EXCP_DATA_ABORT_L:
 644         case EXCP_DATA_ABORT:
 645                 dfsc = esr & ISS_DATA_DFSC_MASK;
 646                 if (dfsc < nitems(abort_handlers) &&
 647                     abort_handlers[dfsc] != NULL)
 648                         abort_handlers[dfsc](td, frame, esr, far, 1);
 649                 else {
 650                         print_registers(frame);
 651                         print_gp_register("far", far);
 652                         printf(" esr: 0x%.16lx\n", esr);
 653                         panic("Unhandled EL0 %s abort: 0x%x",
 654                             exception == EXCP_INSN_ABORT_L ? "instruction" :
 655                             "data", dfsc);
 656                 }
 657                 break;
 658         case EXCP_UNKNOWN:
 659                 if (!undef_insn(0, frame))
 660                         call_trapsignal(td, SIGILL, ILL_ILLTRP, (void *)far,
 661                             exception);
 662                 userret(td, frame);
 663                 break;
 664         case EXCP_FPAC:
 665                 call_trapsignal(td, SIGILL, ILL_ILLOPN, (void *)frame->tf_elr,
 666                     exception);
 667                 userret(td, frame);
 668                 break;
 669         case EXCP_SP_ALIGN:
 670                 call_trapsignal(td, SIGBUS, BUS_ADRALN, (void *)frame->tf_sp,
 671                     exception);
 672                 userret(td, frame);
 673                 break;
 674         case EXCP_PC_ALIGN:
 675                 call_trapsignal(td, SIGBUS, BUS_ADRALN, (void *)frame->tf_elr,
 676                     exception);
 677                 userret(td, frame);
 678                 break;
 679         case EXCP_BRKPT_EL0:
 680         case EXCP_BRK:
 681 #ifdef COMPAT_FREEBSD32
 682         case EXCP_BRKPT_32:
 683 #endif /* COMPAT_FREEBSD32 */
 684                 call_trapsignal(td, SIGTRAP, TRAP_BRKPT, (void *)frame->tf_elr,
 685                     exception);
 686                 userret(td, frame);
 687                 break;
 688         case EXCP_WATCHPT_EL0:
 689                 call_trapsignal(td, SIGTRAP, TRAP_TRACE, (void *)far,
 690                     exception);
 691                 userret(td, frame);
 692                 break;
 693         case EXCP_MSR:
 694                 /*
 695                  * The CPU can raise EXCP_MSR when userspace executes an mrs
 696                  * instruction to access a special register userspace doesn't
 697                  * have access to.
 698                  */
 699                 if (!undef_insn(0, frame))
 700                         call_trapsignal(td, SIGILL, ILL_PRVOPC,
 701                             (void *)frame->tf_elr, exception);
 702                 userret(td, frame);
 703                 break;
 704         case EXCP_SOFTSTP_EL0:
 705                 PROC_LOCK(td->td_proc);
 706                 if ((td->td_dbgflags & TDB_STEP) != 0) {
 707                         td->td_frame->tf_spsr &= ~PSR_SS;
 708                         td->td_pcb->pcb_flags &= ~PCB_SINGLE_STEP;
 709                         WRITE_SPECIALREG(mdscr_el1,
 710                             READ_SPECIALREG(mdscr_el1) & ~MDSCR_SS);
 711                 }
 712                 PROC_UNLOCK(td->td_proc);
 713                 call_trapsignal(td, SIGTRAP, TRAP_TRACE,
 714                     (void *)frame->tf_elr, exception);
 715                 userret(td, frame);
 716                 break;
 717         case EXCP_BTI:
 718                 call_trapsignal(td, SIGILL, ILL_ILLOPC, (void *)frame->tf_elr,
 719                     exception);
 720                 userret(td, frame);
 721                 break;
 722         default:
 723                 call_trapsignal(td, SIGBUS, BUS_OBJERR, (void *)frame->tf_elr,
 724                     exception);
 725                 userret(td, frame);
 726                 break;
 727         }
 728
 729         KASSERT((td->td_pcb->pcb_fpflags & ~PCB_FP_USERMASK) == 0,
 730             ("Kernel VFP flags set while entering userspace"));
 731         KASSERT(
 732             td->td_pcb->pcb_fpusaved == &td->td_pcb->pcb_fpustate,
 733             ("Kernel VFP state in use when entering userspace"));
 734 }
 735
 736 /*
 737  * TODO: We will need to handle these later when we support ARMv8.2 RAS.
 738  */
 739 void
 740 do_serror(struct trapframe *frame)
 741 {
 742         uint64_t esr, far;
 743
 744         kasan_mark(frame, sizeof(*frame), sizeof(*frame), 0);
 745         kmsan_mark(frame, sizeof(*frame), KMSAN_STATE_INITED);
 746
 747         far = frame->tf_far;
 748         esr = frame->tf_esr;
 749
 750         print_registers(frame);
 751         print_gp_register("far", far);
 752         printf(" esr: 0x%.16lx\n", esr);
 753         panic("Unhandled System Error");
 754 }
 755
 756 void
 757 unhandled_exception(struct trapframe *frame)
 758 {
 759         uint64_t esr, far;
 760
 761         kasan_mark(frame, sizeof(*frame), sizeof(*frame), 0);
 762         kmsan_mark(frame, sizeof(*frame), KMSAN_STATE_INITED);
 763
 764         far = frame->tf_far;
 765         esr = frame->tf_esr;
 766
 767         print_registers(frame);
 768         print_gp_register("far", far);
 769         printf(" esr: 0x%.16lx\n", esr);
 770         panic("Unhandled exception");
 771 }