Skip to content
Navigation Menu
Toggle navigation
Sign in
In this repository
All GitHub Enterprise
↵
Jump to
↵
No suggested jump to results
In this repository
All GitHub Enterprise
↵
Jump to
↵
In this organization
All GitHub Enterprise
↵
Jump to
↵
In this repository
All GitHub Enterprise
↵
Jump to
↵
Sign in
Reseting focus
You signed in with another tab or window.
Reload
to refresh your session.
You signed out in another tab or window.
Reload
to refresh your session.
You switched accounts on another tab or window.
Reload
to refresh your session.
Dismiss alert
{{ message }}
mariux64
/
linux
Public
Notifications
You must be signed in to change notification settings
Fork
0
Star
0
Code
Issues
2
Pull requests
0
Actions
Projects
0
Wiki
Security
Insights
Additional navigation options
Code
Issues
Pull requests
Actions
Projects
Wiki
Security
Insights
Files
752be5c
Documentation
LICENSES
arch
block
certs
crypto
drivers
fs
include
init
io_uring
ipc
kernel
bpf
cgroup
configs
debug
dma
entry
events
futex
gcov
irq
kcsan
livepatch
locking
module
power
printk
rcu
sched
time
trace
rv
Kconfig
Makefile
blktrace.c
bpf_trace.c
bpf_trace.h
error_report-traces.c
fgraph.c
fprobe.c
ftrace.c
ftrace_internal.h
kprobe_event_gen_test.c
pid_list.c
pid_list.h
power-traces.c
preemptirq_delay_test.c
rethook.c
ring_buffer.c
ring_buffer_benchmark.c
rpm-traces.c
synth_event_gen_test.c
trace.c
trace.h
trace_benchmark.c
trace_benchmark.h
trace_boot.c
trace_branch.c
trace_clock.c
trace_dynevent.c
trace_dynevent.h
trace_entries.h
trace_eprobe.c
trace_event_perf.c
trace_events.c
trace_events_filter.c
trace_events_filter_test.h
trace_events_hist.c
trace_events_inject.c
trace_events_synth.c
trace_events_trigger.c
trace_events_user.c
trace_export.c
trace_functions.c
trace_functions_graph.c
trace_hwlat.c
trace_irqsoff.c
trace_kdb.c
trace_kprobe.c
trace_kprobe_selftest.c
trace_kprobe_selftest.h
trace_mmiotrace.c
trace_nop.c
trace_osnoise.c
trace_output.c
trace_output.h
trace_preemptirq.c
trace_printk.c
trace_probe.c
trace_probe.h
trace_probe_tmpl.h
trace_recursion_record.c
trace_sched_switch.c
trace_sched_wakeup.c
trace_selftest.c
trace_selftest_dynamic.c
trace_seq.c
trace_stack.c
trace_stat.c
trace_stat.h
trace_synth.h
trace_syscalls.c
trace_uprobe.c
tracing_map.c
tracing_map.h
.gitignore
Kconfig.freezer
Kconfig.hz
Kconfig.locks
Kconfig.preempt
Makefile
acct.c
async.c
audit.c
audit.h
audit_fsnotify.c
audit_tree.c
audit_watch.c
auditfilter.c
auditsc.c
backtracetest.c
bounds.c
capability.c
cfi.c
compat.c
configs.c
context_tracking.c
cpu.c
cpu_pm.c
crash_core.c
crash_dump.c
cred.c
delayacct.c
dma.c
exec_domain.c
exit.c
extable.c
fail_function.c
fork.c
freezer.c
gen_kheaders.sh
groups.c
hung_task.c
iomem.c
irq_work.c
jump_label.c
kallsyms.c
kallsyms_internal.h
kcmp.c
kcov.c
kexec.c
kexec_core.c
kexec_elf.c
kexec_file.c
kexec_internal.h
kheaders.c
kmod.c
kprobes.c
ksysfs.c
kthread.c
latencytop.c
module_signature.c
notifier.c
nsproxy.c
padata.c
panic.c
params.c
pid.c
pid_namespace.c
profile.c
ptrace.c
range.c
reboot.c
regset.c
relay.c
resource.c
resource_kunit.c
rseq.c
scftorture.c
scs.c
seccomp.c
signal.c
smp.c
smpboot.c
smpboot.h
softirq.c
stackleak.c
stacktrace.c
static_call.c
static_call_inline.c
stop_machine.c
sys.c
sys_ni.c
sysctl-test.c
sysctl.c
task_work.c
taskstats.c
torture.c
tracepoint.c
tsacct.c
ucount.c
uid16.c
uid16.h
umh.c
up.c
user-return-notifier.c
user.c
user_namespace.c
usermode_driver.c
utsname.c
utsname_sysctl.c
watch_queue.c
watchdog.c
watchdog_hld.c
workqueue.c
workqueue_internal.h
lib
mm
net
samples
scripts
security
sound
tools
usr
virt
.clang-format
.cocciconfig
.get_maintainer.ignore
.gitattributes
.gitignore
.mailmap
COPYING
CREDITS
Kbuild
Kconfig
MAINTAINERS
Makefile
README
Breadcrumbs
linux
/
kernel
/
trace
/
trace_eprobe.c
Blame
Blame
Latest commit
History
History
1125 lines (946 loc) · 25.6 KB
Breadcrumbs
linux
/
kernel
/
trace
/
trace_eprobe.c
Top
File metadata and controls
Code
Blame
1125 lines (946 loc) · 25.6 KB
Raw
// SPDX-License-Identifier: GPL-2.0 /* * event probes * * Part of this code was copied from kernel/trace/trace_kprobe.c written by * Masami Hiramatsu <mhiramat@kernel.org> * * Copyright (C) 2021, VMware Inc, Steven Rostedt <rostedt@goodmis.org> * Copyright (C) 2021, VMware Inc, Tzvetomir Stoyanov tz.stoyanov@gmail.com> * */ #include <linux/module.h> #include <linux/mutex.h> #include <linux/ftrace.h> #include "trace_dynevent.h" #include "trace_probe.h" #include "trace_probe_tmpl.h" #define EPROBE_EVENT_SYSTEM "eprobes" struct trace_eprobe { /* tracepoint system */ const char *event_system; /* tracepoint event */ const char *event_name; /* filter string for the tracepoint */ char *filter_str; struct trace_event_call *event; struct dyn_event devent; struct trace_probe tp; }; struct eprobe_data { struct trace_event_file *file; struct trace_eprobe *ep; }; static int __trace_eprobe_create(int argc, const char *argv[]); static void trace_event_probe_cleanup(struct trace_eprobe *ep) { if (!ep) return; trace_probe_cleanup(&ep->tp); kfree(ep->event_name); kfree(ep->event_system); if (ep->event) trace_event_put_ref(ep->event); kfree(ep); } static struct trace_eprobe *to_trace_eprobe(struct dyn_event *ev) { return container_of(ev, struct trace_eprobe, devent); } static int eprobe_dyn_event_create(const char *raw_command) { return trace_probe_create(raw_command, __trace_eprobe_create); } static int eprobe_dyn_event_show(struct seq_file *m, struct dyn_event *ev) { struct trace_eprobe *ep = to_trace_eprobe(ev); int i; seq_printf(m, "e:%s/%s", trace_probe_group_name(&ep->tp), trace_probe_name(&ep->tp)); seq_printf(m, " %s.%s", ep->event_system, ep->event_name); for (i = 0; i < ep->tp.nr_args; i++) seq_printf(m, " %s=%s", ep->tp.args[i].name, ep->tp.args[i].comm); seq_putc(m, '\n'); return 0; } static int unregister_trace_eprobe(struct trace_eprobe *ep) { /* If other probes are on the event, just unregister eprobe */ if (trace_probe_has_sibling(&ep->tp)) goto unreg; /* Enabled event can not be unregistered */ if (trace_probe_is_enabled(&ep->tp)) return -EBUSY; /* Will fail if probe is being used by ftrace or perf */ if (trace_probe_unregister_event_call(&ep->tp)) return -EBUSY; unreg: dyn_event_remove(&ep->devent); trace_probe_unlink(&ep->tp); return 0; } static int eprobe_dyn_event_release(struct dyn_event *ev) { struct trace_eprobe *ep = to_trace_eprobe(ev); int ret = unregister_trace_eprobe(ep); if (!ret) trace_event_probe_cleanup(ep); return ret; } static bool eprobe_dyn_event_is_busy(struct dyn_event *ev) { struct trace_eprobe *ep = to_trace_eprobe(ev); return trace_probe_is_enabled(&ep->tp); } static bool eprobe_dyn_event_match(const char *system, const char *event, int argc, const char **argv, struct dyn_event *ev) { struct trace_eprobe *ep = to_trace_eprobe(ev); const char *slash; /* * We match the following: * event only - match all eprobes with event name * system and event only - match all system/event probes * system only - match all system probes * * The below has the above satisfied with more arguments: * * attached system/event - If the arg has the system and event * the probe is attached to, match * probes with the attachment. * * If any more args are given, then it requires a full match. */ /* * If system exists, but this probe is not part of that system * do not match. */ if (system && strcmp(trace_probe_group_name(&ep->tp), system) != 0) return false; /* Must match the event name */ if (event[0] != '\0' && strcmp(trace_probe_name(&ep->tp), event) != 0) return false; /* No arguments match all */ if (argc < 1) return true; /* First argument is the system/event the probe is attached to */ slash = strchr(argv[0], '/'); if (!slash) slash = strchr(argv[0], '.'); if (!slash) return false; if (strncmp(ep->event_system, argv[0], slash - argv[0])) return false; if (strcmp(ep->event_name, slash + 1)) return false; argc--; argv++; /* If there are no other args, then match */ if (argc < 1) return true; return trace_probe_match_command_args(&ep->tp, argc, argv); } static struct dyn_event_operations eprobe_dyn_event_ops = { .create = eprobe_dyn_event_create, .show = eprobe_dyn_event_show, .is_busy = eprobe_dyn_event_is_busy, .free = eprobe_dyn_event_release, .match = eprobe_dyn_event_match, }; static struct trace_eprobe *alloc_event_probe(const char *group, const char *this_event, struct trace_event_call *event, int nargs) { struct trace_eprobe *ep; const char *event_name; const char *sys_name; int ret = -ENOMEM; if (!event) return ERR_PTR(-ENODEV); sys_name = event->class->system; event_name = trace_event_name(event); ep = kzalloc(struct_size(ep, tp.args, nargs), GFP_KERNEL); if (!ep) { trace_event_put_ref(event); goto error; } ep->event = event; ep->event_name = kstrdup(event_name, GFP_KERNEL); if (!ep->event_name) goto error; ep->event_system = kstrdup(sys_name, GFP_KERNEL); if (!ep->event_system) goto error; ret = trace_probe_init(&ep->tp, this_event, group, false); if (ret < 0) goto error; dyn_event_init(&ep->devent, &eprobe_dyn_event_ops); return ep; error: trace_event_probe_cleanup(ep); return ERR_PTR(ret); } static int trace_eprobe_tp_arg_update(struct trace_eprobe *ep, int i) { struct probe_arg *parg = &ep->tp.args[i]; struct ftrace_event_field *field; struct list_head *head; int ret = -ENOENT; head = trace_get_fields(ep->event); list_for_each_entry(field, head, link) { if (!strcmp(parg->code->data, field->name)) { kfree(parg->code->data); parg->code->data = field; return 0; } } /* * Argument not found on event. But allow for comm and COMM * to be used to get the current->comm. */ if (strcmp(parg->code->data, "COMM") == 0 || strcmp(parg->code->data, "comm") == 0) { parg->code->op = FETCH_OP_COMM; ret = 0; } kfree(parg->code->data); parg->code->data = NULL; return ret; } static int eprobe_event_define_fields(struct trace_event_call *event_call) { struct eprobe_trace_entry_head field; struct trace_probe *tp; tp = trace_probe_primary_from_call(event_call); if (WARN_ON_ONCE(!tp)) return -ENOENT; return traceprobe_define_arg_fields(event_call, sizeof(field), tp); } static struct trace_event_fields eprobe_fields_array[] = { { .type = TRACE_FUNCTION_TYPE, .define_fields = eprobe_event_define_fields }, {} }; /* Event entry printers */ static enum print_line_t print_eprobe_event(struct trace_iterator *iter, int flags, struct trace_event *event) { struct eprobe_trace_entry_head *field; struct trace_event_call *pevent; struct trace_event *probed_event; struct trace_seq *s = &iter->seq; struct trace_eprobe *ep; struct trace_probe *tp; unsigned int type; field = (struct eprobe_trace_entry_head *)iter->ent; tp = trace_probe_primary_from_call( container_of(event, struct trace_event_call, event)); if (WARN_ON_ONCE(!tp)) goto out; ep = container_of(tp, struct trace_eprobe, tp); type = ep->event->event.type; trace_seq_printf(s, "%s: (", trace_probe_name(tp)); probed_event = ftrace_find_event(type); if (probed_event) { pevent = container_of(probed_event, struct trace_event_call, event); trace_seq_printf(s, "%s.%s", pevent->class->system, trace_event_name(pevent)); } else { trace_seq_printf(s, "%u", type); } trace_seq_putc(s, ')'); if (print_probe_args(s, tp->args, tp->nr_args, (u8 *)&field[1], field) < 0) goto out; trace_seq_putc(s, '\n'); out: return trace_handle_return(s); } static unsigned long get_event_field(struct fetch_insn *code, void *rec) { struct ftrace_event_field *field = code->data; unsigned long val; void *addr; addr = rec + field->offset; if (is_string_field(field)) { switch (field->filter_type) { case FILTER_DYN_STRING: val = (unsigned long)(rec + (*(unsigned int *)addr & 0xffff)); break; case FILTER_RDYN_STRING: val = (unsigned long)(addr + (*(unsigned int *)addr & 0xffff)); break; case FILTER_STATIC_STRING: val = (unsigned long)addr; break; case FILTER_PTR_STRING: val = (unsigned long)(*(char *)addr); break; default: WARN_ON_ONCE(1); return 0; } return val; } switch (field->size) { case 1: if (field->is_signed) val = *(char *)addr; else val = *(unsigned char *)addr; break; case 2: if (field->is_signed) val = *(short *)addr; else val = *(unsigned short *)addr; break; case 4: if (field->is_signed) val = *(int *)addr; else val = *(unsigned int *)addr; break; default: if (field->is_signed) val = *(long *)addr; else val = *(unsigned long *)addr; break; } return val; } static int get_eprobe_size(struct trace_probe *tp, void *rec) { struct fetch_insn *code; struct probe_arg *arg; int i, len, ret = 0; for (i = 0; i < tp->nr_args; i++) { arg = tp->args + i; if (arg->dynamic) { unsigned long val; code = arg->code; retry: switch (code->op) { case FETCH_OP_TP_ARG: val = get_event_field(code, rec); break; case FETCH_OP_IMM: val = code->immediate; break; case FETCH_OP_COMM: val = (unsigned long)current->comm; break; case FETCH_OP_DATA: val = (unsigned long)code->data; break; case FETCH_NOP_SYMBOL: /* Ignore a place holder */ code++; goto retry; default: continue; } code++; len = process_fetch_insn_bottom(code, val, NULL, NULL); if (len > 0) ret += len; } } return ret; } /* Kprobe specific fetch functions */ /* Note that we don't verify it, since the code does not come from user space */ static int process_fetch_insn(struct fetch_insn *code, void *rec, void *dest, void *base) { unsigned long val; retry: switch (code->op) { case FETCH_OP_TP_ARG: val = get_event_field(code, rec); break; case FETCH_OP_IMM: val = code->immediate; break; case FETCH_OP_COMM: val = (unsigned long)current->comm; break; case FETCH_OP_DATA: val = (unsigned long)code->data; break; case FETCH_NOP_SYMBOL: /* Ignore a place holder */ code++; goto retry; default: return -EILSEQ; } code++; return process_fetch_insn_bottom(code, val, dest, base); } NOKPROBE_SYMBOL(process_fetch_insn) /* Return the length of string -- including null terminal byte */ static nokprobe_inline int fetch_store_strlen_user(unsigned long addr) { const void __user *uaddr = (__force const void __user *)addr; return strnlen_user_nofault(uaddr, MAX_STRING_SIZE); } /* Return the length of string -- including null terminal byte */ static nokprobe_inline int fetch_store_strlen(unsigned long addr) { int ret, len = 0; u8 c; #ifdef CONFIG_ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE if (addr < TASK_SIZE) return fetch_store_strlen_user(addr); #endif do { ret = copy_from_kernel_nofault(&c, (u8 *)addr + len, 1); len++; } while (c && ret == 0 && len < MAX_STRING_SIZE); return (ret < 0) ? ret : len; } /* * Fetch a null-terminated string from user. Caller MUST set *(u32 *)buf * with max length and relative data location. */ static nokprobe_inline int fetch_store_string_user(unsigned long addr, void *dest, void *base) { const void __user *uaddr = (__force const void __user *)addr; int maxlen = get_loc_len(*(u32 *)dest); void *__dest; long ret; if (unlikely(!maxlen)) return -ENOMEM; __dest = get_loc_data(dest, base); ret = strncpy_from_user_nofault(__dest, uaddr, maxlen); if (ret >= 0) *(u32 *)dest = make_data_loc(ret, __dest - base); return ret; } /* * Fetch a null-terminated string. Caller MUST set *(u32 *)buf with max * length and relative data location. */ static nokprobe_inline int fetch_store_string(unsigned long addr, void *dest, void *base) { int maxlen = get_loc_len(*(u32 *)dest); void *__dest; long ret; #ifdef CONFIG_ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE if ((unsigned long)addr < TASK_SIZE) return fetch_store_string_user(addr, dest, base); #endif if (unlikely(!maxlen)) return -ENOMEM; __dest = get_loc_data(dest, base); /* * Try to get string again, since the string can be changed while * probing. */ ret = strncpy_from_kernel_nofault(__dest, (void *)addr, maxlen); if (ret >= 0) *(u32 *)dest = make_data_loc(ret, __dest - base); return ret; } static nokprobe_inline int probe_mem_read_user(void *dest, void *src, size_t size) { const void __user *uaddr = (__force const void __user *)src; return copy_from_user_nofault(dest, uaddr, size); } static nokprobe_inline int probe_mem_read(void *dest, void *src, size_t size) { #ifdef CONFIG_ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE if ((unsigned long)src < TASK_SIZE) return probe_mem_read_user(dest, src, size); #endif return copy_from_kernel_nofault(dest, src, size); } /* eprobe handler */ static inline void __eprobe_trace_func(struct eprobe_data *edata, void *rec) { struct eprobe_trace_entry_head *entry; struct trace_event_call *call = trace_probe_event_call(&edata->ep->tp); struct trace_event_buffer fbuffer; int dsize; if (WARN_ON_ONCE(call != edata->file->event_call)) return; if (trace_trigger_soft_disabled(edata->file)) return; dsize = get_eprobe_size(&edata->ep->tp, rec); entry = trace_event_buffer_reserve(&fbuffer, edata->file, sizeof(*entry) + edata->ep->tp.size + dsize); if (!entry) return; entry = fbuffer.entry = ring_buffer_event_data(fbuffer.event); store_trace_args(&entry[1], &edata->ep->tp, rec, sizeof(*entry), dsize); trace_event_buffer_commit(&fbuffer); } /* * The event probe implementation uses event triggers to get access to * the event it is attached to, but is not an actual trigger. The below * functions are just stubs to fulfill what is needed to use the trigger * infrastructure. */ static int eprobe_trigger_init(struct event_trigger_data *data) { return 0; } static void eprobe_trigger_free(struct event_trigger_data *data) { } static int eprobe_trigger_print(struct seq_file *m, struct event_trigger_data *data) { /* Do not print eprobe event triggers */ return 0; } static void eprobe_trigger_func(struct event_trigger_data *data, struct trace_buffer *buffer, void *rec, struct ring_buffer_event *rbe) { struct eprobe_data *edata = data->private_data; __eprobe_trace_func(edata, rec); } static struct event_trigger_ops eprobe_trigger_ops = { .trigger = eprobe_trigger_func, .print = eprobe_trigger_print, .init = eprobe_trigger_init, .free = eprobe_trigger_free, }; static int eprobe_trigger_cmd_parse(struct event_command *cmd_ops, struct trace_event_file *file, char *glob, char *cmd, char *param_and_filter) { return -1; } static int eprobe_trigger_reg_func(char *glob, struct event_trigger_data *data, struct trace_event_file *file) { return -1; } static void eprobe_trigger_unreg_func(char *glob, struct event_trigger_data *data, struct trace_event_file *file) { } static struct event_trigger_ops *eprobe_trigger_get_ops(char *cmd, char *param) { return &eprobe_trigger_ops; } static struct event_command event_trigger_cmd = { .name = "eprobe", .trigger_type = ETT_EVENT_EPROBE, .flags = EVENT_CMD_FL_NEEDS_REC, .parse = eprobe_trigger_cmd_parse, .reg = eprobe_trigger_reg_func, .unreg = eprobe_trigger_unreg_func, .unreg_all = NULL, .get_trigger_ops = eprobe_trigger_get_ops, .set_filter = NULL, }; static struct event_trigger_data * new_eprobe_trigger(struct trace_eprobe *ep, struct trace_event_file *file) { struct event_trigger_data *trigger; struct event_filter *filter = NULL; struct eprobe_data *edata; int ret; edata = kzalloc(sizeof(*edata), GFP_KERNEL); trigger = kzalloc(sizeof(*trigger), GFP_KERNEL); if (!trigger || !edata) { ret = -ENOMEM; goto error; } trigger->flags = EVENT_TRIGGER_FL_PROBE; trigger->count = -1; trigger->ops = &eprobe_trigger_ops; /* * EVENT PROBE triggers are not registered as commands with * register_event_command(), as they are not controlled by the user * from the trigger file */ trigger->cmd_ops = &event_trigger_cmd; INIT_LIST_HEAD(&trigger->list); if (ep->filter_str) { ret = create_event_filter(file->tr, file->event_call, ep->filter_str, false, &filter); if (ret) goto error; } RCU_INIT_POINTER(trigger->filter, filter); edata->file = file; edata->ep = ep; trigger->private_data = edata; return trigger; error: free_event_filter(filter); kfree(edata); kfree(trigger); return ERR_PTR(ret); } static int enable_eprobe(struct trace_eprobe *ep, struct trace_event_file *eprobe_file) { struct event_trigger_data *trigger; struct trace_event_file *file; struct trace_array *tr = eprobe_file->tr; file = find_event_file(tr, ep->event_system, ep->event_name); if (!file) return -ENOENT; trigger = new_eprobe_trigger(ep, eprobe_file); if (IS_ERR(trigger)) return PTR_ERR(trigger); list_add_tail_rcu(&trigger->list, &file->triggers); trace_event_trigger_enable_disable(file, 1); update_cond_flag(file); return 0; } static struct trace_event_functions eprobe_funcs = { .trace = print_eprobe_event }; static int disable_eprobe(struct trace_eprobe *ep, struct trace_array *tr) { struct event_trigger_data *trigger = NULL, *iter; struct trace_event_file *file; struct event_filter *filter; struct eprobe_data *edata; file = find_event_file(tr, ep->event_system, ep->event_name); if (!file) return -ENOENT; list_for_each_entry(iter, &file->triggers, list) { if (!(iter->flags & EVENT_TRIGGER_FL_PROBE)) continue; edata = iter->private_data; if (edata->ep == ep) { trigger = iter; break; } } if (!trigger) return -ENODEV; list_del_rcu(&trigger->list); trace_event_trigger_enable_disable(file, 0); update_cond_flag(file); /* Make sure nothing is using the edata or trigger */ tracepoint_synchronize_unregister(); filter = rcu_access_pointer(trigger->filter); if (filter) free_event_filter(filter); kfree(edata); kfree(trigger); return 0; } static int enable_trace_eprobe(struct trace_event_call *call, struct trace_event_file *file) { struct trace_probe *pos, *tp; struct trace_eprobe *ep; bool enabled; int ret = 0; tp = trace_probe_primary_from_call(call); if (WARN_ON_ONCE(!tp)) return -ENODEV; enabled = trace_probe_is_enabled(tp); /* This also changes "enabled" state */ if (file) { ret = trace_probe_add_file(tp, file); if (ret) return ret; } else trace_probe_set_flag(tp, TP_FLAG_PROFILE); if (enabled) return 0; list_for_each_entry(pos, trace_probe_probe_list(tp), list) { ep = container_of(pos, struct trace_eprobe, tp); ret = enable_eprobe(ep, file); if (ret) break; enabled = true; } if (ret) { /* Failed to enable one of them. Roll back all */ if (enabled) disable_eprobe(ep, file->tr); if (file) trace_probe_remove_file(tp, file); else trace_probe_clear_flag(tp, TP_FLAG_PROFILE); } return ret; } static int disable_trace_eprobe(struct trace_event_call *call, struct trace_event_file *file) { struct trace_probe *pos, *tp; struct trace_eprobe *ep; tp = trace_probe_primary_from_call(call); if (WARN_ON_ONCE(!tp)) return -ENODEV; if (file) { if (!trace_probe_get_file_link(tp, file)) return -ENOENT; if (!trace_probe_has_single_file(tp)) goto out; trace_probe_clear_flag(tp, TP_FLAG_TRACE); } else trace_probe_clear_flag(tp, TP_FLAG_PROFILE); if (!trace_probe_is_enabled(tp)) { list_for_each_entry(pos, trace_probe_probe_list(tp), list) { ep = container_of(pos, struct trace_eprobe, tp); disable_eprobe(ep, file->tr); } } out: if (file) /* * Synchronization is done in below function. For perf event, * file == NULL and perf_trace_event_unreg() calls * tracepoint_synchronize_unregister() to ensure synchronize * event. We don't need to care about it. */ trace_probe_remove_file(tp, file); return 0; } static int eprobe_register(struct trace_event_call *event, enum trace_reg type, void *data) { struct trace_event_file *file = data; switch (type) { case TRACE_REG_REGISTER: return enable_trace_eprobe(event, file); case TRACE_REG_UNREGISTER: return disable_trace_eprobe(event, file); #ifdef CONFIG_PERF_EVENTS case TRACE_REG_PERF_REGISTER: case TRACE_REG_PERF_UNREGISTER: case TRACE_REG_PERF_OPEN: case TRACE_REG_PERF_CLOSE: case TRACE_REG_PERF_ADD: case TRACE_REG_PERF_DEL: return 0; #endif } return 0; } static inline void init_trace_eprobe_call(struct trace_eprobe *ep) { struct trace_event_call *call = trace_probe_event_call(&ep->tp); call->flags = TRACE_EVENT_FL_EPROBE; call->event.funcs = &eprobe_funcs; call->class->fields_array = eprobe_fields_array; call->class->reg = eprobe_register; } static struct trace_event_call * find_and_get_event(const char *system, const char *event_name) { struct trace_event_call *tp_event; const char *name; list_for_each_entry(tp_event, &ftrace_events, list) { /* Skip other probes and ftrace events */ if (tp_event->flags & (TRACE_EVENT_FL_IGNORE_ENABLE | TRACE_EVENT_FL_KPROBE | TRACE_EVENT_FL_UPROBE | TRACE_EVENT_FL_EPROBE)) continue; if (!tp_event->class->system || strcmp(system, tp_event->class->system)) continue; name = trace_event_name(tp_event); if (!name || strcmp(event_name, name)) continue; if (!trace_event_try_get_ref(tp_event)) { return NULL; break; } return tp_event; break; } return NULL; } static int trace_eprobe_tp_update_arg(struct trace_eprobe *ep, const char *argv[], int i) { unsigned int flags = TPARG_FL_KERNEL | TPARG_FL_TPOINT; int ret; ret = traceprobe_parse_probe_arg(&ep->tp, i, argv[i], flags); if (ret) return ret; if (ep->tp.args[i].code->op == FETCH_OP_TP_ARG) { ret = trace_eprobe_tp_arg_update(ep, i); if (ret) trace_probe_log_err(0, BAD_ATTACH_ARG); } /* Handle symbols "@" */ if (!ret) ret = traceprobe_update_arg(&ep->tp.args[i]); return ret; } static int trace_eprobe_parse_filter(struct trace_eprobe *ep, int argc, const char *argv[]) { struct event_filter *dummy; int i, ret, len = 0; char *p; if (argc == 0) { trace_probe_log_err(0, NO_EP_FILTER); return -EINVAL; } /* Recover the filter string */ for (i = 0; i < argc; i++) len += strlen(argv[i]) + 1; ep->filter_str = kzalloc(len, GFP_KERNEL); if (!ep->filter_str) return -ENOMEM; p = ep->filter_str; for (i = 0; i < argc; i++) { ret = snprintf(p, len, "%s ", argv[i]); if (ret < 0) goto error; if (ret > len) { ret = -E2BIG; goto error; } p += ret; len -= ret; } p[-1] = '\0'; /* * Ensure the filter string can be parsed correctly. Note, this * filter string is for the original event, not for the eprobe. */ ret = create_event_filter(top_trace_array(), ep->event, ep->filter_str, true, &dummy); free_event_filter(dummy); if (ret) goto error; return 0; error: kfree(ep->filter_str); ep->filter_str = NULL; return ret; } static int __trace_eprobe_create(int argc, const char *argv[]) { /* * Argument syntax: * e[:[GRP/][ENAME]] SYSTEM.EVENT [FETCHARGS] [if FILTER] * Fetch args (no space): * <name>=$<field>[:TYPE] */ const char *event = NULL, *group = EPROBE_EVENT_SYSTEM; const char *sys_event = NULL, *sys_name = NULL; struct trace_event_call *event_call; struct trace_eprobe *ep = NULL; char buf1[MAX_EVENT_NAME_LEN]; char buf2[MAX_EVENT_NAME_LEN]; char gbuf[MAX_EVENT_NAME_LEN]; int ret = 0, filter_idx = 0; int i, filter_cnt; if (argc < 2 || argv[0][0] != 'e') return -ECANCELED; trace_probe_log_init("event_probe", argc, argv); event = strchr(&argv[0][1], ':'); if (event) { event++; ret = traceprobe_parse_event_name(&event, &group, gbuf, event - argv[0]); if (ret) goto parse_error; } trace_probe_log_set_index(1); sys_event = argv[1]; ret = traceprobe_parse_event_name(&sys_event, &sys_name, buf2, 0); if (ret || !sys_event || !sys_name) { trace_probe_log_err(0, NO_EVENT_INFO); goto parse_error; } if (!event) { strscpy(buf1, argv[1], MAX_EVENT_NAME_LEN); sanitize_event_name(buf1); event = buf1; } for (i = 2; i < argc; i++) { if (!strcmp(argv[i], "if")) { filter_idx = i + 1; filter_cnt = argc - filter_idx; argc = i; break; } } mutex_lock(&event_mutex); event_call = find_and_get_event(sys_name, sys_event); ep = alloc_event_probe(group, event, event_call, argc - 2); mutex_unlock(&event_mutex); if (IS_ERR(ep)) { ret = PTR_ERR(ep); if (ret == -ENODEV) trace_probe_log_err(0, BAD_ATTACH_EVENT); /* This must return -ENOMEM or missing event, else there is a bug */ WARN_ON_ONCE(ret != -ENOMEM && ret != -ENODEV); ep = NULL; goto error; } if (filter_idx) { trace_probe_log_set_index(filter_idx); ret = trace_eprobe_parse_filter(ep, filter_cnt, argv + filter_idx); if (ret) goto parse_error; } else ep->filter_str = NULL; argc -= 2; argv += 2; /* parse arguments */ for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) { trace_probe_log_set_index(i + 2); ret = trace_eprobe_tp_update_arg(ep, argv, i); if (ret) goto error; } ret = traceprobe_set_print_fmt(&ep->tp, PROBE_PRINT_EVENT); if (ret < 0) goto error; init_trace_eprobe_call(ep); mutex_lock(&event_mutex); ret = trace_probe_register_event_call(&ep->tp); if (ret) { if (ret == -EEXIST) { trace_probe_log_set_index(0); trace_probe_log_err(0, EVENT_EXIST); } mutex_unlock(&event_mutex); goto error; } ret = dyn_event_add(&ep->devent, &ep->tp.event->call); mutex_unlock(&event_mutex); return ret; parse_error: ret = -EINVAL; error: trace_event_probe_cleanup(ep); return ret; } /* * Register dynevent at core_initcall. This allows kernel to setup eprobe * events in postcore_initcall without tracefs. */ static __init int trace_events_eprobe_init_early(void) { int err = 0; err = dyn_event_register(&eprobe_dyn_event_ops); if (err) pr_warn("Could not register eprobe_dyn_event_ops\n"); return err; } core_initcall(trace_events_eprobe_init_early);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
You can’t perform that action at this time.