?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'locks-v3.16-2' of git://git.samba.org/jlayton/linux
[linux/fpc-iii.git] / arch / arm / kernel / kprobes-test.h
blobeecc90a0fd912e7a0de0a50c7a707df8864d59a3
1 /*
2 * arch/arm/kernel/kprobes-test.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
53 #define ARG_FLAG_UNSUPPORTED 0x01
54 #define ARG_FLAG_SUPPORTED 0x02
55 #define ARG_FLAG_THUMB 0x10 /* Must be 16 so TEST_ISA can be used */
56 #define ARG_FLAG_ARM 0x20 /* Must be 32 so TEST_ISA can be used */
57
58 struct test_arg {
59 u8 type; /* ARG_TYPE_x */
60 u8 _padding[7];
61 };
62
63 struct test_arg_regptr {
64 u8 type; /* ARG_TYPE_REG or ARG_TYPE_PTR */
65 u8 reg;
66 u8 _padding[2];
67 u32 val;
68 };
69
70 struct test_arg_mem {
71 u8 type; /* ARG_TYPE_MEM */
72 u8 index;
73 u8 _padding[2];
74 u32 val;
75 };
76
77 struct test_arg_end {
78 u8 type; /* ARG_TYPE_END */
79 u8 flags; /* ARG_FLAG_x */
80 u16 code_offset;
81 u16 branch_offset;
82 u16 end_offset;
83 };
84
85
86 /*
87 * Building blocks for test cases.
88 *
89 * Each test case is wrapped between TESTCASE_START and TESTCASE_END.
90 *
91 * To specify arguments for a test case the TEST_ARG_{REG,PTR,MEM} macros are
92 * used followed by a terminating TEST_ARG_END.
93 *
94 * After this, the instruction to be tested is defined with TEST_INSTRUCTION.
95 * Or for branches, TEST_BRANCH_B and TEST_BRANCH_F (branch forwards/backwards).
96 *
97 * Some specific test cases may make use of other custom constructs.
98 */
99
100 #if VERBOSE
101 #define verbose(fmt, ...) pr_info(fmt, ##__VA_ARGS__)
102 #else
103 #define verbose(fmt, ...)
104 #endif
105
106 #define TEST_GROUP(title) \
107 verbose("\n"); \
108 verbose(title"\n"); \
109 verbose("---------------------------------------------------------\n");
110
111 #define TESTCASE_START(title) \
112 __asm__ __volatile__ ( \
113 "bl __kprobes_test_case_start \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 ".align 2, 0 \n\t"
119
120 #define TEST_ARG_REG(reg, val) \
121 ".byte "__stringify(ARG_TYPE_REG)" \n\t" \
122 ".byte "#reg" \n\t" \
123 ".short 0 \n\t" \
124 ".word "#val" \n\t"
125
126 #define TEST_ARG_PTR(reg, val) \
127 ".byte "__stringify(ARG_TYPE_PTR)" \n\t" \
128 ".byte "#reg" \n\t" \
129 ".short 0 \n\t" \
130 ".word "#val" \n\t"
131
132 #define TEST_ARG_MEM(index, val) \
133 ".byte "__stringify(ARG_TYPE_MEM)" \n\t" \
134 ".byte "#index" \n\t" \
135 ".short 0 \n\t" \
136 ".word "#val" \n\t"
137
138 #define TEST_ARG_END(flags) \
139 ".byte "__stringify(ARG_TYPE_END)" \n\t" \
140 ".byte "TEST_ISA flags" \n\t" \
141 ".short 50f-0f \n\t" \
142 ".short 2f-0f \n\t" \
143 ".short 99f-0f \n\t" \
144 ".code "TEST_ISA" \n\t" \
145 "0: \n\t"
146
147 #define TEST_INSTRUCTION(instruction) \
148 "50: nop \n\t" \
149 "1: "instruction" \n\t" \
150 " nop \n\t"
151
152 #define TEST_BRANCH_F(instruction) \
153 TEST_INSTRUCTION(instruction) \
154 " b 99f \n\t" \
155 "2: nop \n\t"
156
157 #define TEST_BRANCH_B(instruction) \
158 " b 50f \n\t" \
159 " b 99f \n\t" \
160 "2: nop \n\t" \
161 " b 99f \n\t" \
162 TEST_INSTRUCTION(instruction)
163
164 #define TEST_BRANCH_FX(instruction, codex) \
165 TEST_INSTRUCTION(instruction) \
166 " b 99f \n\t" \
167 codex" \n\t" \
168 " b 99f \n\t" \
169 "2: nop \n\t"
170
171 #define TEST_BRANCH_BX(instruction, codex) \
172 " b 50f \n\t" \
173 " b 99f \n\t" \
174 "2: nop \n\t" \
175 " b 99f \n\t" \
176 codex" \n\t" \
177 TEST_INSTRUCTION(instruction)
178
179 #define TESTCASE_END \
180 "2: \n\t" \
181 "99: \n\t" \
182 " bl __kprobes_test_case_end_"TEST_ISA" \n\t" \
183 ".code "NORMAL_ISA" \n\t" \
184 : : \
185 : "r0", "r1", "r2", "r3", "ip", "lr", "memory", "cc" \
186 );
187
188
189 /*
190 * Macros to define test cases.
191 *
192 * Those of the form TEST_{R,P,M}* can be used to define test cases
193 * which take combinations of the three basic types of arguments. E.g.
194 *
195 * TEST_R One register argument
196 * TEST_RR Two register arguments
197 * TEST_RPR A register, a pointer, then a register argument
198 *
199 * For testing instructions which may branch, there are macros TEST_BF_*
200 * and TEST_BB_* for branching forwards and backwards.
201 *
202 * TEST_SUPPORTED and TEST_UNSUPPORTED don't cause the code to be executed,
203 * the just verify that a kprobe is or is not allowed on the given instruction.
204 */
205
206 #define TEST(code) \
207 TESTCASE_START(code) \
208 TEST_ARG_END("") \
209 TEST_INSTRUCTION(code) \
210 TESTCASE_END
211
212 #define TEST_UNSUPPORTED(code) \
213 TESTCASE_START(code) \
214 TEST_ARG_END("|"__stringify(ARG_FLAG_UNSUPPORTED)) \
215 TEST_INSTRUCTION(code) \
216 TESTCASE_END
217
218 #define TEST_SUPPORTED(code) \
219 TESTCASE_START(code) \
220 TEST_ARG_END("|"__stringify(ARG_FLAG_SUPPORTED)) \
221 TEST_INSTRUCTION(code) \
222 TESTCASE_END
223
224 #define TEST_R(code1, reg, val, code2) \
225 TESTCASE_START(code1 #reg code2) \
226 TEST_ARG_REG(reg, val) \
227 TEST_ARG_END("") \
228 TEST_INSTRUCTION(code1 #reg code2) \
229 TESTCASE_END
230
231 #define TEST_RR(code1, reg1, val1, code2, reg2, val2, code3) \
232 TESTCASE_START(code1 #reg1 code2 #reg2 code3) \
233 TEST_ARG_REG(reg1, val1) \
234 TEST_ARG_REG(reg2, val2) \
235 TEST_ARG_END("") \
236 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3) \
237 TESTCASE_END
238
239 #define TEST_RRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
240 TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
241 TEST_ARG_REG(reg1, val1) \
242 TEST_ARG_REG(reg2, val2) \
243 TEST_ARG_REG(reg3, val3) \
244 TEST_ARG_END("") \
245 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
246 TESTCASE_END
247
248 #define TEST_RRRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4, reg4, val4) \
249 TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4 #reg4) \
250 TEST_ARG_REG(reg1, val1) \
251 TEST_ARG_REG(reg2, val2) \
252 TEST_ARG_REG(reg3, val3) \
253 TEST_ARG_REG(reg4, val4) \
254 TEST_ARG_END("") \
255 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4 #reg4) \
256 TESTCASE_END
257
258 #define TEST_P(code1, reg1, val1, code2) \
259 TESTCASE_START(code1 #reg1 code2) \
260 TEST_ARG_PTR(reg1, val1) \
261 TEST_ARG_END("") \
262 TEST_INSTRUCTION(code1 #reg1 code2) \
263 TESTCASE_END
264
265 #define TEST_PR(code1, reg1, val1, code2, reg2, val2, code3) \
266 TESTCASE_START(code1 #reg1 code2 #reg2 code3) \
267 TEST_ARG_PTR(reg1, val1) \
268 TEST_ARG_REG(reg2, val2) \
269 TEST_ARG_END("") \
270 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3) \
271 TESTCASE_END
272
273 #define TEST_RP(code1, reg1, val1, code2, reg2, val2, code3) \
274 TESTCASE_START(code1 #reg1 code2 #reg2 code3) \
275 TEST_ARG_REG(reg1, val1) \
276 TEST_ARG_PTR(reg2, val2) \
277 TEST_ARG_END("") \
278 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3) \
279 TESTCASE_END
280
281 #define TEST_PRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
282 TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
283 TEST_ARG_PTR(reg1, val1) \
284 TEST_ARG_REG(reg2, val2) \
285 TEST_ARG_REG(reg3, val3) \
286 TEST_ARG_END("") \
287 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
288 TESTCASE_END
289
290 #define TEST_RPR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
291 TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
292 TEST_ARG_REG(reg1, val1) \
293 TEST_ARG_PTR(reg2, val2) \
294 TEST_ARG_REG(reg3, val3) \
295 TEST_ARG_END("") \
296 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
297 TESTCASE_END
298
299 #define TEST_RRP(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
300 TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
301 TEST_ARG_REG(reg1, val1) \
302 TEST_ARG_REG(reg2, val2) \
303 TEST_ARG_PTR(reg3, val3) \
304 TEST_ARG_END("") \
305 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4) \
306 TESTCASE_END
307
308 #define TEST_BF_P(code1, reg1, val1, code2) \
309 TESTCASE_START(code1 #reg1 code2) \
310 TEST_ARG_PTR(reg1, val1) \
311 TEST_ARG_END("") \
312 TEST_BRANCH_F(code1 #reg1 code2) \
313 TESTCASE_END
314
315 #define TEST_BF(code) \
316 TESTCASE_START(code) \
317 TEST_ARG_END("") \
318 TEST_BRANCH_F(code) \
319 TESTCASE_END
320
321 #define TEST_BB(code) \
322 TESTCASE_START(code) \
323 TEST_ARG_END("") \
324 TEST_BRANCH_B(code) \
325 TESTCASE_END
326
327 #define TEST_BF_R(code1, reg, val, code2) \
328 TESTCASE_START(code1 #reg code2) \
329 TEST_ARG_REG(reg, val) \
330 TEST_ARG_END("") \
331 TEST_BRANCH_F(code1 #reg code2) \
332 TESTCASE_END
333
334 #define TEST_BB_R(code1, reg, val, code2) \
335 TESTCASE_START(code1 #reg code2) \
336 TEST_ARG_REG(reg, val) \
337 TEST_ARG_END("") \
338 TEST_BRANCH_B(code1 #reg code2) \
339 TESTCASE_END
340
341 #define TEST_BF_RR(code1, reg1, val1, code2, reg2, val2, code3) \
342 TESTCASE_START(code1 #reg1 code2 #reg2 code3) \
343 TEST_ARG_REG(reg1, val1) \
344 TEST_ARG_REG(reg2, val2) \
345 TEST_ARG_END("") \
346 TEST_BRANCH_F(code1 #reg1 code2 #reg2 code3) \
347 TESTCASE_END
348
349 #define TEST_BF_X(code, codex) \
350 TESTCASE_START(code) \
351 TEST_ARG_END("") \
352 TEST_BRANCH_FX(code, codex) \
353 TESTCASE_END
354
355 #define TEST_BB_X(code, codex) \
356 TESTCASE_START(code) \
357 TEST_ARG_END("") \
358 TEST_BRANCH_BX(code, codex) \
359 TESTCASE_END
360
361 #define TEST_BF_RX(code1, reg, val, code2, codex) \
362 TESTCASE_START(code1 #reg code2) \
363 TEST_ARG_REG(reg, val) \
364 TEST_ARG_END("") \
365 TEST_BRANCH_FX(code1 #reg code2, codex) \
366 TESTCASE_END
367
368 #define TEST_X(code, codex) \
369 TESTCASE_START(code) \
370 TEST_ARG_END("") \
371 TEST_INSTRUCTION(code) \
372 " b 99f \n\t" \
373 " "codex" \n\t" \
374 TESTCASE_END
375
376 #define TEST_RX(code1, reg, val, code2, codex) \
377 TESTCASE_START(code1 #reg code2) \
378 TEST_ARG_REG(reg, val) \
379 TEST_ARG_END("") \
380 TEST_INSTRUCTION(code1 __stringify(reg) code2) \
381 " b 99f \n\t" \
382 " "codex" \n\t" \
383 TESTCASE_END
384
385 #define TEST_RRX(code1, reg1, val1, code2, reg2, val2, code3, codex) \
386 TESTCASE_START(code1 #reg1 code2 #reg2 code3) \
387 TEST_ARG_REG(reg1, val1) \
388 TEST_ARG_REG(reg2, val2) \
389 TEST_ARG_END("") \
390 TEST_INSTRUCTION(code1 __stringify(reg1) code2 __stringify(reg2) code3) \
391 " b 99f \n\t" \
392 " "codex" \n\t" \
393 TESTCASE_END
394
395
396 /*
397 * Macros for defining space directives spread over multiple lines.
398 * These are required so the compiler guesses better the length of inline asm
399 * code and will spill the literal pool early enough to avoid generating PC
400 * relative loads with out of range offsets.
401 */
402 #define TWICE(x) x x
403 #define SPACE_0x8 TWICE(".space 4\n\t")
404 #define SPACE_0x10 TWICE(SPACE_0x8)
405 #define SPACE_0x20 TWICE(SPACE_0x10)
406 #define SPACE_0x40 TWICE(SPACE_0x20)
407 #define SPACE_0x80 TWICE(SPACE_0x40)
408 #define SPACE_0x100 TWICE(SPACE_0x80)
409 #define SPACE_0x200 TWICE(SPACE_0x100)
410 #define SPACE_0x400 TWICE(SPACE_0x200)
411 #define SPACE_0x800 TWICE(SPACE_0x400)
412 #define SPACE_0x1000 TWICE(SPACE_0x800)
413
414
415 /* Various values used in test cases... */
416 #define N(val) (val ^ 0xffffffff)
417 #define VAL1 0x12345678
418 #define VAL2 N(VAL1)
419 #define VAL3 0xa5f801
420 #define VAL4 N(VAL3)
421 #define VALM 0x456789ab
422 #define VALR 0xdeaddead
423 #define HH1 0x0123fecb
424 #define HH2 0xa9874567
425
426
427 #ifdef CONFIG_THUMB2_KERNEL
428 void kprobe_thumb16_test_cases(void);
429 void kprobe_thumb32_test_cases(void);
430 #else
431 void kprobe_arm_test_cases(void);
432 #endif
Linux with added FPC-III support