Pileus Git - ~andy/linux/blob - arch/arm/kernel/kprobes-thumb.c

   1 /*
   2  * arch/arm/kernel/kprobes-thumb.c
   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 #include <linux/kernel.h>
  12 #include <linux/kprobes.h>
  13
  14 #include "kprobes.h"
  15
  16
  17 /*
  18  * True if current instruction is in an IT block.
  19  */
  20 #define in_it_block(cpsr)       ((cpsr & 0x06000c00) != 0x00000000)
  21
  22 /*
  23  * Return the condition code to check for the currently executing instruction.
  24  * This is in ITSTATE<7:4> which is in CPSR<15:12> but is only valid if
  25  * in_it_block returns true.
  26  */
  27 #define current_cond(cpsr)      ((cpsr >> 12) & 0xf)
  28
  29 static unsigned long __kprobes
  30 t16_emulate_loregs(struct kprobe *p, struct pt_regs *regs)
  31 {
  32         unsigned long oldcpsr = regs->ARM_cpsr;
  33         unsigned long newcpsr;
  34
  35         __asm__ __volatile__ (
  36                 "msr    cpsr_fs, %[oldcpsr]     \n\t"
  37                 "ldmia  %[regs], {r0-r7}        \n\t"
  38                 "blx    %[fn]                   \n\t"
  39                 "stmia  %[regs], {r0-r7}        \n\t"
  40                 "mrs    %[newcpsr], cpsr        \n\t"
  41                 : [newcpsr] "=r" (newcpsr)
  42                 : [oldcpsr] "r" (oldcpsr), [regs] "r" (regs),
  43                   [fn] "r" (p->ainsn.insn_fn)
  44                 : "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
  45                   "lr", "memory", "cc"
  46                 );
  47
  48         return (oldcpsr & ~APSR_MASK) | (newcpsr & APSR_MASK);
  49 }
  50
  51 static void __kprobes
  52 t16_emulate_loregs_rwflags(struct kprobe *p, struct pt_regs *regs)
  53 {
  54         regs->ARM_cpsr = t16_emulate_loregs(p, regs);
  55 }
  56
  57 static void __kprobes
  58 t16_emulate_loregs_noitrwflags(struct kprobe *p, struct pt_regs *regs)
  59 {
  60         unsigned long cpsr = t16_emulate_loregs(p, regs);
  61         if (!in_it_block(cpsr))
  62                 regs->ARM_cpsr = cpsr;
  63 }
  64
  65 static const union decode_item t16_table_1011[] = {
  66         /* Miscellaneous 16-bit instructions                */
  67
  68         /*
  69          * If-Then, and hints
  70          *                              1011 1111 xxxx xxxx
  71          */
  72
  73         /* YIELD                        1011 1111 0001 0000 */
  74         DECODE_OR       (0xffff, 0xbf10),
  75         /* SEV                          1011 1111 0100 0000 */
  76         DECODE_EMULATE  (0xffff, 0xbf40, kprobe_emulate_none),
  77         /* NOP                          1011 1111 0000 0000 */
  78         /* WFE                          1011 1111 0010 0000 */
  79         /* WFI                          1011 1111 0011 0000 */
  80         DECODE_SIMULATE (0xffcf, 0xbf00, kprobe_simulate_nop),
  81         /* Unassigned hints             1011 1111 xxxx 0000 */
  82         DECODE_REJECT   (0xff0f, 0xbf00),
  83
  84         DECODE_END
  85 };
  86
  87 const union decode_item kprobe_decode_thumb16_table[] = {
  88
  89         /*
  90          * Shift (immediate), add, subtract, move, and compare
  91          *                              00xx xxxx xxxx xxxx
  92          */
  93
  94         /* CMP (immediate)              0010 1xxx xxxx xxxx */
  95         DECODE_EMULATE  (0xf800, 0x2800, t16_emulate_loregs_rwflags),
  96
  97         /* ADD (register)               0001 100x xxxx xxxx */
  98         /* SUB (register)               0001 101x xxxx xxxx */
  99         /* LSL (immediate)              0000 0xxx xxxx xxxx */
 100         /* LSR (immediate)              0000 1xxx xxxx xxxx */
 101         /* ASR (immediate)              0001 0xxx xxxx xxxx */
 102         /* ADD (immediate, Thumb)       0001 110x xxxx xxxx */
 103         /* SUB (immediate, Thumb)       0001 111x xxxx xxxx */
 104         /* MOV (immediate)              0010 0xxx xxxx xxxx */
 105         /* ADD (immediate, Thumb)       0011 0xxx xxxx xxxx */
 106         /* SUB (immediate, Thumb)       0011 1xxx xxxx xxxx */
 107         DECODE_EMULATE  (0xc000, 0x0000, t16_emulate_loregs_noitrwflags),
 108
 109         /*
 110          * 16-bit Thumb data-processing instructions
 111          *                              0100 00xx xxxx xxxx
 112          */
 113
 114         /* TST (register)               0100 0010 00xx xxxx */
 115         DECODE_EMULATE  (0xffc0, 0x4200, t16_emulate_loregs_rwflags),
 116         /* CMP (register)               0100 0010 10xx xxxx */
 117         /* CMN (register)               0100 0010 11xx xxxx */
 118         DECODE_EMULATE  (0xff80, 0x4280, t16_emulate_loregs_rwflags),
 119         /* AND (register)               0100 0000 00xx xxxx */
 120         /* EOR (register)               0100 0000 01xx xxxx */
 121         /* LSL (register)               0100 0000 10xx xxxx */
 122         /* LSR (register)               0100 0000 11xx xxxx */
 123         /* ASR (register)               0100 0001 00xx xxxx */
 124         /* ADC (register)               0100 0001 01xx xxxx */
 125         /* SBC (register)               0100 0001 10xx xxxx */
 126         /* ROR (register)               0100 0001 11xx xxxx */
 127         /* RSB (immediate)              0100 0010 01xx xxxx */
 128         /* ORR (register)               0100 0011 00xx xxxx */
 129         /* MUL                          0100 0011 00xx xxxx */
 130         /* BIC (register)               0100 0011 10xx xxxx */
 131         /* MVN (register)               0100 0011 10xx xxxx */
 132         DECODE_EMULATE  (0xfc00, 0x4000, t16_emulate_loregs_noitrwflags),
 133
 134         /*
 135          * Miscellaneous 16-bit instructions
 136          *                              1011 xxxx xxxx xxxx
 137          */
 138         DECODE_TABLE    (0xf000, 0xb000, t16_table_1011),
 139
 140         DECODE_END
 141 };
 142
 143 static unsigned long __kprobes thumb_check_cc(unsigned long cpsr)
 144 {
 145         if (unlikely(in_it_block(cpsr)))
 146                 return kprobe_condition_checks[current_cond(cpsr)](cpsr);
 147         return true;
 148 }
 149
 150 static void __kprobes thumb16_singlestep(struct kprobe *p, struct pt_regs *regs)
 151 {
 152         regs->ARM_pc += 2;
 153         p->ainsn.insn_handler(p, regs);
 154         regs->ARM_cpsr = it_advance(regs->ARM_cpsr);
 155 }
 156
 157 static void __kprobes thumb32_singlestep(struct kprobe *p, struct pt_regs *regs)
 158 {
 159         regs->ARM_pc += 4;
 160         p->ainsn.insn_handler(p, regs);
 161         regs->ARM_cpsr = it_advance(regs->ARM_cpsr);
 162 }
 163
 164 enum kprobe_insn __kprobes
 165 thumb16_kprobe_decode_insn(kprobe_opcode_t insn, struct arch_specific_insn *asi)
 166 {
 167         asi->insn_singlestep = thumb16_singlestep;
 168         asi->insn_check_cc = thumb_check_cc;
 169         return kprobe_decode_insn(insn, asi, kprobe_decode_thumb16_table, true);
 170 }
 171
 172 enum kprobe_insn __kprobes
 173 thumb32_kprobe_decode_insn(kprobe_opcode_t insn, struct arch_specific_insn *asi)
 174 {
 175         asi->insn_singlestep = thumb32_singlestep;
 176         asi->insn_check_cc = thumb_check_cc;
 177         return INSN_REJECTED;
 178 }