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/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/kernel.h>
  36 #include <sys/ktr.h>
  37 #include <sys/lock.h>
  38 #include <sys/mutex.h>
  39 #include <sys/proc.h>
  40 #include <sys/ptrace.h>
  41 #include <sys/syscall.h>
  42 #include <sys/sysent.h>
  43 #ifdef KDB
  44 #include <sys/kdb.h>
  45 #endif
  46
  47 #include <vm/vm.h>
  48 #include <vm/pmap.h>
  49 #include <vm/vm_kern.h>
  50 #include <vm/vm_map.h>
  51 #include <vm/vm_param.h>
  52 #include <vm/vm_extern.h>
  53
  54 #include <machine/frame.h>
  55 #include <machine/md_var.h>
  56 #include <machine/pcb.h>
  57 #include <machine/pcpu.h>
  58 #include <machine/undefined.h>
  59
  60 #ifdef KDTRACE_HOOKS
  61 #include <sys/dtrace_bsd.h>
  62 #endif
  63
  64 #ifdef VFP
  65 #include <machine/vfp.h>
  66 #endif
  67
  68 #ifdef KDB
  69 #include <machine/db_machdep.h>
  70 #endif
  71
  72 #ifdef DDB
  73 #include <ddb/ddb.h>
  74 #include <ddb/db_sym.h>
  75 #endif
  76
  77 /* Called from exception.S */
  78 void do_el1h_sync(struct thread *, struct trapframe *);
  79 void do_el0_sync(struct thread *, struct trapframe *);
  80 void do_el0_error(struct trapframe *);
  81 void do_serror(struct trapframe *);
  82 void unhandled_exception(struct trapframe *);
  83
  84 static void print_gp_register(const char *name, uint64_t value);
  85 static void print_registers(struct trapframe *frame);
  86
  87 int (*dtrace_invop_jump_addr)(struct trapframe *);
  88
  89 typedef void (abort_handler)(struct thread *, struct trapframe *, uint64_t,
  90     uint64_t, int);
  91
  92 static abort_handler align_abort;
  93 static abort_handler data_abort;
  94 static abort_handler external_abort;
  95
  96 static abort_handler *abort_handlers[] = {
  97         [ISS_DATA_DFSC_TF_L0] = data_abort,
  98         [ISS_DATA_DFSC_TF_L1] = data_abort,
  99         [ISS_DATA_DFSC_TF_L2] = data_abort,
 100         [ISS_DATA_DFSC_TF_L3] = data_abort,
 101         [ISS_DATA_DFSC_AFF_L1] = data_abort,
 102         [ISS_DATA_DFSC_AFF_L2] = data_abort,
 103         [ISS_DATA_DFSC_AFF_L3] = data_abort,
 104         [ISS_DATA_DFSC_PF_L1] = data_abort,
 105         [ISS_DATA_DFSC_PF_L2] = data_abort,
 106         [ISS_DATA_DFSC_PF_L3] = data_abort,
 107         [ISS_DATA_DFSC_ALIGN] = align_abort,
 108         [ISS_DATA_DFSC_EXT] =  external_abort,
 109         [ISS_DATA_DFSC_EXT_L0] =  external_abort,
 110         [ISS_DATA_DFSC_EXT_L1] =  external_abort,
 111         [ISS_DATA_DFSC_EXT_L2] =  external_abort,
 112         [ISS_DATA_DFSC_EXT_L3] =  external_abort,
 113         [ISS_DATA_DFSC_ECC] =  external_abort,
 114         [ISS_DATA_DFSC_ECC_L0] =  external_abort,
 115         [ISS_DATA_DFSC_ECC_L1] =  external_abort,
 116         [ISS_DATA_DFSC_ECC_L2] =  external_abort,
 117         [ISS_DATA_DFSC_ECC_L3] =  external_abort,
 118 };
 119
 120 static __inline void
 121 call_trapsignal(struct thread *td, int sig, int code, void *addr, int trapno)
 122 {
 123         ksiginfo_t ksi;
 124
 125         ksiginfo_init_trap(&ksi);
 126         ksi.ksi_signo = sig;
 127         ksi.ksi_code = code;
 128         ksi.ksi_addr = addr;
 129         ksi.ksi_trapno = trapno;
 130         trapsignal(td, &ksi);
 131 }
 132
 133 int
 134 cpu_fetch_syscall_args(struct thread *td)
 135 {
 136         struct proc *p;
 137         register_t *ap, *dst_ap;
 138         struct syscall_args *sa;
 139
 140         p = td->td_proc;
 141         sa = &td->td_sa;
 142         ap = td->td_frame->tf_x;
 143         dst_ap = &sa->args[0];
 144
 145         sa->code = td->td_frame->tf_x[8];
 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 = &p->p_sysent->sv_table[0];
 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, (MAXARGS - 1) * sizeof(register_t));
 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:         %.8lx\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
 229         /*
 230          * Try to handle synchronous external aborts caused by
 231          * bus_space_peek() and/or bus_space_poke() functions.
 232          */
 233         if (!lower && test_bs_fault((void *)frame->tf_elr)) {
 234                 frame->tf_elr = (uint64_t)generic_bs_fault;
 235                 return;
 236         }
 237
 238         print_registers(frame);
 239         print_gp_register("far", far);
 240         panic("Unhandled EL%d external data abort", lower ? 0: 1);
 241 }
 242
 243 static void
 244 data_abort(struct thread *td, struct trapframe *frame, uint64_t esr,
 245     uint64_t far, int lower)
 246 {
 247         struct vm_map *map;
 248         struct proc *p;
 249         struct pcb *pcb;
 250         vm_prot_t ftype;
 251         int error, sig, ucode;
 252 #ifdef KDB
 253         bool handled;
 254 #endif
 255
 256         /*
 257          * According to the ARMv8-A rev. A.g, B2.10.5 "Load-Exclusive
 258          * and Store-Exclusive instruction usage restrictions", state
 259          * of the exclusive monitors after data abort exception is unknown.
 260          */
 261         clrex();
 262
 263 #ifdef KDB
 264         if (kdb_active) {
 265                 kdb_reenter();
 266                 return;
 267         }
 268 #endif
 269
 270         pcb = td->td_pcb;
 271         p = td->td_proc;
 272         if (lower)
 273                 map = &p->p_vmspace->vm_map;
 274         else {
 275                 intr_enable();
 276
 277                 /* We received a TBI/PAC/etc. fault from the kernel */
 278                 if (!ADDR_IS_CANONICAL(far)) {
 279                         error = KERN_INVALID_ADDRESS;
 280                         goto bad_far;
 281                 }
 282
 283                 /* The top bit tells us which range to use */
 284                 if (ADDR_IS_KERNEL(far)) {
 285                         map = kernel_map;
 286                 } else {
 287                         map = &p->p_vmspace->vm_map;
 288                         if (map == NULL)
 289                                 map = kernel_map;
 290                 }
 291         }
 292
 293         /*
 294          * Try to handle translation, access flag, and permission faults.
 295          * Translation faults may occur as a result of the required
 296          * break-before-make sequence used when promoting or demoting
 297          * superpages.  Such faults must not occur while holding the pmap lock,
 298          * or pmap_fault() will recurse on that lock.
 299          */
 300         if ((lower || map == kernel_map || pcb->pcb_onfault != 0) &&
 301             pmap_fault(map->pmap, esr, far) == KERN_SUCCESS)
 302                 return;
 303
 304         KASSERT(td->td_md.md_spinlock_count == 0,
 305             ("data abort with spinlock held"));
 306         if (td->td_critnest != 0 || WITNESS_CHECK(WARN_SLEEPOK |
 307             WARN_GIANTOK, NULL, "Kernel page fault") != 0) {
 308                 print_registers(frame);
 309                 print_gp_register("far", far);
 310                 printf(" esr:         %.8lx\n", esr);
 311                 panic("data abort in critical section or under mutex");
 312         }
 313
 314         switch (ESR_ELx_EXCEPTION(esr)) {
 315         case EXCP_INSN_ABORT:
 316         case EXCP_INSN_ABORT_L:
 317                 ftype = VM_PROT_EXECUTE;
 318                 break;
 319         default:
 320                 /*
 321                  * If the exception was because of a read or cache operation
 322                  * pass a read fault type into the vm code. Cache operations
 323                  * need read permission but will set the WnR flag when the
 324                  * memory is unmapped.
 325                  */
 326                 if ((esr & ISS_DATA_WnR) == 0 || (esr & ISS_DATA_CM) != 0)
 327                         ftype = VM_PROT_READ;
 328                 else
 329                         ftype = VM_PROT_WRITE;
 330                 break;
 331         }
 332
 333         /* Fault in the page. */
 334         error = vm_fault_trap(map, far, ftype, VM_FAULT_NORMAL, &sig, &ucode);
 335         if (error != KERN_SUCCESS) {
 336 bad_far:
 337                 if (lower) {
 338                         call_trapsignal(td, sig, ucode, (void *)far,
 339                             ESR_ELx_EXCEPTION(esr));
 340                 } else {
 341                         if (td->td_intr_nesting_level == 0 &&
 342                             pcb->pcb_onfault != 0) {
 343                                 frame->tf_x[0] = error;
 344                                 frame->tf_elr = pcb->pcb_onfault;
 345                                 return;
 346                         }
 347
 348                         printf("Fatal data abort:\n");
 349                         print_registers(frame);
 350                         print_gp_register("far", far);
 351                         printf(" esr:         %.8lx\n", esr);
 352
 353 #ifdef KDB
 354                         if (debugger_on_trap) {
 355                                 kdb_why = KDB_WHY_TRAP;
 356                                 handled = kdb_trap(ESR_ELx_EXCEPTION(esr), 0,
 357                                     frame);
 358                                 kdb_why = KDB_WHY_UNSET;
 359                                 if (handled)
 360                                         return;
 361                         }
 362 #endif
 363                         panic("vm_fault failed: %lx", frame->tf_elr);
 364                 }
 365         }
 366
 367         if (lower)
 368                 userret(td, frame);
 369 }
 370
 371 static void
 372 print_gp_register(const char *name, uint64_t value)
 373 {
 374 #if defined(DDB)
 375         c_db_sym_t sym;
 376         const char *sym_name;
 377         db_expr_t sym_value;
 378         db_expr_t offset;
 379 #endif
 380
 381         printf(" %s: %16lx", name, value);
 382 #if defined(DDB)
 383         /* If this looks like a kernel address try to find the symbol */
 384         if (value >= VM_MIN_KERNEL_ADDRESS) {
 385                 sym = db_search_symbol(value, DB_STGY_ANY, &offset);
 386                 if (sym != C_DB_SYM_NULL) {
 387                         db_symbol_values(sym, &sym_name, &sym_value);
 388                         printf(" (%s + %lx)", sym_name, offset);
 389                 }
 390         }
 391 #endif
 392         printf("\n");
 393 }
 394
 395 static void
 396 print_registers(struct trapframe *frame)
 397 {
 398         char name[4];
 399         u_int reg;
 400
 401         for (reg = 0; reg < nitems(frame->tf_x); reg++) {
 402                 snprintf(name, sizeof(name), "%sx%d", (reg < 10) ? " " : "",
 403                     reg);
 404                 print_gp_register(name, frame->tf_x[reg]);
 405         }
 406         printf("  sp: %16lx\n", frame->tf_sp);
 407         print_gp_register(" lr", frame->tf_lr);
 408         print_gp_register("elr", frame->tf_elr);
 409         printf("spsr:         %8x\n", frame->tf_spsr);
 410 }
 411
 412 #ifdef VFP
 413 static void
 414 fpe_trap(struct thread *td, void *addr, uint32_t exception)
 415 {
 416         int code;
 417
 418         code = FPE_FLTIDO;
 419         if ((exception & ISS_FP_TFV) != 0) {
 420                 if ((exception & ISS_FP_IOF) != 0)
 421                         code = FPE_FLTINV;
 422                 else if ((exception & ISS_FP_DZF) != 0)
 423                         code = FPE_FLTDIV;
 424                 else if ((exception & ISS_FP_OFF) != 0)
 425                         code = FPE_FLTOVF;
 426                 else if ((exception & ISS_FP_UFF) != 0)
 427                         code = FPE_FLTUND;
 428                 else if ((exception & ISS_FP_IXF) != 0)
 429                         code = FPE_FLTRES;
 430         }
 431         call_trapsignal(td, SIGFPE, code, addr, exception);
 432 }
 433 #endif
 434
 435 void
 436 do_el1h_sync(struct thread *td, struct trapframe *frame)
 437 {
 438         uint32_t exception;
 439         uint64_t esr, far;
 440         int dfsc;
 441
 442         /* Read the esr register to get the exception details */
 443         esr = frame->tf_esr;
 444         exception = ESR_ELx_EXCEPTION(esr);
 445
 446 #ifdef KDTRACE_HOOKS
 447         if (dtrace_trap_func != NULL && (*dtrace_trap_func)(frame, exception))
 448                 return;
 449 #endif
 450
 451         CTR4(KTR_TRAP,
 452             "do_el1_sync: curthread: %p, esr %lx, elr: %lx, frame: %p", td,
 453             esr, frame->tf_elr, frame);
 454
 455         /*
 456          * Enable debug exceptions if we aren't already handling one. They will
 457          * be masked again in the exception handler's epilogue.
 458          */
 459         if (exception != EXCP_BRK && exception != EXCP_WATCHPT_EL1 &&
 460             exception != EXCP_SOFTSTP_EL1)
 461                 dbg_enable();
 462
 463         switch (exception) {
 464         case EXCP_FP_SIMD:
 465         case EXCP_TRAP_FP:
 466 #ifdef VFP
 467                 if ((td->td_pcb->pcb_fpflags & PCB_FP_KERN) != 0) {
 468                         vfp_restore_state();
 469                 } else
 470 #endif
 471                 {
 472                         print_registers(frame);
 473                         printf(" esr:         %.8lx\n", esr);
 474                         panic("VFP exception in the kernel");
 475                 }
 476                 break;
 477         case EXCP_INSN_ABORT:
 478         case EXCP_DATA_ABORT:
 479                 far = READ_SPECIALREG(far_el1);
 480                 dfsc = esr & ISS_DATA_DFSC_MASK;
 481                 if (dfsc < nitems(abort_handlers) &&
 482                     abort_handlers[dfsc] != NULL) {
 483                         abort_handlers[dfsc](td, frame, esr, far, 0);
 484                 } else {
 485                         print_registers(frame);
 486                         print_gp_register("far", far);
 487                         printf(" esr:         %.8lx\n", esr);
 488                         panic("Unhandled EL1 %s abort: %x",
 489                             exception == EXCP_INSN_ABORT ? "instruction" :
 490                             "data", dfsc);
 491                 }
 492                 break;
 493         case EXCP_BRK:
 494 #ifdef KDTRACE_HOOKS
 495                 if ((esr & ESR_ELx_ISS_MASK) == 0x40d && \
 496                     dtrace_invop_jump_addr != 0) {
 497                         dtrace_invop_jump_addr(frame);
 498                         break;
 499                 }
 500 #endif
 501 #ifdef KDB
 502                 kdb_trap(exception, 0, frame);
 503 #else
 504                 panic("No debugger in kernel.");
 505 #endif
 506                 break;
 507         case EXCP_WATCHPT_EL1:
 508         case EXCP_SOFTSTP_EL1:
 509 #ifdef KDB
 510                 kdb_trap(exception, 0, frame);
 511 #else
 512                 panic("No debugger in kernel.");
 513 #endif
 514                 break;
 515         case EXCP_UNKNOWN:
 516                 if (undef_insn(1, frame))
 517                         break;
 518                 printf("Undefined instruction: %08x\n",
 519                     *(uint32_t *)frame->tf_elr);
 520                 /* FALLTHROUGH */
 521         default:
 522                 print_registers(frame);
 523                 print_gp_register("far", READ_SPECIALREG(far_el1));
 524                 panic("Unknown kernel exception %x esr_el1 %lx", exception,
 525                     esr);
 526         }
 527 }
 528
 529 void
 530 do_el0_sync(struct thread *td, struct trapframe *frame)
 531 {
 532         pcpu_bp_harden bp_harden;
 533         uint32_t exception;
 534         uint64_t esr, far;
 535         int dfsc;
 536
 537         /* Check we have a sane environment when entering from userland */
 538         KASSERT((uintptr_t)get_pcpu() >= VM_MIN_KERNEL_ADDRESS,
 539             ("Invalid pcpu address from userland: %p (tpidr %lx)",
 540              get_pcpu(), READ_SPECIALREG(tpidr_el1)));
 541
 542         esr = frame->tf_esr;
 543         exception = ESR_ELx_EXCEPTION(esr);
 544         switch (exception) {
 545         case EXCP_INSN_ABORT_L:
 546                 far = READ_SPECIALREG(far_el1);
 547
 548                 /*
 549                  * Userspace may be trying to train the branch predictor to
 550                  * attack the kernel. If we are on a CPU affected by this
 551                  * call the handler to clear the branch predictor state.
 552                  */
 553                 if (far > VM_MAXUSER_ADDRESS) {
 554                         bp_harden = PCPU_GET(bp_harden);
 555                         if (bp_harden != NULL)
 556                                 bp_harden();
 557                 }
 558                 break;
 559         case EXCP_UNKNOWN:
 560         case EXCP_DATA_ABORT_L:
 561         case EXCP_DATA_ABORT:
 562         case EXCP_WATCHPT_EL0:
 563                 far = READ_SPECIALREG(far_el1);
 564                 break;
 565         }
 566         intr_enable();
 567
 568         CTR4(KTR_TRAP,
 569             "do_el0_sync: curthread: %p, esr %lx, elr: %lx, frame: %p", td, esr,
 570             frame->tf_elr, frame);
 571
 572         switch (exception) {
 573         case EXCP_FP_SIMD:
 574 #ifdef VFP
 575                 vfp_restore_state();
 576 #else
 577                 panic("VFP exception in userland");
 578 #endif
 579                 break;
 580         case EXCP_TRAP_FP:
 581 #ifdef VFP
 582                 fpe_trap(td, (void *)frame->tf_elr, esr);
 583                 userret(td, frame);
 584 #else
 585                 panic("VFP exception in userland");
 586 #endif
 587                 break;
 588         case EXCP_SVC32:
 589         case EXCP_SVC64:
 590                 svc_handler(td, frame);
 591                 break;
 592         case EXCP_INSN_ABORT_L:
 593         case EXCP_DATA_ABORT_L:
 594         case EXCP_DATA_ABORT:
 595                 dfsc = esr & ISS_DATA_DFSC_MASK;
 596                 if (dfsc < nitems(abort_handlers) &&
 597                     abort_handlers[dfsc] != NULL)
 598                         abort_handlers[dfsc](td, frame, esr, far, 1);
 599                 else {
 600                         print_registers(frame);
 601                         print_gp_register("far", far);
 602                         printf(" esr:         %.8lx\n", esr);
 603                         panic("Unhandled EL0 %s abort: %x",
 604                             exception == EXCP_INSN_ABORT_L ? "instruction" :
 605                             "data", dfsc);
 606                 }
 607                 break;
 608         case EXCP_UNKNOWN:
 609                 if (!undef_insn(0, frame))
 610                         call_trapsignal(td, SIGILL, ILL_ILLTRP, (void *)far,
 611                             exception);
 612                 userret(td, frame);
 613                 break;
 614         case EXCP_SP_ALIGN:
 615                 call_trapsignal(td, SIGBUS, BUS_ADRALN, (void *)frame->tf_sp,
 616                     exception);
 617                 userret(td, frame);
 618                 break;
 619         case EXCP_PC_ALIGN:
 620                 call_trapsignal(td, SIGBUS, BUS_ADRALN, (void *)frame->tf_elr,
 621                     exception);
 622                 userret(td, frame);
 623                 break;
 624         case EXCP_BRKPT_EL0:
 625         case EXCP_BRK:
 626 #ifdef COMPAT_FREEBSD32
 627         case EXCP_BRKPT_32:
 628 #endif /* COMPAT_FREEBSD32 */
 629                 call_trapsignal(td, SIGTRAP, TRAP_BRKPT, (void *)frame->tf_elr,
 630                     exception);
 631                 userret(td, frame);
 632                 break;
 633         case EXCP_WATCHPT_EL0:
 634                 call_trapsignal(td, SIGTRAP, TRAP_TRACE, (void *)far,
 635                     exception);
 636                 userret(td, frame);
 637                 break;
 638         case EXCP_MSR:
 639                 /*
 640                  * The CPU can raise EXCP_MSR when userspace executes an mrs
 641                  * instruction to access a special register userspace doesn't
 642                  * have access to.
 643                  */
 644                 if (!undef_insn(0, frame))
 645                         call_trapsignal(td, SIGILL, ILL_PRVOPC,
 646                             (void *)frame->tf_elr, exception);
 647                 userret(td, frame);
 648                 break;
 649         case EXCP_SOFTSTP_EL0:
 650                 PROC_LOCK(td->td_proc);
 651                 if ((td->td_dbgflags & TDB_STEP) != 0) {
 652                         td->td_frame->tf_spsr &= ~PSR_SS;
 653                         td->td_pcb->pcb_flags &= ~PCB_SINGLE_STEP;
 654                         WRITE_SPECIALREG(mdscr_el1,
 655                             READ_SPECIALREG(mdscr_el1) & ~MDSCR_SS);
 656                 }
 657                 PROC_UNLOCK(td->td_proc);
 658                 call_trapsignal(td, SIGTRAP, TRAP_TRACE,
 659                     (void *)frame->tf_elr, exception);
 660                 userret(td, frame);
 661                 break;
 662         default:
 663                 call_trapsignal(td, SIGBUS, BUS_OBJERR, (void *)frame->tf_elr,
 664                     exception);
 665                 userret(td, frame);
 666                 break;
 667         }
 668
 669         KASSERT((td->td_pcb->pcb_fpflags & ~PCB_FP_USERMASK) == 0,
 670             ("Kernel VFP flags set while entering userspace"));
 671         KASSERT(
 672             td->td_pcb->pcb_fpusaved == &td->td_pcb->pcb_fpustate,
 673             ("Kernel VFP state in use when entering userspace"));
 674 }
 675
 676 /*
 677  * TODO: We will need to handle these later when we support ARMv8.2 RAS.
 678  */
 679 void
 680 do_serror(struct trapframe *frame)
 681 {
 682         uint64_t esr, far;
 683
 684         far = READ_SPECIALREG(far_el1);
 685         esr = frame->tf_esr;
 686
 687         print_registers(frame);
 688         print_gp_register("far", far);
 689         printf(" esr:         %.8lx\n", esr);
 690         panic("Unhandled System Error");
 691 }
 692
 693 void
 694 unhandled_exception(struct trapframe *frame)
 695 {
 696         uint64_t esr, far;
 697
 698         far = READ_SPECIALREG(far_el1);
 699         esr = frame->tf_esr;
 700
 701         print_registers(frame);
 702         print_gp_register("far", far);
 703         printf(" esr:         %.8lx\n", esr);
 704         panic("Unhandled exception");
 705 }