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

   1/* SPDX-License-Identifier: GPL-2.0-only */
   2/*
   3 * arch/arm/probes/kprobes/test-core.h
   4 *
   5 * Copyright (C) 2011 Jon Medhurst <tixy@yxit.co.uk>.
   6 */
   7
   8#define VERBOSE 0 /* Set to '1' for more logging of test cases */
   9
  10#ifdef CONFIG_THUMB2_KERNEL
  11#define NORMAL_ISA "16"
  12#else
  13#define NORMAL_ISA "32"
  14#endif
  15
  16
  17/* Flags used in kprobe_test_flags */
  18#define TEST_FLAG_NO_ITBLOCK    (1<<0)
  19#define TEST_FLAG_FULL_ITBLOCK  (1<<1)
  20#define TEST_FLAG_NARROW_INSTR  (1<<2)
  21
  22extern int kprobe_test_flags;
  23extern int kprobe_test_cc_position;
  24
  25
  26#define TEST_MEMORY_SIZE 256
  27
  28
  29/*
  30 * Test case structures.
  31 *
  32 * The arguments given to test cases can be one of three types.
  33 *
  34 *   ARG_TYPE_REG
  35 *      Load a register with the given value.
  36 *
  37 *   ARG_TYPE_PTR
  38 *      Load a register with a pointer into the stack buffer (SP + given value).
  39 *
  40 *   ARG_TYPE_MEM
  41 *      Store the given value into the stack buffer at [SP+index].
  42 *
  43 */
  44
  45#define ARG_TYPE_END            0
  46#define ARG_TYPE_REG            1
  47#define ARG_TYPE_PTR            2
  48#define ARG_TYPE_MEM            3
  49#define ARG_TYPE_REG_MASKED     4
  50
  51#define ARG_FLAG_UNSUPPORTED    0x01
  52#define ARG_FLAG_SUPPORTED      0x02
  53#define ARG_FLAG_THUMB          0x10    /* Must be 16 so TEST_ISA can be used */
  54#define ARG_FLAG_ARM            0x20    /* Must be 32 so TEST_ISA can be used */
  55
  56struct test_arg {
  57        u8      type;           /* ARG_TYPE_x */
  58        u8      _padding[7];
  59};
  60
  61struct test_arg_regptr {
  62        u8      type;           /* ARG_TYPE_REG or ARG_TYPE_PTR or ARG_TYPE_REG_MASKED */
  63        u8      reg;
  64        u8      _padding[2];
  65        u32     val;
  66};
  67
  68struct test_arg_mem {
  69        u8      type;           /* ARG_TYPE_MEM */
  70        u8      index;
  71        u8      _padding[2];
  72        u32     val;
  73};
  74
  75struct test_arg_end {
  76        u8      type;           /* ARG_TYPE_END */
  77        u8      flags;          /* ARG_FLAG_x */
  78        u16     code_offset;
  79        u16     branch_offset;
  80        u16     end_offset;
  81};
  82
  83
  84/*
  85 * Building blocks for test cases.
  86 *
  87 * Each test case is wrapped between TESTCASE_START and TESTCASE_END.
  88 *
  89 * To specify arguments for a test case the TEST_ARG_{REG,PTR,MEM} macros are
  90 * used followed by a terminating TEST_ARG_END.
  91 *
  92 * After this, the instruction to be tested is defined with TEST_INSTRUCTION.
  93 * Or for branches, TEST_BRANCH_B and TEST_BRANCH_F (branch forwards/backwards).
  94 *
  95 * Some specific test cases may make use of other custom constructs.
  96 */
  97
  98#if VERBOSE
  99#define verbose(fmt, ...) pr_info(fmt, ##__VA_ARGS__)
 100#else
 101#define verbose(fmt, ...)
 102#endif
 103
 104#define TEST_GROUP(title)                                       \
 105        verbose("\n");                                          \
 106        verbose(title"\n");                                     \
 107        verbose("---------------------------------------------------------\n");
 108
 109#define TESTCASE_START(title)                                   \
 110        __asm__ __volatile__ (                                  \
 111        "bl     __kprobes_test_case_start               \n\t"   \
 112        ".pushsection .rodata                           \n\t"   \
 113        "10:                                            \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        ".popsection                                    \n\t"   \
 119        ".word  10b                                     \n\t"
 120
 121#define TEST_ARG_REG(reg, val)                                  \
 122        ".byte  "__stringify(ARG_TYPE_REG)"             \n\t"   \
 123        ".byte  "#reg"                                  \n\t"   \
 124        ".short 0                                       \n\t"   \
 125        ".word  "#val"                                  \n\t"
 126
 127#define TEST_ARG_PTR(reg, val)                                  \
 128        ".byte  "__stringify(ARG_TYPE_PTR)"             \n\t"   \
 129        ".byte  "#reg"                                  \n\t"   \
 130        ".short 0                                       \n\t"   \
 131        ".word  "#val"                                  \n\t"
 132
 133#define TEST_ARG_MEM(index, val)                                \
 134        ".byte  "__stringify(ARG_TYPE_MEM)"             \n\t"   \
 135        ".byte  "#index"                                \n\t"   \
 136        ".short 0                                       \n\t"   \
 137        ".word  "#val"                                  \n\t"
 138
 139#define TEST_ARG_REG_MASKED(reg, val)                           \
 140        ".byte  "__stringify(ARG_TYPE_REG_MASKED)"      \n\t"   \
 141        ".byte  "#reg"                                  \n\t"   \
 142        ".short 0                                       \n\t"   \
 143        ".word  "#val"                                  \n\t"
 144
 145#define TEST_ARG_END(flags)                                     \
 146        ".byte  "__stringify(ARG_TYPE_END)"             \n\t"   \
 147        ".byte  "TEST_ISA flags"                        \n\t"   \
 148        ".short 50f-0f                                  \n\t"   \
 149        ".short 2f-0f                                   \n\t"   \
 150        ".short 99f-0f                                  \n\t"   \
 151        ".code "TEST_ISA"                               \n\t"   \
 152        "0:                                             \n\t"
 153
 154#define TEST_INSTRUCTION(instruction)                           \
 155        "50:    nop                                     \n\t"   \
 156        "1:     "instruction"                           \n\t"   \
 157        "       nop                                     \n\t"
 158
 159#define TEST_BRANCH_F(instruction)                              \
 160        TEST_INSTRUCTION(instruction)                           \
 161        "       b       99f                             \n\t"   \
 162        "2:     nop                                     \n\t"
 163
 164#define TEST_BRANCH_B(instruction)                              \
 165        "       b       50f                             \n\t"   \
 166        "       b       99f                             \n\t"   \
 167        "2:     nop                                     \n\t"   \
 168        "       b       99f                             \n\t"   \
 169        TEST_INSTRUCTION(instruction)
 170
 171#define TEST_BRANCH_FX(instruction, codex)                      \
 172        TEST_INSTRUCTION(instruction)                           \
 173        "       b       99f                             \n\t"   \
 174        codex"                                          \n\t"   \
 175        "       b       99f                             \n\t"   \
 176        "2:     nop                                     \n\t"
 177
 178#define TEST_BRANCH_BX(instruction, codex)                      \
 179        "       b       50f                             \n\t"   \
 180        "       b       99f                             \n\t"   \
 181        "2:     nop                                     \n\t"   \
 182        "       b       99f                             \n\t"   \
 183        codex"                                          \n\t"   \
 184        TEST_INSTRUCTION(instruction)
 185
 186#define TESTCASE_END                                            \
 187        "2:                                             \n\t"   \
 188        "99:                                            \n\t"   \
 189        "       bl __kprobes_test_case_end_"TEST_ISA"   \n\t"   \
 190        ".code "NORMAL_ISA"                             \n\t"   \
 191        : :                                                     \
 192        : "r0", "r1", "r2", "r3", "ip", "lr", "memory", "cc"    \
 193        );
 194
 195
 196/*
 197 * Macros to define test cases.
 198 *
 199 * Those of the form TEST_{R,P,M}* can be used to define test cases
 200 * which take combinations of the three basic types of arguments. E.g.
 201 *
 202 *   TEST_R     One register argument
 203 *   TEST_RR    Two register arguments
 204 *   TEST_RPR   A register, a pointer, then a register argument
 205 *
 206 * For testing instructions which may branch, there are macros TEST_BF_*
 207 * and TEST_BB_* for branching forwards and backwards.
 208 *
 209 * TEST_SUPPORTED and TEST_UNSUPPORTED don't cause the code to be executed,
 210 * the just verify that a kprobe is or is not allowed on the given instruction.
 211 */
 212
 213#define TEST(code)                              \
 214        TESTCASE_START(code)                    \
 215        TEST_ARG_END("")                        \
 216        TEST_INSTRUCTION(code)                  \
 217        TESTCASE_END
 218
 219#define TEST_UNSUPPORTED(code)                                  \
 220        TESTCASE_START(code)                                    \
 221        TEST_ARG_END("|"__stringify(ARG_FLAG_UNSUPPORTED))      \
 222        TEST_INSTRUCTION(code)                                  \
 223        TESTCASE_END
 224
 225#define TEST_SUPPORTED(code)                                    \
 226        TESTCASE_START(code)                                    \
 227        TEST_ARG_END("|"__stringify(ARG_FLAG_SUPPORTED))        \
 228        TEST_INSTRUCTION(code)                                  \
 229        TESTCASE_END
 230
 231#define TEST_R(code1, reg, val, code2)                  \
 232        TESTCASE_START(code1 #reg code2)                \
 233        TEST_ARG_REG(reg, val)                          \
 234        TEST_ARG_END("")                                \
 235        TEST_INSTRUCTION(code1 #reg code2)              \
 236        TESTCASE_END
 237
 238#define TEST_RR(code1, reg1, val1, code2, reg2, val2, code3)    \
 239        TESTCASE_START(code1 #reg1 code2 #reg2 code3)           \
 240        TEST_ARG_REG(reg1, val1)                                \
 241        TEST_ARG_REG(reg2, val2)                                \
 242        TEST_ARG_END("")                                        \
 243        TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3)         \
 244        TESTCASE_END
 245
 246#define TEST_RRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
 247        TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4)               \
 248        TEST_ARG_REG(reg1, val1)                                                \
 249        TEST_ARG_REG(reg2, val2)                                                \
 250        TEST_ARG_REG(reg3, val3)                                                \
 251        TEST_ARG_END("")                                                        \
 252        TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4)             \
 253        TESTCASE_END
 254
 255#define TEST_RRRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4, reg4, val4)   \
 256        TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4 #reg4)         \
 257        TEST_ARG_REG(reg1, val1)                                                \
 258        TEST_ARG_REG(reg2, val2)                                                \
 259        TEST_ARG_REG(reg3, val3)                                                \
 260        TEST_ARG_REG(reg4, val4)                                                \
 261        TEST_ARG_END("")                                                        \
 262        TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4 #reg4)       \
 263        TESTCASE_END
 264
 265#define TEST_P(code1, reg1, val1, code2)        \
 266        TESTCASE_START(code1 #reg1 code2)       \
 267        TEST_ARG_PTR(reg1, val1)                \
 268        TEST_ARG_END("")                        \
 269        TEST_INSTRUCTION(code1 #reg1 code2)     \
 270        TESTCASE_END
 271
 272#define TEST_PR(code1, reg1, val1, code2, reg2, val2, code3)    \
 273        TESTCASE_START(code1 #reg1 code2 #reg2 code3)           \
 274        TEST_ARG_PTR(reg1, val1)                                \
 275        TEST_ARG_REG(reg2, val2)                                \
 276        TEST_ARG_END("")                                        \
 277        TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3)         \
 278        TESTCASE_END
 279
 280#define TEST_RP(code1, reg1, val1, code2, reg2, val2, code3)    \
 281        TESTCASE_START(code1 #reg1 code2 #reg2 code3)           \
 282        TEST_ARG_REG(reg1, val1)                                \
 283        TEST_ARG_PTR(reg2, val2)                                \
 284        TEST_ARG_END("")                                        \
 285        TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3)         \
 286        TESTCASE_END
 287
 288#define TEST_PRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
 289        TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4)               \
 290        TEST_ARG_PTR(reg1, val1)                                                \
 291        TEST_ARG_REG(reg2, val2)                                                \
 292        TEST_ARG_REG(reg3, val3)                                                \
 293        TEST_ARG_END("")                                                        \
 294        TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4)             \
 295        TESTCASE_END
 296
 297#define TEST_RPR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
 298        TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4)               \
 299        TEST_ARG_REG(reg1, val1)                                                \
 300        TEST_ARG_PTR(reg2, val2)                                                \
 301        TEST_ARG_REG(reg3, val3)                                                \
 302        TEST_ARG_END("")                                                        \
 303        TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4)             \
 304        TESTCASE_END
 305
 306#define TEST_RRP(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\
 307        TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4)               \
 308        TEST_ARG_REG(reg1, val1)                                                \
 309        TEST_ARG_REG(reg2, val2)                                                \
 310        TEST_ARG_PTR(reg3, val3)                                                \
 311        TEST_ARG_END("")                                                        \
 312        TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4)             \
 313        TESTCASE_END
 314
 315#define TEST_BF_P(code1, reg1, val1, code2)     \
 316        TESTCASE_START(code1 #reg1 code2)       \
 317        TEST_ARG_PTR(reg1, val1)                \
 318        TEST_ARG_END("")                        \
 319        TEST_BRANCH_F(code1 #reg1 code2)        \
 320        TESTCASE_END
 321
 322#define TEST_BF(code)                           \
 323        TESTCASE_START(code)                    \
 324        TEST_ARG_END("")                        \
 325        TEST_BRANCH_F(code)                     \
 326        TESTCASE_END
 327
 328#define TEST_BB(code)                           \
 329        TESTCASE_START(code)                    \
 330        TEST_ARG_END("")                        \
 331        TEST_BRANCH_B(code)                     \
 332        TESTCASE_END
 333
 334#define TEST_BF_R(code1, reg, val, code2)       \
 335        TESTCASE_START(code1 #reg code2)        \
 336        TEST_ARG_REG(reg, val)                  \
 337        TEST_ARG_END("")                        \
 338        TEST_BRANCH_F(code1 #reg code2)         \
 339        TESTCASE_END
 340
 341#define TEST_BB_R(code1, reg, val, code2)       \
 342        TESTCASE_START(code1 #reg code2)        \
 343        TEST_ARG_REG(reg, val)                  \
 344        TEST_ARG_END("")                        \
 345        TEST_BRANCH_B(code1 #reg code2)         \
 346        TESTCASE_END
 347
 348#define TEST_BF_RR(code1, reg1, val1, code2, reg2, val2, code3) \
 349        TESTCASE_START(code1 #reg1 code2 #reg2 code3)           \
 350        TEST_ARG_REG(reg1, val1)                                \
 351        TEST_ARG_REG(reg2, val2)                                \
 352        TEST_ARG_END("")                                        \
 353        TEST_BRANCH_F(code1 #reg1 code2 #reg2 code3)            \
 354        TESTCASE_END
 355
 356#define TEST_BF_X(code, codex)                  \
 357        TESTCASE_START(code)                    \
 358        TEST_ARG_END("")                        \
 359        TEST_BRANCH_FX(code, codex)             \
 360        TESTCASE_END
 361
 362#define TEST_BB_X(code, codex)                  \
 363        TESTCASE_START(code)                    \
 364        TEST_ARG_END("")                        \
 365        TEST_BRANCH_BX(code, codex)             \
 366        TESTCASE_END
 367
 368#define TEST_BF_RX(code1, reg, val, code2, codex)       \
 369        TESTCASE_START(code1 #reg code2)                \
 370        TEST_ARG_REG(reg, val)                          \
 371        TEST_ARG_END("")                                \
 372        TEST_BRANCH_FX(code1 #reg code2, codex)         \
 373        TESTCASE_END
 374
 375#define TEST_X(code, codex)                     \
 376        TESTCASE_START(code)                    \
 377        TEST_ARG_END("")                        \
 378        TEST_INSTRUCTION(code)                  \
 379        "       b       99f             \n\t"   \
 380        "       "codex"                 \n\t"   \
 381        TESTCASE_END
 382
 383#define TEST_RX(code1, reg, val, code2, codex)          \
 384        TESTCASE_START(code1 #reg code2)                \
 385        TEST_ARG_REG(reg, val)                          \
 386        TEST_ARG_END("")                                \
 387        TEST_INSTRUCTION(code1 __stringify(reg) code2)  \
 388        "       b       99f             \n\t"           \
 389        "       "codex"                 \n\t"           \
 390        TESTCASE_END
 391
 392#define TEST_RRX(code1, reg1, val1, code2, reg2, val2, code3, codex)            \
 393        TESTCASE_START(code1 #reg1 code2 #reg2 code3)                           \
 394        TEST_ARG_REG(reg1, val1)                                                \
 395        TEST_ARG_REG(reg2, val2)                                                \
 396        TEST_ARG_END("")                                                        \
 397        TEST_INSTRUCTION(code1 __stringify(reg1) code2 __stringify(reg2) code3) \
 398        "       b       99f             \n\t"                                   \
 399        "       "codex"                 \n\t"                                   \
 400        TESTCASE_END
 401
 402#define TEST_RMASKED(code1, reg, mask, code2)           \
 403        TESTCASE_START(code1 #reg code2)                \
 404        TEST_ARG_REG_MASKED(reg, mask)                  \
 405        TEST_ARG_END("")                                \
 406        TEST_INSTRUCTION(code1 #reg code2)              \
 407        TESTCASE_END
 408
 409/*
 410 * We ignore the state of the imprecise abort disable flag (CPSR.A) because this
 411 * can change randomly as the kernel doesn't take care to preserve or initialise
 412 * this across context switches. Also, with Security Extensions, the flag may
 413 * not be under control of the kernel; for this reason we ignore the state of
 414 * the FIQ disable flag CPSR.F as well.
 415 */
 416#define PSR_IGNORE_BITS (PSR_A_BIT | PSR_F_BIT)
 417
 418
 419/*
 420 * Macros for defining space directives spread over multiple lines.
 421 * These are required so the compiler guesses better the length of inline asm
 422 * code and will spill the literal pool early enough to avoid generating PC
 423 * relative loads with out of range offsets.
 424 */
 425#define TWICE(x)        x x
 426#define SPACE_0x8       TWICE(".space 4\n\t")
 427#define SPACE_0x10      TWICE(SPACE_0x8)
 428#define SPACE_0x20      TWICE(SPACE_0x10)
 429#define SPACE_0x40      TWICE(SPACE_0x20)
 430#define SPACE_0x80      TWICE(SPACE_0x40)
 431#define SPACE_0x100     TWICE(SPACE_0x80)
 432#define SPACE_0x200     TWICE(SPACE_0x100)
 433#define SPACE_0x400     TWICE(SPACE_0x200)
 434#define SPACE_0x800     TWICE(SPACE_0x400)
 435#define SPACE_0x1000    TWICE(SPACE_0x800)
 436
 437
 438/* Various values used in test cases... */
 439#define N(val)  (val ^ 0xffffffff)
 440#define VAL1    0x12345678
 441#define VAL2    N(VAL1)
 442#define VAL3    0xa5f801
 443#define VAL4    N(VAL3)
 444#define VALM    0x456789ab
 445#define VALR    0xdeaddead
 446#define HH1     0x0123fecb
 447#define HH2     0xa9874567
 448
 449
 450#ifdef CONFIG_THUMB2_KERNEL
 451void kprobe_thumb16_test_cases(void);
 452void kprobe_thumb32_test_cases(void);
 453#else
 454void kprobe_arm_test_cases(void);
 455#endif
 456