hw-breakpoints: introducing generic hardware breakpoint handler interfaces
[linux-2.6.git] / kernel / hw_breakpoint.c
1 /*
2  * This program is free software; you can redistribute it and/or modify
3  * it under the terms of the GNU General Public License as published by
4  * the Free Software Foundation; either version 2 of the License, or
5  * (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software
14  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
15  *
16  * Copyright (C) 2007 Alan Stern
17  * Copyright (C) IBM Corporation, 2009
18  */
19
20 /*
21  * HW_breakpoint: a unified kernel/user-space hardware breakpoint facility,
22  * using the CPU's debug registers.
23  * This file contains the arch-independent routines.
24  */
25
26 #include <linux/irqflags.h>
27 #include <linux/kallsyms.h>
28 #include <linux/notifier.h>
29 #include <linux/kprobes.h>
30 #include <linux/kdebug.h>
31 #include <linux/kernel.h>
32 #include <linux/module.h>
33 #include <linux/percpu.h>
34 #include <linux/sched.h>
35 #include <linux/init.h>
36 #include <linux/smp.h>
37
38 #include <asm/hw_breakpoint.h>
39 #include <asm/processor.h>
40
41 #ifdef CONFIG_X86
42 #include <asm/debugreg.h>
43 #endif
44 /*
45  * Spinlock that protects all (un)register operations over kernel/user-space
46  * breakpoint requests
47  */
48 static DEFINE_SPINLOCK(hw_breakpoint_lock);
49
50 /* Array of kernel-space breakpoint structures */
51 struct hw_breakpoint *hbp_kernel[HBP_NUM];
52
53 /*
54  * Per-processor copy of hbp_kernel[]. Used only when hbp_kernel is being
55  * modified but we need the older copy to handle any hbp exceptions. It will
56  * sync with hbp_kernel[] value after updation is done through IPIs.
57  */
58 DEFINE_PER_CPU(struct hw_breakpoint*, this_hbp_kernel[HBP_NUM]);
59
60 /*
61  * Kernel breakpoints grow downwards, starting from HBP_NUM
62  * 'hbp_kernel_pos' denotes lowest numbered breakpoint register occupied for
63  * kernel-space request. We will initialise it here and not in an __init
64  * routine because load_debug_registers(), which uses this variable can be
65  * called very early during CPU initialisation.
66  */
67 unsigned int hbp_kernel_pos = HBP_NUM;
68
69 /*
70  * An array containing refcount of threads using a given bkpt register
71  * Accesses are synchronised by acquiring hw_breakpoint_lock
72  */
73 unsigned int hbp_user_refcount[HBP_NUM];
74
75 /*
76  * Load the debug registers during startup of a CPU.
77  */
78 void load_debug_registers(void)
79 {
80         unsigned long flags;
81         struct task_struct *tsk = current;
82
83         spin_lock_bh(&hw_breakpoint_lock);
84
85         /* Prevent IPIs for new kernel breakpoint updates */
86         local_irq_save(flags);
87         arch_update_kernel_hw_breakpoint(NULL);
88         local_irq_restore(flags);
89
90         if (test_tsk_thread_flag(tsk, TIF_DEBUG))
91                 arch_install_thread_hw_breakpoint(tsk);
92
93         spin_unlock_bh(&hw_breakpoint_lock);
94 }
95
96 /*
97  * Erase all the hardware breakpoint info associated with a thread.
98  *
99  * If tsk != current then tsk must not be usable (for example, a
100  * child being cleaned up from a failed fork).
101  */
102 void flush_thread_hw_breakpoint(struct task_struct *tsk)
103 {
104         int i;
105         struct thread_struct *thread = &(tsk->thread);
106
107         spin_lock_bh(&hw_breakpoint_lock);
108
109         /* The thread no longer has any breakpoints associated with it */
110         clear_tsk_thread_flag(tsk, TIF_DEBUG);
111         for (i = 0; i < HBP_NUM; i++) {
112                 if (thread->hbp[i]) {
113                         hbp_user_refcount[i]--;
114                         kfree(thread->hbp[i]);
115                         thread->hbp[i] = NULL;
116                 }
117         }
118
119         arch_flush_thread_hw_breakpoint(tsk);
120
121         /* Actually uninstall the breakpoints if necessary */
122         if (tsk == current)
123                 arch_uninstall_thread_hw_breakpoint();
124         spin_unlock_bh(&hw_breakpoint_lock);
125 }
126
127 /*
128  * Copy the hardware breakpoint info from a thread to its cloned child.
129  */
130 int copy_thread_hw_breakpoint(struct task_struct *tsk,
131                 struct task_struct *child, unsigned long clone_flags)
132 {
133         /*
134          * We will assume that breakpoint settings are not inherited
135          * and the child starts out with no debug registers set.
136          * But what about CLONE_PTRACE?
137          */
138         clear_tsk_thread_flag(child, TIF_DEBUG);
139
140         /* We will call flush routine since the debugregs are not inherited */
141         arch_flush_thread_hw_breakpoint(child);
142
143         return 0;
144 }
145
146 static int __register_user_hw_breakpoint(int pos, struct task_struct *tsk,
147                                         struct hw_breakpoint *bp)
148 {
149         struct thread_struct *thread = &(tsk->thread);
150         int rc;
151
152         /* Do not overcommit. Fail if kernel has used the hbp registers */
153         if (pos >= hbp_kernel_pos)
154                 return -ENOSPC;
155
156         rc = arch_validate_hwbkpt_settings(bp, tsk);
157         if (rc)
158                 return rc;
159
160         thread->hbp[pos] = bp;
161         hbp_user_refcount[pos]++;
162
163         arch_update_user_hw_breakpoint(pos, tsk);
164         /*
165          * Does it need to be installed right now?
166          * Otherwise it will get installed the next time tsk runs
167          */
168         if (tsk == current)
169                 arch_install_thread_hw_breakpoint(tsk);
170
171         return rc;
172 }
173
174 /*
175  * Modify the address of a hbp register already in use by the task
176  * Do not invoke this in-lieu of a __unregister_user_hw_breakpoint()
177  */
178 static int __modify_user_hw_breakpoint(int pos, struct task_struct *tsk,
179                                         struct hw_breakpoint *bp)
180 {
181         struct thread_struct *thread = &(tsk->thread);
182
183         if ((pos >= hbp_kernel_pos) || (arch_validate_hwbkpt_settings(bp, tsk)))
184                 return -EINVAL;
185
186         if (thread->hbp[pos] == NULL)
187                 return -EINVAL;
188
189         thread->hbp[pos] = bp;
190         /*
191          * 'pos' must be that of a hbp register already used by 'tsk'
192          * Otherwise arch_modify_user_hw_breakpoint() will fail
193          */
194         arch_update_user_hw_breakpoint(pos, tsk);
195
196         if (tsk == current)
197                 arch_install_thread_hw_breakpoint(tsk);
198
199         return 0;
200 }
201
202 static void __unregister_user_hw_breakpoint(int pos, struct task_struct *tsk)
203 {
204         hbp_user_refcount[pos]--;
205         tsk->thread.hbp[pos] = NULL;
206
207         arch_update_user_hw_breakpoint(pos, tsk);
208
209         if (tsk == current)
210                 arch_install_thread_hw_breakpoint(tsk);
211 }
212
213 /**
214  * register_user_hw_breakpoint - register a hardware breakpoint for user space
215  * @tsk: pointer to 'task_struct' of the process to which the address belongs
216  * @bp: the breakpoint structure to register
217  *
218  * @bp.info->name or @bp.info->address, @bp.info->len, @bp.info->type and
219  * @bp->triggered must be set properly before invocation
220  *
221  */
222 int register_user_hw_breakpoint(struct task_struct *tsk,
223                                         struct hw_breakpoint *bp)
224 {
225         struct thread_struct *thread = &(tsk->thread);
226         int i, rc = -ENOSPC;
227
228         spin_lock_bh(&hw_breakpoint_lock);
229
230         for (i = 0; i < hbp_kernel_pos; i++) {
231                 if (!thread->hbp[i]) {
232                         rc = __register_user_hw_breakpoint(i, tsk, bp);
233                         break;
234                 }
235         }
236         if (!rc)
237                 set_tsk_thread_flag(tsk, TIF_DEBUG);
238
239         spin_unlock_bh(&hw_breakpoint_lock);
240         return rc;
241 }
242 EXPORT_SYMBOL_GPL(register_user_hw_breakpoint);
243
244 /**
245  * modify_user_hw_breakpoint - modify a user-space hardware breakpoint
246  * @tsk: pointer to 'task_struct' of the process to which the address belongs
247  * @bp: the breakpoint structure to unregister
248  *
249  */
250 int modify_user_hw_breakpoint(struct task_struct *tsk, struct hw_breakpoint *bp)
251 {
252         struct thread_struct *thread = &(tsk->thread);
253         int i, ret = -ENOENT;
254
255         spin_lock_bh(&hw_breakpoint_lock);
256         for (i = 0; i < hbp_kernel_pos; i++) {
257                 if (bp == thread->hbp[i]) {
258                         ret = __modify_user_hw_breakpoint(i, tsk, bp);
259                         break;
260                 }
261         }
262         spin_unlock_bh(&hw_breakpoint_lock);
263         return ret;
264 }
265 EXPORT_SYMBOL_GPL(modify_user_hw_breakpoint);
266
267 /**
268  * unregister_user_hw_breakpoint - unregister a user-space hardware breakpoint
269  * @tsk: pointer to 'task_struct' of the process to which the address belongs
270  * @bp: the breakpoint structure to unregister
271  *
272  */
273 void unregister_user_hw_breakpoint(struct task_struct *tsk,
274                                                 struct hw_breakpoint *bp)
275 {
276         struct thread_struct *thread = &(tsk->thread);
277         int i, pos = -1, hbp_counter = 0;
278
279         spin_lock_bh(&hw_breakpoint_lock);
280         for (i = 0; i < hbp_kernel_pos; i++) {
281                 if (thread->hbp[i])
282                         hbp_counter++;
283                 if (bp == thread->hbp[i])
284                         pos = i;
285         }
286         if (pos >= 0) {
287                 __unregister_user_hw_breakpoint(pos, tsk);
288                 hbp_counter--;
289         }
290         if (!hbp_counter)
291                 clear_tsk_thread_flag(tsk, TIF_DEBUG);
292
293         spin_unlock_bh(&hw_breakpoint_lock);
294 }
295 EXPORT_SYMBOL_GPL(unregister_user_hw_breakpoint);
296
297 /**
298  * register_kernel_hw_breakpoint - register a hardware breakpoint for kernel space
299  * @bp: the breakpoint structure to register
300  *
301  * @bp.info->name or @bp.info->address, @bp.info->len, @bp.info->type and
302  * @bp->triggered must be set properly before invocation
303  *
304  */
305 int register_kernel_hw_breakpoint(struct hw_breakpoint *bp)
306 {
307         int rc;
308
309         rc = arch_validate_hwbkpt_settings(bp, NULL);
310         if (rc)
311                 return rc;
312
313         spin_lock_bh(&hw_breakpoint_lock);
314
315         rc = -ENOSPC;
316         /* Check if we are over-committing */
317         if ((hbp_kernel_pos > 0) && (!hbp_user_refcount[hbp_kernel_pos-1])) {
318                 hbp_kernel_pos--;
319                 hbp_kernel[hbp_kernel_pos] = bp;
320                 on_each_cpu(arch_update_kernel_hw_breakpoint, NULL, 1);
321                 rc = 0;
322         }
323
324         spin_unlock_bh(&hw_breakpoint_lock);
325         return rc;
326 }
327 EXPORT_SYMBOL_GPL(register_kernel_hw_breakpoint);
328
329 /**
330  * unregister_kernel_hw_breakpoint - unregister a HW breakpoint for kernel space
331  * @bp: the breakpoint structure to unregister
332  *
333  * Uninstalls and unregisters @bp.
334  */
335 void unregister_kernel_hw_breakpoint(struct hw_breakpoint *bp)
336 {
337         int i, j;
338
339         spin_lock_bh(&hw_breakpoint_lock);
340
341         /* Find the 'bp' in our list of breakpoints for kernel */
342         for (i = hbp_kernel_pos; i < HBP_NUM; i++)
343                 if (bp == hbp_kernel[i])
344                         break;
345
346         /* Check if we did not find a match for 'bp'. If so return early */
347         if (i == HBP_NUM) {
348                 spin_unlock_bh(&hw_breakpoint_lock);
349                 return;
350         }
351
352         /*
353          * We'll shift the breakpoints one-level above to compact if
354          * unregistration creates a hole
355          */
356         for (j = i; j > hbp_kernel_pos; j--)
357                 hbp_kernel[j] = hbp_kernel[j-1];
358
359         hbp_kernel[hbp_kernel_pos] = NULL;
360         on_each_cpu(arch_update_kernel_hw_breakpoint, NULL, 1);
361         hbp_kernel_pos++;
362
363         spin_unlock_bh(&hw_breakpoint_lock);
364 }
365 EXPORT_SYMBOL_GPL(unregister_kernel_hw_breakpoint);
366
367 static struct notifier_block hw_breakpoint_exceptions_nb = {
368         .notifier_call = hw_breakpoint_exceptions_notify,
369         /* we need to be notified first */
370         .priority = 0x7fffffff
371 };
372
373 static int __init init_hw_breakpoint(void)
374 {
375         return register_die_notifier(&hw_breakpoint_exceptions_nb);
376 }
377
378 core_initcall(init_hw_breakpoint);