LXR linux/arch/arm/probes/kprobes/test-core.h

   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
  25extern int kprobe_test_flags;
  26extern 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
  59struct test_arg {
  60        u8      type;           /* ARG_TYPE_x */
  61        u8      _padding[7];
  62};
  63
  64struct 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
  71struct test_arg_mem {
  72        u8      type;           /* ARG_TYPE_MEM */
  73        u8      index;
  74        u8      _padding[2];
  75        u32     val;
  76};
  77
  78struct 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
 454void kprobe_thumb16_test_cases(void);
 455void kprobe_thumb32_test_cases(void);
 456#else
 457void kprobe_arm_test_cases(void);
 458#endif
 459