Merge git://git.kernel.org/pub/scm/linux/kernel/git/lethal/sh-2.6
[linux-2.6.git] / arch / sh / kernel / hw_breakpoint.c
1 /*
2  * arch/sh/kernel/hw_breakpoint.c
3  *
4  * Unified kernel/user-space hardware breakpoint facility for the on-chip UBC.
5  *
6  * Copyright (C) 2009 - 2010  Paul Mundt
7  *
8  * This file is subject to the terms and conditions of the GNU General Public
9  * License.  See the file "COPYING" in the main directory of this archive
10  * for more details.
11  */
12 #include <linux/init.h>
13 #include <linux/perf_event.h>
14 #include <linux/hw_breakpoint.h>
15 #include <linux/percpu.h>
16 #include <linux/kallsyms.h>
17 #include <linux/notifier.h>
18 #include <linux/kprobes.h>
19 #include <linux/kdebug.h>
20 #include <linux/io.h>
21 #include <linux/clk.h>
22 #include <asm/hw_breakpoint.h>
23 #include <asm/mmu_context.h>
24 #include <asm/ptrace.h>
25
26 /*
27  * Stores the breakpoints currently in use on each breakpoint address
28  * register for each cpus
29  */
30 static DEFINE_PER_CPU(struct perf_event *, bp_per_reg[HBP_NUM]);
31
32 /*
33  * A dummy placeholder for early accesses until the CPUs get a chance to
34  * register their UBCs later in the boot process.
35  */
36 static struct sh_ubc ubc_dummy = { .num_events = 0 };
37
38 static struct sh_ubc *sh_ubc __read_mostly = &ubc_dummy;
39
40 /*
41  * Install a perf counter breakpoint.
42  *
43  * We seek a free UBC channel and use it for this breakpoint.
44  *
45  * Atomic: we hold the counter->ctx->lock and we only handle variables
46  * and registers local to this cpu.
47  */
48 int arch_install_hw_breakpoint(struct perf_event *bp)
49 {
50         struct arch_hw_breakpoint *info = counter_arch_bp(bp);
51         int i;
52
53         for (i = 0; i < sh_ubc->num_events; i++) {
54                 struct perf_event **slot = &__get_cpu_var(bp_per_reg[i]);
55
56                 if (!*slot) {
57                         *slot = bp;
58                         break;
59                 }
60         }
61
62         if (WARN_ONCE(i == sh_ubc->num_events, "Can't find any breakpoint slot"))
63                 return -EBUSY;
64
65         clk_enable(sh_ubc->clk);
66         sh_ubc->enable(info, i);
67
68         return 0;
69 }
70
71 /*
72  * Uninstall the breakpoint contained in the given counter.
73  *
74  * First we search the debug address register it uses and then we disable
75  * it.
76  *
77  * Atomic: we hold the counter->ctx->lock and we only handle variables
78  * and registers local to this cpu.
79  */
80 void arch_uninstall_hw_breakpoint(struct perf_event *bp)
81 {
82         struct arch_hw_breakpoint *info = counter_arch_bp(bp);
83         int i;
84
85         for (i = 0; i < sh_ubc->num_events; i++) {
86                 struct perf_event **slot = &__get_cpu_var(bp_per_reg[i]);
87
88                 if (*slot == bp) {
89                         *slot = NULL;
90                         break;
91                 }
92         }
93
94         if (WARN_ONCE(i == sh_ubc->num_events, "Can't find any breakpoint slot"))
95                 return;
96
97         sh_ubc->disable(info, i);
98         clk_disable(sh_ubc->clk);
99 }
100
101 static int get_hbp_len(u16 hbp_len)
102 {
103         unsigned int len_in_bytes = 0;
104
105         switch (hbp_len) {
106         case SH_BREAKPOINT_LEN_1:
107                 len_in_bytes = 1;
108                 break;
109         case SH_BREAKPOINT_LEN_2:
110                 len_in_bytes = 2;
111                 break;
112         case SH_BREAKPOINT_LEN_4:
113                 len_in_bytes = 4;
114                 break;
115         case SH_BREAKPOINT_LEN_8:
116                 len_in_bytes = 8;
117                 break;
118         }
119         return len_in_bytes;
120 }
121
122 /*
123  * Check for virtual address in kernel space.
124  */
125 int arch_check_bp_in_kernelspace(struct perf_event *bp)
126 {
127         unsigned int len;
128         unsigned long va;
129         struct arch_hw_breakpoint *info = counter_arch_bp(bp);
130
131         va = info->address;
132         len = get_hbp_len(info->len);
133
134         return (va >= TASK_SIZE) && ((va + len - 1) >= TASK_SIZE);
135 }
136
137 int arch_bp_generic_fields(int sh_len, int sh_type,
138                            int *gen_len, int *gen_type)
139 {
140         /* Len */
141         switch (sh_len) {
142         case SH_BREAKPOINT_LEN_1:
143                 *gen_len = HW_BREAKPOINT_LEN_1;
144                 break;
145         case SH_BREAKPOINT_LEN_2:
146                 *gen_len = HW_BREAKPOINT_LEN_2;
147                 break;
148         case SH_BREAKPOINT_LEN_4:
149                 *gen_len = HW_BREAKPOINT_LEN_4;
150                 break;
151         case SH_BREAKPOINT_LEN_8:
152                 *gen_len = HW_BREAKPOINT_LEN_8;
153                 break;
154         default:
155                 return -EINVAL;
156         }
157
158         /* Type */
159         switch (sh_type) {
160         case SH_BREAKPOINT_READ:
161                 *gen_type = HW_BREAKPOINT_R;
162         case SH_BREAKPOINT_WRITE:
163                 *gen_type = HW_BREAKPOINT_W;
164                 break;
165         case SH_BREAKPOINT_RW:
166                 *gen_type = HW_BREAKPOINT_W | HW_BREAKPOINT_R;
167                 break;
168         default:
169                 return -EINVAL;
170         }
171
172         return 0;
173 }
174
175 static int arch_build_bp_info(struct perf_event *bp)
176 {
177         struct arch_hw_breakpoint *info = counter_arch_bp(bp);
178
179         info->address = bp->attr.bp_addr;
180
181         /* Len */
182         switch (bp->attr.bp_len) {
183         case HW_BREAKPOINT_LEN_1:
184                 info->len = SH_BREAKPOINT_LEN_1;
185                 break;
186         case HW_BREAKPOINT_LEN_2:
187                 info->len = SH_BREAKPOINT_LEN_2;
188                 break;
189         case HW_BREAKPOINT_LEN_4:
190                 info->len = SH_BREAKPOINT_LEN_4;
191                 break;
192         case HW_BREAKPOINT_LEN_8:
193                 info->len = SH_BREAKPOINT_LEN_8;
194                 break;
195         default:
196                 return -EINVAL;
197         }
198
199         /* Type */
200         switch (bp->attr.bp_type) {
201         case HW_BREAKPOINT_R:
202                 info->type = SH_BREAKPOINT_READ;
203                 break;
204         case HW_BREAKPOINT_W:
205                 info->type = SH_BREAKPOINT_WRITE;
206                 break;
207         case HW_BREAKPOINT_W | HW_BREAKPOINT_R:
208                 info->type = SH_BREAKPOINT_RW;
209                 break;
210         default:
211                 return -EINVAL;
212         }
213
214         return 0;
215 }
216
217 /*
218  * Validate the arch-specific HW Breakpoint register settings
219  */
220 int arch_validate_hwbkpt_settings(struct perf_event *bp)
221 {
222         struct arch_hw_breakpoint *info = counter_arch_bp(bp);
223         unsigned int align;
224         int ret;
225
226         ret = arch_build_bp_info(bp);
227         if (ret)
228                 return ret;
229
230         ret = -EINVAL;
231
232         switch (info->len) {
233         case SH_BREAKPOINT_LEN_1:
234                 align = 0;
235                 break;
236         case SH_BREAKPOINT_LEN_2:
237                 align = 1;
238                 break;
239         case SH_BREAKPOINT_LEN_4:
240                 align = 3;
241                 break;
242         case SH_BREAKPOINT_LEN_8:
243                 align = 7;
244                 break;
245         default:
246                 return ret;
247         }
248
249         /*
250          * For kernel-addresses, either the address or symbol name can be
251          * specified.
252          */
253         if (info->name)
254                 info->address = (unsigned long)kallsyms_lookup_name(info->name);
255
256         /*
257          * Check that the low-order bits of the address are appropriate
258          * for the alignment implied by len.
259          */
260         if (info->address & align)
261                 return -EINVAL;
262
263         return 0;
264 }
265
266 /*
267  * Release the user breakpoints used by ptrace
268  */
269 void flush_ptrace_hw_breakpoint(struct task_struct *tsk)
270 {
271         int i;
272         struct thread_struct *t = &tsk->thread;
273
274         for (i = 0; i < sh_ubc->num_events; i++) {
275                 unregister_hw_breakpoint(t->ptrace_bps[i]);
276                 t->ptrace_bps[i] = NULL;
277         }
278 }
279
280 static int __kprobes hw_breakpoint_handler(struct die_args *args)
281 {
282         int cpu, i, rc = NOTIFY_STOP;
283         struct perf_event *bp;
284         unsigned int cmf, resume_mask;
285
286         /*
287          * Do an early return if none of the channels triggered.
288          */
289         cmf = sh_ubc->triggered_mask();
290         if (unlikely(!cmf))
291                 return NOTIFY_DONE;
292
293         /*
294          * By default, resume all of the active channels.
295          */
296         resume_mask = sh_ubc->active_mask();
297
298         /*
299          * Disable breakpoints during exception handling.
300          */
301         sh_ubc->disable_all();
302
303         cpu = get_cpu();
304         for (i = 0; i < sh_ubc->num_events; i++) {
305                 unsigned long event_mask = (1 << i);
306
307                 if (likely(!(cmf & event_mask)))
308                         continue;
309
310                 /*
311                  * The counter may be concurrently released but that can only
312                  * occur from a call_rcu() path. We can then safely fetch
313                  * the breakpoint, use its callback, touch its counter
314                  * while we are in an rcu_read_lock() path.
315                  */
316                 rcu_read_lock();
317
318                 bp = per_cpu(bp_per_reg[i], cpu);
319                 if (bp)
320                         rc = NOTIFY_DONE;
321
322                 /*
323                  * Reset the condition match flag to denote completion of
324                  * exception handling.
325                  */
326                 sh_ubc->clear_triggered_mask(event_mask);
327
328                 /*
329                  * bp can be NULL due to concurrent perf counter
330                  * removing.
331                  */
332                 if (!bp) {
333                         rcu_read_unlock();
334                         break;
335                 }
336
337                 /*
338                  * Don't restore the channel if the breakpoint is from
339                  * ptrace, as it always operates in one-shot mode.
340                  */
341                 if (bp->overflow_handler == ptrace_triggered)
342                         resume_mask &= ~(1 << i);
343
344                 perf_bp_event(bp, args->regs);
345
346                 /* Deliver the signal to userspace */
347                 if (!arch_check_bp_in_kernelspace(bp)) {
348                         siginfo_t info;
349
350                         info.si_signo = args->signr;
351                         info.si_errno = notifier_to_errno(rc);
352                         info.si_code = TRAP_HWBKPT;
353
354                         force_sig_info(args->signr, &info, current);
355                 }
356
357                 rcu_read_unlock();
358         }
359
360         if (cmf == 0)
361                 rc = NOTIFY_DONE;
362
363         sh_ubc->enable_all(resume_mask);
364
365         put_cpu();
366
367         return rc;
368 }
369
370 BUILD_TRAP_HANDLER(breakpoint)
371 {
372         unsigned long ex = lookup_exception_vector();
373         TRAP_HANDLER_DECL;
374
375         notify_die(DIE_BREAKPOINT, "breakpoint", regs, 0, ex, SIGTRAP);
376 }
377
378 /*
379  * Handle debug exception notifications.
380  */
381 int __kprobes hw_breakpoint_exceptions_notify(struct notifier_block *unused,
382                                     unsigned long val, void *data)
383 {
384         struct die_args *args = data;
385
386         if (val != DIE_BREAKPOINT)
387                 return NOTIFY_DONE;
388
389         /*
390          * If the breakpoint hasn't been triggered by the UBC, it's
391          * probably from a debugger, so don't do anything more here.
392          *
393          * This also permits the UBC interface clock to remain off for
394          * non-UBC breakpoints, as we don't need to check the triggered
395          * or active channel masks.
396          */
397         if (args->trapnr != sh_ubc->trap_nr)
398                 return NOTIFY_DONE;
399
400         return hw_breakpoint_handler(data);
401 }
402
403 void hw_breakpoint_pmu_read(struct perf_event *bp)
404 {
405         /* TODO */
406 }
407
408 int register_sh_ubc(struct sh_ubc *ubc)
409 {
410         /* Bail if it's already assigned */
411         if (sh_ubc != &ubc_dummy)
412                 return -EBUSY;
413         sh_ubc = ubc;
414
415         pr_info("HW Breakpoints: %s UBC support registered\n", ubc->name);
416
417         WARN_ON(ubc->num_events > HBP_NUM);
418
419         return 0;
420 }