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, ...)
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 	"bl	__kprobes_test_case_start		\n\t"	\
112 	".pushsection .rodata				\n\t"	\
113 	"10:						\n\t"	\
114 	/* don't use .asciz here as 'title' may be */		\
115 	/* multiple strings to be concatenated.  */		\
116 	".ascii "#title"				\n\t"	\
117 	".byte	0					\n\t"	\
118 	".popsection					\n\t"	\
119 	".word	10b					\n\t"
120 
121 #define	TEST_ARG_REG(reg, val)					\
122 	".byte	"__stringify(ARG_TYPE_REG)"		\n\t"	\
123 	".byte	"#reg"					\n\t"	\
124 	".short	0					\n\t"	\
125 	".word	"#val"					\n\t"
126 
127 #define	TEST_ARG_PTR(reg, val)					\
128 	".byte	"__stringify(ARG_TYPE_PTR)"		\n\t"	\
129 	".byte	"#reg"					\n\t"	\
130 	".short	0					\n\t"	\
131 	".word	"#val"					\n\t"
132 
133 #define	TEST_ARG_MEM(index, val)				\
134 	".byte	"__stringify(ARG_TYPE_MEM)"		\n\t"	\
135 	".byte	"#index"				\n\t"	\
136 	".short	0					\n\t"	\
137 	".word	"#val"					\n\t"
138 
139 #define	TEST_ARG_REG_MASKED(reg, val)				\
140 	".byte	"__stringify(ARG_TYPE_REG_MASKED)"	\n\t"	\
141 	".byte	"#reg"					\n\t"	\
142 	".short	0					\n\t"	\
143 	".word	"#val"					\n\t"
144 
145 #define	TEST_ARG_END(flags)					\
146 	".byte	"__stringify(ARG_TYPE_END)"		\n\t"	\
147 	".byte	"TEST_ISA flags"			\n\t"	\
148 	".short	50f-0f					\n\t"	\
149 	".short	2f-0f					\n\t"	\
150 	".short	99f-0f					\n\t"	\
151 	".code "TEST_ISA"				\n\t"	\
152 	"0:						\n\t"
153 
154 #define TEST_INSTRUCTION(instruction)				\
155 	"50:	nop					\n\t"	\
156 	"1:	"instruction"				\n\t"	\
157 	"	nop					\n\t"
158 
159 #define TEST_BRANCH_F(instruction)				\
160 	TEST_INSTRUCTION(instruction)				\
161 	"	b	99f				\n\t"	\
162 	"2:	nop					\n\t"
163 
164 #define TEST_BRANCH_B(instruction)				\
165 	"	b	50f				\n\t"	\
166 	"	b	99f				\n\t"	\
167 	"2:	nop					\n\t"	\
168 	"	b	99f				\n\t"	\
169 	TEST_INSTRUCTION(instruction)
170 
171 #define TEST_BRANCH_FX(instruction, codex)			\
172 	TEST_INSTRUCTION(instruction)				\
173 	"	b	99f				\n\t"	\
174 	codex"						\n\t"	\
175 	"	b	99f				\n\t"	\
176 	"2:	nop					\n\t"
177 
178 #define TEST_BRANCH_BX(instruction, codex)			\
179 	"	b	50f				\n\t"	\
180 	"	b	99f				\n\t"	\
181 	"2:	nop					\n\t"	\
182 	"	b	99f				\n\t"	\
183 	codex"						\n\t"	\
184 	TEST_INSTRUCTION(instruction)
185 
186 #define TESTCASE_END						\
187 	"2:						\n\t"	\
188 	"99:						\n\t"	\
189 	"	bl __kprobes_test_case_end_"TEST_ISA"	\n\t"	\
190 	".code "NORMAL_ISA"				\n\t"	\
191 	: :							\
192 	: "r0", "r1", "r2", "r3", "ip", "lr", "memory", "cc"	\
193 	);
194 
195 
196 /*
197  * Macros to define test cases.
198  *
199  * Those of the form TEST_{R,P,M}* can be used to define test cases
200  * which take combinations of the three basic types of arguments. E.g.
201  *
202  *   TEST_R	One register argument
203  *   TEST_RR	Two register arguments
204  *   TEST_RPR	A register, a pointer, then a register argument
205  *
206  * For testing instructions which may branch, there are macros TEST_BF_*
207  * and TEST_BB_* for branching forwards and backwards.
208  *
209  * TEST_SUPPORTED and TEST_UNSUPPORTED don't cause the code to be executed,
210  * the just verify that a kprobe is or is not allowed on the given instruction.
211  */
212 
213 #define TEST(code)				\
214 	TESTCASE_START(code)			\
215 	TEST_ARG_END("")			\
216 	TEST_INSTRUCTION(code)			\
217 	TESTCASE_END
218 
219 #define TEST_UNSUPPORTED(code)					\
220 	TESTCASE_START(code)					\
221 	TEST_ARG_END("|"__stringify(ARG_FLAG_UNSUPPORTED))	\
222 	TEST_INSTRUCTION(code)					\
223 	TESTCASE_END
224 
225 #define TEST_SUPPORTED(code)					\
226 	TESTCASE_START(code)					\
227 	TEST_ARG_END("|"__stringify(ARG_FLAG_SUPPORTED))	\
228 	TEST_INSTRUCTION(code)					\
229 	TESTCASE_END
230 
231 #define TEST_R(code1, reg, val, code2)			\
232 	TESTCASE_START(code1 #reg code2)		\
233 	TEST_ARG_REG(reg, val)				\
234 	TEST_ARG_END("")				\
235 	TEST_INSTRUCTION(code1 #reg code2)		\
236 	TESTCASE_END
237 
238 #define TEST_RR(code1, reg1, val1, code2, reg2, val2, code3)	\
239 	TESTCASE_START(code1 #reg1 code2 #reg2 code3)		\
240 	TEST_ARG_REG(reg1, val1)				\
241 	TEST_ARG_REG(reg2, val2)				\
242 	TEST_ARG_END("")					\
243 	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3)		\
244 	TESTCASE_END
245 
246 #define TEST_RRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
247 	TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4)		\
248 	TEST_ARG_REG(reg1, val1)						\
249 	TEST_ARG_REG(reg2, val2)						\
250 	TEST_ARG_REG(reg3, val3)						\
251 	TEST_ARG_END("")							\
252 	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4)		\
253 	TESTCASE_END
254 
255 #define TEST_RRRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4, reg4, val4)	\
256 	TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4 #reg4)		\
257 	TEST_ARG_REG(reg1, val1)						\
258 	TEST_ARG_REG(reg2, val2)						\
259 	TEST_ARG_REG(reg3, val3)						\
260 	TEST_ARG_REG(reg4, val4)						\
261 	TEST_ARG_END("")							\
262 	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4 #reg4)	\
263 	TESTCASE_END
264 
265 #define TEST_P(code1, reg1, val1, code2)	\
266 	TESTCASE_START(code1 #reg1 code2)	\
267 	TEST_ARG_PTR(reg1, val1)		\
268 	TEST_ARG_END("")			\
269 	TEST_INSTRUCTION(code1 #reg1 code2)	\
270 	TESTCASE_END
271 
272 #define TEST_PR(code1, reg1, val1, code2, reg2, val2, code3)	\
273 	TESTCASE_START(code1 #reg1 code2 #reg2 code3)		\
274 	TEST_ARG_PTR(reg1, val1)				\
275 	TEST_ARG_REG(reg2, val2)				\
276 	TEST_ARG_END("")					\
277 	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3)		\
278 	TESTCASE_END
279 
280 #define TEST_RP(code1, reg1, val1, code2, reg2, val2, code3)	\
281 	TESTCASE_START(code1 #reg1 code2 #reg2 code3)		\
282 	TEST_ARG_REG(reg1, val1)				\
283 	TEST_ARG_PTR(reg2, val2)				\
284 	TEST_ARG_END("")					\
285 	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3)		\
286 	TESTCASE_END
287 
288 #define TEST_PRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
289 	TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4)		\
290 	TEST_ARG_PTR(reg1, val1)						\
291 	TEST_ARG_REG(reg2, val2)						\
292 	TEST_ARG_REG(reg3, val3)						\
293 	TEST_ARG_END("")							\
294 	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4)		\
295 	TESTCASE_END
296 
297 #define TEST_RPR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
298 	TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4)		\
299 	TEST_ARG_REG(reg1, val1)						\
300 	TEST_ARG_PTR(reg2, val2)						\
301 	TEST_ARG_REG(reg3, val3)						\
302 	TEST_ARG_END("")							\
303 	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4)		\
304 	TESTCASE_END
305 
306 #define TEST_RRP(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
307 	TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4)		\
308 	TEST_ARG_REG(reg1, val1)						\
309 	TEST_ARG_REG(reg2, val2)						\
310 	TEST_ARG_PTR(reg3, val3)						\
311 	TEST_ARG_END("")							\
312 	TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4)		\
313 	TESTCASE_END
314 
315 #define TEST_BF_P(code1, reg1, val1, code2)	\
316 	TESTCASE_START(code1 #reg1 code2)	\
317 	TEST_ARG_PTR(reg1, val1)		\
318 	TEST_ARG_END("")			\
319 	TEST_BRANCH_F(code1 #reg1 code2)	\
320 	TESTCASE_END
321 
322 #define TEST_BF(code)				\
323 	TESTCASE_START(code)			\
324 	TEST_ARG_END("")			\
325 	TEST_BRANCH_F(code)			\
326 	TESTCASE_END
327 
328 #define TEST_BB(code)				\
329 	TESTCASE_START(code)			\
330 	TEST_ARG_END("")			\
331 	TEST_BRANCH_B(code)			\
332 	TESTCASE_END
333 
334 #define TEST_BF_R(code1, reg, val, code2)	\
335 	TESTCASE_START(code1 #reg code2)	\
336 	TEST_ARG_REG(reg, val)			\
337 	TEST_ARG_END("")			\
338 	TEST_BRANCH_F(code1 #reg code2)		\
339 	TESTCASE_END
340 
341 #define TEST_BB_R(code1, reg, val, code2)	\
342 	TESTCASE_START(code1 #reg code2)	\
343 	TEST_ARG_REG(reg, val)			\
344 	TEST_ARG_END("")			\
345 	TEST_BRANCH_B(code1 #reg code2)		\
346 	TESTCASE_END
347 
348 #define TEST_BF_RR(code1, reg1, val1, code2, reg2, val2, code3)	\
349 	TESTCASE_START(code1 #reg1 code2 #reg2 code3)		\
350 	TEST_ARG_REG(reg1, val1)				\
351 	TEST_ARG_REG(reg2, val2)				\
352 	TEST_ARG_END("")					\
353 	TEST_BRANCH_F(code1 #reg1 code2 #reg2 code3)		\
354 	TESTCASE_END
355 
356 #define TEST_BF_X(code, codex)			\
357 	TESTCASE_START(code)			\
358 	TEST_ARG_END("")			\
359 	TEST_BRANCH_FX(code, codex)		\
360 	TESTCASE_END
361 
362 #define TEST_BB_X(code, codex)			\
363 	TESTCASE_START(code)			\
364 	TEST_ARG_END("")			\
365 	TEST_BRANCH_BX(code, codex)		\
366 	TESTCASE_END
367 
368 #define TEST_BF_RX(code1, reg, val, code2, codex)	\
369 	TESTCASE_START(code1 #reg code2)		\
370 	TEST_ARG_REG(reg, val)				\
371 	TEST_ARG_END("")				\
372 	TEST_BRANCH_FX(code1 #reg code2, codex)		\
373 	TESTCASE_END
374 
375 #define TEST_X(code, codex)			\
376 	TESTCASE_START(code)			\
377 	TEST_ARG_END("")			\
378 	TEST_INSTRUCTION(code)			\
379 	"	b	99f		\n\t"	\
380 	"	"codex"			\n\t"	\
381 	TESTCASE_END
382 
383 #define TEST_RX(code1, reg, val, code2, codex)		\
384 	TESTCASE_START(code1 #reg code2)		\
385 	TEST_ARG_REG(reg, val)				\
386 	TEST_ARG_END("")				\
387 	TEST_INSTRUCTION(code1 __stringify(reg) code2)	\
388 	"	b	99f		\n\t"		\
389 	"	"codex"			\n\t"		\
390 	TESTCASE_END
391 
392 #define TEST_RRX(code1, reg1, val1, code2, reg2, val2, code3, codex)		\
393 	TESTCASE_START(code1 #reg1 code2 #reg2 code3)				\
394 	TEST_ARG_REG(reg1, val1)						\
395 	TEST_ARG_REG(reg2, val2)						\
396 	TEST_ARG_END("")							\
397 	TEST_INSTRUCTION(code1 __stringify(reg1) code2 __stringify(reg2) code3)	\
398 	"	b	99f		\n\t"					\
399 	"	"codex"			\n\t"					\
400 	TESTCASE_END
401 
402 #define TEST_RMASKED(code1, reg, mask, code2)		\
403 	TESTCASE_START(code1 #reg code2)		\
404 	TEST_ARG_REG_MASKED(reg, mask)			\
405 	TEST_ARG_END("")				\
406 	TEST_INSTRUCTION(code1 #reg code2)		\
407 	TESTCASE_END
408 
409 /*
410  * We ignore the state of the imprecise abort disable flag (CPSR.A) because this
411  * can change randomly as the kernel doesn't take care to preserve or initialise
412  * this across context switches. Also, with Security Extensions, the flag may
413  * not be under control of the kernel; for this reason we ignore the state of
414  * the FIQ disable flag CPSR.F as well.
415  */
416 #define PSR_IGNORE_BITS (PSR_A_BIT | PSR_F_BIT)
417 
418 
419 /*
420  * Macros for defining space directives spread over multiple lines.
421  * These are required so the compiler guesses better the length of inline asm
422  * code and will spill the literal pool early enough to avoid generating PC
423  * relative loads with out of range offsets.
424  */
425 #define TWICE(x)	x x
426 #define SPACE_0x8	TWICE(".space 4\n\t")
427 #define SPACE_0x10	TWICE(SPACE_0x8)
428 #define SPACE_0x20	TWICE(SPACE_0x10)
429 #define SPACE_0x40	TWICE(SPACE_0x20)
430 #define SPACE_0x80	TWICE(SPACE_0x40)
431 #define SPACE_0x100	TWICE(SPACE_0x80)
432 #define SPACE_0x200	TWICE(SPACE_0x100)
433 #define SPACE_0x400	TWICE(SPACE_0x200)
434 #define SPACE_0x800	TWICE(SPACE_0x400)
435 #define SPACE_0x1000	TWICE(SPACE_0x800)
436 
437 
438 /* Various values used in test cases... */
439 #define N(val)	(val ^ 0xffffffff)
440 #define VAL1	0x12345678
441 #define VAL2	N(VAL1)
442 #define VAL3	0xa5f801
443 #define VAL4	N(VAL3)
444 #define VALM	0x456789ab
445 #define VALR	0xdeaddead
446 #define HH1	0x0123fecb
447 #define HH2	0xa9874567
448 
449 
450 #ifdef CONFIG_THUMB2_KERNEL
451 void kprobe_thumb16_test_cases(void);
452 void kprobe_thumb32_test_cases(void);
453 #else
454 void kprobe_arm_test_cases(void);
455 #endif
456