~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/sh/kernel/hw_breakpoint.c

Version: ~ [ linux-5.11 ] ~ [ linux-5.10.17 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.99 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.176 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.221 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.257 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.257 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp