[linux-block.git] / kernel / trace / trace_event_perf.c

// SPDX-License-Identifier: GPL-2.0
/*
 * trace event based perf event profiling/tracing
 *
 * Copyright (C) 2009 Red Hat Inc, Peter Zijlstra
 * Copyright (C) 2009-2010 Frederic Weisbecker <fweisbec@gmail.com>
 */

#include <linux/module.h>
#include <linux/kprobes.h>
#include <linux/security.h>
#include "trace.h"
#include "trace_probe.h"

static char __percpu *perf_trace_buf[PERF_NR_CONTEXTS];

/*
 * Force it to be aligned to unsigned long to avoid misaligned accesses
 * surprises
 */
typedef typeof(unsigned long [PERF_MAX_TRACE_SIZE / sizeof(unsigned long)])
	perf_trace_t;

/* Count the events in use (per event id, not per instance) */
static int	total_ref_count;

static int perf_trace_event_perm(struct trace_event_call *tp_event,
				 struct perf_event *p_event)
{
	int ret;

	if (tp_event->perf_perm) {
		ret = tp_event->perf_perm(tp_event, p_event);
		if (ret)
			return ret;
	}

	/*
	 * We checked and allowed to create parent,
	 * allow children without checking.
	 */
	if (p_event->parent)
		return 0;

	/*
	 * It's ok to check current process (owner) permissions in here,
	 * because code below is called only via perf_event_open syscall.
	 */

	/* The ftrace function trace is allowed only for root. */
	if (ftrace_event_is_function(tp_event)) {
		ret = perf_allow_tracepoint(&p_event->attr);
		if (ret)
			return ret;

		if (!is_sampling_event(p_event))
			return 0;

		/*
		 * We don't allow user space callchains for  function trace
		 * event, due to issues with page faults while tracing page
		 * fault handler and its overall trickiness nature.
		 */
		if (!p_event->attr.exclude_callchain_user)
			return -EINVAL;

		/*
		 * Same reason to disable user stack dump as for user space
		 * callchains above.
		 */
		if (p_event->attr.sample_type & PERF_SAMPLE_STACK_USER)
			return -EINVAL;
	}

	/* No tracing, just counting, so no obvious leak */
	if (!(p_event->attr.sample_type & PERF_SAMPLE_RAW))
		return 0;

	/* Some events are ok to be traced by non-root users... */
	if (p_event->attach_state == PERF_ATTACH_TASK) {
		if (tp_event->flags & TRACE_EVENT_FL_CAP_ANY)
			return 0;
	}

	/*
	 * ...otherwise raw tracepoint data can be a severe data leak,
	 * only allow root to have these.
	 */
	ret = perf_allow_tracepoint(&p_event->attr);
	if (ret)
		return ret;

	return 0;
}

static int perf_trace_event_reg(struct trace_event_call *tp_event,
				struct perf_event *p_event)
{
	struct hlist_head __percpu *list;
	int ret = -ENOMEM;
	int cpu;

	p_event->tp_event = tp_event;
	if (tp_event->perf_refcount++ > 0)
		return 0;

	list = alloc_percpu(struct hlist_head);
	if (!list)
		goto fail;

	for_each_possible_cpu(cpu)
		INIT_HLIST_HEAD(per_cpu_ptr(list, cpu));

	tp_event->perf_events = list;

	if (!total_ref_count) {
		char __percpu *buf;
		int i;

		for (i = 0; i < PERF_NR_CONTEXTS; i++) {
			buf = (char __percpu *)alloc_percpu(perf_trace_t);
			if (!buf)
				goto fail;

			perf_trace_buf[i] = buf;
		}
	}

	ret = tp_event->class->reg(tp_event, TRACE_REG_PERF_REGISTER, NULL);
	if (ret)
		goto fail;

	total_ref_count++;
	return 0;

fail:
	if (!total_ref_count) {
		int i;

		for (i = 0; i < PERF_NR_CONTEXTS; i++) {
			free_percpu(perf_trace_buf[i]);
			perf_trace_buf[i] = NULL;
		}
	}

	if (!--tp_event->perf_refcount) {
		free_percpu(tp_event->perf_events);
		tp_event->perf_events = NULL;
	}

	return ret;
}

static void perf_trace_event_unreg(struct perf_event *p_event)
{
	struct trace_event_call *tp_event = p_event->tp_event;
	int i;

	if (--tp_event->perf_refcount > 0)
		goto out;

	tp_event->class->reg(tp_event, TRACE_REG_PERF_UNREGISTER, NULL);

	/*
	 * Ensure our callback won't be called anymore. The buffers
	 * will be freed after that.
	 */
	tracepoint_synchronize_unregister();

	free_percpu(tp_event->perf_events);
	tp_event->perf_events = NULL;

	if (!--total_ref_count) {
		for (i = 0; i < PERF_NR_CONTEXTS; i++) {
			free_percpu(perf_trace_buf[i]);
			perf_trace_buf[i] = NULL;
		}
	}
out:
	module_put(tp_event->mod);
}

static int perf_trace_event_open(struct perf_event *p_event)
{
	struct trace_event_call *tp_event = p_event->tp_event;
	return tp_event->class->reg(tp_event, TRACE_REG_PERF_OPEN, p_event);
}

static void perf_trace_event_close(struct perf_event *p_event)
{
	struct trace_event_call *tp_event = p_event->tp_event;
	tp_event->class->reg(tp_event, TRACE_REG_PERF_CLOSE, p_event);
}

static int perf_trace_event_init(struct trace_event_call *tp_event,
				 struct perf_event *p_event)
{
	int ret;

	ret = perf_trace_event_perm(tp_event, p_event);
	if (ret)
		return ret;

	ret = perf_trace_event_reg(tp_event, p_event);
	if (ret)
		return ret;

	ret = perf_trace_event_open(p_event);
	if (ret) {
		perf_trace_event_unreg(p_event);
		return ret;
	}

	return 0;
}

int perf_trace_init(struct perf_event *p_event)
{
	struct trace_event_call *tp_event;
	u64 event_id = p_event->attr.config;
	int ret = -EINVAL;

	mutex_lock(&event_mutex);
	list_for_each_entry(tp_event, &ftrace_events, list) {
		if (tp_event->event.type == event_id &&
		    tp_event->class && tp_event->class->reg &&
		    try_module_get(tp_event->mod)) {
			ret = perf_trace_event_init(tp_event, p_event);
			if (ret)
				module_put(tp_event->mod);
			break;
		}
	}
	mutex_unlock(&event_mutex);

	return ret;
}

void perf_trace_destroy(struct perf_event *p_event)
{
	mutex_lock(&event_mutex);
	perf_trace_event_close(p_event);
	perf_trace_event_unreg(p_event);
	mutex_unlock(&event_mutex);
}

#ifdef CONFIG_KPROBE_EVENTS
int perf_kprobe_init(struct perf_event *p_event, bool is_retprobe)
{
	int ret;
	char *func = NULL;
	struct trace_event_call *tp_event;

	if (p_event->attr.kprobe_func) {
		func = kzalloc(KSYM_NAME_LEN, GFP_KERNEL);
		if (!func)
			return -ENOMEM;
		ret = strncpy_from_user(
			func, u64_to_user_ptr(p_event->attr.kprobe_func),
			KSYM_NAME_LEN);
		if (ret == KSYM_NAME_LEN)
			ret = -E2BIG;
		if (ret < 0)
			goto out;

		if (func[0] == '\0') {
			kfree(func);
			func = NULL;
		}
	}

	tp_event = create_local_trace_kprobe(
		func, (void *)(unsigned long)(p_event->attr.kprobe_addr),
		p_event->attr.probe_offset, is_retprobe);
	if (IS_ERR(tp_event)) {
		ret = PTR_ERR(tp_event);
		goto out;
	}

	mutex_lock(&event_mutex);
	ret = perf_trace_event_init(tp_event, p_event);
	if (ret)
		destroy_local_trace_kprobe(tp_event);
	mutex_unlock(&event_mutex);
out:
	kfree(func);
	return ret;
}

void perf_kprobe_destroy(struct perf_event *p_event)
{
	mutex_lock(&event_mutex);
	perf_trace_event_close(p_event);
	perf_trace_event_unreg(p_event);
	mutex_unlock(&event_mutex);

	destroy_local_trace_kprobe(p_event->tp_event);
}
#endif /* CONFIG_KPROBE_EVENTS */

#ifdef CONFIG_UPROBE_EVENTS
int perf_uprobe_init(struct perf_event *p_event,
		     unsigned long ref_ctr_offset, bool is_retprobe)
{
	int ret;
	char *path = NULL;
	struct trace_event_call *tp_event;

	if (!p_event->attr.uprobe_path)
		return -EINVAL;

	path = strndup_user(u64_to_user_ptr(p_event->attr.uprobe_path),
			    PATH_MAX);
	if (IS_ERR(path)) {
		ret = PTR_ERR(path);
		return (ret == -EINVAL) ? -E2BIG : ret;
	}
	if (path[0] == '\0') {
		ret = -EINVAL;
		goto out;
	}

	tp_event = create_local_trace_uprobe(path, p_event->attr.probe_offset,
					     ref_ctr_offset, is_retprobe);
	if (IS_ERR(tp_event)) {
		ret = PTR_ERR(tp_event);
		goto out;
	}

	/*
	 * local trace_uprobe need to hold event_mutex to call
	 * uprobe_buffer_enable() and uprobe_buffer_disable().
	 * event_mutex is not required for local trace_kprobes.
	 */
	mutex_lock(&event_mutex);
	ret = perf_trace_event_init(tp_event, p_event);
	if (ret)
		destroy_local_trace_uprobe(tp_event);
	mutex_unlock(&event_mutex);
out:
	kfree(path);
	return ret;
}

void perf_uprobe_destroy(struct perf_event *p_event)
{
	mutex_lock(&event_mutex);
	perf_trace_event_close(p_event);
	perf_trace_event_unreg(p_event);
	mutex_unlock(&event_mutex);
	destroy_local_trace_uprobe(p_event->tp_event);
}
#endif /* CONFIG_UPROBE_EVENTS */

int perf_trace_add(struct perf_event *p_event, int flags)
{
	struct trace_event_call *tp_event = p_event->tp_event;

	if (!(flags & PERF_EF_START))
		p_event->hw.state = PERF_HES_STOPPED;

	/*
	 * If TRACE_REG_PERF_ADD returns false; no custom action was performed
	 * and we need to take the default action of enqueueing our event on
	 * the right per-cpu hlist.
	 */
	if (!tp_event->class->reg(tp_event, TRACE_REG_PERF_ADD, p_event)) {
		struct hlist_head __percpu *pcpu_list;
		struct hlist_head *list;

		pcpu_list = tp_event->perf_events;
		if (WARN_ON_ONCE(!pcpu_list))
			return -EINVAL;

		list = this_cpu_ptr(pcpu_list);
		hlist_add_head_rcu(&p_event->hlist_entry, list);
	}

	return 0;
}

void perf_trace_del(struct perf_event *p_event, int flags)
{
	struct trace_event_call *tp_event = p_event->tp_event;

	/*
	 * If TRACE_REG_PERF_DEL returns false; no custom action was performed
	 * and we need to take the default action of dequeueing our event from
	 * the right per-cpu hlist.
	 */
	if (!tp_event->class->reg(tp_event, TRACE_REG_PERF_DEL, p_event))
		hlist_del_rcu(&p_event->hlist_entry);
}

void *perf_trace_buf_alloc(int size, struct pt_regs **regs, int *rctxp)
{
	char *raw_data;
	int rctx;

	BUILD_BUG_ON(PERF_MAX_TRACE_SIZE % sizeof(unsigned long));

	if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE,
		      "perf buffer not large enough"))
		return NULL;

	*rctxp = rctx = perf_swevent_get_recursion_context();
	if (rctx < 0)
		return NULL;

	if (regs)
		*regs = this_cpu_ptr(&__perf_regs[rctx]);
	raw_data = this_cpu_ptr(perf_trace_buf[rctx]);

	/* zero the dead bytes from align to not leak stack to user */
	memset(&raw_data[size - sizeof(u64)], 0, sizeof(u64));
	return raw_data;
}
EXPORT_SYMBOL_GPL(perf_trace_buf_alloc);
NOKPROBE_SYMBOL(perf_trace_buf_alloc);

void perf_trace_buf_update(void *record, u16 type)
{
	struct trace_entry *entry = record;

	tracing_generic_entry_update(entry, type, tracing_gen_ctx());
}
NOKPROBE_SYMBOL(perf_trace_buf_update);

#ifdef CONFIG_FUNCTION_TRACER
static void
perf_ftrace_function_call(unsigned long ip, unsigned long parent_ip,
			  struct ftrace_ops *ops,  struct ftrace_regs *fregs)
{
	struct ftrace_entry *entry;
	struct perf_event *event;
	struct hlist_head head;
	struct pt_regs regs;
	int rctx;
	int bit;

	if (!rcu_is_watching())
		return;

	if ((unsigned long)ops->private != smp_processor_id())
		return;

	bit = ftrace_test_recursion_trylock(ip, parent_ip);
	if (bit < 0)
		return;

	event = container_of(ops, struct perf_event, ftrace_ops);

	/*
	 * @event->hlist entry is NULL (per INIT_HLIST_NODE), and all
	 * the perf code does is hlist_for_each_entry_rcu(), so we can
	 * get away with simply setting the @head.first pointer in order
	 * to create a singular list.
	 */
	head.first = &event->hlist_entry;

#define ENTRY_SIZE (ALIGN(sizeof(struct ftrace_entry) + sizeof(u32), \
		    sizeof(u64)) - sizeof(u32))

	BUILD_BUG_ON(ENTRY_SIZE > PERF_MAX_TRACE_SIZE);

	memset(&regs, 0, sizeof(regs));
	perf_fetch_caller_regs(&regs);

	entry = perf_trace_buf_alloc(ENTRY_SIZE, NULL, &rctx);
	if (!entry)
		goto out;

	entry->ip = ip;
	entry->parent_ip = parent_ip;
	perf_trace_buf_submit(entry, ENTRY_SIZE, rctx, TRACE_FN,
			      1, &regs, &head, NULL);

out:
	ftrace_test_recursion_unlock(bit);
#undef ENTRY_SIZE
}

static int perf_ftrace_function_register(struct perf_event *event)
{
	struct ftrace_ops *ops = &event->ftrace_ops;

	ops->func    = perf_ftrace_function_call;
	ops->private = (void *)(unsigned long)nr_cpu_ids;

	return register_ftrace_function(ops);
}

static int perf_ftrace_function_unregister(struct perf_event *event)
{
	struct ftrace_ops *ops = &event->ftrace_ops;
	int ret = unregister_ftrace_function(ops);
	ftrace_free_filter(ops);
	return ret;
}

int perf_ftrace_event_register(struct trace_event_call *call,
			       enum trace_reg type, void *data)
{
	struct perf_event *event = data;

	switch (type) {
	case TRACE_REG_REGISTER:
	case TRACE_REG_UNREGISTER:
		break;
	case TRACE_REG_PERF_REGISTER:
	case TRACE_REG_PERF_UNREGISTER:
		return 0;
	case TRACE_REG_PERF_OPEN:
		return perf_ftrace_function_register(data);
	case TRACE_REG_PERF_CLOSE:
		return perf_ftrace_function_unregister(data);
	case TRACE_REG_PERF_ADD:
		event->ftrace_ops.private = (void *)(unsigned long)smp_processor_id();
		return 1;
	case TRACE_REG_PERF_DEL:
		event->ftrace_ops.private = (void *)(unsigned long)nr_cpu_ids;
		return 1;
	}

	return -EINVAL;
}
#endif /* CONFIG_FUNCTION_TRACER */
Commit	Line	Data
bcea3f96	1	// SPDX-License-Identifier: GPL-2.0
ac199db0	2	/*
97d5a220	3	* trace event based perf event profiling/tracing
ac199db0	4	*
90eec103	5	* Copyright (C) 2009 Red Hat Inc, Peter Zijlstra
c530665c	6	* Copyright (C) 2009-2010 Frederic Weisbecker <fweisbec@gmail.com>
ac199db0 PZ	7	*/
ac199db0 PZ	8
558e6547	9	#include <linux/module.h>
430ad5a6	10	#include <linux/kprobes.h>
da97e184	11	#include <linux/security.h>
ac199db0	12	#include "trace.h"
e12f03d7	13	#include "trace_probe.h"
ac199db0	14
6016ee13	15	static char __percpu *perf_trace_buf[PERF_NR_CONTEXTS];
20ab4425	16
eb1e7961 FW	17	/*
eb1e7961 FW	18	* Force it to be aligned to unsigned long to avoid misaligned accesses
f2cc020d	19	* surprises
eb1e7961 FW	20	*/
	21	typedef typeof(unsigned long [PERF_MAX_TRACE_SIZE / sizeof(unsigned long)])
	22	perf_trace_t;
ce71b9df	23
20ab4425	24	/* Count the events in use (per event id, not per instance) */
97d5a220	25	static int total_ref_count;
20ab4425	26
2425bcb9	27	static int perf_trace_event_perm(struct trace_event_call *tp_event,
61c32659 FW	28	struct perf_event *p_event)
61c32659 FW	29	{
da97e184 JFG	30	int ret;
da97e184 JFG	31
d5b5f391	32	if (tp_event->perf_perm) {
da97e184	33	ret = tp_event->perf_perm(tp_event, p_event);
d5b5f391 PZ	34	if (ret)
	35	return ret;
	36	}
	37
f4be073d JO	38	/*
	39	* We checked and allowed to create parent,
	40	* allow children without checking.
	41	*/
	42	if (p_event->parent)
	43	return 0;
	44
	45	/*
	46	* It's ok to check current process (owner) permissions in here,
	47	* because code below is called only via perf_event_open syscall.
	48	*/
	49
ced39002	50	/* The ftrace function trace is allowed only for root. */
cfa77bc4	51	if (ftrace_event_is_function(tp_event)) {
da97e184 JFG	52	ret = perf_allow_tracepoint(&p_event->attr);
	53	if (ret)
	54	return ret;
cfa77bc4	55
0a74c5b3 JO	56	if (!is_sampling_event(p_event))
	57	return 0;
	58
cfa77bc4 JO	59	/*
	60	* We don't allow user space callchains for function trace
	61	* event, due to issues with page faults while tracing page
	62	* fault handler and its overall trickiness nature.
	63	*/
	64	if (!p_event->attr.exclude_callchain_user)
	65	return -EINVAL;
63c45f4b JO	66
	67	/*
	68	* Same reason to disable user stack dump as for user space
	69	* callchains above.
	70	*/
	71	if (p_event->attr.sample_type & PERF_SAMPLE_STACK_USER)
	72	return -EINVAL;
cfa77bc4	73	}
ced39002	74
61c32659 FW	75	/* No tracing, just counting, so no obvious leak */
	76	if (!(p_event->attr.sample_type & PERF_SAMPLE_RAW))
	77	return 0;
	78
	79	/* Some events are ok to be traced by non-root users... */
	80	if (p_event->attach_state == PERF_ATTACH_TASK) {
	81	if (tp_event->flags & TRACE_EVENT_FL_CAP_ANY)
	82	return 0;
	83	}
	84
	85	/*
	86	* ...otherwise raw tracepoint data can be a severe data leak,
	87	* only allow root to have these.
	88	*/
da97e184 JFG	89	ret = perf_allow_tracepoint(&p_event->attr);
	90	if (ret)
	91	return ret;
61c32659 FW	92
	93	return 0;
	94	}
	95
2425bcb9	96	static int perf_trace_event_reg(struct trace_event_call *tp_event,
ceec0b6f	97	struct perf_event *p_event)
e5e25cf4	98	{
6016ee13	99	struct hlist_head __percpu *list;
ceec0b6f	100	int ret = -ENOMEM;
1c024eca	101	int cpu;
20ab4425	102
1c024eca PZ	103	p_event->tp_event = tp_event;
1c024eca PZ	104	if (tp_event->perf_refcount++ > 0)
e5e25cf4 FW	105	return 0;
e5e25cf4 FW	106
1c024eca PZ	107	list = alloc_percpu(struct hlist_head);
	108	if (!list)
	109	goto fail;
	110
	111	for_each_possible_cpu(cpu)
	112	INIT_HLIST_HEAD(per_cpu_ptr(list, cpu));
20ab4425	113
1c024eca	114	tp_event->perf_events = list;
e5e25cf4	115
97d5a220	116	if (!total_ref_count) {
6016ee13	117	char __percpu *buf;
b7e2ecef	118	int i;
20ab4425	119
7ae07ea3	120	for (i = 0; i < PERF_NR_CONTEXTS; i++) {
6016ee13	121	buf = (char __percpu *)alloc_percpu(perf_trace_t);
b7e2ecef	122	if (!buf)
1c024eca	123	goto fail;
20ab4425	124
1c024eca	125	perf_trace_buf[i] = buf;
b7e2ecef	126	}
20ab4425 FW	127	}
20ab4425 FW	128
ceec0b6f	129	ret = tp_event->class->reg(tp_event, TRACE_REG_PERF_REGISTER, NULL);
1c024eca PZ	130	if (ret)
1c024eca PZ	131	goto fail;
20ab4425	132
1c024eca PZ	133	total_ref_count++;
	134	return 0;
	135
	136	fail:
97d5a220	137	if (!total_ref_count) {
b7e2ecef PZ	138	int i;
b7e2ecef PZ	139
7ae07ea3	140	for (i = 0; i < PERF_NR_CONTEXTS; i++) {
b7e2ecef PZ	141	free_percpu(perf_trace_buf[i]);
	142	perf_trace_buf[i] = NULL;
	143	}
fe8e5b5a	144	}
1c024eca PZ	145
	146	if (!--tp_event->perf_refcount) {
	147	free_percpu(tp_event->perf_events);
	148	tp_event->perf_events = NULL;
fe8e5b5a	149	}
20ab4425 FW	150
20ab4425 FW	151	return ret;
e5e25cf4 FW	152	}
e5e25cf4 FW	153
ceec0b6f JO	154	static void perf_trace_event_unreg(struct perf_event *p_event)
ceec0b6f JO	155	{
2425bcb9	156	struct trace_event_call *tp_event = p_event->tp_event;
ceec0b6f JO	157	int i;
	158
	159	if (--tp_event->perf_refcount > 0)
	160	goto out;
	161
	162	tp_event->class->reg(tp_event, TRACE_REG_PERF_UNREGISTER, NULL);
	163
	164	/*
	165	* Ensure our callback won't be called anymore. The buffers
	166	* will be freed after that.
	167	*/
	168	tracepoint_synchronize_unregister();
	169
	170	free_percpu(tp_event->perf_events);
	171	tp_event->perf_events = NULL;
	172
	173	if (!--total_ref_count) {
	174	for (i = 0; i < PERF_NR_CONTEXTS; i++) {
	175	free_percpu(perf_trace_buf[i]);
	176	perf_trace_buf[i] = NULL;
	177	}
	178	}
	179	out:
	180	module_put(tp_event->mod);
	181	}
	182
	183	static int perf_trace_event_open(struct perf_event *p_event)
	184	{
2425bcb9	185	struct trace_event_call *tp_event = p_event->tp_event;
ceec0b6f JO	186	return tp_event->class->reg(tp_event, TRACE_REG_PERF_OPEN, p_event);
	187	}
	188
	189	static void perf_trace_event_close(struct perf_event *p_event)
	190	{
2425bcb9	191	struct trace_event_call *tp_event = p_event->tp_event;
ceec0b6f JO	192	tp_event->class->reg(tp_event, TRACE_REG_PERF_CLOSE, p_event);
	193	}
	194
2425bcb9	195	static int perf_trace_event_init(struct trace_event_call *tp_event,
ceec0b6f JO	196	struct perf_event *p_event)
	197	{
	198	int ret;
	199
	200	ret = perf_trace_event_perm(tp_event, p_event);
	201	if (ret)
	202	return ret;
	203
	204	ret = perf_trace_event_reg(tp_event, p_event);
	205	if (ret)
	206	return ret;
	207
	208	ret = perf_trace_event_open(p_event);
	209	if (ret) {
	210	perf_trace_event_unreg(p_event);
	211	return ret;
	212	}
	213
	214	return 0;
	215	}
	216
1c024eca	217	int perf_trace_init(struct perf_event *p_event)
ac199db0	218	{
2425bcb9	219	struct trace_event_call *tp_event;
0022cedd	220	u64 event_id = p_event->attr.config;
20c8928a	221	int ret = -EINVAL;
ac199db0	222
20c8928a	223	mutex_lock(&event_mutex);
1c024eca	224	list_for_each_entry(tp_event, &ftrace_events, list) {
ff5f149b	225	if (tp_event->event.type == event_id &&
a1d0ce82	226	tp_event->class && tp_event->class->reg &&
1c024eca PZ	227	try_module_get(tp_event->mod)) {
1c024eca PZ	228	ret = perf_trace_event_init(tp_event, p_event);
9cb627d5 LZ	229	if (ret)
9cb627d5 LZ	230	module_put(tp_event->mod);
20c8928a LZ	231	break;
20c8928a LZ	232	}
ac199db0	233	}
20c8928a	234	mutex_unlock(&event_mutex);
ac199db0	235
20c8928a	236	return ret;
ac199db0 PZ	237	}
ac199db0 PZ	238
ceec0b6f JO	239	void perf_trace_destroy(struct perf_event *p_event)
	240	{
	241	mutex_lock(&event_mutex);
	242	perf_trace_event_close(p_event);
	243	perf_trace_event_unreg(p_event);
	244	mutex_unlock(&event_mutex);
	245	}
	246
e12f03d7 SL	247	#ifdef CONFIG_KPROBE_EVENTS
	248	int perf_kprobe_init(struct perf_event *p_event, bool is_retprobe)
	249	{
	250	int ret;
	251	char *func = NULL;
	252	struct trace_event_call *tp_event;
	253
	254	if (p_event->attr.kprobe_func) {
	255	func = kzalloc(KSYM_NAME_LEN, GFP_KERNEL);
	256	if (!func)
	257	return -ENOMEM;
	258	ret = strncpy_from_user(
	259	func, u64_to_user_ptr(p_event->attr.kprobe_func),
	260	KSYM_NAME_LEN);
5da13ab8 MH	261	if (ret == KSYM_NAME_LEN)
5da13ab8 MH	262	ret = -E2BIG;
e12f03d7 SL	263	if (ret < 0)
	264	goto out;
	265
	266	if (func[0] == '\0') {
	267	kfree(func);
	268	func = NULL;
	269	}
	270	}
	271
	272	tp_event = create_local_trace_kprobe(
	273	func, (void *)(unsigned long)(p_event->attr.kprobe_addr),
	274	p_event->attr.probe_offset, is_retprobe);
	275	if (IS_ERR(tp_event)) {
	276	ret = PTR_ERR(tp_event);
	277	goto out;
	278	}
	279
6b1340cc	280	mutex_lock(&event_mutex);
e12f03d7 SL	281	ret = perf_trace_event_init(tp_event, p_event);
	282	if (ret)
	283	destroy_local_trace_kprobe(tp_event);
6b1340cc	284	mutex_unlock(&event_mutex);
e12f03d7 SL	285	out:
	286	kfree(func);
	287	return ret;
	288	}
	289
	290	void perf_kprobe_destroy(struct perf_event *p_event)
	291	{
6b1340cc	292	mutex_lock(&event_mutex);
e12f03d7 SL	293	perf_trace_event_close(p_event);
e12f03d7 SL	294	perf_trace_event_unreg(p_event);
6b1340cc	295	mutex_unlock(&event_mutex);
e12f03d7 SL	296
	297	destroy_local_trace_kprobe(p_event->tp_event);
	298	}
	299	#endif /* CONFIG_KPROBE_EVENTS */
	300
33ea4b24	301	#ifdef CONFIG_UPROBE_EVENTS
a6ca88b2 SL	302	int perf_uprobe_init(struct perf_event *p_event,
a6ca88b2 SL	303	unsigned long ref_ctr_offset, bool is_retprobe)
33ea4b24 SL	304	{
	305	int ret;
	306	char *path = NULL;
	307	struct trace_event_call *tp_event;
	308
	309	if (!p_event->attr.uprobe_path)
	310	return -EINVAL;
83540fbc JH	311
	312	path = strndup_user(u64_to_user_ptr(p_event->attr.uprobe_path),
	313	PATH_MAX);
	314	if (IS_ERR(path)) {
	315	ret = PTR_ERR(path);
	316	return (ret == -EINVAL) ? -E2BIG : ret;
	317	}
33ea4b24 SL	318	if (path[0] == '\0') {
	319	ret = -EINVAL;
	320	goto out;
	321	}
	322
a6ca88b2 SL	323	tp_event = create_local_trace_uprobe(path, p_event->attr.probe_offset,
a6ca88b2 SL	324	ref_ctr_offset, is_retprobe);
33ea4b24 SL	325	if (IS_ERR(tp_event)) {
	326	ret = PTR_ERR(tp_event);
	327	goto out;
	328	}
	329
	330	/*
	331	* local trace_uprobe need to hold event_mutex to call
	332	* uprobe_buffer_enable() and uprobe_buffer_disable().
	333	* event_mutex is not required for local trace_kprobes.
	334	*/
	335	mutex_lock(&event_mutex);
	336	ret = perf_trace_event_init(tp_event, p_event);
	337	if (ret)
	338	destroy_local_trace_uprobe(tp_event);
	339	mutex_unlock(&event_mutex);
	340	out:
	341	kfree(path);
	342	return ret;
	343	}
	344
	345	void perf_uprobe_destroy(struct perf_event *p_event)
	346	{
	347	mutex_lock(&event_mutex);
	348	perf_trace_event_close(p_event);
	349	perf_trace_event_unreg(p_event);
	350	mutex_unlock(&event_mutex);
	351	destroy_local_trace_uprobe(p_event->tp_event);
	352	}
	353	#endif /* CONFIG_UPROBE_EVENTS */
	354
a4eaf7f1	355	int perf_trace_add(struct perf_event *p_event, int flags)
e5e25cf4	356	{
2425bcb9	357	struct trace_event_call *tp_event = p_event->tp_event;
20ab4425	358
a4eaf7f1 PZ	359	if (!(flags & PERF_EF_START))
	360	p_event->hw.state = PERF_HES_STOPPED;
	361
466c81c4 PZ	362	/*
	363	* If TRACE_REG_PERF_ADD returns false; no custom action was performed
	364	* and we need to take the default action of enqueueing our event on
	365	* the right per-cpu hlist.
	366	*/
	367	if (!tp_event->class->reg(tp_event, TRACE_REG_PERF_ADD, p_event)) {
	368	struct hlist_head __percpu *pcpu_list;
	369	struct hlist_head *list;
	370
	371	pcpu_list = tp_event->perf_events;
	372	if (WARN_ON_ONCE(!pcpu_list))
	373	return -EINVAL;
	374
	375	list = this_cpu_ptr(pcpu_list);
	376	hlist_add_head_rcu(&p_event->hlist_entry, list);
	377	}
20ab4425	378
466c81c4	379	return 0;
1c024eca	380	}
20ab4425	381
a4eaf7f1	382	void perf_trace_del(struct perf_event *p_event, int flags)
1c024eca	383	{
2425bcb9	384	struct trace_event_call *tp_event = p_event->tp_event;
466c81c4 PZ	385
	386	/*
	387	* If TRACE_REG_PERF_DEL returns false; no custom action was performed
	388	* and we need to take the default action of dequeueing our event from
	389	* the right per-cpu hlist.
	390	*/
	391	if (!tp_event->class->reg(tp_event, TRACE_REG_PERF_DEL, p_event))
	392	hlist_del_rcu(&p_event->hlist_entry);
e5e25cf4 FW	393	}
e5e25cf4 FW	394
1e1dcd93	395	void perf_trace_buf_alloc(int size, struct pt_regs regs, int rctxp)
430ad5a6	396	{
1c024eca	397	char *raw_data;
1e1dcd93	398	int rctx;
430ad5a6	399
eb1e7961 FW	400	BUILD_BUG_ON(PERF_MAX_TRACE_SIZE % sizeof(unsigned long));
eb1e7961 FW	401
cd92bf61	402	if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE,
1e1dcd93	403	"perf buffer not large enough"))
cd92bf61 ON	404	return NULL;
cd92bf61 ON	405
1e1dcd93 AS	406	*rctxp = rctx = perf_swevent_get_recursion_context();
1e1dcd93 AS	407	if (rctx < 0)
1c024eca	408	return NULL;
430ad5a6	409
86038c5e	410	if (regs)
1e1dcd93 AS	411	*regs = this_cpu_ptr(&__perf_regs[rctx]);
1e1dcd93 AS	412	raw_data = this_cpu_ptr(perf_trace_buf[rctx]);
430ad5a6 XG	413
430ad5a6 XG	414	/* zero the dead bytes from align to not leak stack to user */
eb1e7961	415	memset(&raw_data[size - sizeof(u64)], 0, sizeof(u64));
1e1dcd93 AS	416	return raw_data;
	417	}
	418	EXPORT_SYMBOL_GPL(perf_trace_buf_alloc);
	419	NOKPROBE_SYMBOL(perf_trace_buf_alloc);
	420
	421	void perf_trace_buf_update(void *record, u16 type)
	422	{
	423	struct trace_entry *entry = record;
430ad5a6	424
36590c50	425	tracing_generic_entry_update(entry, type, tracing_gen_ctx());
430ad5a6	426	}
1e1dcd93	427	NOKPROBE_SYMBOL(perf_trace_buf_update);
ced39002 JO	428
	429	#ifdef CONFIG_FUNCTION_TRACER
	430	static void
2f5f6ad9	431	perf_ftrace_function_call(unsigned long ip, unsigned long parent_ip,
d19ad077	432	struct ftrace_ops ops, struct ftrace_regs fregs)
ced39002 JO	433	{
ced39002 JO	434	struct ftrace_entry *entry;
466c81c4 PZ	435	struct perf_event *event;
466c81c4 PZ	436	struct hlist_head head;
ced39002 JO	437	struct pt_regs regs;
ced39002 JO	438	int rctx;
5d15a624	439	int bit;
ced39002	440
5d029b03 SRV	441	if (!rcu_is_watching())
	442	return;
	443
466c81c4	444	if ((unsigned long)ops->private != smp_processor_id())
b8ebfd3f ON	445	return;
b8ebfd3f ON	446
773c1670	447	bit = ftrace_test_recursion_trylock(ip, parent_ip);
5d15a624 SRV	448	if (bit < 0)
	449	return;
	450
466c81c4 PZ	451	event = container_of(ops, struct perf_event, ftrace_ops);
	452
	453	/*
	454	* @event->hlist entry is NULL (per INIT_HLIST_NODE), and all
	455	* the perf code does is hlist_for_each_entry_rcu(), so we can
	456	* get away with simply setting the @head.first pointer in order
	457	* to create a singular list.
	458	*/
	459	head.first = &event->hlist_entry;
	460
ced39002 JO	461	#define ENTRY_SIZE (ALIGN(sizeof(struct ftrace_entry) + sizeof(u32), \
	462	sizeof(u64)) - sizeof(u32))
	463
	464	BUILD_BUG_ON(ENTRY_SIZE > PERF_MAX_TRACE_SIZE);
	465
ec5e099d	466	memset(&regs, 0, sizeof(regs));
ced39002 JO	467	perf_fetch_caller_regs(&regs);
ced39002 JO	468
1e1dcd93	469	entry = perf_trace_buf_alloc(ENTRY_SIZE, NULL, &rctx);
ced39002	470	if (!entry)
5d15a624	471	goto out;
ced39002 JO	472
	473	entry->ip = ip;
	474	entry->parent_ip = parent_ip;
1e1dcd93	475	perf_trace_buf_submit(entry, ENTRY_SIZE, rctx, TRACE_FN,
466c81c4	476	1, &regs, &head, NULL);
ced39002	477
5d15a624 SRV	478	out:
5d15a624 SRV	479	ftrace_test_recursion_unlock(bit);
ced39002 JO	480	#undef ENTRY_SIZE
	481	}
	482
	483	static int perf_ftrace_function_register(struct perf_event *event)
	484	{
	485	struct ftrace_ops *ops = &event->ftrace_ops;
	486
466c81c4 PZ	487	ops->func = perf_ftrace_function_call;
	488	ops->private = (void *)(unsigned long)nr_cpu_ids;
	489
ced39002 JO	490	return register_ftrace_function(ops);
	491	}
	492
	493	static int perf_ftrace_function_unregister(struct perf_event *event)
	494	{
	495	struct ftrace_ops *ops = &event->ftrace_ops;
5500fa51 JO	496	int ret = unregister_ftrace_function(ops);
	497	ftrace_free_filter(ops);
	498	return ret;
ced39002 JO	499	}
ced39002 JO	500
2425bcb9	501	int perf_ftrace_event_register(struct trace_event_call *call,
ced39002 JO	502	enum trace_reg type, void *data)
ced39002 JO	503	{
466c81c4 PZ	504	struct perf_event *event = data;
466c81c4 PZ	505
ced39002 JO	506	switch (type) {
	507	case TRACE_REG_REGISTER:
	508	case TRACE_REG_UNREGISTER:
	509	break;
	510	case TRACE_REG_PERF_REGISTER:
	511	case TRACE_REG_PERF_UNREGISTER:
	512	return 0;
	513	case TRACE_REG_PERF_OPEN:
	514	return perf_ftrace_function_register(data);
	515	case TRACE_REG_PERF_CLOSE:
	516	return perf_ftrace_function_unregister(data);
	517	case TRACE_REG_PERF_ADD:
466c81c4 PZ	518	event->ftrace_ops.private = (void *)(unsigned long)smp_processor_id();
466c81c4 PZ	519	return 1;
ced39002	520	case TRACE_REG_PERF_DEL:
466c81c4 PZ	521	event->ftrace_ops.private = (void *)(unsigned long)nr_cpu_ids;
466c81c4 PZ	522	return 1;
ced39002 JO	523	}
	524
	525	return -EINVAL;
	526	}
	527	#endif /* CONFIG_FUNCTION_TRACER */