Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * Kernel Probes Jump Optimization (Optprobes)
4 : : *
5 : : * Copyright (C) IBM Corporation, 2002, 2004
6 : : * Copyright (C) Hitachi Ltd., 2012
7 : : * Copyright (C) Huawei Inc., 2014
8 : : */
9 : :
10 : : #include <linux/kprobes.h>
11 : : #include <linux/jump_label.h>
12 : : #include <asm/kprobes.h>
13 : : #include <asm/cacheflush.h>
14 : : /* for arm_gen_branch */
15 : : #include <asm/insn.h>
16 : : /* for patch_text */
17 : : #include <asm/patch.h>
18 : :
19 : : #include "core.h"
20 : :
21 : : /*
22 : : * See register_usage_flags. If the probed instruction doesn't use PC,
23 : : * we can copy it into template and have it executed directly without
24 : : * simulation or emulation.
25 : : */
26 : : #define ARM_REG_PC 15
27 : : #define can_kprobe_direct_exec(m) (!test_bit(ARM_REG_PC, &(m)))
28 : :
29 : : /*
30 : : * NOTE: the first sub and add instruction will be modified according
31 : : * to the stack cost of the instruction.
32 : : */
33 : : asm (
34 : : ".global optprobe_template_entry\n"
35 : : "optprobe_template_entry:\n"
36 : : ".global optprobe_template_sub_sp\n"
37 : : "optprobe_template_sub_sp:"
38 : : " sub sp, sp, #0xff\n"
39 : : " stmia sp, {r0 - r14} \n"
40 : : ".global optprobe_template_add_sp\n"
41 : : "optprobe_template_add_sp:"
42 : : " add r3, sp, #0xff\n"
43 : : " str r3, [sp, #52]\n"
44 : : " mrs r4, cpsr\n"
45 : : " str r4, [sp, #64]\n"
46 : : " mov r1, sp\n"
47 : : " ldr r0, 1f\n"
48 : : " ldr r2, 2f\n"
49 : : /*
50 : : * AEABI requires an 8-bytes alignment stack. If
51 : : * SP % 8 != 0 (SP % 4 == 0 should be ensured),
52 : : * alloc more bytes here.
53 : : */
54 : : " and r4, sp, #4\n"
55 : : " sub sp, sp, r4\n"
56 : : #if __LINUX_ARM_ARCH__ >= 5
57 : : " blx r2\n"
58 : : #else
59 : : " mov lr, pc\n"
60 : : " mov pc, r2\n"
61 : : #endif
62 : : " add sp, sp, r4\n"
63 : : " ldr r1, [sp, #64]\n"
64 : : " tst r1, #"__stringify(PSR_T_BIT)"\n"
65 : : " ldrne r2, [sp, #60]\n"
66 : : " orrne r2, #1\n"
67 : : " strne r2, [sp, #60] @ set bit0 of PC for thumb\n"
68 : : " msr cpsr_cxsf, r1\n"
69 : : ".global optprobe_template_restore_begin\n"
70 : : "optprobe_template_restore_begin:\n"
71 : : " ldmia sp, {r0 - r15}\n"
72 : : ".global optprobe_template_restore_orig_insn\n"
73 : : "optprobe_template_restore_orig_insn:\n"
74 : : " nop\n"
75 : : ".global optprobe_template_restore_end\n"
76 : : "optprobe_template_restore_end:\n"
77 : : " nop\n"
78 : : ".global optprobe_template_val\n"
79 : : "optprobe_template_val:\n"
80 : : "1: .long 0\n"
81 : : ".global optprobe_template_call\n"
82 : : "optprobe_template_call:\n"
83 : : "2: .long 0\n"
84 : : ".global optprobe_template_end\n"
85 : : "optprobe_template_end:\n");
86 : :
87 : : #define TMPL_VAL_IDX \
88 : : ((unsigned long *)&optprobe_template_val - (unsigned long *)&optprobe_template_entry)
89 : : #define TMPL_CALL_IDX \
90 : : ((unsigned long *)&optprobe_template_call - (unsigned long *)&optprobe_template_entry)
91 : : #define TMPL_END_IDX \
92 : : ((unsigned long *)&optprobe_template_end - (unsigned long *)&optprobe_template_entry)
93 : : #define TMPL_ADD_SP \
94 : : ((unsigned long *)&optprobe_template_add_sp - (unsigned long *)&optprobe_template_entry)
95 : : #define TMPL_SUB_SP \
96 : : ((unsigned long *)&optprobe_template_sub_sp - (unsigned long *)&optprobe_template_entry)
97 : : #define TMPL_RESTORE_BEGIN \
98 : : ((unsigned long *)&optprobe_template_restore_begin - (unsigned long *)&optprobe_template_entry)
99 : : #define TMPL_RESTORE_ORIGN_INSN \
100 : : ((unsigned long *)&optprobe_template_restore_orig_insn - (unsigned long *)&optprobe_template_entry)
101 : : #define TMPL_RESTORE_END \
102 : : ((unsigned long *)&optprobe_template_restore_end - (unsigned long *)&optprobe_template_entry)
103 : :
104 : : /*
105 : : * ARM can always optimize an instruction when using ARM ISA, except
106 : : * instructions like 'str r0, [sp, r1]' which store to stack and unable
107 : : * to determine stack space consumption statically.
108 : : */
109 : 0 : int arch_prepared_optinsn(struct arch_optimized_insn *optinsn)
110 : : {
111 : 0 : return optinsn->insn != NULL;
112 : : }
113 : :
114 : : /*
115 : : * In ARM ISA, kprobe opt always replace one instruction (4 bytes
116 : : * aligned and 4 bytes long). It is impossible to encounter another
117 : : * kprobe in the address range. So always return 0.
118 : : */
119 : 0 : int arch_check_optimized_kprobe(struct optimized_kprobe *op)
120 : : {
121 : 0 : return 0;
122 : : }
123 : :
124 : : /* Caller must ensure addr & 3 == 0 */
125 : : static int can_optimize(struct kprobe *kp)
126 : : {
127 [ # # ]: 0 : if (kp->ainsn.stack_space < 0)
128 : : return 0;
129 : : /*
130 : : * 255 is the biggest imm can be used in 'sub r0, r0, #<imm>'.
131 : : * Number larger than 255 needs special encoding.
132 : : */
133 [ # # ]: 0 : if (kp->ainsn.stack_space > 255 - sizeof(struct pt_regs))
134 : : return 0;
135 : : return 1;
136 : : }
137 : :
138 : : /* Free optimized instruction slot */
139 : : static void
140 : : __arch_remove_optimized_kprobe(struct optimized_kprobe *op, int dirty)
141 : : {
142 [ # # ]: 0 : if (op->optinsn.insn) {
143 : : free_optinsn_slot(op->optinsn.insn, dirty);
144 : 0 : op->optinsn.insn = NULL;
145 : : }
146 : : }
147 : :
148 : : extern void kprobe_handler(struct pt_regs *regs);
149 : :
150 : : static void
151 : 0 : optimized_callback(struct optimized_kprobe *op, struct pt_regs *regs)
152 : : {
153 : : unsigned long flags;
154 : : struct kprobe *p = &op->kp;
155 : : struct kprobe_ctlblk *kcb;
156 : :
157 : : /* Save skipped registers */
158 : 0 : regs->ARM_pc = (unsigned long)op->kp.addr;
159 : 0 : regs->ARM_ORIG_r0 = ~0UL;
160 : :
161 : 0 : local_irq_save(flags);
162 : : kcb = get_kprobe_ctlblk();
163 : :
164 [ # # ]: 0 : if (kprobe_running()) {
165 : 0 : kprobes_inc_nmissed_count(&op->kp);
166 : : } else {
167 : 0 : __this_cpu_write(current_kprobe, &op->kp);
168 : 0 : kcb->kprobe_status = KPROBE_HIT_ACTIVE;
169 : 0 : opt_pre_handler(&op->kp, regs);
170 : 0 : __this_cpu_write(current_kprobe, NULL);
171 : : }
172 : :
173 : : /*
174 : : * We singlestep the replaced instruction only when it can't be
175 : : * executed directly during restore.
176 : : */
177 [ # # ]: 0 : if (!p->ainsn.kprobe_direct_exec)
178 : 0 : op->kp.ainsn.insn_singlestep(p->opcode, &p->ainsn, regs);
179 : :
180 [ # # ]: 0 : local_irq_restore(flags);
181 : 0 : }
182 : : NOKPROBE_SYMBOL(optimized_callback)
183 : :
184 : 0 : int arch_prepare_optimized_kprobe(struct optimized_kprobe *op, struct kprobe *orig)
185 : : {
186 : : kprobe_opcode_t *code;
187 : : unsigned long rel_chk;
188 : : unsigned long val;
189 : : unsigned long stack_protect = sizeof(struct pt_regs);
190 : :
191 [ # # ]: 0 : if (!can_optimize(orig))
192 : : return -EILSEQ;
193 : :
194 : : code = get_optinsn_slot();
195 [ # # ]: 0 : if (!code)
196 : : return -ENOMEM;
197 : :
198 : : /*
199 : : * Verify if the address gap is in 32MiB range, because this uses
200 : : * a relative jump.
201 : : *
202 : : * kprobe opt use a 'b' instruction to branch to optinsn.insn.
203 : : * According to ARM manual, branch instruction is:
204 : : *
205 : : * 31 28 27 24 23 0
206 : : * +------+---+---+---+---+----------------+
207 : : * | cond | 1 | 0 | 1 | 0 | imm24 |
208 : : * +------+---+---+---+---+----------------+
209 : : *
210 : : * imm24 is a signed 24 bits integer. The real branch offset is computed
211 : : * by: imm32 = SignExtend(imm24:'00', 32);
212 : : *
213 : : * So the maximum forward branch should be:
214 : : * (0x007fffff << 2) = 0x01fffffc = 0x1fffffc
215 : : * The maximum backword branch should be:
216 : : * (0xff800000 << 2) = 0xfe000000 = -0x2000000
217 : : *
218 : : * We can simply check (rel & 0xfe000003):
219 : : * if rel is positive, (rel & 0xfe000000) shoule be 0
220 : : * if rel is negitive, (rel & 0xfe000000) should be 0xfe000000
221 : : * the last '3' is used for alignment checking.
222 : : */
223 : 0 : rel_chk = (unsigned long)((long)code -
224 : 0 : (long)orig->addr + 8) & 0xfe000003;
225 : :
226 [ # # ]: 0 : if ((rel_chk != 0) && (rel_chk != 0xfe000000)) {
227 : : /*
228 : : * Different from x86, we free code buf directly instead of
229 : : * calling __arch_remove_optimized_kprobe() because
230 : : * we have not fill any field in op.
231 : : */
232 : : free_optinsn_slot(code, 0);
233 : 0 : return -ERANGE;
234 : : }
235 : :
236 : : /* Copy arch-dep-instance from template. */
237 : 0 : memcpy(code, (unsigned long *)&optprobe_template_entry,
238 : 0 : TMPL_END_IDX * sizeof(kprobe_opcode_t));
239 : :
240 : : /* Adjust buffer according to instruction. */
241 [ # # ]: 0 : BUG_ON(orig->ainsn.stack_space < 0);
242 : :
243 : 0 : stack_protect += orig->ainsn.stack_space;
244 : :
245 : : /* Should have been filtered by can_optimize(). */
246 [ # # ]: 0 : BUG_ON(stack_protect > 255);
247 : :
248 : : /* Create a 'sub sp, sp, #<stack_protect>' */
249 : 0 : code[TMPL_SUB_SP] = __opcode_to_mem_arm(0xe24dd000 | stack_protect);
250 : : /* Create a 'add r3, sp, #<stack_protect>' */
251 : 0 : code[TMPL_ADD_SP] = __opcode_to_mem_arm(0xe28d3000 | stack_protect);
252 : :
253 : : /* Set probe information */
254 : 0 : val = (unsigned long)op;
255 : 0 : code[TMPL_VAL_IDX] = val;
256 : :
257 : : /* Set probe function call */
258 : 0 : val = (unsigned long)optimized_callback;
259 : 0 : code[TMPL_CALL_IDX] = val;
260 : :
261 : : /* If possible, copy insn and have it executed during restore */
262 : 0 : orig->ainsn.kprobe_direct_exec = false;
263 [ # # ]: 0 : if (can_kprobe_direct_exec(orig->ainsn.register_usage_flags)) {
264 : 0 : kprobe_opcode_t final_branch = arm_gen_branch(
265 : 0 : (unsigned long)(&code[TMPL_RESTORE_END]),
266 : 0 : (unsigned long)(op->kp.addr) + 4);
267 [ # # ]: 0 : if (final_branch != 0) {
268 : : /*
269 : : * Replace original 'ldmia sp, {r0 - r15}' with
270 : : * 'ldmia {r0 - r14}', restore all registers except pc.
271 : : */
272 : 0 : code[TMPL_RESTORE_BEGIN] = __opcode_to_mem_arm(0xe89d7fff);
273 : :
274 : : /* The original probed instruction */
275 : 0 : code[TMPL_RESTORE_ORIGN_INSN] = __opcode_to_mem_arm(orig->opcode);
276 : :
277 : : /* Jump back to next instruction */
278 : 0 : code[TMPL_RESTORE_END] = __opcode_to_mem_arm(final_branch);
279 : 0 : orig->ainsn.kprobe_direct_exec = true;
280 : : }
281 : : }
282 : :
283 : 0 : flush_icache_range((unsigned long)code,
284 : : (unsigned long)(&code[TMPL_END_IDX]));
285 : :
286 : : /* Set op->optinsn.insn means prepared. */
287 : 0 : op->optinsn.insn = code;
288 : 0 : return 0;
289 : : }
290 : :
291 : 0 : void __kprobes arch_optimize_kprobes(struct list_head *oplist)
292 : : {
293 : : struct optimized_kprobe *op, *tmp;
294 : :
295 [ # # ]: 0 : list_for_each_entry_safe(op, tmp, oplist, list) {
296 : : unsigned long insn;
297 [ # # ]: 0 : WARN_ON(kprobe_disabled(&op->kp));
298 : :
299 : : /*
300 : : * Backup instructions which will be replaced
301 : : * by jump address
302 : : */
303 : 0 : memcpy(op->optinsn.copied_insn, op->kp.addr,
304 : : RELATIVEJUMP_SIZE);
305 : :
306 : 0 : insn = arm_gen_branch((unsigned long)op->kp.addr,
307 : 0 : (unsigned long)op->optinsn.insn);
308 [ # # ]: 0 : BUG_ON(insn == 0);
309 : :
310 : : /*
311 : : * Make it a conditional branch if replaced insn
312 : : * is consitional
313 : : */
314 : 0 : insn = (__mem_to_opcode_arm(
315 : 0 : op->optinsn.copied_insn[0]) & 0xf0000000) |
316 : 0 : (insn & 0x0fffffff);
317 : :
318 : : /*
319 : : * Similar to __arch_disarm_kprobe, operations which
320 : : * removing breakpoints must be wrapped by stop_machine
321 : : * to avoid racing.
322 : : */
323 : 0 : kprobes_remove_breakpoint(op->kp.addr, insn);
324 : :
325 : : list_del_init(&op->list);
326 : : }
327 : 0 : }
328 : :
329 : 0 : void arch_unoptimize_kprobe(struct optimized_kprobe *op)
330 : : {
331 : 0 : arch_arm_kprobe(&op->kp);
332 : 0 : }
333 : :
334 : : /*
335 : : * Recover original instructions and breakpoints from relative jumps.
336 : : * Caller must call with locking kprobe_mutex.
337 : : */
338 : 0 : void arch_unoptimize_kprobes(struct list_head *oplist,
339 : : struct list_head *done_list)
340 : : {
341 : : struct optimized_kprobe *op, *tmp;
342 : :
343 [ # # ]: 0 : list_for_each_entry_safe(op, tmp, oplist, list) {
344 : : arch_unoptimize_kprobe(op);
345 : : list_move(&op->list, done_list);
346 : : }
347 : 0 : }
348 : :
349 : 0 : int arch_within_optimized_kprobe(struct optimized_kprobe *op,
350 : : unsigned long addr)
351 : : {
352 [ # # # # ]: 0 : return ((unsigned long)op->kp.addr <= addr &&
353 : 0 : (unsigned long)op->kp.addr + RELATIVEJUMP_SIZE > addr);
354 : : }
355 : :
356 : 0 : void arch_remove_optimized_kprobe(struct optimized_kprobe *op)
357 : : {
358 : : __arch_remove_optimized_kprobe(op, 1);
359 : 0 : }
|
