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