]> git.proxmox.com Git - mirror_ubuntu-kernels.git/commitdiff
powerpc: Reject probes on instructions that can't be single stepped
authorNaveen N. Rao <naveen.n.rao@linux.vnet.ibm.com>
Wed, 30 Mar 2022 14:07:18 +0000 (19:37 +0530)
committerMichael Ellerman <mpe@ellerman.id.au>
Thu, 5 May 2022 14:00:20 +0000 (00:00 +1000)
Per the ISA, a Trace interrupt is not generated for:
- [h|u]rfi[d]
- rfscv
- sc, scv, and Trap instructions that trap
- Power-Saving Mode instructions
- other instructions that cause interrupts (other than Trace interrupts)
- the first instructions of any interrupt handler (applies to Branch and Single Step tracing;
CIABR matches may still occur)
- instructions that are emulated by software

Add a helper to check for instructions belonging to the first four
categories above and to reject kprobes, uprobes and xmon breakpoints on
such instructions. We reject probing on instructions belonging to these
categories across all ISA versions and across both BookS and BookE.

For trap instructions, we can't know in advance if they can cause a
trap, and there is no good reason to allow probing on those. Also,
uprobes already refuses to probe trap instructions and kprobes does not
allow probes on trap instructions used for kernel warnings and bugs. As
such, stop allowing any type of probes/breakpoints on trap instruction
across uprobes, kprobes and xmon.

For some of the fp/altivec instructions that can generate an interrupt
and which we emulate in the kernel (altivec assist, for example), we
check and turn off single stepping in emulate_single_step().

Instructions generating a DSI are restarted and single stepping normally
completes once the instruction is completed.

In uprobes, if a single stepped instruction results in a non-fatal
signal to be delivered to the task, such signals are "delayed" until
after the instruction completes. For fatal signals, single stepping is
cancelled and the instruction restarted in-place so that core dump
captures proper addresses.

In kprobes, we do not allow probes on instructions having an extable
entry and we also do not allow probing interrupt vectors.

Signed-off-by: Naveen N. Rao <naveen.n.rao@linux.vnet.ibm.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://lore.kernel.org/r/f56ee979d50b8711fae350fc97870f3ca34acd75.1648648712.git.naveen.n.rao@linux.vnet.ibm.com
arch/powerpc/include/asm/ppc-opcode.h
arch/powerpc/include/asm/probes.h
arch/powerpc/kernel/kprobes.c
arch/powerpc/kernel/uprobes.c
arch/powerpc/xmon/xmon.c

index a5d89cd3e8d12d222a8c966f905fe2830dd35dd6..683e9bc618a74de52fceb8143da3f73cc0d96783 100644 (file)
 #define OP_PREFIX      1
 #define OP_TRAP_64     2
 #define OP_TRAP                3
+#define OP_SC          17
+#define OP_19          19
 #define OP_31          31
 #define OP_LWZ         32
 #define OP_LWZU                33
 #define OP_LD          58
 #define OP_STD         62
 
+#define OP_19_XOP_RFID         18
+#define OP_19_XOP_RFMCI                38
+#define OP_19_XOP_RFDI         39
+#define OP_19_XOP_RFI          50
+#define OP_19_XOP_RFCI         51
+#define OP_19_XOP_RFSCV                82
+#define OP_19_XOP_HRFID                274
+#define OP_19_XOP_URFID                306
+#define OP_19_XOP_STOP         370
+#define OP_19_XOP_DOZE         402
+#define OP_19_XOP_NAP          434
+#define OP_19_XOP_SLEEP                466
+#define OP_19_XOP_RVWINKLE     498
+
 #define OP_31_XOP_TRAP      4
 #define OP_31_XOP_LDX       21
 #define OP_31_XOP_LWZX      23
 #define OP_31_XOP_LHZUX     311
 #define OP_31_XOP_MSGSNDP   142
 #define OP_31_XOP_MSGCLRP   174
+#define OP_31_XOP_MTMSR     146
+#define OP_31_XOP_MTMSRD    178
 #define OP_31_XOP_TLBIE     306
 #define OP_31_XOP_MFSPR     339
 #define OP_31_XOP_LWAX      341
index c5d984700d241a976e9d1039d16a410de9875293..6f66e358aa37805cd7169b3c4d329bcd40375842 100644 (file)
@@ -8,6 +8,7 @@
  * Copyright IBM Corporation, 2012
  */
 #include <linux/types.h>
+#include <asm/disassemble.h>
 
 typedef u32 ppc_opcode_t;
 #define BREAKPOINT_INSTRUCTION 0x7fe00008      /* trap */
@@ -31,6 +32,41 @@ typedef u32 ppc_opcode_t;
 #define MSR_SINGLESTEP (MSR_SE)
 #endif
 
+static inline bool can_single_step(u32 inst)
+{
+       switch (get_op(inst)) {
+       case OP_TRAP_64:        return false;
+       case OP_TRAP:           return false;
+       case OP_SC:             return false;
+       case OP_19:
+               switch (get_xop(inst)) {
+               case OP_19_XOP_RFID:            return false;
+               case OP_19_XOP_RFMCI:           return false;
+               case OP_19_XOP_RFDI:            return false;
+               case OP_19_XOP_RFI:             return false;
+               case OP_19_XOP_RFCI:            return false;
+               case OP_19_XOP_RFSCV:           return false;
+               case OP_19_XOP_HRFID:           return false;
+               case OP_19_XOP_URFID:           return false;
+               case OP_19_XOP_STOP:            return false;
+               case OP_19_XOP_DOZE:            return false;
+               case OP_19_XOP_NAP:             return false;
+               case OP_19_XOP_SLEEP:           return false;
+               case OP_19_XOP_RVWINKLE:        return false;
+               }
+               break;
+       case OP_31:
+               switch (get_xop(inst)) {
+               case OP_31_XOP_TRAP:            return false;
+               case OP_31_XOP_TRAP_64:         return false;
+               case OP_31_XOP_MTMSR:           return false;
+               case OP_31_XOP_MTMSRD:          return false;
+               }
+               break;
+       }
+       return true;
+}
+
 /* Enable single stepping for the current task */
 static inline void enable_single_step(struct pt_regs *regs)
 {
index 7dae0b01abfbd6ead362ed3eb1ec58d5b427e15c..d5f55e5c8971b59b42c9327148a5fc721059f896 100644 (file)
@@ -150,8 +150,8 @@ int arch_prepare_kprobe(struct kprobe *p)
        if ((unsigned long)p->addr & 0x03) {
                printk("Attempt to register kprobe at an unaligned address\n");
                ret = -EINVAL;
-       } else if (IS_MTMSRD(insn) || IS_RFID(insn)) {
-               printk("Cannot register a kprobe on mtmsr[d]/rfi[d]\n");
+       } else if (!can_single_step(ppc_inst_val(insn))) {
+               printk("Cannot register a kprobe on instructions that can't be single stepped\n");
                ret = -EINVAL;
        } else if ((unsigned long)p->addr & ~PAGE_MASK &&
                   ppc_inst_prefixed(ppc_inst_read(p->addr - 1))) {
index c6975467d9ffdcad81b9a56a7a96a75b9ca0c3c6..95a41ae9dfa75553ca4ee38a999570f210a52b20 100644 (file)
@@ -48,6 +48,11 @@ int arch_uprobe_analyze_insn(struct arch_uprobe *auprobe,
                return -EINVAL;
        }
 
+       if (!can_single_step(ppc_inst_val(ppc_inst_read(auprobe->insn)))) {
+               pr_info_ratelimited("Cannot register a uprobe on instructions that can't be single stepped\n");
+               return -ENOTSUPP;
+       }
+
        return 0;
 }
 
index 27da7d5c20241373681aab104e49051be18a9cd4..f93090c033a43d43b2563344196b67781f37e8a5 100644 (file)
@@ -921,9 +921,9 @@ static void insert_bpts(void)
                        bp->enabled = 0;
                        continue;
                }
-               if (IS_MTMSRD(instr) || IS_RFID(instr)) {
-                       printf("Breakpoint at %lx is on an mtmsrd or rfid "
-                              "instruction, disabling it\n", bp->address);
+               if (!can_single_step(ppc_inst_val(instr))) {
+                       printf("Breakpoint at %lx is on an instruction that can't be single stepped, disabling it\n",
+                                       bp->address);
                        bp->enabled = 0;
                        continue;
                }
@@ -1470,9 +1470,8 @@ static long check_bp_loc(unsigned long addr)
                printf("Can't read instruction at address %lx\n", addr);
                return 0;
        }
-       if (IS_MTMSRD(instr) || IS_RFID(instr)) {
-               printf("Breakpoints may not be placed on mtmsrd or rfid "
-                      "instructions\n");
+       if (!can_single_step(ppc_inst_val(instr))) {
+               printf("Breakpoints may not be placed on instructions that can't be single stepped\n");
                return 0;
        }
        return 1;