// 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/kthread.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); static struct task_struct *trigger_kthread;static struct llist_head trigger_data_free_list;static DEFINE_MUTEX(trigger_data_kthread_mutex); static int trigger_kthread_fn(void *ignore); static void trigger_create_kthread_locked(void){	lockdep_assert_held(&trigger_data_kthread_mutex); 	if (!trigger_kthread) {		struct task_struct *kthread; 		kthread = kthread_create(trigger_kthread_fn, NULL,					 "trigger_data_free");		if (!IS_ERR(kthread))			WRITE_ONCE(trigger_kthread, kthread);	}} static void trigger_data_free_queued_locked(void){	struct event_trigger_data *data, *tmp;	struct llist_node *llnodes; 	lockdep_assert_held(&trigger_data_kthread_mutex); 	llnodes = llist_del_all(&trigger_data_free_list);	if (!llnodes)		return; 	tracepoint_synchronize_unregister(); 	llist_for_each_entry_safe(data, tmp, llnodes, llist)		kfree(data);} /* Bulk garbage collection of event_trigger_data elements */static int trigger_kthread_fn(void *ignore){	struct event_trigger_data *data, *tmp;	struct llist_node *llnodes; 	/* Once this task starts, it lives forever */	for (;;) {		set_current_state(TASK_INTERRUPTIBLE);		if (llist_empty(&trigger_data_free_list))			schedule(); 		__set_current_state(TASK_RUNNING); 		llnodes = llist_del_all(&trigger_data_free_list); 		/* make sure current triggers exit before free */		tracepoint_synchronize_unregister(); 		llist_for_each_entry_safe(data, tmp, llnodes, llist)			kfree(data);	} 	return 0;} void trigger_data_free(struct event_trigger_data *data){	if (!data)		return; 	if (data->cmd_ops->set_filter)		data->cmd_ops->set_filter(NULL, data, NULL); 	/*	 * Boot-time trigger registration can fail before kthread creation	 * works. Keep the deferred-free semantics during boot and let late	 * init start the kthread to drain the list.	 */	if (system_state == SYSTEM_BOOTING && !trigger_kthread) {		llist_add(&data->llist, &trigger_data_free_list);		return;	} 	if (unlikely(!trigger_kthread)) {		guard(mutex)(&trigger_data_kthread_mutex); 		trigger_create_kthread_locked();		/* Check again after taking mutex */		if (!trigger_kthread) {			llist_add(&data->llist, &trigger_data_free_list);			/* Drain the queued frees synchronously if creation failed. */			trigger_data_free_queued_locked();			return;		}	} 	llist_add(&data->llist, &trigger_data_free_list);	wake_up_process(trigger_kthread);} static int __init trigger_data_free_init(void){	guard(mutex)(&trigger_data_kthread_mutex); 	if (llist_empty(&trigger_data_free_list))		return 0; 	trigger_create_kthread_locked();	if (trigger_kthread)		wake_up_process(trigger_kthread);	else		trigger_data_free_queued_locked(); 	return 0;}late_initcall(trigger_data_free_init); static inline void data_ops_trigger(struct event_trigger_data *data,				    struct trace_buffer *buffer,  void *rec,				    struct ring_buffer_event *event){	const struct event_command *cmd_ops = data->cmd_ops; 	if (data->flags & EVENT_TRIGGER_FL_COUNT) {		if (!cmd_ops->count_func(data, buffer, rec, event))			return;	} 	cmd_ops->trigger(data, buffer, rec, event);} /** * 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->cmd_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 = strim(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); 	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){	if (file->f_mode & FMODE_READ)		seq_release(inode, file); 	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_count - Optional count function for event triggers * @data: Trigger-specific data * @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 *

Lines 1–500 of 1983. Load more