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" \ | |
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 | ||
46589e29 | 152 | #define TEST_BRANCH_F(instruction) \ |
a43bc69b | 153 | TEST_INSTRUCTION(instruction) \ |
a43bc69b | 154 | " b 99f \n\t" \ |
46589e29 JM |
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" \ | |
a43bc69b JM |
168 | " b 99f \n\t" \ |
169 | "2: nop \n\t" | |
170 | ||
46589e29 | 171 | #define TEST_BRANCH_BX(instruction, codex) \ |
a43bc69b JM |
172 | " b 50f \n\t" \ |
173 | " b 99f \n\t" \ | |
174 | "2: nop \n\t" \ | |
175 | " b 99f \n\t" \ | |
46589e29 | 176 | codex" \n\t" \ |
a43bc69b JM |
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("") \ | |
46589e29 | 312 | TEST_BRANCH_F(code1 #reg1 code2) \ |
a43bc69b JM |
313 | TESTCASE_END |
314 | ||
46589e29 | 315 | #define TEST_BF(code) \ |
a43bc69b JM |
316 | TESTCASE_START(code) \ |
317 | TEST_ARG_END("") \ | |
46589e29 | 318 | TEST_BRANCH_F(code) \ |
a43bc69b JM |
319 | TESTCASE_END |
320 | ||
46589e29 | 321 | #define TEST_BB(code) \ |
a43bc69b JM |
322 | TESTCASE_START(code) \ |
323 | TEST_ARG_END("") \ | |
46589e29 | 324 | TEST_BRANCH_B(code) \ |
a43bc69b JM |
325 | TESTCASE_END |
326 | ||
46589e29 JM |
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) \ | |
a43bc69b JM |
332 | TESTCASE_END |
333 | ||
46589e29 JM |
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) \ | |
a43bc69b JM |
339 | TESTCASE_END |
340 | ||
a43bc69b JM |
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("") \ | |
46589e29 JM |
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) \ | |
a43bc69b JM |
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 | ||
46589e29 JM |
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 | ||
a43bc69b JM |
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 | |
c7054aad JM |
425 | |
426 | ||
427 | #ifdef CONFIG_THUMB2_KERNEL | |
428 | void kprobe_thumb16_test_cases(void); | |
429 | void kprobe_thumb32_test_cases(void); | |
c0cc6df1 JM |
430 | #else |
431 | void kprobe_arm_test_cases(void); | |
c7054aad | 432 | #endif |