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