Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
kprobes-test.h
Go to the documentation of this file.
1 /*
2  * arch/arm/kernel/kprobes-test.h
3  *
4  * Copyright (C) 2011 Jon Medhurst <[email protected]>.
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 \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
Generated on Thu Jan 10 2013 12:56:14 for Linux Kernel by   doxygen 1.8.2