[PATCH] Kprobes/IA64: arch specific handling
[linux-2.6.git] / arch / ia64 / kernel / kprobes.c
1 /*
2  *  Kernel Probes (KProbes)
3  *  arch/ia64/kernel/kprobes.c
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  *
19  * Copyright (C) IBM Corporation, 2002, 2004
20  * Copyright (C) Intel Corporation, 2005
21  *
22  * 2005-Apr     Rusty Lynch <rusty.lynch@intel.com> and Anil S Keshavamurthy
23  *              <anil.s.keshavamurthy@intel.com> adapted from i386
24  */
25
26 #include <linux/config.h>
27 #include <linux/kprobes.h>
28 #include <linux/ptrace.h>
29 #include <linux/spinlock.h>
30 #include <linux/string.h>
31 #include <linux/slab.h>
32 #include <linux/preempt.h>
33 #include <linux/moduleloader.h>
34
35 #include <asm/pgtable.h>
36 #include <asm/kdebug.h>
37
38 /* kprobe_status settings */
39 #define KPROBE_HIT_ACTIVE       0x00000001
40 #define KPROBE_HIT_SS           0x00000002
41
42 static struct kprobe *current_kprobe;
43 static unsigned long kprobe_status;
44
45 enum instruction_type {A, I, M, F, B, L, X, u};
46 static enum instruction_type bundle_encoding[32][3] = {
47   { M, I, I },                          /* 00 */
48   { M, I, I },                          /* 01 */
49   { M, I, I },                          /* 02 */
50   { M, I, I },                          /* 03 */
51   { M, L, X },                          /* 04 */
52   { M, L, X },                          /* 05 */
53   { u, u, u },                          /* 06 */
54   { u, u, u },                          /* 07 */
55   { M, M, I },                          /* 08 */
56   { M, M, I },                          /* 09 */
57   { M, M, I },                          /* 0A */
58   { M, M, I },                          /* 0B */
59   { M, F, I },                          /* 0C */
60   { M, F, I },                          /* 0D */
61   { M, M, F },                          /* 0E */
62   { M, M, F },                          /* 0F */
63   { M, I, B },                          /* 10 */
64   { M, I, B },                          /* 11 */
65   { M, B, B },                          /* 12 */
66   { M, B, B },                          /* 13 */
67   { u, u, u },                          /* 14 */
68   { u, u, u },                          /* 15 */
69   { B, B, B },                          /* 16 */
70   { B, B, B },                          /* 17 */
71   { M, M, B },                          /* 18 */
72   { M, M, B },                          /* 19 */
73   { u, u, u },                          /* 1A */
74   { u, u, u },                          /* 1B */
75   { M, F, B },                          /* 1C */
76   { M, F, B },                          /* 1D */
77   { u, u, u },                          /* 1E */
78   { u, u, u },                          /* 1F */
79 };
80
81 int arch_prepare_kprobe(struct kprobe *p)
82 {
83         unsigned long addr = (unsigned long) p->addr;
84         unsigned long bundle_addr = addr & ~0xFULL;
85         unsigned long slot = addr & 0xf;
86         bundle_t bundle;
87         unsigned long template;
88
89         /*
90          * TODO: Verify that a probe is not being inserted
91          *       in sensitive regions of code
92          * TODO: Verify that the memory holding the probe is rwx
93          * TODO: verify this is a kernel address
94          */
95         memcpy(&bundle, (unsigned long *)bundle_addr, sizeof(bundle_t));
96         template = bundle.quad0.template;
97         if (((bundle_encoding[template][1] == L) && slot > 1) || (slot > 2)) {
98                 printk(KERN_WARNING "Attempting to insert unaligned kprobe at 0x%lx\n", addr);
99                 return -EINVAL;
100         }
101         return 0;
102 }
103
104 void arch_copy_kprobe(struct kprobe *p)
105 {
106         unsigned long addr = (unsigned long)p->addr;
107         unsigned long bundle_addr = addr & ~0xFULL;
108
109         memcpy(&p->ainsn.insn.bundle, (unsigned long *)bundle_addr,
110                                 sizeof(bundle_t));
111         memcpy(&p->opcode.bundle, &p->ainsn.insn.bundle, sizeof(bundle_t));
112 }
113
114 void arch_arm_kprobe(struct kprobe *p)
115 {
116         unsigned long addr = (unsigned long)p->addr;
117         unsigned long arm_addr = addr & ~0xFULL;
118         unsigned long slot = addr & 0xf;
119         unsigned long template;
120         bundle_t bundle;
121
122         memcpy(&bundle, &p->ainsn.insn.bundle, sizeof(bundle_t));
123
124         template = bundle.quad0.template;
125         if (slot == 1 && bundle_encoding[template][1] == L)
126                 slot = 2;
127         switch (slot) {
128         case 0:
129                 bundle.quad0.slot0 = BREAK_INST;
130                 break;
131         case 1:
132                 bundle.quad0.slot1_p0 = BREAK_INST;
133                 bundle.quad1.slot1_p1 = (BREAK_INST >> (64-46));
134                 break;
135         case 2:
136                 bundle.quad1.slot2 = BREAK_INST;
137                 break;
138         }
139
140         /* Flush icache for the instruction at the emulated address */
141         flush_icache_range((unsigned long)&p->ainsn.insn.bundle,
142                         (unsigned long)&p->ainsn.insn.bundle +
143                         sizeof(bundle_t));
144         /*
145          * Patch the original instruction with the probe instruction
146          * and flush the instruction cache
147          */
148         memcpy((char *) arm_addr, (char *) &bundle, sizeof(bundle_t));
149         flush_icache_range(arm_addr, arm_addr + sizeof(bundle_t));
150 }
151
152 void arch_disarm_kprobe(struct kprobe *p)
153 {
154         unsigned long addr = (unsigned long)p->addr;
155         unsigned long arm_addr = addr & ~0xFULL;
156
157         /* p->opcode contains the original unaltered bundle */
158         memcpy((char *) arm_addr, (char *) &p->opcode.bundle, sizeof(bundle_t));
159         flush_icache_range(arm_addr, arm_addr + sizeof(bundle_t));
160 }
161
162 void arch_remove_kprobe(struct kprobe *p)
163 {
164 }
165
166 /*
167  * We are resuming execution after a single step fault, so the pt_regs
168  * structure reflects the register state after we executed the instruction
169  * located in the kprobe (p->ainsn.insn.bundle).  We still need to adjust
170  * the ip to point back to the original stack address, and if we see that
171  * the slot has incremented back to zero, then we need to point to the next
172  * slot location.
173  */
174 static void resume_execution(struct kprobe *p, struct pt_regs *regs)
175 {
176         unsigned long bundle = (unsigned long)p->addr & ~0xFULL;
177
178         /*
179          * TODO: Handle cases where kprobe was inserted on a branch instruction
180          */
181
182         if (!ia64_psr(regs)->ri)
183                 regs->cr_iip = bundle + 0x10;
184         else
185                 regs->cr_iip = bundle;
186
187         ia64_psr(regs)->ss = 0;
188 }
189
190 static void prepare_ss(struct kprobe *p, struct pt_regs *regs)
191 {
192         unsigned long bundle_addr = (unsigned long) &p->ainsn.insn.bundle;
193         unsigned long slot = (unsigned long)p->addr & 0xf;
194
195         /* Update instruction pointer (IIP) and slot number (IPSR.ri) */
196         regs->cr_iip = bundle_addr & ~0xFULL;
197
198         if (slot > 2)
199                 slot = 0;
200
201         ia64_psr(regs)->ri = slot;
202
203         /* turn on single stepping */
204         ia64_psr(regs)->ss = 1;
205 }
206
207 static int pre_kprobes_handler(struct pt_regs *regs)
208 {
209         struct kprobe *p;
210         int ret = 0;
211         kprobe_opcode_t *addr = (kprobe_opcode_t *)instruction_pointer(regs);
212
213         preempt_disable();
214
215         /* Handle recursion cases */
216         if (kprobe_running()) {
217                 p = get_kprobe(addr);
218                 if (p) {
219                         if (kprobe_status == KPROBE_HIT_SS) {
220                                 unlock_kprobes();
221                                 goto no_kprobe;
222                         }
223                         arch_disarm_kprobe(p);
224                         ret = 1;
225                 } else {
226                         /*
227                          * jprobe instrumented function just completed
228                          */
229                         p = current_kprobe;
230                         if (p->break_handler && p->break_handler(p, regs)) {
231                                 goto ss_probe;
232                         }
233                 }
234         }
235
236         lock_kprobes();
237         p = get_kprobe(addr);
238         if (!p) {
239                 unlock_kprobes();
240                 goto no_kprobe;
241         }
242
243         kprobe_status = KPROBE_HIT_ACTIVE;
244         current_kprobe = p;
245
246         if (p->pre_handler && p->pre_handler(p, regs))
247                 /*
248                  * Our pre-handler is specifically requesting that we just
249                  * do a return.  This is handling the case where the
250                  * pre-handler is really our special jprobe pre-handler.
251                  */
252                 return 1;
253
254 ss_probe:
255         prepare_ss(p, regs);
256         kprobe_status = KPROBE_HIT_SS;
257         return 1;
258
259 no_kprobe:
260         preempt_enable_no_resched();
261         return ret;
262 }
263
264 static int post_kprobes_handler(struct pt_regs *regs)
265 {
266         if (!kprobe_running())
267                 return 0;
268
269         if (current_kprobe->post_handler)
270                 current_kprobe->post_handler(current_kprobe, regs, 0);
271
272         resume_execution(current_kprobe, regs);
273
274         unlock_kprobes();
275         preempt_enable_no_resched();
276         return 1;
277 }
278
279 static int kprobes_fault_handler(struct pt_regs *regs, int trapnr)
280 {
281         if (!kprobe_running())
282                 return 0;
283
284         if (current_kprobe->fault_handler &&
285             current_kprobe->fault_handler(current_kprobe, regs, trapnr))
286                 return 1;
287
288         if (kprobe_status & KPROBE_HIT_SS) {
289                 resume_execution(current_kprobe, regs);
290                 unlock_kprobes();
291                 preempt_enable_no_resched();
292         }
293
294         return 0;
295 }
296
297 int kprobe_exceptions_notify(struct notifier_block *self, unsigned long val,
298                              void *data)
299 {
300         struct die_args *args = (struct die_args *)data;
301         switch(val) {
302         case DIE_BREAK:
303                 if (pre_kprobes_handler(args->regs))
304                         return NOTIFY_STOP;
305                 break;
306         case DIE_SS:
307                 if (post_kprobes_handler(args->regs))
308                         return NOTIFY_STOP;
309                 break;
310         case DIE_PAGE_FAULT:
311                 if (kprobes_fault_handler(args->regs, args->trapnr))
312                         return NOTIFY_STOP;
313         default:
314                 break;
315         }
316         return NOTIFY_DONE;
317 }
318
319 int setjmp_pre_handler(struct kprobe *p, struct pt_regs *regs)
320 {
321         printk(KERN_WARNING "Jprobes is not supported\n");
322         return 0;
323 }
324
325 void jprobe_return(void)
326 {
327 }
328
329 int longjmp_break_handler(struct kprobe *p, struct pt_regs *regs)
330 {
331         return 0;
332 }