Messages in this thread | | | Subject | Re: [PATCH v7 02/10] tracing: add basic event trigger framework | From | Tom Zanussi <> | Date | Tue, 27 Aug 2013 18:38:54 -0500 |
| |
On Tue, 2013-08-27 at 16:15 -0400, Steven Rostedt wrote: > On Tue, 27 Aug 2013 14:40:14 -0500 > Tom Zanussi <tom.zanussi@linux.intel.com> wrote: > > > > Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com> > > Idea-by: Steve Rostedt <rostedt@goodmis.org> > > --- > > include/linux/ftrace_event.h | 13 +- > > include/trace/ftrace.h | 4 + > > kernel/trace/Makefile | 1 + > > kernel/trace/trace.h | 171 ++++++++++++++++++++++ > > kernel/trace/trace_events.c | 21 ++- > > kernel/trace/trace_events_trigger.c | 280 ++++++++++++++++++++++++++++++++++++ > > kernel/trace/trace_syscalls.c | 4 + > > 7 files changed, 488 insertions(+), 6 deletions(-) > > create mode 100644 kernel/trace/trace_events_trigger.c > > > > diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h > > index 5eaa746..4b4fa62 100644 > > --- a/include/linux/ftrace_event.h > > +++ b/include/linux/ftrace_event.h > > @@ -255,6 +255,7 @@ enum { > > FTRACE_EVENT_FL_RECORDED_CMD_BIT, > > FTRACE_EVENT_FL_SOFT_MODE_BIT, > > FTRACE_EVENT_FL_SOFT_DISABLED_BIT, > > + FTRACE_EVENT_FL_TRIGGER_MODE_BIT, > > }; > > > > /* > > @@ -263,13 +264,15 @@ enum { > > * RECORDED_CMD - The comms should be recorded at sched_switch > > * SOFT_MODE - The event is enabled/disabled by SOFT_DISABLED > > * SOFT_DISABLED - When set, do not trace the event (even though its > > - * tracepoint may be enabled) > > + * tracepoint may be enabled) > > Nitpick... I like the extra space in the indentation. It makes the > continuation of the line obvious. Otherwise I start reading the next > line as part of the original line. >
OK, I can put that back.
> > > + * TRIGGER_MODE - The event is enabled/disabled by SOFT_DISABLED > > */ > > enum { > > FTRACE_EVENT_FL_ENABLED = (1 << FTRACE_EVENT_FL_ENABLED_BIT), > > FTRACE_EVENT_FL_RECORDED_CMD = (1 << FTRACE_EVENT_FL_RECORDED_CMD_BIT), > > FTRACE_EVENT_FL_SOFT_MODE = (1 << FTRACE_EVENT_FL_SOFT_MODE_BIT), > > FTRACE_EVENT_FL_SOFT_DISABLED = (1 << FTRACE_EVENT_FL_SOFT_DISABLED_BIT), > > + FTRACE_EVENT_FL_TRIGGER_MODE = (1 << FTRACE_EVENT_FL_TRIGGER_MODE_BIT), > > }; > > > > struct ftrace_event_file { > > @@ -278,6 +281,7 @@ struct ftrace_event_file { > > struct dentry *dir; > > struct trace_array *tr; > > struct ftrace_subsystem_dir *system; > > + struct list_head triggers; > > > > /* > > * 32 bit flags: > > @@ -285,6 +289,7 @@ struct ftrace_event_file { > > * bit 1: enabled cmd record > > * bit 2: enable/disable with the soft disable bit > > * bit 3: soft disabled > > + * bit 4: trigger enabled > > * > > * Note: The bits must be set atomically to prevent races > > * from other writers. Reads of flags do not need to be in > > @@ -296,6 +301,7 @@ struct ftrace_event_file { > > */ > > unsigned long flags; > > atomic_t sm_ref; /* soft-mode reference counter */ > > + atomic_t tm_ref; /* trigger-mode reference counter */ > > }; > > > > #define __TRACE_EVENT_FLAGS(name, value) \ > > @@ -310,12 +316,17 @@ struct ftrace_event_file { > > > > #define MAX_FILTER_STR_VAL 256 /* Should handle KSYM_SYMBOL_LEN */ > > > > +enum event_trigger_type { > > + ETT_NONE = (0), > > +}; > > + > > extern void destroy_preds(struct ftrace_event_call *call); > > extern int filter_match_preds(struct event_filter *filter, void *rec); > > extern int filter_current_check_discard(struct ring_buffer *buffer, > > struct ftrace_event_call *call, > > void *rec, > > struct ring_buffer_event *event); > > +extern void event_triggers_call(struct ftrace_event_file *file); > > > > enum { > > FILTER_OTHER = 0, > > diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h > > index 41a6643..326ba32 100644 > > --- a/include/trace/ftrace.h > > +++ b/include/trace/ftrace.h > > @@ -526,6 +526,10 @@ ftrace_raw_event_##call(void *__data, proto) \ > > int __data_size; \ > > int pc; \ > > \ > > + if (test_bit(FTRACE_EVENT_FL_TRIGGER_MODE_BIT, \ > > + &ftrace_file->flags)) \ > > + event_triggers_call(ftrace_file); \ > > + \ > > if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, \ > > &ftrace_file->flags)) \ > > return; \ > > diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile > > index d7e2068..1378e84 100644 > > --- a/kernel/trace/Makefile > > +++ b/kernel/trace/Makefile > > @@ -50,6 +50,7 @@ ifeq ($(CONFIG_PERF_EVENTS),y) > > obj-$(CONFIG_EVENT_TRACING) += trace_event_perf.o > > endif > > obj-$(CONFIG_EVENT_TRACING) += trace_events_filter.o > > +obj-$(CONFIG_EVENT_TRACING) += trace_events_trigger.o > > obj-$(CONFIG_KPROBE_EVENT) += trace_kprobe.o > > obj-$(CONFIG_TRACEPOINTS) += power-traces.o > > ifeq ($(CONFIG_PM_RUNTIME),y) > > diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h > > index b1227b9..f8a18e5 100644 > > --- a/kernel/trace/trace.h > > +++ b/kernel/trace/trace.h > > @@ -1016,9 +1016,180 @@ extern void trace_event_enable_cmd_record(bool enable); > > extern int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr); > > extern int event_trace_del_tracer(struct trace_array *tr); > > > > +static inline void *event_file_data(struct file *filp) > > +{ > > + return ACCESS_ONCE(file_inode(filp)->i_private); > > +} > > + > > extern struct mutex event_mutex; > > extern struct list_head ftrace_events; > > > > +extern const struct file_operations event_trigger_fops; > > + > > +extern int register_trigger_cmds(void); > > +extern void clear_event_triggers(struct trace_array *tr); > > + > > +/** > > + * struct event_trigger_ops - callbacks for trace event triggers > > + * > > + * The methods in this structure provide per-event trigger hooks for > > + * various trigger operations. > > + * > > + * All the methods below, except for @init() and @free(), must be > > + * implemented. > > + * > > + * @func: The trigger 'probe' function called when the triggering > > + * event occurs. The data passed into this callback is the data > > + * that was supplied to the event_command @reg() function that > > + * registered the trigger (see struct event_command). > > + * > > + * @init: An optional initialization function called for the trigger > > + * when the trigger is registered (via the event_command reg() > > + * function). This can be used to perform per-trigger > > + * initialization such as incrementing a per-trigger reference > > + * count, for instance. This is usually implemented by the > > + * generic utility function @event_trigger_init() (see > > + * trace_event_triggers.c). > > + * > > + * @free: An optional de-initialization function called for the > > + * trigger when the trigger is unregistered (via the > > + * event_command @reg() function). This can be used to perform > > + * per-trigger de-initialization such as decrementing a > > + * per-trigger reference count and freeing corresponding trigger > > + * data, for instance. This is usually implemented by the > > + * generic utility function @event_trigger_free() (see > > + * trace_event_triggers.c). > > + * > > + * @print: The callback function invoked to have the trigger print > > + * itself. This is usually implemented by a wrapper function > > + * that calls the generic utility function @event_trigger_print() > > + * (see trace_event_triggers.c). > > + */ > > +struct event_trigger_ops { > > + void (*func)(void **data); > > Why the void **? >
This is another vestige of the original patchset, where I tried to keep the event triggers and the ftrace triggers unified. One of the things that I attempted to keep common was this struct and the ftrace_probe_ops, which you can see have essentially the same signatures for all the functions (minus the ip params). Anyway, since that's not a goal of this patchset, I'll just simplify and not use the double pointers.
> > + int (*init)(struct event_trigger_ops *ops, > > + void **data); > > + void (*free)(struct event_trigger_ops *ops, > > + void **data); > > + int (*print)(struct seq_file *m, > > + struct event_trigger_ops *ops, > > + void *data); > > +}; > > + > > +/** > > + * struct event_command - callbacks and data members for event commands > > + * > > + * Event commands are invoked by users by writing the command name > > + * into the 'trigger' file associated with a trace event. The > > + * parameters associated with a specific invocation of an event > > + * command are used to create an event trigger instance, which is > > + * added to the list of trigger instances associated with that trace > > + * event. When the event is hit, the set of triggers associated with > > + * that event is invoked. > > + * > > + * The data members in this structure provide per-event command data > > + * for various event commands. > > + * > > + * All the data members below, except for @post_trigger, must be set > > + * for each event command. > > + * > > + * @name: The unique name that identifies the event command. This is > > + * the name used when setting triggers via trigger files. > > + * > > + * @trigger_type: A unique id that identifies the event command > > + * 'type'. This value has two purposes, the first to ensure that > > + * only one trigger of the same type can be set at a given time > > + * for a particular event e.g. it doesn't make sense to have both > > + * a traceon and traceoff trigger attached to a single event at > > + * the same time, so traceon and traceoff have the same type > > + * though they have different names. The @trigger_type value is > > Heh, I didn't bother for that in the ftrace triggers. If the root user > wants to start and stop tracing on the same function, so be it. They > get what they ask for. > > I'm not against this, I was just pointing out how you care more than I > do about keeping root from stepping on his/her own toes ;-) > > > + * also used as a bit value for deferring the actual trigger > > + * action until after the current event is finished. Some > > + * commands need to do this if they themselves log to the trace > > + * buffer (see the @post_trigger() member below). @trigger_type > > + * values are defined by adding new values to the trigger_type > > + * enum in include/linux/ftrace_event.h. > > + * > > + * @post_trigger: A flag that says whether or not this command needs > > + * to have its action delayed until after the current event has > > + * been closed. Some triggers need to avoid being invoked while > > + * an event is currently in the process of being logged, since > > + * the trigger may itself log data into the trace buffer. Thus > > + * we make sure the current event is committed before invoking > > + * those triggers. To do that, the trigger invocation is split > > + * in two - the first part checks the filter using the current > > + * trace record; if a command has the @post_trigger flag set, it > > + * sets a bit for itself in the return value, otherwise it > > + * directly invokes the trigger. Once all commands have been > > + * either invoked or set their return flag, the current record is > > + * either committed or discarded. At that point, if any commands > > + * have deferred their triggers, those commands are finally > > + * invoked following the close of the current event. In other > > + * words, if the event_trigger_ops @func() probe implementation > > + * itself logs to the trace buffer, this flag should be set, > > + * otherwise it can be left unspecified. > > Is this just for consistency of output layout? So the normal event gets > printed first before this prints anything, like a stack trace? >
Yeah, that's one of the reasons - it makes sense to me to always have the triggering event print first, but also, this is essentially the implementation of the post triggers we discussed here:
https://lkml.org/lkml/2013/6/22/37
From there, basically the problem is that the trace_recursive_lock() check in ring_buffer_lock_reserve() prevents a trigger that itself logs to the ring buffer from reserving a slot in the buffer, since it's being done from the same context as the triggering event. For example, the stacktrace trigger, which calls trace_dump_stack().
> > + * > > + * All the methods below, except for @set_filter(), must be > > + * implemented. > > + * > > + * @func: The callback function responsible for parsing and > > + * registering the trigger written to the 'trigger' file by the > > + * user. It allocates the trigger instance and registers it with > > + * the appropriate trace event. It makes use of the other > > + * event_command callback functions to orchestrate this, and is > > + * usually implemented by the generic utility function > > + * @event_trigger_callback() (see trace_event_triggers.c). > > + * > > + * @reg: Adds the trigger to the list of triggers associated with the > > + * event, and enables the event trigger itself, after > > + * initializing it (via the event_trigger_ops @init() function). > > + * This is also where commands can use the @trigger_type value to > > + * make the decision as to whether or not multiple instances of > > + * the trigger should be allowed. This is usually implemented by > > + * the generic utility function @register_trigger() (see > > + * trace_event_triggers.c). > > + * > > + * @unreg: Removes the trigger from the list of triggers associated > > + * with the event, and disables the event trigger itself, after > > + * initializing it (via the event_trigger_ops @free() function). > > + * This is usually implemented by the generic utility function > > + * @unregister_trigger() (see trace_event_triggers.c). > > + * > > + * @set_filter: An optional function called to parse and set a filter > > + * for the trigger. If no @set_filter() method is set for the > > + * event command, filters set by the user for the command will be > > + * ignored. This is usually implemented by the generic utility > > + * function @set_trigger_filter() (see trace_event_triggers.c). > > + * > > + * @get_trigger_ops: The callback function invoked to retrieve the > > + * event_trigger_ops implementation associated with the command. > > + */ > > +struct event_command { > > + struct list_head list; > > + char *name; > > + enum event_trigger_type trigger_type; > > + bool post_trigger; > > + int (*func)(struct event_command *cmd_ops, > > + struct ftrace_event_file *file, > > + char *glob, char *cmd, > > + char *params, int enable); > > + int (*reg)(char *glob, > > + struct event_trigger_ops *trigger_ops, > > + void *trigger_data, > > + struct ftrace_event_file *file); > > + void (*unreg)(char *glob, > > + struct event_trigger_ops *trigger_ops, > > + void *trigger_data, > > + struct ftrace_event_file *file); > > + int (*set_filter)(char *filter_str, > > + void *trigger_data, > > + struct ftrace_event_file *file); > > + struct event_trigger_ops *(*get_trigger_ops)(char *cmd, char *param); > > +}; > > + > > +extern int trace_event_enable_disable(struct ftrace_event_file *file, > > + int enable, int soft_disable); > > + > > extern const char *__start___trace_bprintk_fmt[]; > > extern const char *__stop___trace_bprintk_fmt[]; > > > > diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c > > index 368a4d5..7d8eb8a 100644 > > --- a/kernel/trace/trace_events.c > > +++ b/kernel/trace/trace_events.c > > @@ -342,6 +342,12 @@ static int __ftrace_event_enable_disable(struct ftrace_event_file *file, > > return ret; > > } > > > > +int trace_event_enable_disable(struct ftrace_event_file *file, > > + int enable, int soft_disable) > > +{ > > + return __ftrace_event_enable_disable(file, enable, soft_disable); > > +} > > + > > static int ftrace_event_enable_disable(struct ftrace_event_file *file, > > int enable) > > { > > @@ -421,11 +427,6 @@ static void remove_subsystem(struct ftrace_subsystem_dir *dir) > > } > > } > > > > -static void *event_file_data(struct file *filp) > > -{ > > - return ACCESS_ONCE(file_inode(filp)->i_private); > > -} > > - > > static void remove_event_file_dir(struct ftrace_event_file *file) > > { > > struct dentry *dir = file->dir; > > @@ -1542,6 +1543,9 @@ event_create_dir(struct dentry *parent, struct ftrace_event_file *file) > > trace_create_file("filter", 0644, file->dir, call, > > &ftrace_event_filter_fops); > > > > + trace_create_file("trigger", 0644, file->dir, file, > > + &event_trigger_fops); > > + > > trace_create_file("format", 0444, file->dir, call, > > &ftrace_event_format_fops); > > > > @@ -1637,6 +1641,8 @@ trace_create_new_event(struct ftrace_event_call *call, > > file->event_call = call; > > file->tr = tr; > > atomic_set(&file->sm_ref, 0); > > + atomic_set(&file->tm_ref, 0); > > + INIT_LIST_HEAD(&file->triggers); > > list_add(&file->list, &tr->events); > > > > return file; > > @@ -2303,6 +2309,9 @@ int event_trace_del_tracer(struct trace_array *tr) > > { > > mutex_lock(&event_mutex); > > > > + /* Disable any event triggers and associated soft-disabled events */ > > + clear_event_triggers(tr); > > + > > /* Disable any running events */ > > __ftrace_set_clr_event_nolock(tr, NULL, NULL, NULL, 0); > > > > @@ -2366,6 +2375,8 @@ static __init int event_trace_enable(void) > > > > register_event_cmds(); > > > > + register_trigger_cmds(); > > + > > return 0; > > } > > > > diff --git a/kernel/trace/trace_events_trigger.c b/kernel/trace/trace_events_trigger.c > > new file mode 100644 > > index 0000000..5ec8336 > > --- /dev/null > > +++ b/kernel/trace/trace_events_trigger.c > > @@ -0,0 +1,280 @@ > > +/* > > + * trace_events_trigger - trace event triggers > > + * > > + * 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) 2013 Tom Zanussi <tom.zanussi@linux.intel.com> > > + */ > > + > > +#include <linux/module.h> > > +#include <linux/ctype.h> > > +#include <linux/mutex.h> > > +#include <linux/slab.h> > > + > > +#include "trace.h" > > + > > +static LIST_HEAD(trigger_commands); > > +static DEFINE_MUTEX(trigger_cmd_mutex); > > + > > +struct event_trigger_data { > > + struct ftrace_event_file *file; > > + unsigned long count; > > + int ref; > > + bool enable; > > + struct event_trigger_ops *ops; > > + struct event_command * cmd_ops; > > + struct event_filter *filter; > > + char *filter_str; > > + struct list_head list; > > +}; > > + > > +void event_triggers_call(struct ftrace_event_file *file) > > +{ > > + struct event_trigger_data *data; > > + > > + if (list_empty(&file->triggers)) > > + return; > > + > > + preempt_disable_notrace(); > > + list_for_each_entry_rcu(data, &file->triggers, list) > > + data->ops->func((void **)&data); > > Why is this a void ** and why are you passing the address of the > variable that holds the pointer to the data that was registered and not > the pointer to the data itself? > > Do you plan on modifying the local data variable on return? >
No, as above, another vestige of the original patchset, where I tried to keep the event triggers and the ftrace triggers unified. It'll be gone in the next revision.
> > + preempt_enable_notrace(); > > +} > > +EXPORT_SYMBOL_GPL(event_triggers_call); > > + > > +static void *trigger_next(struct seq_file *m, void *t, loff_t *pos) > > +{ > > + struct ftrace_event_file *event_file = event_file_data(m->private); > > + > > + return seq_list_next(t, &event_file->triggers, pos); > > +} > > + > > +static void *trigger_start(struct seq_file *m, loff_t *pos) > > +{ > > + struct ftrace_event_file *event_file; > > + > > + /* ->stop() is called even if ->start() fails */ > > + mutex_lock(&event_mutex); > > + event_file = event_file_data(m->private); > > + if (unlikely(!event_file)) > > + return ERR_PTR(-ENODEV); > > + > > + return seq_list_start(&event_file->triggers, *pos); > > +} > > + > > +static void trigger_stop(struct seq_file *m, void *t) > > +{ > > + mutex_unlock(&event_mutex); > > +} > > + > > +static int trigger_show(struct seq_file *m, void *v) > > +{ > > + struct event_trigger_data *data; > > + > > + data = list_entry(v, struct event_trigger_data, list); > > + data->ops->print(m, data->ops, data); > > + > > + return 0; > > +} > > + > > +static const struct seq_operations event_triggers_seq_ops = { > > + .start = trigger_start, > > + .next = trigger_next, > > + .stop = trigger_stop, > > + .show = trigger_show, > > +}; > > + > > +static int event_trigger_regex_open(struct inode *inode, struct file *file) > > +{ > > + int ret = 0; > > + > > + mutex_lock(&event_mutex); > > + > > + if (unlikely(!event_file_data(file))) { > > + mutex_unlock(&event_mutex); > > + return -ENODEV; > > + } > > + > > + if (file->f_mode & FMODE_READ) { > > + ret = seq_open(file, &event_triggers_seq_ops); > > + if (!ret) { > > + struct seq_file *m = file->private_data; > > + m->private = file; > > + } > > + } > > + > > + mutex_unlock(&event_mutex); > > + > > + return ret; > > +} > > + > > +static int trigger_process_regex(struct ftrace_event_file *file, > > + char *buff, int enable) > > +{ > > + char *command, *next = buff; > > + struct event_command *p; > > + int ret = -EINVAL; > > + > > + command = strsep(&next, ": \t"); > > + command = (command[0] != '!') ? command : command + 1; > > + > > + mutex_lock(&trigger_cmd_mutex); > > + list_for_each_entry(p, &trigger_commands, list) { > > + if (strcmp(p->name, command) == 0) { > > + ret = p->func(p, file, buff, command, next, enable); > > + goto out_unlock; > > + } > > + } > > + out_unlock: > > + mutex_unlock(&trigger_cmd_mutex); > > + > > + return ret; > > +} > > + > > +static ssize_t event_trigger_regex_write(struct file *file, > > + const char __user *ubuf, > > + size_t cnt, loff_t *ppos, int enable) > > +{ > > + struct ftrace_event_file *event_file; > > + ssize_t ret; > > + char *buf; > > + > > + if (!cnt) > > + return 0; > > + > > + if (cnt >= PAGE_SIZE) > > + return -EINVAL; > > + > > + buf = (char *)__get_free_page(GFP_TEMPORARY); > > + if (!buf) > > + return -ENOMEM; > > + > > + if (copy_from_user(buf, ubuf, cnt)) { > > + free_page((unsigned long) buf); > > + return -EFAULT; > > + } > > + buf[cnt] = '\0'; > > + strim(buf); > > + > > + mutex_lock(&event_mutex); > > + event_file = event_file_data(file); > > + if (unlikely(!event_file)) { > > + mutex_unlock(&event_mutex); > > + free_page((unsigned long) buf); > > + return -ENODEV; > > + } > > + ret = trigger_process_regex(event_file, buf, enable); > > + mutex_unlock(&event_mutex); > > + > > + free_page((unsigned long) buf); > > + if (ret < 0) > > + goto out; > > + > > + *ppos += cnt; > > + ret = cnt; > > + out: > > + return ret; > > +} > > + > > +static int event_trigger_regex_release(struct inode *inode, struct file *file) > > +{ > > + mutex_lock(&event_mutex); > > + > > + if (file->f_mode & FMODE_READ) > > + seq_release(inode, file); > > + > > + mutex_unlock(&event_mutex); > > + > > + return 0; > > +} > > + > > +static ssize_t > > +event_trigger_write(struct file *filp, const char __user *ubuf, > > + size_t cnt, loff_t *ppos) > > +{ > > + return event_trigger_regex_write(filp, ubuf, cnt, ppos, 1); > > +} > > + > > +static int > > +event_trigger_open(struct inode *inode, struct file *filp) > > +{ > > + return event_trigger_regex_open(inode, filp); > > +} > > + > > +static int > > +event_trigger_release(struct inode *inode, struct file *file) > > +{ > > + return event_trigger_regex_release(inode, file); > > +} > > + > > +const struct file_operations event_trigger_fops = { > > + .open = event_trigger_open, > > + .read = seq_read, > > + .write = event_trigger_write, > > + .llseek = ftrace_filter_lseek, > > + .release = event_trigger_release, > > +}; > > + > > +static int trace_event_trigger_enable_disable(struct ftrace_event_file *file, > > + int trigger_enable) > > +{ > > + int ret = 0; > > + > > + if (trigger_enable) { > > + if (atomic_inc_return(&file->tm_ref) > 1) > > + return ret; > > + set_bit(FTRACE_EVENT_FL_TRIGGER_MODE_BIT, &file->flags); > > + ret = trace_event_enable_disable(file, 1, 1); > > + } else { > > + if (atomic_dec_return(&file->tm_ref) > 0) > > + return ret; > > + clear_bit(FTRACE_EVENT_FL_TRIGGER_MODE_BIT, &file->flags); > > + ret = trace_event_enable_disable(file, 0, 1); > > + } > > + > > + return ret; > > +} > > + > > +/** > > + * clear_event_triggers - clear all triggers associated with a trace array. > > + * > > + * For each trigger, the triggering event has its tm_ref decremented > > + * via trace_event_trigger_enable_disable(), and any associated event > > + * (in the case of enable/disable_event triggers) will have its sm_ref > > + * decremented via free()->trace_event_enable_disable(). That > > + * combination effectively reverses the soft-mode/trigger state added > > + * by trigger registration. > > + * > > + * Must be called with event_mutex held. > > + */ > > +void > > +clear_event_triggers(struct trace_array *tr) > > +{ > > + struct ftrace_event_file *file; > > + > > + list_for_each_entry(file, &tr->events, list) { > > + struct event_trigger_data *data; > > + list_for_each_entry_rcu(data, &file->triggers, list) { > > + trace_event_trigger_enable_disable(file, 0); > > + if (data->ops->free) > > + data->ops->free(data->ops, (void **)&data); > > ditto here. >
Same here, that'll get fixed up too, as above.
Thanks,
Tom
> -- Steve > > > + } > > + } > > +} > > + > > +__init int register_trigger_cmds(void) > > +{ > > + return 0; > > +} > > diff --git a/kernel/trace/trace_syscalls.c b/kernel/trace/trace_syscalls.c > > index 230cdb6..4f56d54 100644 > > --- a/kernel/trace/trace_syscalls.c > > +++ b/kernel/trace/trace_syscalls.c > > @@ -321,6 +321,8 @@ static void ftrace_syscall_enter(void *data, struct pt_regs *regs, long id) > > if (!ftrace_file) > > return; > > > > + if (test_bit(FTRACE_EVENT_FL_TRIGGER_MODE_BIT, &ftrace_file->flags)) > > + event_triggers_call(ftrace_file); > > if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &ftrace_file->flags)) > > return; > > > > @@ -370,6 +372,8 @@ static void ftrace_syscall_exit(void *data, struct pt_regs *regs, long ret) > > if (!ftrace_file) > > return; > > > > + if (test_bit(FTRACE_EVENT_FL_TRIGGER_MODE_BIT, &ftrace_file->flags)) > > + event_triggers_call(ftrace_file); > > if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &ftrace_file->flags)) > > return; > > >
| |