// SPDX-License-Identifier: GPL-2.0/* * trace_events_trigger - trace event triggers * * Copyright (C) 2013 Tom Zanussi <tom.zanussi@linux.intel.com> */ #include <linux/security.h>#include <linux/module.h>#include <linux/ctype.h>#include <linux/mutex.h>#include <linux/slab.h>#include <linux/rculist.h> #include "trace.h" static LIST_HEAD(trigger_commands);static DEFINE_MUTEX(trigger_cmd_mutex); void trigger_data_free(struct event_trigger_data *data){	if (data->cmd_ops->set_filter)		data->cmd_ops->set_filter(NULL, data, NULL); 	/* make sure current triggers exit before free */	tracepoint_synchronize_unregister(); 	kfree(data);} /** * event_triggers_call - Call triggers associated with a trace event * @file: The trace_event_file associated with the event * @buffer: The ring buffer that the event is being written to * @rec: The trace entry for the event, NULL for unconditional invocation * @event: The event meta data in the ring buffer * * For each trigger associated with an event, invoke the trigger * function registered with the associated trigger command.  If rec is * non-NULL, it means that the trigger requires further processing and * shouldn't be unconditionally invoked.  If rec is non-NULL and the * trigger has a filter associated with it, rec will checked against * the filter and if the record matches the trigger will be invoked. * If the trigger is a 'post_trigger', meaning it shouldn't be invoked * in any case until the current event is written, the trigger * function isn't invoked but the bit associated with the deferred * trigger is set in the return value. * * Returns an enum event_trigger_type value containing a set bit for * any trigger that should be deferred, ETT_NONE if nothing to defer. * * Called from tracepoint handlers (with rcu_read_lock_sched() held). * * Return: an enum event_trigger_type value containing a set bit for * any trigger that should be deferred, ETT_NONE if nothing to defer. */enum event_trigger_typeevent_triggers_call(struct trace_event_file *file,		    struct trace_buffer *buffer, void *rec,		    struct ring_buffer_event *event){	struct event_trigger_data *data;	enum event_trigger_type tt = ETT_NONE;	struct event_filter *filter; 	if (list_empty(&file->triggers))		return tt; 	list_for_each_entry_rcu(data, &file->triggers, list) {		if (data->paused)			continue;		if (!rec) {			data->ops->trigger(data, buffer, rec, event);			continue;		}		filter = rcu_dereference_sched(data->filter);		if (filter && !filter_match_preds(filter, rec))			continue;		if (event_command_post_trigger(data->cmd_ops)) {			tt |= data->cmd_ops->trigger_type;			continue;		}		data->ops->trigger(data, buffer, rec, event);	}	return tt;}EXPORT_SYMBOL_GPL(event_triggers_call); bool __trace_trigger_soft_disabled(struct trace_event_file *file){	unsigned long eflags = file->flags; 	if (eflags & EVENT_FILE_FL_TRIGGER_MODE)		event_triggers_call(file, NULL, NULL, NULL);	if (eflags & EVENT_FILE_FL_SOFT_DISABLED)		return true;	if (eflags & EVENT_FILE_FL_PID_FILTER)		return trace_event_ignore_this_pid(file);	return false;}EXPORT_SYMBOL_GPL(__trace_trigger_soft_disabled); /** * event_triggers_post_call - Call 'post_triggers' for a trace event * @file: The trace_event_file associated with the event * @tt: enum event_trigger_type containing a set bit for each trigger to invoke * * For each trigger associated with an event, invoke the trigger * function registered with the associated trigger command, if the * corresponding bit is set in the tt enum passed into this function. * See @event_triggers_call for details on how those bits are set. * * Called from tracepoint handlers (with rcu_read_lock_sched() held). */voidevent_triggers_post_call(struct trace_event_file *file,			 enum event_trigger_type tt){	struct event_trigger_data *data; 	list_for_each_entry_rcu(data, &file->triggers, list) {		if (data->paused)			continue;		if (data->cmd_ops->trigger_type & tt)			data->ops->trigger(data, NULL, NULL, NULL);	}}EXPORT_SYMBOL_GPL(event_triggers_post_call); #define SHOW_AVAILABLE_TRIGGERS	(void *)(1UL) static void *trigger_next(struct seq_file *m, void *t, loff_t *pos){	struct trace_event_file *event_file = event_file_data(m->private); 	if (t == SHOW_AVAILABLE_TRIGGERS) {		(*pos)++;		return NULL;	}	return seq_list_next(t, &event_file->triggers, pos);} static bool check_user_trigger(struct trace_event_file *file){	struct event_trigger_data *data; 	list_for_each_entry_rcu(data, &file->triggers, list,				lockdep_is_held(&event_mutex)) {		if (data->flags & EVENT_TRIGGER_FL_PROBE)			continue;		return true;	}	return false;} static void *trigger_start(struct seq_file *m, loff_t *pos){	struct trace_event_file *event_file; 	/* ->stop() is called even if ->start() fails */	mutex_lock(&event_mutex);	event_file = event_file_file(m->private);	if (unlikely(!event_file))		return ERR_PTR(-ENODEV); 	if (list_empty(&event_file->triggers) || !check_user_trigger(event_file))		return *pos == 0 ? SHOW_AVAILABLE_TRIGGERS : NULL; 	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;	struct event_command *p; 	if (v == SHOW_AVAILABLE_TRIGGERS) {		seq_puts(m, "# Available triggers:\n");		seq_putc(m, '#');		mutex_lock(&trigger_cmd_mutex);		list_for_each_entry_reverse(p, &trigger_commands, list)			seq_printf(m, " %s", p->name);		seq_putc(m, '\n');		mutex_unlock(&trigger_cmd_mutex);		return 0;	} 	data = list_entry(v, struct event_trigger_data, list);	data->ops->print(m, 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; 	ret = security_locked_down(LOCKDOWN_TRACEFS);	if (ret)		return ret; 	guard(mutex)(&event_mutex); 	if (unlikely(!event_file_file(file)))		return -ENODEV; 	if ((file->f_mode & FMODE_WRITE) &&	    (file->f_flags & O_TRUNC)) {		struct trace_event_file *event_file;		struct event_command *p; 		event_file = event_file_data(file); 		list_for_each_entry(p, &trigger_commands, list) {			if (p->unreg_all)				p->unreg_all(event_file);		}	} 	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;		}	} 	return ret;} int trigger_process_regex(struct trace_event_file *file, char *buff){	char *command, *next;	struct event_command *p; 	next = buff = skip_spaces(buff);	command = strsep(&next, ": \t");	if (next) {		next = skip_spaces(next);		if (!*next)			next = NULL;	}	command = (command[0] != '!') ? command : command + 1; 	guard(mutex)(&trigger_cmd_mutex); 	list_for_each_entry(p, &trigger_commands, list) {		if (strcmp(p->name, command) == 0)			return p->parse(p, file, buff, command, next);	} 	return -EINVAL;} static ssize_t event_trigger_regex_write(struct file *file,					 const char __user *ubuf,					 size_t cnt, loff_t *ppos){	struct trace_event_file *event_file;	ssize_t ret;	char *buf __free(kfree) = NULL; 	if (!cnt)		return 0; 	if (cnt >= PAGE_SIZE)		return -EINVAL; 	buf = memdup_user_nul(ubuf, cnt);	if (IS_ERR(buf))		return PTR_ERR(buf); 	strim(buf); 	guard(mutex)(&event_mutex); 	event_file = event_file_file(file);	if (unlikely(!event_file))		return -ENODEV; 	ret = trigger_process_regex(event_file, buf);	if (ret < 0)		return ret; 	*ppos += cnt;	return cnt;} 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_tevent_trigger_write(struct file *filp, const char __user *ubuf,		    size_t cnt, loff_t *ppos){	return event_trigger_regex_write(filp, ubuf, cnt, ppos);} static intevent_trigger_open(struct inode *inode, struct file *filp){	/* Checks for tracefs lockdown */	return event_trigger_regex_open(inode, filp);} static intevent_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 = tracing_lseek,	.release = event_trigger_release,}; /* * Currently we only register event commands from __init, so mark this * __init too. */__init int register_event_command(struct event_command *cmd){	struct event_command *p; 	guard(mutex)(&trigger_cmd_mutex); 	list_for_each_entry(p, &trigger_commands, list) {		if (strcmp(cmd->name, p->name) == 0)			return -EBUSY;	}	list_add(&cmd->list, &trigger_commands); 	return 0;} /* * Currently we only unregister event commands from __init, so mark * this __init too. */__init int unregister_event_command(struct event_command *cmd){	struct event_command *p, *n; 	guard(mutex)(&trigger_cmd_mutex); 	list_for_each_entry_safe(p, n, &trigger_commands, list) {		if (strcmp(cmd->name, p->name) == 0) {			list_del_init(&p->list);			return 0;		}	} 	return -ENODEV;} /** * event_trigger_print - Generic event_trigger_ops @print implementation * @name: The name of the event trigger * @m: The seq_file being printed to * @data: Trigger-specific data * @filter_str: filter_str to print, if present * * Common implementation for event triggers to print themselves. * * Usually wrapped by a function that simply sets the @name of the * trigger command and then invokes this. * * Return: 0 on success, errno otherwise */static intevent_trigger_print(const char *name, struct seq_file *m,		    void *data, char *filter_str){	long count = (long)data; 	seq_puts(m, name); 	if (count == -1)		seq_puts(m, ":unlimited");	else		seq_printf(m, ":count=%ld", count); 	if (filter_str)		seq_printf(m, " if %s\n", filter_str);	else		seq_putc(m, '\n'); 	return 0;} /** * event_trigger_init - Generic event_trigger_ops @init implementation * @data: Trigger-specific data * * Common implementation of event trigger initialization. * * Usually used directly as the @init method in event trigger * implementations. * * Return: 0 on success, errno otherwise */int event_trigger_init(struct event_trigger_data *data){	data->ref++;	return 0;} /** * event_trigger_free - Generic event_trigger_ops @free implementation * @data: Trigger-specific data * * Common implementation of event trigger de-initialization. * * Usually used directly as the @free method in event trigger * implementations. */static voidevent_trigger_free(struct event_trigger_data *data){	if (WARN_ON_ONCE(data->ref <= 0))		return; 	data->ref--;	if (!data->ref)		trigger_data_free(data);} int trace_event_trigger_enable_disable(struct trace_event_file *file,				       int trigger_enable){	int ret = 0; 	if (trigger_enable) {		if (atomic_inc_return(&file->tm_ref) > 1)			return ret;		set_bit(EVENT_FILE_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(EVENT_FILE_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 * @tr: The trace array to clear * * 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. */voidclear_event_triggers(struct trace_array *tr){	struct trace_event_file *file; 	list_for_each_entry(file, &tr->events, list) {		struct event_trigger_data *data, *n;		list_for_each_entry_safe(data, n, &file->triggers, list) {			trace_event_trigger_enable_disable(file, 0);			list_del_rcu(&data->list);			if (data->ops->free)				data->ops->free(data);		}	}} 

Lines 1–500 of 2005. Load more