Branch data Line data Source code
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/opcodes.h>
17 : :
18 : : #include "kprobes.h"
19 : :
20 : :
21 : 0 : static void __kprobes simulate_ldm1stm1(probes_opcode_t insn,
22 : : struct arch_probes_insn *asi,
23 : : struct pt_regs *regs)
24 : : {
25 : 0 : int rn = (insn >> 16) & 0xf;
26 : 0 : int lbit = insn & (1 << 20);
27 : 0 : int wbit = insn & (1 << 21);
28 : 0 : int ubit = insn & (1 << 23);
29 : 0 : int pbit = insn & (1 << 24);
30 : 0 : long *addr = (long *)regs->uregs[rn];
31 : : int reg_bit_vector;
32 : : int reg_count;
33 : :
34 : : reg_count = 0;
35 : 0 : reg_bit_vector = insn & 0xffff;
36 [ # # ]: 0 : while (reg_bit_vector) {
37 : 0 : reg_bit_vector &= (reg_bit_vector - 1);
38 : 0 : ++reg_count;
39 : : }
40 : :
41 [ # # ]: 0 : if (!ubit)
42 : 0 : addr -= reg_count;
43 : 0 : addr += (!pbit == !ubit);
44 : :
45 : : reg_bit_vector = insn & 0xffff;
46 [ # # ]: 0 : while (reg_bit_vector) {
47 : : int reg = __ffs(reg_bit_vector);
48 : 0 : reg_bit_vector &= (reg_bit_vector - 1);
49 [ # # ]: 0 : if (lbit)
50 : 0 : regs->uregs[reg] = *addr++;
51 : : else
52 : 0 : *addr++ = regs->uregs[reg];
53 : : }
54 : :
55 [ # # ]: 0 : if (wbit) {
56 [ # # ]: 0 : if (!ubit)
57 : 0 : addr -= reg_count;
58 : 0 : addr -= (!pbit == !ubit);
59 : 0 : regs->uregs[rn] = (long)addr;
60 : : }
61 : 0 : }
62 : :
63 : 0 : static void __kprobes simulate_stm1_pc(probes_opcode_t insn,
64 : : struct arch_probes_insn *asi,
65 : : struct pt_regs *regs)
66 : : {
67 : 0 : unsigned long addr = regs->ARM_pc - 4;
68 : :
69 : 0 : regs->ARM_pc = (long)addr + str_pc_offset;
70 : 0 : simulate_ldm1stm1(insn, asi, regs);
71 : 0 : regs->ARM_pc = (long)addr + 4;
72 : 0 : }
73 : :
74 : 0 : static void __kprobes simulate_ldm1_pc(probes_opcode_t insn,
75 : : struct arch_probes_insn *asi,
76 : : struct pt_regs *regs)
77 : : {
78 : 0 : simulate_ldm1stm1(insn, asi, regs);
79 : 0 : load_write_pc(regs->ARM_pc, regs);
80 : 0 : }
81 : :
82 : : static void __kprobes
83 : 0 : emulate_generic_r0_12_noflags(probes_opcode_t insn,
84 : : struct arch_probes_insn *asi, struct pt_regs *regs)
85 : : {
86 : 0 : register void *rregs asm("r1") = regs;
87 : 0 : register void *rfn asm("lr") = asi->insn_fn;
88 : :
89 : 0 : __asm__ __volatile__ (
90 : : "stmdb sp!, {%[regs], r11} \n\t"
91 : : "ldmia %[regs], {r0-r12} \n\t"
92 : : #if __LINUX_ARM_ARCH__ >= 6
93 : : "blx %[fn] \n\t"
94 : : #else
95 : : "str %[fn], [sp, #-4]! \n\t"
96 : : "adr lr, 1f \n\t"
97 : : "ldr pc, [sp], #4 \n\t"
98 : : "1: \n\t"
99 : : #endif
100 : : "ldr lr, [sp], #4 \n\t" /* lr = regs */
101 : : "stmia lr, {r0-r12} \n\t"
102 : : "ldr r11, [sp], #4 \n\t"
103 : : : [regs] "=r" (rregs), [fn] "=r" (rfn)
104 : : : "0" (rregs), "1" (rfn)
105 : : : "r0", "r2", "r3", "r4", "r5", "r6", "r7",
106 : : "r8", "r9", "r10", "r12", "memory", "cc"
107 : : );
108 : 0 : }
109 : :
110 : : static void __kprobes
111 : 0 : emulate_generic_r2_14_noflags(probes_opcode_t insn,
112 : : struct arch_probes_insn *asi, struct pt_regs *regs)
113 : : {
114 : : emulate_generic_r0_12_noflags(insn, asi,
115 : 0 : (struct pt_regs *)(regs->uregs+2));
116 : 0 : }
117 : :
118 : : static void __kprobes
119 : 0 : emulate_ldm_r3_15(probes_opcode_t insn,
120 : : struct arch_probes_insn *asi, struct pt_regs *regs)
121 : : {
122 : : emulate_generic_r0_12_noflags(insn, asi,
123 : 0 : (struct pt_regs *)(regs->uregs+3));
124 : 0 : load_write_pc(regs->ARM_pc, regs);
125 : 0 : }
126 : :
127 : : enum probes_insn __kprobes
128 : 0 : kprobe_decode_ldmstm(probes_opcode_t insn, struct arch_probes_insn *asi,
129 : : const struct decode_header *h)
130 : : {
131 : : probes_insn_handler_t *handler = 0;
132 : 0 : unsigned reglist = insn & 0xffff;
133 : 0 : int is_ldm = insn & 0x100000;
134 : 0 : int rn = (insn >> 16) & 0xf;
135 : :
136 [ # # ][ # # ]: 0 : if (rn <= 12 && (reglist & 0xe000) == 0) {
137 : : /* Instruction only uses registers in the range R0..R12 */
138 : : handler = emulate_generic_r0_12_noflags;
139 : :
140 [ # # ][ # # ]: 0 : } else if (rn >= 2 && (reglist & 0x8003) == 0) {
141 : : /* Instruction only uses registers in the range R2..R14 */
142 : 0 : rn -= 2;
143 : 0 : reglist >>= 2;
144 : 0 : handler = emulate_generic_r2_14_noflags;
145 : :
146 [ # # ][ # # ]: 0 : } else if (rn >= 3 && (reglist & 0x0007) == 0) {
147 : : /* Instruction only uses registers in the range R3..R15 */
148 [ # # ][ # # ]: 0 : if (is_ldm && (reglist & 0x8000)) {
149 : 0 : rn -= 3;
150 : 0 : reglist >>= 3;
151 : : handler = emulate_ldm_r3_15;
152 : : }
153 : : }
154 : :
155 [ # # ]: 0 : if (handler) {
156 : : /* We can emulate the instruction in (possibly) modified form */
157 : 0 : asi->insn[0] = __opcode_to_mem_arm((insn & 0xfff00000) |
158 : : (rn << 16) | reglist);
159 : 0 : asi->insn_handler = handler;
160 : 0 : return INSN_GOOD;
161 : : }
162 : :
163 : : /* Fallback to slower simulation... */
164 [ # # ]: 0 : if (reglist & 0x8000)
165 [ # # ]: 0 : handler = is_ldm ? simulate_ldm1_pc : simulate_stm1_pc;
166 : : else
167 : : handler = simulate_ldm1stm1;
168 : 0 : asi->insn_handler = handler;
169 : 0 : return INSN_GOOD_NO_SLOT;
170 : : }
171 : :
|
