2 * Copyright (C) 2014 ARM Limited
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
10 #include <linux/init.h>
11 #include <linux/list.h>
12 #include <linux/perf_event.h>
13 #include <linux/sched.h>
14 #include <linux/slab.h>
15 #include <linux/sysctl.h>
17 #include <asm/cpufeature.h>
19 #include <asm/sysreg.h>
20 #include <asm/system_misc.h>
21 #include <asm/traps.h>
22 #include <asm/kprobes.h>
23 #include <linux/uaccess.h>
24 #include <asm/cpufeature.h>
26 #define CREATE_TRACE_POINTS
27 #include "trace-events-emulation.h"
30 * The runtime support for deprecated instruction support can be in one of
31 * following three states -
34 * 1 = emulate (software emulation)
35 * 2 = hw (supported in hardware)
37 enum insn_emulation_mode
{
43 enum legacy_insn_status
{
48 struct insn_emulation_ops
{
50 enum legacy_insn_status status
;
51 struct undef_hook
*hooks
;
52 int (*set_hw_mode
)(bool enable
);
55 struct insn_emulation
{
56 struct list_head node
;
57 struct insn_emulation_ops
*ops
;
63 static LIST_HEAD(insn_emulation
);
64 static int nr_insn_emulated __initdata
;
65 static DEFINE_RAW_SPINLOCK(insn_emulation_lock
);
67 static void register_emulation_hooks(struct insn_emulation_ops
*ops
)
69 struct undef_hook
*hook
;
73 for (hook
= ops
->hooks
; hook
->instr_mask
; hook
++)
74 register_undef_hook(hook
);
76 pr_notice("Registered %s emulation handler\n", ops
->name
);
79 static void remove_emulation_hooks(struct insn_emulation_ops
*ops
)
81 struct undef_hook
*hook
;
85 for (hook
= ops
->hooks
; hook
->instr_mask
; hook
++)
86 unregister_undef_hook(hook
);
88 pr_notice("Removed %s emulation handler\n", ops
->name
);
91 static void enable_insn_hw_mode(void *data
)
93 struct insn_emulation
*insn
= (struct insn_emulation
*)data
;
94 if (insn
->ops
->set_hw_mode
)
95 insn
->ops
->set_hw_mode(true);
98 static void disable_insn_hw_mode(void *data
)
100 struct insn_emulation
*insn
= (struct insn_emulation
*)data
;
101 if (insn
->ops
->set_hw_mode
)
102 insn
->ops
->set_hw_mode(false);
105 /* Run set_hw_mode(mode) on all active CPUs */
106 static int run_all_cpu_set_hw_mode(struct insn_emulation
*insn
, bool enable
)
108 if (!insn
->ops
->set_hw_mode
)
111 on_each_cpu(enable_insn_hw_mode
, (void *)insn
, true);
113 on_each_cpu(disable_insn_hw_mode
, (void *)insn
, true);
118 * Run set_hw_mode for all insns on a starting CPU.
120 * 0 - If all the hooks ran successfully.
121 * -EINVAL - At least one hook is not supported by the CPU.
123 static int run_all_insn_set_hw_mode(unsigned int cpu
)
127 struct insn_emulation
*insn
;
129 raw_spin_lock_irqsave(&insn_emulation_lock
, flags
);
130 list_for_each_entry(insn
, &insn_emulation
, node
) {
131 bool enable
= (insn
->current_mode
== INSN_HW
);
132 if (insn
->ops
->set_hw_mode
&& insn
->ops
->set_hw_mode(enable
)) {
133 pr_warn("CPU[%u] cannot support the emulation of %s",
134 cpu
, insn
->ops
->name
);
138 raw_spin_unlock_irqrestore(&insn_emulation_lock
, flags
);
142 static int update_insn_emulation_mode(struct insn_emulation
*insn
,
143 enum insn_emulation_mode prev
)
148 case INSN_UNDEF
: /* Nothing to be done */
151 remove_emulation_hooks(insn
->ops
);
154 if (!run_all_cpu_set_hw_mode(insn
, false))
155 pr_notice("Disabled %s support\n", insn
->ops
->name
);
159 switch (insn
->current_mode
) {
163 register_emulation_hooks(insn
->ops
);
166 ret
= run_all_cpu_set_hw_mode(insn
, true);
168 pr_notice("Enabled %s support\n", insn
->ops
->name
);
175 static void __init
register_insn_emulation(struct insn_emulation_ops
*ops
)
178 struct insn_emulation
*insn
;
180 insn
= kzalloc(sizeof(*insn
), GFP_KERNEL
);
182 insn
->min
= INSN_UNDEF
;
184 switch (ops
->status
) {
185 case INSN_DEPRECATED
:
187 insn
->current_mode
= INSN_EMULATE
;
188 /* Disable the HW mode if it was turned on at early boot time */
189 run_all_cpu_set_hw_mode(insn
, false);
191 insn
->current_mode
= INSN_HW
;
192 run_all_cpu_set_hw_mode(insn
, true);
197 insn
->current_mode
= INSN_UNDEF
;
198 insn
->max
= INSN_EMULATE
;
202 raw_spin_lock_irqsave(&insn_emulation_lock
, flags
);
203 list_add(&insn
->node
, &insn_emulation
);
205 raw_spin_unlock_irqrestore(&insn_emulation_lock
, flags
);
207 /* Register any handlers if required */
208 update_insn_emulation_mode(insn
, INSN_UNDEF
);
211 static int emulation_proc_handler(struct ctl_table
*table
, int write
,
212 void __user
*buffer
, size_t *lenp
,
216 struct insn_emulation
*insn
= (struct insn_emulation
*) table
->data
;
217 enum insn_emulation_mode prev_mode
= insn
->current_mode
;
219 table
->data
= &insn
->current_mode
;
220 ret
= proc_dointvec_minmax(table
, write
, buffer
, lenp
, ppos
);
222 if (ret
|| !write
|| prev_mode
== insn
->current_mode
)
225 ret
= update_insn_emulation_mode(insn
, prev_mode
);
227 /* Mode change failed, revert to previous mode. */
228 insn
->current_mode
= prev_mode
;
229 update_insn_emulation_mode(insn
, INSN_UNDEF
);
236 static struct ctl_table ctl_abi
[] = {
244 static void __init
register_insn_emulation_sysctl(struct ctl_table
*table
)
248 struct insn_emulation
*insn
;
249 struct ctl_table
*insns_sysctl
, *sysctl
;
251 insns_sysctl
= kzalloc(sizeof(*sysctl
) * (nr_insn_emulated
+ 1),
254 raw_spin_lock_irqsave(&insn_emulation_lock
, flags
);
255 list_for_each_entry(insn
, &insn_emulation
, node
) {
256 sysctl
= &insns_sysctl
[i
];
259 sysctl
->maxlen
= sizeof(int);
261 sysctl
->procname
= insn
->ops
->name
;
263 sysctl
->extra1
= &insn
->min
;
264 sysctl
->extra2
= &insn
->max
;
265 sysctl
->proc_handler
= emulation_proc_handler
;
268 raw_spin_unlock_irqrestore(&insn_emulation_lock
, flags
);
270 table
->child
= insns_sysctl
;
271 register_sysctl_table(table
);
275 * Implement emulation of the SWP/SWPB instructions using load-exclusive and
278 * Syntax of SWP{B} instruction: SWP{B}<c> <Rt>, <Rt2>, [<Rn>]
279 * Where: Rt = destination
285 * Error-checking SWP macros implemented using ldxr{b}/stxr{b}
288 /* Arbitrary constant to ensure forward-progress of the LL/SC loop */
289 #define __SWP_LL_SC_LOOPS 4
291 #define __user_swpX_asm(data, addr, res, temp, temp2, B) \
294 __asm__ __volatile__( \
296 "0: ldxr"B" %w2, [%4]\n" \
297 "1: stxr"B" %w0, %w1, [%4]\n" \
299 " sub %w3, %w3, #1\n" \
306 " .pushsection .fixup,\"ax\"\n" \
308 "4: mov %w0, %w6\n" \
311 _ASM_EXTABLE(0b, 4b) \
312 _ASM_EXTABLE(1b, 4b) \
313 : "=&r" (res), "+r" (data), "=&r" (temp), "=&r" (temp2) \
314 : "r" ((unsigned long)addr), "i" (-EAGAIN), \
316 "i" (__SWP_LL_SC_LOOPS) \
321 #define __user_swp_asm(data, addr, res, temp, temp2) \
322 __user_swpX_asm(data, addr, res, temp, temp2, "")
323 #define __user_swpb_asm(data, addr, res, temp, temp2) \
324 __user_swpX_asm(data, addr, res, temp, temp2, "b")
327 * Bit 22 of the instruction encoding distinguishes between
328 * the SWP and SWPB variants (bit set means SWPB).
330 #define TYPE_SWPB (1 << 22)
332 static int emulate_swpX(unsigned int address
, unsigned int *data
,
335 unsigned int res
= 0;
337 if ((type
!= TYPE_SWPB
) && (address
& 0x3)) {
338 /* SWP to unaligned address not permitted */
339 pr_debug("SWP instruction on unaligned pointer!\n");
344 unsigned long temp
, temp2
;
346 if (type
== TYPE_SWPB
)
347 __user_swpb_asm(*data
, address
, res
, temp
, temp2
);
349 __user_swp_asm(*data
, address
, res
, temp
, temp2
);
351 if (likely(res
!= -EAGAIN
) || signal_pending(current
))
360 #define ARM_OPCODE_CONDTEST_FAIL 0
361 #define ARM_OPCODE_CONDTEST_PASS 1
362 #define ARM_OPCODE_CONDTEST_UNCOND 2
364 #define ARM_OPCODE_CONDITION_UNCOND 0xf
366 static unsigned int __kprobes
aarch32_check_condition(u32 opcode
, u32 psr
)
368 u32 cc_bits
= opcode
>> 28;
370 if (cc_bits
!= ARM_OPCODE_CONDITION_UNCOND
) {
371 if ((*aarch32_opcode_cond_checks
[cc_bits
])(psr
))
372 return ARM_OPCODE_CONDTEST_PASS
;
374 return ARM_OPCODE_CONDTEST_FAIL
;
376 return ARM_OPCODE_CONDTEST_UNCOND
;
380 * swp_handler logs the id of calling process, dissects the instruction, sanity
381 * checks the memory location, calls emulate_swpX for the actual operation and
382 * deals with fixup/error handling before returning
384 static int swp_handler(struct pt_regs
*regs
, u32 instr
)
386 u32 destreg
, data
, type
, address
= 0;
387 int rn
, rt2
, res
= 0;
389 perf_sw_event(PERF_COUNT_SW_EMULATION_FAULTS
, 1, regs
, regs
->pc
);
391 type
= instr
& TYPE_SWPB
;
393 switch (aarch32_check_condition(instr
, regs
->pstate
)) {
394 case ARM_OPCODE_CONDTEST_PASS
:
396 case ARM_OPCODE_CONDTEST_FAIL
:
397 /* Condition failed - return to next instruction */
399 case ARM_OPCODE_CONDTEST_UNCOND
:
400 /* If unconditional encoding - not a SWP, undef */
406 rn
= aarch32_insn_extract_reg_num(instr
, A32_RN_OFFSET
);
407 rt2
= aarch32_insn_extract_reg_num(instr
, A32_RT2_OFFSET
);
409 address
= (u32
)regs
->user_regs
.regs
[rn
];
410 data
= (u32
)regs
->user_regs
.regs
[rt2
];
411 destreg
= aarch32_insn_extract_reg_num(instr
, A32_RT_OFFSET
);
413 pr_debug("addr in r%d->0x%08x, dest is r%d, source in r%d->0x%08x)\n",
414 rn
, address
, destreg
,
415 aarch32_insn_extract_reg_num(instr
, A32_RT2_OFFSET
), data
);
417 /* Check access in reasonable access range for both SWP and SWPB */
418 if (!access_ok(VERIFY_WRITE
, (address
& ~3), 4)) {
419 pr_debug("SWP{B} emulation: access to 0x%08x not allowed!\n",
424 res
= emulate_swpX(address
, &data
, type
);
428 regs
->user_regs
.regs
[destreg
] = data
;
431 if (type
== TYPE_SWPB
)
432 trace_instruction_emulation("swpb", regs
->pc
);
434 trace_instruction_emulation("swp", regs
->pc
);
436 pr_warn_ratelimited("\"%s\" (%ld) uses obsolete SWP{B} instruction at 0x%llx\n",
437 current
->comm
, (unsigned long)current
->pid
, regs
->pc
);
443 pr_debug("SWP{B} emulation: access caused memory abort!\n");
444 arm64_notify_segfault(regs
, address
);
450 * Only emulate SWP/SWPB executed in ARM state/User mode.
451 * The kernel must be SWP free and SWP{B} does not exist in Thumb.
453 static struct undef_hook swp_hooks
[] = {
455 .instr_mask
= 0x0fb00ff0,
456 .instr_val
= 0x01000090,
457 .pstate_mask
= COMPAT_PSR_MODE_MASK
,
458 .pstate_val
= COMPAT_PSR_MODE_USR
,
464 static struct insn_emulation_ops swp_ops
= {
466 .status
= INSN_OBSOLETE
,
471 static int cp15barrier_handler(struct pt_regs
*regs
, u32 instr
)
473 perf_sw_event(PERF_COUNT_SW_EMULATION_FAULTS
, 1, regs
, regs
->pc
);
475 switch (aarch32_check_condition(instr
, regs
->pstate
)) {
476 case ARM_OPCODE_CONDTEST_PASS
:
478 case ARM_OPCODE_CONDTEST_FAIL
:
479 /* Condition failed - return to next instruction */
481 case ARM_OPCODE_CONDTEST_UNCOND
:
482 /* If unconditional encoding - not a barrier instruction */
488 switch (aarch32_insn_mcr_extract_crm(instr
)) {
491 * dmb - mcr p15, 0, Rt, c7, c10, 5
492 * dsb - mcr p15, 0, Rt, c7, c10, 4
494 if (aarch32_insn_mcr_extract_opc2(instr
) == 5) {
496 trace_instruction_emulation(
497 "mcr p15, 0, Rt, c7, c10, 5 ; dmb", regs
->pc
);
500 trace_instruction_emulation(
501 "mcr p15, 0, Rt, c7, c10, 4 ; dsb", regs
->pc
);
506 * isb - mcr p15, 0, Rt, c7, c5, 4
508 * Taking an exception or returning from one acts as an
509 * instruction barrier. So no explicit barrier needed here.
511 trace_instruction_emulation(
512 "mcr p15, 0, Rt, c7, c5, 4 ; isb", regs
->pc
);
517 pr_warn_ratelimited("\"%s\" (%ld) uses deprecated CP15 Barrier instruction at 0x%llx\n",
518 current
->comm
, (unsigned long)current
->pid
, regs
->pc
);
524 static int cp15_barrier_set_hw_mode(bool enable
)
527 config_sctlr_el1(0, SCTLR_EL1_CP15BEN
);
529 config_sctlr_el1(SCTLR_EL1_CP15BEN
, 0);
533 static struct undef_hook cp15_barrier_hooks
[] = {
535 .instr_mask
= 0x0fff0fdf,
536 .instr_val
= 0x0e070f9a,
537 .pstate_mask
= COMPAT_PSR_MODE_MASK
,
538 .pstate_val
= COMPAT_PSR_MODE_USR
,
539 .fn
= cp15barrier_handler
,
542 .instr_mask
= 0x0fff0fff,
543 .instr_val
= 0x0e070f95,
544 .pstate_mask
= COMPAT_PSR_MODE_MASK
,
545 .pstate_val
= COMPAT_PSR_MODE_USR
,
546 .fn
= cp15barrier_handler
,
551 static struct insn_emulation_ops cp15_barrier_ops
= {
552 .name
= "cp15_barrier",
553 .status
= INSN_DEPRECATED
,
554 .hooks
= cp15_barrier_hooks
,
555 .set_hw_mode
= cp15_barrier_set_hw_mode
,
558 static int setend_set_hw_mode(bool enable
)
560 if (!cpu_supports_mixed_endian_el0())
564 config_sctlr_el1(SCTLR_EL1_SED
, 0);
566 config_sctlr_el1(0, SCTLR_EL1_SED
);
570 static int compat_setend_handler(struct pt_regs
*regs
, u32 big_endian
)
574 perf_sw_event(PERF_COUNT_SW_EMULATION_FAULTS
, 1, regs
, regs
->pc
);
578 regs
->pstate
|= COMPAT_PSR_E_BIT
;
581 regs
->pstate
&= ~COMPAT_PSR_E_BIT
;
584 trace_instruction_emulation(insn
, regs
->pc
);
585 pr_warn_ratelimited("\"%s\" (%ld) uses deprecated setend instruction at 0x%llx\n",
586 current
->comm
, (unsigned long)current
->pid
, regs
->pc
);
591 static int a32_setend_handler(struct pt_regs
*regs
, u32 instr
)
593 int rc
= compat_setend_handler(regs
, (instr
>> 9) & 1);
598 static int t16_setend_handler(struct pt_regs
*regs
, u32 instr
)
600 int rc
= compat_setend_handler(regs
, (instr
>> 3) & 1);
605 static struct undef_hook setend_hooks
[] = {
607 .instr_mask
= 0xfffffdff,
608 .instr_val
= 0xf1010000,
609 .pstate_mask
= COMPAT_PSR_MODE_MASK
,
610 .pstate_val
= COMPAT_PSR_MODE_USR
,
611 .fn
= a32_setend_handler
,
615 .instr_mask
= 0x0000fff7,
616 .instr_val
= 0x0000b650,
617 .pstate_mask
= (COMPAT_PSR_T_BIT
| COMPAT_PSR_MODE_MASK
),
618 .pstate_val
= (COMPAT_PSR_T_BIT
| COMPAT_PSR_MODE_USR
),
619 .fn
= t16_setend_handler
,
624 static struct insn_emulation_ops setend_ops
= {
626 .status
= INSN_DEPRECATED
,
627 .hooks
= setend_hooks
,
628 .set_hw_mode
= setend_set_hw_mode
,
632 * Invoked as late_initcall, since not needed before init spawned.
634 static int __init
armv8_deprecated_init(void)
636 if (IS_ENABLED(CONFIG_SWP_EMULATION
))
637 register_insn_emulation(&swp_ops
);
639 if (IS_ENABLED(CONFIG_CP15_BARRIER_EMULATION
))
640 register_insn_emulation(&cp15_barrier_ops
);
642 if (IS_ENABLED(CONFIG_SETEND_EMULATION
)) {
643 if(system_supports_mixed_endian_el0())
644 register_insn_emulation(&setend_ops
);
646 pr_info("setend instruction emulation is not supported on this system\n");
649 cpuhp_setup_state_nocalls(CPUHP_AP_ARM64_ISNDEP_STARTING
,
650 "arm64/isndep:starting",
651 run_all_insn_set_hw_mode
, NULL
);
652 register_insn_emulation_sysctl(ctl_abi
);
657 late_initcall(armv8_deprecated_init
);