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