2009-06-01 12:13:33 -06:00
|
|
|
/*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2007 Alan Stern
|
|
|
|
* Copyright (C) IBM Corporation, 2009
|
2009-09-09 11:22:48 -06:00
|
|
|
* Copyright (C) 2009, Frederic Weisbecker <fweisbec@gmail.com>
|
2009-06-01 12:13:33 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* HW_breakpoint: a unified kernel/user-space hardware breakpoint facility,
|
|
|
|
* using the CPU's debug registers.
|
|
|
|
* This file contains the arch-independent routines.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/irqflags.h>
|
|
|
|
#include <linux/kallsyms.h>
|
|
|
|
#include <linux/notifier.h>
|
|
|
|
#include <linux/kprobes.h>
|
|
|
|
#include <linux/kdebug.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/percpu.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
#include <linux/hw_breakpoint.h>
|
|
|
|
|
2009-06-01 12:13:33 -06:00
|
|
|
#include <asm/processor.h>
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86
|
|
|
|
#include <asm/debugreg.h>
|
|
|
|
#endif
|
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
static atomic_t bp_slot;
|
2009-06-01 12:13:33 -06:00
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
int reserve_bp_slot(struct perf_event *bp)
|
2009-06-01 12:13:33 -06:00
|
|
|
{
|
2009-09-09 11:22:48 -06:00
|
|
|
if (atomic_inc_return(&bp_slot) == HBP_NUM) {
|
|
|
|
atomic_dec(&bp_slot);
|
2009-06-01 12:13:33 -06:00
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
return -ENOSPC;
|
2009-06-01 12:13:33 -06:00
|
|
|
}
|
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
return 0;
|
2009-06-01 12:13:33 -06:00
|
|
|
}
|
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
void release_bp_slot(struct perf_event *bp)
|
2009-06-01 12:13:33 -06:00
|
|
|
{
|
2009-09-09 11:22:48 -06:00
|
|
|
atomic_dec(&bp_slot);
|
2009-06-01 12:13:33 -06:00
|
|
|
}
|
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
int __register_perf_hw_breakpoint(struct perf_event *bp)
|
2009-06-01 12:13:33 -06:00
|
|
|
{
|
2009-09-09 11:22:48 -06:00
|
|
|
int ret;
|
2009-06-01 12:13:33 -06:00
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
ret = reserve_bp_slot(bp);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2009-06-01 12:13:33 -06:00
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
if (!bp->attr.disabled)
|
|
|
|
ret = arch_validate_hwbkpt_settings(bp, bp->ctx->task);
|
2009-06-01 12:13:33 -06:00
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
return ret;
|
|
|
|
}
|
2009-06-01 12:13:33 -06:00
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
int register_perf_hw_breakpoint(struct perf_event *bp)
|
|
|
|
{
|
|
|
|
bp->callback = perf_bp_event;
|
2009-06-01 12:13:33 -06:00
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
return __register_perf_hw_breakpoint(bp);
|
2009-06-01 12:13:33 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2009-09-09 11:22:48 -06:00
|
|
|
* Register a breakpoint bound to a task and a given cpu.
|
|
|
|
* If cpu is -1, the breakpoint is active for the task in every cpu
|
|
|
|
* If the task is -1, the breakpoint is active for every tasks in the given
|
|
|
|
* cpu.
|
2009-06-01 12:13:33 -06:00
|
|
|
*/
|
2009-09-09 11:22:48 -06:00
|
|
|
static struct perf_event *
|
|
|
|
register_user_hw_breakpoint_cpu(unsigned long addr,
|
|
|
|
int len,
|
|
|
|
int type,
|
|
|
|
perf_callback_t triggered,
|
|
|
|
pid_t pid,
|
|
|
|
int cpu,
|
|
|
|
bool active)
|
2009-06-01 12:13:33 -06:00
|
|
|
{
|
2009-09-09 11:22:48 -06:00
|
|
|
struct perf_event_attr *attr;
|
|
|
|
struct perf_event *bp;
|
|
|
|
|
|
|
|
attr = kzalloc(sizeof(*attr), GFP_KERNEL);
|
|
|
|
if (!attr)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
attr->type = PERF_TYPE_BREAKPOINT;
|
|
|
|
attr->size = sizeof(*attr);
|
|
|
|
attr->bp_addr = addr;
|
|
|
|
attr->bp_len = len;
|
|
|
|
attr->bp_type = type;
|
2009-06-01 12:13:33 -06:00
|
|
|
/*
|
2009-09-09 11:22:48 -06:00
|
|
|
* Such breakpoints are used by debuggers to trigger signals when
|
|
|
|
* we hit the excepted memory op. We can't miss such events, they
|
|
|
|
* must be pinned.
|
2009-06-01 12:13:33 -06:00
|
|
|
*/
|
2009-09-09 11:22:48 -06:00
|
|
|
attr->pinned = 1;
|
2009-06-01 12:13:33 -06:00
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
if (!active)
|
|
|
|
attr->disabled = 1;
|
2009-06-01 12:13:33 -06:00
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
bp = perf_event_create_kernel_counter(attr, cpu, pid, triggered);
|
|
|
|
kfree(attr);
|
2009-06-01 12:13:33 -06:00
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
return bp;
|
2009-06-01 12:13:33 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* register_user_hw_breakpoint - register a hardware breakpoint for user space
|
2009-09-09 11:22:48 -06:00
|
|
|
* @addr: is the memory address that triggers the breakpoint
|
|
|
|
* @len: the length of the access to the memory (1 byte, 2 bytes etc...)
|
|
|
|
* @type: the type of the access to the memory (read/write/exec)
|
|
|
|
* @triggered: callback to trigger when we hit the breakpoint
|
2009-06-01 12:13:33 -06:00
|
|
|
* @tsk: pointer to 'task_struct' of the process to which the address belongs
|
2009-09-09 11:22:48 -06:00
|
|
|
* @active: should we activate it while registering it
|
2009-06-01 12:13:33 -06:00
|
|
|
*
|
|
|
|
*/
|
2009-09-09 11:22:48 -06:00
|
|
|
struct perf_event *
|
|
|
|
register_user_hw_breakpoint(unsigned long addr,
|
|
|
|
int len,
|
|
|
|
int type,
|
|
|
|
perf_callback_t triggered,
|
|
|
|
struct task_struct *tsk,
|
|
|
|
bool active)
|
2009-06-01 12:13:33 -06:00
|
|
|
{
|
2009-09-09 11:22:48 -06:00
|
|
|
return register_user_hw_breakpoint_cpu(addr, len, type, triggered,
|
|
|
|
tsk->pid, -1, active);
|
2009-06-01 12:13:33 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(register_user_hw_breakpoint);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* modify_user_hw_breakpoint - modify a user-space hardware breakpoint
|
2009-09-09 11:22:48 -06:00
|
|
|
* @bp: the breakpoint structure to modify
|
|
|
|
* @addr: is the memory address that triggers the breakpoint
|
|
|
|
* @len: the length of the access to the memory (1 byte, 2 bytes etc...)
|
|
|
|
* @type: the type of the access to the memory (read/write/exec)
|
|
|
|
* @triggered: callback to trigger when we hit the breakpoint
|
2009-06-01 12:13:33 -06:00
|
|
|
* @tsk: pointer to 'task_struct' of the process to which the address belongs
|
2009-09-09 11:22:48 -06:00
|
|
|
* @active: should we activate it while registering it
|
2009-06-01 12:13:33 -06:00
|
|
|
*/
|
2009-09-09 11:22:48 -06:00
|
|
|
struct perf_event *
|
|
|
|
modify_user_hw_breakpoint(struct perf_event *bp,
|
|
|
|
unsigned long addr,
|
|
|
|
int len,
|
|
|
|
int type,
|
|
|
|
perf_callback_t triggered,
|
|
|
|
struct task_struct *tsk,
|
|
|
|
bool active)
|
2009-06-01 12:13:33 -06:00
|
|
|
{
|
2009-09-09 11:22:48 -06:00
|
|
|
/*
|
|
|
|
* FIXME: do it without unregistering
|
|
|
|
* - We don't want to lose our slot
|
|
|
|
* - If the new bp is incorrect, don't lose the older one
|
|
|
|
*/
|
|
|
|
unregister_hw_breakpoint(bp);
|
2009-06-01 12:13:33 -06:00
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
return register_user_hw_breakpoint(addr, len, type, triggered,
|
|
|
|
tsk, active);
|
2009-06-01 12:13:33 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(modify_user_hw_breakpoint);
|
|
|
|
|
|
|
|
/**
|
2009-09-09 11:22:48 -06:00
|
|
|
* unregister_hw_breakpoint - unregister a user-space hardware breakpoint
|
2009-06-01 12:13:33 -06:00
|
|
|
* @bp: the breakpoint structure to unregister
|
|
|
|
*/
|
2009-09-09 11:22:48 -06:00
|
|
|
void unregister_hw_breakpoint(struct perf_event *bp)
|
2009-06-01 12:13:33 -06:00
|
|
|
{
|
2009-09-09 11:22:48 -06:00
|
|
|
if (!bp)
|
|
|
|
return;
|
|
|
|
perf_event_release_kernel(bp);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(unregister_hw_breakpoint);
|
|
|
|
|
|
|
|
static struct perf_event *
|
|
|
|
register_kernel_hw_breakpoint_cpu(unsigned long addr,
|
|
|
|
int len,
|
|
|
|
int type,
|
|
|
|
perf_callback_t triggered,
|
|
|
|
int cpu,
|
|
|
|
bool active)
|
|
|
|
{
|
|
|
|
return register_user_hw_breakpoint_cpu(addr, len, type, triggered,
|
|
|
|
-1, cpu, active);
|
2009-06-01 12:13:33 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-09-09 11:22:48 -06:00
|
|
|
* register_wide_hw_breakpoint - register a wide breakpoint in the kernel
|
|
|
|
* @addr: is the memory address that triggers the breakpoint
|
|
|
|
* @len: the length of the access to the memory (1 byte, 2 bytes etc...)
|
|
|
|
* @type: the type of the access to the memory (read/write/exec)
|
|
|
|
* @triggered: callback to trigger when we hit the breakpoint
|
|
|
|
* @active: should we activate it while registering it
|
2009-06-01 12:13:33 -06:00
|
|
|
*
|
2009-09-09 11:22:48 -06:00
|
|
|
* @return a set of per_cpu pointers to perf events
|
2009-06-01 12:13:33 -06:00
|
|
|
*/
|
2009-09-09 11:22:48 -06:00
|
|
|
struct perf_event **
|
|
|
|
register_wide_hw_breakpoint(unsigned long addr,
|
|
|
|
int len,
|
|
|
|
int type,
|
|
|
|
perf_callback_t triggered,
|
|
|
|
bool active)
|
2009-06-01 12:13:33 -06:00
|
|
|
{
|
2009-09-09 11:22:48 -06:00
|
|
|
struct perf_event **cpu_events, **pevent, *bp;
|
|
|
|
long err;
|
|
|
|
int cpu;
|
|
|
|
|
|
|
|
cpu_events = alloc_percpu(typeof(*cpu_events));
|
|
|
|
if (!cpu_events)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
2009-06-01 12:13:33 -06:00
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
pevent = per_cpu_ptr(cpu_events, cpu);
|
|
|
|
bp = register_kernel_hw_breakpoint_cpu(addr, len, type,
|
|
|
|
triggered, cpu, active);
|
2009-06-01 12:13:33 -06:00
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
*pevent = bp;
|
2009-06-01 12:13:33 -06:00
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
if (IS_ERR(bp) || !bp) {
|
|
|
|
err = PTR_ERR(bp);
|
|
|
|
goto fail;
|
|
|
|
}
|
2009-06-01 12:13:33 -06:00
|
|
|
}
|
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
return cpu_events;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
pevent = per_cpu_ptr(cpu_events, cpu);
|
|
|
|
if (IS_ERR(*pevent) || !*pevent)
|
|
|
|
break;
|
|
|
|
unregister_hw_breakpoint(*pevent);
|
|
|
|
}
|
|
|
|
free_percpu(cpu_events);
|
|
|
|
/* return the error if any */
|
|
|
|
return ERR_PTR(err);
|
2009-06-01 12:13:33 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-09-09 11:22:48 -06:00
|
|
|
* unregister_wide_hw_breakpoint - unregister a wide breakpoint in the kernel
|
|
|
|
* @cpu_events: the per cpu set of events to unregister
|
2009-06-01 12:13:33 -06:00
|
|
|
*/
|
2009-09-09 11:22:48 -06:00
|
|
|
void unregister_wide_hw_breakpoint(struct perf_event **cpu_events)
|
2009-06-01 12:13:33 -06:00
|
|
|
{
|
2009-09-09 11:22:48 -06:00
|
|
|
int cpu;
|
|
|
|
struct perf_event **pevent;
|
2009-06-01 12:13:33 -06:00
|
|
|
|
2009-09-09 11:22:48 -06:00
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
pevent = per_cpu_ptr(cpu_events, cpu);
|
|
|
|
unregister_hw_breakpoint(*pevent);
|
2009-06-01 12:13:33 -06:00
|
|
|
}
|
2009-09-09 11:22:48 -06:00
|
|
|
free_percpu(cpu_events);
|
2009-06-01 12:13:33 -06:00
|
|
|
}
|
2009-09-09 11:22:48 -06:00
|
|
|
|
2009-06-01 12:13:33 -06:00
|
|
|
|
|
|
|
static struct notifier_block hw_breakpoint_exceptions_nb = {
|
|
|
|
.notifier_call = hw_breakpoint_exceptions_notify,
|
|
|
|
/* we need to be notified first */
|
|
|
|
.priority = 0x7fffffff
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init init_hw_breakpoint(void)
|
|
|
|
{
|
|
|
|
return register_die_notifier(&hw_breakpoint_exceptions_nb);
|
|
|
|
}
|
|
|
|
core_initcall(init_hw_breakpoint);
|
2009-09-09 11:22:48 -06:00
|
|
|
|
|
|
|
|
|
|
|
struct pmu perf_ops_bp = {
|
|
|
|
.enable = arch_install_hw_breakpoint,
|
|
|
|
.disable = arch_uninstall_hw_breakpoint,
|
|
|
|
.read = hw_breakpoint_pmu_read,
|
|
|
|
.unthrottle = hw_breakpoint_pmu_unthrottle
|
|
|
|
};
|