~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/arm/probes/kprobes/test-core.h

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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
459 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp