xref: /linux/kernel/trace/trace_events_trigger.c (revision 9466b6ae6befa87b27cc13ee7263e01b9c48efc0)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * trace_events_trigger - trace event triggers
4  *
5  * Copyright (C) 2013 Tom Zanussi <tom.zanussi@linux.intel.com>
6  */
7 
8 #include <linux/security.h>
9 #include <linux/module.h>
10 #include <linux/ctype.h>
11 #include <linux/mutex.h>
12 #include <linux/slab.h>
13 #include <linux/rculist.h>
14 
15 #include "trace.h"
16 
17 static LIST_HEAD(trigger_commands);
18 static DEFINE_MUTEX(trigger_cmd_mutex);
19 
trigger_data_free(struct event_trigger_data * data)20 void trigger_data_free(struct event_trigger_data *data)
21 {
22 	if (data->cmd_ops->set_filter)
23 		data->cmd_ops->set_filter(NULL, data, NULL);
24 
25 	/* make sure current triggers exit before free */
26 	tracepoint_synchronize_unregister();
27 
28 	kfree(data);
29 }
30 
31 /**
32  * event_triggers_call - Call triggers associated with a trace event
33  * @file: The trace_event_file associated with the event
34  * @buffer: The ring buffer that the event is being written to
35  * @rec: The trace entry for the event, NULL for unconditional invocation
36  * @event: The event meta data in the ring buffer
37  *
38  * For each trigger associated with an event, invoke the trigger
39  * function registered with the associated trigger command.  If rec is
40  * non-NULL, it means that the trigger requires further processing and
41  * shouldn't be unconditionally invoked.  If rec is non-NULL and the
42  * trigger has a filter associated with it, rec will checked against
43  * the filter and if the record matches the trigger will be invoked.
44  * If the trigger is a 'post_trigger', meaning it shouldn't be invoked
45  * in any case until the current event is written, the trigger
46  * function isn't invoked but the bit associated with the deferred
47  * trigger is set in the return value.
48  *
49  * Returns an enum event_trigger_type value containing a set bit for
50  * any trigger that should be deferred, ETT_NONE if nothing to defer.
51  *
52  * Called from tracepoint handlers (with rcu_read_lock_sched() held).
53  *
54  * Return: an enum event_trigger_type value containing a set bit for
55  * any trigger that should be deferred, ETT_NONE if nothing to defer.
56  */
57 enum event_trigger_type
event_triggers_call(struct trace_event_file * file,struct trace_buffer * buffer,void * rec,struct ring_buffer_event * event)58 event_triggers_call(struct trace_event_file *file,
59 		    struct trace_buffer *buffer, void *rec,
60 		    struct ring_buffer_event *event)
61 {
62 	struct event_trigger_data *data;
63 	enum event_trigger_type tt = ETT_NONE;
64 	struct event_filter *filter;
65 
66 	if (list_empty(&file->triggers))
67 		return tt;
68 
69 	list_for_each_entry_rcu(data, &file->triggers, list) {
70 		if (data->paused)
71 			continue;
72 		if (!rec) {
73 			data->ops->trigger(data, buffer, rec, event);
74 			continue;
75 		}
76 		filter = rcu_dereference_sched(data->filter);
77 		if (filter && !filter_match_preds(filter, rec))
78 			continue;
79 		if (event_command_post_trigger(data->cmd_ops)) {
80 			tt |= data->cmd_ops->trigger_type;
81 			continue;
82 		}
83 		data->ops->trigger(data, buffer, rec, event);
84 	}
85 	return tt;
86 }
87 EXPORT_SYMBOL_GPL(event_triggers_call);
88 
__trace_trigger_soft_disabled(struct trace_event_file * file)89 bool __trace_trigger_soft_disabled(struct trace_event_file *file)
90 {
91 	unsigned long eflags = file->flags;
92 
93 	if (eflags & EVENT_FILE_FL_TRIGGER_MODE)
94 		event_triggers_call(file, NULL, NULL, NULL);
95 	if (eflags & EVENT_FILE_FL_SOFT_DISABLED)
96 		return true;
97 	if (eflags & EVENT_FILE_FL_PID_FILTER)
98 		return trace_event_ignore_this_pid(file);
99 	return false;
100 }
101 EXPORT_SYMBOL_GPL(__trace_trigger_soft_disabled);
102 
103 /**
104  * event_triggers_post_call - Call 'post_triggers' for a trace event
105  * @file: The trace_event_file associated with the event
106  * @tt: enum event_trigger_type containing a set bit for each trigger to invoke
107  *
108  * For each trigger associated with an event, invoke the trigger
109  * function registered with the associated trigger command, if the
110  * corresponding bit is set in the tt enum passed into this function.
111  * See @event_triggers_call for details on how those bits are set.
112  *
113  * Called from tracepoint handlers (with rcu_read_lock_sched() held).
114  */
115 void
event_triggers_post_call(struct trace_event_file * file,enum event_trigger_type tt)116 event_triggers_post_call(struct trace_event_file *file,
117 			 enum event_trigger_type tt)
118 {
119 	struct event_trigger_data *data;
120 
121 	list_for_each_entry_rcu(data, &file->triggers, list) {
122 		if (data->paused)
123 			continue;
124 		if (data->cmd_ops->trigger_type & tt)
125 			data->ops->trigger(data, NULL, NULL, NULL);
126 	}
127 }
128 EXPORT_SYMBOL_GPL(event_triggers_post_call);
129 
130 #define SHOW_AVAILABLE_TRIGGERS	(void *)(1UL)
131 
trigger_next(struct seq_file * m,void * t,loff_t * pos)132 static void *trigger_next(struct seq_file *m, void *t, loff_t *pos)
133 {
134 	struct trace_event_file *event_file = event_file_data(m->private);
135 
136 	if (t == SHOW_AVAILABLE_TRIGGERS) {
137 		(*pos)++;
138 		return NULL;
139 	}
140 	return seq_list_next(t, &event_file->triggers, pos);
141 }
142 
check_user_trigger(struct trace_event_file * file)143 static bool check_user_trigger(struct trace_event_file *file)
144 {
145 	struct event_trigger_data *data;
146 
147 	list_for_each_entry_rcu(data, &file->triggers, list,
148 				lockdep_is_held(&event_mutex)) {
149 		if (data->flags & EVENT_TRIGGER_FL_PROBE)
150 			continue;
151 		return true;
152 	}
153 	return false;
154 }
155 
trigger_start(struct seq_file * m,loff_t * pos)156 static void *trigger_start(struct seq_file *m, loff_t *pos)
157 {
158 	struct trace_event_file *event_file;
159 
160 	/* ->stop() is called even if ->start() fails */
161 	mutex_lock(&event_mutex);
162 	event_file = event_file_file(m->private);
163 	if (unlikely(!event_file))
164 		return ERR_PTR(-ENODEV);
165 
166 	if (list_empty(&event_file->triggers) || !check_user_trigger(event_file))
167 		return *pos == 0 ? SHOW_AVAILABLE_TRIGGERS : NULL;
168 
169 	return seq_list_start(&event_file->triggers, *pos);
170 }
171 
trigger_stop(struct seq_file * m,void * t)172 static void trigger_stop(struct seq_file *m, void *t)
173 {
174 	mutex_unlock(&event_mutex);
175 }
176 
trigger_show(struct seq_file * m,void * v)177 static int trigger_show(struct seq_file *m, void *v)
178 {
179 	struct event_trigger_data *data;
180 	struct event_command *p;
181 
182 	if (v == SHOW_AVAILABLE_TRIGGERS) {
183 		seq_puts(m, "# Available triggers:\n");
184 		seq_putc(m, '#');
185 		mutex_lock(&trigger_cmd_mutex);
186 		list_for_each_entry_reverse(p, &trigger_commands, list)
187 			seq_printf(m, " %s", p->name);
188 		seq_putc(m, '\n');
189 		mutex_unlock(&trigger_cmd_mutex);
190 		return 0;
191 	}
192 
193 	data = list_entry(v, struct event_trigger_data, list);
194 	data->ops->print(m, data);
195 
196 	return 0;
197 }
198 
199 static const struct seq_operations event_triggers_seq_ops = {
200 	.start = trigger_start,
201 	.next = trigger_next,
202 	.stop = trigger_stop,
203 	.show = trigger_show,
204 };
205 
event_trigger_regex_open(struct inode * inode,struct file * file)206 static int event_trigger_regex_open(struct inode *inode, struct file *file)
207 {
208 	int ret;
209 
210 	ret = security_locked_down(LOCKDOWN_TRACEFS);
211 	if (ret)
212 		return ret;
213 
214 	mutex_lock(&event_mutex);
215 
216 	if (unlikely(!event_file_file(file))) {
217 		mutex_unlock(&event_mutex);
218 		return -ENODEV;
219 	}
220 
221 	if ((file->f_mode & FMODE_WRITE) &&
222 	    (file->f_flags & O_TRUNC)) {
223 		struct trace_event_file *event_file;
224 		struct event_command *p;
225 
226 		event_file = event_file_data(file);
227 
228 		list_for_each_entry(p, &trigger_commands, list) {
229 			if (p->unreg_all)
230 				p->unreg_all(event_file);
231 		}
232 	}
233 
234 	if (file->f_mode & FMODE_READ) {
235 		ret = seq_open(file, &event_triggers_seq_ops);
236 		if (!ret) {
237 			struct seq_file *m = file->private_data;
238 			m->private = file;
239 		}
240 	}
241 
242 	mutex_unlock(&event_mutex);
243 
244 	return ret;
245 }
246 
trigger_process_regex(struct trace_event_file * file,char * buff)247 int trigger_process_regex(struct trace_event_file *file, char *buff)
248 {
249 	char *command, *next;
250 	struct event_command *p;
251 	int ret = -EINVAL;
252 
253 	next = buff = skip_spaces(buff);
254 	command = strsep(&next, ": \t");
255 	if (next) {
256 		next = skip_spaces(next);
257 		if (!*next)
258 			next = NULL;
259 	}
260 	command = (command[0] != '!') ? command : command + 1;
261 
262 	mutex_lock(&trigger_cmd_mutex);
263 	list_for_each_entry(p, &trigger_commands, list) {
264 		if (strcmp(p->name, command) == 0) {
265 			ret = p->parse(p, file, buff, command, next);
266 			goto out_unlock;
267 		}
268 	}
269  out_unlock:
270 	mutex_unlock(&trigger_cmd_mutex);
271 
272 	return ret;
273 }
274 
event_trigger_regex_write(struct file * file,const char __user * ubuf,size_t cnt,loff_t * ppos)275 static ssize_t event_trigger_regex_write(struct file *file,
276 					 const char __user *ubuf,
277 					 size_t cnt, loff_t *ppos)
278 {
279 	struct trace_event_file *event_file;
280 	ssize_t ret;
281 	char *buf;
282 
283 	if (!cnt)
284 		return 0;
285 
286 	if (cnt >= PAGE_SIZE)
287 		return -EINVAL;
288 
289 	buf = memdup_user_nul(ubuf, cnt);
290 	if (IS_ERR(buf))
291 		return PTR_ERR(buf);
292 
293 	strim(buf);
294 
295 	mutex_lock(&event_mutex);
296 	event_file = event_file_file(file);
297 	if (unlikely(!event_file)) {
298 		mutex_unlock(&event_mutex);
299 		kfree(buf);
300 		return -ENODEV;
301 	}
302 	ret = trigger_process_regex(event_file, buf);
303 	mutex_unlock(&event_mutex);
304 
305 	kfree(buf);
306 	if (ret < 0)
307 		goto out;
308 
309 	*ppos += cnt;
310 	ret = cnt;
311  out:
312 	return ret;
313 }
314 
event_trigger_regex_release(struct inode * inode,struct file * file)315 static int event_trigger_regex_release(struct inode *inode, struct file *file)
316 {
317 	mutex_lock(&event_mutex);
318 
319 	if (file->f_mode & FMODE_READ)
320 		seq_release(inode, file);
321 
322 	mutex_unlock(&event_mutex);
323 
324 	return 0;
325 }
326 
327 static ssize_t
event_trigger_write(struct file * filp,const char __user * ubuf,size_t cnt,loff_t * ppos)328 event_trigger_write(struct file *filp, const char __user *ubuf,
329 		    size_t cnt, loff_t *ppos)
330 {
331 	return event_trigger_regex_write(filp, ubuf, cnt, ppos);
332 }
333 
334 static int
event_trigger_open(struct inode * inode,struct file * filp)335 event_trigger_open(struct inode *inode, struct file *filp)
336 {
337 	/* Checks for tracefs lockdown */
338 	return event_trigger_regex_open(inode, filp);
339 }
340 
341 static int
event_trigger_release(struct inode * inode,struct file * file)342 event_trigger_release(struct inode *inode, struct file *file)
343 {
344 	return event_trigger_regex_release(inode, file);
345 }
346 
347 const struct file_operations event_trigger_fops = {
348 	.open = event_trigger_open,
349 	.read = seq_read,
350 	.write = event_trigger_write,
351 	.llseek = tracing_lseek,
352 	.release = event_trigger_release,
353 };
354 
355 /*
356  * Currently we only register event commands from __init, so mark this
357  * __init too.
358  */
register_event_command(struct event_command * cmd)359 __init int register_event_command(struct event_command *cmd)
360 {
361 	struct event_command *p;
362 	int ret = 0;
363 
364 	mutex_lock(&trigger_cmd_mutex);
365 	list_for_each_entry(p, &trigger_commands, list) {
366 		if (strcmp(cmd->name, p->name) == 0) {
367 			ret = -EBUSY;
368 			goto out_unlock;
369 		}
370 	}
371 	list_add(&cmd->list, &trigger_commands);
372  out_unlock:
373 	mutex_unlock(&trigger_cmd_mutex);
374 
375 	return ret;
376 }
377 
378 /*
379  * Currently we only unregister event commands from __init, so mark
380  * this __init too.
381  */
unregister_event_command(struct event_command * cmd)382 __init int unregister_event_command(struct event_command *cmd)
383 {
384 	struct event_command *p, *n;
385 	int ret = -ENODEV;
386 
387 	mutex_lock(&trigger_cmd_mutex);
388 	list_for_each_entry_safe(p, n, &trigger_commands, list) {
389 		if (strcmp(cmd->name, p->name) == 0) {
390 			ret = 0;
391 			list_del_init(&p->list);
392 			goto out_unlock;
393 		}
394 	}
395  out_unlock:
396 	mutex_unlock(&trigger_cmd_mutex);
397 
398 	return ret;
399 }
400 
401 /**
402  * event_trigger_print - Generic event_trigger_ops @print implementation
403  * @name: The name of the event trigger
404  * @m: The seq_file being printed to
405  * @data: Trigger-specific data
406  * @filter_str: filter_str to print, if present
407  *
408  * Common implementation for event triggers to print themselves.
409  *
410  * Usually wrapped by a function that simply sets the @name of the
411  * trigger command and then invokes this.
412  *
413  * Return: 0 on success, errno otherwise
414  */
415 static int
event_trigger_print(const char * name,struct seq_file * m,void * data,char * filter_str)416 event_trigger_print(const char *name, struct seq_file *m,
417 		    void *data, char *filter_str)
418 {
419 	long count = (long)data;
420 
421 	seq_puts(m, name);
422 
423 	if (count == -1)
424 		seq_puts(m, ":unlimited");
425 	else
426 		seq_printf(m, ":count=%ld", count);
427 
428 	if (filter_str)
429 		seq_printf(m, " if %s\n", filter_str);
430 	else
431 		seq_putc(m, '\n');
432 
433 	return 0;
434 }
435 
436 /**
437  * event_trigger_init - Generic event_trigger_ops @init implementation
438  * @data: Trigger-specific data
439  *
440  * Common implementation of event trigger initialization.
441  *
442  * Usually used directly as the @init method in event trigger
443  * implementations.
444  *
445  * Return: 0 on success, errno otherwise
446  */
event_trigger_init(struct event_trigger_data * data)447 int event_trigger_init(struct event_trigger_data *data)
448 {
449 	data->ref++;
450 	return 0;
451 }
452 
453 /**
454  * event_trigger_free - Generic event_trigger_ops @free implementation
455  * @data: Trigger-specific data
456  *
457  * Common implementation of event trigger de-initialization.
458  *
459  * Usually used directly as the @free method in event trigger
460  * implementations.
461  */
462 static void
event_trigger_free(struct event_trigger_data * data)463 event_trigger_free(struct event_trigger_data *data)
464 {
465 	if (WARN_ON_ONCE(data->ref <= 0))
466 		return;
467 
468 	data->ref--;
469 	if (!data->ref)
470 		trigger_data_free(data);
471 }
472 
trace_event_trigger_enable_disable(struct trace_event_file * file,int trigger_enable)473 int trace_event_trigger_enable_disable(struct trace_event_file *file,
474 				       int trigger_enable)
475 {
476 	int ret = 0;
477 
478 	if (trigger_enable) {
479 		if (atomic_inc_return(&file->tm_ref) > 1)
480 			return ret;
481 		set_bit(EVENT_FILE_FL_TRIGGER_MODE_BIT, &file->flags);
482 		ret = trace_event_enable_disable(file, 1, 1);
483 	} else {
484 		if (atomic_dec_return(&file->tm_ref) > 0)
485 			return ret;
486 		clear_bit(EVENT_FILE_FL_TRIGGER_MODE_BIT, &file->flags);
487 		ret = trace_event_enable_disable(file, 0, 1);
488 	}
489 
490 	return ret;
491 }
492 
493 /**
494  * clear_event_triggers - Clear all triggers associated with a trace array
495  * @tr: The trace array to clear
496  *
497  * For each trigger, the triggering event has its tm_ref decremented
498  * via trace_event_trigger_enable_disable(), and any associated event
499  * (in the case of enable/disable_event triggers) will have its sm_ref
500  * decremented via free()->trace_event_enable_disable().  That
501  * combination effectively reverses the soft-mode/trigger state added
502  * by trigger registration.
503  *
504  * Must be called with event_mutex held.
505  */
506 void
clear_event_triggers(struct trace_array * tr)507 clear_event_triggers(struct trace_array *tr)
508 {
509 	struct trace_event_file *file;
510 
511 	list_for_each_entry(file, &tr->events, list) {
512 		struct event_trigger_data *data, *n;
513 		list_for_each_entry_safe(data, n, &file->triggers, list) {
514 			trace_event_trigger_enable_disable(file, 0);
515 			list_del_rcu(&data->list);
516 			if (data->ops->free)
517 				data->ops->free(data);
518 		}
519 	}
520 }
521 
522 /**
523  * update_cond_flag - Set or reset the TRIGGER_COND bit
524  * @file: The trace_event_file associated with the event
525  *
526  * If an event has triggers and any of those triggers has a filter or
527  * a post_trigger, trigger invocation needs to be deferred until after
528  * the current event has logged its data, and the event should have
529  * its TRIGGER_COND bit set, otherwise the TRIGGER_COND bit should be
530  * cleared.
531  */
update_cond_flag(struct trace_event_file * file)532 void update_cond_flag(struct trace_event_file *file)
533 {
534 	struct event_trigger_data *data;
535 	bool set_cond = false;
536 
537 	lockdep_assert_held(&event_mutex);
538 
539 	list_for_each_entry(data, &file->triggers, list) {
540 		if (data->filter || event_command_post_trigger(data->cmd_ops) ||
541 		    event_command_needs_rec(data->cmd_ops)) {
542 			set_cond = true;
543 			break;
544 		}
545 	}
546 
547 	if (set_cond)
548 		set_bit(EVENT_FILE_FL_TRIGGER_COND_BIT, &file->flags);
549 	else
550 		clear_bit(EVENT_FILE_FL_TRIGGER_COND_BIT, &file->flags);
551 }
552 
553 /**
554  * register_trigger - Generic event_command @reg implementation
555  * @glob: The raw string used to register the trigger
556  * @data: Trigger-specific data to associate with the trigger
557  * @file: The trace_event_file associated with the event
558  *
559  * Common implementation for event trigger registration.
560  *
561  * Usually used directly as the @reg method in event command
562  * implementations.
563  *
564  * Return: 0 on success, errno otherwise
565  */
register_trigger(char * glob,struct event_trigger_data * data,struct trace_event_file * file)566 static int register_trigger(char *glob,
567 			    struct event_trigger_data *data,
568 			    struct trace_event_file *file)
569 {
570 	struct event_trigger_data *test;
571 	int ret = 0;
572 
573 	lockdep_assert_held(&event_mutex);
574 
575 	list_for_each_entry(test, &file->triggers, list) {
576 		if (test->cmd_ops->trigger_type == data->cmd_ops->trigger_type) {
577 			ret = -EEXIST;
578 			goto out;
579 		}
580 	}
581 
582 	if (data->ops->init) {
583 		ret = data->ops->init(data);
584 		if (ret < 0)
585 			goto out;
586 	}
587 
588 	list_add_rcu(&data->list, &file->triggers);
589 
590 	update_cond_flag(file);
591 	ret = trace_event_trigger_enable_disable(file, 1);
592 	if (ret < 0) {
593 		list_del_rcu(&data->list);
594 		update_cond_flag(file);
595 	}
596 out:
597 	return ret;
598 }
599 
600 /*
601  * True if the trigger was found and unregistered, else false.
602  */
try_unregister_trigger(char * glob,struct event_trigger_data * test,struct trace_event_file * file)603 static bool try_unregister_trigger(char *glob,
604 				   struct event_trigger_data *test,
605 				   struct trace_event_file *file)
606 {
607 	struct event_trigger_data *data = NULL, *iter;
608 
609 	lockdep_assert_held(&event_mutex);
610 
611 	list_for_each_entry(iter, &file->triggers, list) {
612 		if (iter->cmd_ops->trigger_type == test->cmd_ops->trigger_type) {
613 			data = iter;
614 			list_del_rcu(&data->list);
615 			trace_event_trigger_enable_disable(file, 0);
616 			update_cond_flag(file);
617 			break;
618 		}
619 	}
620 
621 	if (data) {
622 		if (data->ops->free)
623 			data->ops->free(data);
624 
625 		return true;
626 	}
627 
628 	return false;
629 }
630 
631 /**
632  * unregister_trigger - Generic event_command @unreg implementation
633  * @glob: The raw string used to register the trigger
634  * @test: Trigger-specific data used to find the trigger to remove
635  * @file: The trace_event_file associated with the event
636  *
637  * Common implementation for event trigger unregistration.
638  *
639  * Usually used directly as the @unreg method in event command
640  * implementations.
641  */
unregister_trigger(char * glob,struct event_trigger_data * test,struct trace_event_file * file)642 static void unregister_trigger(char *glob,
643 			       struct event_trigger_data *test,
644 			       struct trace_event_file *file)
645 {
646 	try_unregister_trigger(glob, test, file);
647 }
648 
649 /*
650  * Event trigger parsing helper functions.
651  *
652  * These functions help make it easier to write an event trigger
653  * parsing function i.e. the struct event_command.parse() callback
654  * function responsible for parsing and registering a trigger command
655  * written to the 'trigger' file.
656  *
657  * A trigger command (or just 'trigger' for short) takes the form:
658  *   [trigger] [if filter]
659  *
660  * The struct event_command.parse() callback (and other struct
661  * event_command functions) refer to several components of a trigger
662  * command.  Those same components are referenced by the event trigger
663  * parsing helper functions defined below.  These components are:
664  *
665  *   cmd               - the trigger command name
666  *   glob              - the trigger command name optionally prefaced with '!'
667  *   param_and_filter  - text following cmd and ':'
668  *   param             - text following cmd and ':' and stripped of filter
669  *   filter            - the optional filter text following (and including) 'if'
670  *
671  * To illustrate the use of these componenents, here are some concrete
672  * examples. For the following triggers:
673  *
674  *   echo 'traceon:5 if pid == 0' > trigger
675  *     - 'traceon' is both cmd and glob
676  *     - '5 if pid == 0' is the param_and_filter
677  *     - '5' is the param
678  *     - 'if pid == 0' is the filter
679  *
680  *   echo 'enable_event:sys:event:n' > trigger
681  *     - 'enable_event' is both cmd and glob
682  *     - 'sys:event:n' is the param_and_filter
683  *     - 'sys:event:n' is the param
684  *     - there is no filter
685  *
686  *   echo 'hist:keys=pid if prio > 50' > trigger
687  *     - 'hist' is both cmd and glob
688  *     - 'keys=pid if prio > 50' is the param_and_filter
689  *     - 'keys=pid' is the param
690  *     - 'if prio > 50' is the filter
691  *
692  *   echo '!enable_event:sys:event:n' > trigger
693  *     - 'enable_event' the cmd
694  *     - '!enable_event' is the glob
695  *     - 'sys:event:n' is the param_and_filter
696  *     - 'sys:event:n' is the param
697  *     - there is no filter
698  *
699  *   echo 'traceoff' > trigger
700  *     - 'traceoff' is both cmd and glob
701  *     - there is no param_and_filter
702  *     - there is no param
703  *     - there is no filter
704  *
705  * There are a few different categories of event trigger covered by
706  * these helpers:
707  *
708  *  - triggers that don't require a parameter e.g. traceon
709  *  - triggers that do require a parameter e.g. enable_event and hist
710  *  - triggers that though they may not require a param may support an
711  *    optional 'n' param (n = number of times the trigger should fire)
712  *    e.g.: traceon:5 or enable_event:sys:event:n
713  *  - triggers that do not support an 'n' param e.g. hist
714  *
715  * These functions can be used or ignored as necessary - it all
716  * depends on the complexity of the trigger, and the granularity of
717  * the functions supported reflects the fact that some implementations
718  * may need to customize certain aspects of their implementations and
719  * won't need certain functions.  For instance, the hist trigger
720  * implementation doesn't use event_trigger_separate_filter() because
721  * it has special requirements for handling the filter.
722  */
723 
724 /**
725  * event_trigger_check_remove - check whether an event trigger specifies remove
726  * @glob: The trigger command string, with optional remove(!) operator
727  *
728  * The event trigger callback implementations pass in 'glob' as a
729  * parameter.  This is the command name either with or without a
730  * remove(!)  operator.  This function simply parses the glob and
731  * determines whether the command corresponds to a trigger removal or
732  * a trigger addition.
733  *
734  * Return: true if this is a remove command, false otherwise
735  */
event_trigger_check_remove(const char * glob)736 bool event_trigger_check_remove(const char *glob)
737 {
738 	return (glob && glob[0] == '!') ? true : false;
739 }
740 
741 /**
742  * event_trigger_empty_param - check whether the param is empty
743  * @param: The trigger param string
744  *
745  * The event trigger callback implementations pass in 'param' as a
746  * parameter.  This corresponds to the string following the command
747  * name minus the command name.  This function can be called by a
748  * callback implementation for any command that requires a param; a
749  * callback that doesn't require a param can ignore it.
750  *
751  * Return: true if this is an empty param, false otherwise
752  */
event_trigger_empty_param(const char * param)753 bool event_trigger_empty_param(const char *param)
754 {
755 	return !param;
756 }
757 
758 /**
759  * event_trigger_separate_filter - separate an event trigger from a filter
760  * @param_and_filter: String containing trigger and possibly filter
761  * @param: outparam, will be filled with a pointer to the trigger
762  * @filter: outparam, will be filled with a pointer to the filter
763  * @param_required: Specifies whether or not the param string is required
764  *
765  * Given a param string of the form '[trigger] [if filter]', this
766  * function separates the filter from the trigger and returns the
767  * trigger in @param and the filter in @filter.  Either the @param
768  * or the @filter may be set to NULL by this function - if not set to
769  * NULL, they will contain strings corresponding to the trigger and
770  * filter.
771  *
772  * There are two cases that need to be handled with respect to the
773  * passed-in param: either the param is required, or it is not
774  * required.  If @param_required is set, and there's no param, it will
775  * return -EINVAL.  If @param_required is not set and there's a param
776  * that starts with a number, that corresponds to the case of a
777  * trigger with :n (n = number of times the trigger should fire) and
778  * the parsing continues normally; otherwise the function just returns
779  * and assumes param just contains a filter and there's nothing else
780  * to do.
781  *
782  * Return: 0 on success, errno otherwise
783  */
event_trigger_separate_filter(char * param_and_filter,char ** param,char ** filter,bool param_required)784 int event_trigger_separate_filter(char *param_and_filter, char **param,
785 				  char **filter, bool param_required)
786 {
787 	int ret = 0;
788 
789 	*param = *filter = NULL;
790 
791 	if (!param_and_filter) {
792 		if (param_required)
793 			ret = -EINVAL;
794 		goto out;
795 	}
796 
797 	/*
798 	 * Here we check for an optional param. The only legal
799 	 * optional param is :n, and if that's the case, continue
800 	 * below. Otherwise we assume what's left is a filter and
801 	 * return it as the filter string for the caller to deal with.
802 	 */
803 	if (!param_required && param_and_filter && !isdigit(param_and_filter[0])) {
804 		*filter = param_and_filter;
805 		goto out;
806 	}
807 
808 	/*
809 	 * Separate the param from the filter (param [if filter]).
810 	 * Here we have either an optional :n param or a required
811 	 * param and an optional filter.
812 	 */
813 	*param = strsep(&param_and_filter, " \t");
814 
815 	/*
816 	 * Here we have a filter, though it may be empty.
817 	 */
818 	if (param_and_filter) {
819 		*filter = skip_spaces(param_and_filter);
820 		if (!**filter)
821 			*filter = NULL;
822 	}
823 out:
824 	return ret;
825 }
826 
827 /**
828  * event_trigger_alloc - allocate and init event_trigger_data for a trigger
829  * @cmd_ops: The event_command operations for the trigger
830  * @cmd: The cmd string
831  * @param: The param string
832  * @private_data: User data to associate with the event trigger
833  *
834  * Allocate an event_trigger_data instance and initialize it.  The
835  * @cmd_ops are used along with the @cmd and @param to get the
836  * trigger_ops to assign to the event_trigger_data.  @private_data can
837  * also be passed in and associated with the event_trigger_data.
838  *
839  * Use event_trigger_free() to free an event_trigger_data object.
840  *
841  * Return: The trigger_data object success, NULL otherwise
842  */
event_trigger_alloc(struct event_command * cmd_ops,char * cmd,char * param,void * private_data)843 struct event_trigger_data *event_trigger_alloc(struct event_command *cmd_ops,
844 					       char *cmd,
845 					       char *param,
846 					       void *private_data)
847 {
848 	struct event_trigger_data *trigger_data;
849 	struct event_trigger_ops *trigger_ops;
850 
851 	trigger_ops = cmd_ops->get_trigger_ops(cmd, param);
852 
853 	trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);
854 	if (!trigger_data)
855 		return NULL;
856 
857 	trigger_data->count = -1;
858 	trigger_data->ops = trigger_ops;
859 	trigger_data->cmd_ops = cmd_ops;
860 	trigger_data->private_data = private_data;
861 
862 	INIT_LIST_HEAD(&trigger_data->list);
863 	INIT_LIST_HEAD(&trigger_data->named_list);
864 	RCU_INIT_POINTER(trigger_data->filter, NULL);
865 
866 	return trigger_data;
867 }
868 
869 /**
870  * event_trigger_parse_num - parse and return the number param for a trigger
871  * @param: The param string
872  * @trigger_data: The trigger_data for the trigger
873  *
874  * Parse the :n (n = number of times the trigger should fire) param
875  * and set the count variable in the trigger_data to the parsed count.
876  *
877  * Return: 0 on success, errno otherwise
878  */
event_trigger_parse_num(char * param,struct event_trigger_data * trigger_data)879 int event_trigger_parse_num(char *param,
880 			    struct event_trigger_data *trigger_data)
881 {
882 	char *number;
883 	int ret = 0;
884 
885 	if (param) {
886 		number = strsep(&param, ":");
887 
888 		if (!strlen(number))
889 			return -EINVAL;
890 
891 		/*
892 		 * We use the callback data field (which is a pointer)
893 		 * as our counter.
894 		 */
895 		ret = kstrtoul(number, 0, &trigger_data->count);
896 	}
897 
898 	return ret;
899 }
900 
901 /**
902  * event_trigger_set_filter - set an event trigger's filter
903  * @cmd_ops: The event_command operations for the trigger
904  * @file: The event file for the trigger's event
905  * @param: The string containing the filter
906  * @trigger_data: The trigger_data for the trigger
907  *
908  * Set the filter for the trigger.  If the filter is NULL, just return
909  * without error.
910  *
911  * Return: 0 on success, errno otherwise
912  */
event_trigger_set_filter(struct event_command * cmd_ops,struct trace_event_file * file,char * param,struct event_trigger_data * trigger_data)913 int event_trigger_set_filter(struct event_command *cmd_ops,
914 			     struct trace_event_file *file,
915 			     char *param,
916 			     struct event_trigger_data *trigger_data)
917 {
918 	if (param && cmd_ops->set_filter)
919 		return cmd_ops->set_filter(param, trigger_data, file);
920 
921 	return 0;
922 }
923 
924 /**
925  * event_trigger_reset_filter - reset an event trigger's filter
926  * @cmd_ops: The event_command operations for the trigger
927  * @trigger_data: The trigger_data for the trigger
928  *
929  * Reset the filter for the trigger to no filter.
930  */
event_trigger_reset_filter(struct event_command * cmd_ops,struct event_trigger_data * trigger_data)931 void event_trigger_reset_filter(struct event_command *cmd_ops,
932 				struct event_trigger_data *trigger_data)
933 {
934 	if (cmd_ops->set_filter)
935 		cmd_ops->set_filter(NULL, trigger_data, NULL);
936 }
937 
938 /**
939  * event_trigger_register - register an event trigger
940  * @cmd_ops: The event_command operations for the trigger
941  * @file: The event file for the trigger's event
942  * @glob: The trigger command string, with optional remove(!) operator
943  * @trigger_data: The trigger_data for the trigger
944  *
945  * Register an event trigger.  The @cmd_ops are used to call the
946  * cmd_ops->reg() function which actually does the registration.
947  *
948  * Return: 0 on success, errno otherwise
949  */
event_trigger_register(struct event_command * cmd_ops,struct trace_event_file * file,char * glob,struct event_trigger_data * trigger_data)950 int event_trigger_register(struct event_command *cmd_ops,
951 			   struct trace_event_file *file,
952 			   char *glob,
953 			   struct event_trigger_data *trigger_data)
954 {
955 	return cmd_ops->reg(glob, trigger_data, file);
956 }
957 
958 /**
959  * event_trigger_unregister - unregister an event trigger
960  * @cmd_ops: The event_command operations for the trigger
961  * @file: The event file for the trigger's event
962  * @glob: The trigger command string, with optional remove(!) operator
963  * @trigger_data: The trigger_data for the trigger
964  *
965  * Unregister an event trigger.  The @cmd_ops are used to call the
966  * cmd_ops->unreg() function which actually does the unregistration.
967  */
event_trigger_unregister(struct event_command * cmd_ops,struct trace_event_file * file,char * glob,struct event_trigger_data * trigger_data)968 void event_trigger_unregister(struct event_command *cmd_ops,
969 			      struct trace_event_file *file,
970 			      char *glob,
971 			      struct event_trigger_data *trigger_data)
972 {
973 	cmd_ops->unreg(glob, trigger_data, file);
974 }
975 
976 /*
977  * End event trigger parsing helper functions.
978  */
979 
980 /**
981  * event_trigger_parse - Generic event_command @parse implementation
982  * @cmd_ops: The command ops, used for trigger registration
983  * @file: The trace_event_file associated with the event
984  * @glob: The raw string used to register the trigger
985  * @cmd: The cmd portion of the string used to register the trigger
986  * @param_and_filter: The param and filter portion of the string used to register the trigger
987  *
988  * Common implementation for event command parsing and trigger
989  * instantiation.
990  *
991  * Usually used directly as the @parse method in event command
992  * implementations.
993  *
994  * Return: 0 on success, errno otherwise
995  */
996 static int
event_trigger_parse(struct event_command * cmd_ops,struct trace_event_file * file,char * glob,char * cmd,char * param_and_filter)997 event_trigger_parse(struct event_command *cmd_ops,
998 		    struct trace_event_file *file,
999 		    char *glob, char *cmd, char *param_and_filter)
1000 {
1001 	struct event_trigger_data *trigger_data;
1002 	char *param, *filter;
1003 	bool remove;
1004 	int ret;
1005 
1006 	remove = event_trigger_check_remove(glob);
1007 
1008 	ret = event_trigger_separate_filter(param_and_filter, &param, &filter, false);
1009 	if (ret)
1010 		return ret;
1011 
1012 	ret = -ENOMEM;
1013 	trigger_data = event_trigger_alloc(cmd_ops, cmd, param, file);
1014 	if (!trigger_data)
1015 		goto out;
1016 
1017 	if (remove) {
1018 		event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
1019 		kfree(trigger_data);
1020 		ret = 0;
1021 		goto out;
1022 	}
1023 
1024 	ret = event_trigger_parse_num(param, trigger_data);
1025 	if (ret)
1026 		goto out_free;
1027 
1028 	ret = event_trigger_set_filter(cmd_ops, file, filter, trigger_data);
1029 	if (ret < 0)
1030 		goto out_free;
1031 
1032 	/* Up the trigger_data count to make sure reg doesn't free it on failure */
1033 	event_trigger_init(trigger_data);
1034 
1035 	ret = event_trigger_register(cmd_ops, file, glob, trigger_data);
1036 	if (ret)
1037 		goto out_free;
1038 
1039 	/* Down the counter of trigger_data or free it if not used anymore */
1040 	event_trigger_free(trigger_data);
1041  out:
1042 	return ret;
1043 
1044  out_free:
1045 	event_trigger_reset_filter(cmd_ops, trigger_data);
1046 	kfree(trigger_data);
1047 	goto out;
1048 }
1049 
1050 /**
1051  * set_trigger_filter - Generic event_command @set_filter implementation
1052  * @filter_str: The filter string for the trigger, NULL to remove filter
1053  * @trigger_data: Trigger-specific data
1054  * @file: The trace_event_file associated with the event
1055  *
1056  * Common implementation for event command filter parsing and filter
1057  * instantiation.
1058  *
1059  * Usually used directly as the @set_filter method in event command
1060  * implementations.
1061  *
1062  * Also used to remove a filter (if filter_str = NULL).
1063  *
1064  * Return: 0 on success, errno otherwise
1065  */
set_trigger_filter(char * filter_str,struct event_trigger_data * trigger_data,struct trace_event_file * file)1066 int set_trigger_filter(char *filter_str,
1067 		       struct event_trigger_data *trigger_data,
1068 		       struct trace_event_file *file)
1069 {
1070 	struct event_trigger_data *data = trigger_data;
1071 	struct event_filter *filter = NULL, *tmp;
1072 	int ret = -EINVAL;
1073 	char *s;
1074 
1075 	if (!filter_str) /* clear the current filter */
1076 		goto assign;
1077 
1078 	s = strsep(&filter_str, " \t");
1079 
1080 	if (!strlen(s) || strcmp(s, "if") != 0)
1081 		goto out;
1082 
1083 	if (!filter_str)
1084 		goto out;
1085 
1086 	/* The filter is for the 'trigger' event, not the triggered event */
1087 	ret = create_event_filter(file->tr, file->event_call,
1088 				  filter_str, true, &filter);
1089 
1090 	/* Only enabled set_str for error handling */
1091 	if (filter) {
1092 		kfree(filter->filter_string);
1093 		filter->filter_string = NULL;
1094 	}
1095 
1096 	/*
1097 	 * If create_event_filter() fails, filter still needs to be freed.
1098 	 * Which the calling code will do with data->filter.
1099 	 */
1100  assign:
1101 	tmp = rcu_access_pointer(data->filter);
1102 
1103 	rcu_assign_pointer(data->filter, filter);
1104 
1105 	if (tmp) {
1106 		/*
1107 		 * Make sure the call is done with the filter.
1108 		 * It is possible that a filter could fail at boot up,
1109 		 * and then this path will be called. Avoid the synchronization
1110 		 * in that case.
1111 		 */
1112 		if (system_state != SYSTEM_BOOTING)
1113 			tracepoint_synchronize_unregister();
1114 		free_event_filter(tmp);
1115 	}
1116 
1117 	kfree(data->filter_str);
1118 	data->filter_str = NULL;
1119 
1120 	if (filter_str) {
1121 		data->filter_str = kstrdup(filter_str, GFP_KERNEL);
1122 		if (!data->filter_str) {
1123 			free_event_filter(rcu_access_pointer(data->filter));
1124 			data->filter = NULL;
1125 			ret = -ENOMEM;
1126 		}
1127 	}
1128  out:
1129 	return ret;
1130 }
1131 
1132 static LIST_HEAD(named_triggers);
1133 
1134 /**
1135  * find_named_trigger - Find the common named trigger associated with @name
1136  * @name: The name of the set of named triggers to find the common data for
1137  *
1138  * Named triggers are sets of triggers that share a common set of
1139  * trigger data.  The first named trigger registered with a given name
1140  * owns the common trigger data that the others subsequently
1141  * registered with the same name will reference.  This function
1142  * returns the common trigger data associated with that first
1143  * registered instance.
1144  *
1145  * Return: the common trigger data for the given named trigger on
1146  * success, NULL otherwise.
1147  */
find_named_trigger(const char * name)1148 struct event_trigger_data *find_named_trigger(const char *name)
1149 {
1150 	struct event_trigger_data *data;
1151 
1152 	if (!name)
1153 		return NULL;
1154 
1155 	list_for_each_entry(data, &named_triggers, named_list) {
1156 		if (data->named_data)
1157 			continue;
1158 		if (strcmp(data->name, name) == 0)
1159 			return data;
1160 	}
1161 
1162 	return NULL;
1163 }
1164 
1165 /**
1166  * is_named_trigger - determine if a given trigger is a named trigger
1167  * @test: The trigger data to test
1168  *
1169  * Return: true if 'test' is a named trigger, false otherwise.
1170  */
is_named_trigger(struct event_trigger_data * test)1171 bool is_named_trigger(struct event_trigger_data *test)
1172 {
1173 	struct event_trigger_data *data;
1174 
1175 	list_for_each_entry(data, &named_triggers, named_list) {
1176 		if (test == data)
1177 			return true;
1178 	}
1179 
1180 	return false;
1181 }
1182 
1183 /**
1184  * save_named_trigger - save the trigger in the named trigger list
1185  * @name: The name of the named trigger set
1186  * @data: The trigger data to save
1187  *
1188  * Return: 0 if successful, negative error otherwise.
1189  */
save_named_trigger(const char * name,struct event_trigger_data * data)1190 int save_named_trigger(const char *name, struct event_trigger_data *data)
1191 {
1192 	data->name = kstrdup(name, GFP_KERNEL);
1193 	if (!data->name)
1194 		return -ENOMEM;
1195 
1196 	list_add(&data->named_list, &named_triggers);
1197 
1198 	return 0;
1199 }
1200 
1201 /**
1202  * del_named_trigger - delete a trigger from the named trigger list
1203  * @data: The trigger data to delete
1204  */
del_named_trigger(struct event_trigger_data * data)1205 void del_named_trigger(struct event_trigger_data *data)
1206 {
1207 	kfree(data->name);
1208 	data->name = NULL;
1209 
1210 	list_del(&data->named_list);
1211 }
1212 
__pause_named_trigger(struct event_trigger_data * data,bool pause)1213 static void __pause_named_trigger(struct event_trigger_data *data, bool pause)
1214 {
1215 	struct event_trigger_data *test;
1216 
1217 	list_for_each_entry(test, &named_triggers, named_list) {
1218 		if (strcmp(test->name, data->name) == 0) {
1219 			if (pause) {
1220 				test->paused_tmp = test->paused;
1221 				test->paused = true;
1222 			} else {
1223 				test->paused = test->paused_tmp;
1224 			}
1225 		}
1226 	}
1227 }
1228 
1229 /**
1230  * pause_named_trigger - Pause all named triggers with the same name
1231  * @data: The trigger data of a named trigger to pause
1232  *
1233  * Pauses a named trigger along with all other triggers having the
1234  * same name.  Because named triggers share a common set of data,
1235  * pausing only one is meaningless, so pausing one named trigger needs
1236  * to pause all triggers with the same name.
1237  */
pause_named_trigger(struct event_trigger_data * data)1238 void pause_named_trigger(struct event_trigger_data *data)
1239 {
1240 	__pause_named_trigger(data, true);
1241 }
1242 
1243 /**
1244  * unpause_named_trigger - Un-pause all named triggers with the same name
1245  * @data: The trigger data of a named trigger to unpause
1246  *
1247  * Un-pauses a named trigger along with all other triggers having the
1248  * same name.  Because named triggers share a common set of data,
1249  * unpausing only one is meaningless, so unpausing one named trigger
1250  * needs to unpause all triggers with the same name.
1251  */
unpause_named_trigger(struct event_trigger_data * data)1252 void unpause_named_trigger(struct event_trigger_data *data)
1253 {
1254 	__pause_named_trigger(data, false);
1255 }
1256 
1257 /**
1258  * set_named_trigger_data - Associate common named trigger data
1259  * @data: The trigger data to associate
1260  * @named_data: The common named trigger to be associated
1261  *
1262  * Named triggers are sets of triggers that share a common set of
1263  * trigger data.  The first named trigger registered with a given name
1264  * owns the common trigger data that the others subsequently
1265  * registered with the same name will reference.  This function
1266  * associates the common trigger data from the first trigger with the
1267  * given trigger.
1268  */
set_named_trigger_data(struct event_trigger_data * data,struct event_trigger_data * named_data)1269 void set_named_trigger_data(struct event_trigger_data *data,
1270 			    struct event_trigger_data *named_data)
1271 {
1272 	data->named_data = named_data;
1273 }
1274 
1275 struct event_trigger_data *
get_named_trigger_data(struct event_trigger_data * data)1276 get_named_trigger_data(struct event_trigger_data *data)
1277 {
1278 	return data->named_data;
1279 }
1280 
1281 static void
traceon_trigger(struct event_trigger_data * data,struct trace_buffer * buffer,void * rec,struct ring_buffer_event * event)1282 traceon_trigger(struct event_trigger_data *data,
1283 		struct trace_buffer *buffer, void *rec,
1284 		struct ring_buffer_event *event)
1285 {
1286 	struct trace_event_file *file = data->private_data;
1287 
1288 	if (file) {
1289 		if (tracer_tracing_is_on(file->tr))
1290 			return;
1291 
1292 		tracer_tracing_on(file->tr);
1293 		return;
1294 	}
1295 
1296 	if (tracing_is_on())
1297 		return;
1298 
1299 	tracing_on();
1300 }
1301 
1302 static void
traceon_count_trigger(struct event_trigger_data * data,struct trace_buffer * buffer,void * rec,struct ring_buffer_event * event)1303 traceon_count_trigger(struct event_trigger_data *data,
1304 		      struct trace_buffer *buffer, void *rec,
1305 		      struct ring_buffer_event *event)
1306 {
1307 	struct trace_event_file *file = data->private_data;
1308 
1309 	if (file) {
1310 		if (tracer_tracing_is_on(file->tr))
1311 			return;
1312 	} else {
1313 		if (tracing_is_on())
1314 			return;
1315 	}
1316 
1317 	if (!data->count)
1318 		return;
1319 
1320 	if (data->count != -1)
1321 		(data->count)--;
1322 
1323 	if (file)
1324 		tracer_tracing_on(file->tr);
1325 	else
1326 		tracing_on();
1327 }
1328 
1329 static void
traceoff_trigger(struct event_trigger_data * data,struct trace_buffer * buffer,void * rec,struct ring_buffer_event * event)1330 traceoff_trigger(struct event_trigger_data *data,
1331 		 struct trace_buffer *buffer, void *rec,
1332 		 struct ring_buffer_event *event)
1333 {
1334 	struct trace_event_file *file = data->private_data;
1335 
1336 	if (file) {
1337 		if (!tracer_tracing_is_on(file->tr))
1338 			return;
1339 
1340 		tracer_tracing_off(file->tr);
1341 		return;
1342 	}
1343 
1344 	if (!tracing_is_on())
1345 		return;
1346 
1347 	tracing_off();
1348 }
1349 
1350 static void
traceoff_count_trigger(struct event_trigger_data * data,struct trace_buffer * buffer,void * rec,struct ring_buffer_event * event)1351 traceoff_count_trigger(struct event_trigger_data *data,
1352 		       struct trace_buffer *buffer, void *rec,
1353 		       struct ring_buffer_event *event)
1354 {
1355 	struct trace_event_file *file = data->private_data;
1356 
1357 	if (file) {
1358 		if (!tracer_tracing_is_on(file->tr))
1359 			return;
1360 	} else {
1361 		if (!tracing_is_on())
1362 			return;
1363 	}
1364 
1365 	if (!data->count)
1366 		return;
1367 
1368 	if (data->count != -1)
1369 		(data->count)--;
1370 
1371 	if (file)
1372 		tracer_tracing_off(file->tr);
1373 	else
1374 		tracing_off();
1375 }
1376 
1377 static int
traceon_trigger_print(struct seq_file * m,struct event_trigger_data * data)1378 traceon_trigger_print(struct seq_file *m, struct event_trigger_data *data)
1379 {
1380 	return event_trigger_print("traceon", m, (void *)data->count,
1381 				   data->filter_str);
1382 }
1383 
1384 static int
traceoff_trigger_print(struct seq_file * m,struct event_trigger_data * data)1385 traceoff_trigger_print(struct seq_file *m, struct event_trigger_data *data)
1386 {
1387 	return event_trigger_print("traceoff", m, (void *)data->count,
1388 				   data->filter_str);
1389 }
1390 
1391 static struct event_trigger_ops traceon_trigger_ops = {
1392 	.trigger		= traceon_trigger,
1393 	.print			= traceon_trigger_print,
1394 	.init			= event_trigger_init,
1395 	.free			= event_trigger_free,
1396 };
1397 
1398 static struct event_trigger_ops traceon_count_trigger_ops = {
1399 	.trigger		= traceon_count_trigger,
1400 	.print			= traceon_trigger_print,
1401 	.init			= event_trigger_init,
1402 	.free			= event_trigger_free,
1403 };
1404 
1405 static struct event_trigger_ops traceoff_trigger_ops = {
1406 	.trigger		= traceoff_trigger,
1407 	.print			= traceoff_trigger_print,
1408 	.init			= event_trigger_init,
1409 	.free			= event_trigger_free,
1410 };
1411 
1412 static struct event_trigger_ops traceoff_count_trigger_ops = {
1413 	.trigger		= traceoff_count_trigger,
1414 	.print			= traceoff_trigger_print,
1415 	.init			= event_trigger_init,
1416 	.free			= event_trigger_free,
1417 };
1418 
1419 static struct event_trigger_ops *
onoff_get_trigger_ops(char * cmd,char * param)1420 onoff_get_trigger_ops(char *cmd, char *param)
1421 {
1422 	struct event_trigger_ops *ops;
1423 
1424 	/* we register both traceon and traceoff to this callback */
1425 	if (strcmp(cmd, "traceon") == 0)
1426 		ops = param ? &traceon_count_trigger_ops :
1427 			&traceon_trigger_ops;
1428 	else
1429 		ops = param ? &traceoff_count_trigger_ops :
1430 			&traceoff_trigger_ops;
1431 
1432 	return ops;
1433 }
1434 
1435 static struct event_command trigger_traceon_cmd = {
1436 	.name			= "traceon",
1437 	.trigger_type		= ETT_TRACE_ONOFF,
1438 	.parse			= event_trigger_parse,
1439 	.reg			= register_trigger,
1440 	.unreg			= unregister_trigger,
1441 	.get_trigger_ops	= onoff_get_trigger_ops,
1442 	.set_filter		= set_trigger_filter,
1443 };
1444 
1445 static struct event_command trigger_traceoff_cmd = {
1446 	.name			= "traceoff",
1447 	.trigger_type		= ETT_TRACE_ONOFF,
1448 	.flags			= EVENT_CMD_FL_POST_TRIGGER,
1449 	.parse			= event_trigger_parse,
1450 	.reg			= register_trigger,
1451 	.unreg			= unregister_trigger,
1452 	.get_trigger_ops	= onoff_get_trigger_ops,
1453 	.set_filter		= set_trigger_filter,
1454 };
1455 
1456 #ifdef CONFIG_TRACER_SNAPSHOT
1457 static void
snapshot_trigger(struct event_trigger_data * data,struct trace_buffer * buffer,void * rec,struct ring_buffer_event * event)1458 snapshot_trigger(struct event_trigger_data *data,
1459 		 struct trace_buffer *buffer, void *rec,
1460 		 struct ring_buffer_event *event)
1461 {
1462 	struct trace_event_file *file = data->private_data;
1463 
1464 	if (file)
1465 		tracing_snapshot_instance(file->tr);
1466 	else
1467 		tracing_snapshot();
1468 }
1469 
1470 static void
snapshot_count_trigger(struct event_trigger_data * data,struct trace_buffer * buffer,void * rec,struct ring_buffer_event * event)1471 snapshot_count_trigger(struct event_trigger_data *data,
1472 		       struct trace_buffer *buffer, void *rec,
1473 		       struct ring_buffer_event *event)
1474 {
1475 	if (!data->count)
1476 		return;
1477 
1478 	if (data->count != -1)
1479 		(data->count)--;
1480 
1481 	snapshot_trigger(data, buffer, rec, event);
1482 }
1483 
1484 static int
register_snapshot_trigger(char * glob,struct event_trigger_data * data,struct trace_event_file * file)1485 register_snapshot_trigger(char *glob,
1486 			  struct event_trigger_data *data,
1487 			  struct trace_event_file *file)
1488 {
1489 	int ret = tracing_arm_snapshot(file->tr);
1490 
1491 	if (ret < 0)
1492 		return ret;
1493 
1494 	ret = register_trigger(glob, data, file);
1495 	if (ret < 0)
1496 		tracing_disarm_snapshot(file->tr);
1497 	return ret;
1498 }
1499 
unregister_snapshot_trigger(char * glob,struct event_trigger_data * data,struct trace_event_file * file)1500 static void unregister_snapshot_trigger(char *glob,
1501 					struct event_trigger_data *data,
1502 					struct trace_event_file *file)
1503 {
1504 	if (try_unregister_trigger(glob, data, file))
1505 		tracing_disarm_snapshot(file->tr);
1506 }
1507 
1508 static int
snapshot_trigger_print(struct seq_file * m,struct event_trigger_data * data)1509 snapshot_trigger_print(struct seq_file *m, struct event_trigger_data *data)
1510 {
1511 	return event_trigger_print("snapshot", m, (void *)data->count,
1512 				   data->filter_str);
1513 }
1514 
1515 static struct event_trigger_ops snapshot_trigger_ops = {
1516 	.trigger		= snapshot_trigger,
1517 	.print			= snapshot_trigger_print,
1518 	.init			= event_trigger_init,
1519 	.free			= event_trigger_free,
1520 };
1521 
1522 static struct event_trigger_ops snapshot_count_trigger_ops = {
1523 	.trigger		= snapshot_count_trigger,
1524 	.print			= snapshot_trigger_print,
1525 	.init			= event_trigger_init,
1526 	.free			= event_trigger_free,
1527 };
1528 
1529 static struct event_trigger_ops *
snapshot_get_trigger_ops(char * cmd,char * param)1530 snapshot_get_trigger_ops(char *cmd, char *param)
1531 {
1532 	return param ? &snapshot_count_trigger_ops : &snapshot_trigger_ops;
1533 }
1534 
1535 static struct event_command trigger_snapshot_cmd = {
1536 	.name			= "snapshot",
1537 	.trigger_type		= ETT_SNAPSHOT,
1538 	.parse			= event_trigger_parse,
1539 	.reg			= register_snapshot_trigger,
1540 	.unreg			= unregister_snapshot_trigger,
1541 	.get_trigger_ops	= snapshot_get_trigger_ops,
1542 	.set_filter		= set_trigger_filter,
1543 };
1544 
register_trigger_snapshot_cmd(void)1545 static __init int register_trigger_snapshot_cmd(void)
1546 {
1547 	int ret;
1548 
1549 	ret = register_event_command(&trigger_snapshot_cmd);
1550 	WARN_ON(ret < 0);
1551 
1552 	return ret;
1553 }
1554 #else
register_trigger_snapshot_cmd(void)1555 static __init int register_trigger_snapshot_cmd(void) { return 0; }
1556 #endif /* CONFIG_TRACER_SNAPSHOT */
1557 
1558 #ifdef CONFIG_STACKTRACE
1559 #ifdef CONFIG_UNWINDER_ORC
1560 /* Skip 2:
1561  *   event_triggers_post_call()
1562  *   trace_event_raw_event_xxx()
1563  */
1564 # define STACK_SKIP 2
1565 #else
1566 /*
1567  * Skip 4:
1568  *   stacktrace_trigger()
1569  *   event_triggers_post_call()
1570  *   trace_event_buffer_commit()
1571  *   trace_event_raw_event_xxx()
1572  */
1573 #define STACK_SKIP 4
1574 #endif
1575 
1576 static void
stacktrace_trigger(struct event_trigger_data * data,struct trace_buffer * buffer,void * rec,struct ring_buffer_event * event)1577 stacktrace_trigger(struct event_trigger_data *data,
1578 		   struct trace_buffer *buffer,  void *rec,
1579 		   struct ring_buffer_event *event)
1580 {
1581 	struct trace_event_file *file = data->private_data;
1582 
1583 	if (file)
1584 		__trace_stack(file->tr, tracing_gen_ctx(), STACK_SKIP);
1585 	else
1586 		trace_dump_stack(STACK_SKIP);
1587 }
1588 
1589 static void
stacktrace_count_trigger(struct event_trigger_data * data,struct trace_buffer * buffer,void * rec,struct ring_buffer_event * event)1590 stacktrace_count_trigger(struct event_trigger_data *data,
1591 			 struct trace_buffer *buffer, void *rec,
1592 			 struct ring_buffer_event *event)
1593 {
1594 	if (!data->count)
1595 		return;
1596 
1597 	if (data->count != -1)
1598 		(data->count)--;
1599 
1600 	stacktrace_trigger(data, buffer, rec, event);
1601 }
1602 
1603 static int
stacktrace_trigger_print(struct seq_file * m,struct event_trigger_data * data)1604 stacktrace_trigger_print(struct seq_file *m, struct event_trigger_data *data)
1605 {
1606 	return event_trigger_print("stacktrace", m, (void *)data->count,
1607 				   data->filter_str);
1608 }
1609 
1610 static struct event_trigger_ops stacktrace_trigger_ops = {
1611 	.trigger		= stacktrace_trigger,
1612 	.print			= stacktrace_trigger_print,
1613 	.init			= event_trigger_init,
1614 	.free			= event_trigger_free,
1615 };
1616 
1617 static struct event_trigger_ops stacktrace_count_trigger_ops = {
1618 	.trigger		= stacktrace_count_trigger,
1619 	.print			= stacktrace_trigger_print,
1620 	.init			= event_trigger_init,
1621 	.free			= event_trigger_free,
1622 };
1623 
1624 static struct event_trigger_ops *
stacktrace_get_trigger_ops(char * cmd,char * param)1625 stacktrace_get_trigger_ops(char *cmd, char *param)
1626 {
1627 	return param ? &stacktrace_count_trigger_ops : &stacktrace_trigger_ops;
1628 }
1629 
1630 static struct event_command trigger_stacktrace_cmd = {
1631 	.name			= "stacktrace",
1632 	.trigger_type		= ETT_STACKTRACE,
1633 	.flags			= EVENT_CMD_FL_POST_TRIGGER,
1634 	.parse			= event_trigger_parse,
1635 	.reg			= register_trigger,
1636 	.unreg			= unregister_trigger,
1637 	.get_trigger_ops	= stacktrace_get_trigger_ops,
1638 	.set_filter		= set_trigger_filter,
1639 };
1640 
register_trigger_stacktrace_cmd(void)1641 static __init int register_trigger_stacktrace_cmd(void)
1642 {
1643 	int ret;
1644 
1645 	ret = register_event_command(&trigger_stacktrace_cmd);
1646 	WARN_ON(ret < 0);
1647 
1648 	return ret;
1649 }
1650 #else
register_trigger_stacktrace_cmd(void)1651 static __init int register_trigger_stacktrace_cmd(void) { return 0; }
1652 #endif /* CONFIG_STACKTRACE */
1653 
unregister_trigger_traceon_traceoff_cmds(void)1654 static __init void unregister_trigger_traceon_traceoff_cmds(void)
1655 {
1656 	unregister_event_command(&trigger_traceon_cmd);
1657 	unregister_event_command(&trigger_traceoff_cmd);
1658 }
1659 
1660 static void
event_enable_trigger(struct event_trigger_data * data,struct trace_buffer * buffer,void * rec,struct ring_buffer_event * event)1661 event_enable_trigger(struct event_trigger_data *data,
1662 		     struct trace_buffer *buffer,  void *rec,
1663 		     struct ring_buffer_event *event)
1664 {
1665 	struct enable_trigger_data *enable_data = data->private_data;
1666 
1667 	if (enable_data->enable)
1668 		clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &enable_data->file->flags);
1669 	else
1670 		set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &enable_data->file->flags);
1671 }
1672 
1673 static void
event_enable_count_trigger(struct event_trigger_data * data,struct trace_buffer * buffer,void * rec,struct ring_buffer_event * event)1674 event_enable_count_trigger(struct event_trigger_data *data,
1675 			   struct trace_buffer *buffer,  void *rec,
1676 			   struct ring_buffer_event *event)
1677 {
1678 	struct enable_trigger_data *enable_data = data->private_data;
1679 
1680 	if (!data->count)
1681 		return;
1682 
1683 	/* Skip if the event is in a state we want to switch to */
1684 	if (enable_data->enable == !(enable_data->file->flags & EVENT_FILE_FL_SOFT_DISABLED))
1685 		return;
1686 
1687 	if (data->count != -1)
1688 		(data->count)--;
1689 
1690 	event_enable_trigger(data, buffer, rec, event);
1691 }
1692 
event_enable_trigger_print(struct seq_file * m,struct event_trigger_data * data)1693 int event_enable_trigger_print(struct seq_file *m,
1694 			       struct event_trigger_data *data)
1695 {
1696 	struct enable_trigger_data *enable_data = data->private_data;
1697 
1698 	seq_printf(m, "%s:%s:%s",
1699 		   enable_data->hist ?
1700 		   (enable_data->enable ? ENABLE_HIST_STR : DISABLE_HIST_STR) :
1701 		   (enable_data->enable ? ENABLE_EVENT_STR : DISABLE_EVENT_STR),
1702 		   enable_data->file->event_call->class->system,
1703 		   trace_event_name(enable_data->file->event_call));
1704 
1705 	if (data->count == -1)
1706 		seq_puts(m, ":unlimited");
1707 	else
1708 		seq_printf(m, ":count=%ld", data->count);
1709 
1710 	if (data->filter_str)
1711 		seq_printf(m, " if %s\n", data->filter_str);
1712 	else
1713 		seq_putc(m, '\n');
1714 
1715 	return 0;
1716 }
1717 
event_enable_trigger_free(struct event_trigger_data * data)1718 void event_enable_trigger_free(struct event_trigger_data *data)
1719 {
1720 	struct enable_trigger_data *enable_data = data->private_data;
1721 
1722 	if (WARN_ON_ONCE(data->ref <= 0))
1723 		return;
1724 
1725 	data->ref--;
1726 	if (!data->ref) {
1727 		/* Remove the SOFT_MODE flag */
1728 		trace_event_enable_disable(enable_data->file, 0, 1);
1729 		trace_event_put_ref(enable_data->file->event_call);
1730 		trigger_data_free(data);
1731 		kfree(enable_data);
1732 	}
1733 }
1734 
1735 static struct event_trigger_ops event_enable_trigger_ops = {
1736 	.trigger		= event_enable_trigger,
1737 	.print			= event_enable_trigger_print,
1738 	.init			= event_trigger_init,
1739 	.free			= event_enable_trigger_free,
1740 };
1741 
1742 static struct event_trigger_ops event_enable_count_trigger_ops = {
1743 	.trigger		= event_enable_count_trigger,
1744 	.print			= event_enable_trigger_print,
1745 	.init			= event_trigger_init,
1746 	.free			= event_enable_trigger_free,
1747 };
1748 
1749 static struct event_trigger_ops event_disable_trigger_ops = {
1750 	.trigger		= event_enable_trigger,
1751 	.print			= event_enable_trigger_print,
1752 	.init			= event_trigger_init,
1753 	.free			= event_enable_trigger_free,
1754 };
1755 
1756 static struct event_trigger_ops event_disable_count_trigger_ops = {
1757 	.trigger		= event_enable_count_trigger,
1758 	.print			= event_enable_trigger_print,
1759 	.init			= event_trigger_init,
1760 	.free			= event_enable_trigger_free,
1761 };
1762 
event_enable_trigger_parse(struct event_command * cmd_ops,struct trace_event_file * file,char * glob,char * cmd,char * param_and_filter)1763 int event_enable_trigger_parse(struct event_command *cmd_ops,
1764 			       struct trace_event_file *file,
1765 			       char *glob, char *cmd, char *param_and_filter)
1766 {
1767 	struct trace_event_file *event_enable_file;
1768 	struct enable_trigger_data *enable_data;
1769 	struct event_trigger_data *trigger_data;
1770 	struct trace_array *tr = file->tr;
1771 	char *param, *filter;
1772 	bool enable, remove;
1773 	const char *system;
1774 	const char *event;
1775 	bool hist = false;
1776 	int ret;
1777 
1778 	remove = event_trigger_check_remove(glob);
1779 
1780 	if (event_trigger_empty_param(param_and_filter))
1781 		return -EINVAL;
1782 
1783 	ret = event_trigger_separate_filter(param_and_filter, &param, &filter, true);
1784 	if (ret)
1785 		return ret;
1786 
1787 	system = strsep(&param, ":");
1788 	if (!param)
1789 		return -EINVAL;
1790 
1791 	event = strsep(&param, ":");
1792 
1793 	ret = -EINVAL;
1794 	event_enable_file = find_event_file(tr, system, event);
1795 	if (!event_enable_file)
1796 		goto out;
1797 
1798 #ifdef CONFIG_HIST_TRIGGERS
1799 	hist = ((strcmp(cmd, ENABLE_HIST_STR) == 0) ||
1800 		(strcmp(cmd, DISABLE_HIST_STR) == 0));
1801 
1802 	enable = ((strcmp(cmd, ENABLE_EVENT_STR) == 0) ||
1803 		  (strcmp(cmd, ENABLE_HIST_STR) == 0));
1804 #else
1805 	enable = strcmp(cmd, ENABLE_EVENT_STR) == 0;
1806 #endif
1807 	ret = -ENOMEM;
1808 
1809 	enable_data = kzalloc(sizeof(*enable_data), GFP_KERNEL);
1810 	if (!enable_data)
1811 		goto out;
1812 
1813 	enable_data->hist = hist;
1814 	enable_data->enable = enable;
1815 	enable_data->file = event_enable_file;
1816 
1817 	trigger_data = event_trigger_alloc(cmd_ops, cmd, param, enable_data);
1818 	if (!trigger_data) {
1819 		kfree(enable_data);
1820 		goto out;
1821 	}
1822 
1823 	if (remove) {
1824 		event_trigger_unregister(cmd_ops, file, glob+1, trigger_data);
1825 		kfree(trigger_data);
1826 		kfree(enable_data);
1827 		ret = 0;
1828 		goto out;
1829 	}
1830 
1831 	/* Up the trigger_data count to make sure nothing frees it on failure */
1832 	event_trigger_init(trigger_data);
1833 
1834 	ret = event_trigger_parse_num(param, trigger_data);
1835 	if (ret)
1836 		goto out_free;
1837 
1838 	ret = event_trigger_set_filter(cmd_ops, file, filter, trigger_data);
1839 	if (ret < 0)
1840 		goto out_free;
1841 
1842 	/* Don't let event modules unload while probe registered */
1843 	ret = trace_event_try_get_ref(event_enable_file->event_call);
1844 	if (!ret) {
1845 		ret = -EBUSY;
1846 		goto out_free;
1847 	}
1848 
1849 	ret = trace_event_enable_disable(event_enable_file, 1, 1);
1850 	if (ret < 0)
1851 		goto out_put;
1852 
1853 	ret = event_trigger_register(cmd_ops, file, glob, trigger_data);
1854 	if (ret)
1855 		goto out_disable;
1856 
1857 	event_trigger_free(trigger_data);
1858  out:
1859 	return ret;
1860  out_disable:
1861 	trace_event_enable_disable(event_enable_file, 0, 1);
1862  out_put:
1863 	trace_event_put_ref(event_enable_file->event_call);
1864  out_free:
1865 	event_trigger_reset_filter(cmd_ops, trigger_data);
1866 	event_trigger_free(trigger_data);
1867 	kfree(enable_data);
1868 
1869 	goto out;
1870 }
1871 
event_enable_register_trigger(char * glob,struct event_trigger_data * data,struct trace_event_file * file)1872 int event_enable_register_trigger(char *glob,
1873 				  struct event_trigger_data *data,
1874 				  struct trace_event_file *file)
1875 {
1876 	struct enable_trigger_data *enable_data = data->private_data;
1877 	struct enable_trigger_data *test_enable_data;
1878 	struct event_trigger_data *test;
1879 	int ret = 0;
1880 
1881 	lockdep_assert_held(&event_mutex);
1882 
1883 	list_for_each_entry(test, &file->triggers, list) {
1884 		test_enable_data = test->private_data;
1885 		if (test_enable_data &&
1886 		    (test->cmd_ops->trigger_type ==
1887 		     data->cmd_ops->trigger_type) &&
1888 		    (test_enable_data->file == enable_data->file)) {
1889 			ret = -EEXIST;
1890 			goto out;
1891 		}
1892 	}
1893 
1894 	if (data->ops->init) {
1895 		ret = data->ops->init(data);
1896 		if (ret < 0)
1897 			goto out;
1898 	}
1899 
1900 	list_add_rcu(&data->list, &file->triggers);
1901 
1902 	update_cond_flag(file);
1903 	ret = trace_event_trigger_enable_disable(file, 1);
1904 	if (ret < 0) {
1905 		list_del_rcu(&data->list);
1906 		update_cond_flag(file);
1907 	}
1908 out:
1909 	return ret;
1910 }
1911 
event_enable_unregister_trigger(char * glob,struct event_trigger_data * test,struct trace_event_file * file)1912 void event_enable_unregister_trigger(char *glob,
1913 				     struct event_trigger_data *test,
1914 				     struct trace_event_file *file)
1915 {
1916 	struct enable_trigger_data *test_enable_data = test->private_data;
1917 	struct event_trigger_data *data = NULL, *iter;
1918 	struct enable_trigger_data *enable_data;
1919 
1920 	lockdep_assert_held(&event_mutex);
1921 
1922 	list_for_each_entry(iter, &file->triggers, list) {
1923 		enable_data = iter->private_data;
1924 		if (enable_data &&
1925 		    (iter->cmd_ops->trigger_type ==
1926 		     test->cmd_ops->trigger_type) &&
1927 		    (enable_data->file == test_enable_data->file)) {
1928 			data = iter;
1929 			list_del_rcu(&data->list);
1930 			trace_event_trigger_enable_disable(file, 0);
1931 			update_cond_flag(file);
1932 			break;
1933 		}
1934 	}
1935 
1936 	if (data && data->ops->free)
1937 		data->ops->free(data);
1938 }
1939 
1940 static struct event_trigger_ops *
event_enable_get_trigger_ops(char * cmd,char * param)1941 event_enable_get_trigger_ops(char *cmd, char *param)
1942 {
1943 	struct event_trigger_ops *ops;
1944 	bool enable;
1945 
1946 #ifdef CONFIG_HIST_TRIGGERS
1947 	enable = ((strcmp(cmd, ENABLE_EVENT_STR) == 0) ||
1948 		  (strcmp(cmd, ENABLE_HIST_STR) == 0));
1949 #else
1950 	enable = strcmp(cmd, ENABLE_EVENT_STR) == 0;
1951 #endif
1952 	if (enable)
1953 		ops = param ? &event_enable_count_trigger_ops :
1954 			&event_enable_trigger_ops;
1955 	else
1956 		ops = param ? &event_disable_count_trigger_ops :
1957 			&event_disable_trigger_ops;
1958 
1959 	return ops;
1960 }
1961 
1962 static struct event_command trigger_enable_cmd = {
1963 	.name			= ENABLE_EVENT_STR,
1964 	.trigger_type		= ETT_EVENT_ENABLE,
1965 	.parse			= event_enable_trigger_parse,
1966 	.reg			= event_enable_register_trigger,
1967 	.unreg			= event_enable_unregister_trigger,
1968 	.get_trigger_ops	= event_enable_get_trigger_ops,
1969 	.set_filter		= set_trigger_filter,
1970 };
1971 
1972 static struct event_command trigger_disable_cmd = {
1973 	.name			= DISABLE_EVENT_STR,
1974 	.trigger_type		= ETT_EVENT_ENABLE,
1975 	.parse			= event_enable_trigger_parse,
1976 	.reg			= event_enable_register_trigger,
1977 	.unreg			= event_enable_unregister_trigger,
1978 	.get_trigger_ops	= event_enable_get_trigger_ops,
1979 	.set_filter		= set_trigger_filter,
1980 };
1981 
unregister_trigger_enable_disable_cmds(void)1982 static __init void unregister_trigger_enable_disable_cmds(void)
1983 {
1984 	unregister_event_command(&trigger_enable_cmd);
1985 	unregister_event_command(&trigger_disable_cmd);
1986 }
1987 
register_trigger_enable_disable_cmds(void)1988 static __init int register_trigger_enable_disable_cmds(void)
1989 {
1990 	int ret;
1991 
1992 	ret = register_event_command(&trigger_enable_cmd);
1993 	if (WARN_ON(ret < 0))
1994 		return ret;
1995 	ret = register_event_command(&trigger_disable_cmd);
1996 	if (WARN_ON(ret < 0))
1997 		unregister_trigger_enable_disable_cmds();
1998 
1999 	return ret;
2000 }
2001 
register_trigger_traceon_traceoff_cmds(void)2002 static __init int register_trigger_traceon_traceoff_cmds(void)
2003 {
2004 	int ret;
2005 
2006 	ret = register_event_command(&trigger_traceon_cmd);
2007 	if (WARN_ON(ret < 0))
2008 		return ret;
2009 	ret = register_event_command(&trigger_traceoff_cmd);
2010 	if (WARN_ON(ret < 0))
2011 		unregister_trigger_traceon_traceoff_cmds();
2012 
2013 	return ret;
2014 }
2015 
register_trigger_cmds(void)2016 __init int register_trigger_cmds(void)
2017 {
2018 	register_trigger_traceon_traceoff_cmds();
2019 	register_trigger_snapshot_cmd();
2020 	register_trigger_stacktrace_cmd();
2021 	register_trigger_enable_disable_cmds();
2022 	register_trigger_hist_enable_disable_cmds();
2023 	register_trigger_hist_cmd();
2024 
2025 	return 0;
2026 }
2027