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