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