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