arch/arm/kernel/kprobes-common.c

   1 /*
   2  * arch/arm/kernel/kprobes-common.c
   3  *
   4  * Copyright (C) 2011 Jon Medhurst <tixy@yxit.co.uk>.
   5  *
   6  * Some contents moved here from arch/arm/include/asm/kprobes-arm.c which is
   7  * Copyright (C) 2006, 2007 Motorola Inc.
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/kprobes.h>
  16 #include <asm/system_info.h>
  17
  18 #include "kprobes.h"
  19
  20
  21 #ifndef find_str_pc_offset
  22
  23 /*
  24  * For STR and STM instructions, an ARM core may choose to use either
  25  * a +8 or a +12 displacement from the current instruction's address.
  26  * Whichever value is chosen for a given core, it must be the same for
  27  * both instructions and may not change.  This function measures it.
  28  */
  29
  30 int str_pc_offset;
  31
  32 void __init find_str_pc_offset(void)
  33 {
  34         int addr, scratch, ret;
  35
  36         __asm__ (
  37                 "sub    %[ret], pc, #4          \n\t"
  38                 "str    pc, %[addr]             \n\t"
  39                 "ldr    %[scr], %[addr]         \n\t"
  40                 "sub    %[ret], %[scr], %[ret]  \n\t"
  41                 : [ret] "=r" (ret), [scr] "=r" (scratch), [addr] "+m" (addr));
  42
  43         str_pc_offset = ret;
  44 }
  45
  46 #endif /* !find_str_pc_offset */
  47
  48
  49 #ifndef test_load_write_pc_interworking
  50
  51 bool load_write_pc_interworks;
  52
  53 void __init test_load_write_pc_interworking(void)
  54 {
  55         int arch = cpu_architecture();
  56         BUG_ON(arch == CPU_ARCH_UNKNOWN);
  57         load_write_pc_interworks = arch >= CPU_ARCH_ARMv5T;
  58 }
  59
  60 #endif /* !test_load_write_pc_interworking */
  61
  62
  63 #ifndef test_alu_write_pc_interworking
  64
  65 bool alu_write_pc_interworks;
  66
  67 void __init test_alu_write_pc_interworking(void)
  68 {
  69         int arch = cpu_architecture();
  70         BUG_ON(arch == CPU_ARCH_UNKNOWN);
  71         alu_write_pc_interworks = arch >= CPU_ARCH_ARMv7;
  72 }
  73
  74 #endif /* !test_alu_write_pc_interworking */
  75
  76
  77 void __init arm_kprobe_decode_init(void)
  78 {
  79         find_str_pc_offset();
  80         test_load_write_pc_interworking();
  81         test_alu_write_pc_interworking();
  82 }
  83
  84
  85 static unsigned long __kprobes __check_eq(unsigned long cpsr)
  86 {
  87         return cpsr & PSR_Z_BIT;
  88 }
  89
  90 static unsigned long __kprobes __check_ne(unsigned long cpsr)
  91 {
  92         return (~cpsr) & PSR_Z_BIT;
  93 }
  94
  95 static unsigned long __kprobes __check_cs(unsigned long cpsr)
  96 {
  97         return cpsr & PSR_C_BIT;
  98 }
  99
 100 static unsigned long __kprobes __check_cc(unsigned long cpsr)
 101 {
 102         return (~cpsr) & PSR_C_BIT;
 103 }
 104
 105 static unsigned long __kprobes __check_mi(unsigned long cpsr)
 106 {
 107         return cpsr & PSR_N_BIT;
 108 }
 109
 110 static unsigned long __kprobes __check_pl(unsigned long cpsr)
 111 {
 112         return (~cpsr) & PSR_N_BIT;
 113 }
 114
 115 static unsigned long __kprobes __check_vs(unsigned long cpsr)
 116 {
 117         return cpsr & PSR_V_BIT;
 118 }
 119
 120 static unsigned long __kprobes __check_vc(unsigned long cpsr)
 121 {
 122         return (~cpsr) & PSR_V_BIT;
 123 }
 124
 125 static unsigned long __kprobes __check_hi(unsigned long cpsr)
 126 {
 127         cpsr &= ~(cpsr >> 1); /* PSR_C_BIT &= ~PSR_Z_BIT */
 128         return cpsr & PSR_C_BIT;
 129 }
 130
 131 static unsigned long __kprobes __check_ls(unsigned long cpsr)
 132 {
 133         cpsr &= ~(cpsr >> 1); /* PSR_C_BIT &= ~PSR_Z_BIT */
 134         return (~cpsr) & PSR_C_BIT;
 135 }
 136
 137 static unsigned long __kprobes __check_ge(unsigned long cpsr)
 138 {
 139         cpsr ^= (cpsr << 3); /* PSR_N_BIT ^= PSR_V_BIT */
 140         return (~cpsr) & PSR_N_BIT;
 141 }
 142
 143 static unsigned long __kprobes __check_lt(unsigned long cpsr)
 144 {
 145         cpsr ^= (cpsr << 3); /* PSR_N_BIT ^= PSR_V_BIT */
 146         return cpsr & PSR_N_BIT;
 147 }
 148
 149 static unsigned long __kprobes __check_gt(unsigned long cpsr)
 150 {
 151         unsigned long temp = cpsr ^ (cpsr << 3); /* PSR_N_BIT ^= PSR_V_BIT */
 152         temp |= (cpsr << 1);                     /* PSR_N_BIT |= PSR_Z_BIT */
 153         return (~temp) & PSR_N_BIT;
 154 }
 155
 156 static unsigned long __kprobes __check_le(unsigned long cpsr)
 157 {
 158         unsigned long temp = cpsr ^ (cpsr << 3); /* PSR_N_BIT ^= PSR_V_BIT */
 159         temp |= (cpsr << 1);                     /* PSR_N_BIT |= PSR_Z_BIT */
 160         return temp & PSR_N_BIT;
 161 }
 162
 163 static unsigned long __kprobes __check_al(unsigned long cpsr)
 164 {
 165         return true;
 166 }
 167
 168 kprobe_check_cc * const kprobe_condition_checks[16] = {
 169         &__check_eq, &__check_ne, &__check_cs, &__check_cc,
 170         &__check_mi, &__check_pl, &__check_vs, &__check_vc,
 171         &__check_hi, &__check_ls, &__check_ge, &__check_lt,
 172         &__check_gt, &__check_le, &__check_al, &__check_al
 173 };
 174
 175
 176 void __kprobes kprobe_simulate_nop(struct kprobe *p, struct pt_regs *regs)
 177 {
 178 }
 179
 180 void __kprobes kprobe_emulate_none(struct kprobe *p, struct pt_regs *regs)
 181 {
 182         p->ainsn.insn_fn();
 183 }
 184
 185 static void __kprobes simulate_ldm1stm1(struct kprobe *p, struct pt_regs *regs)
 186 {
 187         kprobe_opcode_t insn = p->opcode;
 188         int rn = (insn >> 16) & 0xf;
 189         int lbit = insn & (1 << 20);
 190         int wbit = insn & (1 << 21);
 191         int ubit = insn & (1 << 23);
 192         int pbit = insn & (1 << 24);
 193         long *addr = (long *)regs->uregs[rn];
 194         int reg_bit_vector;
 195         int reg_count;
 196
 197         reg_count = 0;
 198         reg_bit_vector = insn & 0xffff;
 199         while (reg_bit_vector) {
 200                 reg_bit_vector &= (reg_bit_vector - 1);
 201                 ++reg_count;
 202         }
 203
 204         if (!ubit)
 205                 addr -= reg_count;
 206         addr += (!pbit == !ubit);
 207
 208         reg_bit_vector = insn & 0xffff;
 209         while (reg_bit_vector) {
 210                 int reg = __ffs(reg_bit_vector);
 211                 reg_bit_vector &= (reg_bit_vector - 1);
 212                 if (lbit)
 213                         regs->uregs[reg] = *addr++;
 214                 else
 215                         *addr++ = regs->uregs[reg];
 216         }
 217
 218         if (wbit) {
 219                 if (!ubit)
 220                         addr -= reg_count;
 221                 addr -= (!pbit == !ubit);
 222                 regs->uregs[rn] = (long)addr;
 223         }
 224 }
 225
 226 static void __kprobes simulate_stm1_pc(struct kprobe *p, struct pt_regs *regs)
 227 {
 228         regs->ARM_pc = (long)p->addr + str_pc_offset;
 229         simulate_ldm1stm1(p, regs);
 230         regs->ARM_pc = (long)p->addr + 4;
 231 }
 232
 233 static void __kprobes simulate_ldm1_pc(struct kprobe *p, struct pt_regs *regs)
 234 {
 235         simulate_ldm1stm1(p, regs);
 236         load_write_pc(regs->ARM_pc, regs);
 237 }
 238
 239 static void __kprobes
 240 emulate_generic_r0_12_noflags(struct kprobe *p, struct pt_regs *regs)
 241 {
 242         register void *rregs asm("r1") = regs;
 243         register void *rfn asm("lr") = p->ainsn.insn_fn;
 244
 245         __asm__ __volatile__ (
 246                 "stmdb  sp!, {%[regs], r11}     \n\t"
 247                 "ldmia  %[regs], {r0-r12}       \n\t"
 248 #if __LINUX_ARM_ARCH__ >= 6
 249                 "blx    %[fn]                   \n\t"
 250 #else
 251                 "str    %[fn], [sp, #-4]!       \n\t"
 252                 "adr    lr, 1f                  \n\t"
 253                 "ldr    pc, [sp], #4            \n\t"
 254                 "1:                             \n\t"
 255 #endif
 256                 "ldr    lr, [sp], #4            \n\t" /* lr = regs */
 257                 "stmia  lr, {r0-r12}            \n\t"
 258                 "ldr    r11, [sp], #4           \n\t"
 259                 : [regs] "=r" (rregs), [fn] "=r" (rfn)
 260                 : "0" (rregs), "1" (rfn)
 261                 : "r0", "r2", "r3", "r4", "r5", "r6", "r7",
 262                   "r8", "r9", "r10", "r12", "memory", "cc"
 263                 );
 264 }
 265
 266 static void __kprobes
 267 emulate_generic_r2_14_noflags(struct kprobe *p, struct pt_regs *regs)
 268 {
 269         emulate_generic_r0_12_noflags(p, (struct pt_regs *)(regs->uregs+2));
 270 }
 271
 272 static void __kprobes
 273 emulate_ldm_r3_15(struct kprobe *p, struct pt_regs *regs)
 274 {
 275         emulate_generic_r0_12_noflags(p, (struct pt_regs *)(regs->uregs+3));
 276         load_write_pc(regs->ARM_pc, regs);
 277 }
 278
 279 enum kprobe_insn __kprobes
 280 kprobe_decode_ldmstm(kprobe_opcode_t insn, struct arch_specific_insn *asi)
 281 {
 282         kprobe_insn_handler_t *handler = 0;
 283         unsigned reglist = insn & 0xffff;
 284         int is_ldm = insn & 0x100000;
 285         int rn = (insn >> 16) & 0xf;
 286
 287         if (rn <= 12 && (reglist & 0xe000) == 0) {
 288                 /* Instruction only uses registers in the range R0..R12 */
 289                 handler = emulate_generic_r0_12_noflags;
 290
 291         } else if (rn >= 2 && (reglist & 0x8003) == 0) {
 292                 /* Instruction only uses registers in the range R2..R14 */
 293                 rn -= 2;
 294                 reglist >>= 2;
 295                 handler = emulate_generic_r2_14_noflags;
 296
 297         } else if (rn >= 3 && (reglist & 0x0007) == 0) {
 298                 /* Instruction only uses registers in the range R3..R15 */
 299                 if (is_ldm && (reglist & 0x8000)) {
 300                         rn -= 3;
 301                         reglist >>= 3;
 302                         handler = emulate_ldm_r3_15;
 303                 }
 304         }
 305
 306         if (handler) {
 307                 /* We can emulate the instruction in (possibly) modified form */
 308                 asi->insn[0] = (insn & 0xfff00000) | (rn << 16) | reglist;
 309                 asi->insn_handler = handler;
 310                 return INSN_GOOD;
 311         }
 312
 313         /* Fallback to slower simulation... */
 314         if (reglist & 0x8000)
 315                 handler = is_ldm ? simulate_ldm1_pc : simulate_stm1_pc;
 316         else
 317                 handler = simulate_ldm1stm1;
 318         asi->insn_handler = handler;
 319         return INSN_GOOD_NO_SLOT;
 320 }
 321
 322
 323 /*
 324  * Prepare an instruction slot to receive an instruction for emulating.
 325  * This is done by placing a subroutine return after the location where the
 326  * instruction will be placed. We also modify ARM instructions to be
 327  * unconditional as the condition code will already be checked before any
 328  * emulation handler is called.
 329  */
 330 static kprobe_opcode_t __kprobes
 331 prepare_emulated_insn(kprobe_opcode_t insn, struct arch_specific_insn *asi,
 332                                                                 bool thumb)
 333 {
 334 #ifdef CONFIG_THUMB2_KERNEL
 335         if (thumb) {
 336                 u16 *thumb_insn = (u16 *)asi->insn;
 337                 thumb_insn[1] = 0x4770; /* Thumb bx lr */
 338                 thumb_insn[2] = 0x4770; /* Thumb bx lr */
 339                 return insn;
 340         }
 341         asi->insn[1] = 0xe12fff1e; /* ARM bx lr */
 342 #else
 343         asi->insn[1] = 0xe1a0f00e; /* mov pc, lr */
 344 #endif
 345         /* Make an ARM instruction unconditional */
 346         if (insn < 0xe0000000)
 347                 insn = (insn | 0xe0000000) & ~0x10000000;
 348         return insn;
 349 }
 350
 351 /*
 352  * Write a (probably modified) instruction into the slot previously prepared by
 353  * prepare_emulated_insn
 354  */
 355 static void  __kprobes
 356 set_emulated_insn(kprobe_opcode_t insn, struct arch_specific_insn *asi,
 357                                                                 bool thumb)
 358 {
 359 #ifdef CONFIG_THUMB2_KERNEL
 360         if (thumb) {
 361                 u16 *ip = (u16 *)asi->insn;
 362                 if (is_wide_instruction(insn))
 363                         *ip++ = insn >> 16;
 364                 *ip++ = insn;
 365                 return;
 366         }
 367 #endif
 368         asi->insn[0] = insn;
 369 }
 370
 371 /*
 372  * When we modify the register numbers encoded in an instruction to be emulated,
 373  * the new values come from this define. For ARM and 32-bit Thumb instructions
 374  * this gives...
 375  *
 376  *      bit position      16  12   8   4   0
 377  *      ---------------+---+---+---+---+---+
 378  *      register         r2  r0  r1  --  r3
 379  */
 380 #define INSN_NEW_BITS           0x00020103
 381
 382 /* Each nibble has same value as that at INSN_NEW_BITS bit 16 */
 383 #define INSN_SAMEAS16_BITS      0x22222222
 384
 385 /*
 386  * Validate and modify each of the registers encoded in an instruction.
 387  *
 388  * Each nibble in regs contains a value from enum decode_reg_type. For each
 389  * non-zero value, the corresponding nibble in pinsn is validated and modified
 390  * according to the type.
 391  */
 392 static bool __kprobes decode_regs(kprobe_opcode_t* pinsn, u32 regs)
 393 {
 394         kprobe_opcode_t insn = *pinsn;
 395         kprobe_opcode_t mask = 0xf; /* Start at least significant nibble */
 396
 397         for (; regs != 0; regs >>= 4, mask <<= 4) {
 398
 399                 kprobe_opcode_t new_bits = INSN_NEW_BITS;
 400
 401                 switch (regs & 0xf) {
 402
 403                 case REG_TYPE_NONE:
 404                         /* Nibble not a register, skip to next */
 405                         continue;
 406
 407                 case REG_TYPE_ANY:
 408                         /* Any register is allowed */
 409                         break;
 410
 411                 case REG_TYPE_SAMEAS16:
 412                         /* Replace register with same as at bit position 16 */
 413                         new_bits = INSN_SAMEAS16_BITS;
 414                         break;
 415
 416                 case REG_TYPE_SP:
 417                         /* Only allow SP (R13) */
 418                         if ((insn ^ 0xdddddddd) & mask)
 419                                 goto reject;
 420                         break;
 421
 422                 case REG_TYPE_PC:
 423                         /* Only allow PC (R15) */
 424                         if ((insn ^ 0xffffffff) & mask)
 425                                 goto reject;
 426                         break;
 427
 428                 case REG_TYPE_NOSP:
 429                         /* Reject SP (R13) */
 430                         if (((insn ^ 0xdddddddd) & mask) == 0)
 431                                 goto reject;
 432                         break;
 433
 434                 case REG_TYPE_NOSPPC:
 435                 case REG_TYPE_NOSPPCX:
 436                         /* Reject SP and PC (R13 and R15) */
 437                         if (((insn ^ 0xdddddddd) & 0xdddddddd & mask) == 0)
 438                                 goto reject;
 439                         break;
 440
 441                 case REG_TYPE_NOPCWB:
 442                         if (!is_writeback(insn))
 443                                 break; /* No writeback, so any register is OK */
 444                         /* fall through... */
 445                 case REG_TYPE_NOPC:
 446                 case REG_TYPE_NOPCX:
 447                         /* Reject PC (R15) */
 448                         if (((insn ^ 0xffffffff) & mask) == 0)
 449                                 goto reject;
 450                         break;
 451                 }
 452
 453                 /* Replace value of nibble with new register number... */
 454                 insn &= ~mask;
 455                 insn |= new_bits & mask;
 456         }
 457
 458         *pinsn = insn;
 459         return true;
 460
 461 reject:
 462         return false;
 463 }
 464
 465 static const int decode_struct_sizes[NUM_DECODE_TYPES] = {
 466         [DECODE_TYPE_TABLE]     = sizeof(struct decode_table),
 467         [DECODE_TYPE_CUSTOM]    = sizeof(struct decode_custom),
 468         [DECODE_TYPE_SIMULATE]  = sizeof(struct decode_simulate),
 469         [DECODE_TYPE_EMULATE]   = sizeof(struct decode_emulate),
 470         [DECODE_TYPE_OR]        = sizeof(struct decode_or),
 471         [DECODE_TYPE_REJECT]    = sizeof(struct decode_reject)
 472 };
 473
 474 /*
 475  * kprobe_decode_insn operates on data tables in order to decode an ARM
 476  * architecture instruction onto which a kprobe has been placed.
 477  *
 478  * These instruction decoding tables are a concatenation of entries each
 479  * of which consist of one of the following structs:
 480  *
 481  *      decode_table
 482  *      decode_custom
 483  *      decode_simulate
 484  *      decode_emulate
 485  *      decode_or
 486  *      decode_reject
 487  *
 488  * Each of these starts with a struct decode_header which has the following
 489  * fields:
 490  *
 491  *      type_regs
 492  *      mask
 493  *      value
 494  *
 495  * The least significant DECODE_TYPE_BITS of type_regs contains a value
 496  * from enum decode_type, this indicates which of the decode_* structs
 497  * the entry contains. The value DECODE_TYPE_END indicates the end of the
 498  * table.
 499  *
 500  * When the table is parsed, each entry is checked in turn to see if it
 501  * matches the instruction to be decoded using the test:
 502  *
 503  *      (insn & mask) == value
 504  *
 505  * If no match is found before the end of the table is reached then decoding
 506  * fails with INSN_REJECTED.
 507  *
 508  * When a match is found, decode_regs() is called to validate and modify each
 509  * of the registers encoded in the instruction; the data it uses to do this
 510  * is (type_regs >> DECODE_TYPE_BITS). A validation failure will cause decoding
 511  * to fail with INSN_REJECTED.
 512  *
 513  * Once the instruction has passed the above tests, further processing
 514  * depends on the type of the table entry's decode struct.
 515  *
 516  */
 517 int __kprobes
 518 kprobe_decode_insn(kprobe_opcode_t insn, struct arch_specific_insn *asi,
 519                                 const union decode_item *table, bool thumb)
 520 {
 521         const struct decode_header *h = (struct decode_header *)table;
 522         const struct decode_header *next;
 523         bool matched = false;
 524
 525         insn = prepare_emulated_insn(insn, asi, thumb);
 526
 527         for (;; h = next) {
 528                 enum decode_type type = h->type_regs.bits & DECODE_TYPE_MASK;
 529                 u32 regs = h->type_regs.bits >> DECODE_TYPE_BITS;
 530
 531                 if (type == DECODE_TYPE_END)
 532                         return INSN_REJECTED;
 533
 534                 next = (struct decode_header *)
 535                                 ((uintptr_t)h + decode_struct_sizes[type]);
 536
 537                 if (!matched && (insn & h->mask.bits) != h->value.bits)
 538                         continue;
 539
 540                 if (!decode_regs(&insn, regs))
 541                         return INSN_REJECTED;
 542
 543                 switch (type) {
 544
 545                 case DECODE_TYPE_TABLE: {
 546                         struct decode_table *d = (struct decode_table *)h;
 547                         next = (struct decode_header *)d->table.table;
 548                         break;
 549                 }
 550
 551                 case DECODE_TYPE_CUSTOM: {
 552                         struct decode_custom *d = (struct decode_custom *)h;
 553                         return (*d->decoder.decoder)(insn, asi);
 554                 }
 555
 556                 case DECODE_TYPE_SIMULATE: {
 557                         struct decode_simulate *d = (struct decode_simulate *)h;
 558                         asi->insn_handler = d->handler.handler;
 559                         return INSN_GOOD_NO_SLOT;
 560                 }
 561
 562                 case DECODE_TYPE_EMULATE: {
 563                         struct decode_emulate *d = (struct decode_emulate *)h;
 564                         asi->insn_handler = d->handler.handler;
 565                         set_emulated_insn(insn, asi, thumb);
 566                         return INSN_GOOD;
 567                 }
 568
 569                 case DECODE_TYPE_OR:
 570                         matched = true;
 571                         break;
 572
 573                 case DECODE_TYPE_REJECT:
 574                 default:
 575                         return INSN_REJECTED;
 576                 }
 577                 }
 578         }