1 // SPDX-License-Identifier: GPL-2.0-only 1
2 /*
3 * Copyright (C) 2012 Rabin Vincent <rabin at
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
18 {
19 probes_opcode_t insn = __mem_to_opcode
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, i
27 if ((regs & 0xf) == REG_TYPE_N
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
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, f
52 if ((regs & 0xf) == REG_TYPE_N
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 *
67 struct arch_uprobe_t
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
77 struct arch_uprobe
78 struct pt_regs *re
79 {
80 /* PC will be taken care of by common
81 regs->uregs[auprobe->pcreg] = autask->
82 }
83
84 static void uprobe_aluwrite_pc(struct arch_upr
85 struct arch_upr
86 struct pt_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
95 struct arch_uprobe
96 struct pt_regs *re
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
106 const struct decode_header *d)
107 {
108 struct arch_uprobe *auprobe = containe
109
110 struct decode_emulate *decode = (struc
111 u32 regs = decode->header.type_regs.bi
112 int reg;
113
114 reg = uprobes_substitute_pc(&auprobe->
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
130 const struct decode_header *d, bo
131 {
132 struct arch_uprobe *auprobe = containe
133
134 enum probes_insn ret = decode_pc_ro(in
135
136 if (((insn >> 12) & 0xf) == 15)
137 auprobe->posthandler = alu ? u
138 : u
139
140 return ret;
141 }
142
143 enum probes_insn
144 decode_rd12rn16rm0rs8_rwflags(probes_opcode_t
145 struct arch_prob
146 const struct dec
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_p
153 const struct decode_header *d)
154 {
155 return decode_wb_pc(insn, asi, d, fals
156 }
157
158 enum probes_insn
159 uprobe_decode_ldmstm(probes_opcode_t insn,
160 struct arch_probes_insn *
161 const struct decode_heade
162 {
163 struct arch_uprobe *auprobe = containe
164
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
184
185 auprobe->prehandler = uprobe_set_pc;
186 if (lbit)
187 auprobe->posthandler = uprobe_
188 else
189 auprobe->posthandler = uprobe_
190
191 return INSN_GOOD;
192 }
193
194 const union decode_action uprobes_probes_actio
195 [PROBES_PRELOAD_IMM] = {.handler = pro
196 [PROBES_PRELOAD_REG] = {.handler = pro
197 [PROBES_BRANCH_IMM] = {.handler = simu
198 [PROBES_MRS] = {.handler = simulate_mr
199 [PROBES_BRANCH_REG] = {.handler = simu
200 [PROBES_CLZ] = {.handler = probes_simu
201 [PROBES_SATURATING_ARITHMETIC] = {.han
202 [PROBES_MUL1] = {.handler = probes_sim
203 [PROBES_MUL2] = {.handler = probes_sim
204 [PROBES_SWP] = {.handler = probes_simu
205 [PROBES_LDRSTRD] = {.decoder = decode_
206 [PROBES_LOAD_EXTRA] = {.decoder = deco
207 [PROBES_LOAD] = {.decoder = decode_ldr
208 [PROBES_STORE_EXTRA] = {.decoder = dec
209 [PROBES_STORE] = {.decoder = decode_pc
210 [PROBES_MOV_IP_SP] = {.handler = simul
211 [PROBES_DATA_PROCESSING_REG] = {
212 .decoder = decode_rd12rn16rm0r
213 [PROBES_DATA_PROCESSING_IMM] = {
214 .decoder = decode_rd12rn16rm0r
215 [PROBES_MOV_HALFWORD] = {.handler = pr
216 [PROBES_SEV] = {.handler = probes_simu
217 [PROBES_WFE] = {.handler = probes_simu
218 [PROBES_SATURATE] = {.handler = probes
219 [PROBES_REV] = {.handler = probes_simu
220 [PROBES_MMI] = {.handler = probes_simu
221 [PROBES_PACK] = {.handler = probes_sim
222 [PROBES_EXTEND] = {.handler = probes_s
223 [PROBES_EXTEND_ADD] = {.handler = prob
224 [PROBES_MUL_ADD_LONG] = {.handler = pr
225 [PROBES_MUL_ADD] = {.handler = probes_
226 [PROBES_BITFIELD] = {.handler = probes
227 [PROBES_BRANCH] = {.handler = simulate
228 [PROBES_LDMSTM] = {.decoder = uprobe_d
229 };
230
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.