test-core.h (12645B)
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, ...) no_printk(fmt, ##__VA_ARGS__) 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 ".syntax unified \n\t" \ 112 "bl __kprobes_test_case_start \n\t" \ 113 ".pushsection .rodata \n\t" \ 114 "10: \n\t" \ 115 /* don't use .asciz here as 'title' may be */ \ 116 /* multiple strings to be concatenated. */ \ 117 ".ascii "#title" \n\t" \ 118 ".byte 0 \n\t" \ 119 ".popsection \n\t" \ 120 ".word 10b \n\t" 121 122#define TEST_ARG_REG(reg, val) \ 123 ".byte "__stringify(ARG_TYPE_REG)" \n\t" \ 124 ".byte "#reg" \n\t" \ 125 ".short 0 \n\t" \ 126 ".word "#val" \n\t" 127 128#define TEST_ARG_PTR(reg, val) \ 129 ".byte "__stringify(ARG_TYPE_PTR)" \n\t" \ 130 ".byte "#reg" \n\t" \ 131 ".short 0 \n\t" \ 132 ".word "#val" \n\t" 133 134#define TEST_ARG_MEM(index, val) \ 135 ".byte "__stringify(ARG_TYPE_MEM)" \n\t" \ 136 ".byte "#index" \n\t" \ 137 ".short 0 \n\t" \ 138 ".word "#val" \n\t" 139 140#define TEST_ARG_REG_MASKED(reg, val) \ 141 ".byte "__stringify(ARG_TYPE_REG_MASKED)" \n\t" \ 142 ".byte "#reg" \n\t" \ 143 ".short 0 \n\t" \ 144 ".word "#val" \n\t" 145 146#define TEST_ARG_END(flags) \ 147 ".byte "__stringify(ARG_TYPE_END)" \n\t" \ 148 ".byte "TEST_ISA flags" \n\t" \ 149 ".short 50f-0f \n\t" \ 150 ".short 2f-0f \n\t" \ 151 ".short 99f-0f \n\t" \ 152 ".code "TEST_ISA" \n\t" \ 153 "0: \n\t" 154 155#define TEST_INSTRUCTION(instruction) \ 156 "50: nop \n\t" \ 157 "1: "instruction" \n\t" \ 158 " nop \n\t" 159 160#define TEST_BRANCH_F(instruction) \ 161 TEST_INSTRUCTION(instruction) \ 162 " b 99f \n\t" \ 163 "2: nop \n\t" 164 165#define TEST_BRANCH_B(instruction) \ 166 " b 50f \n\t" \ 167 " b 99f \n\t" \ 168 "2: nop \n\t" \ 169 " b 99f \n\t" \ 170 TEST_INSTRUCTION(instruction) 171 172#define TEST_BRANCH_FX(instruction, codex) \ 173 TEST_INSTRUCTION(instruction) \ 174 " b 99f \n\t" \ 175 codex" \n\t" \ 176 " b 99f \n\t" \ 177 "2: nop \n\t" 178 179#define TEST_BRANCH_BX(instruction, codex) \ 180 " b 50f \n\t" \ 181 " b 99f \n\t" \ 182 "2: nop \n\t" \ 183 " b 99f \n\t" \ 184 codex" \n\t" \ 185 TEST_INSTRUCTION(instruction) 186 187#define TESTCASE_END \ 188 "2: \n\t" \ 189 "99: \n\t" \ 190 " bl __kprobes_test_case_end_"TEST_ISA" \n\t" \ 191 ".code "NORMAL_ISA" \n\t" \ 192 : : \ 193 : "r0", "r1", "r2", "r3", "ip", "lr", "memory", "cc" \ 194 ); 195 196 197/* 198 * Macros to define test cases. 199 * 200 * Those of the form TEST_{R,P,M}* can be used to define test cases 201 * which take combinations of the three basic types of arguments. E.g. 202 * 203 * TEST_R One register argument 204 * TEST_RR Two register arguments 205 * TEST_RPR A register, a pointer, then a register argument 206 * 207 * For testing instructions which may branch, there are macros TEST_BF_* 208 * and TEST_BB_* for branching forwards and backwards. 209 * 210 * TEST_SUPPORTED and TEST_UNSUPPORTED don't cause the code to be executed, 211 * the just verify that a kprobe is or is not allowed on the given instruction. 212 */ 213 214#define TEST(code) \ 215 TESTCASE_START(code) \ 216 TEST_ARG_END("") \ 217 TEST_INSTRUCTION(code) \ 218 TESTCASE_END 219 220#define TEST_UNSUPPORTED(code) \ 221 TESTCASE_START(code) \ 222 TEST_ARG_END("|"__stringify(ARG_FLAG_UNSUPPORTED)) \ 223 TEST_INSTRUCTION(code) \ 224 TESTCASE_END 225 226#define TEST_SUPPORTED(code) \ 227 TESTCASE_START(code) \ 228 TEST_ARG_END("|"__stringify(ARG_FLAG_SUPPORTED)) \ 229 TEST_INSTRUCTION(code) \ 230 TESTCASE_END 231 232#define TEST_R(code1, reg, val, code2) \ 233 TESTCASE_START(code1 #reg code2) \ 234 TEST_ARG_REG(reg, val) \ 235 TEST_ARG_END("") \ 236 TEST_INSTRUCTION(code1 #reg code2) \ 237 TESTCASE_END 238 239#define TEST_RR(code1, reg1, val1, code2, reg2, val2, code3) \ 240 TESTCASE_START(code1 #reg1 code2 #reg2 code3) \ 241 TEST_ARG_REG(reg1, val1) \ 242 TEST_ARG_REG(reg2, val2) \ 243 TEST_ARG_END("") \ 244 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3) \ 245 TESTCASE_END 246 247#define TEST_RRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\ 248 TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4) \ 249 TEST_ARG_REG(reg1, val1) \ 250 TEST_ARG_REG(reg2, val2) \ 251 TEST_ARG_REG(reg3, val3) \ 252 TEST_ARG_END("") \ 253 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4) \ 254 TESTCASE_END 255 256#define TEST_RRRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4, reg4, val4) \ 257 TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4 #reg4) \ 258 TEST_ARG_REG(reg1, val1) \ 259 TEST_ARG_REG(reg2, val2) \ 260 TEST_ARG_REG(reg3, val3) \ 261 TEST_ARG_REG(reg4, val4) \ 262 TEST_ARG_END("") \ 263 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4 #reg4) \ 264 TESTCASE_END 265 266#define TEST_P(code1, reg1, val1, code2) \ 267 TESTCASE_START(code1 #reg1 code2) \ 268 TEST_ARG_PTR(reg1, val1) \ 269 TEST_ARG_END("") \ 270 TEST_INSTRUCTION(code1 #reg1 code2) \ 271 TESTCASE_END 272 273#define TEST_PR(code1, reg1, val1, code2, reg2, val2, code3) \ 274 TESTCASE_START(code1 #reg1 code2 #reg2 code3) \ 275 TEST_ARG_PTR(reg1, val1) \ 276 TEST_ARG_REG(reg2, val2) \ 277 TEST_ARG_END("") \ 278 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3) \ 279 TESTCASE_END 280 281#define TEST_RP(code1, reg1, val1, code2, reg2, val2, code3) \ 282 TESTCASE_START(code1 #reg1 code2 #reg2 code3) \ 283 TEST_ARG_REG(reg1, val1) \ 284 TEST_ARG_PTR(reg2, val2) \ 285 TEST_ARG_END("") \ 286 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3) \ 287 TESTCASE_END 288 289#define TEST_PRR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\ 290 TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4) \ 291 TEST_ARG_PTR(reg1, val1) \ 292 TEST_ARG_REG(reg2, val2) \ 293 TEST_ARG_REG(reg3, val3) \ 294 TEST_ARG_END("") \ 295 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4) \ 296 TESTCASE_END 297 298#define TEST_RPR(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\ 299 TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4) \ 300 TEST_ARG_REG(reg1, val1) \ 301 TEST_ARG_PTR(reg2, val2) \ 302 TEST_ARG_REG(reg3, val3) \ 303 TEST_ARG_END("") \ 304 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4) \ 305 TESTCASE_END 306 307#define TEST_RRP(code1, reg1, val1, code2, reg2, val2, code3, reg3, val3, code4)\ 308 TESTCASE_START(code1 #reg1 code2 #reg2 code3 #reg3 code4) \ 309 TEST_ARG_REG(reg1, val1) \ 310 TEST_ARG_REG(reg2, val2) \ 311 TEST_ARG_PTR(reg3, val3) \ 312 TEST_ARG_END("") \ 313 TEST_INSTRUCTION(code1 #reg1 code2 #reg2 code3 #reg3 code4) \ 314 TESTCASE_END 315 316#define TEST_BF_P(code1, reg1, val1, code2) \ 317 TESTCASE_START(code1 #reg1 code2) \ 318 TEST_ARG_PTR(reg1, val1) \ 319 TEST_ARG_END("") \ 320 TEST_BRANCH_F(code1 #reg1 code2) \ 321 TESTCASE_END 322 323#define TEST_BF(code) \ 324 TESTCASE_START(code) \ 325 TEST_ARG_END("") \ 326 TEST_BRANCH_F(code) \ 327 TESTCASE_END 328 329#define TEST_BB(code) \ 330 TESTCASE_START(code) \ 331 TEST_ARG_END("") \ 332 TEST_BRANCH_B(code) \ 333 TESTCASE_END 334 335#define TEST_BF_R(code1, reg, val, code2) \ 336 TESTCASE_START(code1 #reg code2) \ 337 TEST_ARG_REG(reg, val) \ 338 TEST_ARG_END("") \ 339 TEST_BRANCH_F(code1 #reg code2) \ 340 TESTCASE_END 341 342#define TEST_BB_R(code1, reg, val, code2) \ 343 TESTCASE_START(code1 #reg code2) \ 344 TEST_ARG_REG(reg, val) \ 345 TEST_ARG_END("") \ 346 TEST_BRANCH_B(code1 #reg code2) \ 347 TESTCASE_END 348 349#define TEST_BF_RR(code1, reg1, val1, code2, reg2, val2, code3) \ 350 TESTCASE_START(code1 #reg1 code2 #reg2 code3) \ 351 TEST_ARG_REG(reg1, val1) \ 352 TEST_ARG_REG(reg2, val2) \ 353 TEST_ARG_END("") \ 354 TEST_BRANCH_F(code1 #reg1 code2 #reg2 code3) \ 355 TESTCASE_END 356 357#define TEST_BF_X(code, codex) \ 358 TESTCASE_START(code) \ 359 TEST_ARG_END("") \ 360 TEST_BRANCH_FX(code, codex) \ 361 TESTCASE_END 362 363#define TEST_BB_X(code, codex) \ 364 TESTCASE_START(code) \ 365 TEST_ARG_END("") \ 366 TEST_BRANCH_BX(code, codex) \ 367 TESTCASE_END 368 369#define TEST_BF_RX(code1, reg, val, code2, codex) \ 370 TESTCASE_START(code1 #reg code2) \ 371 TEST_ARG_REG(reg, val) \ 372 TEST_ARG_END("") \ 373 TEST_BRANCH_FX(code1 #reg code2, codex) \ 374 TESTCASE_END 375 376#define TEST_X(code, codex) \ 377 TESTCASE_START(code) \ 378 TEST_ARG_END("") \ 379 TEST_INSTRUCTION(code) \ 380 " b 99f \n\t" \ 381 " "codex" \n\t" \ 382 TESTCASE_END 383 384#define TEST_RX(code1, reg, val, code2, codex) \ 385 TESTCASE_START(code1 #reg code2) \ 386 TEST_ARG_REG(reg, val) \ 387 TEST_ARG_END("") \ 388 TEST_INSTRUCTION(code1 __stringify(reg) code2) \ 389 " b 99f \n\t" \ 390 " "codex" \n\t" \ 391 TESTCASE_END 392 393#define TEST_RRX(code1, reg1, val1, code2, reg2, val2, code3, codex) \ 394 TESTCASE_START(code1 #reg1 code2 #reg2 code3) \ 395 TEST_ARG_REG(reg1, val1) \ 396 TEST_ARG_REG(reg2, val2) \ 397 TEST_ARG_END("") \ 398 TEST_INSTRUCTION(code1 __stringify(reg1) code2 __stringify(reg2) code3) \ 399 " b 99f \n\t" \ 400 " "codex" \n\t" \ 401 TESTCASE_END 402 403#define TEST_RMASKED(code1, reg, mask, code2) \ 404 TESTCASE_START(code1 #reg code2) \ 405 TEST_ARG_REG_MASKED(reg, mask) \ 406 TEST_ARG_END("") \ 407 TEST_INSTRUCTION(code1 #reg code2) \ 408 TESTCASE_END 409 410/* 411 * We ignore the state of the imprecise abort disable flag (CPSR.A) because this 412 * can change randomly as the kernel doesn't take care to preserve or initialise 413 * this across context switches. Also, with Security Extensions, the flag may 414 * not be under control of the kernel; for this reason we ignore the state of 415 * the FIQ disable flag CPSR.F as well. 416 */ 417#define PSR_IGNORE_BITS (PSR_A_BIT | PSR_F_BIT) 418 419 420/* 421 * Macros for defining space directives spread over multiple lines. 422 * These are required so the compiler guesses better the length of inline asm 423 * code and will spill the literal pool early enough to avoid generating PC 424 * relative loads with out of range offsets. 425 */ 426#define TWICE(x) x x 427#define SPACE_0x8 TWICE(".space 4\n\t") 428#define SPACE_0x10 TWICE(SPACE_0x8) 429#define SPACE_0x20 TWICE(SPACE_0x10) 430#define SPACE_0x40 TWICE(SPACE_0x20) 431#define SPACE_0x80 TWICE(SPACE_0x40) 432#define SPACE_0x100 TWICE(SPACE_0x80) 433#define SPACE_0x200 TWICE(SPACE_0x100) 434#define SPACE_0x400 TWICE(SPACE_0x200) 435#define SPACE_0x800 TWICE(SPACE_0x400) 436#define SPACE_0x1000 TWICE(SPACE_0x800) 437 438 439/* Various values used in test cases... */ 440#define N(val) (val ^ 0xffffffff) 441#define VAL1 0x12345678 442#define VAL2 N(VAL1) 443#define VAL3 0xa5f801 444#define VAL4 N(VAL3) 445#define VALM 0x456789ab 446#define VALR 0xdeaddead 447#define HH1 0x0123fecb 448#define HH2 0xa9874567 449 450 451#ifdef CONFIG_THUMB2_KERNEL 452void kprobe_thumb16_test_cases(void); 453void kprobe_thumb32_test_cases(void); 454#else 455void kprobe_arm_test_cases(void); 456#endif