diff --git a/sys/arm64/arm64/undefined.c b/sys/arm64/arm64/undefined.c index 71c9b689aa78..74b9de49a7ef 100644 --- a/sys/arm64/arm64/undefined.c +++ b/sys/arm64/arm64/undefined.c @@ -1,299 +1,327 @@ /*- * Copyright (c) 2017 Andrew Turner * All rights reserved. * * This software was developed by SRI International and the University of * Cambridge Computer Laboratory under DARPA/AFRL contract FA8750-10-C-0237 * ("CTSRD"), as part of the DARPA CRASH research programme. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include #include #include #include #include #include #define _MD_WANT_SWAPWORD #include #include #include #include #include #include /* Low bit masked off */ #define INSN_COND(insn) ((insn >> 28) & ~0x1) #define INSN_COND_INVERTED(insn) ((insn >> 28) & 0x1) #define INSN_COND_EQ 0x00 /* NE */ #define INSN_COND_CS 0x02 /* CC */ #define INSN_COND_MI 0x04 /* PL */ #define INSN_COND_VS 0x06 /* VC */ #define INSN_COND_HI 0x08 /* LS */ #define INSN_COND_GE 0x0a /* LT */ #define INSN_COND_GT 0x0c /* LE */ #define INSN_COND_AL 0x0e /* Always */ MALLOC_DEFINE(M_UNDEF, "undefhandler", "Undefined instruction handler data"); #ifdef COMPAT_FREEBSD32 #ifndef EMUL_SWP #define EMUL_SWP 0 #endif SYSCTL_DECL(_compat_arm); static bool compat32_emul_swp = EMUL_SWP; SYSCTL_BOOL(_compat_arm, OID_AUTO, emul_swp, CTLFLAG_RWTUN | CTLFLAG_MPSAFE, &compat32_emul_swp, 0, "Enable SWP/SWPB emulation"); #endif struct undef_handler { LIST_ENTRY(undef_handler) uh_link; undef_handler_t uh_handler; }; /* * Create the undefined instruction handler lists. * This allows us to handle instructions that will trap. */ LIST_HEAD(, undef_handler) undef_handlers = LIST_HEAD_INITIALIZER(undef_handlers); +#ifdef COMPAT_FREEBSD32 +LIST_HEAD(, undef_handler) undef32_handlers = + LIST_HEAD_INITIALIZER(undef32_handlers); +#endif static bool arm_cond_match(uint32_t insn, struct trapframe *frame) { uint64_t spsr; uint32_t cond; bool invert; bool match; /* * Generally based on the function of the same name in NetBSD, though * condition bits left in their original position rather than shifting * over the low bit that indicates inversion for quicker sanity checking * against spec. */ spsr = frame->tf_spsr; cond = INSN_COND(insn); invert = INSN_COND_INVERTED(insn); switch (cond) { case INSN_COND_EQ: match = (spsr & PSR_Z) != 0; break; case INSN_COND_CS: match = (spsr & PSR_C) != 0; break; case INSN_COND_MI: match = (spsr & PSR_N) != 0; break; case INSN_COND_VS: match = (spsr & PSR_V) != 0; break; case INSN_COND_HI: match = (spsr & (PSR_C | PSR_Z)) == PSR_C; break; case INSN_COND_GE: match = (!(spsr & PSR_N) == !(spsr & PSR_V)); break; case INSN_COND_GT: match = !(spsr & PSR_Z) && (!(spsr & PSR_N) == !(spsr & PSR_V)); break; case INSN_COND_AL: match = true; break; default: __assert_unreachable(); } return (match != invert); } #ifdef COMPAT_FREEBSD32 /* arm32 GDB breakpoints */ #define GDB_BREAKPOINT 0xe6000011 #define GDB5_BREAKPOINT 0xe7ffdefe static int gdb_trapper(vm_offset_t va, uint32_t insn, struct trapframe *frame, uint32_t esr) { struct thread *td = curthread; if (insn == GDB_BREAKPOINT || insn == GDB5_BREAKPOINT) { - if (SV_PROC_FLAG(td->td_proc, SV_ILP32) && - va < VM_MAXUSER_ADDRESS) { + if (va < VM_MAXUSER_ADDRESS) { ksiginfo_t ksi; ksiginfo_init_trap(&ksi); ksi.ksi_signo = SIGTRAP; ksi.ksi_code = TRAP_BRKPT; ksi.ksi_addr = (void *)va; trapsignal(td, &ksi); return 1; } } return 0; } static int swp_emulate(vm_offset_t va, uint32_t insn, struct trapframe *frame, uint32_t esr) { ksiginfo_t ksi; struct thread *td; vm_offset_t vaddr; uint64_t *regs; uint32_t val; int attempts, error, Rn, Rd, Rm; bool is_swpb; td = curthread; /* * swp, swpb only; there are no Thumb swp/swpb instructions so we can * safely bail out if we're in Thumb mode. */ - if (!compat32_emul_swp || !SV_PROC_FLAG(td->td_proc, SV_ILP32) || - (frame->tf_spsr & PSR_T) != 0) + if (!compat32_emul_swp || (frame->tf_spsr & PSR_T) != 0) return (0); else if ((insn & 0x0fb00ff0) != 0x01000090) return (0); else if (!arm_cond_match(insn, frame)) goto next; /* Handled, but does nothing */ Rn = (insn & 0xf0000) >> 16; Rd = (insn & 0xf000) >> 12; Rm = (insn & 0xf); regs = frame->tf_x; vaddr = regs[Rn] & 0xffffffff; val = regs[Rm]; /* Enforce alignment for swp. */ is_swpb = (insn & 0x00400000) != 0; if (!is_swpb && (vaddr & 3) != 0) goto fault; attempts = 0; do { if (is_swpb) { uint8_t bval; bval = val; error = swapueword8((void *)vaddr, &bval); val = bval; } else { error = swapueword32((void *)vaddr, &val); } if (error == -1) goto fault; /* * Avoid potential DoS, e.g., on CPUs that don't implement * global monitors. */ if (error != 0 && (++attempts % 5) == 0) maybe_yield(); } while (error != 0); regs[Rd] = val; next: /* No thumb SWP/SWPB */ frame->tf_elr += 4; //INSN_SIZE; return (1); fault: ksiginfo_init_trap(&ksi); ksi.ksi_signo = SIGSEGV; ksi.ksi_code = SEGV_MAPERR; ksi.ksi_addr = (void *)va; trapsignal(td, &ksi); return (1); } #endif void undef_init(void) { #ifdef COMPAT_FREEBSD32 - install_undef_handler(gdb_trapper); - install_undef_handler(swp_emulate); + install_undef32_handler(gdb_trapper); + install_undef32_handler(swp_emulate); #endif } void * install_undef_handler(undef_handler_t func) { struct undef_handler *uh; uh = malloc(sizeof(*uh), M_UNDEF, M_WAITOK); uh->uh_handler = func; LIST_INSERT_HEAD(&undef_handlers, uh, uh_link); return (uh); } +#ifdef COMPAT_FREEBSD32 +void * +install_undef32_handler(undef_handler_t func) +{ + struct undef_handler *uh; + + uh = malloc(sizeof(*uh), M_UNDEF, M_WAITOK); + uh->uh_handler = func; + LIST_INSERT_HEAD(&undef32_handlers, uh, uh_link); + + return (uh); +} +#endif + void remove_undef_handler(void *handle) { struct undef_handler *uh; uh = handle; LIST_REMOVE(uh, uh_link); free(handle, M_UNDEF); } int undef_insn(struct trapframe *frame) { struct undef_handler *uh; uint32_t insn; int ret; ret = fueword32((uint32_t *)frame->tf_elr, &insn); /* Raise a SIGILL if we are unable to read the instruction */ if (ret != 0) return (0); +#ifdef COMPAT_FREEBSD32 + if (SV_PROC_FLAG(curthread->td_proc, SV_ILP32)) { + LIST_FOREACH(uh, &undef32_handlers, uh_link) { + ret = uh->uh_handler(frame->tf_elr, insn, frame, + frame->tf_esr); + if (ret) + return (1); + } + return (0); + } +#endif + LIST_FOREACH(uh, &undef_handlers, uh_link) { ret = uh->uh_handler(frame->tf_elr, insn, frame, frame->tf_esr); if (ret) return (1); } return (0); } diff --git a/sys/arm64/include/undefined.h b/sys/arm64/include/undefined.h index 1370a648b17c..104d6e9a8e67 100644 --- a/sys/arm64/include/undefined.h +++ b/sys/arm64/include/undefined.h @@ -1,66 +1,69 @@ /*- * Copyright (c) 2017 Andrew Turner * All rights reserved. * * This software was developed by SRI International and the University of * Cambridge Computer Laboratory under DARPA/AFRL contract FA8750-10-C-0237 * ("CTSRD"), as part of the DARPA CRASH research programme. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef _MACHINE__UNDEFINED_H_ #define _MACHINE__UNDEFINED_H_ #ifdef _KERNEL typedef int (*undef_handler_t)(vm_offset_t, uint32_t, struct trapframe *, uint32_t); static inline int mrs_Op0(uint32_t insn) { /* op0 is encoded without the top bit in a mrs instruction */ return (2 | ((insn & MRS_Op0_MASK) >> MRS_Op0_SHIFT)); } #define MRS_GET(op) \ static inline int \ mrs_##op(uint32_t insn) \ { \ \ return ((insn & MRS_##op##_MASK) >> MRS_##op##_SHIFT); \ } MRS_GET(Op1) MRS_GET(CRn) MRS_GET(CRm) MRS_GET(Op2) void undef_init(void); void *install_undef_handler(undef_handler_t); +#ifdef COMPAT_FREEBSD32 +void *install_undef32_handler(undef_handler_t); +#endif void remove_undef_handler(void *); int undef_insn(struct trapframe *); #endif /* _KERNEL */ #endif