1 /* SPDX-License-Identifier: GPL-2.0-only */
2 /*
3 * arch/arm/probes/kprobes/test-core.h
4 *
5 * Copyright (C) 2011 Jon Medhurst <tixy@yxit.co.uk>.
6 */
7
8 #define VERBOSE 0 /* Set to '1' for more logging of test cases */
9
10 #ifdef CONFIG_THUMB2_KERNEL
11 #define NORMAL_ISA "16"
12 #else
13 #define NORMAL_ISA "32"
14 #endif
15
16
17 /* Flags used in kprobe_test_flags */
18 #define TEST_FLAG_NO_ITBLOCK (1<<0)
19 #define TEST_FLAG_FULL_ITBLOCK (1<<1)
20 #define TEST_FLAG_NARROW_INSTR (1<<2)
21
22 extern int kprobe_test_flags;
23 extern int kprobe_test_cc_position;
24
25
26 #define TEST_MEMORY_SIZE 256
27
28
29 /*
30 * Test case structures.
31 *
32 * The arguments given to test cases can be one of three types.
33 *
34 * ARG_TYPE_REG
35 * Load a register with the given value.
36 *
37 * ARG_TYPE_PTR
38 * Load a register with a pointer into the stack buffer (SP + given value).
39 *
40 * ARG_TYPE_MEM
41 * Store the given value into the stack buffer at [SP+index].
42 *
43 */
44
45 #define ARG_TYPE_END 0
46 #define ARG_TYPE_REG 1
47 #define ARG_TYPE_PTR 2
48 #define ARG_TYPE_MEM 3
49 #define ARG_TYPE_REG_MASKED 4
50
51 #define ARG_FLAG_UNSUPPORTED 0x01
52 #define ARG_FLAG_SUPPORTED 0x02
53 #define ARG_FLAG_THUMB 0x10 /* Must be 16 so TEST_ISA can be used */
54 #define ARG_FLAG_ARM 0x20 /* Must be 32 so TEST_ISA can be used */
55
56 struct test_arg {
57 u8 type; /* ARG_TYPE_x */
58 u8 _padding[7];
59 };
60
61 struct test_arg_regptr {
62 u8 type; /* ARG_TYPE_REG or ARG_TYPE_PTR or ARG_TYPE_REG_MASKED */
63 u8 reg;
64 u8 _padding[2];
65 u32 val;
66 };
67
68 struct test_arg_mem {
69 u8 type; /* ARG_TYPE_MEM */
70 u8 index;
71 u8 _padding[2];
72 u32 val;
73 };
74
75 struct test_arg_end {
76 u8 type; /* ARG_TYPE_END */
77 u8 flags; /* ARG_FLAG_x */
78 u16 code_offset;
79 u16 branch_offset;
80 u16 end_offset;
81 };
82
83
84 /*
85 * Building blocks for test cases.
86 *
87 * Each test case is wrapped between TESTCASE_START and TESTCASE_END.
88 *
89 * To specify arguments for a test case the TEST_ARG_{REG,PTR,MEM} macros are
90 * used followed by a terminating TEST_ARG_END.
91 *
92 * After this, the instruction to be tested is defined with TEST_INSTRUCTION.
93 * Or for branches, TEST_BRANCH_B and TEST_BRANCH_F (branch forwards/backwards).
94 *
95 * Some specific test cases may make use of other custom constructs.
96 */
97
98 #if VERBOSE
99 #define verbose(fmt, ...) pr_info(fmt, ##__VA_ARGS__)
100 #else
101 #define verbose(fmt, ...) no_printk(fmt, ##__VA_ARGS__)
102 #endif
103
104 #define TEST_GROUP(title) \
105 verbose("\n"); \
106 verbose(title"\n"); \
107 verbose("---------------------------------------------------------\n");
108
109 #define TESTCASE_START(title) \
110 __asm__ __volatile__ ( \
111 ".syntax unified \n\t" \
112 "bl __kprobes_test_case_start \n\t" \
113 ".pushsection .rodata \n\t" \
114 "10: \n\t" \
115 /* don't use .asciz here as 'title' may be */ \
116 /* multiple strings to be concatenated. */ \
117 ".ascii "#title" \n\t" \
118 ".byte 0 \n\t" \
119 ".popsection \n\t" \
120 ".word 10b \n\t"
121
122 #define TEST_ARG_REG(reg, val) \
123 ".byte "__stringify(ARG_TYPE_REG)" \n\t" \
124 ".byte "#reg" \n\t" \
125 ".short 0 \n\t" \
126 ".word "#val" \n\t"
127
128 #define TEST_ARG_PTR(reg, val) \
129 ".byte "__stringify(ARG_TYPE_PTR)" \n\t" \
130 ".byte "#reg" \n\t" \
131 ".short 0 \n\t" \
132 ".word "#val" \n\t"
133
134 #define TEST_ARG_MEM(index, val) \
135 ".byte "__stringify(ARG_TYPE_MEM)" \n\t" \
136 ".byte "#index" \n\t" \
137 ".short 0 \n\t" \
138 ".word "#val" \n\t"
139
140 #define TEST_ARG_REG_MASKED(reg, val) \
141 ".byte "__stringify(ARG_TYPE_REG_MASKED)" \n\t" \
142 ".byte "#reg" \n\t" \
143 ".short 0 \n\t" \
144 ".word "#val" \n\t"
145
146 #define TEST_ARG_END(flags) \
147 ".byte "__stringify(ARG_TYPE_END)" \n\t" \
148 ".byte "TEST_ISA flags" \n\t" \
149 ".short 50f-0f \n\t" \
150 ".short 2f-0f \n\t" \
151 ".short 99f-0f \n\t" \
152 ".code "TEST_ISA" \n\t" \
153 "0: \n\t"
154
155 #define TEST_INSTRUCTION(instruction) \
156 "50: nop \n\t" \
157 "1: "instruction" \n\t" \
158 " nop \n\t"
159
160 #define TEST_BRANCH_F(instruction) \
161 TEST_INSTRUCTION(instruction) \
162 " b 99f \n\t" \
163 "2: nop \n\t"
164
165 #define TEST_BRANCH_B(instruction) \
166 " b 50f \n\t" \
167 " b 99f \n\t" \
168 "2: nop \n\t" \
169 " b 99f \n\t" \
170 TEST_INSTRUCTION(instruction)
171
172 #define TEST_BRANCH_FX(instruction, codex) \
173 TEST_INSTRUCTION(instruction) \
174 " b 99f \n\t" \
175 codex" \n\t" \
176 " b 99f \n\t" \
177 "2: nop \n\t"
178
179 #define TEST_BRANCH_BX(instruction, codex) \
180 " b 50f \n\t" \
181 " b 99f \n\t" \
182 "2: nop \n\t" \
183 " b 99f \n\t" \
184 codex" \n\t" \
185 TEST_INSTRUCTION(instruction)
186
187 #define TESTCASE_END \
188 "2: \n\t" \
189 "99: \n\t" \
190 " bl __kprobes_test_case_end_"TEST_ISA" \n\t" \
191 ".code "NORMAL_ISA" \n\t" \
192 : : \
193 : "r0", "r1", "r2", "r3", "ip", "lr", "memory", "cc" \
194 );
195
196
197 /*
198 * Macros to define test cases.
199 *
200 * Those of the form TEST_{R,P,M}* can be used to define test cases
201 * which take combinations of the three basic types of arguments. E.g.
202 *
203 * TEST_R One register argument
204 * TEST_RR Two register arguments
205 * TEST_RPR A register, a pointer, then a register argument
206 *
207 * For testing instructions which may branch, there are macros TEST_BF_*
208 * and TEST_BB_* for branching forwards and backwards.
209 *
210 * TEST_SUPPORTED and TEST_UNSUPPORTED don't cause the code to be executed,
211 * the just verify that a kprobe is or is not allowed on the given instruction.
212 */
213
214 #define TEST(code) \
215 TESTCASE_START(code) \
216 TEST_ARG_END("") \
217 TEST_INSTRUCTION(code) \
218 TESTCASE_END
219
220 #define TEST_UNSUPPORTED(code) \
221 TESTCASE_START(code) \
222 TEST_ARG_END("|"__stringify(ARG_FLAG_UNSUPPORTED)) \
223 TEST_INSTRUCTION(code) \
224 TESTCASE_END
225
226 #define TEST_SUPPORTED(code) \
227 TESTCASE_START(code) \
228 TEST_ARG_END("|"__stringify(ARG_FLAG_SUPPORTED)) \
229 TEST_INSTRUCTION(code) \
230 TESTCASE_END
231
232 #define TEST_R(code1, reg, val, code2) \
233 TESTCASE_START(code1 #reg code2) \
234 TEST_ARG_REG(reg, val) \
235 TEST_ARG_END("") \
236 TEST_INSTRUCTION(code1 #reg code2) \
237 TESTCASE_END
238
239 #define TEST_RR(code1, reg1, val1, code2, reg2, val2, code3) \
240 TESTCASE_START(code1 #reg1 code2 #reg2 code3) \
241 TEST_ARG_REG(reg1, val1) \
242 TEST_ARG_REG(reg2, val2) \
243 TEST_ARG_END("") \
244 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3) \
245 TESTCASE_END
246
247 #define TEST_RRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
248 TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
249 TEST_ARG_REG(reg1, val1) \
250 TEST_ARG_REG(reg2, val2) \
251 TEST_ARG_REG(reg3, val3) \
252 TEST_ARG_END("") \
253 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
254 TESTCASE_END
255
256 #define TEST_RRRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4, reg4, val4) \
257 TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4 #reg4) \
258 TEST_ARG_REG(reg1, val1) \
259 TEST_ARG_REG(reg2, val2) \
260 TEST_ARG_REG(reg3, val3) \
261 TEST_ARG_REG(reg4, val4) \
262 TEST_ARG_END("") \
263 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4 #reg4) \
264 TESTCASE_END
265
266 #define TEST_P(code1, reg1, val1, code2) \
267 TESTCASE_START(code1 #reg1 code2) \
268 TEST_ARG_PTR(reg1, val1) \
269 TEST_ARG_END("") \
270 TEST_INSTRUCTION(code1 #reg1 code2) \
271 TESTCASE_END
272
273 #define TEST_PR(code1, reg1, val1, code2, reg2, val2, code3) \
274 TESTCASE_START(code1 #reg1 code2 #reg2 code3) \
275 TEST_ARG_PTR(reg1, val1) \
276 TEST_ARG_REG(reg2, val2) \
277 TEST_ARG_END("") \
278 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3) \
279 TESTCASE_END
280
281 #define TEST_RP(code1, reg1, val1, code2, reg2, val2, code3) \
282 TESTCASE_START(code1 #reg1 code2 #reg2 code3) \
283 TEST_ARG_REG(reg1, val1) \
284 TEST_ARG_PTR(reg2, val2) \
285 TEST_ARG_END("") \
286 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3) \
287 TESTCASE_END
288
289 #define TEST_PRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
290 TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
291 TEST_ARG_PTR(reg1, val1) \
292 TEST_ARG_REG(reg2, val2) \
293 TEST_ARG_REG(reg3, val3) \
294 TEST_ARG_END("") \
295 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
296 TESTCASE_END
297
298 #define TEST_RPR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
299 TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
300 TEST_ARG_REG(reg1, val1) \
301 TEST_ARG_PTR(reg2, val2) \
302 TEST_ARG_REG(reg3, val3) \
303 TEST_ARG_END("") \
304 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
305 TESTCASE_END
306
307 #define TEST_RRP(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
308 TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
309 TEST_ARG_REG(reg1, val1) \
310 TEST_ARG_REG(reg2, val2) \
311 TEST_ARG_PTR(reg3, val3) \
312 TEST_ARG_END("") \
313 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
314 TESTCASE_END
315
316 #define TEST_BF_P(code1, reg1, val1, code2) \
317 TESTCASE_START(code1 #reg1 code2) \
318 TEST_ARG_PTR(reg1, val1) \
319 TEST_ARG_END("") \
320 TEST_BRANCH_F(code1 #reg1 code2) \
321 TESTCASE_END
322
323 #define TEST_BF(code) \
324 TESTCASE_START(code) \
325 TEST_ARG_END("") \
326 TEST_BRANCH_F(code) \
327 TESTCASE_END
328
329 #define TEST_BB(code) \
330 TESTCASE_START(code) \
331 TEST_ARG_END("") \
332 TEST_BRANCH_B(code) \
333 TESTCASE_END
334
335 #define TEST_BF_R(code1, reg, val, code2) \
336 TESTCASE_START(code1 #reg code2) \
337 TEST_ARG_REG(reg, val) \
338 TEST_ARG_END("") \
339 TEST_BRANCH_F(code1 #reg code2) \
340 TESTCASE_END
341
342 #define TEST_BB_R(code1, reg, val, code2) \
343 TESTCASE_START(code1 #reg code2) \
344 TEST_ARG_REG(reg, val) \
345 TEST_ARG_END("") \
346 TEST_BRANCH_B(code1 #reg code2) \
347 TESTCASE_END
348
349 #define TEST_BF_RR(code1, reg1, val1, code2, reg2, val2, code3) \
350 TESTCASE_START(code1 #reg1 code2 #reg2 code3) \
351 TEST_ARG_REG(reg1, val1) \
352 TEST_ARG_REG(reg2, val2) \
353 TEST_ARG_END("") \
354 TEST_BRANCH_F(code1 #reg1 code2 #reg2 code3) \
355 TESTCASE_END
356
357 #define TEST_BF_X(code, codex) \
358 TESTCASE_START(code) \
359 TEST_ARG_END("") \
360 TEST_BRANCH_FX(code, codex) \
361 TESTCASE_END
362
363 #define TEST_BB_X(code, codex) \
364 TESTCASE_START(code) \
365 TEST_ARG_END("") \
366 TEST_BRANCH_BX(code, codex) \
367 TESTCASE_END
368
369 #define TEST_BF_RX(code1, reg, val, code2, codex) \
370 TESTCASE_START(code1 #reg code2) \
371 TEST_ARG_REG(reg, val) \
372 TEST_ARG_END("") \
373 TEST_BRANCH_FX(code1 #reg code2, codex) \
374 TESTCASE_END
375
376 #define TEST_X(code, codex) \
377 TESTCASE_START(code) \
378 TEST_ARG_END("") \
379 TEST_INSTRUCTION(code) \
380 " b 99f \n\t" \
381 " "codex" \n\t" \
382 TESTCASE_END
383
384 #define TEST_RX(code1, reg, val, code2, codex) \
385 TESTCASE_START(code1 #reg code2) \
386 TEST_ARG_REG(reg, val) \
387 TEST_ARG_END("") \
388 TEST_INSTRUCTION(code1 __stringify(reg) code2) \
389 " b 99f \n\t" \
390 " "codex" \n\t" \
391 TESTCASE_END
392
393 #define TEST_RRX(code1, reg1, val1, code2, reg2, val2, code3, codex) \
394 TESTCASE_START(code1 #reg1 code2 #reg2 code3) \
395 TEST_ARG_REG(reg1, val1) \
396 TEST_ARG_REG(reg2, val2) \
397 TEST_ARG_END("") \
398 TEST_INSTRUCTION(code1 __stringify(reg1) code2 __stringify(reg2) code3) \
399 " b 99f \n\t" \
400 " "codex" \n\t" \
401 TESTCASE_END
402
403 #define TEST_RMASKED(code1, reg, mask, code2) \
404 TESTCASE_START(code1 #reg code2) \
405 TEST_ARG_REG_MASKED(reg, mask) \
406 TEST_ARG_END("") \
407 TEST_INSTRUCTION(code1 #reg code2) \
408 TESTCASE_END
409
410 /*
411 * We ignore the state of the imprecise abort disable flag (CPSR.A) because this
412 * can change randomly as the kernel doesn't take care to preserve or initialise
413 * this across context switches. Also, with Security Extensions, the flag may
414 * not be under control of the kernel; for this reason we ignore the state of
415 * the FIQ disable flag CPSR.F as well.
416 */
417 #define PSR_IGNORE_BITS (PSR_A_BIT | PSR_F_BIT)
418
419
420 /*
421 * Macros for defining space directives spread over multiple lines.
422 * These are required so the compiler guesses better the length of inline asm
423 * code and will spill the literal pool early enough to avoid generating PC
424 * relative loads with out of range offsets.
425 */
426 #define TWICE(x) x x
427 #define SPACE_0x8 TWICE(".space 4\n\t")
428 #define SPACE_0x10 TWICE(SPACE_0x8)
429 #define SPACE_0x20 TWICE(SPACE_0x10)
430 #define SPACE_0x40 TWICE(SPACE_0x20)
431 #define SPACE_0x80 TWICE(SPACE_0x40)
432 #define SPACE_0x100 TWICE(SPACE_0x80)
433 #define SPACE_0x200 TWICE(SPACE_0x100)
434 #define SPACE_0x400 TWICE(SPACE_0x200)
435 #define SPACE_0x800 TWICE(SPACE_0x400)
436 #define SPACE_0x1000 TWICE(SPACE_0x800)
437
438
439 /* Various values used in test cases... */
440 #define N(val) (val ^ 0xffffffff)
441 #define VAL1 0x12345678
442 #define VAL2 N(VAL1)
443 #define VAL3 0xa5f801
444 #define VAL4 N(VAL3)
445 #define VALM 0x456789ab
446 #define VALR 0xdeaddead
447 #define HH1 0x0123fecb
448 #define HH2 0xa9874567
449
450
451 #ifdef CONFIG_THUMB2_KERNEL
452 void kprobe_thumb16_test_cases(void);
453 void kprobe_thumb32_test_cases(void);
454 #else
455 void kprobe_arm_test_cases(void);
456 #endif
457
458 void __kprobes_test_case_start(void);
459 void __kprobes_test_case_end_16(void);
460 void __kprobes_test_case_end_32(void);
461
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.