arch/arm/probes/uprobes/actions-arm.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2012 Rabin Vincent <rabin at rab.in>
   4  */
   5
   6 #include <linux/kernel.h>
   7 #include <linux/types.h>
   8 #include <linux/stddef.h>
   9 #include <linux/wait.h>
  10 #include <linux/uprobes.h>
  11 #include <linux/module.h>
  12
  13 #include "../decode.h"
  14 #include "../decode-arm.h"
  15 #include "core.h"
  16
  17 static int uprobes_substitute_pc(unsigned long *pinsn, u32 oregs)
  18 {
  19         probes_opcode_t insn = __mem_to_opcode_arm(*pinsn);
  20         probes_opcode_t temp;
  21         probes_opcode_t mask;
  22         int freereg;
  23         u32 free = 0xffff;
  24         u32 regs;
  25
  26         for (regs = oregs; regs; regs >>= 4, insn >>= 4) {
  27                 if ((regs & 0xf) == REG_TYPE_NONE)
  28                         continue;
  29
  30                 free &= ~(1 << (insn & 0xf));
  31         }
  32
  33         /* No PC, no problem */
  34         if (free & (1 << 15))
  35                 return 15;
  36
  37         if (!free)
  38                 return -1;
  39
  40         /*
  41          * fls instead of ffs ensures that for "ldrd r0, r1, [pc]" we would
  42          * pick LR instead of R1.
  43          */
  44         freereg = free = fls(free) - 1;
  45
  46         temp = __mem_to_opcode_arm(*pinsn);
  47         insn = temp;
  48         regs = oregs;
  49         mask = 0xf;
  50
  51         for (; regs; regs >>= 4, mask <<= 4, free <<= 4, temp >>= 4) {
  52                 if ((regs & 0xf) == REG_TYPE_NONE)
  53                         continue;
  54
  55                 if ((temp & 0xf) != 15)
  56                         continue;
  57
  58                 insn &= ~mask;
  59                 insn |= free & mask;
  60         }
  61
  62         *pinsn = __opcode_to_mem_arm(insn);
  63         return freereg;
  64 }
  65
  66 static void uprobe_set_pc(struct arch_uprobe *auprobe,
  67                           struct arch_uprobe_task *autask,
  68                           struct pt_regs *regs)
  69 {
  70         u32 pcreg = auprobe->pcreg;
  71
  72         autask->backup = regs->uregs[pcreg];
  73         regs->uregs[pcreg] = regs->ARM_pc + 8;
  74 }
  75
  76 static void uprobe_unset_pc(struct arch_uprobe *auprobe,
  77                             struct arch_uprobe_task *autask,
  78                             struct pt_regs *regs)
  79 {
  80         /* PC will be taken care of by common code */
  81         regs->uregs[auprobe->pcreg] = autask->backup;
  82 }
  83
  84 static void uprobe_aluwrite_pc(struct arch_uprobe *auprobe,
  85                                struct arch_uprobe_task *autask,
  86                                struct pt_regs *regs)
  87 {
  88         u32 pcreg = auprobe->pcreg;
  89
  90         alu_write_pc(regs->uregs[pcreg], regs);
  91         regs->uregs[pcreg] = autask->backup;
  92 }
  93
  94 static void uprobe_write_pc(struct arch_uprobe *auprobe,
  95                             struct arch_uprobe_task *autask,
  96                             struct pt_regs *regs)
  97 {
  98         u32 pcreg = auprobe->pcreg;
  99
 100         load_write_pc(regs->uregs[pcreg], regs);
 101         regs->uregs[pcreg] = autask->backup;
 102 }
 103
 104 enum probes_insn
 105 decode_pc_ro(probes_opcode_t insn, struct arch_probes_insn *asi,
 106              const struct decode_header *d)
 107 {
 108         struct arch_uprobe *auprobe = container_of(asi, struct arch_uprobe,
 109                                                    asi);
 110         struct decode_emulate *decode = (struct decode_emulate *) d;
 111         u32 regs = decode->header.type_regs.bits >> DECODE_TYPE_BITS;
 112         int reg;
 113
 114         reg = uprobes_substitute_pc(&auprobe->ixol[0], regs);
 115         if (reg == 15)
 116                 return INSN_GOOD;
 117
 118         if (reg == -1)
 119                 return INSN_REJECTED;
 120
 121         auprobe->pcreg = reg;
 122         auprobe->prehandler = uprobe_set_pc;
 123         auprobe->posthandler = uprobe_unset_pc;
 124
 125         return INSN_GOOD;
 126 }
 127
 128 enum probes_insn
 129 decode_wb_pc(probes_opcode_t insn, struct arch_probes_insn *asi,
 130              const struct decode_header *d, bool alu)
 131 {
 132         struct arch_uprobe *auprobe = container_of(asi, struct arch_uprobe,
 133                                                    asi);
 134         enum probes_insn ret = decode_pc_ro(insn, asi, d);
 135
 136         if (((insn >> 12) & 0xf) == 15)
 137                 auprobe->posthandler = alu ? uprobe_aluwrite_pc
 138                                            : uprobe_write_pc;
 139
 140         return ret;
 141 }
 142
 143 enum probes_insn
 144 decode_rd12rn16rm0rs8_rwflags(probes_opcode_t insn,
 145                               struct arch_probes_insn *asi,
 146                               const struct decode_header *d)
 147 {
 148         return decode_wb_pc(insn, asi, d, true);
 149 }
 150
 151 enum probes_insn
 152 decode_ldr(probes_opcode_t insn, struct arch_probes_insn *asi,
 153            const struct decode_header *d)
 154 {
 155         return decode_wb_pc(insn, asi, d, false);
 156 }
 157
 158 enum probes_insn
 159 uprobe_decode_ldmstm(probes_opcode_t insn,
 160                      struct arch_probes_insn *asi,
 161                      const struct decode_header *d)
 162 {
 163         struct arch_uprobe *auprobe = container_of(asi, struct arch_uprobe,
 164                                                    asi);
 165         unsigned reglist = insn & 0xffff;
 166         int rn = (insn >> 16) & 0xf;
 167         int lbit = insn & (1 << 20);
 168         unsigned used = reglist | (1 << rn);
 169
 170         if (rn == 15)
 171                 return INSN_REJECTED;
 172
 173         if (!(used & (1 << 15)))
 174                 return INSN_GOOD;
 175
 176         if (used & (1 << 14))
 177                 return INSN_REJECTED;
 178
 179         /* Use LR instead of PC */
 180         insn ^= 0xc000;
 181
 182         auprobe->pcreg = 14;
 183         auprobe->ixol[0] = __opcode_to_mem_arm(insn);
 184
 185         auprobe->prehandler = uprobe_set_pc;
 186         if (lbit)
 187                 auprobe->posthandler = uprobe_write_pc;
 188         else
 189                 auprobe->posthandler = uprobe_unset_pc;
 190
 191         return INSN_GOOD;
 192 }
 193
 194 const union decode_action uprobes_probes_actions[] = {
 195         [PROBES_PRELOAD_IMM] = {.handler = probes_simulate_nop},
 196         [PROBES_PRELOAD_REG] = {.handler = probes_simulate_nop},
 197         [PROBES_BRANCH_IMM] = {.handler = simulate_blx1},
 198         [PROBES_MRS] = {.handler = simulate_mrs},
 199         [PROBES_BRANCH_REG] = {.handler = simulate_blx2bx},
 200         [PROBES_CLZ] = {.handler = probes_simulate_nop},
 201         [PROBES_SATURATING_ARITHMETIC] = {.handler = probes_simulate_nop},
 202         [PROBES_MUL1] = {.handler = probes_simulate_nop},
 203         [PROBES_MUL2] = {.handler = probes_simulate_nop},
 204         [PROBES_SWP] = {.handler = probes_simulate_nop},
 205         [PROBES_LDRSTRD] = {.decoder = decode_pc_ro},
 206         [PROBES_LOAD_EXTRA] = {.decoder = decode_pc_ro},
 207         [PROBES_LOAD] = {.decoder = decode_ldr},
 208         [PROBES_STORE_EXTRA] = {.decoder = decode_pc_ro},
 209         [PROBES_STORE] = {.decoder = decode_pc_ro},
 210         [PROBES_MOV_IP_SP] = {.handler = simulate_mov_ipsp},
 211         [PROBES_DATA_PROCESSING_REG] = {
 212                 .decoder = decode_rd12rn16rm0rs8_rwflags},
 213         [PROBES_DATA_PROCESSING_IMM] = {
 214                 .decoder = decode_rd12rn16rm0rs8_rwflags},
 215         [PROBES_MOV_HALFWORD] = {.handler = probes_simulate_nop},
 216         [PROBES_SEV] = {.handler = probes_simulate_nop},
 217         [PROBES_WFE] = {.handler = probes_simulate_nop},
 218         [PROBES_SATURATE] = {.handler = probes_simulate_nop},
 219         [PROBES_REV] = {.handler = probes_simulate_nop},
 220         [PROBES_MMI] = {.handler = probes_simulate_nop},
 221         [PROBES_PACK] = {.handler = probes_simulate_nop},
 222         [PROBES_EXTEND] = {.handler = probes_simulate_nop},
 223         [PROBES_EXTEND_ADD] = {.handler = probes_simulate_nop},
 224         [PROBES_MUL_ADD_LONG] = {.handler = probes_simulate_nop},
 225         [PROBES_MUL_ADD] = {.handler = probes_simulate_nop},
 226         [PROBES_BITFIELD] = {.handler = probes_simulate_nop},
 227         [PROBES_BRANCH] = {.handler = simulate_bbl},
 228         [PROBES_LDMSTM] = {.decoder = uprobe_decode_ldmstm}
 229 };