1	// SPDX-License-Identifier: GPL-2.0
2	/*
3	* event tracer
4	*
5	* Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
6	*
7	* - Added format output of fields of the trace point.
8	* This was based off of work by Tom Zanussi <tzanussi@gmail.com>.
9	*
10	*/
11
12	#define pr_fmt(fmt) fmt
13
14	#include <linux/workqueue.h>
15	#include <linux/security.h>
16	#include <linux/spinlock.h>
17	#include <linux/kthread.h>
18	#include <linux/tracefs.h>
19	#include <linux/uaccess.h>
20	#include <linux/module.h>
21	#include <linux/ctype.h>
22	#include <linux/sort.h>
23	#include <linux/slab.h>
24	#include <linux/delay.h>
25
26	#include <trace/events/sched.h>
27	#include <trace/syscall.h>
28
29	#include <asm/setup.h>
30
31	#include "trace_output.h"
32
33	#undef TRACE_SYSTEM
34	#define TRACE_SYSTEM "TRACE_SYSTEM"
35
36	DEFINE_MUTEX(event_mutex);
37
38	LIST_HEAD(ftrace_events);
39	static LIST_HEAD(ftrace_generic_fields);
40	static LIST_HEAD(ftrace_common_fields);
41	static bool eventdir_initialized;
42
43	static LIST_HEAD(module_strings);
44
45	struct module_string {
46	struct list_head next;
47	struct module *module;
48	char *str;
49	};
50
51	#define GFP_TRACE (GFP_KERNEL | __GFP_ZERO)
52
53	static struct kmem_cache *field_cachep;
54	static struct kmem_cache *file_cachep;
55
56	static inline int system_refcount(struct event_subsystem *system)
57	{
58	return system->ref_count;
59	}
60
61	static int system_refcount_inc(struct event_subsystem *system)
62	{
63	return system->ref_count++;
64	}
65
66	static int system_refcount_dec(struct event_subsystem *system)
67	{
68	return --system->ref_count;
69	}
70
71	/* Double loops, do not use break, only goto's work */
72	#define do_for_each_event_file(tr, file) \
73	list_for_each_entry(tr, &ftrace_trace_arrays, list) { \
74	list_for_each_entry(file, &tr->events, list)
75
76	#define do_for_each_event_file_safe(tr, file) \
77	list_for_each_entry(tr, &ftrace_trace_arrays, list) { \
78	struct trace_event_file *___n; \
79	list_for_each_entry_safe(file, ___n, &tr->events, list)
80
81	#define while_for_each_event_file() \
82	}
83
84	static struct ftrace_event_field *
85	__find_event_field(struct list_head *head, char *name)
86	{
87	struct ftrace_event_field *field;
88
89	list_for_each_entry(field, head, link) {
90	if (!strcmp(field->name, name))
91	return field;
92	}
93
94	return NULL;
95	}
96
97	struct ftrace_event_field *
98	trace_find_event_field(struct trace_event_call *call, char *name)
99	{
100	struct ftrace_event_field *field;
101	struct list_head *head;
102
103	head = trace_get_fields(event_call: call);
104	field = __find_event_field(head, name);
105	if (field)
106	return field;
107
108	field = __find_event_field(head: &ftrace_generic_fields, name);
109	if (field)
110	return field;
111
112	return __find_event_field(head: &ftrace_common_fields, name);
113	}
114
115	static int __trace_define_field(struct list_head *head, const char *type,
116	const char *name, int offset, int size,
117	int is_signed, int filter_type, int len)
118	{
119	struct ftrace_event_field *field;
120
121	field = kmem_cache_alloc(cachep: field_cachep, GFP_TRACE);
122	if (!field)
123	return -ENOMEM;
124
125	field->name = name;
126	field->type = type;
127
128	if (filter_type == FILTER_OTHER)
129	field->filter_type = filter_assign_type(type);
130	else
131	field->filter_type = filter_type;
132
133	field->offset = offset;
134	field->size = size;
135	field->is_signed = is_signed;
136	field->len = len;
137
138	list_add(new: &field->link, head);
139
140	return 0;
141	}
142
143	int trace_define_field(struct trace_event_call *call, const char *type,
144	const char *name, int offset, int size, int is_signed,
145	int filter_type)
146	{
147	struct list_head *head;
148
149	if (WARN_ON(!call->class))
150	return 0;
151
152	head = trace_get_fields(event_call: call);
153	return __trace_define_field(head, type, name, offset, size,
154	is_signed, filter_type, len: 0);
155	}
156	EXPORT_SYMBOL_GPL(trace_define_field);
157
158	static int trace_define_field_ext(struct trace_event_call *call, const char *type,
159	const char *name, int offset, int size, int is_signed,
160	int filter_type, int len)
161	{
162	struct list_head *head;
163
164	if (WARN_ON(!call->class))
165	return 0;
166
167	head = trace_get_fields(event_call: call);
168	return __trace_define_field(head, type, name, offset, size,
169	is_signed, filter_type, len);
170	}
171
172	#define __generic_field(type, item, filter_type) \
173	ret = __trace_define_field(&ftrace_generic_fields, #type, \
174	#item, 0, 0, is_signed_type(type), \
175	filter_type, 0); \
176	if (ret) \
177	return ret;
178
179	#define __common_field(type, item) \
180	ret = __trace_define_field(&ftrace_common_fields, #type, \
181	"common_" #item, \
182	offsetof(typeof(ent), item), \
183	sizeof(ent.item), \
184	is_signed_type(type), FILTER_OTHER, 0); \
185	if (ret) \
186	return ret;
187
188	static int trace_define_generic_fields(void)
189	{
190	int ret;
191
192	__generic_field(int, CPU, FILTER_CPU);
193	__generic_field(int, cpu, FILTER_CPU);
194	__generic_field(int, common_cpu, FILTER_CPU);
195	__generic_field(char *, COMM, FILTER_COMM);
196	__generic_field(char *, comm, FILTER_COMM);
197	__generic_field(char *, stacktrace, FILTER_STACKTRACE);
198	__generic_field(char *, STACKTRACE, FILTER_STACKTRACE);
199
200	return ret;
201	}
202
203	static int trace_define_common_fields(void)
204	{
205	int ret;
206	struct trace_entry ent;
207
208	__common_field(unsigned short, type);
209	__common_field(unsigned char, flags);
210	/* Holds both preempt_count and migrate_disable */
211	__common_field(unsigned char, preempt_count);
212	__common_field(int, pid);
213
214	return ret;
215	}
216
217	static void trace_destroy_fields(struct trace_event_call *call)
218	{
219	struct ftrace_event_field *field, *next;
220	struct list_head *head;
221
222	head = trace_get_fields(event_call: call);
223	list_for_each_entry_safe(field, next, head, link) {
224	list_del(entry: &field->link);
225	kmem_cache_free(s: field_cachep, objp: field);
226	}
227	}
228
229	/*
230	* run-time version of trace_event_get_offsets_<call>() that returns the last
231	* accessible offset of trace fields excluding __dynamic_array bytes
232	*/
233	int trace_event_get_offsets(struct trace_event_call *call)
234	{
235	struct ftrace_event_field *tail;
236	struct list_head *head;
237
238	head = trace_get_fields(event_call: call);
239	/*
240	* head->next points to the last field with the largest offset,
241	* since it was added last by trace_define_field()
242	*/
243	tail = list_first_entry(head, struct ftrace_event_field, link);
244	return tail->offset + tail->size;
245	}
246
247	/*
248	* Check if the referenced field is an array and return true,
249	* as arrays are OK to dereference.
250	*/
251	static bool test_field(const char *fmt, struct trace_event_call *call)
252	{
253	struct trace_event_fields *field = call->class->fields_array;
254	const char *array_descriptor;
255	const char *p = fmt;
256	int len;
257
258	if (!(len = str_has_prefix(str: fmt, prefix: "REC->")))
259	return false;
260	fmt += len;
261	for (p = fmt; *p; p++) {
262	if (!isalnum(*p) && *p != '_')
263	break;
264	}
265	len = p - fmt;
266
267	for (; field->type; field++) {
268	if (strncmp(field->name, fmt, len) ||
269	field->name[len])
270	continue;
271	array_descriptor = strchr(field->type, '[');
272	/* This is an array and is OK to dereference. */
273	return array_descriptor != NULL;
274	}
275	return false;
276	}
277
278	/*
279	* Examine the print fmt of the event looking for unsafe dereference
280	* pointers using %p* that could be recorded in the trace event and
281	* much later referenced after the pointer was freed. Dereferencing
282	* pointers are OK, if it is dereferenced into the event itself.
283	*/
284	static void test_event_printk(struct trace_event_call *call)
285	{
286	u64 dereference_flags = 0;
287	bool first = true;
288	const char *fmt, *c, *r, *a;
289	int parens = 0;
290	char in_quote = 0;
291	int start_arg = 0;
292	int arg = 0;
293	int i;
294
295	fmt = call->print_fmt;
296
297	if (!fmt)
298	return;
299
300	for (i = 0; fmt[i]; i++) {
301	switch (fmt[i]) {
302	case '\\':
303	i++;
304	if (!fmt[i])
305	return;
306	continue;
307	case '"':
308	case '\'':
309	/*
310	* The print fmt starts with a string that
311	* is processed first to find %p* usage,
312	* then after the first string, the print fmt
313	* contains arguments that are used to check
314	* if the dereferenced %p* usage is safe.
315	*/
316	if (first) {
317	if (fmt[i] == '\'')
318	continue;
319	if (in_quote) {
320	arg = 0;
321	first = false;
322	/*
323	* If there was no %p* uses
324	* the fmt is OK.
325	*/
326	if (!dereference_flags)
327	return;
328	}
329	}
330	if (in_quote) {
331	if (in_quote == fmt[i])
332	in_quote = 0;
333	} else {
334	in_quote = fmt[i];
335	}
336	continue;
337	case '%':
338	if (!first || !in_quote)
339	continue;
340	i++;
341	if (!fmt[i])
342	return;
343	switch (fmt[i]) {
344	case '%':
345	continue;
346	case 'p':
347	/* Find dereferencing fields */
348	switch (fmt[i + 1]) {
349	case 'B': case 'R': case 'r':
350	case 'b': case 'M': case 'm':
351	case 'I': case 'i': case 'E':
352	case 'U': case 'V': case 'N':
353	case 'a': case 'd': case 'D':
354	case 'g': case 't': case 'C':
355	case 'O': case 'f':
356	if (WARN_ONCE(arg == 63,
357	"Too many args for event: %s",
358	trace_event_name(call)))
359	return;
360	dereference_flags |= 1ULL << arg;
361	}
362	break;
363	default:
364	{
365	bool star = false;
366	int j;
367
368	/* Increment arg if %*s exists. */
369	for (j = 0; fmt[i + j]; j++) {
370	if (isdigit(c: fmt[i + j]) ||
371	fmt[i + j] == '.')
372	continue;
373	if (fmt[i + j] == '*') {
374	star = true;
375	continue;
376	}
377	if ((fmt[i + j] == 's') && star)
378	arg++;
379	break;
380	}
381	break;
382	} /* default */
383
384	} /* switch */
385	arg++;
386	continue;
387	case '(':
388	if (in_quote)
389	continue;
390	parens++;
391	continue;
392	case ')':
393	if (in_quote)
394	continue;
395	parens--;
396	if (WARN_ONCE(parens < 0,
397	"Paren mismatch for event: %s\narg='%s'\n%*s",
398	trace_event_name(call),
399	fmt + start_arg,
400	(i - start_arg) + 5, "^"))
401	return;
402	continue;
403	case ',':
404	if (in_quote || parens)
405	continue;
406	i++;
407	while (isspace(fmt[i]))
408	i++;
409	start_arg = i;
410	if (!(dereference_flags & (1ULL << arg)))
411	goto next_arg;
412
413	/* Find the REC-> in the argument */
414	c = strchr(fmt + i, ',');
415	r = strstr(fmt + i, "REC->");
416	if (r && (!c || r < c)) {
417	/*
418	* Addresses of events on the buffer,
419	* or an array on the buffer is
420	* OK to dereference.
421	* There's ways to fool this, but
422	* this is to catch common mistakes,
423	* not malicious code.
424	*/
425	a = strchr(fmt + i, '&');
426	if ((a && (a < r)) || test_field(fmt: r, call))
427	dereference_flags &= ~(1ULL << arg);
428	} else if ((r = strstr(fmt + i, "__get_dynamic_array(")) &&
429	(!c || r < c)) {
430	dereference_flags &= ~(1ULL << arg);
431	} else if ((r = strstr(fmt + i, "__get_sockaddr(")) &&
432	(!c || r < c)) {
433	dereference_flags &= ~(1ULL << arg);
434	}
435
436	next_arg:
437	i--;
438	arg++;
439	}
440	}
441
442	/*
443	* If you triggered the below warning, the trace event reported
444	* uses an unsafe dereference pointer %p*. As the data stored
445	* at the trace event time may no longer exist when the trace
446	* event is printed, dereferencing to the original source is
447	* unsafe. The source of the dereference must be copied into the
448	* event itself, and the dereference must access the copy instead.
449	*/
450	if (WARN_ON_ONCE(dereference_flags)) {
451	arg = 1;
452	while (!(dereference_flags & 1)) {
453	dereference_flags >>= 1;
454	arg++;
455	}
456	pr_warn("event %s has unsafe dereference of argument %d\n",
457	trace_event_name(call), arg);
458	pr_warn("print_fmt: %s\n", fmt);
459	}
460	}
461
462	int trace_event_raw_init(struct trace_event_call *call)
463	{
464	int id;
465
466	id = register_trace_event(event: &call->event);
467	if (!id)
468	return -ENODEV;
469
470	test_event_printk(call);
471
472	return 0;
473	}
474	EXPORT_SYMBOL_GPL(trace_event_raw_init);
475
476	bool trace_event_ignore_this_pid(struct trace_event_file *trace_file)
477	{
478	struct trace_array *tr = trace_file->tr;
479	struct trace_array_cpu *data;
480	struct trace_pid_list *no_pid_list;
481	struct trace_pid_list *pid_list;
482
483	pid_list = rcu_dereference_raw(tr->filtered_pids);
484	no_pid_list = rcu_dereference_raw(tr->filtered_no_pids);
485
486	if (!pid_list && !no_pid_list)
487	return false;
488
489	data = this_cpu_ptr(tr->array_buffer.data);
490
491	return data->ignore_pid;
492	}
493	EXPORT_SYMBOL_GPL(trace_event_ignore_this_pid);
494
495	void *trace_event_buffer_reserve(struct trace_event_buffer *fbuffer,
496	struct trace_event_file *trace_file,
497	unsigned long len)
498	{
499	struct trace_event_call *event_call = trace_file->event_call;
500
501	if ((trace_file->flags & EVENT_FILE_FL_PID_FILTER) &&
502	trace_event_ignore_this_pid(trace_file))
503	return NULL;
504
505	/*
506	* If CONFIG_PREEMPTION is enabled, then the tracepoint itself disables
507	* preemption (adding one to the preempt_count). Since we are
508	* interested in the preempt_count at the time the tracepoint was
509	* hit, we need to subtract one to offset the increment.
510	*/
511	fbuffer->trace_ctx = tracing_gen_ctx_dec();
512	fbuffer->trace_file = trace_file;
513
514	fbuffer->event =
515	trace_event_buffer_lock_reserve(current_buffer: &fbuffer->buffer, trace_file,
516	type: event_call->event.type, len,
517	trace_ctx: fbuffer->trace_ctx);
518	if (!fbuffer->event)
519	return NULL;
520
521	fbuffer->regs = NULL;
522	fbuffer->entry = ring_buffer_event_data(event: fbuffer->event);
523	return fbuffer->entry;
524	}
525	EXPORT_SYMBOL_GPL(trace_event_buffer_reserve);
526
527	int trace_event_reg(struct trace_event_call *call,
528	enum trace_reg type, void *data)
529	{
530	struct trace_event_file *file = data;
531
532	WARN_ON(!(call->flags & TRACE_EVENT_FL_TRACEPOINT));
533	switch (type) {
534	case TRACE_REG_REGISTER:
535	return tracepoint_probe_register(tp: call->tp,
536	probe: call->class->probe,
537	data: file);
538	case TRACE_REG_UNREGISTER:
539	tracepoint_probe_unregister(tp: call->tp,
540	probe: call->class->probe,
541	data: file);
542	return 0;
543
544	#ifdef CONFIG_PERF_EVENTS
545	case TRACE_REG_PERF_REGISTER:
546	return tracepoint_probe_register(tp: call->tp,
547	probe: call->class->perf_probe,
548	data: call);
549	case TRACE_REG_PERF_UNREGISTER:
550	tracepoint_probe_unregister(tp: call->tp,
551	probe: call->class->perf_probe,
552	data: call);
553	return 0;
554	case TRACE_REG_PERF_OPEN:
555	case TRACE_REG_PERF_CLOSE:
556	case TRACE_REG_PERF_ADD:
557	case TRACE_REG_PERF_DEL:
558	return 0;
559	#endif
560	}
561	return 0;
562	}
563	EXPORT_SYMBOL_GPL(trace_event_reg);
564
565	void trace_event_enable_cmd_record(bool enable)
566	{
567	struct trace_event_file *file;
568	struct trace_array *tr;
569
570	lockdep_assert_held(&event_mutex);
571
572	do_for_each_event_file(tr, file) {
573
574	if (!(file->flags & EVENT_FILE_FL_ENABLED))
575	continue;
576
577	if (enable) {
578	tracing_start_cmdline_record();
579	set_bit(nr: EVENT_FILE_FL_RECORDED_CMD_BIT, addr: &file->flags);
580	} else {
581	tracing_stop_cmdline_record();
582	clear_bit(nr: EVENT_FILE_FL_RECORDED_CMD_BIT, addr: &file->flags);
583	}
584	} while_for_each_event_file();
585	}
586
587	void trace_event_enable_tgid_record(bool enable)
588	{
589	struct trace_event_file *file;
590	struct trace_array *tr;
591
592	lockdep_assert_held(&event_mutex);
593
594	do_for_each_event_file(tr, file) {
595	if (!(file->flags & EVENT_FILE_FL_ENABLED))
596	continue;
597
598	if (enable) {
599	tracing_start_tgid_record();
600	set_bit(nr: EVENT_FILE_FL_RECORDED_TGID_BIT, addr: &file->flags);
601	} else {
602	tracing_stop_tgid_record();
603	clear_bit(nr: EVENT_FILE_FL_RECORDED_TGID_BIT,
604	addr: &file->flags);
605	}
606	} while_for_each_event_file();
607	}
608
609	static int __ftrace_event_enable_disable(struct trace_event_file *file,
610	int enable, int soft_disable)
611	{
612	struct trace_event_call *call = file->event_call;
613	struct trace_array *tr = file->tr;
614	int ret = 0;
615	int disable;
616
617	switch (enable) {
618	case 0:
619	/*
620	* When soft_disable is set and enable is cleared, the sm_ref
621	* reference counter is decremented. If it reaches 0, we want
622	* to clear the SOFT_DISABLED flag but leave the event in the
623	* state that it was. That is, if the event was enabled and
624	* SOFT_DISABLED isn't set, then do nothing. But if SOFT_DISABLED
625	* is set we do not want the event to be enabled before we
626	* clear the bit.
627	*
628	* When soft_disable is not set but the SOFT_MODE flag is,
629	* we do nothing. Do not disable the tracepoint, otherwise
630	* "soft enable"s (clearing the SOFT_DISABLED bit) wont work.
631	*/
632	if (soft_disable) {
633	if (atomic_dec_return(v: &file->sm_ref) > 0)
634	break;
635	disable = file->flags & EVENT_FILE_FL_SOFT_DISABLED;
636	clear_bit(nr: EVENT_FILE_FL_SOFT_MODE_BIT, addr: &file->flags);
637	/* Disable use of trace_buffered_event */
638	trace_buffered_event_disable();
639	} else
640	disable = !(file->flags & EVENT_FILE_FL_SOFT_MODE);
641
642	if (disable && (file->flags & EVENT_FILE_FL_ENABLED)) {
643	clear_bit(nr: EVENT_FILE_FL_ENABLED_BIT, addr: &file->flags);
644	if (file->flags & EVENT_FILE_FL_RECORDED_CMD) {
645	tracing_stop_cmdline_record();
646	clear_bit(nr: EVENT_FILE_FL_RECORDED_CMD_BIT, addr: &file->flags);
647	}
648
649	if (file->flags & EVENT_FILE_FL_RECORDED_TGID) {
650	tracing_stop_tgid_record();
651	clear_bit(nr: EVENT_FILE_FL_RECORDED_TGID_BIT, addr: &file->flags);
652	}
653
654	call->class->reg(call, TRACE_REG_UNREGISTER, file);
655	}
656	/* If in SOFT_MODE, just set the SOFT_DISABLE_BIT, else clear it */
657	if (file->flags & EVENT_FILE_FL_SOFT_MODE)
658	set_bit(nr: EVENT_FILE_FL_SOFT_DISABLED_BIT, addr: &file->flags);
659	else
660	clear_bit(nr: EVENT_FILE_FL_SOFT_DISABLED_BIT, addr: &file->flags);
661	break;
662	case 1:
663	/*
664	* When soft_disable is set and enable is set, we want to
665	* register the tracepoint for the event, but leave the event
666	* as is. That means, if the event was already enabled, we do
667	* nothing (but set SOFT_MODE). If the event is disabled, we
668	* set SOFT_DISABLED before enabling the event tracepoint, so
669	* it still seems to be disabled.
670	*/
671	if (!soft_disable)
672	clear_bit(nr: EVENT_FILE_FL_SOFT_DISABLED_BIT, addr: &file->flags);
673	else {
674	if (atomic_inc_return(v: &file->sm_ref) > 1)
675	break;
676	set_bit(nr: EVENT_FILE_FL_SOFT_MODE_BIT, addr: &file->flags);
677	/* Enable use of trace_buffered_event */
678	trace_buffered_event_enable();
679	}
680
681	if (!(file->flags & EVENT_FILE_FL_ENABLED)) {
682	bool cmd = false, tgid = false;
683
684	/* Keep the event disabled, when going to SOFT_MODE. */
685	if (soft_disable)
686	set_bit(nr: EVENT_FILE_FL_SOFT_DISABLED_BIT, addr: &file->flags);
687
688	if (tr->trace_flags & TRACE_ITER_RECORD_CMD) {
689	cmd = true;
690	tracing_start_cmdline_record();
691	set_bit(nr: EVENT_FILE_FL_RECORDED_CMD_BIT, addr: &file->flags);
692	}
693
694	if (tr->trace_flags & TRACE_ITER_RECORD_TGID) {
695	tgid = true;
696	tracing_start_tgid_record();
697	set_bit(nr: EVENT_FILE_FL_RECORDED_TGID_BIT, addr: &file->flags);
698	}
699
700	ret = call->class->reg(call, TRACE_REG_REGISTER, file);
701	if (ret) {
702	if (cmd)
703	tracing_stop_cmdline_record();
704	if (tgid)
705	tracing_stop_tgid_record();
706	pr_info("event trace: Could not enable event "
707	"%s\n", trace_event_name(call));
708	break;
709	}
710	set_bit(nr: EVENT_FILE_FL_ENABLED_BIT, addr: &file->flags);
711
712	/* WAS_ENABLED gets set but never cleared. */
713	set_bit(nr: EVENT_FILE_FL_WAS_ENABLED_BIT, addr: &file->flags);
714	}
715	break;
716	}
717
718	return ret;
719	}
720
721	int trace_event_enable_disable(struct trace_event_file *file,
722	int enable, int soft_disable)
723	{
724	return __ftrace_event_enable_disable(file, enable, soft_disable);
725	}
726
727	static int ftrace_event_enable_disable(struct trace_event_file *file,
728	int enable)
729	{
730	return __ftrace_event_enable_disable(file, enable, soft_disable: 0);
731	}
732
733	static void ftrace_clear_events(struct trace_array *tr)
734	{
735	struct trace_event_file *file;
736
737	mutex_lock(&event_mutex);
738	list_for_each_entry(file, &tr->events, list) {
739	ftrace_event_enable_disable(file, enable: 0);
740	}
741	mutex_unlock(lock: &event_mutex);
742	}
743
744	static void
745	event_filter_pid_sched_process_exit(void *data, struct task_struct *task)
746	{
747	struct trace_pid_list *pid_list;
748	struct trace_array *tr = data;
749
750	pid_list = rcu_dereference_raw(tr->filtered_pids);
751	trace_filter_add_remove_task(pid_list, NULL, task);
752
753	pid_list = rcu_dereference_raw(tr->filtered_no_pids);
754	trace_filter_add_remove_task(pid_list, NULL, task);
755	}
756
757	static void
758	event_filter_pid_sched_process_fork(void *data,
759	struct task_struct *self,
760	struct task_struct *task)
761	{
762	struct trace_pid_list *pid_list;
763	struct trace_array *tr = data;
764
765	pid_list = rcu_dereference_sched(tr->filtered_pids);
766	trace_filter_add_remove_task(pid_list, self, task);
767
768	pid_list = rcu_dereference_sched(tr->filtered_no_pids);
769	trace_filter_add_remove_task(pid_list, self, task);
770	}
771
772	void trace_event_follow_fork(struct trace_array *tr, bool enable)
773	{
774	if (enable) {
775	register_trace_prio_sched_process_fork(probe: event_filter_pid_sched_process_fork,
776	data: tr, INT_MIN);
777	register_trace_prio_sched_process_free(probe: event_filter_pid_sched_process_exit,
778	data: tr, INT_MAX);
779	} else {
780	unregister_trace_sched_process_fork(probe: event_filter_pid_sched_process_fork,
781	data: tr);
782	unregister_trace_sched_process_free(probe: event_filter_pid_sched_process_exit,
783	data: tr);
784	}
785	}
786
787	static void
788	event_filter_pid_sched_switch_probe_pre(void *data, bool preempt,
789	struct task_struct *prev,
790	struct task_struct *next,
791	unsigned int prev_state)
792	{
793	struct trace_array *tr = data;
794	struct trace_pid_list *no_pid_list;
795	struct trace_pid_list *pid_list;
796	bool ret;
797
798	pid_list = rcu_dereference_sched(tr->filtered_pids);
799	no_pid_list = rcu_dereference_sched(tr->filtered_no_pids);
800
801	/*
802	* Sched switch is funny, as we only want to ignore it
803	* in the notrace case if both prev and next should be ignored.
804	*/
805	ret = trace_ignore_this_task(NULL, filtered_no_pids: no_pid_list, task: prev) &&
806	trace_ignore_this_task(NULL, filtered_no_pids: no_pid_list, task: next);
807
808	this_cpu_write(tr->array_buffer.data->ignore_pid, ret ||
809	(trace_ignore_this_task(pid_list, NULL, prev) &&
810	trace_ignore_this_task(pid_list, NULL, next)));
811	}
812
813	static void
814	event_filter_pid_sched_switch_probe_post(void *data, bool preempt,
815	struct task_struct *prev,
816	struct task_struct *next,
817	unsigned int prev_state)
818	{
819	struct trace_array *tr = data;
820	struct trace_pid_list *no_pid_list;
821	struct trace_pid_list *pid_list;
822
823	pid_list = rcu_dereference_sched(tr->filtered_pids);
824	no_pid_list = rcu_dereference_sched(tr->filtered_no_pids);
825
826	this_cpu_write(tr->array_buffer.data->ignore_pid,
827	trace_ignore_this_task(pid_list, no_pid_list, next));
828	}
829
830	static void
831	event_filter_pid_sched_wakeup_probe_pre(void *data, struct task_struct *task)
832	{
833	struct trace_array *tr = data;
834	struct trace_pid_list *no_pid_list;
835	struct trace_pid_list *pid_list;
836
837	/* Nothing to do if we are already tracing */
838	if (!this_cpu_read(tr->array_buffer.data->ignore_pid))
839	return;
840
841	pid_list = rcu_dereference_sched(tr->filtered_pids);
842	no_pid_list = rcu_dereference_sched(tr->filtered_no_pids);
843
844	this_cpu_write(tr->array_buffer.data->ignore_pid,
845	trace_ignore_this_task(pid_list, no_pid_list, task));
846	}
847
848	static void
849	event_filter_pid_sched_wakeup_probe_post(void *data, struct task_struct *task)
850	{
851	struct trace_array *tr = data;
852	struct trace_pid_list *no_pid_list;
853	struct trace_pid_list *pid_list;
854
855	/* Nothing to do if we are not tracing */
856	if (this_cpu_read(tr->array_buffer.data->ignore_pid))
857	return;
858
859	pid_list = rcu_dereference_sched(tr->filtered_pids);
860	no_pid_list = rcu_dereference_sched(tr->filtered_no_pids);
861
862	/* Set tracing if current is enabled */
863	this_cpu_write(tr->array_buffer.data->ignore_pid,
864	trace_ignore_this_task(pid_list, no_pid_list, current));
865	}
866
867	static void unregister_pid_events(struct trace_array *tr)
868	{
869	unregister_trace_sched_switch(probe: event_filter_pid_sched_switch_probe_pre, data: tr);
870	unregister_trace_sched_switch(probe: event_filter_pid_sched_switch_probe_post, data: tr);
871
872	unregister_trace_sched_wakeup(probe: event_filter_pid_sched_wakeup_probe_pre, data: tr);
873	unregister_trace_sched_wakeup(probe: event_filter_pid_sched_wakeup_probe_post, data: tr);
874
875	unregister_trace_sched_wakeup_new(probe: event_filter_pid_sched_wakeup_probe_pre, data: tr);
876	unregister_trace_sched_wakeup_new(probe: event_filter_pid_sched_wakeup_probe_post, data: tr);
877
878	unregister_trace_sched_waking(probe: event_filter_pid_sched_wakeup_probe_pre, data: tr);
879	unregister_trace_sched_waking(probe: event_filter_pid_sched_wakeup_probe_post, data: tr);
880	}
881
882	static void __ftrace_clear_event_pids(struct trace_array *tr, int type)
883	{
884	struct trace_pid_list *pid_list;
885	struct trace_pid_list *no_pid_list;
886	struct trace_event_file *file;
887	int cpu;
888
889	pid_list = rcu_dereference_protected(tr->filtered_pids,
890	lockdep_is_held(&event_mutex));
891	no_pid_list = rcu_dereference_protected(tr->filtered_no_pids,
892	lockdep_is_held(&event_mutex));
893
894	/* Make sure there's something to do */
895	if (!pid_type_enabled(type, pid_list, no_pid_list))
896	return;
897
898	if (!still_need_pid_events(type, pid_list, no_pid_list)) {
899	unregister_pid_events(tr);
900
901	list_for_each_entry(file, &tr->events, list) {
902	clear_bit(nr: EVENT_FILE_FL_PID_FILTER_BIT, addr: &file->flags);
903	}
904
905	for_each_possible_cpu(cpu)
906	per_cpu_ptr(tr->array_buffer.data, cpu)->ignore_pid = false;
907	}
908
909	if (type & TRACE_PIDS)
910	rcu_assign_pointer(tr->filtered_pids, NULL);
911
912	if (type & TRACE_NO_PIDS)
913	rcu_assign_pointer(tr->filtered_no_pids, NULL);
914
915	/* Wait till all users are no longer using pid filtering */
916	tracepoint_synchronize_unregister();
917
918	if ((type & TRACE_PIDS) && pid_list)
919	trace_pid_list_free(pid_list);
920
921	if ((type & TRACE_NO_PIDS) && no_pid_list)
922	trace_pid_list_free(pid_list: no_pid_list);
923	}
924
925	static void ftrace_clear_event_pids(struct trace_array *tr, int type)
926	{
927	mutex_lock(&event_mutex);
928	__ftrace_clear_event_pids(tr, type);
929	mutex_unlock(lock: &event_mutex);
930	}
931
932	static void __put_system(struct event_subsystem *system)
933	{
934	struct event_filter *filter = system->filter;
935
936	WARN_ON_ONCE(system_refcount(system) == 0);
937	if (system_refcount_dec(system))
938	return;
939
940	list_del(entry: &system->list);
941
942	if (filter) {
943	kfree(objp: filter->filter_string);
944	kfree(objp: filter);
945	}
946	kfree_const(x: system->name);
947	kfree(objp: system);
948	}
949
950	static void __get_system(struct event_subsystem *system)
951	{
952	WARN_ON_ONCE(system_refcount(system) == 0);
953	system_refcount_inc(system);
954	}
955
956	static void __get_system_dir(struct trace_subsystem_dir *dir)
957	{
958	WARN_ON_ONCE(dir->ref_count == 0);
959	dir->ref_count++;
960	__get_system(system: dir->subsystem);
961	}
962
963	static void __put_system_dir(struct trace_subsystem_dir *dir)
964	{
965	WARN_ON_ONCE(dir->ref_count == 0);
966	/* If the subsystem is about to be freed, the dir must be too */
967	WARN_ON_ONCE(system_refcount(dir->subsystem) == 1 && dir->ref_count != 1);
968
969	__put_system(system: dir->subsystem);
970	if (!--dir->ref_count)
971	kfree(objp: dir);
972	}
973
974	static void put_system(struct trace_subsystem_dir *dir)
975	{
976	mutex_lock(&event_mutex);
977	__put_system_dir(dir);
978	mutex_unlock(lock: &event_mutex);
979	}
980
981	static void remove_subsystem(struct trace_subsystem_dir *dir)
982	{
983	if (!dir)
984	return;
985
986	if (!--dir->nr_events) {
987	eventfs_remove_dir(ei: dir->ei);
988	list_del(entry: &dir->list);
989	__put_system_dir(dir);
990	}
991	}
992
993	void event_file_get(struct trace_event_file *file)
994	{
995	atomic_inc(v: &file->ref);
996	}
997
998	void event_file_put(struct trace_event_file *file)
999	{
1000	if (WARN_ON_ONCE(!atomic_read(&file->ref))) {
1001	if (file->flags & EVENT_FILE_FL_FREED)
1002	kmem_cache_free(s: file_cachep, objp: file);
1003	return;
1004	}
1005
1006	if (atomic_dec_and_test(v: &file->ref)) {
1007	/* Count should only go to zero when it is freed */
1008	if (WARN_ON_ONCE(!(file->flags & EVENT_FILE_FL_FREED)))
1009	return;
1010	kmem_cache_free(s: file_cachep, objp: file);
1011	}
1012	}
1013
1014	static void remove_event_file_dir(struct trace_event_file *file)
1015	{
1016	eventfs_remove_dir(ei: file->ei);
1017	list_del(entry: &file->list);
1018	remove_subsystem(dir: file->system);
1019	free_event_filter(filter: file->filter);
1020	file->flags |= EVENT_FILE_FL_FREED;
1021	event_file_put(file);
1022	}
1023
1024	/*
1025	* __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events.
1026	*/
1027	static int
1028	__ftrace_set_clr_event_nolock(struct trace_array *tr, const char *match,
1029	const char *sub, const char *event, int set)
1030	{
1031	struct trace_event_file *file;
1032	struct trace_event_call *call;
1033	const char *name;
1034	int ret = -EINVAL;
1035	int eret = 0;
1036
1037	list_for_each_entry(file, &tr->events, list) {
1038
1039	call = file->event_call;
1040	name = trace_event_name(call);
1041
1042	if (!name || !call->class || !call->class->reg)
1043	continue;
1044
1045	if (call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)
1046	continue;
1047
1048	if (match &&
1049	strcmp(match, name) != 0 &&
1050	strcmp(match, call->class->system) != 0)
1051	continue;
1052
1053	if (sub && strcmp(sub, call->class->system) != 0)
1054	continue;
1055
1056	if (event && strcmp(event, name) != 0)
1057	continue;
1058
1059	ret = ftrace_event_enable_disable(file, enable: set);
1060
1061	/*
1062	* Save the first error and return that. Some events
1063	* may still have been enabled, but let the user
1064	* know that something went wrong.
1065	*/
1066	if (ret && !eret)
1067	eret = ret;
1068
1069	ret = eret;
1070	}
1071
1072	return ret;
1073	}
1074
1075	static int __ftrace_set_clr_event(struct trace_array *tr, const char *match,
1076	const char *sub, const char *event, int set)
1077	{
1078	int ret;
1079
1080	mutex_lock(&event_mutex);
1081	ret = __ftrace_set_clr_event_nolock(tr, match, sub, event, set);
1082	mutex_unlock(lock: &event_mutex);
1083
1084	return ret;
1085	}
1086
1087	int ftrace_set_clr_event(struct trace_array *tr, char *buf, int set)
1088	{
1089	char *event = NULL, *sub = NULL, *match;
1090	int ret;
1091
1092	if (!tr)
1093	return -ENOENT;
1094	/*
1095	* The buf format can be <subsystem>:<event-name>
1096	* *:<event-name> means any event by that name.
1097	* :<event-name> is the same.
1098	*
1099	* <subsystem>:* means all events in that subsystem
1100	* <subsystem>: means the same.
1101	*
1102	* <name> (no ':') means all events in a subsystem with
1103	* the name <name> or any event that matches <name>
1104	*/
1105
1106	match = strsep(&buf, ":");
1107	if (buf) {
1108	sub = match;
1109	event = buf;
1110	match = NULL;
1111
1112	if (!strlen(sub) || strcmp(sub, "*") == 0)
1113	sub = NULL;
1114	if (!strlen(event) || strcmp(event, "*") == 0)
1115	event = NULL;
1116	}
1117
1118	ret = __ftrace_set_clr_event(tr, match, sub, event, set);
1119
1120	/* Put back the colon to allow this to be called again */
1121	if (buf)
1122	*(buf - 1) = ':';
1123
1124	return ret;
1125	}
1126
1127	/**
1128	* trace_set_clr_event - enable or disable an event
1129	* @system: system name to match (NULL for any system)
1130	* @event: event name to match (NULL for all events, within system)
1131	* @set: 1 to enable, 0 to disable
1132	*
1133	* This is a way for other parts of the kernel to enable or disable
1134	* event recording.
1135	*
1136	* Returns 0 on success, -EINVAL if the parameters do not match any
1137	* registered events.
1138	*/
1139	int trace_set_clr_event(const char *system, const char *event, int set)
1140	{
1141	struct trace_array *tr = top_trace_array();
1142
1143	if (!tr)
1144	return -ENODEV;
1145
1146	return __ftrace_set_clr_event(tr, NULL, sub: system, event, set);
1147	}
1148	EXPORT_SYMBOL_GPL(trace_set_clr_event);
1149
1150	/**
1151	* trace_array_set_clr_event - enable or disable an event for a trace array.
1152	* @tr: concerned trace array.
1153	* @system: system name to match (NULL for any system)
1154	* @event: event name to match (NULL for all events, within system)
1155	* @enable: true to enable, false to disable
1156	*
1157	* This is a way for other parts of the kernel to enable or disable
1158	* event recording.
1159	*
1160	* Returns 0 on success, -EINVAL if the parameters do not match any
1161	* registered events.
1162	*/
1163	int trace_array_set_clr_event(struct trace_array *tr, const char *system,
1164	const char *event, bool enable)
1165	{
1166	int set;
1167
1168	if (!tr)
1169	return -ENOENT;
1170
1171	set = (enable == true) ? 1 : 0;
1172	return __ftrace_set_clr_event(tr, NULL, sub: system, event, set);
1173	}
1174	EXPORT_SYMBOL_GPL(trace_array_set_clr_event);
1175
1176	/* 128 should be much more than enough */
1177	#define EVENT_BUF_SIZE 127
1178
1179	static ssize_t
1180	ftrace_event_write(struct file *file, const char __user *ubuf,
1181	size_t cnt, loff_t *ppos)
1182	{
1183	struct trace_parser parser;
1184	struct seq_file *m = file->private_data;
1185	struct trace_array *tr = m->private;
1186	ssize_t read, ret;
1187
1188	if (!cnt)
1189	return 0;
1190
1191	ret = tracing_update_buffers(tr);
1192	if (ret < 0)
1193	return ret;
1194
1195	if (trace_parser_get_init(parser: &parser, EVENT_BUF_SIZE + 1))
1196	return -ENOMEM;
1197
1198	read = trace_get_user(parser: &parser, ubuf, cnt, ppos);
1199
1200	if (read >= 0 && trace_parser_loaded(parser: (&parser))) {
1201	int set = 1;
1202
1203	if (*parser.buffer == '!')
1204	set = 0;
1205
1206	ret = ftrace_set_clr_event(tr, buf: parser.buffer + !set, set);
1207	if (ret)
1208	goto out_put;
1209	}
1210
1211	ret = read;
1212
1213	out_put:
1214	trace_parser_put(parser: &parser);
1215
1216	return ret;
1217	}
1218
1219	static void *
1220	t_next(struct seq_file *m, void *v, loff_t *pos)
1221	{
1222	struct trace_event_file *file = v;
1223	struct trace_event_call *call;
1224	struct trace_array *tr = m->private;
1225
1226	(*pos)++;
1227
1228	list_for_each_entry_continue(file, &tr->events, list) {
1229	call = file->event_call;
1230	/*
1231	* The ftrace subsystem is for showing formats only.
1232	* They can not be enabled or disabled via the event files.
1233	*/
1234	if (call->class && call->class->reg &&
1235	!(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE))
1236	return file;
1237	}
1238
1239	return NULL;
1240	}
1241
1242	static void *t_start(struct seq_file *m, loff_t *pos)
1243	{
1244	struct trace_event_file *file;
1245	struct trace_array *tr = m->private;
1246	loff_t l;
1247
1248	mutex_lock(&event_mutex);
1249
1250	file = list_entry(&tr->events, struct trace_event_file, list);
1251	for (l = 0; l <= *pos; ) {
1252	file = t_next(m, v: file, pos: &l);
1253	if (!file)
1254	break;
1255	}
1256	return file;
1257	}
1258
1259	static void *
1260	s_next(struct seq_file *m, void *v, loff_t *pos)
1261	{
1262	struct trace_event_file *file = v;
1263	struct trace_array *tr = m->private;
1264
1265	(*pos)++;
1266
1267	list_for_each_entry_continue(file, &tr->events, list) {
1268	if (file->flags & EVENT_FILE_FL_ENABLED)
1269	return file;
1270	}
1271
1272	return NULL;
1273	}
1274
1275	static void *s_start(struct seq_file *m, loff_t *pos)
1276	{
1277	struct trace_event_file *file;
1278	struct trace_array *tr = m->private;
1279	loff_t l;
1280
1281	mutex_lock(&event_mutex);
1282
1283	file = list_entry(&tr->events, struct trace_event_file, list);
1284	for (l = 0; l <= *pos; ) {
1285	file = s_next(m, v: file, pos: &l);
1286	if (!file)
1287	break;
1288	}
1289	return file;
1290	}
1291
1292	static int t_show(struct seq_file *m, void *v)
1293	{
1294	struct trace_event_file *file = v;
1295	struct trace_event_call *call = file->event_call;
1296
1297	if (strcmp(call->class->system, TRACE_SYSTEM) != 0)
1298	seq_printf(m, fmt: "%s:", call->class->system);
1299	seq_printf(m, fmt: "%s\n", trace_event_name(call));
1300
1301	return 0;
1302	}
1303
1304	static void t_stop(struct seq_file *m, void *p)
1305	{
1306	mutex_unlock(lock: &event_mutex);
1307	}
1308
1309	static void *
1310	__next(struct seq_file *m, void *v, loff_t *pos, int type)
1311	{
1312	struct trace_array *tr = m->private;
1313	struct trace_pid_list *pid_list;
1314
1315	if (type == TRACE_PIDS)
1316	pid_list = rcu_dereference_sched(tr->filtered_pids);
1317	else
1318	pid_list = rcu_dereference_sched(tr->filtered_no_pids);
1319
1320	return trace_pid_next(pid_list, v, pos);
1321	}
1322
1323	static void *
1324	p_next(struct seq_file *m, void *v, loff_t *pos)
1325	{
1326	return __next(m, v, pos, type: TRACE_PIDS);
1327	}
1328
1329	static void *
1330	np_next(struct seq_file *m, void *v, loff_t *pos)
1331	{
1332	return __next(m, v, pos, type: TRACE_NO_PIDS);
1333	}
1334
1335	static void *__start(struct seq_file *m, loff_t *pos, int type)
1336	__acquires(RCU)
1337	{
1338	struct trace_pid_list *pid_list;
1339	struct trace_array *tr = m->private;
1340
1341	/*
1342	* Grab the mutex, to keep calls to p_next() having the same
1343	* tr->filtered_pids as p_start() has.
1344	* If we just passed the tr->filtered_pids around, then RCU would
1345	* have been enough, but doing that makes things more complex.
1346	*/
1347	mutex_lock(&event_mutex);
1348	rcu_read_lock_sched();
1349
1350	if (type == TRACE_PIDS)
1351	pid_list = rcu_dereference_sched(tr->filtered_pids);
1352	else
1353	pid_list = rcu_dereference_sched(tr->filtered_no_pids);
1354
1355	if (!pid_list)
1356	return NULL;
1357
1358	return trace_pid_start(pid_list, pos);
1359	}
1360
1361	static void *p_start(struct seq_file *m, loff_t *pos)
1362	__acquires(RCU)
1363	{
1364	return __start(m, pos, type: TRACE_PIDS);
1365	}
1366
1367	static void *np_start(struct seq_file *m, loff_t *pos)
1368	__acquires(RCU)
1369	{
1370	return __start(m, pos, type: TRACE_NO_PIDS);
1371	}
1372
1373	static void p_stop(struct seq_file *m, void *p)
1374	__releases(RCU)
1375	{
1376	rcu_read_unlock_sched();
1377	mutex_unlock(lock: &event_mutex);
1378	}
1379
1380	static ssize_t
1381	event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
1382	loff_t *ppos)
1383	{
1384	struct trace_event_file *file;
1385	unsigned long flags;
1386	char buf[4] = "0";
1387
1388	mutex_lock(&event_mutex);
1389	file = event_file_data(filp);
1390	if (likely(file))
1391	flags = file->flags;
1392	mutex_unlock(lock: &event_mutex);
1393
1394	if (!file || flags & EVENT_FILE_FL_FREED)
1395	return -ENODEV;
1396
1397	if (flags & EVENT_FILE_FL_ENABLED &&
1398	!(flags & EVENT_FILE_FL_SOFT_DISABLED))
1399	strcpy(p: buf, q: "1");
1400
1401	if (flags & EVENT_FILE_FL_SOFT_DISABLED ||
1402	flags & EVENT_FILE_FL_SOFT_MODE)
1403	strcat(p: buf, q: "*");
1404
1405	strcat(p: buf, q: "\n");
1406
1407	return simple_read_from_buffer(to: ubuf, count: cnt, ppos, from: buf, strlen(buf));
1408	}
1409
1410	static ssize_t
1411	event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
1412	loff_t *ppos)
1413	{
1414	struct trace_event_file *file;
1415	unsigned long val;
1416	int ret;
1417
1418	ret = kstrtoul_from_user(s: ubuf, count: cnt, base: 10, res: &val);
1419	if (ret)
1420	return ret;
1421
1422	switch (val) {
1423	case 0:
1424	case 1:
1425	ret = -ENODEV;
1426	mutex_lock(&event_mutex);
1427	file = event_file_data(filp);
1428	if (likely(file && !(file->flags & EVENT_FILE_FL_FREED))) {
1429	ret = tracing_update_buffers(tr: file->tr);
1430	if (ret < 0) {
1431	mutex_unlock(lock: &event_mutex);
1432	return ret;
1433	}
1434	ret = ftrace_event_enable_disable(file, enable: val);
1435	}
1436	mutex_unlock(lock: &event_mutex);
1437	break;
1438
1439	default:
1440	return -EINVAL;
1441	}
1442
1443	*ppos += cnt;
1444
1445	return ret ? ret : cnt;
1446	}
1447
1448	static ssize_t
1449	system_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
1450	loff_t *ppos)
1451	{
1452	const char set_to_char[4] = { '?', '0', '1', 'X' };
1453	struct trace_subsystem_dir *dir = filp->private_data;
1454	struct event_subsystem *system = dir->subsystem;
1455	struct trace_event_call *call;
1456	struct trace_event_file *file;
1457	struct trace_array *tr = dir->tr;
1458	char buf[2];
1459	int set = 0;
1460	int ret;
1461
1462	mutex_lock(&event_mutex);
1463	list_for_each_entry(file, &tr->events, list) {
1464	call = file->event_call;
1465	if ((call->flags & TRACE_EVENT_FL_IGNORE_ENABLE) ||
1466	!trace_event_name(call) || !call->class || !call->class->reg)
1467	continue;
1468
1469	if (system && strcmp(call->class->system, system->name) != 0)
1470	continue;
1471
1472	/*
1473	* We need to find out if all the events are set
1474	* or if all events or cleared, or if we have
1475	* a mixture.
1476	*/
1477	set |= (1 << !!(file->flags & EVENT_FILE_FL_ENABLED));
1478
1479	/*
1480	* If we have a mixture, no need to look further.
1481	*/
1482	if (set == 3)
1483	break;
1484	}
1485	mutex_unlock(lock: &event_mutex);
1486
1487	buf[0] = set_to_char[set];
1488	buf[1] = '\n';
1489
1490	ret = simple_read_from_buffer(to: ubuf, count: cnt, ppos, from: buf, available: 2);
1491
1492	return ret;
1493	}
1494
1495	static ssize_t
1496	system_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
1497	loff_t *ppos)
1498	{
1499	struct trace_subsystem_dir *dir = filp->private_data;
1500	struct event_subsystem *system = dir->subsystem;
1501	const char *name = NULL;
1502	unsigned long val;
1503	ssize_t ret;
1504
1505	ret = kstrtoul_from_user(s: ubuf, count: cnt, base: 10, res: &val);
1506	if (ret)
1507	return ret;
1508
1509	ret = tracing_update_buffers(tr: dir->tr);
1510	if (ret < 0)
1511	return ret;
1512
1513	if (val != 0 && val != 1)
1514	return -EINVAL;
1515
1516	/*
1517	* Opening of "enable" adds a ref count to system,
1518	* so the name is safe to use.
1519	*/
1520	if (system)
1521	name = system->name;
1522
1523	ret = __ftrace_set_clr_event(tr: dir->tr, NULL, sub: name, NULL, set: val);
1524	if (ret)
1525	goto out;
1526
1527	ret = cnt;
1528
1529	out:
1530	*ppos += cnt;
1531
1532	return ret;
1533	}
1534
1535	enum {
1536	FORMAT_HEADER = 1,
1537	FORMAT_FIELD_SEPERATOR = 2,
1538	FORMAT_PRINTFMT = 3,
1539	};
1540
1541	static void *f_next(struct seq_file *m, void *v, loff_t *pos)
1542	{
1543	struct trace_event_call *call = event_file_data(filp: m->private);
1544	struct list_head *common_head = &ftrace_common_fields;
1545	struct list_head *head = trace_get_fields(event_call: call);
1546	struct list_head *node = v;
1547
1548	(*pos)++;
1549
1550	switch ((unsigned long)v) {
1551	case FORMAT_HEADER:
1552	node = common_head;
1553	break;
1554
1555	case FORMAT_FIELD_SEPERATOR:
1556	node = head;
1557	break;
1558
1559	case FORMAT_PRINTFMT:
1560	/* all done */
1561	return NULL;
1562	}
1563
1564	node = node->prev;
1565	if (node == common_head)
1566	return (void *)FORMAT_FIELD_SEPERATOR;
1567	else if (node == head)
1568	return (void *)FORMAT_PRINTFMT;
1569	else
1570	return node;
1571	}
1572
1573	static int f_show(struct seq_file *m, void *v)
1574	{
1575	struct trace_event_call *call = event_file_data(filp: m->private);
1576	struct ftrace_event_field *field;
1577	const char *array_descriptor;
1578
1579	switch ((unsigned long)v) {
1580	case FORMAT_HEADER:
1581	seq_printf(m, fmt: "name: %s\n", trace_event_name(call));
1582	seq_printf(m, fmt: "ID: %d\n", call->event.type);
1583	seq_puts(m, s: "format:\n");
1584	return 0;
1585
1586	case FORMAT_FIELD_SEPERATOR:
1587	seq_putc(m, c: '\n');
1588	return 0;
1589
1590	case FORMAT_PRINTFMT:
1591	seq_printf(m, fmt: "\nprint fmt: %s\n",
1592	call->print_fmt);
1593	return 0;
1594	}
1595
1596	field = list_entry(v, struct ftrace_event_field, link);
1597	/*
1598	* Smartly shows the array type(except dynamic array).
1599	* Normal:
1600	* field:TYPE VAR
1601	* If TYPE := TYPE[LEN], it is shown:
1602	* field:TYPE VAR[LEN]
1603	*/
1604	array_descriptor = strchr(field->type, '[');
1605
1606	if (str_has_prefix(str: field->type, prefix: "__data_loc"))
1607	array_descriptor = NULL;
1608
1609	if (!array_descriptor)
1610	seq_printf(m, fmt: "\tfield:%s %s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
1611	field->type, field->name, field->offset,
1612	field->size, !!field->is_signed);
1613	else if (field->len)
1614	seq_printf(m, fmt: "\tfield:%.*s %s[%d];\toffset:%u;\tsize:%u;\tsigned:%d;\n",
1615	(int)(array_descriptor - field->type),
1616	field->type, field->name,
1617	field->len, field->offset,
1618	field->size, !!field->is_signed);
1619	else
1620	seq_printf(m, fmt: "\tfield:%.*s %s[];\toffset:%u;\tsize:%u;\tsigned:%d;\n",
1621	(int)(array_descriptor - field->type),
1622	field->type, field->name,
1623	field->offset, field->size, !!field->is_signed);
1624
1625	return 0;
1626	}
1627
1628	static void *f_start(struct seq_file *m, loff_t *pos)
1629	{
1630	void *p = (void *)FORMAT_HEADER;
1631	loff_t l = 0;
1632
1633	/* ->stop() is called even if ->start() fails */
1634	mutex_lock(&event_mutex);
1635	if (!event_file_data(filp: m->private))
1636	return ERR_PTR(error: -ENODEV);
1637
1638	while (l < *pos && p)
1639	p = f_next(m, v: p, pos: &l);
1640
1641	return p;
1642	}
1643
1644	static void f_stop(struct seq_file *m, void *p)
1645	{
1646	mutex_unlock(lock: &event_mutex);
1647	}
1648
1649	static const struct seq_operations trace_format_seq_ops = {
1650	.start = f_start,
1651	.next = f_next,
1652	.stop = f_stop,
1653	.show = f_show,
1654	};
1655
1656	static int trace_format_open(struct inode *inode, struct file *file)
1657	{
1658	struct seq_file *m;
1659	int ret;
1660
1661	/* Do we want to hide event format files on tracefs lockdown? */
1662
1663	ret = seq_open(file, &trace_format_seq_ops);
1664	if (ret < 0)
1665	return ret;
1666
1667	m = file->private_data;
1668	m->private = file;
1669
1670	return 0;
1671	}
1672
1673	#ifdef CONFIG_PERF_EVENTS
1674	static ssize_t
1675	event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
1676	{
1677	int id = (long)event_file_data(filp);
1678	char buf[32];
1679	int len;
1680
1681	if (unlikely(!id))
1682	return -ENODEV;
1683
1684	len = sprintf(buf, fmt: "%d\n", id);
1685
1686	return simple_read_from_buffer(to: ubuf, count: cnt, ppos, from: buf, available: len);
1687	}
1688	#endif
1689
1690	static ssize_t
1691	event_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
1692	loff_t *ppos)
1693	{
1694	struct trace_event_file *file;
1695	struct trace_seq *s;
1696	int r = -ENODEV;
1697
1698	if (*ppos)
1699	return 0;
1700
1701	s = kmalloc(size: sizeof(*s), GFP_KERNEL);
1702
1703	if (!s)
1704	return -ENOMEM;
1705
1706	trace_seq_init(s);
1707
1708	mutex_lock(&event_mutex);
1709	file = event_file_data(filp);
1710	if (file && !(file->flags & EVENT_FILE_FL_FREED))
1711	print_event_filter(file, s);
1712	mutex_unlock(lock: &event_mutex);
1713
1714	if (file)
1715	r = simple_read_from_buffer(to: ubuf, count: cnt, ppos,
1716	from: s->buffer, available: trace_seq_used(s));
1717
1718	kfree(objp: s);
1719
1720	return r;
1721	}
1722
1723	static ssize_t
1724	event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
1725	loff_t *ppos)
1726	{
1727	struct trace_event_file *file;
1728	char *buf;
1729	int err = -ENODEV;
1730
1731	if (cnt >= PAGE_SIZE)
1732	return -EINVAL;
1733
1734	buf = memdup_user_nul(ubuf, cnt);
1735	if (IS_ERR(ptr: buf))
1736	return PTR_ERR(ptr: buf);
1737
1738	mutex_lock(&event_mutex);
1739	file = event_file_data(filp);
1740	if (file)
1741	err = apply_event_filter(file, filter_string: buf);
1742	mutex_unlock(lock: &event_mutex);
1743
1744	kfree(objp: buf);
1745	if (err < 0)
1746	return err;
1747
1748	*ppos += cnt;
1749
1750	return cnt;
1751	}
1752
1753	static LIST_HEAD(event_subsystems);
1754
1755	static int subsystem_open(struct inode *inode, struct file *filp)
1756	{
1757	struct trace_subsystem_dir *dir = NULL, *iter_dir;
1758	struct trace_array *tr = NULL, *iter_tr;
1759	struct event_subsystem *system = NULL;
1760	int ret;
1761
1762	if (tracing_is_disabled())
1763	return -ENODEV;
1764
1765	/* Make sure the system still exists */
1766	mutex_lock(&event_mutex);
1767	mutex_lock(&trace_types_lock);
1768	list_for_each_entry(iter_tr, &ftrace_trace_arrays, list) {
1769	list_for_each_entry(iter_dir, &iter_tr->systems, list) {
1770	if (iter_dir == inode->i_private) {
1771	/* Don't open systems with no events */
1772	tr = iter_tr;
1773	dir = iter_dir;
1774	if (dir->nr_events) {
1775	__get_system_dir(dir);
1776	system = dir->subsystem;
1777	}
1778	goto exit_loop;
1779	}
1780	}
1781	}
1782	exit_loop:
1783	mutex_unlock(lock: &trace_types_lock);
1784	mutex_unlock(lock: &event_mutex);
1785
1786	if (!system)
1787	return -ENODEV;
1788
1789	/* Still need to increment the ref count of the system */
1790	if (trace_array_get(tr) < 0) {
1791	put_system(dir);
1792	return -ENODEV;
1793	}
1794
1795	ret = tracing_open_generic(inode, filp);
1796	if (ret < 0) {
1797	trace_array_put(tr);
1798	put_system(dir);
1799	}
1800
1801	return ret;
1802	}
1803
1804	static int system_tr_open(struct inode *inode, struct file *filp)
1805	{
1806	struct trace_subsystem_dir *dir;
1807	struct trace_array *tr = inode->i_private;
1808	int ret;
1809
1810	/* Make a temporary dir that has no system but points to tr */
1811	dir = kzalloc(size: sizeof(*dir), GFP_KERNEL);
1812	if (!dir)
1813	return -ENOMEM;
1814
1815	ret = tracing_open_generic_tr(inode, filp);
1816	if (ret < 0) {
1817	kfree(objp: dir);
1818	return ret;
1819	}
1820	dir->tr = tr;
1821	filp->private_data = dir;
1822
1823	return 0;
1824	}
1825
1826	static int subsystem_release(struct inode *inode, struct file *file)
1827	{
1828	struct trace_subsystem_dir *dir = file->private_data;
1829
1830	trace_array_put(tr: dir->tr);
1831
1832	/*
1833	* If dir->subsystem is NULL, then this is a temporary
1834	* descriptor that was made for a trace_array to enable
1835	* all subsystems.
1836	*/
1837	if (dir->subsystem)
1838	put_system(dir);
1839	else
1840	kfree(objp: dir);
1841
1842	return 0;
1843	}
1844
1845	static ssize_t
1846	subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
1847	loff_t *ppos)
1848	{
1849	struct trace_subsystem_dir *dir = filp->private_data;
1850	struct event_subsystem *system = dir->subsystem;
1851	struct trace_seq *s;
1852	int r;
1853
1854	if (*ppos)
1855	return 0;
1856
1857	s = kmalloc(size: sizeof(*s), GFP_KERNEL);
1858	if (!s)
1859	return -ENOMEM;
1860
1861	trace_seq_init(s);
1862
1863	print_subsystem_event_filter(system, s);
1864	r = simple_read_from_buffer(to: ubuf, count: cnt, ppos,
1865	from: s->buffer, available: trace_seq_used(s));
1866
1867	kfree(objp: s);
1868
1869	return r;
1870	}
1871
1872	static ssize_t
1873	subsystem_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
1874	loff_t *ppos)
1875	{
1876	struct trace_subsystem_dir *dir = filp->private_data;
1877	char *buf;
1878	int err;
1879
1880	if (cnt >= PAGE_SIZE)
1881	return -EINVAL;
1882
1883	buf = memdup_user_nul(ubuf, cnt);
1884	if (IS_ERR(ptr: buf))
1885	return PTR_ERR(ptr: buf);
1886
1887	err = apply_subsystem_event_filter(dir, filter_string: buf);
1888	kfree(objp: buf);
1889	if (err < 0)
1890	return err;
1891
1892	*ppos += cnt;
1893
1894	return cnt;
1895	}
1896
1897	static ssize_t
1898	show_header_page_file(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
1899	{
1900	struct trace_array *tr = filp->private_data;
1901	struct trace_seq *s;
1902	int r;
1903
1904	if (*ppos)
1905	return 0;
1906
1907	s = kmalloc(size: sizeof(*s), GFP_KERNEL);
1908	if (!s)
1909	return -ENOMEM;
1910
1911	trace_seq_init(s);
1912
1913	ring_buffer_print_page_header(buffer: tr->array_buffer.buffer, s);
1914	r = simple_read_from_buffer(to: ubuf, count: cnt, ppos,
1915	from: s->buffer, available: trace_seq_used(s));
1916
1917	kfree(objp: s);
1918
1919	return r;
1920	}
1921
1922	static ssize_t
1923	show_header_event_file(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
1924	{
1925	struct trace_seq *s;
1926	int r;
1927
1928	if (*ppos)
1929	return 0;
1930
1931	s = kmalloc(size: sizeof(*s), GFP_KERNEL);
1932	if (!s)
1933	return -ENOMEM;
1934
1935	trace_seq_init(s);
1936
1937	ring_buffer_print_entry_header(s);
1938	r = simple_read_from_buffer(to: ubuf, count: cnt, ppos,
1939	from: s->buffer, available: trace_seq_used(s));
1940
1941	kfree(objp: s);
1942
1943	return r;
1944	}
1945
1946	static void ignore_task_cpu(void *data)
1947	{
1948	struct trace_array *tr = data;
1949	struct trace_pid_list *pid_list;
1950	struct trace_pid_list *no_pid_list;
1951
1952	/*
1953	* This function is called by on_each_cpu() while the
1954	* event_mutex is held.
1955	*/
1956	pid_list = rcu_dereference_protected(tr->filtered_pids,
1957	mutex_is_locked(&event_mutex));
1958	no_pid_list = rcu_dereference_protected(tr->filtered_no_pids,
1959	mutex_is_locked(&event_mutex));
1960
1961	this_cpu_write(tr->array_buffer.data->ignore_pid,
1962	trace_ignore_this_task(pid_list, no_pid_list, current));
1963	}
1964
1965	static void register_pid_events(struct trace_array *tr)
1966	{
1967	/*
1968	* Register a probe that is called before all other probes
1969	* to set ignore_pid if next or prev do not match.
1970	* Register a probe this is called after all other probes
1971	* to only keep ignore_pid set if next pid matches.
1972	*/
1973	register_trace_prio_sched_switch(probe: event_filter_pid_sched_switch_probe_pre,
1974	data: tr, INT_MAX);
1975	register_trace_prio_sched_switch(probe: event_filter_pid_sched_switch_probe_post,
1976	data: tr, prio: 0);
1977
1978	register_trace_prio_sched_wakeup(probe: event_filter_pid_sched_wakeup_probe_pre,
1979	data: tr, INT_MAX);
1980	register_trace_prio_sched_wakeup(probe: event_filter_pid_sched_wakeup_probe_post,
1981	data: tr, prio: 0);
1982
1983	register_trace_prio_sched_wakeup_new(probe: event_filter_pid_sched_wakeup_probe_pre,
1984	data: tr, INT_MAX);
1985	register_trace_prio_sched_wakeup_new(probe: event_filter_pid_sched_wakeup_probe_post,
1986	data: tr, prio: 0);
1987
1988	register_trace_prio_sched_waking(probe: event_filter_pid_sched_wakeup_probe_pre,
1989	data: tr, INT_MAX);
1990	register_trace_prio_sched_waking(probe: event_filter_pid_sched_wakeup_probe_post,
1991	data: tr, prio: 0);
1992	}
1993
1994	static ssize_t
1995	event_pid_write(struct file *filp, const char __user *ubuf,
1996	size_t cnt, loff_t *ppos, int type)
1997	{
1998	struct seq_file *m = filp->private_data;
1999	struct trace_array *tr = m->private;
2000	struct trace_pid_list *filtered_pids = NULL;
2001	struct trace_pid_list *other_pids = NULL;
2002	struct trace_pid_list *pid_list;
2003	struct trace_event_file *file;
2004	ssize_t ret;
2005
2006	if (!cnt)
2007	return 0;
2008
2009	ret = tracing_update_buffers(tr);
2010	if (ret < 0)
2011	return ret;
2012
2013	mutex_lock(&event_mutex);
2014
2015	if (type == TRACE_PIDS) {
2016	filtered_pids = rcu_dereference_protected(tr->filtered_pids,
2017	lockdep_is_held(&event_mutex));
2018	other_pids = rcu_dereference_protected(tr->filtered_no_pids,
2019	lockdep_is_held(&event_mutex));
2020	} else {
2021	filtered_pids = rcu_dereference_protected(tr->filtered_no_pids,
2022	lockdep_is_held(&event_mutex));
2023	other_pids = rcu_dereference_protected(tr->filtered_pids,
2024	lockdep_is_held(&event_mutex));
2025	}
2026
2027	ret = trace_pid_write(filtered_pids, new_pid_list: &pid_list, ubuf, cnt);
2028	if (ret < 0)
2029	goto out;
2030
2031	if (type == TRACE_PIDS)
2032	rcu_assign_pointer(tr->filtered_pids, pid_list);
2033	else
2034	rcu_assign_pointer(tr->filtered_no_pids, pid_list);
2035
2036	list_for_each_entry(file, &tr->events, list) {
2037	set_bit(nr: EVENT_FILE_FL_PID_FILTER_BIT, addr: &file->flags);
2038	}
2039
2040	if (filtered_pids) {
2041	tracepoint_synchronize_unregister();
2042	trace_pid_list_free(pid_list: filtered_pids);
2043	} else if (pid_list && !other_pids) {
2044	register_pid_events(tr);
2045	}
2046
2047	/*
2048	* Ignoring of pids is done at task switch. But we have to
2049	* check for those tasks that are currently running.
2050	* Always do this in case a pid was appended or removed.
2051	*/
2052	on_each_cpu(func: ignore_task_cpu, info: tr, wait: 1);
2053
2054	out:
2055	mutex_unlock(lock: &event_mutex);
2056
2057	if (ret > 0)
2058	*ppos += ret;
2059
2060	return ret;
2061	}
2062
2063	static ssize_t
2064	ftrace_event_pid_write(struct file *filp, const char __user *ubuf,
2065	size_t cnt, loff_t *ppos)
2066	{
2067	return event_pid_write(filp, ubuf, cnt, ppos, type: TRACE_PIDS);
2068	}
2069
2070	static ssize_t
2071	ftrace_event_npid_write(struct file *filp, const char __user *ubuf,
2072	size_t cnt, loff_t *ppos)
2073	{
2074	return event_pid_write(filp, ubuf, cnt, ppos, type: TRACE_NO_PIDS);
2075	}
2076
2077	static int ftrace_event_avail_open(struct inode *inode, struct file *file);
2078	static int ftrace_event_set_open(struct inode *inode, struct file *file);
2079	static int ftrace_event_set_pid_open(struct inode *inode, struct file *file);
2080	static int ftrace_event_set_npid_open(struct inode *inode, struct file *file);
2081	static int ftrace_event_release(struct inode *inode, struct file *file);
2082
2083	static const struct seq_operations show_event_seq_ops = {
2084	.start = t_start,
2085	.next = t_next,
2086	.show = t_show,
2087	.stop = t_stop,
2088	};
2089
2090	static const struct seq_operations show_set_event_seq_ops = {
2091	.start = s_start,
2092	.next = s_next,
2093	.show = t_show,
2094	.stop = t_stop,
2095	};
2096
2097	static const struct seq_operations show_set_pid_seq_ops = {
2098	.start = p_start,
2099	.next = p_next,
2100	.show = trace_pid_show,
2101	.stop = p_stop,
2102	};
2103
2104	static const struct seq_operations show_set_no_pid_seq_ops = {
2105	.start = np_start,
2106	.next = np_next,
2107	.show = trace_pid_show,
2108	.stop = p_stop,
2109	};
2110
2111	static const struct file_operations ftrace_avail_fops = {
2112	.open = ftrace_event_avail_open,
2113	.read = seq_read,
2114	.llseek = seq_lseek,
2115	.release = seq_release,
2116	};
2117
2118	static const struct file_operations ftrace_set_event_fops = {
2119	.open = ftrace_event_set_open,
2120	.read = seq_read,
2121	.write = ftrace_event_write,
2122	.llseek = seq_lseek,
2123	.release = ftrace_event_release,
2124	};
2125
2126	static const struct file_operations ftrace_set_event_pid_fops = {
2127	.open = ftrace_event_set_pid_open,
2128	.read = seq_read,
2129	.write = ftrace_event_pid_write,
2130	.llseek = seq_lseek,
2131	.release = ftrace_event_release,
2132	};
2133
2134	static const struct file_operations ftrace_set_event_notrace_pid_fops = {
2135	.open = ftrace_event_set_npid_open,
2136	.read = seq_read,
2137	.write = ftrace_event_npid_write,
2138	.llseek = seq_lseek,
2139	.release = ftrace_event_release,
2140	};
2141
2142	static const struct file_operations ftrace_enable_fops = {
2143	.open = tracing_open_file_tr,
2144	.read = event_enable_read,
2145	.write = event_enable_write,
2146	.release = tracing_release_file_tr,
2147	.llseek = default_llseek,
2148	};
2149
2150	static const struct file_operations ftrace_event_format_fops = {
2151	.open = trace_format_open,
2152	.read = seq_read,
2153	.llseek = seq_lseek,
2154	.release = seq_release,
2155	};
2156
2157	#ifdef CONFIG_PERF_EVENTS
2158	static const struct file_operations ftrace_event_id_fops = {
2159	.read = event_id_read,
2160	.llseek = default_llseek,
2161	};
2162	#endif
2163
2164	static const struct file_operations ftrace_event_filter_fops = {
2165	.open = tracing_open_file_tr,
2166	.read = event_filter_read,
2167	.write = event_filter_write,
2168	.release = tracing_release_file_tr,
2169	.llseek = default_llseek,
2170	};
2171
2172	static const struct file_operations ftrace_subsystem_filter_fops = {
2173	.open = subsystem_open,
2174	.read = subsystem_filter_read,
2175	.write = subsystem_filter_write,
2176	.llseek = default_llseek,
2177	.release = subsystem_release,
2178	};
2179
2180	static const struct file_operations ftrace_system_enable_fops = {
2181	.open = subsystem_open,
2182	.read = system_enable_read,
2183	.write = system_enable_write,
2184	.llseek = default_llseek,
2185	.release = subsystem_release,
2186	};
2187
2188	static const struct file_operations ftrace_tr_enable_fops = {
2189	.open = system_tr_open,
2190	.read = system_enable_read,
2191	.write = system_enable_write,
2192	.llseek = default_llseek,
2193	.release = subsystem_release,
2194	};
2195
2196	static const struct file_operations ftrace_show_header_page_fops = {
2197	.open = tracing_open_generic_tr,
2198	.read = show_header_page_file,
2199	.llseek = default_llseek,
2200	.release = tracing_release_generic_tr,
2201	};
2202
2203	static const struct file_operations ftrace_show_header_event_fops = {
2204	.open = tracing_open_generic_tr,
2205	.read = show_header_event_file,
2206	.llseek = default_llseek,
2207	.release = tracing_release_generic_tr,
2208	};
2209
2210	static int
2211	ftrace_event_open(struct inode *inode, struct file *file,
2212	const struct seq_operations *seq_ops)
2213	{
2214	struct seq_file *m;
2215	int ret;
2216
2217	ret = security_locked_down(what: LOCKDOWN_TRACEFS);
2218	if (ret)
2219	return ret;
2220
2221	ret = seq_open(file, seq_ops);
2222	if (ret < 0)
2223	return ret;
2224	m = file->private_data;
2225	/* copy tr over to seq ops */
2226	m->private = inode->i_private;
2227
2228	return ret;
2229	}
2230
2231	static int ftrace_event_release(struct inode *inode, struct file *file)
2232	{
2233	struct trace_array *tr = inode->i_private;
2234
2235	trace_array_put(tr);
2236
2237	return seq_release(inode, file);
2238	}
2239
2240	static int
2241	ftrace_event_avail_open(struct inode *inode, struct file *file)
2242	{
2243	const struct seq_operations *seq_ops = &show_event_seq_ops;
2244
2245	/* Checks for tracefs lockdown */
2246	return ftrace_event_open(inode, file, seq_ops);
2247	}
2248
2249	static int
2250	ftrace_event_set_open(struct inode *inode, struct file *file)
2251	{
2252	const struct seq_operations *seq_ops = &show_set_event_seq_ops;
2253	struct trace_array *tr = inode->i_private;
2254	int ret;
2255
2256	ret = tracing_check_open_get_tr(tr);
2257	if (ret)
2258	return ret;
2259
2260	if ((file->f_mode & FMODE_WRITE) &&
2261	(file->f_flags & O_TRUNC))
2262	ftrace_clear_events(tr);
2263
2264	ret = ftrace_event_open(inode, file, seq_ops);
2265	if (ret < 0)
2266	trace_array_put(tr);
2267	return ret;
2268	}
2269
2270	static int
2271	ftrace_event_set_pid_open(struct inode *inode, struct file *file)
2272	{
2273	const struct seq_operations *seq_ops = &show_set_pid_seq_ops;
2274	struct trace_array *tr = inode->i_private;
2275	int ret;
2276
2277	ret = tracing_check_open_get_tr(tr);
2278	if (ret)
2279	return ret;
2280
2281	if ((file->f_mode & FMODE_WRITE) &&
2282	(file->f_flags & O_TRUNC))
2283	ftrace_clear_event_pids(tr, type: TRACE_PIDS);
2284
2285	ret = ftrace_event_open(inode, file, seq_ops);
2286	if (ret < 0)
2287	trace_array_put(tr);
2288	return ret;
2289	}
2290
2291	static int
2292	ftrace_event_set_npid_open(struct inode *inode, struct file *file)
2293	{
2294	const struct seq_operations *seq_ops = &show_set_no_pid_seq_ops;
2295	struct trace_array *tr = inode->i_private;
2296	int ret;
2297
2298	ret = tracing_check_open_get_tr(tr);
2299	if (ret)
2300	return ret;
2301
2302	if ((file->f_mode & FMODE_WRITE) &&
2303	(file->f_flags & O_TRUNC))
2304	ftrace_clear_event_pids(tr, type: TRACE_NO_PIDS);
2305
2306	ret = ftrace_event_open(inode, file, seq_ops);
2307	if (ret < 0)
2308	trace_array_put(tr);
2309	return ret;
2310	}
2311
2312	static struct event_subsystem *
2313	create_new_subsystem(const char *name)
2314	{
2315	struct event_subsystem *system;
2316
2317	/* need to create new entry */
2318	system = kmalloc(size: sizeof(*system), GFP_KERNEL);
2319	if (!system)
2320	return NULL;
2321
2322	system->ref_count = 1;
2323
2324	/* Only allocate if dynamic (kprobes and modules) */
2325	system->name = kstrdup_const(s: name, GFP_KERNEL);
2326	if (!system->name)
2327	goto out_free;
2328
2329	system->filter = kzalloc(size: sizeof(struct event_filter), GFP_KERNEL);
2330	if (!system->filter)
2331	goto out_free;
2332
2333	list_add(new: &system->list, head: &event_subsystems);
2334
2335	return system;
2336
2337	out_free:
2338	kfree_const(x: system->name);
2339	kfree(objp: system);
2340	return NULL;
2341	}
2342
2343	static int system_callback(const char *name, umode_t *mode, void **data,
2344	const struct file_operations **fops)
2345	{
2346	if (strcmp(name, "filter") == 0)
2347	*fops = &ftrace_subsystem_filter_fops;
2348
2349	else if (strcmp(name, "enable") == 0)
2350	*fops = &ftrace_system_enable_fops;
2351
2352	else
2353	return 0;
2354
2355	*mode = TRACE_MODE_WRITE;
2356	return 1;
2357	}
2358
2359	static struct eventfs_inode *
2360	event_subsystem_dir(struct trace_array *tr, const char *name,
2361	struct trace_event_file *file, struct eventfs_inode *parent)
2362	{
2363	struct event_subsystem *system, *iter;
2364	struct trace_subsystem_dir *dir;
2365	struct eventfs_inode *ei;
2366	int nr_entries;
2367	static struct eventfs_entry system_entries[] = {
2368	{
2369	.name = "filter",
2370	.callback = system_callback,
2371	},
2372	{
2373	.name = "enable",
2374	.callback = system_callback,
2375	}
2376	};
2377
2378	/* First see if we did not already create this dir */
2379	list_for_each_entry(dir, &tr->systems, list) {
2380	system = dir->subsystem;
2381	if (strcmp(system->name, name) == 0) {
2382	dir->nr_events++;
2383	file->system = dir;
2384	return dir->ei;
2385	}
2386	}
2387
2388	/* Now see if the system itself exists. */
2389	system = NULL;
2390	list_for_each_entry(iter, &event_subsystems, list) {
2391	if (strcmp(iter->name, name) == 0) {
2392	system = iter;
2393	break;
2394	}
2395	}
2396
2397	dir = kmalloc(size: sizeof(*dir), GFP_KERNEL);
2398	if (!dir)
2399	goto out_fail;
2400
2401	if (!system) {
2402	system = create_new_subsystem(name);
2403	if (!system)
2404	goto out_free;
2405	} else
2406	__get_system(system);
2407
2408	/* ftrace only has directories no files */
2409	if (strcmp(name, "ftrace") == 0)
2410	nr_entries = 0;
2411	else
2412	nr_entries = ARRAY_SIZE(system_entries);
2413
2414	ei = eventfs_create_dir(name, parent, entries: system_entries, size: nr_entries, data: dir);
2415	if (IS_ERR(ptr: ei)) {
2416	pr_warn("Failed to create system directory %s\n", name);
2417	__put_system(system);
2418	goto out_free;
2419	}
2420
2421	dir->ei = ei;
2422	dir->tr = tr;
2423	dir->ref_count = 1;
2424	dir->nr_events = 1;
2425	dir->subsystem = system;
2426	file->system = dir;
2427
2428	list_add(new: &dir->list, head: &tr->systems);
2429
2430	return dir->ei;
2431
2432	out_free:
2433	kfree(objp: dir);
2434	out_fail:
2435	/* Only print this message if failed on memory allocation */
2436	if (!dir || !system)
2437	pr_warn("No memory to create event subsystem %s\n", name);
2438	return NULL;
2439	}
2440
2441	static int
2442	event_define_fields(struct trace_event_call *call)
2443	{
2444	struct list_head *head;
2445	int ret = 0;
2446
2447	/*
2448	* Other events may have the same class. Only update
2449	* the fields if they are not already defined.
2450	*/
2451	head = trace_get_fields(event_call: call);
2452	if (list_empty(head)) {
2453	struct trace_event_fields *field = call->class->fields_array;
2454	unsigned int offset = sizeof(struct trace_entry);
2455
2456	for (; field->type; field++) {
2457	if (field->type == TRACE_FUNCTION_TYPE) {
2458	field->define_fields(call);
2459	break;
2460	}
2461
2462	offset = ALIGN(offset, field->align);
2463	ret = trace_define_field_ext(call, type: field->type, name: field->name,
2464	offset, size: field->size,
2465	is_signed: field->is_signed, filter_type: field->filter_type,
2466	len: field->len);
2467	if (WARN_ON_ONCE(ret)) {
2468	pr_err("error code is %d\n", ret);
2469	break;
2470	}
2471
2472	offset += field->size;
2473	}
2474	}
2475
2476	return ret;
2477	}
2478
2479	static int event_callback(const char *name, umode_t *mode, void **data,
2480	const struct file_operations **fops)
2481	{
2482	struct trace_event_file *file = *data;
2483	struct trace_event_call *call = file->event_call;
2484
2485	if (strcmp(name, "format") == 0) {
2486	*mode = TRACE_MODE_READ;
2487	*fops = &ftrace_event_format_fops;
2488	*data = call;
2489	return 1;
2490	}
2491
2492	/*
2493	* Only event directories that can be enabled should have
2494	* triggers or filters, with the exception of the "print"
2495	* event that can have a "trigger" file.
2496	*/
2497	if (!(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)) {
2498	if (call->class->reg && strcmp(name, "enable") == 0) {
2499	*mode = TRACE_MODE_WRITE;
2500	*fops = &ftrace_enable_fops;
2501	return 1;
2502	}
2503
2504	if (strcmp(name, "filter") == 0) {
2505	*mode = TRACE_MODE_WRITE;
2506	*fops = &ftrace_event_filter_fops;
2507	return 1;
2508	}
2509	}
2510
2511	if (!(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE) ||
2512	strcmp(trace_event_name(call), "print") == 0) {
2513	if (strcmp(name, "trigger") == 0) {
2514	*mode = TRACE_MODE_WRITE;
2515	*fops = &event_trigger_fops;
2516	return 1;
2517	}
2518	}
2519
2520	#ifdef CONFIG_PERF_EVENTS
2521	if (call->event.type && call->class->reg &&
2522	strcmp(name, "id") == 0) {
2523	*mode = TRACE_MODE_READ;
2524	*data = (void *)(long)call->event.type;
2525	*fops = &ftrace_event_id_fops;
2526	return 1;
2527	}
2528	#endif
2529
2530	#ifdef CONFIG_HIST_TRIGGERS
2531	if (strcmp(name, "hist") == 0) {
2532	*mode = TRACE_MODE_READ;
2533	*fops = &event_hist_fops;
2534	return 1;
2535	}
2536	#endif
2537	#ifdef CONFIG_HIST_TRIGGERS_DEBUG
2538	if (strcmp(name, "hist_debug") == 0) {
2539	*mode = TRACE_MODE_READ;
2540	*fops = &event_hist_debug_fops;
2541	return 1;
2542	}
2543	#endif
2544	#ifdef CONFIG_TRACE_EVENT_INJECT
2545	if (call->event.type && call->class->reg &&
2546	strcmp(name, "inject") == 0) {
2547	*mode = 0200;
2548	*fops = &event_inject_fops;
2549	return 1;
2550	}
2551	#endif
2552	return 0;
2553	}
2554
2555	static int
2556	event_create_dir(struct eventfs_inode *parent, struct trace_event_file *file)
2557	{
2558	struct trace_event_call *call = file->event_call;
2559	struct trace_array *tr = file->tr;
2560	struct eventfs_inode *e_events;
2561	struct eventfs_inode *ei;
2562	const char *name;
2563	int nr_entries;
2564	int ret;
2565	static struct eventfs_entry event_entries[] = {
2566	{
2567	.name = "enable",
2568	.callback = event_callback,
2569	},
2570	{
2571	.name = "filter",
2572	.callback = event_callback,
2573	},
2574	{
2575	.name = "trigger",
2576	.callback = event_callback,
2577	},
2578	{
2579	.name = "format",
2580	.callback = event_callback,
2581	},
2582	#ifdef CONFIG_PERF_EVENTS
2583	{
2584	.name = "id",
2585	.callback = event_callback,
2586	},
2587	#endif
2588	#ifdef CONFIG_HIST_TRIGGERS
2589	{
2590	.name = "hist",
2591	.callback = event_callback,
2592	},
2593	#endif
2594	#ifdef CONFIG_HIST_TRIGGERS_DEBUG
2595	{
2596	.name = "hist_debug",
2597	.callback = event_callback,
2598	},
2599	#endif
2600	#ifdef CONFIG_TRACE_EVENT_INJECT
2601	{
2602	.name = "inject",
2603	.callback = event_callback,
2604	},
2605	#endif
2606	};
2607
2608	/*
2609	* If the trace point header did not define TRACE_SYSTEM
2610	* then the system would be called "TRACE_SYSTEM". This should
2611	* never happen.
2612	*/
2613	if (WARN_ON_ONCE(strcmp(call->class->system, TRACE_SYSTEM) == 0))
2614	return -ENODEV;
2615
2616	e_events = event_subsystem_dir(tr, name: call->class->system, file, parent);
2617	if (!e_events)
2618	return -ENOMEM;
2619
2620	nr_entries = ARRAY_SIZE(event_entries);
2621
2622	name = trace_event_name(call);
2623	ei = eventfs_create_dir(name, parent: e_events, entries: event_entries, size: nr_entries, data: file);
2624	if (IS_ERR(ptr: ei)) {
2625	pr_warn("Could not create tracefs '%s' directory\n", name);
2626	return -1;
2627	}
2628
2629	file->ei = ei;
2630
2631	ret = event_define_fields(call);
2632	if (ret < 0) {
2633	pr_warn("Could not initialize trace point events/%s\n", name);
2634	return ret;
2635	}
2636
2637	return 0;
2638	}
2639
2640	static void remove_event_from_tracers(struct trace_event_call *call)
2641	{
2642	struct trace_event_file *file;
2643	struct trace_array *tr;
2644
2645	do_for_each_event_file_safe(tr, file) {
2646	if (file->event_call != call)
2647	continue;
2648
2649	remove_event_file_dir(file);
2650	/*
2651	* The do_for_each_event_file_safe() is
2652	* a double loop. After finding the call for this
2653	* trace_array, we use break to jump to the next
2654	* trace_array.
2655	*/
2656	break;
2657	} while_for_each_event_file();
2658	}
2659
2660	static void event_remove(struct trace_event_call *call)
2661	{
2662	struct trace_array *tr;
2663	struct trace_event_file *file;
2664
2665	do_for_each_event_file(tr, file) {
2666	if (file->event_call != call)
2667	continue;
2668
2669	if (file->flags & EVENT_FILE_FL_WAS_ENABLED)
2670	tr->clear_trace = true;
2671
2672	ftrace_event_enable_disable(file, enable: 0);
2673	/*
2674	* The do_for_each_event_file() is
2675	* a double loop. After finding the call for this
2676	* trace_array, we use break to jump to the next
2677	* trace_array.
2678	*/
2679	break;
2680	} while_for_each_event_file();
2681
2682	if (call->event.funcs)
2683	__unregister_trace_event(event: &call->event);
2684	remove_event_from_tracers(call);
2685	list_del(entry: &call->list);
2686	}
2687
2688	static int event_init(struct trace_event_call *call)
2689	{
2690	int ret = 0;
2691	const char *name;
2692
2693	name = trace_event_name(call);
2694	if (WARN_ON(!name))
2695	return -EINVAL;
2696
2697	if (call->class->raw_init) {
2698	ret = call->class->raw_init(call);
2699	if (ret < 0 && ret != -ENOSYS)
2700	pr_warn("Could not initialize trace events/%s\n", name);
2701	}
2702
2703	return ret;
2704	}
2705
2706	static int
2707	__register_event(struct trace_event_call *call, struct module *mod)
2708	{
2709	int ret;
2710
2711	ret = event_init(call);
2712	if (ret < 0)
2713	return ret;
2714
2715	list_add(new: &call->list, head: &ftrace_events);
2716	if (call->flags & TRACE_EVENT_FL_DYNAMIC)
2717	atomic_set(v: &call->refcnt, i: 0);
2718	else
2719	call->module = mod;
2720
2721	return 0;
2722	}
2723
2724	static char *eval_replace(char *ptr, struct trace_eval_map *map, int len)
2725	{
2726	int rlen;
2727	int elen;
2728
2729	/* Find the length of the eval value as a string */
2730	elen = snprintf(buf: ptr, size: 0, fmt: "%ld", map->eval_value);
2731	/* Make sure there's enough room to replace the string with the value */
2732	if (len < elen)
2733	return NULL;
2734
2735	snprintf(buf: ptr, size: elen + 1, fmt: "%ld", map->eval_value);
2736
2737	/* Get the rest of the string of ptr */
2738	rlen = strlen(ptr + len);
2739	memmove(ptr + elen, ptr + len, rlen);
2740	/* Make sure we end the new string */
2741	ptr[elen + rlen] = 0;
2742
2743	return ptr + elen;
2744	}
2745
2746	static void update_event_printk(struct trace_event_call *call,
2747	struct trace_eval_map *map)
2748	{
2749	char *ptr;
2750	int quote = 0;
2751	int len = strlen(map->eval_string);
2752
2753	for (ptr = call->print_fmt; *ptr; ptr++) {
2754	if (*ptr == '\\') {
2755	ptr++;
2756	/* paranoid */
2757	if (!*ptr)
2758	break;
2759	continue;
2760	}
2761	if (*ptr == '"') {
2762	quote ^= 1;
2763	continue;
2764	}
2765	if (quote)
2766	continue;
2767	if (isdigit(c: *ptr)) {
2768	/* skip numbers */
2769	do {
2770	ptr++;
2771	/* Check for alpha chars like ULL */
2772	} while (isalnum(*ptr));
2773	if (!*ptr)
2774	break;
2775	/*
2776	* A number must have some kind of delimiter after
2777	* it, and we can ignore that too.
2778	*/
2779	continue;
2780	}
2781	if (isalpha(*ptr) || *ptr == '_') {
2782	if (strncmp(map->eval_string, ptr, len) == 0 &&
2783	!isalnum(ptr[len]) && ptr[len] != '_') {
2784	ptr = eval_replace(ptr, map, len);
2785	/* enum/sizeof string smaller than value */
2786	if (WARN_ON_ONCE(!ptr))
2787	return;
2788	/*
2789	* No need to decrement here, as eval_replace()
2790	* returns the pointer to the character passed
2791	* the eval, and two evals can not be placed
2792	* back to back without something in between.
2793	* We can skip that something in between.
2794	*/
2795	continue;
2796	}
2797	skip_more:
2798	do {
2799	ptr++;
2800	} while (isalnum(*ptr) || *ptr == '_');
2801	if (!*ptr)
2802	break;
2803	/*
2804	* If what comes after this variable is a '.' or
2805	* '->' then we can continue to ignore that string.
2806	*/
2807	if (*ptr == '.' || (ptr[0] == '-' && ptr[1] == '>')) {
2808	ptr += *ptr == '.' ? 1 : 2;
2809	if (!*ptr)
2810	break;
2811	goto skip_more;
2812	}
2813	/*
2814	* Once again, we can skip the delimiter that came
2815	* after the string.
2816	*/
2817	continue;
2818	}
2819	}
2820	}
2821
2822	static void add_str_to_module(struct module *module, char *str)
2823	{
2824	struct module_string *modstr;
2825
2826	modstr = kmalloc(size: sizeof(*modstr), GFP_KERNEL);
2827
2828	/*
2829	* If we failed to allocate memory here, then we'll just
2830	* let the str memory leak when the module is removed.
2831	* If this fails to allocate, there's worse problems than
2832	* a leaked string on module removal.
2833	*/
2834	if (WARN_ON_ONCE(!modstr))
2835	return;
2836
2837	modstr->module = module;
2838	modstr->str = str;
2839
2840	list_add(new: &modstr->next, head: &module_strings);
2841	}
2842
2843	static void update_event_fields(struct trace_event_call *call,
2844	struct trace_eval_map *map)
2845	{
2846	struct ftrace_event_field *field;
2847	struct list_head *head;
2848	char *ptr;
2849	char *str;
2850	int len = strlen(map->eval_string);
2851
2852	/* Dynamic events should never have field maps */
2853	if (WARN_ON_ONCE(call->flags & TRACE_EVENT_FL_DYNAMIC))
2854	return;
2855
2856	head = trace_get_fields(event_call: call);
2857	list_for_each_entry(field, head, link) {
2858	ptr = strchr(field->type, '[');
2859	if (!ptr)
2860	continue;
2861	ptr++;
2862
2863	if (!isalpha(*ptr) && *ptr != '_')
2864	continue;
2865
2866	if (strncmp(map->eval_string, ptr, len) != 0)
2867	continue;
2868
2869	str = kstrdup(s: field->type, GFP_KERNEL);
2870	if (WARN_ON_ONCE(!str))
2871	return;
2872	ptr = str + (ptr - field->type);
2873	ptr = eval_replace(ptr, map, len);
2874	/* enum/sizeof string smaller than value */
2875	if (WARN_ON_ONCE(!ptr)) {
2876	kfree(objp: str);
2877	continue;
2878	}
2879
2880	/*
2881	* If the event is part of a module, then we need to free the string
2882	* when the module is removed. Otherwise, it will stay allocated
2883	* until a reboot.
2884	*/
2885	if (call->module)
2886	add_str_to_module(module: call->module, str);
2887
2888	field->type = str;
2889	}
2890	}
2891
2892	void trace_event_eval_update(struct trace_eval_map **map, int len)
2893	{
2894	struct trace_event_call *call, *p;
2895	const char *last_system = NULL;
2896	bool first = false;
2897	int last_i;
2898	int i;
2899
2900	down_write(sem: &trace_event_sem);
2901	list_for_each_entry_safe(call, p, &ftrace_events, list) {
2902	/* events are usually grouped together with systems */
2903	if (!last_system || call->class->system != last_system) {
2904	first = true;
2905	last_i = 0;
2906	last_system = call->class->system;
2907	}
2908
2909	/*
2910	* Since calls are grouped by systems, the likelihood that the
2911	* next call in the iteration belongs to the same system as the
2912	* previous call is high. As an optimization, we skip searching
2913	* for a map[] that matches the call's system if the last call
2914	* was from the same system. That's what last_i is for. If the
2915	* call has the same system as the previous call, then last_i
2916	* will be the index of the first map[] that has a matching
2917	* system.
2918	*/
2919	for (i = last_i; i < len; i++) {
2920	if (call->class->system == map[i]->system) {
2921	/* Save the first system if need be */
2922	if (first) {
2923	last_i = i;
2924	first = false;
2925	}
2926	update_event_printk(call, map: map[i]);
2927	update_event_fields(call, map: map[i]);
2928	}
2929	}
2930	cond_resched();
2931	}
2932	up_write(sem: &trace_event_sem);
2933	}
2934
2935	static bool event_in_systems(struct trace_event_call *call,
2936	const char *systems)
2937	{
2938	const char *system;
2939	const char *p;
2940
2941	if (!systems)
2942	return true;
2943
2944	system = call->class->system;
2945	p = strstr(systems, system);
2946	if (!p)
2947	return false;
2948
2949	if (p != systems && !isspace(*(p - 1)) && *(p - 1) != ',')
2950	return false;
2951
2952	p += strlen(system);
2953	return !*p || isspace(*p) || *p == ',';
2954	}
2955
2956	static struct trace_event_file *
2957	trace_create_new_event(struct trace_event_call *call,
2958	struct trace_array *tr)
2959	{
2960	struct trace_pid_list *no_pid_list;
2961	struct trace_pid_list *pid_list;
2962	struct trace_event_file *file;
2963	unsigned int first;
2964
2965	if (!event_in_systems(call, systems: tr->system_names))
2966	return NULL;
2967
2968	file = kmem_cache_alloc(cachep: file_cachep, GFP_TRACE);
2969	if (!file)
2970	return ERR_PTR(error: -ENOMEM);
2971
2972	pid_list = rcu_dereference_protected(tr->filtered_pids,
2973	lockdep_is_held(&event_mutex));
2974	no_pid_list = rcu_dereference_protected(tr->filtered_no_pids,
2975	lockdep_is_held(&event_mutex));
2976
2977	if (!trace_pid_list_first(pid_list, pid: &first) ||
2978	!trace_pid_list_first(pid_list: no_pid_list, pid: &first))
2979	file->flags |= EVENT_FILE_FL_PID_FILTER;
2980
2981	file->event_call = call;
2982	file->tr = tr;
2983	atomic_set(v: &file->sm_ref, i: 0);
2984	atomic_set(v: &file->tm_ref, i: 0);
2985	INIT_LIST_HEAD(list: &file->triggers);
2986	list_add(new: &file->list, head: &tr->events);
2987	event_file_get(file);
2988
2989	return file;
2990	}
2991
2992	#define MAX_BOOT_TRIGGERS 32
2993
2994	static struct boot_triggers {
2995	const char *event;
2996	char *trigger;
2997	} bootup_triggers[MAX_BOOT_TRIGGERS];
2998
2999	static char bootup_trigger_buf[COMMAND_LINE_SIZE];
3000	static int nr_boot_triggers;
3001
3002	static __init int setup_trace_triggers(char *str)
3003	{
3004	char *trigger;
3005	char *buf;
3006	int i;
3007
3008	strscpy(bootup_trigger_buf, str, COMMAND_LINE_SIZE);
3009	trace_set_ring_buffer_expanded(NULL);
3010	disable_tracing_selftest(reason: "running event triggers");
3011
3012	buf = bootup_trigger_buf;
3013	for (i = 0; i < MAX_BOOT_TRIGGERS; i++) {
3014	trigger = strsep(&buf, ",");
3015	if (!trigger)
3016	break;
3017	bootup_triggers[i].event = strsep(&trigger, ".");
3018	bootup_triggers[i].trigger = trigger;
3019	if (!bootup_triggers[i].trigger)
3020	break;
3021	}
3022
3023	nr_boot_triggers = i;
3024	return 1;
3025	}
3026	__setup("trace_trigger=", setup_trace_triggers);
3027
3028	/* Add an event to a trace directory */
3029	static int
3030	__trace_add_new_event(struct trace_event_call *call, struct trace_array *tr)
3031	{
3032	struct trace_event_file *file;
3033
3034	file = trace_create_new_event(call, tr);
3035	/*
3036	* trace_create_new_event() returns ERR_PTR(-ENOMEM) if failed
3037	* allocation, or NULL if the event is not part of the tr->system_names.
3038	* When the event is not part of the tr->system_names, return zero, not
3039	* an error.
3040	*/
3041	if (!file)
3042	return 0;
3043
3044	if (IS_ERR(ptr: file))
3045	return PTR_ERR(ptr: file);
3046
3047	if (eventdir_initialized)
3048	return event_create_dir(parent: tr->event_dir, file);
3049	else
3050	return event_define_fields(call);
3051	}
3052
3053	static void trace_early_triggers(struct trace_event_file *file, const char *name)
3054	{
3055	int ret;
3056	int i;
3057
3058	for (i = 0; i < nr_boot_triggers; i++) {
3059	if (strcmp(name, bootup_triggers[i].event))
3060	continue;
3061	mutex_lock(&event_mutex);
3062	ret = trigger_process_regex(file, buff: bootup_triggers[i].trigger);
3063	mutex_unlock(lock: &event_mutex);
3064	if (ret)
3065	pr_err("Failed to register trigger '%s' on event %s\n",
3066	bootup_triggers[i].trigger,
3067	bootup_triggers[i].event);
3068	}
3069	}
3070
3071	/*
3072	* Just create a descriptor for early init. A descriptor is required
3073	* for enabling events at boot. We want to enable events before
3074	* the filesystem is initialized.
3075	*/
3076	static int
3077	__trace_early_add_new_event(struct trace_event_call *call,
3078	struct trace_array *tr)
3079	{
3080	struct trace_event_file *file;
3081	int ret;
3082
3083	file = trace_create_new_event(call, tr);
3084	/*
3085	* trace_create_new_event() returns ERR_PTR(-ENOMEM) if failed
3086	* allocation, or NULL if the event is not part of the tr->system_names.
3087	* When the event is not part of the tr->system_names, return zero, not
3088	* an error.
3089	*/
3090	if (!file)
3091	return 0;
3092
3093	if (IS_ERR(ptr: file))
3094	return PTR_ERR(ptr: file);
3095
3096	ret = event_define_fields(call);
3097	if (ret)
3098	return ret;
3099
3100	trace_early_triggers(file, name: trace_event_name(call));
3101
3102	return 0;
3103	}
3104
3105	struct ftrace_module_file_ops;
3106	static void __add_event_to_tracers(struct trace_event_call *call);
3107
3108	/* Add an additional event_call dynamically */
3109	int trace_add_event_call(struct trace_event_call *call)
3110	{
3111	int ret;
3112	lockdep_assert_held(&event_mutex);
3113
3114	mutex_lock(&trace_types_lock);
3115
3116	ret = __register_event(call, NULL);
3117	if (ret >= 0)
3118	__add_event_to_tracers(call);
3119
3120	mutex_unlock(lock: &trace_types_lock);
3121	return ret;
3122	}
3123	EXPORT_SYMBOL_GPL(trace_add_event_call);
3124
3125	/*
3126	* Must be called under locking of trace_types_lock, event_mutex and
3127	* trace_event_sem.
3128	*/
3129	static void __trace_remove_event_call(struct trace_event_call *call)
3130	{
3131	event_remove(call);
3132	trace_destroy_fields(call);
3133	free_event_filter(filter: call->filter);
3134	call->filter = NULL;
3135	}
3136
3137	static int probe_remove_event_call(struct trace_event_call *call)
3138	{
3139	struct trace_array *tr;
3140	struct trace_event_file *file;
3141
3142	#ifdef CONFIG_PERF_EVENTS
3143	if (call->perf_refcount)
3144	return -EBUSY;
3145	#endif
3146	do_for_each_event_file(tr, file) {
3147	if (file->event_call != call)
3148	continue;
3149	/*
3150	* We can't rely on ftrace_event_enable_disable(enable => 0)
3151	* we are going to do, EVENT_FILE_FL_SOFT_MODE can suppress
3152	* TRACE_REG_UNREGISTER.
3153	*/
3154	if (file->flags & EVENT_FILE_FL_ENABLED)
3155	goto busy;
3156
3157	if (file->flags & EVENT_FILE_FL_WAS_ENABLED)
3158	tr->clear_trace = true;
3159	/*
3160	* The do_for_each_event_file_safe() is
3161	* a double loop. After finding the call for this
3162	* trace_array, we use break to jump to the next
3163	* trace_array.
3164	*/
3165	break;
3166	} while_for_each_event_file();
3167
3168	__trace_remove_event_call(call);
3169
3170	return 0;
3171	busy:
3172	/* No need to clear the trace now */
3173	list_for_each_entry(tr, &ftrace_trace_arrays, list) {
3174	tr->clear_trace = false;
3175	}
3176	return -EBUSY;
3177	}
3178
3179	/* Remove an event_call */
3180	int trace_remove_event_call(struct trace_event_call *call)
3181	{
3182	int ret;
3183
3184	lockdep_assert_held(&event_mutex);
3185
3186	mutex_lock(&trace_types_lock);
3187	down_write(sem: &trace_event_sem);
3188	ret = probe_remove_event_call(call);
3189	up_write(sem: &trace_event_sem);
3190	mutex_unlock(lock: &trace_types_lock);
3191
3192	return ret;
3193	}
3194	EXPORT_SYMBOL_GPL(trace_remove_event_call);
3195
3196	#define for_each_event(event, start, end) \
3197	for (event = start; \
3198	(unsigned long)event < (unsigned long)end; \
3199	event++)
3200
3201	#ifdef CONFIG_MODULES
3202
3203	static void trace_module_add_events(struct module *mod)
3204	{
3205	struct trace_event_call **call, **start, **end;
3206
3207	if (!mod->num_trace_events)
3208	return;
3209
3210	/* Don't add infrastructure for mods without tracepoints */
3211	if (trace_module_has_bad_taint(mod)) {
3212	pr_err("%s: module has bad taint, not creating trace events\n",
3213	mod->name);
3214	return;
3215	}
3216
3217	start = mod->trace_events;
3218	end = mod->trace_events + mod->num_trace_events;
3219
3220	for_each_event(call, start, end) {
3221	__register_event(call: *call, mod);
3222	__add_event_to_tracers(call: *call);
3223	}
3224	}
3225
3226	static void trace_module_remove_events(struct module *mod)
3227	{
3228	struct trace_event_call *call, *p;
3229	struct module_string *modstr, *m;
3230
3231	down_write(sem: &trace_event_sem);
3232	list_for_each_entry_safe(call, p, &ftrace_events, list) {
3233	if ((call->flags & TRACE_EVENT_FL_DYNAMIC) || !call->module)
3234	continue;
3235	if (call->module == mod)
3236	__trace_remove_event_call(call);
3237	}
3238	/* Check for any strings allocade for this module */
3239	list_for_each_entry_safe(modstr, m, &module_strings, next) {
3240	if (modstr->module != mod)
3241	continue;
3242	list_del(entry: &modstr->next);
3243	kfree(objp: modstr->str);
3244	kfree(objp: modstr);
3245	}
3246	up_write(sem: &trace_event_sem);
3247
3248	/*
3249	* It is safest to reset the ring buffer if the module being unloaded
3250	* registered any events that were used. The only worry is if
3251	* a new module gets loaded, and takes on the same id as the events
3252	* of this module. When printing out the buffer, traced events left
3253	* over from this module may be passed to the new module events and
3254	* unexpected results may occur.
3255	*/
3256	tracing_reset_all_online_cpus_unlocked();
3257	}
3258
3259	static int trace_module_notify(struct notifier_block *self,
3260	unsigned long val, void *data)
3261	{
3262	struct module *mod = data;
3263
3264	mutex_lock(&event_mutex);
3265	mutex_lock(&trace_types_lock);
3266	switch (val) {
3267	case MODULE_STATE_COMING:
3268	trace_module_add_events(mod);
3269	break;
3270	case MODULE_STATE_GOING:
3271	trace_module_remove_events(mod);
3272	break;
3273	}
3274	mutex_unlock(lock: &trace_types_lock);
3275	mutex_unlock(lock: &event_mutex);
3276
3277	return NOTIFY_OK;
3278	}
3279
3280	static struct notifier_block trace_module_nb = {
3281	.notifier_call = trace_module_notify,
3282	.priority = 1, /* higher than trace.c module notify */
3283	};
3284	#endif /* CONFIG_MODULES */
3285
3286	/* Create a new event directory structure for a trace directory. */
3287	static void
3288	__trace_add_event_dirs(struct trace_array *tr)
3289	{
3290	struct trace_event_call *call;
3291	int ret;
3292
3293	list_for_each_entry(call, &ftrace_events, list) {
3294	ret = __trace_add_new_event(call, tr);
3295	if (ret < 0)
3296	pr_warn("Could not create directory for event %s\n",
3297	trace_event_name(call));
3298	}
3299	}
3300
3301	/* Returns any file that matches the system and event */
3302	struct trace_event_file *
3303	__find_event_file(struct trace_array *tr, const char *system, const char *event)
3304	{
3305	struct trace_event_file *file;
3306	struct trace_event_call *call;
3307	const char *name;
3308
3309	list_for_each_entry(file, &tr->events, list) {
3310
3311	call = file->event_call;
3312	name = trace_event_name(call);
3313
3314	if (!name || !call->class)
3315	continue;
3316
3317	if (strcmp(event, name) == 0 &&
3318	strcmp(system, call->class->system) == 0)
3319	return file;
3320	}
3321	return NULL;
3322	}
3323
3324	/* Returns valid trace event files that match system and event */
3325	struct trace_event_file *
3326	find_event_file(struct trace_array *tr, const char *system, const char *event)
3327	{
3328	struct trace_event_file *file;
3329
3330	file = __find_event_file(tr, system, event);
3331	if (!file || !file->event_call->class->reg ||
3332	file->event_call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)
3333	return NULL;
3334
3335	return file;
3336	}
3337
3338	/**
3339	* trace_get_event_file - Find and return a trace event file
3340	* @instance: The name of the trace instance containing the event
3341	* @system: The name of the system containing the event
3342	* @event: The name of the event
3343	*
3344	* Return a trace event file given the trace instance name, trace
3345	* system, and trace event name. If the instance name is NULL, it
3346	* refers to the top-level trace array.
3347	*
3348	* This function will look it up and return it if found, after calling
3349	* trace_array_get() to prevent the instance from going away, and
3350	* increment the event's module refcount to prevent it from being
3351	* removed.
3352	*
3353	* To release the file, call trace_put_event_file(), which will call
3354	* trace_array_put() and decrement the event's module refcount.
3355	*
3356	* Return: The trace event on success, ERR_PTR otherwise.
3357	*/
3358	struct trace_event_file *trace_get_event_file(const char *instance,
3359	const char *system,
3360	const char *event)
3361	{
3362	struct trace_array *tr = top_trace_array();
3363	struct trace_event_file *file = NULL;
3364	int ret = -EINVAL;
3365
3366	if (instance) {
3367	tr = trace_array_find_get(instance);
3368	if (!tr)
3369	return ERR_PTR(error: -ENOENT);
3370	} else {
3371	ret = trace_array_get(tr);
3372	if (ret)
3373	return ERR_PTR(error: ret);
3374	}
3375
3376	mutex_lock(&event_mutex);
3377
3378	file = find_event_file(tr, system, event);
3379	if (!file) {
3380	trace_array_put(tr);
3381	ret = -EINVAL;
3382	goto out;
3383	}
3384
3385	/* Don't let event modules unload while in use */
3386	ret = trace_event_try_get_ref(call: file->event_call);
3387	if (!ret) {
3388	trace_array_put(tr);
3389	ret = -EBUSY;
3390	goto out;
3391	}
3392
3393	ret = 0;
3394	out:
3395	mutex_unlock(lock: &event_mutex);
3396
3397	if (ret)
3398	file = ERR_PTR(error: ret);
3399
3400	return file;
3401	}
3402	EXPORT_SYMBOL_GPL(trace_get_event_file);
3403
3404	/**
3405	* trace_put_event_file - Release a file from trace_get_event_file()
3406	* @file: The trace event file
3407	*
3408	* If a file was retrieved using trace_get_event_file(), this should
3409	* be called when it's no longer needed. It will cancel the previous
3410	* trace_array_get() called by that function, and decrement the
3411	* event's module refcount.
3412	*/
3413	void trace_put_event_file(struct trace_event_file *file)
3414	{
3415	mutex_lock(&event_mutex);
3416	trace_event_put_ref(call: file->event_call);
3417	mutex_unlock(lock: &event_mutex);
3418
3419	trace_array_put(tr: file->tr);
3420	}
3421	EXPORT_SYMBOL_GPL(trace_put_event_file);
3422
3423	#ifdef CONFIG_DYNAMIC_FTRACE
3424
3425	/* Avoid typos */
3426	#define ENABLE_EVENT_STR "enable_event"
3427	#define DISABLE_EVENT_STR "disable_event"
3428
3429	struct event_probe_data {
3430	struct trace_event_file *file;
3431	unsigned long count;
3432	int ref;
3433	bool enable;
3434	};
3435
3436	static void update_event_probe(struct event_probe_data *data)
3437	{
3438	if (data->enable)
3439	clear_bit(nr: EVENT_FILE_FL_SOFT_DISABLED_BIT, addr: &data->file->flags);
3440	else
3441	set_bit(nr: EVENT_FILE_FL_SOFT_DISABLED_BIT, addr: &data->file->flags);
3442	}
3443
3444	static void
3445	event_enable_probe(unsigned long ip, unsigned long parent_ip,
3446	struct trace_array *tr, struct ftrace_probe_ops *ops,
3447	void *data)
3448	{
3449	struct ftrace_func_mapper *mapper = data;
3450	struct event_probe_data *edata;
3451	void **pdata;
3452
3453	pdata = ftrace_func_mapper_find_ip(mapper, ip);
3454	if (!pdata || !*pdata)
3455	return;
3456
3457	edata = *pdata;
3458	update_event_probe(data: edata);
3459	}
3460
3461	static void
3462	event_enable_count_probe(unsigned long ip, unsigned long parent_ip,
3463	struct trace_array *tr, struct ftrace_probe_ops *ops,
3464	void *data)
3465	{
3466	struct ftrace_func_mapper *mapper = data;
3467	struct event_probe_data *edata;
3468	void **pdata;
3469
3470	pdata = ftrace_func_mapper_find_ip(mapper, ip);
3471	if (!pdata || !*pdata)
3472	return;
3473
3474	edata = *pdata;
3475
3476	if (!edata->count)
3477	return;
3478
3479	/* Skip if the event is in a state we want to switch to */
3480	if (edata->enable == !(edata->file->flags & EVENT_FILE_FL_SOFT_DISABLED))
3481	return;
3482
3483	if (edata->count != -1)
3484	(edata->count)--;
3485
3486	update_event_probe(data: edata);
3487	}
3488
3489	static int
3490	event_enable_print(struct seq_file *m, unsigned long ip,
3491	struct ftrace_probe_ops *ops, void *data)
3492	{
3493	struct ftrace_func_mapper *mapper = data;
3494	struct event_probe_data *edata;
3495	void **pdata;
3496
3497	pdata = ftrace_func_mapper_find_ip(mapper, ip);
3498
3499	if (WARN_ON_ONCE(!pdata || !*pdata))
3500	return 0;
3501
3502	edata = *pdata;
3503
3504	seq_printf(m, fmt: "%ps:", (void *)ip);
3505
3506	seq_printf(m, fmt: "%s:%s:%s",
3507	edata->enable ? ENABLE_EVENT_STR : DISABLE_EVENT_STR,
3508	edata->file->event_call->class->system,
3509	trace_event_name(call: edata->file->event_call));
3510
3511	if (edata->count == -1)
3512	seq_puts(m, s: ":unlimited\n");
3513	else
3514	seq_printf(m, fmt: ":count=%ld\n", edata->count);
3515
3516	return 0;
3517	}
3518
3519	static int
3520	event_enable_init(struct ftrace_probe_ops *ops, struct trace_array *tr,
3521	unsigned long ip, void *init_data, void **data)
3522	{
3523	struct ftrace_func_mapper *mapper = *data;
3524	struct event_probe_data *edata = init_data;
3525	int ret;
3526
3527	if (!mapper) {
3528	mapper = allocate_ftrace_func_mapper();
3529	if (!mapper)
3530	return -ENODEV;
3531	*data = mapper;
3532	}
3533
3534	ret = ftrace_func_mapper_add_ip(mapper, ip, data: edata);
3535	if (ret < 0)
3536	return ret;
3537
3538	edata->ref++;
3539
3540	return 0;
3541	}
3542
3543	static int free_probe_data(void *data)
3544	{
3545	struct event_probe_data *edata = data;
3546
3547	edata->ref--;
3548	if (!edata->ref) {
3549	/* Remove the SOFT_MODE flag */
3550	__ftrace_event_enable_disable(file: edata->file, enable: 0, soft_disable: 1);
3551	trace_event_put_ref(call: edata->file->event_call);
3552	kfree(objp: edata);
3553	}
3554	return 0;
3555	}
3556
3557	static void
3558	event_enable_free(struct ftrace_probe_ops *ops, struct trace_array *tr,
3559	unsigned long ip, void *data)
3560	{
3561	struct ftrace_func_mapper *mapper = data;
3562	struct event_probe_data *edata;
3563
3564	if (!ip) {
3565	if (!mapper)
3566	return;
3567	free_ftrace_func_mapper(mapper, free_func: free_probe_data);
3568	return;
3569	}
3570
3571	edata = ftrace_func_mapper_remove_ip(mapper, ip);
3572
3573	if (WARN_ON_ONCE(!edata))
3574	return;
3575
3576	if (WARN_ON_ONCE(edata->ref <= 0))
3577	return;
3578
3579	free_probe_data(data: edata);
3580	}
3581
3582	static struct ftrace_probe_ops event_enable_probe_ops = {
3583	.func = event_enable_probe,
3584	.print = event_enable_print,
3585	.init = event_enable_init,
3586	.free = event_enable_free,
3587	};
3588
3589	static struct ftrace_probe_ops event_enable_count_probe_ops = {
3590	.func = event_enable_count_probe,
3591	.print = event_enable_print,
3592	.init = event_enable_init,
3593	.free = event_enable_free,
3594	};
3595
3596	static struct ftrace_probe_ops event_disable_probe_ops = {
3597	.func = event_enable_probe,
3598	.print = event_enable_print,
3599	.init = event_enable_init,
3600	.free = event_enable_free,
3601	};
3602
3603	static struct ftrace_probe_ops event_disable_count_probe_ops = {
3604	.func = event_enable_count_probe,
3605	.print = event_enable_print,
3606	.init = event_enable_init,
3607	.free = event_enable_free,
3608	};
3609
3610	static int
3611	event_enable_func(struct trace_array *tr, struct ftrace_hash *hash,
3612	char *glob, char *cmd, char *param, int enabled)
3613	{
3614	struct trace_event_file *file;
3615	struct ftrace_probe_ops *ops;
3616	struct event_probe_data *data;
3617	const char *system;
3618	const char *event;
3619	char *number;
3620	bool enable;
3621	int ret;
3622
3623	if (!tr)
3624	return -ENODEV;
3625
3626	/* hash funcs only work with set_ftrace_filter */
3627	if (!enabled || !param)
3628	return -EINVAL;
3629
3630	system = strsep(&param, ":");
3631	if (!param)
3632	return -EINVAL;
3633
3634	event = strsep(&param, ":");
3635
3636	mutex_lock(&event_mutex);
3637
3638	ret = -EINVAL;
3639	file = find_event_file(tr, system, event);
3640	if (!file)
3641	goto out;
3642
3643	enable = strcmp(cmd, ENABLE_EVENT_STR) == 0;
3644
3645	if (enable)
3646	ops = param ? &event_enable_count_probe_ops : &event_enable_probe_ops;
3647	else
3648	ops = param ? &event_disable_count_probe_ops : &event_disable_probe_ops;
3649
3650	if (glob[0] == '!') {
3651	ret = unregister_ftrace_function_probe_func(glob: glob+1, tr, ops);
3652	goto out;
3653	}
3654
3655	ret = -ENOMEM;
3656
3657	data = kzalloc(size: sizeof(*data), GFP_KERNEL);
3658	if (!data)
3659	goto out;
3660
3661	data->enable = enable;
3662	data->count = -1;
3663	data->file = file;
3664
3665	if (!param)
3666	goto out_reg;
3667
3668	number = strsep(&param, ":");
3669
3670	ret = -EINVAL;
3671	if (!strlen(number))
3672	goto out_free;
3673
3674	/*
3675	* We use the callback data field (which is a pointer)
3676	* as our counter.
3677	*/
3678	ret = kstrtoul(s: number, base: 0, res: &data->count);
3679	if (ret)
3680	goto out_free;
3681
3682	out_reg:
3683	/* Don't let event modules unload while probe registered */
3684	ret = trace_event_try_get_ref(call: file->event_call);
3685	if (!ret) {
3686	ret = -EBUSY;
3687	goto out_free;
3688	}
3689
3690	ret = __ftrace_event_enable_disable(file, enable: 1, soft_disable: 1);
3691	if (ret < 0)
3692	goto out_put;
3693
3694	ret = register_ftrace_function_probe(glob, tr, ops, data);
3695	/*
3696	* The above returns on success the # of functions enabled,
3697	* but if it didn't find any functions it returns zero.
3698	* Consider no functions a failure too.
3699	*/
3700	if (!ret) {
3701	ret = -ENOENT;
3702	goto out_disable;
3703	} else if (ret < 0)
3704	goto out_disable;
3705	/* Just return zero, not the number of enabled functions */
3706	ret = 0;
3707	out:
3708	mutex_unlock(lock: &event_mutex);
3709	return ret;
3710
3711	out_disable:
3712	__ftrace_event_enable_disable(file, enable: 0, soft_disable: 1);
3713	out_put:
3714	trace_event_put_ref(call: file->event_call);
3715	out_free:
3716	kfree(objp: data);
3717	goto out;
3718	}
3719
3720	static struct ftrace_func_command event_enable_cmd = {
3721	.name = ENABLE_EVENT_STR,
3722	.func = event_enable_func,
3723	};
3724
3725	static struct ftrace_func_command event_disable_cmd = {
3726	.name = DISABLE_EVENT_STR,
3727	.func = event_enable_func,
3728	};
3729
3730	static __init int register_event_cmds(void)
3731	{
3732	int ret;
3733
3734	ret = register_ftrace_command(cmd: &event_enable_cmd);
3735	if (WARN_ON(ret < 0))
3736	return ret;
3737	ret = register_ftrace_command(cmd: &event_disable_cmd);
3738	if (WARN_ON(ret < 0))
3739	unregister_ftrace_command(cmd: &event_enable_cmd);
3740	return ret;
3741	}
3742	#else
3743	static inline int register_event_cmds(void) { return 0; }
3744	#endif /* CONFIG_DYNAMIC_FTRACE */
3745
3746	/*
3747	* The top level array and trace arrays created by boot-time tracing
3748	* have already had its trace_event_file descriptors created in order
3749	* to allow for early events to be recorded.
3750	* This function is called after the tracefs has been initialized,
3751	* and we now have to create the files associated to the events.
3752	*/
3753	static void __trace_early_add_event_dirs(struct trace_array *tr)
3754	{
3755	struct trace_event_file *file;
3756	int ret;
3757
3758
3759	list_for_each_entry(file, &tr->events, list) {
3760	ret = event_create_dir(parent: tr->event_dir, file);
3761	if (ret < 0)
3762	pr_warn("Could not create directory for event %s\n",
3763	trace_event_name(file->event_call));
3764	}
3765	}
3766
3767	/*
3768	* For early boot up, the top trace array and the trace arrays created
3769	* by boot-time tracing require to have a list of events that can be
3770	* enabled. This must be done before the filesystem is set up in order
3771	* to allow events to be traced early.
3772	*/
3773	void __trace_early_add_events(struct trace_array *tr)
3774	{
3775	struct trace_event_call *call;
3776	int ret;
3777
3778	list_for_each_entry(call, &ftrace_events, list) {
3779	/* Early boot up should not have any modules loaded */
3780	if (!(call->flags & TRACE_EVENT_FL_DYNAMIC) &&
3781	WARN_ON_ONCE(call->module))
3782	continue;
3783
3784	ret = __trace_early_add_new_event(call, tr);
3785	if (ret < 0)
3786	pr_warn("Could not create early event %s\n",
3787	trace_event_name(call));
3788	}
3789	}
3790
3791	/* Remove the event directory structure for a trace directory. */
3792	static void
3793	__trace_remove_event_dirs(struct trace_array *tr)
3794	{
3795	struct trace_event_file *file, *next;
3796
3797	list_for_each_entry_safe(file, next, &tr->events, list)
3798	remove_event_file_dir(file);
3799	}
3800
3801	static void __add_event_to_tracers(struct trace_event_call *call)
3802	{
3803	struct trace_array *tr;
3804
3805	list_for_each_entry(tr, &ftrace_trace_arrays, list)
3806	__trace_add_new_event(call, tr);
3807	}
3808
3809	extern struct trace_event_call *__start_ftrace_events[];
3810	extern struct trace_event_call *__stop_ftrace_events[];
3811
3812	static char bootup_event_buf[COMMAND_LINE_SIZE] __initdata;
3813
3814	static __init int setup_trace_event(char *str)
3815	{
3816	strscpy(bootup_event_buf, str, COMMAND_LINE_SIZE);
3817	trace_set_ring_buffer_expanded(NULL);
3818	disable_tracing_selftest(reason: "running event tracing");
3819
3820	return 1;
3821	}
3822	__setup("trace_event=", setup_trace_event);
3823
3824	static int events_callback(const char *name, umode_t *mode, void **data,
3825	const struct file_operations **fops)
3826	{
3827	if (strcmp(name, "enable") == 0) {
3828	*mode = TRACE_MODE_WRITE;
3829	*fops = &ftrace_tr_enable_fops;
3830	return 1;
3831	}
3832
3833	if (strcmp(name, "header_page") == 0) {
3834	*mode = TRACE_MODE_READ;
3835	*fops = &ftrace_show_header_page_fops;
3836
3837	} else if (strcmp(name, "header_event") == 0) {
3838	*mode = TRACE_MODE_READ;
3839	*fops = &ftrace_show_header_event_fops;
3840	} else
3841	return 0;
3842
3843	return 1;
3844	}
3845
3846	/* Expects to have event_mutex held when called */
3847	static int
3848	create_event_toplevel_files(struct dentry *parent, struct trace_array *tr)
3849	{
3850	struct eventfs_inode *e_events;
3851	struct dentry *entry;
3852	int nr_entries;
3853	static struct eventfs_entry events_entries[] = {
3854	{
3855	.name = "enable",
3856	.callback = events_callback,
3857	},
3858	{
3859	.name = "header_page",
3860	.callback = events_callback,
3861	},
3862	{
3863	.name = "header_event",
3864	.callback = events_callback,
3865	},
3866	};
3867
3868	entry = trace_create_file(name: "set_event", TRACE_MODE_WRITE, parent,
3869	data: tr, fops: &ftrace_set_event_fops);
3870	if (!entry)
3871	return -ENOMEM;
3872
3873	nr_entries = ARRAY_SIZE(events_entries);
3874
3875	e_events = eventfs_create_events_dir(name: "events", parent, entries: events_entries,
3876	size: nr_entries, data: tr);
3877	if (IS_ERR(ptr: e_events)) {
3878	pr_warn("Could not create tracefs 'events' directory\n");
3879	return -ENOMEM;
3880	}
3881
3882	/* There are not as crucial, just warn if they are not created */
3883
3884	trace_create_file(name: "set_event_pid", TRACE_MODE_WRITE, parent,
3885	data: tr, fops: &ftrace_set_event_pid_fops);
3886
3887	trace_create_file(name: "set_event_notrace_pid",
3888	TRACE_MODE_WRITE, parent, data: tr,
3889	fops: &ftrace_set_event_notrace_pid_fops);
3890
3891	tr->event_dir = e_events;
3892
3893	return 0;
3894	}
3895
3896	/**
3897	* event_trace_add_tracer - add a instance of a trace_array to events
3898	* @parent: The parent dentry to place the files/directories for events in
3899	* @tr: The trace array associated with these events
3900	*
3901	* When a new instance is created, it needs to set up its events
3902	* directory, as well as other files associated with events. It also
3903	* creates the event hierarchy in the @parent/events directory.
3904	*
3905	* Returns 0 on success.
3906	*
3907	* Must be called with event_mutex held.
3908	*/
3909	int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr)
3910	{
3911	int ret;
3912
3913	lockdep_assert_held(&event_mutex);
3914
3915	ret = create_event_toplevel_files(parent, tr);
3916	if (ret)
3917	goto out;
3918
3919	down_write(sem: &trace_event_sem);
3920	/* If tr already has the event list, it is initialized in early boot. */
3921	if (unlikely(!list_empty(&tr->events)))
3922	__trace_early_add_event_dirs(tr);
3923	else
3924	__trace_add_event_dirs(tr);
3925	up_write(sem: &trace_event_sem);
3926
3927	out:
3928	return ret;
3929	}
3930
3931	/*
3932	* The top trace array already had its file descriptors created.
3933	* Now the files themselves need to be created.
3934	*/
3935	static __init int
3936	early_event_add_tracer(struct dentry *parent, struct trace_array *tr)
3937	{
3938	int ret;
3939
3940	mutex_lock(&event_mutex);
3941
3942	ret = create_event_toplevel_files(parent, tr);
3943	if (ret)
3944	goto out_unlock;
3945
3946	down_write(sem: &trace_event_sem);
3947	__trace_early_add_event_dirs(tr);
3948	up_write(sem: &trace_event_sem);
3949
3950	out_unlock:
3951	mutex_unlock(lock: &event_mutex);
3952
3953	return ret;
3954	}
3955
3956	/* Must be called with event_mutex held */
3957	int event_trace_del_tracer(struct trace_array *tr)
3958	{
3959	lockdep_assert_held(&event_mutex);
3960
3961	/* Disable any event triggers and associated soft-disabled events */
3962	clear_event_triggers(tr);
3963
3964	/* Clear the pid list */
3965	__ftrace_clear_event_pids(tr, type: TRACE_PIDS | TRACE_NO_PIDS);
3966
3967	/* Disable any running events */
3968	__ftrace_set_clr_event_nolock(tr, NULL, NULL, NULL, set: 0);
3969
3970	/* Make sure no more events are being executed */
3971	tracepoint_synchronize_unregister();
3972
3973	down_write(sem: &trace_event_sem);
3974	__trace_remove_event_dirs(tr);
3975	eventfs_remove_events_dir(ei: tr->event_dir);
3976	up_write(sem: &trace_event_sem);
3977
3978	tr->event_dir = NULL;
3979
3980	return 0;
3981	}
3982
3983	static __init int event_trace_memsetup(void)
3984	{
3985	field_cachep = KMEM_CACHE(ftrace_event_field, SLAB_PANIC);
3986	file_cachep = KMEM_CACHE(trace_event_file, SLAB_PANIC);
3987	return 0;
3988	}
3989
3990	__init void
3991	early_enable_events(struct trace_array *tr, char *buf, bool disable_first)
3992	{
3993	char *token;
3994	int ret;
3995
3996	while (true) {
3997	token = strsep(&buf, ",");
3998
3999	if (!token)
4000	break;
4001
4002	if (*token) {
4003	/* Restarting syscalls requires that we stop them first */
4004	if (disable_first)
4005	ftrace_set_clr_event(tr, buf: token, set: 0);
4006
4007	ret = ftrace_set_clr_event(tr, buf: token, set: 1);
4008	if (ret)
4009	pr_warn("Failed to enable trace event: %s\n", token);
4010	}
4011
4012	/* Put back the comma to allow this to be called again */
4013	if (buf)
4014	*(buf - 1) = ',';
4015	}
4016	}
4017
4018	static __init int event_trace_enable(void)
4019	{
4020	struct trace_array *tr = top_trace_array();
4021	struct trace_event_call **iter, *call;
4022	int ret;
4023
4024	if (!tr)
4025	return -ENODEV;
4026
4027	for_each_event(iter, __start_ftrace_events, __stop_ftrace_events) {
4028
4029	call = *iter;
4030	ret = event_init(call);
4031	if (!ret)
4032	list_add(new: &call->list, head: &ftrace_events);
4033	}
4034
4035	register_trigger_cmds();
4036
4037	/*
4038	* We need the top trace array to have a working set of trace
4039	* points at early init, before the debug files and directories
4040	* are created. Create the file entries now, and attach them
4041	* to the actual file dentries later.
4042	*/
4043	__trace_early_add_events(tr);
4044
4045	early_enable_events(tr, buf: bootup_event_buf, disable_first: false);
4046
4047	trace_printk_start_comm();
4048
4049	register_event_cmds();
4050
4051
4052	return 0;
4053	}
4054
4055	/*
4056	* event_trace_enable() is called from trace_event_init() first to
4057	* initialize events and perhaps start any events that are on the
4058	* command line. Unfortunately, there are some events that will not
4059	* start this early, like the system call tracepoints that need
4060	* to set the %SYSCALL_WORK_SYSCALL_TRACEPOINT flag of pid 1. But
4061	* event_trace_enable() is called before pid 1 starts, and this flag
4062	* is never set, making the syscall tracepoint never get reached, but
4063	* the event is enabled regardless (and not doing anything).
4064	*/
4065	static __init int event_trace_enable_again(void)
4066	{
4067	struct trace_array *tr;
4068
4069	tr = top_trace_array();
4070	if (!tr)
4071	return -ENODEV;
4072
4073	early_enable_events(tr, buf: bootup_event_buf, disable_first: true);
4074
4075	return 0;
4076	}
4077
4078	early_initcall(event_trace_enable_again);
4079
4080	/* Init fields which doesn't related to the tracefs */
4081	static __init int event_trace_init_fields(void)
4082	{
4083	if (trace_define_generic_fields())
4084	pr_warn("tracing: Failed to allocated generic fields");
4085
4086	if (trace_define_common_fields())
4087	pr_warn("tracing: Failed to allocate common fields");
4088
4089	return 0;
4090	}
4091
4092	__init int event_trace_init(void)
4093	{
4094	struct trace_array *tr;
4095	int ret;
4096
4097	tr = top_trace_array();
4098	if (!tr)
4099	return -ENODEV;
4100
4101	trace_create_file(name: "available_events", TRACE_MODE_READ,
4102	NULL, data: tr, fops: &ftrace_avail_fops);
4103
4104	ret = early_event_add_tracer(NULL, tr);
4105	if (ret)
4106	return ret;
4107
4108	#ifdef CONFIG_MODULES
4109	ret = register_module_notifier(nb: &trace_module_nb);
4110	if (ret)
4111	pr_warn("Failed to register trace events module notifier\n");
4112	#endif
4113
4114	eventdir_initialized = true;
4115
4116	return 0;
4117	}
4118
4119	void __init trace_event_init(void)
4120	{
4121	event_trace_memsetup();
4122	init_ftrace_syscalls();
4123	event_trace_enable();
4124	event_trace_init_fields();
4125	}
4126
4127	#ifdef CONFIG_EVENT_TRACE_STARTUP_TEST
4128
4129	static DEFINE_SPINLOCK(test_spinlock);
4130	static DEFINE_SPINLOCK(test_spinlock_irq);
4131	static DEFINE_MUTEX(test_mutex);
4132
4133	static __init void test_work(struct work_struct *dummy)
4134	{
4135	spin_lock(lock: &test_spinlock);
4136	spin_lock_irq(lock: &test_spinlock_irq);
4137	udelay(1);
4138	spin_unlock_irq(lock: &test_spinlock_irq);
4139	spin_unlock(lock: &test_spinlock);
4140
4141	mutex_lock(&test_mutex);
4142	msleep(msecs: 1);
4143	mutex_unlock(lock: &test_mutex);
4144	}
4145
4146	static __init int event_test_thread(void *unused)
4147	{
4148	void *test_malloc;
4149
4150	test_malloc = kmalloc(size: 1234, GFP_KERNEL);
4151	if (!test_malloc)
4152	pr_info("failed to kmalloc\n");
4153
4154	schedule_on_each_cpu(func: test_work);
4155
4156	kfree(objp: test_malloc);
4157
4158	set_current_state(TASK_INTERRUPTIBLE);
4159	while (!kthread_should_stop()) {
4160	schedule();
4161	set_current_state(TASK_INTERRUPTIBLE);
4162	}
4163	__set_current_state(TASK_RUNNING);
4164
4165	return 0;
4166	}
4167
4168	/*
4169	* Do various things that may trigger events.
4170	*/
4171	static __init void event_test_stuff(void)
4172	{
4173	struct task_struct *test_thread;
4174
4175	test_thread = kthread_run(event_test_thread, NULL, "test-events");
4176	msleep(msecs: 1);
4177	kthread_stop(k: test_thread);
4178	}
4179
4180	/*
4181	* For every trace event defined, we will test each trace point separately,
4182	* and then by groups, and finally all trace points.
4183	*/
4184	static __init void event_trace_self_tests(void)
4185	{
4186	struct trace_subsystem_dir *dir;
4187	struct trace_event_file *file;
4188	struct trace_event_call *call;
4189	struct event_subsystem *system;
4190	struct trace_array *tr;
4191	int ret;
4192
4193	tr = top_trace_array();
4194	if (!tr)
4195	return;
4196
4197	pr_info("Running tests on trace events:\n");
4198
4199	list_for_each_entry(file, &tr->events, list) {
4200
4201	call = file->event_call;
4202
4203	/* Only test those that have a probe */
4204	if (!call->class || !call->class->probe)
4205	continue;
4206
4207	/*
4208	* Testing syscall events here is pretty useless, but
4209	* we still do it if configured. But this is time consuming.
4210	* What we really need is a user thread to perform the
4211	* syscalls as we test.
4212	*/
4213	#ifndef CONFIG_EVENT_TRACE_TEST_SYSCALLS
4214	if (call->class->system &&
4215	strcmp(call->class->system, "syscalls") == 0)
4216	continue;
4217	#endif
4218
4219	pr_info("Testing event %s: ", trace_event_name(call));
4220
4221	/*
4222	* If an event is already enabled, someone is using
4223	* it and the self test should not be on.
4224	*/
4225	if (file->flags & EVENT_FILE_FL_ENABLED) {
4226	pr_warn("Enabled event during self test!\n");
4227	WARN_ON_ONCE(1);
4228	continue;
4229	}
4230
4231	ftrace_event_enable_disable(file, enable: 1);
4232	event_test_stuff();
4233	ftrace_event_enable_disable(file, enable: 0);
4234
4235	pr_cont("OK\n");
4236	}
4237
4238	/* Now test at the sub system level */
4239
4240	pr_info("Running tests on trace event systems:\n");
4241
4242	list_for_each_entry(dir, &tr->systems, list) {
4243
4244	system = dir->subsystem;
4245
4246	/* the ftrace system is special, skip it */
4247	if (strcmp(system->name, "ftrace") == 0)
4248	continue;
4249
4250	pr_info("Testing event system %s: ", system->name);
4251
4252	ret = __ftrace_set_clr_event(tr, NULL, sub: system->name, NULL, set: 1);
4253	if (WARN_ON_ONCE(ret)) {
4254	pr_warn("error enabling system %s\n",
4255	system->name);
4256	continue;
4257	}
4258
4259	event_test_stuff();
4260
4261	ret = __ftrace_set_clr_event(tr, NULL, sub: system->name, NULL, set: 0);
4262	if (WARN_ON_ONCE(ret)) {
4263	pr_warn("error disabling system %s\n",
4264	system->name);
4265	continue;
4266	}
4267
4268	pr_cont("OK\n");
4269	}
4270
4271	/* Test with all events enabled */
4272
4273	pr_info("Running tests on all trace events:\n");
4274	pr_info("Testing all events: ");
4275
4276	ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, set: 1);
4277	if (WARN_ON_ONCE(ret)) {
4278	pr_warn("error enabling all events\n");
4279	return;
4280	}
4281
4282	event_test_stuff();
4283
4284	/* reset sysname */
4285	ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, set: 0);
4286	if (WARN_ON_ONCE(ret)) {
4287	pr_warn("error disabling all events\n");
4288	return;
4289	}
4290
4291	pr_cont("OK\n");
4292	}
4293
4294	#ifdef CONFIG_FUNCTION_TRACER
4295
4296	static DEFINE_PER_CPU(atomic_t, ftrace_test_event_disable);
4297
4298	static struct trace_event_file event_trace_file __initdata;
4299
4300	static void __init
4301	function_test_events_call(unsigned long ip, unsigned long parent_ip,
4302	struct ftrace_ops *op, struct ftrace_regs *regs)
4303	{
4304	struct trace_buffer *buffer;
4305	struct ring_buffer_event *event;
4306	struct ftrace_entry *entry;
4307	unsigned int trace_ctx;
4308	long disabled;
4309	int cpu;
4310
4311	trace_ctx = tracing_gen_ctx();
4312	preempt_disable_notrace();
4313	cpu = raw_smp_processor_id();
4314	disabled = atomic_inc_return(v: &per_cpu(ftrace_test_event_disable, cpu));
4315
4316	if (disabled != 1)
4317	goto out;
4318
4319	event = trace_event_buffer_lock_reserve(current_buffer: &buffer, trace_file: &event_trace_file,
4320	type: TRACE_FN, len: sizeof(*entry),
4321	trace_ctx);
4322	if (!event)
4323	goto out;
4324	entry = ring_buffer_event_data(event);
4325	entry->ip = ip;
4326	entry->parent_ip = parent_ip;
4327
4328	event_trigger_unlock_commit(file: &event_trace_file, buffer, event,
4329	entry, trace_ctx);
4330	out:
4331	atomic_dec(v: &per_cpu(ftrace_test_event_disable, cpu));
4332	preempt_enable_notrace();
4333	}
4334
4335	static struct ftrace_ops trace_ops __initdata =
4336	{
4337	.func = function_test_events_call,
4338	};
4339
4340	static __init void event_trace_self_test_with_function(void)
4341	{
4342	int ret;
4343
4344	event_trace_file.tr = top_trace_array();
4345	if (WARN_ON(!event_trace_file.tr))
4346	return;
4347
4348	ret = register_ftrace_function(ops: &trace_ops);
4349	if (WARN_ON(ret < 0)) {
4350	pr_info("Failed to enable function tracer for event tests\n");
4351	return;
4352	}
4353	pr_info("Running tests again, along with the function tracer\n");
4354	event_trace_self_tests();
4355	unregister_ftrace_function(ops: &trace_ops);
4356	}
4357	#else
4358	static __init void event_trace_self_test_with_function(void)
4359	{
4360	}
4361	#endif
4362
4363	static __init int event_trace_self_tests_init(void)
4364	{
4365	if (!tracing_selftest_disabled) {
4366	event_trace_self_tests();
4367	event_trace_self_test_with_function();
4368	}
4369
4370	return 0;
4371	}
4372
4373	late_initcall(event_trace_self_tests_init);
4374
4375	#endif
4376