arch/arm/kernel/kprobes-test.h

   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
 152 #define TEST_BRANCH_F(instruction, xtra_dist)                   \
 153         TEST_INSTRUCTION(instruction)                           \
 154         ".if "#xtra_dist"                               \n\t"   \
 155         "       b       99f                             \n\t"   \
 156         ".space "#xtra_dist"                            \n\t"   \
 157         ".endif                                         \n\t"   \
 158         "       b       99f                             \n\t"   \
 159         "2:     nop                                     \n\t"
 160
 161 #define TEST_BRANCH_B(instruction, xtra_dist)                   \
 162         "       b       50f                             \n\t"   \
 163         "       b       99f                             \n\t"   \
 164         "2:     nop                                     \n\t"   \
 165         "       b       99f                             \n\t"   \
 166         ".if "#xtra_dist"                               \n\t"   \
 167         ".space "#xtra_dist"                            \n\t"   \
 168         ".endif                                         \n\t"   \
 169         TEST_INSTRUCTION(instruction)
 170
 171 #define TESTCASE_END                                            \
 172         "2:                                             \n\t"   \
 173         "99:                                            \n\t"   \
 174         "       bl __kprobes_test_case_end_"TEST_ISA"   \n\t"   \
 175         ".code "NORMAL_ISA"                             \n\t"   \
 176         : :                                                     \
 177         : "r0", "r1", "r2", "r3", "ip", "lr", "memory", "cc"    \
 178         );
 179
 180
 181 /*
 182  * Macros to define test cases.
 183  *
 184  * Those of the form TEST_{R,P,M}* can be used to define test cases
 185  * which take combinations of the three basic types of arguments. E.g.
 186  *
 187  *   TEST_R     One register argument
 188  *   TEST_RR    Two register arguments
 189  *   TEST_RPR   A register, a pointer, then a register argument
 190  *
 191  * For testing instructions which may branch, there are macros TEST_BF_*
 192  * and TEST_BB_* for branching forwards and backwards.
 193  *
 194  * TEST_SUPPORTED and TEST_UNSUPPORTED don't cause the code to be executed,
 195  * the just verify that a kprobe is or is not allowed on the given instruction.
 196  */
 197
 198 #define TEST(code)                              \
 199         TESTCASE_START(code)                    \
 200         TEST_ARG_END("")                        \
 201         TEST_INSTRUCTION(code)                  \
 202         TESTCASE_END
 203
 204 #define TEST_UNSUPPORTED(code)                                  \
 205         TESTCASE_START(code)                                    \
 206         TEST_ARG_END("|"__stringify(ARG_FLAG_UNSUPPORTED))      \
 207         TEST_INSTRUCTION(code)                                  \
 208         TESTCASE_END
 209
 210 #define TEST_SUPPORTED(code)                                    \
 211         TESTCASE_START(code)                                    \
 212         TEST_ARG_END("|"__stringify(ARG_FLAG_SUPPORTED))        \
 213         TEST_INSTRUCTION(code)                                  \
 214         TESTCASE_END
 215
 216 #define TEST_R(code1, reg, val, code2)                  \
 217         TESTCASE_START(code1 #reg code2)                \
 218         TEST_ARG_REG(reg, val)                          \
 219         TEST_ARG_END("")                                \
 220         TEST_INSTRUCTION(code1 #reg code2)              \
 221         TESTCASE_END
 222
 223 #define TEST_RR(code1, reg1, val1, code2, reg2, val2, code3)    \
 224         TESTCASE_START(code1 #reg1 code2 #reg2 code3)           \
 225         TEST_ARG_REG(reg1, val1)                                \
 226         TEST_ARG_REG(reg2, val2)                                \
 227         TEST_ARG_END("")                                        \
 228         TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3)         \
 229         TESTCASE_END
 230
 231 #define TEST_RRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
 232         TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4)               \
 233         TEST_ARG_REG(reg1, val1)                                                \
 234         TEST_ARG_REG(reg2, val2)                                                \
 235         TEST_ARG_REG(reg3, val3)                                                \
 236         TEST_ARG_END("")                                                        \
 237         TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4)             \
 238         TESTCASE_END
 239
 240 #define TEST_RRRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4, reg4, val4)   \
 241         TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4 #reg4)         \
 242         TEST_ARG_REG(reg1, val1)                                                \
 243         TEST_ARG_REG(reg2, val2)                                                \
 244         TEST_ARG_REG(reg3, val3)                                                \
 245         TEST_ARG_REG(reg4, val4)                                                \
 246         TEST_ARG_END("")                                                        \
 247         TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4 #reg4)       \
 248         TESTCASE_END
 249
 250 #define TEST_P(code1, reg1, val1, code2)        \
 251         TESTCASE_START(code1 #reg1 code2)       \
 252         TEST_ARG_PTR(reg1, val1)                \
 253         TEST_ARG_END("")                        \
 254         TEST_INSTRUCTION(code1 #reg1 code2)     \
 255         TESTCASE_END
 256
 257 #define TEST_PR(code1, reg1, val1, code2, reg2, val2, code3)    \
 258         TESTCASE_START(code1 #reg1 code2 #reg2 code3)           \
 259         TEST_ARG_PTR(reg1, val1)                                \
 260         TEST_ARG_REG(reg2, val2)                                \
 261         TEST_ARG_END("")                                        \
 262         TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3)         \
 263         TESTCASE_END
 264
 265 #define TEST_RP(code1, reg1, val1, code2, reg2, val2, code3)    \
 266         TESTCASE_START(code1 #reg1 code2 #reg2 code3)           \
 267         TEST_ARG_REG(reg1, val1)                                \
 268         TEST_ARG_PTR(reg2, val2)                                \
 269         TEST_ARG_END("")                                        \
 270         TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3)         \
 271         TESTCASE_END
 272
 273 #define TEST_PRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
 274         TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4)               \
 275         TEST_ARG_PTR(reg1, val1)                                                \
 276         TEST_ARG_REG(reg2, val2)                                                \
 277         TEST_ARG_REG(reg3, val3)                                                \
 278         TEST_ARG_END("")                                                        \
 279         TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4)             \
 280         TESTCASE_END
 281
 282 #define TEST_RPR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
 283         TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4)               \
 284         TEST_ARG_REG(reg1, val1)                                                \
 285         TEST_ARG_PTR(reg2, val2)                                                \
 286         TEST_ARG_REG(reg3, val3)                                                \
 287         TEST_ARG_END("")                                                        \
 288         TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4)             \
 289         TESTCASE_END
 290
 291 #define TEST_RRP(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
 292         TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4)               \
 293         TEST_ARG_REG(reg1, val1)                                                \
 294         TEST_ARG_REG(reg2, val2)                                                \
 295         TEST_ARG_PTR(reg3, val3)                                                \
 296         TEST_ARG_END("")                                                        \
 297         TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4)             \
 298         TESTCASE_END
 299
 300 #define TEST_BF_P(code1, reg1, val1, code2)     \
 301         TESTCASE_START(code1 #reg1 code2)       \
 302         TEST_ARG_PTR(reg1, val1)                \
 303         TEST_ARG_END("")                        \
 304         TEST_BRANCH_F(code1 #reg1 code2, 0)     \
 305         TESTCASE_END
 306
 307 #define TEST_BF_X(code, xtra_dist)              \
 308         TESTCASE_START(code)                    \
 309         TEST_ARG_END("")                        \
 310         TEST_BRANCH_F(code, xtra_dist)          \
 311         TESTCASE_END
 312
 313 #define TEST_BB_X(code, xtra_dist)              \
 314         TESTCASE_START(code)                    \
 315         TEST_ARG_END("")                        \
 316         TEST_BRANCH_B(code, xtra_dist)          \
 317         TESTCASE_END
 318
 319 #define TEST_BF_RX(code1, reg, val, code2, xtra_dist)   \
 320         TESTCASE_START(code1 #reg code2)                \
 321         TEST_ARG_REG(reg, val)                          \
 322         TEST_ARG_END("")                                \
 323         TEST_BRANCH_F(code1 #reg code2, xtra_dist)      \
 324         TESTCASE_END
 325
 326 #define TEST_BB_RX(code1, reg, val, code2, xtra_dist)   \
 327         TESTCASE_START(code1 #reg code2)                \
 328         TEST_ARG_REG(reg, val)                          \
 329         TEST_ARG_END("")                                \
 330         TEST_BRANCH_B(code1 #reg code2, xtra_dist)      \
 331         TESTCASE_END
 332
 333 #define TEST_BF(code)   TEST_BF_X(code, 0)
 334 #define TEST_BB(code)   TEST_BB_X(code, 0)
 335
 336 #define TEST_BF_R(code1, reg, val, code2) TEST_BF_RX(code1, reg, val, code2, 0)
 337 #define TEST_BB_R(code1, reg, val, code2) TEST_BB_RX(code1, reg, val, code2, 0)
 338
 339 #define TEST_BF_RR(code1, reg1, val1, code2, reg2, val2, code3) \
 340         TESTCASE_START(code1 #reg1 code2 #reg2 code3)           \
 341         TEST_ARG_REG(reg1, val1)                                \
 342         TEST_ARG_REG(reg2, val2)                                \
 343         TEST_ARG_END("")                                        \
 344         TEST_BRANCH_F(code1 #reg1 code2 #reg2 code3, 0)         \
 345         TESTCASE_END
 346
 347 #define TEST_X(code, codex)                     \
 348         TESTCASE_START(code)                    \
 349         TEST_ARG_END("")                        \
 350         TEST_INSTRUCTION(code)                  \
 351         "       b       99f             \n\t"   \
 352         "       "codex"                 \n\t"   \
 353         TESTCASE_END
 354
 355 #define TEST_RX(code1, reg, val, code2, codex)          \
 356         TESTCASE_START(code1 #reg code2)                \
 357         TEST_ARG_REG(reg, val)                          \
 358         TEST_ARG_END("")                                \
 359         TEST_INSTRUCTION(code1 __stringify(reg) code2)  \
 360         "       b       99f             \n\t"           \
 361         "       "codex"                 \n\t"           \
 362         TESTCASE_END
 363
 364 #define TEST_RRX(code1, reg1, val1, code2, reg2, val2, code3, codex)            \
 365         TESTCASE_START(code1 #reg1 code2 #reg2 code3)                           \
 366         TEST_ARG_REG(reg1, val1)                                                \
 367         TEST_ARG_REG(reg2, val2)                                                \
 368         TEST_ARG_END("")                                                        \
 369         TEST_INSTRUCTION(code1 __stringify(reg1) code2 __stringify(reg2) code3) \
 370         "       b       99f             \n\t"                                   \
 371         "       "codex"                 \n\t"                                   \
 372         TESTCASE_END
 373
 374
 375 /* Various values used in test cases... */
 376 #define N(val)  (val ^ 0xffffffff)
 377 #define VAL1    0x12345678
 378 #define VAL2    N(VAL1)
 379 #define VAL3    0xa5f801
 380 #define VAL4    N(VAL3)
 381 #define VALM    0x456789ab
 382 #define VALR    0xdeaddead
 383 #define HH1     0x0123fecb
 384 #define HH2     0xa9874567
 385
 386
 387 #ifdef CONFIG_THUMB2_KERNEL
 388 void kprobe_thumb16_test_cases(void);
 389 void kprobe_thumb32_test_cases(void);
 390 #else
 391 void kprobe_arm_test_cases(void);
 392 #endif