blob: 81c038ed6cee780965e33fe40ec468a6f4fdf004 [file] [log] [blame]
Steven Rostedt (VMware)bcea3f92018-08-16 11:23:53 -04001// SPDX-License-Identifier: GPL-2.0
Steven Rostedtb77e38a2009-02-24 10:21:36 -05002/*
3 * event tracer
4 *
5 * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
6 *
Steven Rostedt981d0812009-03-02 13:53:59 -05007 * - Added format output of fields of the trace point.
8 * This was based off of work by Tom Zanussi <tzanussi@gmail.com>.
9 *
Steven Rostedtb77e38a2009-02-24 10:21:36 -050010 */
11
Fabian Frederick3448bac2014-06-07 13:43:08 +020012#define pr_fmt(fmt) fmt
13
Steven Rostedte6187002009-04-15 13:36:40 -040014#include <linux/workqueue.h>
15#include <linux/spinlock.h>
16#include <linux/kthread.h>
Steven Rostedt (Red Hat)8434dc92015-01-20 12:13:40 -050017#include <linux/tracefs.h>
Steven Rostedtb77e38a2009-02-24 10:21:36 -050018#include <linux/uaccess.h>
19#include <linux/module.h>
20#include <linux/ctype.h>
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -040021#include <linux/sort.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090022#include <linux/slab.h>
Steven Rostedte6187002009-04-15 13:36:40 -040023#include <linux/delay.h>
Steven Rostedtb77e38a2009-02-24 10:21:36 -050024
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -040025#include <trace/events/sched.h>
26
Li Zefan020e5f82009-07-01 10:47:05 +080027#include <asm/setup.h>
28
Steven Rostedt91729ef92009-03-02 15:03:01 -050029#include "trace_output.h"
Steven Rostedtb77e38a2009-02-24 10:21:36 -050030
Steven Rostedt4e5292e2009-09-12 19:26:21 -040031#undef TRACE_SYSTEM
Steven Rostedtb628b3e2009-02-27 23:32:58 -050032#define TRACE_SYSTEM "TRACE_SYSTEM"
33
Li Zefan20c89282009-05-06 10:33:45 +080034DEFINE_MUTEX(event_mutex);
Steven Rostedt11a241a2009-03-02 11:49:04 -050035
Steven Rostedta59fd602009-04-10 13:52:20 -040036LIST_HEAD(ftrace_events);
Daniel Wagner9f616682015-08-10 14:35:46 +020037static LIST_HEAD(ftrace_generic_fields);
zhangwei(Jovi)b3a8c6f2013-03-11 15:13:42 +080038static LIST_HEAD(ftrace_common_fields);
Steven Rostedta59fd602009-04-10 13:52:20 -040039
Steven Rostedtd1a29142013-02-27 20:23:57 -050040#define GFP_TRACE (GFP_KERNEL | __GFP_ZERO)
41
42static struct kmem_cache *field_cachep;
43static struct kmem_cache *file_cachep;
44
Steven Rostedt6e94a782013-06-27 10:58:31 -040045static inline int system_refcount(struct event_subsystem *system)
46{
Rasmus Villemoes79ac6ef2015-09-09 23:24:01 +020047 return system->ref_count;
Steven Rostedt6e94a782013-06-27 10:58:31 -040048}
49
50static int system_refcount_inc(struct event_subsystem *system)
51{
Rasmus Villemoes79ac6ef2015-09-09 23:24:01 +020052 return system->ref_count++;
Steven Rostedt6e94a782013-06-27 10:58:31 -040053}
54
55static int system_refcount_dec(struct event_subsystem *system)
56{
Rasmus Villemoes79ac6ef2015-09-09 23:24:01 +020057 return --system->ref_count;
Steven Rostedt6e94a782013-06-27 10:58:31 -040058}
59
Steven Rostedtae63b31e2012-05-03 23:09:03 -040060/* Double loops, do not use break, only goto's work */
61#define do_for_each_event_file(tr, file) \
62 list_for_each_entry(tr, &ftrace_trace_arrays, list) { \
63 list_for_each_entry(file, &tr->events, list)
64
65#define do_for_each_event_file_safe(tr, file) \
66 list_for_each_entry(tr, &ftrace_trace_arrays, list) { \
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -040067 struct trace_event_file *___n; \
Steven Rostedtae63b31e2012-05-03 23:09:03 -040068 list_for_each_entry_safe(file, ___n, &tr->events, list)
69
70#define while_for_each_event_file() \
71 }
72
zhangwei(Jovi)b3a8c6f2013-03-11 15:13:42 +080073static struct list_head *
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -040074trace_get_fields(struct trace_event_call *event_call)
Steven Rostedt2e33af02010-04-22 10:35:55 -040075{
76 if (!event_call->class->get_fields)
77 return &event_call->class->fields;
78 return event_call->class->get_fields(event_call);
79}
80
zhangwei(Jovi)b3a8c6f2013-03-11 15:13:42 +080081static struct ftrace_event_field *
82__find_event_field(struct list_head *head, char *name)
83{
84 struct ftrace_event_field *field;
85
86 list_for_each_entry(field, head, link) {
87 if (!strcmp(field->name, name))
88 return field;
89 }
90
91 return NULL;
92}
93
94struct ftrace_event_field *
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -040095trace_find_event_field(struct trace_event_call *call, char *name)
zhangwei(Jovi)b3a8c6f2013-03-11 15:13:42 +080096{
97 struct ftrace_event_field *field;
98 struct list_head *head;
99
Steven Rostedt (Red Hat)e57cbaf2016-03-03 17:18:20 -0500100 head = trace_get_fields(call);
101 field = __find_event_field(head, name);
102 if (field)
103 return field;
104
Daniel Wagner9f616682015-08-10 14:35:46 +0200105 field = __find_event_field(&ftrace_generic_fields, name);
106 if (field)
107 return field;
108
Steven Rostedt (Red Hat)e57cbaf2016-03-03 17:18:20 -0500109 return __find_event_field(&ftrace_common_fields, name);
zhangwei(Jovi)b3a8c6f2013-03-11 15:13:42 +0800110}
111
Li Zefan8728fe52010-05-24 16:22:49 +0800112static int __trace_define_field(struct list_head *head, const char *type,
113 const char *name, int offset, int size,
114 int is_signed, int filter_type)
Tom Zanussicf027f62009-03-22 03:30:39 -0500115{
116 struct ftrace_event_field *field;
117
Steven Rostedtd1a29142013-02-27 20:23:57 -0500118 field = kmem_cache_alloc(field_cachep, GFP_TRACE);
Tom Zanussicf027f62009-03-22 03:30:39 -0500119 if (!field)
Namhyung Kimaaf6ac02013-06-07 15:07:48 +0900120 return -ENOMEM;
Ingo Molnarfe9f57f22009-03-22 18:41:59 +0100121
Steven Rostedt92edca02013-02-27 20:41:37 -0500122 field->name = name;
123 field->type = type;
Ingo Molnarfe9f57f22009-03-22 18:41:59 +0100124
Li Zefan43b51ea2009-08-07 10:33:22 +0800125 if (filter_type == FILTER_OTHER)
126 field->filter_type = filter_assign_type(type);
127 else
128 field->filter_type = filter_type;
129
Tom Zanussicf027f62009-03-22 03:30:39 -0500130 field->offset = offset;
131 field->size = size;
Tom Zanussia118e4d2009-04-28 03:04:53 -0500132 field->is_signed = is_signed;
Li Zefanaa38e9f2009-08-07 10:33:02 +0800133
Steven Rostedt2e33af02010-04-22 10:35:55 -0400134 list_add(&field->link, head);
Tom Zanussicf027f62009-03-22 03:30:39 -0500135
136 return 0;
Tom Zanussicf027f62009-03-22 03:30:39 -0500137}
Li Zefan8728fe52010-05-24 16:22:49 +0800138
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400139int trace_define_field(struct trace_event_call *call, const char *type,
Li Zefan8728fe52010-05-24 16:22:49 +0800140 const char *name, int offset, int size, int is_signed,
141 int filter_type)
142{
143 struct list_head *head;
144
145 if (WARN_ON(!call->class))
146 return 0;
147
148 head = trace_get_fields(call);
149 return __trace_define_field(head, type, name, offset, size,
150 is_signed, filter_type);
151}
Steven Rostedt17c873e2009-04-10 18:12:50 -0400152EXPORT_SYMBOL_GPL(trace_define_field);
Tom Zanussicf027f62009-03-22 03:30:39 -0500153
Daniel Wagner9f616682015-08-10 14:35:46 +0200154#define __generic_field(type, item, filter_type) \
155 ret = __trace_define_field(&ftrace_generic_fields, #type, \
156 #item, 0, 0, is_signed_type(type), \
157 filter_type); \
158 if (ret) \
159 return ret;
160
Li Zefane647d6b2009-08-19 15:54:32 +0800161#define __common_field(type, item) \
Li Zefan8728fe52010-05-24 16:22:49 +0800162 ret = __trace_define_field(&ftrace_common_fields, #type, \
163 "common_" #item, \
164 offsetof(typeof(ent), item), \
165 sizeof(ent.item), \
166 is_signed_type(type), FILTER_OTHER); \
Li Zefane647d6b2009-08-19 15:54:32 +0800167 if (ret) \
168 return ret;
169
Daniel Wagner9f616682015-08-10 14:35:46 +0200170static int trace_define_generic_fields(void)
171{
172 int ret;
173
Steven Rostedt (Red Hat)e57cbaf2016-03-03 17:18:20 -0500174 __generic_field(int, CPU, FILTER_CPU);
175 __generic_field(int, cpu, FILTER_CPU);
176 __generic_field(char *, COMM, FILTER_COMM);
177 __generic_field(char *, comm, FILTER_COMM);
Daniel Wagner9f616682015-08-10 14:35:46 +0200178
179 return ret;
180}
181
Li Zefan8728fe52010-05-24 16:22:49 +0800182static int trace_define_common_fields(void)
Li Zefane647d6b2009-08-19 15:54:32 +0800183{
184 int ret;
185 struct trace_entry ent;
186
187 __common_field(unsigned short, type);
188 __common_field(unsigned char, flags);
189 __common_field(unsigned char, preempt_count);
190 __common_field(int, pid);
Li Zefane647d6b2009-08-19 15:54:32 +0800191
192 return ret;
193}
194
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400195static void trace_destroy_fields(struct trace_event_call *call)
Li Zefan2df75e42009-05-06 10:33:04 +0800196{
197 struct ftrace_event_field *field, *next;
Steven Rostedt2e33af02010-04-22 10:35:55 -0400198 struct list_head *head;
Li Zefan2df75e42009-05-06 10:33:04 +0800199
Steven Rostedt2e33af02010-04-22 10:35:55 -0400200 head = trace_get_fields(call);
201 list_for_each_entry_safe(field, next, head, link) {
Li Zefan2df75e42009-05-06 10:33:04 +0800202 list_del(&field->link);
Steven Rostedtd1a29142013-02-27 20:23:57 -0500203 kmem_cache_free(field_cachep, field);
Li Zefan2df75e42009-05-06 10:33:04 +0800204 }
205}
206
Alexei Starovoitov32bbe002016-04-06 18:43:28 -0700207/*
208 * run-time version of trace_event_get_offsets_<call>() that returns the last
209 * accessible offset of trace fields excluding __dynamic_array bytes
210 */
211int trace_event_get_offsets(struct trace_event_call *call)
212{
213 struct ftrace_event_field *tail;
214 struct list_head *head;
215
216 head = trace_get_fields(call);
217 /*
218 * head->next points to the last field with the largest offset,
219 * since it was added last by trace_define_field()
220 */
221 tail = list_first_entry(head, struct ftrace_event_field, link);
222 return tail->offset + tail->size;
223}
224
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400225int trace_event_raw_init(struct trace_event_call *call)
Li Zefan87d9b4e2009-12-08 11:14:20 +0800226{
227 int id;
228
Steven Rostedt (Red Hat)9023c932015-05-05 09:39:12 -0400229 id = register_trace_event(&call->event);
Li Zefan87d9b4e2009-12-08 11:14:20 +0800230 if (!id)
231 return -ENODEV;
Li Zefan87d9b4e2009-12-08 11:14:20 +0800232
233 return 0;
234}
235EXPORT_SYMBOL_GPL(trace_event_raw_init);
236
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400237bool trace_event_ignore_this_pid(struct trace_event_file *trace_file)
238{
239 struct trace_array *tr = trace_file->tr;
240 struct trace_array_cpu *data;
241 struct trace_pid_list *pid_list;
242
Joel Fernandes (Google)da25a672018-08-02 19:34:07 -0700243 pid_list = rcu_dereference_raw(tr->filtered_pids);
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400244 if (!pid_list)
245 return false;
246
247 data = this_cpu_ptr(tr->trace_buffer.data);
248
249 return data->ignore_pid;
250}
251EXPORT_SYMBOL_GPL(trace_event_ignore_this_pid);
252
Steven Rostedt (Red Hat)3f795dc2015-05-05 13:18:46 -0400253void *trace_event_buffer_reserve(struct trace_event_buffer *fbuffer,
254 struct trace_event_file *trace_file,
255 unsigned long len)
Steven Rostedt3fd40d12012-08-09 22:42:57 -0400256{
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400257 struct trace_event_call *event_call = trace_file->event_call;
Steven Rostedt3fd40d12012-08-09 22:42:57 -0400258
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400259 if ((trace_file->flags & EVENT_FILE_FL_PID_FILTER) &&
260 trace_event_ignore_this_pid(trace_file))
261 return NULL;
262
Steven Rostedt3fd40d12012-08-09 22:42:57 -0400263 local_save_flags(fbuffer->flags);
264 fbuffer->pc = preempt_count();
Steven Rostedt (Red Hat)e9478412016-06-17 17:40:58 -0400265 /*
266 * If CONFIG_PREEMPT is enabled, then the tracepoint itself disables
267 * preemption (adding one to the preempt_count). Since we are
268 * interested in the preempt_count at the time the tracepoint was
269 * hit, we need to subtract one to offset the increment.
270 */
271 if (IS_ENABLED(CONFIG_PREEMPT))
272 fbuffer->pc--;
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400273 fbuffer->trace_file = trace_file;
Steven Rostedt3fd40d12012-08-09 22:42:57 -0400274
275 fbuffer->event =
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400276 trace_event_buffer_lock_reserve(&fbuffer->buffer, trace_file,
Steven Rostedt3fd40d12012-08-09 22:42:57 -0400277 event_call->event.type, len,
278 fbuffer->flags, fbuffer->pc);
279 if (!fbuffer->event)
280 return NULL;
281
282 fbuffer->entry = ring_buffer_event_data(fbuffer->event);
283 return fbuffer->entry;
284}
Steven Rostedt (Red Hat)3f795dc2015-05-05 13:18:46 -0400285EXPORT_SYMBOL_GPL(trace_event_buffer_reserve);
Steven Rostedt3fd40d12012-08-09 22:42:57 -0400286
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400287int trace_event_reg(struct trace_event_call *call,
Steven Rostedt (Red Hat)9023c932015-05-05 09:39:12 -0400288 enum trace_reg type, void *data)
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400289{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400290 struct trace_event_file *file = data;
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400291
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400292 WARN_ON(!(call->flags & TRACE_EVENT_FL_TRACEPOINT));
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400293 switch (type) {
294 case TRACE_REG_REGISTER:
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400295 return tracepoint_probe_register(call->tp,
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400296 call->class->probe,
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400297 file);
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400298 case TRACE_REG_UNREGISTER:
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400299 tracepoint_probe_unregister(call->tp,
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400300 call->class->probe,
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400301 file);
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400302 return 0;
303
304#ifdef CONFIG_PERF_EVENTS
305 case TRACE_REG_PERF_REGISTER:
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400306 return tracepoint_probe_register(call->tp,
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400307 call->class->perf_probe,
308 call);
309 case TRACE_REG_PERF_UNREGISTER:
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400310 tracepoint_probe_unregister(call->tp,
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400311 call->class->perf_probe,
312 call);
313 return 0;
Jiri Olsaceec0b62012-02-15 15:51:49 +0100314 case TRACE_REG_PERF_OPEN:
315 case TRACE_REG_PERF_CLOSE:
Jiri Olsa489c75c2012-02-15 15:51:50 +0100316 case TRACE_REG_PERF_ADD:
317 case TRACE_REG_PERF_DEL:
Jiri Olsaceec0b62012-02-15 15:51:49 +0100318 return 0;
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400319#endif
320 }
321 return 0;
322}
Steven Rostedt (Red Hat)9023c932015-05-05 09:39:12 -0400323EXPORT_SYMBOL_GPL(trace_event_reg);
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400324
Li Zefane870e9a2010-07-02 11:07:32 +0800325void trace_event_enable_cmd_record(bool enable)
326{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400327 struct trace_event_file *file;
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400328 struct trace_array *tr;
Li Zefane870e9a2010-07-02 11:07:32 +0800329
330 mutex_lock(&event_mutex);
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400331 do_for_each_event_file(tr, file) {
332
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400333 if (!(file->flags & EVENT_FILE_FL_ENABLED))
Li Zefane870e9a2010-07-02 11:07:32 +0800334 continue;
335
336 if (enable) {
337 tracing_start_cmdline_record();
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400338 set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
Li Zefane870e9a2010-07-02 11:07:32 +0800339 } else {
340 tracing_stop_cmdline_record();
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400341 clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
Li Zefane870e9a2010-07-02 11:07:32 +0800342 }
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400343 } while_for_each_event_file();
Li Zefane870e9a2010-07-02 11:07:32 +0800344 mutex_unlock(&event_mutex);
345}
346
Joel Fernandesd914ba32017-06-26 19:01:55 -0700347void trace_event_enable_tgid_record(bool enable)
348{
349 struct trace_event_file *file;
350 struct trace_array *tr;
351
352 mutex_lock(&event_mutex);
353 do_for_each_event_file(tr, file) {
354 if (!(file->flags & EVENT_FILE_FL_ENABLED))
355 continue;
356
357 if (enable) {
358 tracing_start_tgid_record();
359 set_bit(EVENT_FILE_FL_RECORDED_TGID_BIT, &file->flags);
360 } else {
361 tracing_stop_tgid_record();
362 clear_bit(EVENT_FILE_FL_RECORDED_TGID_BIT,
363 &file->flags);
364 }
365 } while_for_each_event_file();
366 mutex_unlock(&event_mutex);
367}
368
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400369static int __ftrace_event_enable_disable(struct trace_event_file *file,
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400370 int enable, int soft_disable)
Steven Rostedtfd994982009-02-28 02:41:25 -0500371{
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400372 struct trace_event_call *call = file->event_call;
Steven Rostedt (Red Hat)983f9382015-09-30 09:42:05 -0400373 struct trace_array *tr = file->tr;
Steven Rostedt (Red Hat)0fc1b092016-05-03 17:15:43 -0400374 unsigned long file_flags = file->flags;
Li Zefan3b8e4272009-12-08 11:14:52 +0800375 int ret = 0;
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400376 int disable;
Li Zefan3b8e4272009-12-08 11:14:52 +0800377
Steven Rostedtfd994982009-02-28 02:41:25 -0500378 switch (enable) {
379 case 0:
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400380 /*
Masami Hiramatsu1cf4c072013-05-09 14:44:29 +0900381 * When soft_disable is set and enable is cleared, the sm_ref
382 * reference counter is decremented. If it reaches 0, we want
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400383 * to clear the SOFT_DISABLED flag but leave the event in the
384 * state that it was. That is, if the event was enabled and
385 * SOFT_DISABLED isn't set, then do nothing. But if SOFT_DISABLED
386 * is set we do not want the event to be enabled before we
387 * clear the bit.
388 *
389 * When soft_disable is not set but the SOFT_MODE flag is,
390 * we do nothing. Do not disable the tracepoint, otherwise
391 * "soft enable"s (clearing the SOFT_DISABLED bit) wont work.
392 */
393 if (soft_disable) {
Masami Hiramatsu1cf4c072013-05-09 14:44:29 +0900394 if (atomic_dec_return(&file->sm_ref) > 0)
395 break;
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400396 disable = file->flags & EVENT_FILE_FL_SOFT_DISABLED;
397 clear_bit(EVENT_FILE_FL_SOFT_MODE_BIT, &file->flags);
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400398 } else
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400399 disable = !(file->flags & EVENT_FILE_FL_SOFT_MODE);
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400400
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400401 if (disable && (file->flags & EVENT_FILE_FL_ENABLED)) {
402 clear_bit(EVENT_FILE_FL_ENABLED_BIT, &file->flags);
403 if (file->flags & EVENT_FILE_FL_RECORDED_CMD) {
Li Zefane870e9a2010-07-02 11:07:32 +0800404 tracing_stop_cmdline_record();
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400405 clear_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
Li Zefane870e9a2010-07-02 11:07:32 +0800406 }
Joel Fernandesd914ba32017-06-26 19:01:55 -0700407
408 if (file->flags & EVENT_FILE_FL_RECORDED_TGID) {
409 tracing_stop_tgid_record();
Chunyu Hu7685ab62017-09-05 13:36:46 +0800410 clear_bit(EVENT_FILE_FL_RECORDED_TGID_BIT, &file->flags);
Joel Fernandesd914ba32017-06-26 19:01:55 -0700411 }
412
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400413 call->class->reg(call, TRACE_REG_UNREGISTER, file);
Steven Rostedtfd994982009-02-28 02:41:25 -0500414 }
Tom Zanussi3baa5e42013-06-29 00:08:07 -0500415 /* If in SOFT_MODE, just set the SOFT_DISABLE_BIT, else clear it */
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400416 if (file->flags & EVENT_FILE_FL_SOFT_MODE)
417 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
Tom Zanussi3baa5e42013-06-29 00:08:07 -0500418 else
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400419 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
Steven Rostedtfd994982009-02-28 02:41:25 -0500420 break;
421 case 1:
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400422 /*
423 * When soft_disable is set and enable is set, we want to
424 * register the tracepoint for the event, but leave the event
425 * as is. That means, if the event was already enabled, we do
426 * nothing (but set SOFT_MODE). If the event is disabled, we
427 * set SOFT_DISABLED before enabling the event tracepoint, so
428 * it still seems to be disabled.
429 */
430 if (!soft_disable)
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400431 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
Masami Hiramatsu1cf4c072013-05-09 14:44:29 +0900432 else {
433 if (atomic_inc_return(&file->sm_ref) > 1)
434 break;
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400435 set_bit(EVENT_FILE_FL_SOFT_MODE_BIT, &file->flags);
Masami Hiramatsu1cf4c072013-05-09 14:44:29 +0900436 }
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400437
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400438 if (!(file->flags & EVENT_FILE_FL_ENABLED)) {
Joel Fernandesd914ba32017-06-26 19:01:55 -0700439 bool cmd = false, tgid = false;
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400440
441 /* Keep the event disabled, when going to SOFT_MODE. */
442 if (soft_disable)
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400443 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &file->flags);
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400444
Steven Rostedt (Red Hat)983f9382015-09-30 09:42:05 -0400445 if (tr->trace_flags & TRACE_ITER_RECORD_CMD) {
Joel Fernandesd914ba32017-06-26 19:01:55 -0700446 cmd = true;
Li Zefane870e9a2010-07-02 11:07:32 +0800447 tracing_start_cmdline_record();
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400448 set_bit(EVENT_FILE_FL_RECORDED_CMD_BIT, &file->flags);
Li Zefane870e9a2010-07-02 11:07:32 +0800449 }
Joel Fernandesd914ba32017-06-26 19:01:55 -0700450
451 if (tr->trace_flags & TRACE_ITER_RECORD_TGID) {
452 tgid = true;
453 tracing_start_tgid_record();
454 set_bit(EVENT_FILE_FL_RECORDED_TGID_BIT, &file->flags);
455 }
456
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400457 ret = call->class->reg(call, TRACE_REG_REGISTER, file);
Li Zefan3b8e4272009-12-08 11:14:52 +0800458 if (ret) {
Joel Fernandesd914ba32017-06-26 19:01:55 -0700459 if (cmd)
460 tracing_stop_cmdline_record();
461 if (tgid)
462 tracing_stop_tgid_record();
Li Zefan3b8e4272009-12-08 11:14:52 +0800463 pr_info("event trace: Could not enable event "
Steven Rostedt (Red Hat)687fcc42015-05-13 14:20:14 -0400464 "%s\n", trace_event_name(call));
Li Zefan3b8e4272009-12-08 11:14:52 +0800465 break;
466 }
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400467 set_bit(EVENT_FILE_FL_ENABLED_BIT, &file->flags);
Steven Rostedt (Red Hat)575380d2013-03-04 23:05:12 -0500468
469 /* WAS_ENABLED gets set but never cleared. */
Steven Rostedt (VMware)065e63f2017-08-31 17:03:47 -0400470 set_bit(EVENT_FILE_FL_WAS_ENABLED_BIT, &file->flags);
Steven Rostedtfd994982009-02-28 02:41:25 -0500471 }
Steven Rostedtfd994982009-02-28 02:41:25 -0500472 break;
473 }
Li Zefan3b8e4272009-12-08 11:14:52 +0800474
Steven Rostedt (Red Hat)0fc1b092016-05-03 17:15:43 -0400475 /* Enable or disable use of trace_buffered_event */
476 if ((file_flags & EVENT_FILE_FL_SOFT_DISABLED) !=
477 (file->flags & EVENT_FILE_FL_SOFT_DISABLED)) {
478 if (file->flags & EVENT_FILE_FL_SOFT_DISABLED)
479 trace_buffered_event_enable();
480 else
481 trace_buffered_event_disable();
482 }
483
Li Zefan3b8e4272009-12-08 11:14:52 +0800484 return ret;
Steven Rostedtfd994982009-02-28 02:41:25 -0500485}
486
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400487int trace_event_enable_disable(struct trace_event_file *file,
Tom Zanussi85f2b082013-10-24 08:59:24 -0500488 int enable, int soft_disable)
489{
490 return __ftrace_event_enable_disable(file, enable, soft_disable);
491}
492
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400493static int ftrace_event_enable_disable(struct trace_event_file *file,
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -0400494 int enable)
495{
496 return __ftrace_event_enable_disable(file, enable, 0);
497}
498
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400499static void ftrace_clear_events(struct trace_array *tr)
Zhaolei0e907c92009-05-25 18:13:59 +0800500{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400501 struct trace_event_file *file;
Zhaolei0e907c92009-05-25 18:13:59 +0800502
503 mutex_lock(&event_mutex);
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400504 list_for_each_entry(file, &tr->events, list) {
505 ftrace_event_enable_disable(file, 0);
Zhaolei0e907c92009-05-25 18:13:59 +0800506 }
507 mutex_unlock(&event_mutex);
508}
509
Steven Rostedtc37775d2016-04-13 16:59:18 -0400510static void
511event_filter_pid_sched_process_exit(void *data, struct task_struct *task)
512{
513 struct trace_pid_list *pid_list;
514 struct trace_array *tr = data;
515
Joel Fernandes (Google)da25a672018-08-02 19:34:07 -0700516 pid_list = rcu_dereference_raw(tr->filtered_pids);
Steven Rostedt4e267db2016-04-14 07:38:13 -0400517 trace_filter_add_remove_task(pid_list, NULL, task);
Steven Rostedtc37775d2016-04-13 16:59:18 -0400518}
519
520static void
521event_filter_pid_sched_process_fork(void *data,
522 struct task_struct *self,
523 struct task_struct *task)
524{
525 struct trace_pid_list *pid_list;
526 struct trace_array *tr = data;
527
528 pid_list = rcu_dereference_sched(tr->filtered_pids);
Steven Rostedt4e267db2016-04-14 07:38:13 -0400529 trace_filter_add_remove_task(pid_list, self, task);
Steven Rostedtc37775d2016-04-13 16:59:18 -0400530}
531
532void trace_event_follow_fork(struct trace_array *tr, bool enable)
533{
534 if (enable) {
535 register_trace_prio_sched_process_fork(event_filter_pid_sched_process_fork,
536 tr, INT_MIN);
537 register_trace_prio_sched_process_exit(event_filter_pid_sched_process_exit,
538 tr, INT_MAX);
539 } else {
540 unregister_trace_sched_process_fork(event_filter_pid_sched_process_fork,
541 tr);
542 unregister_trace_sched_process_exit(event_filter_pid_sched_process_exit,
543 tr);
544 }
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400545}
546
547static void
Linus Torvalds22402cd2015-11-06 13:30:20 -0800548event_filter_pid_sched_switch_probe_pre(void *data, bool preempt,
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400549 struct task_struct *prev, struct task_struct *next)
550{
551 struct trace_array *tr = data;
552 struct trace_pid_list *pid_list;
553
554 pid_list = rcu_dereference_sched(tr->filtered_pids);
555
556 this_cpu_write(tr->trace_buffer.data->ignore_pid,
Steven Rostedt4e267db2016-04-14 07:38:13 -0400557 trace_ignore_this_task(pid_list, prev) &&
558 trace_ignore_this_task(pid_list, next));
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400559}
560
561static void
Linus Torvalds22402cd2015-11-06 13:30:20 -0800562event_filter_pid_sched_switch_probe_post(void *data, bool preempt,
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400563 struct task_struct *prev, struct task_struct *next)
564{
565 struct trace_array *tr = data;
566 struct trace_pid_list *pid_list;
567
568 pid_list = rcu_dereference_sched(tr->filtered_pids);
569
570 this_cpu_write(tr->trace_buffer.data->ignore_pid,
Steven Rostedt4e267db2016-04-14 07:38:13 -0400571 trace_ignore_this_task(pid_list, next));
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400572}
573
574static void
575event_filter_pid_sched_wakeup_probe_pre(void *data, struct task_struct *task)
576{
577 struct trace_array *tr = data;
578 struct trace_pid_list *pid_list;
579
580 /* Nothing to do if we are already tracing */
581 if (!this_cpu_read(tr->trace_buffer.data->ignore_pid))
582 return;
583
584 pid_list = rcu_dereference_sched(tr->filtered_pids);
585
586 this_cpu_write(tr->trace_buffer.data->ignore_pid,
Steven Rostedt4e267db2016-04-14 07:38:13 -0400587 trace_ignore_this_task(pid_list, task));
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400588}
589
590static void
591event_filter_pid_sched_wakeup_probe_post(void *data, struct task_struct *task)
592{
593 struct trace_array *tr = data;
594 struct trace_pid_list *pid_list;
595
596 /* Nothing to do if we are not tracing */
597 if (this_cpu_read(tr->trace_buffer.data->ignore_pid))
598 return;
599
600 pid_list = rcu_dereference_sched(tr->filtered_pids);
601
602 /* Set tracing if current is enabled */
603 this_cpu_write(tr->trace_buffer.data->ignore_pid,
Steven Rostedt4e267db2016-04-14 07:38:13 -0400604 trace_ignore_this_task(pid_list, current));
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400605}
606
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -0400607static void __ftrace_clear_event_pids(struct trace_array *tr)
608{
609 struct trace_pid_list *pid_list;
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400610 struct trace_event_file *file;
611 int cpu;
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -0400612
613 pid_list = rcu_dereference_protected(tr->filtered_pids,
614 lockdep_is_held(&event_mutex));
615 if (!pid_list)
616 return;
617
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400618 unregister_trace_sched_switch(event_filter_pid_sched_switch_probe_pre, tr);
619 unregister_trace_sched_switch(event_filter_pid_sched_switch_probe_post, tr);
620
621 unregister_trace_sched_wakeup(event_filter_pid_sched_wakeup_probe_pre, tr);
622 unregister_trace_sched_wakeup(event_filter_pid_sched_wakeup_probe_post, tr);
623
Steven Rostedt (Red Hat)0f72e372015-12-01 16:08:05 -0500624 unregister_trace_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_pre, tr);
625 unregister_trace_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_post, tr);
626
627 unregister_trace_sched_waking(event_filter_pid_sched_wakeup_probe_pre, tr);
628 unregister_trace_sched_waking(event_filter_pid_sched_wakeup_probe_post, tr);
629
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -0400630 list_for_each_entry(file, &tr->events, list) {
631 clear_bit(EVENT_FILE_FL_PID_FILTER_BIT, &file->flags);
632 }
633
634 for_each_possible_cpu(cpu)
635 per_cpu_ptr(tr->trace_buffer.data, cpu)->ignore_pid = false;
636
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -0400637 rcu_assign_pointer(tr->filtered_pids, NULL);
638
639 /* Wait till all users are no longer using pid filtering */
Steven Rostedt (VMware)e0a568d2018-08-09 15:31:48 -0400640 tracepoint_synchronize_unregister();
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -0400641
Steven Rostedt (Red Hat)76c813e2016-04-21 11:35:30 -0400642 trace_free_pid_list(pid_list);
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -0400643}
644
645static void ftrace_clear_event_pids(struct trace_array *tr)
646{
647 mutex_lock(&event_mutex);
648 __ftrace_clear_event_pids(tr);
649 mutex_unlock(&event_mutex);
650}
651
Steven Rostedte9dbfae2011-07-05 11:36:06 -0400652static void __put_system(struct event_subsystem *system)
653{
654 struct event_filter *filter = system->filter;
655
Steven Rostedt6e94a782013-06-27 10:58:31 -0400656 WARN_ON_ONCE(system_refcount(system) == 0);
657 if (system_refcount_dec(system))
Steven Rostedte9dbfae2011-07-05 11:36:06 -0400658 return;
659
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400660 list_del(&system->list);
661
Steven Rostedte9dbfae2011-07-05 11:36:06 -0400662 if (filter) {
663 kfree(filter->filter_string);
664 kfree(filter);
665 }
Rasmus Villemoes79ac6ef2015-09-09 23:24:01 +0200666 kfree_const(system->name);
Steven Rostedte9dbfae2011-07-05 11:36:06 -0400667 kfree(system);
668}
669
670static void __get_system(struct event_subsystem *system)
671{
Steven Rostedt6e94a782013-06-27 10:58:31 -0400672 WARN_ON_ONCE(system_refcount(system) == 0);
673 system_refcount_inc(system);
Steven Rostedte9dbfae2011-07-05 11:36:06 -0400674}
675
Steven Rostedt (Red Hat)7967b3e2015-05-13 14:59:40 -0400676static void __get_system_dir(struct trace_subsystem_dir *dir)
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400677{
678 WARN_ON_ONCE(dir->ref_count == 0);
679 dir->ref_count++;
680 __get_system(dir->subsystem);
681}
682
Steven Rostedt (Red Hat)7967b3e2015-05-13 14:59:40 -0400683static void __put_system_dir(struct trace_subsystem_dir *dir)
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400684{
685 WARN_ON_ONCE(dir->ref_count == 0);
686 /* If the subsystem is about to be freed, the dir must be too */
Steven Rostedt6e94a782013-06-27 10:58:31 -0400687 WARN_ON_ONCE(system_refcount(dir->subsystem) == 1 && dir->ref_count != 1);
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400688
689 __put_system(dir->subsystem);
690 if (!--dir->ref_count)
691 kfree(dir);
692}
693
Steven Rostedt (Red Hat)7967b3e2015-05-13 14:59:40 -0400694static void put_system(struct trace_subsystem_dir *dir)
Steven Rostedte9dbfae2011-07-05 11:36:06 -0400695{
696 mutex_lock(&event_mutex);
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400697 __put_system_dir(dir);
Steven Rostedte9dbfae2011-07-05 11:36:06 -0400698 mutex_unlock(&event_mutex);
699}
700
Steven Rostedt (Red Hat)7967b3e2015-05-13 14:59:40 -0400701static void remove_subsystem(struct trace_subsystem_dir *dir)
Oleg Nesterovf6a84bd2013-07-26 19:25:47 +0200702{
703 if (!dir)
704 return;
705
706 if (!--dir->nr_events) {
Steven Rostedt (Red Hat)8434dc92015-01-20 12:13:40 -0500707 tracefs_remove_recursive(dir->entry);
Oleg Nesterovf6a84bd2013-07-26 19:25:47 +0200708 list_del(&dir->list);
709 __put_system_dir(dir);
710 }
711}
712
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400713static void remove_event_file_dir(struct trace_event_file *file)
Oleg Nesterovf6a84bd2013-07-26 19:25:47 +0200714{
Oleg Nesterovbf682c32013-07-28 20:35:27 +0200715 struct dentry *dir = file->dir;
716 struct dentry *child;
717
718 if (dir) {
719 spin_lock(&dir->d_lock); /* probably unneeded */
Al Viro946e51f2014-10-26 19:19:16 -0400720 list_for_each_entry(child, &dir->d_subdirs, d_child) {
David Howells7682c912015-03-17 22:26:16 +0000721 if (d_really_is_positive(child)) /* probably unneeded */
722 d_inode(child)->i_private = NULL;
Oleg Nesterovbf682c32013-07-28 20:35:27 +0200723 }
724 spin_unlock(&dir->d_lock);
725
Steven Rostedt (Red Hat)8434dc92015-01-20 12:13:40 -0500726 tracefs_remove_recursive(dir);
Oleg Nesterovbf682c32013-07-28 20:35:27 +0200727 }
728
Oleg Nesterovf6a84bd2013-07-26 19:25:47 +0200729 list_del(&file->list);
Oleg Nesterovf6a84bd2013-07-26 19:25:47 +0200730 remove_subsystem(file->system);
Oleg Nesterov2448e342014-07-11 21:06:38 +0200731 free_event_filter(file->filter);
Oleg Nesterovf6a84bd2013-07-26 19:25:47 +0200732 kmem_cache_free(file_cachep, file);
733}
734
Li Zefan8f31bfe2009-05-08 10:31:42 +0800735/*
736 * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events.
737 */
Steven Rostedt (Red Hat)2a6c24a2013-07-02 14:48:23 -0400738static int
739__ftrace_set_clr_event_nolock(struct trace_array *tr, const char *match,
740 const char *sub, const char *event, int set)
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500741{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400742 struct trace_event_file *file;
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400743 struct trace_event_call *call;
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400744 const char *name;
Steven Rostedt29f93942009-05-08 16:06:47 -0400745 int ret = -EINVAL;
Steven Rostedt (Red Hat)989a0a32016-11-28 13:54:57 -0500746 int eret = 0;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500747
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400748 list_for_each_entry(file, &tr->events, list) {
749
750 call = file->event_call;
Steven Rostedt (Red Hat)687fcc42015-05-13 14:20:14 -0400751 name = trace_event_name(call);
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500752
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400753 if (!name || !call->class || !call->class->reg)
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500754 continue;
Steven Rostedt1473e442009-02-24 14:15:08 -0500755
Steven Rostedt9b637762012-05-10 15:55:43 -0400756 if (call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)
757 continue;
758
Steven Rostedtb628b3e2009-02-27 23:32:58 -0500759 if (match &&
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400760 strcmp(match, name) != 0 &&
Steven Rostedt8f082012010-04-20 10:47:33 -0400761 strcmp(match, call->class->system) != 0)
Steven Rostedtb628b3e2009-02-27 23:32:58 -0500762 continue;
763
Steven Rostedt8f082012010-04-20 10:47:33 -0400764 if (sub && strcmp(sub, call->class->system) != 0)
Steven Rostedtb628b3e2009-02-27 23:32:58 -0500765 continue;
766
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -0400767 if (event && strcmp(event, name) != 0)
Steven Rostedt1473e442009-02-24 14:15:08 -0500768 continue;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500769
Steven Rostedt (Red Hat)989a0a32016-11-28 13:54:57 -0500770 ret = ftrace_event_enable_disable(file, set);
Steven Rostedtfd994982009-02-28 02:41:25 -0500771
Steven Rostedt (Red Hat)989a0a32016-11-28 13:54:57 -0500772 /*
773 * Save the first error and return that. Some events
774 * may still have been enabled, but let the user
775 * know that something went wrong.
776 */
777 if (ret && !eret)
778 eret = ret;
779
780 ret = eret;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500781 }
Steven Rostedt (Red Hat)2a6c24a2013-07-02 14:48:23 -0400782
783 return ret;
784}
785
786static int __ftrace_set_clr_event(struct trace_array *tr, const char *match,
787 const char *sub, const char *event, int set)
788{
789 int ret;
790
791 mutex_lock(&event_mutex);
792 ret = __ftrace_set_clr_event_nolock(tr, match, sub, event, set);
Steven Rostedt11a241a2009-03-02 11:49:04 -0500793 mutex_unlock(&event_mutex);
794
Steven Rostedtb628b3e2009-02-27 23:32:58 -0500795 return ret;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500796}
797
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400798static int ftrace_set_clr_event(struct trace_array *tr, char *buf, int set)
Li Zefan8f31bfe2009-05-08 10:31:42 +0800799{
800 char *event = NULL, *sub = NULL, *match;
Joonsoo Kim84fce9d2015-04-16 13:44:44 +0900801 int ret;
Li Zefan8f31bfe2009-05-08 10:31:42 +0800802
803 /*
804 * The buf format can be <subsystem>:<event-name>
805 * *:<event-name> means any event by that name.
806 * :<event-name> is the same.
807 *
808 * <subsystem>:* means all events in that subsystem
809 * <subsystem>: means the same.
810 *
811 * <name> (no ':') means all events in a subsystem with
812 * the name <name> or any event that matches <name>
813 */
814
815 match = strsep(&buf, ":");
816 if (buf) {
817 sub = match;
818 event = buf;
819 match = NULL;
820
821 if (!strlen(sub) || strcmp(sub, "*") == 0)
822 sub = NULL;
823 if (!strlen(event) || strcmp(event, "*") == 0)
824 event = NULL;
825 }
826
Joonsoo Kim84fce9d2015-04-16 13:44:44 +0900827 ret = __ftrace_set_clr_event(tr, match, sub, event, set);
828
829 /* Put back the colon to allow this to be called again */
830 if (buf)
831 *(buf - 1) = ':';
832
833 return ret;
Li Zefan8f31bfe2009-05-08 10:31:42 +0800834}
Divya Indif45d1222019-03-20 11:28:51 -0700835EXPORT_SYMBOL_GPL(ftrace_set_clr_event);
Li Zefan8f31bfe2009-05-08 10:31:42 +0800836
Steven Rostedt4671c792009-05-08 16:27:41 -0400837/**
838 * trace_set_clr_event - enable or disable an event
839 * @system: system name to match (NULL for any system)
840 * @event: event name to match (NULL for all events, within system)
841 * @set: 1 to enable, 0 to disable
842 *
843 * This is a way for other parts of the kernel to enable or disable
844 * event recording.
845 *
846 * Returns 0 on success, -EINVAL if the parameters do not match any
847 * registered events.
848 */
849int trace_set_clr_event(const char *system, const char *event, int set)
850{
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400851 struct trace_array *tr = top_trace_array();
852
Yoshihiro YUNOMAEdc81e5e2014-06-06 07:35:17 +0900853 if (!tr)
854 return -ENODEV;
855
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400856 return __ftrace_set_clr_event(tr, NULL, system, event, set);
Steven Rostedt4671c792009-05-08 16:27:41 -0400857}
Yuanhan Liu56355b82010-11-08 14:05:12 +0800858EXPORT_SYMBOL_GPL(trace_set_clr_event);
Steven Rostedt4671c792009-05-08 16:27:41 -0400859
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500860/* 128 should be much more than enough */
861#define EVENT_BUF_SIZE 127
862
863static ssize_t
864ftrace_event_write(struct file *file, const char __user *ubuf,
865 size_t cnt, loff_t *ppos)
866{
jolsa@redhat.com48966362009-09-11 17:29:28 +0200867 struct trace_parser parser;
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400868 struct seq_file *m = file->private_data;
869 struct trace_array *tr = m->private;
Li Zefan4ba79782009-09-22 13:52:20 +0800870 ssize_t read, ret;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500871
Li Zefan4ba79782009-09-22 13:52:20 +0800872 if (!cnt)
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500873 return 0;
874
Steven Rostedt1852fcc2009-03-11 14:33:00 -0400875 ret = tracing_update_buffers();
876 if (ret < 0)
877 return ret;
878
jolsa@redhat.com48966362009-09-11 17:29:28 +0200879 if (trace_parser_get_init(&parser, EVENT_BUF_SIZE + 1))
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500880 return -ENOMEM;
881
jolsa@redhat.com48966362009-09-11 17:29:28 +0200882 read = trace_get_user(&parser, ubuf, cnt, ppos);
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500883
Li Zefan4ba79782009-09-22 13:52:20 +0800884 if (read >= 0 && trace_parser_loaded((&parser))) {
jolsa@redhat.com48966362009-09-11 17:29:28 +0200885 int set = 1;
886
887 if (*parser.buffer == '!')
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500888 set = 0;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500889
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400890 ret = ftrace_set_clr_event(tr, parser.buffer + !set, set);
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500891 if (ret)
jolsa@redhat.com48966362009-09-11 17:29:28 +0200892 goto out_put;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500893 }
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500894
895 ret = read;
896
jolsa@redhat.com48966362009-09-11 17:29:28 +0200897 out_put:
898 trace_parser_put(&parser);
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500899
900 return ret;
901}
902
903static void *
904t_next(struct seq_file *m, void *v, loff_t *pos)
905{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400906 struct trace_event_file *file = v;
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400907 struct trace_event_call *call;
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400908 struct trace_array *tr = m->private;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500909
910 (*pos)++;
911
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400912 list_for_each_entry_continue(file, &tr->events, list) {
913 call = file->event_call;
Steven Rostedt40e26812009-03-10 11:32:40 -0400914 /*
915 * The ftrace subsystem is for showing formats only.
916 * They can not be enabled or disabled via the event files.
917 */
Steven Rostedt (Red Hat)d0454372016-02-24 09:04:24 -0500918 if (call->class && call->class->reg &&
919 !(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE))
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400920 return file;
Steven Rostedt40e26812009-03-10 11:32:40 -0400921 }
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500922
Li Zefan30bd39c2009-09-18 14:07:05 +0800923 return NULL;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500924}
925
926static void *t_start(struct seq_file *m, loff_t *pos)
927{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400928 struct trace_event_file *file;
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400929 struct trace_array *tr = m->private;
Li Zefane1c7e2a2009-06-24 09:52:29 +0800930 loff_t l;
931
Li Zefan20c89282009-05-06 10:33:45 +0800932 mutex_lock(&event_mutex);
Li Zefane1c7e2a2009-06-24 09:52:29 +0800933
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400934 file = list_entry(&tr->events, struct trace_event_file, list);
Li Zefane1c7e2a2009-06-24 09:52:29 +0800935 for (l = 0; l <= *pos; ) {
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400936 file = t_next(m, file, &l);
937 if (!file)
Li Zefane1c7e2a2009-06-24 09:52:29 +0800938 break;
939 }
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400940 return file;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500941}
942
943static void *
944s_next(struct seq_file *m, void *v, loff_t *pos)
945{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400946 struct trace_event_file *file = v;
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400947 struct trace_array *tr = m->private;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500948
949 (*pos)++;
950
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400951 list_for_each_entry_continue(file, &tr->events, list) {
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -0400952 if (file->flags & EVENT_FILE_FL_ENABLED)
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400953 return file;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500954 }
955
Li Zefan30bd39c2009-09-18 14:07:05 +0800956 return NULL;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500957}
958
959static void *s_start(struct seq_file *m, loff_t *pos)
960{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400961 struct trace_event_file *file;
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400962 struct trace_array *tr = m->private;
Li Zefane1c7e2a2009-06-24 09:52:29 +0800963 loff_t l;
964
Li Zefan20c89282009-05-06 10:33:45 +0800965 mutex_lock(&event_mutex);
Li Zefane1c7e2a2009-06-24 09:52:29 +0800966
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400967 file = list_entry(&tr->events, struct trace_event_file, list);
Li Zefane1c7e2a2009-06-24 09:52:29 +0800968 for (l = 0; l <= *pos; ) {
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400969 file = s_next(m, file, &l);
970 if (!file)
Li Zefane1c7e2a2009-06-24 09:52:29 +0800971 break;
972 }
Steven Rostedtae63b31e2012-05-03 23:09:03 -0400973 return file;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500974}
975
976static int t_show(struct seq_file *m, void *v)
977{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -0400978 struct trace_event_file *file = v;
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400979 struct trace_event_call *call = file->event_call;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500980
Steven Rostedt8f082012010-04-20 10:47:33 -0400981 if (strcmp(call->class->system, TRACE_SYSTEM) != 0)
982 seq_printf(m, "%s:", call->class->system);
Steven Rostedt (Red Hat)687fcc42015-05-13 14:20:14 -0400983 seq_printf(m, "%s\n", trace_event_name(call));
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500984
985 return 0;
986}
987
988static void t_stop(struct seq_file *m, void *p)
989{
Li Zefan20c89282009-05-06 10:33:45 +0800990 mutex_unlock(&event_mutex);
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500991}
992
Steven Rostedtf4d34a82016-04-13 16:27:49 -0400993static void *
994p_next(struct seq_file *m, void *v, loff_t *pos)
995{
996 struct trace_array *tr = m->private;
997 struct trace_pid_list *pid_list = rcu_dereference_sched(tr->filtered_pids);
Steven Rostedtf4d34a82016-04-13 16:27:49 -0400998
Steven Rostedt (Red Hat)5cc89762016-04-20 15:19:54 -0400999 return trace_pid_next(pid_list, v, pos);
Steven Rostedtf4d34a82016-04-13 16:27:49 -04001000}
1001
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001002static void *p_start(struct seq_file *m, loff_t *pos)
Steven Rostedt (Red Hat)fb662282015-10-26 03:45:22 -04001003 __acquires(RCU)
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001004{
1005 struct trace_pid_list *pid_list;
1006 struct trace_array *tr = m->private;
1007
1008 /*
1009 * Grab the mutex, to keep calls to p_next() having the same
1010 * tr->filtered_pids as p_start() has.
1011 * If we just passed the tr->filtered_pids around, then RCU would
1012 * have been enough, but doing that makes things more complex.
1013 */
1014 mutex_lock(&event_mutex);
1015 rcu_read_lock_sched();
1016
1017 pid_list = rcu_dereference_sched(tr->filtered_pids);
1018
Steven Rostedtf4d34a82016-04-13 16:27:49 -04001019 if (!pid_list)
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001020 return NULL;
1021
Steven Rostedt (Red Hat)5cc89762016-04-20 15:19:54 -04001022 return trace_pid_start(pid_list, pos);
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001023}
1024
1025static void p_stop(struct seq_file *m, void *p)
Steven Rostedt (Red Hat)fb662282015-10-26 03:45:22 -04001026 __releases(RCU)
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001027{
1028 rcu_read_unlock_sched();
1029 mutex_unlock(&event_mutex);
1030}
1031
Steven Rostedt1473e442009-02-24 14:15:08 -05001032static ssize_t
1033event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
1034 loff_t *ppos)
1035{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04001036 struct trace_event_file *file;
Oleg Nesterovbc6f6b02013-07-26 19:25:36 +02001037 unsigned long flags;
Tom Zanussia4390592013-06-29 00:08:04 -05001038 char buf[4] = "0";
Steven Rostedt1473e442009-02-24 14:15:08 -05001039
Oleg Nesterovbc6f6b02013-07-26 19:25:36 +02001040 mutex_lock(&event_mutex);
1041 file = event_file_data(filp);
1042 if (likely(file))
1043 flags = file->flags;
1044 mutex_unlock(&event_mutex);
1045
1046 if (!file)
1047 return -ENODEV;
1048
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -04001049 if (flags & EVENT_FILE_FL_ENABLED &&
1050 !(flags & EVENT_FILE_FL_SOFT_DISABLED))
Tom Zanussia4390592013-06-29 00:08:04 -05001051 strcpy(buf, "1");
1052
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -04001053 if (flags & EVENT_FILE_FL_SOFT_DISABLED ||
1054 flags & EVENT_FILE_FL_SOFT_MODE)
Tom Zanussia4390592013-06-29 00:08:04 -05001055 strcat(buf, "*");
1056
1057 strcat(buf, "\n");
Steven Rostedt1473e442009-02-24 14:15:08 -05001058
Steven Rostedt (Red Hat)417944c2013-03-12 13:26:18 -04001059 return simple_read_from_buffer(ubuf, cnt, ppos, buf, strlen(buf));
Steven Rostedt1473e442009-02-24 14:15:08 -05001060}
1061
1062static ssize_t
1063event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
1064 loff_t *ppos)
1065{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04001066 struct trace_event_file *file;
Steven Rostedt1473e442009-02-24 14:15:08 -05001067 unsigned long val;
1068 int ret;
1069
Peter Huewe22fe9b52011-06-07 21:58:27 +02001070 ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
1071 if (ret)
Steven Rostedt1473e442009-02-24 14:15:08 -05001072 return ret;
1073
Steven Rostedt1852fcc2009-03-11 14:33:00 -04001074 ret = tracing_update_buffers();
1075 if (ret < 0)
1076 return ret;
1077
Steven Rostedt1473e442009-02-24 14:15:08 -05001078 switch (val) {
1079 case 0:
Steven Rostedt1473e442009-02-24 14:15:08 -05001080 case 1:
Oleg Nesterovbc6f6b02013-07-26 19:25:36 +02001081 ret = -ENODEV;
Steven Rostedt11a241a2009-03-02 11:49:04 -05001082 mutex_lock(&event_mutex);
Oleg Nesterovbc6f6b02013-07-26 19:25:36 +02001083 file = event_file_data(filp);
1084 if (likely(file))
1085 ret = ftrace_event_enable_disable(file, val);
Steven Rostedt11a241a2009-03-02 11:49:04 -05001086 mutex_unlock(&event_mutex);
Steven Rostedt1473e442009-02-24 14:15:08 -05001087 break;
1088
1089 default:
1090 return -EINVAL;
1091 }
1092
1093 *ppos += cnt;
1094
Li Zefan3b8e4272009-12-08 11:14:52 +08001095 return ret ? ret : cnt;
Steven Rostedt1473e442009-02-24 14:15:08 -05001096}
1097
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001098static ssize_t
1099system_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
1100 loff_t *ppos)
1101{
Li Zefanc142b152009-05-08 10:32:05 +08001102 const char set_to_char[4] = { '?', '0', '1', 'X' };
Steven Rostedt (Red Hat)7967b3e2015-05-13 14:59:40 -04001103 struct trace_subsystem_dir *dir = filp->private_data;
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001104 struct event_subsystem *system = dir->subsystem;
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04001105 struct trace_event_call *call;
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04001106 struct trace_event_file *file;
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001107 struct trace_array *tr = dir->tr;
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001108 char buf[2];
Li Zefanc142b152009-05-08 10:32:05 +08001109 int set = 0;
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001110 int ret;
1111
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001112 mutex_lock(&event_mutex);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001113 list_for_each_entry(file, &tr->events, list) {
1114 call = file->event_call;
Steven Rostedt (Red Hat)687fcc42015-05-13 14:20:14 -04001115 if (!trace_event_name(call) || !call->class || !call->class->reg)
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001116 continue;
1117
Steven Rostedt40ee4df2011-07-05 14:32:51 -04001118 if (system && strcmp(call->class->system, system->name) != 0)
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001119 continue;
1120
1121 /*
1122 * We need to find out if all the events are set
1123 * or if all events or cleared, or if we have
1124 * a mixture.
1125 */
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -04001126 set |= (1 << !!(file->flags & EVENT_FILE_FL_ENABLED));
Li Zefanc142b152009-05-08 10:32:05 +08001127
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001128 /*
1129 * If we have a mixture, no need to look further.
1130 */
Li Zefanc142b152009-05-08 10:32:05 +08001131 if (set == 3)
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001132 break;
1133 }
1134 mutex_unlock(&event_mutex);
1135
Li Zefanc142b152009-05-08 10:32:05 +08001136 buf[0] = set_to_char[set];
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001137 buf[1] = '\n';
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001138
1139 ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
1140
1141 return ret;
1142}
1143
1144static ssize_t
1145system_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
1146 loff_t *ppos)
1147{
Steven Rostedt (Red Hat)7967b3e2015-05-13 14:59:40 -04001148 struct trace_subsystem_dir *dir = filp->private_data;
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001149 struct event_subsystem *system = dir->subsystem;
Steven Rostedt40ee4df2011-07-05 14:32:51 -04001150 const char *name = NULL;
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001151 unsigned long val;
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001152 ssize_t ret;
1153
Peter Huewe22fe9b52011-06-07 21:58:27 +02001154 ret = kstrtoul_from_user(ubuf, cnt, 10, &val);
1155 if (ret)
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001156 return ret;
1157
1158 ret = tracing_update_buffers();
1159 if (ret < 0)
1160 return ret;
1161
Li Zefan8f31bfe2009-05-08 10:31:42 +08001162 if (val != 0 && val != 1)
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001163 return -EINVAL;
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001164
Steven Rostedt40ee4df2011-07-05 14:32:51 -04001165 /*
1166 * Opening of "enable" adds a ref count to system,
1167 * so the name is safe to use.
1168 */
1169 if (system)
1170 name = system->name;
1171
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001172 ret = __ftrace_set_clr_event(dir->tr, NULL, name, NULL, val);
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001173 if (ret)
Li Zefan8f31bfe2009-05-08 10:31:42 +08001174 goto out;
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001175
1176 ret = cnt;
1177
Li Zefan8f31bfe2009-05-08 10:31:42 +08001178out:
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001179 *ppos += cnt;
1180
1181 return ret;
1182}
1183
Steven Rostedt2a37a3d2010-06-03 15:21:34 -04001184enum {
1185 FORMAT_HEADER = 1,
Li Zefan86397dc2010-08-17 13:53:06 +08001186 FORMAT_FIELD_SEPERATOR = 2,
1187 FORMAT_PRINTFMT = 3,
Steven Rostedt2a37a3d2010-06-03 15:21:34 -04001188};
1189
1190static void *f_next(struct seq_file *m, void *v, loff_t *pos)
Steven Rostedt981d0812009-03-02 13:53:59 -05001191{
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04001192 struct trace_event_call *call = event_file_data(m->private);
Li Zefan86397dc2010-08-17 13:53:06 +08001193 struct list_head *common_head = &ftrace_common_fields;
1194 struct list_head *head = trace_get_fields(call);
Oleg Nesterov7710b632013-07-18 20:47:10 +02001195 struct list_head *node = v;
Steven Rostedt981d0812009-03-02 13:53:59 -05001196
Steven Rostedt2a37a3d2010-06-03 15:21:34 -04001197 (*pos)++;
Lai Jiangshan5a65e952009-12-15 15:39:53 +08001198
Steven Rostedt2a37a3d2010-06-03 15:21:34 -04001199 switch ((unsigned long)v) {
1200 case FORMAT_HEADER:
Oleg Nesterov7710b632013-07-18 20:47:10 +02001201 node = common_head;
1202 break;
Li Zefan86397dc2010-08-17 13:53:06 +08001203
1204 case FORMAT_FIELD_SEPERATOR:
Oleg Nesterov7710b632013-07-18 20:47:10 +02001205 node = head;
1206 break;
Lai Jiangshan5a65e952009-12-15 15:39:53 +08001207
Steven Rostedt2a37a3d2010-06-03 15:21:34 -04001208 case FORMAT_PRINTFMT:
1209 /* all done */
1210 return NULL;
Lai Jiangshan5a65e952009-12-15 15:39:53 +08001211 }
1212
Oleg Nesterov7710b632013-07-18 20:47:10 +02001213 node = node->prev;
1214 if (node == common_head)
Li Zefan86397dc2010-08-17 13:53:06 +08001215 return (void *)FORMAT_FIELD_SEPERATOR;
Oleg Nesterov7710b632013-07-18 20:47:10 +02001216 else if (node == head)
Steven Rostedt2a37a3d2010-06-03 15:21:34 -04001217 return (void *)FORMAT_PRINTFMT;
Oleg Nesterov7710b632013-07-18 20:47:10 +02001218 else
1219 return node;
Steven Rostedt2a37a3d2010-06-03 15:21:34 -04001220}
1221
1222static int f_show(struct seq_file *m, void *v)
1223{
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04001224 struct trace_event_call *call = event_file_data(m->private);
Steven Rostedt2a37a3d2010-06-03 15:21:34 -04001225 struct ftrace_event_field *field;
1226 const char *array_descriptor;
1227
1228 switch ((unsigned long)v) {
1229 case FORMAT_HEADER:
Steven Rostedt (Red Hat)687fcc42015-05-13 14:20:14 -04001230 seq_printf(m, "name: %s\n", trace_event_name(call));
Steven Rostedt2a37a3d2010-06-03 15:21:34 -04001231 seq_printf(m, "ID: %d\n", call->event.type);
Rasmus Villemoesfa6f0cc2014-11-08 21:42:10 +01001232 seq_puts(m, "format:\n");
Li Zefan8728fe52010-05-24 16:22:49 +08001233 return 0;
1234
Li Zefan86397dc2010-08-17 13:53:06 +08001235 case FORMAT_FIELD_SEPERATOR:
1236 seq_putc(m, '\n');
1237 return 0;
1238
Steven Rostedt2a37a3d2010-06-03 15:21:34 -04001239 case FORMAT_PRINTFMT:
1240 seq_printf(m, "\nprint fmt: %s\n",
1241 call->print_fmt);
1242 return 0;
Steven Rostedt981d0812009-03-02 13:53:59 -05001243 }
1244
Oleg Nesterov7710b632013-07-18 20:47:10 +02001245 field = list_entry(v, struct ftrace_event_field, link);
Steven Rostedt2a37a3d2010-06-03 15:21:34 -04001246 /*
1247 * Smartly shows the array type(except dynamic array).
1248 * Normal:
1249 * field:TYPE VAR
1250 * If TYPE := TYPE[LEN], it is shown:
1251 * field:TYPE VAR[LEN]
1252 */
1253 array_descriptor = strchr(field->type, '[');
1254
Steven Rostedt (VMware)b6b27352018-12-20 13:20:07 -05001255 if (str_has_prefix(field->type, "__data_loc"))
Steven Rostedt2a37a3d2010-06-03 15:21:34 -04001256 array_descriptor = NULL;
1257
1258 if (!array_descriptor)
1259 seq_printf(m, "\tfield:%s %s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
1260 field->type, field->name, field->offset,
1261 field->size, !!field->is_signed);
1262 else
1263 seq_printf(m, "\tfield:%.*s %s%s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
1264 (int)(array_descriptor - field->type),
1265 field->type, field->name,
1266 array_descriptor, field->offset,
1267 field->size, !!field->is_signed);
1268
1269 return 0;
1270}
1271
Oleg Nesterov7710b632013-07-18 20:47:10 +02001272static void *f_start(struct seq_file *m, loff_t *pos)
1273{
1274 void *p = (void *)FORMAT_HEADER;
1275 loff_t l = 0;
1276
Oleg Nesterovc5a44a12013-07-26 19:25:43 +02001277 /* ->stop() is called even if ->start() fails */
1278 mutex_lock(&event_mutex);
1279 if (!event_file_data(m->private))
1280 return ERR_PTR(-ENODEV);
1281
Oleg Nesterov7710b632013-07-18 20:47:10 +02001282 while (l < *pos && p)
1283 p = f_next(m, p, &l);
1284
1285 return p;
1286}
1287
Steven Rostedt2a37a3d2010-06-03 15:21:34 -04001288static void f_stop(struct seq_file *m, void *p)
1289{
Oleg Nesterovc5a44a12013-07-26 19:25:43 +02001290 mutex_unlock(&event_mutex);
Steven Rostedt2a37a3d2010-06-03 15:21:34 -04001291}
1292
1293static const struct seq_operations trace_format_seq_ops = {
1294 .start = f_start,
1295 .next = f_next,
1296 .stop = f_stop,
1297 .show = f_show,
1298};
1299
1300static int trace_format_open(struct inode *inode, struct file *file)
1301{
Steven Rostedt2a37a3d2010-06-03 15:21:34 -04001302 struct seq_file *m;
1303 int ret;
1304
1305 ret = seq_open(file, &trace_format_seq_ops);
1306 if (ret < 0)
1307 return ret;
1308
1309 m = file->private_data;
Oleg Nesterovc5a44a12013-07-26 19:25:43 +02001310 m->private = file;
Steven Rostedt2a37a3d2010-06-03 15:21:34 -04001311
1312 return 0;
Steven Rostedt981d0812009-03-02 13:53:59 -05001313}
1314
Peter Zijlstra23725ae2009-03-19 20:26:13 +01001315static ssize_t
1316event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
1317{
Oleg Nesterov1a111262013-07-26 19:25:32 +02001318 int id = (long)event_file_data(filp);
Oleg Nesterovcd458ba2013-07-18 20:47:12 +02001319 char buf[32];
1320 int len;
Peter Zijlstra23725ae2009-03-19 20:26:13 +01001321
1322 if (*ppos)
1323 return 0;
1324
Oleg Nesterov1a111262013-07-26 19:25:32 +02001325 if (unlikely(!id))
1326 return -ENODEV;
1327
1328 len = sprintf(buf, "%d\n", id);
1329
Oleg Nesterovcd458ba2013-07-18 20:47:12 +02001330 return simple_read_from_buffer(ubuf, cnt, ppos, buf, len);
Peter Zijlstra23725ae2009-03-19 20:26:13 +01001331}
1332
Tom Zanussi7ce7e422009-03-22 03:31:04 -05001333static ssize_t
1334event_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
1335 loff_t *ppos)
1336{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04001337 struct trace_event_file *file;
Tom Zanussi7ce7e422009-03-22 03:31:04 -05001338 struct trace_seq *s;
Oleg Nesterove2912b02013-07-26 19:25:40 +02001339 int r = -ENODEV;
Tom Zanussi7ce7e422009-03-22 03:31:04 -05001340
1341 if (*ppos)
1342 return 0;
1343
1344 s = kmalloc(sizeof(*s), GFP_KERNEL);
Oleg Nesterove2912b02013-07-26 19:25:40 +02001345
Tom Zanussi7ce7e422009-03-22 03:31:04 -05001346 if (!s)
1347 return -ENOMEM;
1348
1349 trace_seq_init(s);
1350
Oleg Nesterove2912b02013-07-26 19:25:40 +02001351 mutex_lock(&event_mutex);
Tom Zanussif306cc82013-10-24 08:34:17 -05001352 file = event_file_data(filp);
1353 if (file)
1354 print_event_filter(file, s);
Oleg Nesterove2912b02013-07-26 19:25:40 +02001355 mutex_unlock(&event_mutex);
1356
Tom Zanussif306cc82013-10-24 08:34:17 -05001357 if (file)
Steven Rostedt (Red Hat)5ac483782014-11-14 15:49:41 -05001358 r = simple_read_from_buffer(ubuf, cnt, ppos,
1359 s->buffer, trace_seq_used(s));
Tom Zanussi7ce7e422009-03-22 03:31:04 -05001360
1361 kfree(s);
1362
1363 return r;
1364}
1365
1366static ssize_t
1367event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
1368 loff_t *ppos)
1369{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04001370 struct trace_event_file *file;
Tom Zanussi8b372562009-04-28 03:04:59 -05001371 char *buf;
Oleg Nesterove2912b02013-07-26 19:25:40 +02001372 int err = -ENODEV;
Tom Zanussi7ce7e422009-03-22 03:31:04 -05001373
Tom Zanussi8b372562009-04-28 03:04:59 -05001374 if (cnt >= PAGE_SIZE)
Tom Zanussi7ce7e422009-03-22 03:31:04 -05001375 return -EINVAL;
1376
Al Viro70f6cbb2015-12-24 00:13:10 -05001377 buf = memdup_user_nul(ubuf, cnt);
1378 if (IS_ERR(buf))
1379 return PTR_ERR(buf);
Tom Zanussi8b372562009-04-28 03:04:59 -05001380
Oleg Nesterove2912b02013-07-26 19:25:40 +02001381 mutex_lock(&event_mutex);
Tom Zanussif306cc82013-10-24 08:34:17 -05001382 file = event_file_data(filp);
1383 if (file)
1384 err = apply_event_filter(file, buf);
Oleg Nesterove2912b02013-07-26 19:25:40 +02001385 mutex_unlock(&event_mutex);
1386
Al Viro70f6cbb2015-12-24 00:13:10 -05001387 kfree(buf);
Tom Zanussi8b372562009-04-28 03:04:59 -05001388 if (err < 0)
Tom Zanussi7ce7e422009-03-22 03:31:04 -05001389 return err;
Tom Zanussi0a19e532009-04-13 03:17:50 -05001390
Tom Zanussi7ce7e422009-03-22 03:31:04 -05001391 *ppos += cnt;
1392
1393 return cnt;
1394}
1395
Steven Rostedte9dbfae2011-07-05 11:36:06 -04001396static LIST_HEAD(event_subsystems);
1397
1398static int subsystem_open(struct inode *inode, struct file *filp)
1399{
1400 struct event_subsystem *system = NULL;
Steven Rostedt (Red Hat)7967b3e2015-05-13 14:59:40 -04001401 struct trace_subsystem_dir *dir = NULL; /* Initialize for gcc */
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001402 struct trace_array *tr;
Steven Rostedte9dbfae2011-07-05 11:36:06 -04001403 int ret;
1404
Geyslan G. Bemd6d35232013-11-06 16:02:51 -03001405 if (tracing_is_disabled())
1406 return -ENODEV;
1407
Steven Rostedte9dbfae2011-07-05 11:36:06 -04001408 /* Make sure the system still exists */
1409 mutex_lock(&event_mutex);
Steven Rostedt (VMware)12ecef02017-09-21 16:22:49 -04001410 mutex_lock(&trace_types_lock);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001411 list_for_each_entry(tr, &ftrace_trace_arrays, list) {
1412 list_for_each_entry(dir, &tr->systems, list) {
1413 if (dir == inode->i_private) {
1414 /* Don't open systems with no events */
1415 if (dir->nr_events) {
1416 __get_system_dir(dir);
1417 system = dir->subsystem;
1418 }
1419 goto exit_loop;
Steven Rostedte9dbfae2011-07-05 11:36:06 -04001420 }
Steven Rostedte9dbfae2011-07-05 11:36:06 -04001421 }
1422 }
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001423 exit_loop:
Alexander Z Lama8227412013-07-01 19:37:54 -07001424 mutex_unlock(&trace_types_lock);
Steven Rostedt (VMware)12ecef02017-09-21 16:22:49 -04001425 mutex_unlock(&event_mutex);
Steven Rostedte9dbfae2011-07-05 11:36:06 -04001426
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001427 if (!system)
Steven Rostedte9dbfae2011-07-05 11:36:06 -04001428 return -ENODEV;
1429
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001430 /* Some versions of gcc think dir can be uninitialized here */
1431 WARN_ON(!dir);
1432
Steven Rostedt (Red Hat)8e2e2fa2013-07-02 15:30:53 -04001433 /* Still need to increment the ref count of the system */
1434 if (trace_array_get(tr) < 0) {
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001435 put_system(dir);
Steven Rostedt (Red Hat)8e2e2fa2013-07-02 15:30:53 -04001436 return -ENODEV;
1437 }
1438
1439 ret = tracing_open_generic(inode, filp);
1440 if (ret < 0) {
1441 trace_array_put(tr);
1442 put_system(dir);
1443 }
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001444
1445 return ret;
1446}
1447
1448static int system_tr_open(struct inode *inode, struct file *filp)
1449{
Steven Rostedt (Red Hat)7967b3e2015-05-13 14:59:40 -04001450 struct trace_subsystem_dir *dir;
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001451 struct trace_array *tr = inode->i_private;
1452 int ret;
1453
Geyslan G. Bemd6d35232013-11-06 16:02:51 -03001454 if (tracing_is_disabled())
1455 return -ENODEV;
1456
Steven Rostedt (Red Hat)8e2e2fa2013-07-02 15:30:53 -04001457 if (trace_array_get(tr) < 0)
1458 return -ENODEV;
1459
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001460 /* Make a temporary dir that has no system but points to tr */
1461 dir = kzalloc(sizeof(*dir), GFP_KERNEL);
Steven Rostedt (Red Hat)8e2e2fa2013-07-02 15:30:53 -04001462 if (!dir) {
1463 trace_array_put(tr);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001464 return -ENOMEM;
Steven Rostedt (Red Hat)8e2e2fa2013-07-02 15:30:53 -04001465 }
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001466
1467 dir->tr = tr;
1468
1469 ret = tracing_open_generic(inode, filp);
Steven Rostedt (Red Hat)8e2e2fa2013-07-02 15:30:53 -04001470 if (ret < 0) {
1471 trace_array_put(tr);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001472 kfree(dir);
Geyslan G. Bemd6d35232013-11-06 16:02:51 -03001473 return ret;
Steven Rostedt (Red Hat)8e2e2fa2013-07-02 15:30:53 -04001474 }
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001475
1476 filp->private_data = dir;
Steven Rostedte9dbfae2011-07-05 11:36:06 -04001477
Geyslan G. Bemd6d35232013-11-06 16:02:51 -03001478 return 0;
Steven Rostedte9dbfae2011-07-05 11:36:06 -04001479}
1480
1481static int subsystem_release(struct inode *inode, struct file *file)
1482{
Steven Rostedt (Red Hat)7967b3e2015-05-13 14:59:40 -04001483 struct trace_subsystem_dir *dir = file->private_data;
Steven Rostedte9dbfae2011-07-05 11:36:06 -04001484
Steven Rostedt (Red Hat)8e2e2fa2013-07-02 15:30:53 -04001485 trace_array_put(dir->tr);
1486
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001487 /*
1488 * If dir->subsystem is NULL, then this is a temporary
1489 * descriptor that was made for a trace_array to enable
1490 * all subsystems.
1491 */
1492 if (dir->subsystem)
1493 put_system(dir);
1494 else
1495 kfree(dir);
Steven Rostedte9dbfae2011-07-05 11:36:06 -04001496
1497 return 0;
1498}
1499
Tom Zanussicfb180f2009-03-22 03:31:17 -05001500static ssize_t
1501subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
1502 loff_t *ppos)
1503{
Steven Rostedt (Red Hat)7967b3e2015-05-13 14:59:40 -04001504 struct trace_subsystem_dir *dir = filp->private_data;
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001505 struct event_subsystem *system = dir->subsystem;
Tom Zanussicfb180f2009-03-22 03:31:17 -05001506 struct trace_seq *s;
1507 int r;
1508
1509 if (*ppos)
1510 return 0;
1511
1512 s = kmalloc(sizeof(*s), GFP_KERNEL);
1513 if (!s)
1514 return -ENOMEM;
1515
1516 trace_seq_init(s);
1517
Tom Zanussi8b372562009-04-28 03:04:59 -05001518 print_subsystem_event_filter(system, s);
Steven Rostedt (Red Hat)5ac483782014-11-14 15:49:41 -05001519 r = simple_read_from_buffer(ubuf, cnt, ppos,
1520 s->buffer, trace_seq_used(s));
Tom Zanussicfb180f2009-03-22 03:31:17 -05001521
1522 kfree(s);
1523
1524 return r;
1525}
1526
1527static ssize_t
1528subsystem_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
1529 loff_t *ppos)
1530{
Steven Rostedt (Red Hat)7967b3e2015-05-13 14:59:40 -04001531 struct trace_subsystem_dir *dir = filp->private_data;
Tom Zanussi8b372562009-04-28 03:04:59 -05001532 char *buf;
Tom Zanussicfb180f2009-03-22 03:31:17 -05001533 int err;
1534
Tom Zanussi8b372562009-04-28 03:04:59 -05001535 if (cnt >= PAGE_SIZE)
Tom Zanussicfb180f2009-03-22 03:31:17 -05001536 return -EINVAL;
1537
Al Viro70f6cbb2015-12-24 00:13:10 -05001538 buf = memdup_user_nul(ubuf, cnt);
1539 if (IS_ERR(buf))
1540 return PTR_ERR(buf);
Tom Zanussicfb180f2009-03-22 03:31:17 -05001541
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001542 err = apply_subsystem_event_filter(dir, buf);
Al Viro70f6cbb2015-12-24 00:13:10 -05001543 kfree(buf);
Tom Zanussi8b372562009-04-28 03:04:59 -05001544 if (err < 0)
Li Zefan44e9c8b2009-04-11 15:55:28 +08001545 return err;
Tom Zanussicfb180f2009-03-22 03:31:17 -05001546
1547 *ppos += cnt;
1548
1549 return cnt;
1550}
1551
Steven Rostedtd1b182a2009-04-15 16:53:47 -04001552static ssize_t
1553show_header(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
1554{
1555 int (*func)(struct trace_seq *s) = filp->private_data;
1556 struct trace_seq *s;
1557 int r;
1558
1559 if (*ppos)
1560 return 0;
1561
1562 s = kmalloc(sizeof(*s), GFP_KERNEL);
1563 if (!s)
1564 return -ENOMEM;
1565
1566 trace_seq_init(s);
1567
1568 func(s);
Steven Rostedt (Red Hat)5ac483782014-11-14 15:49:41 -05001569 r = simple_read_from_buffer(ubuf, cnt, ppos,
1570 s->buffer, trace_seq_used(s));
Steven Rostedtd1b182a2009-04-15 16:53:47 -04001571
1572 kfree(s);
1573
1574 return r;
1575}
1576
Steven Rostedt (Red Hat)8ca532a2015-10-21 15:27:36 -04001577static void ignore_task_cpu(void *data)
1578{
1579 struct trace_array *tr = data;
1580 struct trace_pid_list *pid_list;
1581
1582 /*
1583 * This function is called by on_each_cpu() while the
1584 * event_mutex is held.
1585 */
1586 pid_list = rcu_dereference_protected(tr->filtered_pids,
1587 mutex_is_locked(&event_mutex));
1588
1589 this_cpu_write(tr->trace_buffer.data->ignore_pid,
Steven Rostedt4e267db2016-04-14 07:38:13 -04001590 trace_ignore_this_task(pid_list, current));
Steven Rostedt (Red Hat)8ca532a2015-10-21 15:27:36 -04001591}
1592
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001593static ssize_t
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -04001594ftrace_event_pid_write(struct file *filp, const char __user *ubuf,
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001595 size_t cnt, loff_t *ppos)
1596{
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -04001597 struct seq_file *m = filp->private_data;
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001598 struct trace_array *tr = m->private;
1599 struct trace_pid_list *filtered_pids = NULL;
Steven Rostedtf4d34a82016-04-13 16:27:49 -04001600 struct trace_pid_list *pid_list;
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -04001601 struct trace_event_file *file;
Steven Rostedt (Red Hat)76c813e2016-04-21 11:35:30 -04001602 ssize_t ret;
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001603
1604 if (!cnt)
1605 return 0;
1606
1607 ret = tracing_update_buffers();
1608 if (ret < 0)
1609 return ret;
1610
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001611 mutex_lock(&event_mutex);
Steven Rostedt (Red Hat)76c813e2016-04-21 11:35:30 -04001612
Steven Rostedtf4d34a82016-04-13 16:27:49 -04001613 filtered_pids = rcu_dereference_protected(tr->filtered_pids,
1614 lockdep_is_held(&event_mutex));
1615
Steven Rostedt (Red Hat)76c813e2016-04-21 11:35:30 -04001616 ret = trace_pid_write(filtered_pids, &pid_list, ubuf, cnt);
1617 if (ret < 0)
Steven Rostedtf4d34a82016-04-13 16:27:49 -04001618 goto out;
Steven Rostedtf4d34a82016-04-13 16:27:49 -04001619
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001620 rcu_assign_pointer(tr->filtered_pids, pid_list);
1621
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -04001622 list_for_each_entry(file, &tr->events, list) {
1623 set_bit(EVENT_FILE_FL_PID_FILTER_BIT, &file->flags);
1624 }
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001625
1626 if (filtered_pids) {
Steven Rostedt (VMware)e0a568d2018-08-09 15:31:48 -04001627 tracepoint_synchronize_unregister();
Steven Rostedt (Red Hat)76c813e2016-04-21 11:35:30 -04001628 trace_free_pid_list(filtered_pids);
1629 } else if (pid_list) {
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -04001630 /*
1631 * Register a probe that is called before all other probes
1632 * to set ignore_pid if next or prev do not match.
1633 * Register a probe this is called after all other probes
1634 * to only keep ignore_pid set if next pid matches.
1635 */
1636 register_trace_prio_sched_switch(event_filter_pid_sched_switch_probe_pre,
1637 tr, INT_MAX);
1638 register_trace_prio_sched_switch(event_filter_pid_sched_switch_probe_post,
1639 tr, 0);
1640
1641 register_trace_prio_sched_wakeup(event_filter_pid_sched_wakeup_probe_pre,
1642 tr, INT_MAX);
1643 register_trace_prio_sched_wakeup(event_filter_pid_sched_wakeup_probe_post,
1644 tr, 0);
Steven Rostedt (Red Hat)0f72e372015-12-01 16:08:05 -05001645
1646 register_trace_prio_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_pre,
1647 tr, INT_MAX);
1648 register_trace_prio_sched_wakeup_new(event_filter_pid_sched_wakeup_probe_post,
1649 tr, 0);
1650
1651 register_trace_prio_sched_waking(event_filter_pid_sched_wakeup_probe_pre,
1652 tr, INT_MAX);
1653 register_trace_prio_sched_waking(event_filter_pid_sched_wakeup_probe_post,
1654 tr, 0);
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001655 }
1656
Steven Rostedt (Red Hat)799fd442015-11-02 13:08:26 -05001657 /*
1658 * Ignoring of pids is done at task switch. But we have to
1659 * check for those tasks that are currently running.
1660 * Always do this in case a pid was appended or removed.
1661 */
1662 on_each_cpu(ignore_task_cpu, tr, 1);
1663
Steven Rostedtf4d34a82016-04-13 16:27:49 -04001664 out:
Steven Rostedt (Red Hat)3fdaf802015-09-25 12:58:44 -04001665 mutex_unlock(&event_mutex);
1666
Steven Rostedt (Red Hat)76c813e2016-04-21 11:35:30 -04001667 if (ret > 0)
1668 *ppos += ret;
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001669
1670 return ret;
1671}
1672
Steven Rostedt15075ca2012-05-03 14:57:28 -04001673static int ftrace_event_avail_open(struct inode *inode, struct file *file);
1674static int ftrace_event_set_open(struct inode *inode, struct file *file);
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001675static int ftrace_event_set_pid_open(struct inode *inode, struct file *file);
Alexander Z Lamf77d09a2013-07-18 11:18:44 -07001676static int ftrace_event_release(struct inode *inode, struct file *file);
Steven Rostedt15075ca2012-05-03 14:57:28 -04001677
Steven Rostedtb77e38a2009-02-24 10:21:36 -05001678static const struct seq_operations show_event_seq_ops = {
1679 .start = t_start,
1680 .next = t_next,
1681 .show = t_show,
1682 .stop = t_stop,
1683};
1684
1685static const struct seq_operations show_set_event_seq_ops = {
1686 .start = s_start,
1687 .next = s_next,
1688 .show = t_show,
1689 .stop = t_stop,
1690};
1691
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001692static const struct seq_operations show_set_pid_seq_ops = {
1693 .start = p_start,
1694 .next = p_next,
Steven Rostedt (Red Hat)5cc89762016-04-20 15:19:54 -04001695 .show = trace_pid_show,
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001696 .stop = p_stop,
1697};
1698
Steven Rostedt2314c4a2009-03-10 12:04:02 -04001699static const struct file_operations ftrace_avail_fops = {
Steven Rostedt15075ca2012-05-03 14:57:28 -04001700 .open = ftrace_event_avail_open,
Steven Rostedt2314c4a2009-03-10 12:04:02 -04001701 .read = seq_read,
1702 .llseek = seq_lseek,
1703 .release = seq_release,
1704};
1705
Steven Rostedtb77e38a2009-02-24 10:21:36 -05001706static const struct file_operations ftrace_set_event_fops = {
Steven Rostedt15075ca2012-05-03 14:57:28 -04001707 .open = ftrace_event_set_open,
Steven Rostedtb77e38a2009-02-24 10:21:36 -05001708 .read = seq_read,
1709 .write = ftrace_event_write,
1710 .llseek = seq_lseek,
Alexander Z Lamf77d09a2013-07-18 11:18:44 -07001711 .release = ftrace_event_release,
Steven Rostedtb77e38a2009-02-24 10:21:36 -05001712};
1713
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001714static const struct file_operations ftrace_set_event_pid_fops = {
1715 .open = ftrace_event_set_pid_open,
1716 .read = seq_read,
1717 .write = ftrace_event_pid_write,
1718 .llseek = seq_lseek,
1719 .release = ftrace_event_release,
1720};
1721
Steven Rostedt1473e442009-02-24 14:15:08 -05001722static const struct file_operations ftrace_enable_fops = {
Oleg Nesterovbf682c32013-07-28 20:35:27 +02001723 .open = tracing_open_generic,
Steven Rostedt1473e442009-02-24 14:15:08 -05001724 .read = event_enable_read,
1725 .write = event_enable_write,
Arnd Bergmann6038f372010-08-15 18:52:59 +02001726 .llseek = default_llseek,
Steven Rostedt1473e442009-02-24 14:15:08 -05001727};
1728
Steven Rostedt981d0812009-03-02 13:53:59 -05001729static const struct file_operations ftrace_event_format_fops = {
Steven Rostedt2a37a3d2010-06-03 15:21:34 -04001730 .open = trace_format_open,
1731 .read = seq_read,
1732 .llseek = seq_lseek,
1733 .release = seq_release,
Steven Rostedt981d0812009-03-02 13:53:59 -05001734};
1735
Peter Zijlstra23725ae2009-03-19 20:26:13 +01001736static const struct file_operations ftrace_event_id_fops = {
Peter Zijlstra23725ae2009-03-19 20:26:13 +01001737 .read = event_id_read,
Arnd Bergmann6038f372010-08-15 18:52:59 +02001738 .llseek = default_llseek,
Peter Zijlstra23725ae2009-03-19 20:26:13 +01001739};
1740
Tom Zanussi7ce7e422009-03-22 03:31:04 -05001741static const struct file_operations ftrace_event_filter_fops = {
1742 .open = tracing_open_generic,
1743 .read = event_filter_read,
1744 .write = event_filter_write,
Arnd Bergmann6038f372010-08-15 18:52:59 +02001745 .llseek = default_llseek,
Tom Zanussi7ce7e422009-03-22 03:31:04 -05001746};
1747
Tom Zanussicfb180f2009-03-22 03:31:17 -05001748static const struct file_operations ftrace_subsystem_filter_fops = {
Steven Rostedte9dbfae2011-07-05 11:36:06 -04001749 .open = subsystem_open,
Tom Zanussicfb180f2009-03-22 03:31:17 -05001750 .read = subsystem_filter_read,
1751 .write = subsystem_filter_write,
Arnd Bergmann6038f372010-08-15 18:52:59 +02001752 .llseek = default_llseek,
Steven Rostedte9dbfae2011-07-05 11:36:06 -04001753 .release = subsystem_release,
Tom Zanussicfb180f2009-03-22 03:31:17 -05001754};
1755
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001756static const struct file_operations ftrace_system_enable_fops = {
Steven Rostedt40ee4df2011-07-05 14:32:51 -04001757 .open = subsystem_open,
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001758 .read = system_enable_read,
1759 .write = system_enable_write,
Arnd Bergmann6038f372010-08-15 18:52:59 +02001760 .llseek = default_llseek,
Steven Rostedt40ee4df2011-07-05 14:32:51 -04001761 .release = subsystem_release,
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001762};
1763
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001764static const struct file_operations ftrace_tr_enable_fops = {
1765 .open = system_tr_open,
1766 .read = system_enable_read,
1767 .write = system_enable_write,
1768 .llseek = default_llseek,
1769 .release = subsystem_release,
1770};
1771
Steven Rostedtd1b182a2009-04-15 16:53:47 -04001772static const struct file_operations ftrace_show_header_fops = {
1773 .open = tracing_open_generic,
1774 .read = show_header,
Arnd Bergmann6038f372010-08-15 18:52:59 +02001775 .llseek = default_llseek,
Steven Rostedtd1b182a2009-04-15 16:53:47 -04001776};
1777
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001778static int
1779ftrace_event_open(struct inode *inode, struct file *file,
1780 const struct seq_operations *seq_ops)
Steven Rostedt1473e442009-02-24 14:15:08 -05001781{
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001782 struct seq_file *m;
1783 int ret;
Steven Rostedt1473e442009-02-24 14:15:08 -05001784
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001785 ret = seq_open(file, seq_ops);
1786 if (ret < 0)
1787 return ret;
1788 m = file->private_data;
1789 /* copy tr over to seq ops */
1790 m->private = inode->i_private;
Steven Rostedt1473e442009-02-24 14:15:08 -05001791
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001792 return ret;
Steven Rostedt1473e442009-02-24 14:15:08 -05001793}
1794
Alexander Z Lamf77d09a2013-07-18 11:18:44 -07001795static int ftrace_event_release(struct inode *inode, struct file *file)
1796{
1797 struct trace_array *tr = inode->i_private;
1798
1799 trace_array_put(tr);
1800
1801 return seq_release(inode, file);
1802}
1803
Steven Rostedt15075ca2012-05-03 14:57:28 -04001804static int
1805ftrace_event_avail_open(struct inode *inode, struct file *file)
1806{
1807 const struct seq_operations *seq_ops = &show_event_seq_ops;
1808
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001809 return ftrace_event_open(inode, file, seq_ops);
Steven Rostedt15075ca2012-05-03 14:57:28 -04001810}
1811
1812static int
1813ftrace_event_set_open(struct inode *inode, struct file *file)
1814{
1815 const struct seq_operations *seq_ops = &show_set_event_seq_ops;
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001816 struct trace_array *tr = inode->i_private;
Alexander Z Lamf77d09a2013-07-18 11:18:44 -07001817 int ret;
1818
1819 if (trace_array_get(tr) < 0)
1820 return -ENODEV;
Steven Rostedt15075ca2012-05-03 14:57:28 -04001821
1822 if ((file->f_mode & FMODE_WRITE) &&
1823 (file->f_flags & O_TRUNC))
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001824 ftrace_clear_events(tr);
Steven Rostedt15075ca2012-05-03 14:57:28 -04001825
Alexander Z Lamf77d09a2013-07-18 11:18:44 -07001826 ret = ftrace_event_open(inode, file, seq_ops);
1827 if (ret < 0)
1828 trace_array_put(tr);
1829 return ret;
Steven Rostedt15075ca2012-05-03 14:57:28 -04001830}
1831
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04001832static int
1833ftrace_event_set_pid_open(struct inode *inode, struct file *file)
1834{
1835 const struct seq_operations *seq_ops = &show_set_pid_seq_ops;
1836 struct trace_array *tr = inode->i_private;
1837 int ret;
1838
1839 if (trace_array_get(tr) < 0)
1840 return -ENODEV;
1841
1842 if ((file->f_mode & FMODE_WRITE) &&
1843 (file->f_flags & O_TRUNC))
1844 ftrace_clear_event_pids(tr);
1845
1846 ret = ftrace_event_open(inode, file, seq_ops);
1847 if (ret < 0)
1848 trace_array_put(tr);
1849 return ret;
1850}
1851
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001852static struct event_subsystem *
1853create_new_subsystem(const char *name)
Steven Rostedt6ecc2d12009-02-27 21:33:02 -05001854{
1855 struct event_subsystem *system;
Steven Rostedt6ecc2d12009-02-27 21:33:02 -05001856
1857 /* need to create new entry */
1858 system = kmalloc(sizeof(*system), GFP_KERNEL);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001859 if (!system)
1860 return NULL;
Steven Rostedt6ecc2d12009-02-27 21:33:02 -05001861
Steven Rostedte9dbfae2011-07-05 11:36:06 -04001862 system->ref_count = 1;
Steven Rostedt6e94a782013-06-27 10:58:31 -04001863
1864 /* Only allocate if dynamic (kprobes and modules) */
Rasmus Villemoes79ac6ef2015-09-09 23:24:01 +02001865 system->name = kstrdup_const(name, GFP_KERNEL);
1866 if (!system->name)
1867 goto out_free;
Steven Rostedt6ecc2d12009-02-27 21:33:02 -05001868
Tom Zanussi30e673b2009-04-28 03:04:47 -05001869 system->filter = NULL;
Tom Zanussicfb180f2009-03-22 03:31:17 -05001870
Tom Zanussi8b372562009-04-28 03:04:59 -05001871 system->filter = kzalloc(sizeof(struct event_filter), GFP_KERNEL);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001872 if (!system->filter)
1873 goto out_free;
1874
1875 list_add(&system->list, &event_subsystems);
1876
1877 return system;
1878
1879 out_free:
Rasmus Villemoes79ac6ef2015-09-09 23:24:01 +02001880 kfree_const(system->name);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001881 kfree(system);
1882 return NULL;
1883}
1884
1885static struct dentry *
1886event_subsystem_dir(struct trace_array *tr, const char *name,
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04001887 struct trace_event_file *file, struct dentry *parent)
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001888{
Steven Rostedt (Red Hat)7967b3e2015-05-13 14:59:40 -04001889 struct trace_subsystem_dir *dir;
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001890 struct event_subsystem *system;
1891 struct dentry *entry;
1892
1893 /* First see if we did not already create this dir */
1894 list_for_each_entry(dir, &tr->systems, list) {
1895 system = dir->subsystem;
1896 if (strcmp(system->name, name) == 0) {
1897 dir->nr_events++;
1898 file->system = dir;
1899 return dir->entry;
1900 }
Tom Zanussi8b372562009-04-28 03:04:59 -05001901 }
1902
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001903 /* Now see if the system itself exists. */
1904 list_for_each_entry(system, &event_subsystems, list) {
1905 if (strcmp(system->name, name) == 0)
1906 break;
1907 }
1908 /* Reset system variable when not found */
1909 if (&system->list == &event_subsystems)
1910 system = NULL;
1911
1912 dir = kmalloc(sizeof(*dir), GFP_KERNEL);
1913 if (!dir)
1914 goto out_fail;
1915
1916 if (!system) {
1917 system = create_new_subsystem(name);
1918 if (!system)
1919 goto out_free;
1920 } else
1921 __get_system(system);
1922
Steven Rostedt (Red Hat)8434dc92015-01-20 12:13:40 -05001923 dir->entry = tracefs_create_dir(name, parent);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001924 if (!dir->entry) {
Fabian Frederick3448bac2014-06-07 13:43:08 +02001925 pr_warn("Failed to create system directory %s\n", name);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001926 __put_system(system);
1927 goto out_free;
1928 }
1929
1930 dir->tr = tr;
1931 dir->ref_count = 1;
1932 dir->nr_events = 1;
1933 dir->subsystem = system;
1934 file->system = dir;
1935
Steven Rostedt (Red Hat)8434dc92015-01-20 12:13:40 -05001936 entry = tracefs_create_file("filter", 0644, dir->entry, dir,
Tom Zanussie1112b42009-03-31 00:48:49 -05001937 &ftrace_subsystem_filter_fops);
Tom Zanussi8b372562009-04-28 03:04:59 -05001938 if (!entry) {
1939 kfree(system->filter);
1940 system->filter = NULL;
Steven Rostedt (Red Hat)8434dc92015-01-20 12:13:40 -05001941 pr_warn("Could not create tracefs '%s/filter' entry\n", name);
Tom Zanussi8b372562009-04-28 03:04:59 -05001942 }
Tom Zanussie1112b42009-03-31 00:48:49 -05001943
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001944 trace_create_file("enable", 0644, dir->entry, dir,
Frederic Weisbeckerf3f3f002009-09-24 15:27:41 +02001945 &ftrace_system_enable_fops);
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001946
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001947 list_add(&dir->list, &tr->systems);
1948
1949 return dir->entry;
1950
1951 out_free:
1952 kfree(dir);
1953 out_fail:
1954 /* Only print this message if failed on memory allocation */
1955 if (!dir || !system)
Fabian Frederick3448bac2014-06-07 13:43:08 +02001956 pr_warn("No memory to create event subsystem %s\n", name);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001957 return NULL;
Steven Rostedt6ecc2d12009-02-27 21:33:02 -05001958}
1959
Steven Rostedt1473e442009-02-24 14:15:08 -05001960static int
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04001961event_create_dir(struct dentry *parent, struct trace_event_file *file)
Steven Rostedt1473e442009-02-24 14:15:08 -05001962{
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04001963 struct trace_event_call *call = file->event_call;
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001964 struct trace_array *tr = file->tr;
Steven Rostedt2e33af02010-04-22 10:35:55 -04001965 struct list_head *head;
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001966 struct dentry *d_events;
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -04001967 const char *name;
Steven Rostedtfd994982009-02-28 02:41:25 -05001968 int ret;
Steven Rostedt1473e442009-02-24 14:15:08 -05001969
Steven Rostedt6ecc2d12009-02-27 21:33:02 -05001970 /*
1971 * If the trace point header did not define TRACE_SYSTEM
1972 * then the system would be called "TRACE_SYSTEM".
1973 */
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001974 if (strcmp(call->class->system, TRACE_SYSTEM) != 0) {
1975 d_events = event_subsystem_dir(tr, call->class->system, file, parent);
1976 if (!d_events)
1977 return -ENOMEM;
1978 } else
1979 d_events = parent;
Steven Rostedt6ecc2d12009-02-27 21:33:02 -05001980
Steven Rostedt (Red Hat)687fcc42015-05-13 14:20:14 -04001981 name = trace_event_name(call);
Steven Rostedt (Red Hat)8434dc92015-01-20 12:13:40 -05001982 file->dir = tracefs_create_dir(name, d_events);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001983 if (!file->dir) {
Steven Rostedt (Red Hat)8434dc92015-01-20 12:13:40 -05001984 pr_warn("Could not create tracefs '%s' directory\n", name);
Steven Rostedt1473e442009-02-24 14:15:08 -05001985 return -1;
1986 }
1987
Steven Rostedt9b637762012-05-10 15:55:43 -04001988 if (call->class->reg && !(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE))
Steven Rostedtae63b31e2012-05-03 23:09:03 -04001989 trace_create_file("enable", 0644, file->dir, file,
Oleg Nesterov620a30e2013-07-31 19:31:35 +02001990 &ftrace_enable_fops);
Steven Rostedt1473e442009-02-24 14:15:08 -05001991
Steven Rostedt22392912010-04-21 12:27:06 -04001992#ifdef CONFIG_PERF_EVENTS
Steven Rostedta1d0ce82010-06-08 11:22:06 -04001993 if (call->event.type && call->class->reg)
Oleg Nesterov1a111262013-07-26 19:25:32 +02001994 trace_create_file("id", 0444, file->dir,
Oleg Nesterov620a30e2013-07-31 19:31:35 +02001995 (void *)(long)call->event.type,
1996 &ftrace_event_id_fops);
Steven Rostedt22392912010-04-21 12:27:06 -04001997#endif
Peter Zijlstra23725ae2009-03-19 20:26:13 +01001998
Li Zefanc9d932c2010-05-24 16:24:28 +08001999 /*
2000 * Other events may have the same class. Only update
2001 * the fields if they are not already defined.
2002 */
2003 head = trace_get_fields(call);
2004 if (list_empty(head)) {
2005 ret = call->class->define_fields(call);
2006 if (ret < 0) {
Fabian Frederick3448bac2014-06-07 13:43:08 +02002007 pr_warn("Could not initialize trace point events/%s\n",
2008 name);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002009 return -1;
Tom Zanussicf027f62009-03-22 03:30:39 -05002010 }
2011 }
2012
Chunyu Hu854145e2016-05-03 19:34:34 +08002013 /*
2014 * Only event directories that can be enabled should have
Steven Rostedt (VMware)5d948c82018-05-09 09:48:41 -04002015 * triggers or filters.
Chunyu Hu854145e2016-05-03 19:34:34 +08002016 */
Steven Rostedt (VMware)5d948c82018-05-09 09:48:41 -04002017 if (!(call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)) {
2018 trace_create_file("filter", 0644, file->dir, file,
2019 &ftrace_event_filter_fops);
2020
Chunyu Hu854145e2016-05-03 19:34:34 +08002021 trace_create_file("trigger", 0644, file->dir, file,
2022 &event_trigger_fops);
Steven Rostedt (VMware)5d948c82018-05-09 09:48:41 -04002023 }
Tom Zanussi85f2b082013-10-24 08:59:24 -05002024
Tom Zanussi7ef224d2016-03-03 12:54:42 -06002025#ifdef CONFIG_HIST_TRIGGERS
2026 trace_create_file("hist", 0444, file->dir, file,
2027 &event_hist_fops);
2028#endif
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002029 trace_create_file("format", 0444, file->dir, call,
Oleg Nesterov620a30e2013-07-31 19:31:35 +02002030 &ftrace_event_format_fops);
Steven Rostedtfd994982009-02-28 02:41:25 -05002031
Steven Rostedt1473e442009-02-24 14:15:08 -05002032 return 0;
2033}
2034
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002035static void remove_event_from_tracers(struct trace_event_call *call)
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002036{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04002037 struct trace_event_file *file;
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002038 struct trace_array *tr;
2039
2040 do_for_each_event_file_safe(tr, file) {
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002041 if (file->event_call != call)
2042 continue;
2043
Oleg Nesterovf6a84bd2013-07-26 19:25:47 +02002044 remove_event_file_dir(file);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002045 /*
2046 * The do_for_each_event_file_safe() is
2047 * a double loop. After finding the call for this
2048 * trace_array, we use break to jump to the next
2049 * trace_array.
2050 */
2051 break;
2052 } while_for_each_event_file();
2053}
2054
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002055static void event_remove(struct trace_event_call *call)
Ezequiel Garcia87819152012-09-12 11:47:57 -03002056{
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002057 struct trace_array *tr;
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04002058 struct trace_event_file *file;
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002059
2060 do_for_each_event_file(tr, file) {
2061 if (file->event_call != call)
2062 continue;
Steven Rostedt (VMware)065e63f2017-08-31 17:03:47 -04002063
2064 if (file->flags & EVENT_FILE_FL_WAS_ENABLED)
2065 tr->clear_trace = true;
2066
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002067 ftrace_event_enable_disable(file, 0);
2068 /*
2069 * The do_for_each_event_file() is
2070 * a double loop. After finding the call for this
2071 * trace_array, we use break to jump to the next
2072 * trace_array.
2073 */
2074 break;
2075 } while_for_each_event_file();
2076
Ezequiel Garcia87819152012-09-12 11:47:57 -03002077 if (call->event.funcs)
Steven Rostedt (Red Hat)9023c932015-05-05 09:39:12 -04002078 __unregister_trace_event(&call->event);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002079 remove_event_from_tracers(call);
Ezequiel Garcia87819152012-09-12 11:47:57 -03002080 list_del(&call->list);
2081}
2082
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002083static int event_init(struct trace_event_call *call)
Ezequiel Garcia87819152012-09-12 11:47:57 -03002084{
2085 int ret = 0;
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -04002086 const char *name;
Ezequiel Garcia87819152012-09-12 11:47:57 -03002087
Steven Rostedt (Red Hat)687fcc42015-05-13 14:20:14 -04002088 name = trace_event_name(call);
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -04002089 if (WARN_ON(!name))
Ezequiel Garcia87819152012-09-12 11:47:57 -03002090 return -EINVAL;
2091
2092 if (call->class->raw_init) {
2093 ret = call->class->raw_init(call);
2094 if (ret < 0 && ret != -ENOSYS)
Fabian Frederick3448bac2014-06-07 13:43:08 +02002095 pr_warn("Could not initialize trace events/%s\n", name);
Ezequiel Garcia87819152012-09-12 11:47:57 -03002096 }
2097
2098 return ret;
2099}
2100
Li Zefan67ead0a2010-05-24 16:25:13 +08002101static int
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002102__register_event(struct trace_event_call *call, struct module *mod)
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04002103{
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04002104 int ret;
Steven Rostedt6d723732009-04-10 14:53:50 -04002105
Ezequiel Garcia87819152012-09-12 11:47:57 -03002106 ret = event_init(call);
2107 if (ret < 0)
2108 return ret;
Steven Rostedt701970b2009-04-24 23:11:22 -04002109
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002110 list_add(&call->list, &ftrace_events);
Li Zefan67ead0a2010-05-24 16:25:13 +08002111 call->mod = mod;
Masami Hiramatsu88f70d72009-09-25 11:20:54 -07002112
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002113 return 0;
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04002114}
2115
Jeremy Linton67ec0d82017-05-31 16:56:49 -05002116static char *eval_replace(char *ptr, struct trace_eval_map *map, int len)
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002117{
2118 int rlen;
2119 int elen;
2120
Jeremy Linton67ec0d82017-05-31 16:56:49 -05002121 /* Find the length of the eval value as a string */
Jeremy Linton00f4b652017-05-31 16:56:43 -05002122 elen = snprintf(ptr, 0, "%ld", map->eval_value);
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002123 /* Make sure there's enough room to replace the string with the value */
2124 if (len < elen)
2125 return NULL;
2126
Jeremy Linton00f4b652017-05-31 16:56:43 -05002127 snprintf(ptr, elen + 1, "%ld", map->eval_value);
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002128
2129 /* Get the rest of the string of ptr */
2130 rlen = strlen(ptr + len);
2131 memmove(ptr + elen, ptr + len, rlen);
2132 /* Make sure we end the new string */
2133 ptr[elen + rlen] = 0;
2134
2135 return ptr + elen;
2136}
2137
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002138static void update_event_printk(struct trace_event_call *call,
Jeremy Linton00f4b652017-05-31 16:56:43 -05002139 struct trace_eval_map *map)
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002140{
2141 char *ptr;
2142 int quote = 0;
Jeremy Linton00f4b652017-05-31 16:56:43 -05002143 int len = strlen(map->eval_string);
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002144
2145 for (ptr = call->print_fmt; *ptr; ptr++) {
2146 if (*ptr == '\\') {
2147 ptr++;
2148 /* paranoid */
2149 if (!*ptr)
2150 break;
2151 continue;
2152 }
2153 if (*ptr == '"') {
2154 quote ^= 1;
2155 continue;
2156 }
2157 if (quote)
2158 continue;
2159 if (isdigit(*ptr)) {
2160 /* skip numbers */
2161 do {
2162 ptr++;
2163 /* Check for alpha chars like ULL */
2164 } while (isalnum(*ptr));
Steven Rostedt (Red Hat)31938992015-04-17 10:27:57 -04002165 if (!*ptr)
2166 break;
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002167 /*
2168 * A number must have some kind of delimiter after
2169 * it, and we can ignore that too.
2170 */
2171 continue;
2172 }
2173 if (isalpha(*ptr) || *ptr == '_') {
Jeremy Linton00f4b652017-05-31 16:56:43 -05002174 if (strncmp(map->eval_string, ptr, len) == 0 &&
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002175 !isalnum(ptr[len]) && ptr[len] != '_') {
Jeremy Linton67ec0d82017-05-31 16:56:49 -05002176 ptr = eval_replace(ptr, map, len);
2177 /* enum/sizeof string smaller than value */
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002178 if (WARN_ON_ONCE(!ptr))
2179 return;
2180 /*
Jeremy Linton67ec0d82017-05-31 16:56:49 -05002181 * No need to decrement here, as eval_replace()
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002182 * returns the pointer to the character passed
Jeremy Linton67ec0d82017-05-31 16:56:49 -05002183 * the eval, and two evals can not be placed
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002184 * back to back without something in between.
2185 * We can skip that something in between.
2186 */
2187 continue;
2188 }
2189 skip_more:
2190 do {
2191 ptr++;
2192 } while (isalnum(*ptr) || *ptr == '_');
Steven Rostedt (Red Hat)31938992015-04-17 10:27:57 -04002193 if (!*ptr)
2194 break;
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002195 /*
2196 * If what comes after this variable is a '.' or
2197 * '->' then we can continue to ignore that string.
2198 */
2199 if (*ptr == '.' || (ptr[0] == '-' && ptr[1] == '>')) {
2200 ptr += *ptr == '.' ? 1 : 2;
Steven Rostedt (Red Hat)31938992015-04-17 10:27:57 -04002201 if (!*ptr)
2202 break;
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002203 goto skip_more;
2204 }
2205 /*
2206 * Once again, we can skip the delimiter that came
2207 * after the string.
2208 */
2209 continue;
2210 }
2211 }
2212}
2213
Jeremy Lintonf57a4142017-05-31 16:56:48 -05002214void trace_event_eval_update(struct trace_eval_map **map, int len)
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002215{
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002216 struct trace_event_call *call, *p;
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002217 const char *last_system = NULL;
Steven Rostedt (VMware)1ebe1ea2018-01-18 15:53:10 -05002218 bool first = false;
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002219 int last_i;
2220 int i;
2221
2222 down_write(&trace_event_sem);
2223 list_for_each_entry_safe(call, p, &ftrace_events, list) {
2224 /* events are usually grouped together with systems */
2225 if (!last_system || call->class->system != last_system) {
Steven Rostedt (VMware)1ebe1ea2018-01-18 15:53:10 -05002226 first = true;
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002227 last_i = 0;
2228 last_system = call->class->system;
2229 }
2230
Steven Rostedt (VMware)1ebe1ea2018-01-18 15:53:10 -05002231 /*
2232 * Since calls are grouped by systems, the likelyhood that the
2233 * next call in the iteration belongs to the same system as the
2234 * previous call is high. As an optimization, we skip seaching
2235 * for a map[] that matches the call's system if the last call
2236 * was from the same system. That's what last_i is for. If the
2237 * call has the same system as the previous call, then last_i
2238 * will be the index of the first map[] that has a matching
2239 * system.
2240 */
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002241 for (i = last_i; i < len; i++) {
2242 if (call->class->system == map[i]->system) {
2243 /* Save the first system if need be */
Steven Rostedt (VMware)1ebe1ea2018-01-18 15:53:10 -05002244 if (first) {
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002245 last_i = i;
Steven Rostedt (VMware)1ebe1ea2018-01-18 15:53:10 -05002246 first = false;
2247 }
Steven Rostedt (Red Hat)0c564a52015-03-24 17:58:09 -04002248 update_event_printk(call, map[i]);
2249 }
2250 }
2251 }
2252 up_write(&trace_event_sem);
2253}
2254
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04002255static struct trace_event_file *
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002256trace_create_new_event(struct trace_event_call *call,
Steven Rostedt (Red Hat)da511bf2013-05-09 15:00:07 -04002257 struct trace_array *tr)
2258{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04002259 struct trace_event_file *file;
Steven Rostedt (Red Hat)da511bf2013-05-09 15:00:07 -04002260
2261 file = kmem_cache_alloc(file_cachep, GFP_TRACE);
2262 if (!file)
2263 return NULL;
2264
2265 file->event_call = call;
2266 file->tr = tr;
2267 atomic_set(&file->sm_ref, 0);
Tom Zanussi85f2b082013-10-24 08:59:24 -05002268 atomic_set(&file->tm_ref, 0);
2269 INIT_LIST_HEAD(&file->triggers);
Steven Rostedt (Red Hat)da511bf2013-05-09 15:00:07 -04002270 list_add(&file->list, &tr->events);
2271
2272 return file;
2273}
2274
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002275/* Add an event to a trace directory */
2276static int
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002277__trace_add_new_event(struct trace_event_call *call, struct trace_array *tr)
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002278{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04002279 struct trace_event_file *file;
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002280
Steven Rostedt (Red Hat)da511bf2013-05-09 15:00:07 -04002281 file = trace_create_new_event(call, tr);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002282 if (!file)
2283 return -ENOMEM;
2284
Oleg Nesterov620a30e2013-07-31 19:31:35 +02002285 return event_create_dir(tr->event_dir, file);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002286}
2287
Steven Rostedt77248222013-02-27 16:28:06 -05002288/*
2289 * Just create a decriptor for early init. A descriptor is required
2290 * for enabling events at boot. We want to enable events before
2291 * the filesystem is initialized.
2292 */
2293static __init int
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002294__trace_early_add_new_event(struct trace_event_call *call,
Steven Rostedt77248222013-02-27 16:28:06 -05002295 struct trace_array *tr)
2296{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04002297 struct trace_event_file *file;
Steven Rostedt77248222013-02-27 16:28:06 -05002298
Steven Rostedt (Red Hat)da511bf2013-05-09 15:00:07 -04002299 file = trace_create_new_event(call, tr);
Steven Rostedt77248222013-02-27 16:28:06 -05002300 if (!file)
2301 return -ENOMEM;
2302
Steven Rostedt77248222013-02-27 16:28:06 -05002303 return 0;
2304}
2305
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002306struct ftrace_module_file_ops;
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002307static void __add_event_to_tracers(struct trace_event_call *call);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002308
Steven Rostedt (VMware)7e1413e2018-12-04 13:35:45 -05002309/* Add an additional event_call dynamically */
2310int trace_add_event_call(struct trace_event_call *call)
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04002311{
2312 int ret;
Masami Hiramatsufc800a12018-11-05 18:00:43 +09002313 lockdep_assert_held(&event_mutex);
2314
Steven Rostedt (VMware)12ecef02017-09-21 16:22:49 -04002315 mutex_lock(&trace_types_lock);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002316
2317 ret = __register_event(call, NULL);
2318 if (ret >= 0)
Oleg Nesterov779c5e32013-07-31 19:31:32 +02002319 __add_event_to_tracers(call);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002320
Alexander Z Lama8227412013-07-01 19:37:54 -07002321 mutex_unlock(&trace_types_lock);
Masami Hiramatsufc800a12018-11-05 18:00:43 +09002322 return ret;
2323}
2324
Masami Hiramatsu4fead8e2009-09-14 16:49:12 -04002325/*
Alexander Z Lama8227412013-07-01 19:37:54 -07002326 * Must be called under locking of trace_types_lock, event_mutex and
2327 * trace_event_sem.
Masami Hiramatsu4fead8e2009-09-14 16:49:12 -04002328 */
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002329static void __trace_remove_event_call(struct trace_event_call *call)
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04002330{
Ezequiel Garcia87819152012-09-12 11:47:57 -03002331 event_remove(call);
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04002332 trace_destroy_fields(call);
Oleg Nesterov57375742014-07-15 20:48:16 +02002333 free_event_filter(call->filter);
2334 call->filter = NULL;
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04002335}
2336
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002337static int probe_remove_event_call(struct trace_event_call *call)
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04002338{
Oleg Nesterov2816c552013-07-29 19:50:33 +02002339 struct trace_array *tr;
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04002340 struct trace_event_file *file;
Oleg Nesterov2816c552013-07-29 19:50:33 +02002341
2342#ifdef CONFIG_PERF_EVENTS
2343 if (call->perf_refcount)
2344 return -EBUSY;
2345#endif
2346 do_for_each_event_file(tr, file) {
2347 if (file->event_call != call)
2348 continue;
2349 /*
2350 * We can't rely on ftrace_event_enable_disable(enable => 0)
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -04002351 * we are going to do, EVENT_FILE_FL_SOFT_MODE can suppress
Oleg Nesterov2816c552013-07-29 19:50:33 +02002352 * TRACE_REG_UNREGISTER.
2353 */
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -04002354 if (file->flags & EVENT_FILE_FL_ENABLED)
Oleg Nesterov2816c552013-07-29 19:50:33 +02002355 return -EBUSY;
Steven Rostedt (Red Hat)2ba64032013-07-31 13:16:22 -04002356 /*
2357 * The do_for_each_event_file_safe() is
2358 * a double loop. After finding the call for this
2359 * trace_array, we use break to jump to the next
2360 * trace_array.
2361 */
Oleg Nesterov2816c552013-07-29 19:50:33 +02002362 break;
2363 } while_for_each_event_file();
2364
2365 __trace_remove_event_call(call);
2366
2367 return 0;
2368}
2369
Steven Rostedt (VMware)7e1413e2018-12-04 13:35:45 -05002370/* Remove an event_call */
2371int trace_remove_event_call(struct trace_event_call *call)
Masami Hiramatsufc800a12018-11-05 18:00:43 +09002372{
2373 int ret;
2374
2375 lockdep_assert_held(&event_mutex);
2376
2377 mutex_lock(&trace_types_lock);
2378 down_write(&trace_event_sem);
2379 ret = probe_remove_event_call(call);
2380 up_write(&trace_event_sem);
2381 mutex_unlock(&trace_types_lock);
2382
2383 return ret;
2384}
2385
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04002386#define for_each_event(event, start, end) \
2387 for (event = start; \
2388 (unsigned long)event < (unsigned long)end; \
2389 event++)
2390
2391#ifdef CONFIG_MODULES
2392
Steven Rostedt6d723732009-04-10 14:53:50 -04002393static void trace_module_add_events(struct module *mod)
2394{
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002395 struct trace_event_call **call, **start, **end;
Steven Rostedt6d723732009-04-10 14:53:50 -04002396
Steven Rostedt (Red Hat)45ab2812014-02-26 13:37:38 -05002397 if (!mod->num_trace_events)
2398 return;
2399
2400 /* Don't add infrastructure for mods without tracepoints */
2401 if (trace_module_has_bad_taint(mod)) {
2402 pr_err("%s: module has bad taint, not creating trace events\n",
2403 mod->name);
2404 return;
2405 }
2406
Steven Rostedt6d723732009-04-10 14:53:50 -04002407 start = mod->trace_events;
2408 end = mod->trace_events + mod->num_trace_events;
2409
Steven Rostedt6d723732009-04-10 14:53:50 -04002410 for_each_event(call, start, end) {
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002411 __register_event(*call, mod);
Oleg Nesterov779c5e32013-07-31 19:31:32 +02002412 __add_event_to_tracers(*call);
Steven Rostedt6d723732009-04-10 14:53:50 -04002413 }
2414}
2415
2416static void trace_module_remove_events(struct module *mod)
2417{
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002418 struct trace_event_call *call, *p;
Steven Rostedt6d723732009-04-10 14:53:50 -04002419
zhangwei(Jovi)52f6ad62013-03-11 15:14:03 +08002420 down_write(&trace_event_sem);
Steven Rostedt6d723732009-04-10 14:53:50 -04002421 list_for_each_entry_safe(call, p, &ftrace_events, list) {
Steven Rostedt (VMware)065e63f2017-08-31 17:03:47 -04002422 if (call->mod == mod)
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04002423 __trace_remove_event_call(call);
Steven Rostedt6d723732009-04-10 14:53:50 -04002424 }
zhangwei(Jovi)52f6ad62013-03-11 15:14:03 +08002425 up_write(&trace_event_sem);
Steven Rostedt9456f0f2009-05-06 21:54:09 -04002426
2427 /*
2428 * It is safest to reset the ring buffer if the module being unloaded
Steven Rostedt (Red Hat)873c6422013-03-04 23:26:06 -05002429 * registered any events that were used. The only worry is if
2430 * a new module gets loaded, and takes on the same id as the events
2431 * of this module. When printing out the buffer, traced events left
2432 * over from this module may be passed to the new module events and
2433 * unexpected results may occur.
Steven Rostedt9456f0f2009-05-06 21:54:09 -04002434 */
Steven Rostedt (VMware)065e63f2017-08-31 17:03:47 -04002435 tracing_reset_all_online_cpus();
Steven Rostedt6d723732009-04-10 14:53:50 -04002436}
2437
Steven Rostedt61f919a2009-04-14 18:22:32 -04002438static int trace_module_notify(struct notifier_block *self,
2439 unsigned long val, void *data)
Steven Rostedt6d723732009-04-10 14:53:50 -04002440{
2441 struct module *mod = data;
2442
2443 mutex_lock(&event_mutex);
Steven Rostedt (VMware)12ecef02017-09-21 16:22:49 -04002444 mutex_lock(&trace_types_lock);
Steven Rostedt6d723732009-04-10 14:53:50 -04002445 switch (val) {
2446 case MODULE_STATE_COMING:
2447 trace_module_add_events(mod);
2448 break;
2449 case MODULE_STATE_GOING:
2450 trace_module_remove_events(mod);
2451 break;
2452 }
Alexander Z Lama8227412013-07-01 19:37:54 -07002453 mutex_unlock(&trace_types_lock);
Steven Rostedt (VMware)12ecef02017-09-21 16:22:49 -04002454 mutex_unlock(&event_mutex);
Steven Rostedt6d723732009-04-10 14:53:50 -04002455
2456 return 0;
2457}
Steven Rostedt (Red Hat)315326c2013-03-02 17:37:14 -05002458
Oleg Nesterov836d4812013-07-31 19:31:37 +02002459static struct notifier_block trace_module_nb = {
2460 .notifier_call = trace_module_notify,
Steven Rostedt (Red Hat)3673b8e2015-03-25 15:44:21 -04002461 .priority = 1, /* higher than trace.c module notify */
Oleg Nesterov836d4812013-07-31 19:31:37 +02002462};
Steven Rostedt61f919a2009-04-14 18:22:32 -04002463#endif /* CONFIG_MODULES */
Steven Rostedt6d723732009-04-10 14:53:50 -04002464
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002465/* Create a new event directory structure for a trace directory. */
2466static void
2467__trace_add_event_dirs(struct trace_array *tr)
2468{
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002469 struct trace_event_call *call;
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002470 int ret;
2471
2472 list_for_each_entry(call, &ftrace_events, list) {
Oleg Nesterov620a30e2013-07-31 19:31:35 +02002473 ret = __trace_add_new_event(call, tr);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002474 if (ret < 0)
Fabian Frederick3448bac2014-06-07 13:43:08 +02002475 pr_warn("Could not create directory for event %s\n",
Steven Rostedt (Red Hat)687fcc42015-05-13 14:20:14 -04002476 trace_event_name(call));
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002477 }
2478}
2479
Steven Rostedt (VMware)3c965292018-05-08 15:06:38 -04002480/* Returns any file that matches the system and event */
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04002481struct trace_event_file *
Steven Rostedt (VMware)3c965292018-05-08 15:06:38 -04002482__find_event_file(struct trace_array *tr, const char *system, const char *event)
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002483{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04002484 struct trace_event_file *file;
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002485 struct trace_event_call *call;
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -04002486 const char *name;
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002487
2488 list_for_each_entry(file, &tr->events, list) {
2489
2490 call = file->event_call;
Steven Rostedt (Red Hat)687fcc42015-05-13 14:20:14 -04002491 name = trace_event_name(call);
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002492
Steven Rostedt (VMware)3c965292018-05-08 15:06:38 -04002493 if (!name || !call->class)
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002494 continue;
2495
Mathieu Desnoyersde7b2972014-04-08 17:26:21 -04002496 if (strcmp(event, name) == 0 &&
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002497 strcmp(system, call->class->system) == 0)
2498 return file;
2499 }
2500 return NULL;
2501}
2502
Steven Rostedt (VMware)3c965292018-05-08 15:06:38 -04002503/* Returns valid trace event files that match system and event */
2504struct trace_event_file *
2505find_event_file(struct trace_array *tr, const char *system, const char *event)
2506{
2507 struct trace_event_file *file;
2508
2509 file = __find_event_file(tr, system, event);
2510 if (!file || !file->event_call->class->reg ||
2511 file->event_call->flags & TRACE_EVENT_FL_IGNORE_ENABLE)
2512 return NULL;
2513
2514 return file;
2515}
2516
Steven Rostedt (Red Hat)2875a082013-12-20 23:23:05 -05002517#ifdef CONFIG_DYNAMIC_FTRACE
2518
2519/* Avoid typos */
2520#define ENABLE_EVENT_STR "enable_event"
2521#define DISABLE_EVENT_STR "disable_event"
2522
2523struct event_probe_data {
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04002524 struct trace_event_file *file;
Steven Rostedt (Red Hat)2875a082013-12-20 23:23:05 -05002525 unsigned long count;
2526 int ref;
2527 bool enable;
2528};
2529
Steven Rostedt (VMware)41794f12017-04-03 20:58:35 -04002530static void update_event_probe(struct event_probe_data *data)
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002531{
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002532 if (data->enable)
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -04002533 clear_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &data->file->flags);
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002534 else
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -04002535 set_bit(EVENT_FILE_FL_SOFT_DISABLED_BIT, &data->file->flags);
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002536}
2537
2538static void
Steven Rostedt (VMware)41794f12017-04-03 20:58:35 -04002539event_enable_probe(unsigned long ip, unsigned long parent_ip,
Steven Rostedt (VMware)b5f081b2017-04-10 22:30:05 -04002540 struct trace_array *tr, struct ftrace_probe_ops *ops,
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002541 void *data)
Steven Rostedt (VMware)41794f12017-04-03 20:58:35 -04002542{
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002543 struct ftrace_func_mapper *mapper = data;
2544 struct event_probe_data *edata;
Steven Rostedt (VMware)41794f12017-04-03 20:58:35 -04002545 void **pdata;
2546
2547 pdata = ftrace_func_mapper_find_ip(mapper, ip);
2548 if (!pdata || !*pdata)
2549 return;
2550
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002551 edata = *pdata;
2552 update_event_probe(edata);
Steven Rostedt (VMware)41794f12017-04-03 20:58:35 -04002553}
2554
2555static void
Steven Rostedt (VMware)bca6c8d2017-04-03 18:18:47 -04002556event_enable_count_probe(unsigned long ip, unsigned long parent_ip,
Steven Rostedt (VMware)b5f081b2017-04-10 22:30:05 -04002557 struct trace_array *tr, struct ftrace_probe_ops *ops,
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002558 void *data)
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002559{
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002560 struct ftrace_func_mapper *mapper = data;
2561 struct event_probe_data *edata;
Steven Rostedt (VMware)41794f12017-04-03 20:58:35 -04002562 void **pdata;
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002563
Steven Rostedt (VMware)41794f12017-04-03 20:58:35 -04002564 pdata = ftrace_func_mapper_find_ip(mapper, ip);
2565 if (!pdata || !*pdata)
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002566 return;
2567
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002568 edata = *pdata;
Steven Rostedt (VMware)41794f12017-04-03 20:58:35 -04002569
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002570 if (!edata->count)
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002571 return;
2572
2573 /* Skip if the event is in a state we want to switch to */
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002574 if (edata->enable == !(edata->file->flags & EVENT_FILE_FL_SOFT_DISABLED))
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002575 return;
2576
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002577 if (edata->count != -1)
2578 (edata->count)--;
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002579
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002580 update_event_probe(edata);
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002581}
2582
2583static int
2584event_enable_print(struct seq_file *m, unsigned long ip,
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002585 struct ftrace_probe_ops *ops, void *data)
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002586{
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002587 struct ftrace_func_mapper *mapper = data;
2588 struct event_probe_data *edata;
Steven Rostedt (VMware)41794f12017-04-03 20:58:35 -04002589 void **pdata;
2590
2591 pdata = ftrace_func_mapper_find_ip(mapper, ip);
2592
2593 if (WARN_ON_ONCE(!pdata || !*pdata))
2594 return 0;
2595
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002596 edata = *pdata;
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002597
2598 seq_printf(m, "%ps:", (void *)ip);
2599
2600 seq_printf(m, "%s:%s:%s",
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002601 edata->enable ? ENABLE_EVENT_STR : DISABLE_EVENT_STR,
2602 edata->file->event_call->class->system,
2603 trace_event_name(edata->file->event_call));
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002604
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002605 if (edata->count == -1)
Rasmus Villemoesfa6f0cc2014-11-08 21:42:10 +01002606 seq_puts(m, ":unlimited\n");
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002607 else
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002608 seq_printf(m, ":count=%ld\n", edata->count);
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002609
2610 return 0;
2611}
2612
2613static int
Steven Rostedt (VMware)b5f081b2017-04-10 22:30:05 -04002614event_enable_init(struct ftrace_probe_ops *ops, struct trace_array *tr,
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002615 unsigned long ip, void *init_data, void **data)
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002616{
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002617 struct ftrace_func_mapper *mapper = *data;
2618 struct event_probe_data *edata = init_data;
Steven Rostedt (VMware)41794f12017-04-03 20:58:35 -04002619 int ret;
2620
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002621 if (!mapper) {
2622 mapper = allocate_ftrace_func_mapper();
2623 if (!mapper)
2624 return -ENODEV;
2625 *data = mapper;
2626 }
2627
2628 ret = ftrace_func_mapper_add_ip(mapper, ip, edata);
Steven Rostedt (VMware)41794f12017-04-03 20:58:35 -04002629 if (ret < 0)
2630 return ret;
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002631
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002632 edata->ref++;
Steven Rostedt (VMware)41794f12017-04-03 20:58:35 -04002633
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002634 return 0;
2635}
2636
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002637static int free_probe_data(void *data)
2638{
2639 struct event_probe_data *edata = data;
2640
2641 edata->ref--;
2642 if (!edata->ref) {
2643 /* Remove the SOFT_MODE flag */
2644 __ftrace_event_enable_disable(edata->file, 0, 1);
2645 module_put(edata->file->event_call->mod);
2646 kfree(edata);
2647 }
2648 return 0;
2649}
2650
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002651static void
Steven Rostedt (VMware)b5f081b2017-04-10 22:30:05 -04002652event_enable_free(struct ftrace_probe_ops *ops, struct trace_array *tr,
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002653 unsigned long ip, void *data)
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002654{
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002655 struct ftrace_func_mapper *mapper = data;
2656 struct event_probe_data *edata;
Steven Rostedt (VMware)41794f12017-04-03 20:58:35 -04002657
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002658 if (!ip) {
2659 if (!mapper)
2660 return;
2661 free_ftrace_func_mapper(mapper, free_probe_data);
Steven Rostedt (VMware)41794f12017-04-03 20:58:35 -04002662 return;
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002663 }
Steven Rostedt (VMware)6e444312017-04-19 22:39:44 -04002664
2665 edata = ftrace_func_mapper_remove_ip(mapper, ip);
2666
2667 if (WARN_ON_ONCE(!edata))
2668 return;
2669
2670 if (WARN_ON_ONCE(edata->ref <= 0))
2671 return;
2672
2673 free_probe_data(edata);
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002674}
2675
2676static struct ftrace_probe_ops event_enable_probe_ops = {
2677 .func = event_enable_probe,
2678 .print = event_enable_print,
2679 .init = event_enable_init,
2680 .free = event_enable_free,
2681};
2682
2683static struct ftrace_probe_ops event_enable_count_probe_ops = {
2684 .func = event_enable_count_probe,
2685 .print = event_enable_print,
2686 .init = event_enable_init,
2687 .free = event_enable_free,
2688};
2689
2690static struct ftrace_probe_ops event_disable_probe_ops = {
2691 .func = event_enable_probe,
2692 .print = event_enable_print,
2693 .init = event_enable_init,
2694 .free = event_enable_free,
2695};
2696
2697static struct ftrace_probe_ops event_disable_count_probe_ops = {
2698 .func = event_enable_count_probe,
2699 .print = event_enable_print,
2700 .init = event_enable_init,
2701 .free = event_enable_free,
2702};
2703
2704static int
Steven Rostedt (VMware)04ec7bb2017-04-05 13:12:55 -04002705event_enable_func(struct trace_array *tr, struct ftrace_hash *hash,
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002706 char *glob, char *cmd, char *param, int enabled)
2707{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04002708 struct trace_event_file *file;
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002709 struct ftrace_probe_ops *ops;
2710 struct event_probe_data *data;
2711 const char *system;
2712 const char *event;
2713 char *number;
2714 bool enable;
2715 int ret;
2716
Yoshihiro YUNOMAEdc81e5e2014-06-06 07:35:17 +09002717 if (!tr)
2718 return -ENODEV;
2719
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002720 /* hash funcs only work with set_ftrace_filter */
Harsh Prateek Bora8092e802013-05-24 12:52:17 +05302721 if (!enabled || !param)
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002722 return -EINVAL;
2723
2724 system = strsep(&param, ":");
2725 if (!param)
2726 return -EINVAL;
2727
2728 event = strsep(&param, ":");
2729
2730 mutex_lock(&event_mutex);
2731
2732 ret = -EINVAL;
2733 file = find_event_file(tr, system, event);
2734 if (!file)
2735 goto out;
2736
2737 enable = strcmp(cmd, ENABLE_EVENT_STR) == 0;
2738
2739 if (enable)
2740 ops = param ? &event_enable_count_probe_ops : &event_enable_probe_ops;
2741 else
2742 ops = param ? &event_disable_count_probe_ops : &event_disable_probe_ops;
2743
2744 if (glob[0] == '!') {
Steven Rostedt (VMware)7b60f3d2017-04-18 14:50:39 -04002745 ret = unregister_ftrace_function_probe_func(glob+1, tr, ops);
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002746 goto out;
2747 }
2748
2749 ret = -ENOMEM;
Steven Rostedt (VMware)41794f12017-04-03 20:58:35 -04002750
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002751 data = kzalloc(sizeof(*data), GFP_KERNEL);
2752 if (!data)
2753 goto out;
2754
2755 data->enable = enable;
2756 data->count = -1;
2757 data->file = file;
2758
2759 if (!param)
2760 goto out_reg;
2761
2762 number = strsep(&param, ":");
2763
2764 ret = -EINVAL;
2765 if (!strlen(number))
2766 goto out_free;
2767
2768 /*
2769 * We use the callback data field (which is a pointer)
2770 * as our counter.
2771 */
2772 ret = kstrtoul(number, 0, &data->count);
2773 if (ret)
2774 goto out_free;
2775
2776 out_reg:
2777 /* Don't let event modules unload while probe registered */
2778 ret = try_module_get(file->event_call->mod);
Masami Hiramatsu6ed01062013-05-16 20:48:49 +09002779 if (!ret) {
2780 ret = -EBUSY;
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002781 goto out_free;
Masami Hiramatsu6ed01062013-05-16 20:48:49 +09002782 }
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002783
2784 ret = __ftrace_event_enable_disable(file, 1, 1);
2785 if (ret < 0)
2786 goto out_put;
Steven Rostedt (VMware)41794f12017-04-03 20:58:35 -04002787
Steven Rostedt (VMware)04ec7bb2017-04-05 13:12:55 -04002788 ret = register_ftrace_function_probe(glob, tr, ops, data);
Steven Rostedt (Red Hat)ff305de2013-05-09 11:30:26 -04002789 /*
2790 * The above returns on success the # of functions enabled,
2791 * but if it didn't find any functions it returns zero.
2792 * Consider no functions a failure too.
2793 */
Masami Hiramatsua5b85bd2013-05-09 14:44:14 +09002794 if (!ret) {
2795 ret = -ENOENT;
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002796 goto out_disable;
Steven Rostedt (Red Hat)ff305de2013-05-09 11:30:26 -04002797 } else if (ret < 0)
2798 goto out_disable;
2799 /* Just return zero, not the number of enabled functions */
2800 ret = 0;
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04002801 out:
2802 mutex_unlock(&event_mutex);
2803 return ret;
2804
2805 out_disable:
2806 __ftrace_event_enable_disable(file, 0, 1);
2807 out_put:
2808 module_put(file->event_call->mod);
2809 out_free:
2810 kfree(data);
2811 goto out;
2812}
2813
2814static struct ftrace_func_command event_enable_cmd = {
2815 .name = ENABLE_EVENT_STR,
2816 .func = event_enable_func,
2817};
2818
2819static struct ftrace_func_command event_disable_cmd = {
2820 .name = DISABLE_EVENT_STR,
2821 .func = event_enable_func,
2822};
2823
2824static __init int register_event_cmds(void)
2825{
2826 int ret;
2827
2828 ret = register_ftrace_command(&event_enable_cmd);
2829 if (WARN_ON(ret < 0))
2830 return ret;
2831 ret = register_ftrace_command(&event_disable_cmd);
2832 if (WARN_ON(ret < 0))
2833 unregister_ftrace_command(&event_enable_cmd);
2834 return ret;
2835}
2836#else
2837static inline int register_event_cmds(void) { return 0; }
2838#endif /* CONFIG_DYNAMIC_FTRACE */
2839
Steven Rostedt77248222013-02-27 16:28:06 -05002840/*
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04002841 * The top level array has already had its trace_event_file
Steven Rostedt77248222013-02-27 16:28:06 -05002842 * descriptors created in order to allow for early events to
Steven Rostedt (Red Hat)8434dc92015-01-20 12:13:40 -05002843 * be recorded. This function is called after the tracefs has been
Steven Rostedt77248222013-02-27 16:28:06 -05002844 * initialized, and we now have to create the files associated
2845 * to the events.
2846 */
2847static __init void
2848__trace_early_add_event_dirs(struct trace_array *tr)
2849{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04002850 struct trace_event_file *file;
Steven Rostedt77248222013-02-27 16:28:06 -05002851 int ret;
2852
2853
2854 list_for_each_entry(file, &tr->events, list) {
Oleg Nesterov620a30e2013-07-31 19:31:35 +02002855 ret = event_create_dir(tr->event_dir, file);
Steven Rostedt77248222013-02-27 16:28:06 -05002856 if (ret < 0)
Fabian Frederick3448bac2014-06-07 13:43:08 +02002857 pr_warn("Could not create directory for event %s\n",
Steven Rostedt (Red Hat)687fcc42015-05-13 14:20:14 -04002858 trace_event_name(file->event_call));
Steven Rostedt77248222013-02-27 16:28:06 -05002859 }
2860}
2861
2862/*
2863 * For early boot up, the top trace array requires to have
2864 * a list of events that can be enabled. This must be done before
2865 * the filesystem is set up in order to allow events to be traced
2866 * early.
2867 */
2868static __init void
2869__trace_early_add_events(struct trace_array *tr)
2870{
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002871 struct trace_event_call *call;
Steven Rostedt77248222013-02-27 16:28:06 -05002872 int ret;
2873
2874 list_for_each_entry(call, &ftrace_events, list) {
2875 /* Early boot up should not have any modules loaded */
2876 if (WARN_ON_ONCE(call->mod))
2877 continue;
2878
2879 ret = __trace_early_add_new_event(call, tr);
2880 if (ret < 0)
Fabian Frederick3448bac2014-06-07 13:43:08 +02002881 pr_warn("Could not create early event %s\n",
Steven Rostedt (Red Hat)687fcc42015-05-13 14:20:14 -04002882 trace_event_name(call));
Steven Rostedt77248222013-02-27 16:28:06 -05002883 }
2884}
2885
Steven Rostedt0c8916c2012-08-07 16:14:16 -04002886/* Remove the event directory structure for a trace directory. */
2887static void
2888__trace_remove_event_dirs(struct trace_array *tr)
2889{
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04002890 struct trace_event_file *file, *next;
Steven Rostedt0c8916c2012-08-07 16:14:16 -04002891
Oleg Nesterovf6a84bd2013-07-26 19:25:47 +02002892 list_for_each_entry_safe(file, next, &tr->events, list)
2893 remove_event_file_dir(file);
Steven Rostedt0c8916c2012-08-07 16:14:16 -04002894}
2895
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002896static void __add_event_to_tracers(struct trace_event_call *call)
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002897{
2898 struct trace_array *tr;
2899
Oleg Nesterov620a30e2013-07-31 19:31:35 +02002900 list_for_each_entry(tr, &ftrace_trace_arrays, list)
2901 __trace_add_new_event(call, tr);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002902}
2903
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04002904extern struct trace_event_call *__start_ftrace_events[];
2905extern struct trace_event_call *__stop_ftrace_events[];
Steven Rostedta59fd602009-04-10 13:52:20 -04002906
Li Zefan020e5f82009-07-01 10:47:05 +08002907static char bootup_event_buf[COMMAND_LINE_SIZE] __initdata;
2908
2909static __init int setup_trace_event(char *str)
2910{
2911 strlcpy(bootup_event_buf, str, COMMAND_LINE_SIZE);
Steven Rostedt (Red Hat)55034cd2013-03-07 22:48:09 -05002912 ring_buffer_expanded = true;
2913 tracing_selftest_disabled = true;
Li Zefan020e5f82009-07-01 10:47:05 +08002914
2915 return 1;
2916}
2917__setup("trace_event=", setup_trace_event);
2918
Steven Rostedt77248222013-02-27 16:28:06 -05002919/* Expects to have event_mutex held when called */
2920static int
2921create_event_toplevel_files(struct dentry *parent, struct trace_array *tr)
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002922{
2923 struct dentry *d_events;
2924 struct dentry *entry;
2925
Steven Rostedt (Red Hat)8434dc92015-01-20 12:13:40 -05002926 entry = tracefs_create_file("set_event", 0644, parent,
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002927 tr, &ftrace_set_event_fops);
2928 if (!entry) {
Steven Rostedt (Red Hat)8434dc92015-01-20 12:13:40 -05002929 pr_warn("Could not create tracefs 'set_event' entry\n");
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002930 return -ENOMEM;
2931 }
2932
Steven Rostedt (Red Hat)8434dc92015-01-20 12:13:40 -05002933 d_events = tracefs_create_dir("events", parent);
Steven Rostedt277ba042012-08-03 16:10:49 -04002934 if (!d_events) {
Steven Rostedt (Red Hat)8434dc92015-01-20 12:13:40 -05002935 pr_warn("Could not create tracefs 'events' directory\n");
Steven Rostedt277ba042012-08-03 16:10:49 -04002936 return -ENOMEM;
2937 }
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002938
Steven Rostedt (Red Hat)7d436402016-11-22 18:32:03 -05002939 entry = trace_create_file("enable", 0644, d_events,
2940 tr, &ftrace_tr_enable_fops);
2941 if (!entry) {
2942 pr_warn("Could not create tracefs 'enable' entry\n");
2943 return -ENOMEM;
2944 }
2945
2946 /* There are not as crucial, just warn if they are not created */
2947
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04002948 entry = tracefs_create_file("set_event_pid", 0644, parent,
2949 tr, &ftrace_set_event_pid_fops);
Steven Rostedt (Red Hat)7d436402016-11-22 18:32:03 -05002950 if (!entry)
2951 pr_warn("Could not create tracefs 'set_event_pid' entry\n");
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04002952
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002953 /* ring buffer internal formats */
Steven Rostedt (Red Hat)7d436402016-11-22 18:32:03 -05002954 entry = trace_create_file("header_page", 0444, d_events,
2955 ring_buffer_print_page_header,
2956 &ftrace_show_header_fops);
2957 if (!entry)
2958 pr_warn("Could not create tracefs 'header_page' entry\n");
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002959
Steven Rostedt (Red Hat)7d436402016-11-22 18:32:03 -05002960 entry = trace_create_file("header_event", 0444, d_events,
2961 ring_buffer_print_entry_header,
2962 &ftrace_show_header_fops);
2963 if (!entry)
2964 pr_warn("Could not create tracefs 'header_event' entry\n");
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002965
2966 tr->event_dir = d_events;
Steven Rostedt77248222013-02-27 16:28:06 -05002967
2968 return 0;
2969}
2970
2971/**
2972 * event_trace_add_tracer - add a instance of a trace_array to events
2973 * @parent: The parent dentry to place the files/directories for events in
2974 * @tr: The trace array associated with these events
2975 *
2976 * When a new instance is created, it needs to set up its events
2977 * directory, as well as other files associated with events. It also
2978 * creates the event hierachry in the @parent/events directory.
2979 *
2980 * Returns 0 on success.
Steven Rostedt (VMware)12ecef02017-09-21 16:22:49 -04002981 *
2982 * Must be called with event_mutex held.
Steven Rostedt77248222013-02-27 16:28:06 -05002983 */
2984int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr)
2985{
2986 int ret;
2987
Steven Rostedt (VMware)12ecef02017-09-21 16:22:49 -04002988 lockdep_assert_held(&event_mutex);
Steven Rostedt77248222013-02-27 16:28:06 -05002989
2990 ret = create_event_toplevel_files(parent, tr);
2991 if (ret)
Steven Rostedt (VMware)12ecef02017-09-21 16:22:49 -04002992 goto out;
Steven Rostedt77248222013-02-27 16:28:06 -05002993
zhangwei(Jovi)52f6ad62013-03-11 15:14:03 +08002994 down_write(&trace_event_sem);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04002995 __trace_add_event_dirs(tr);
zhangwei(Jovi)52f6ad62013-03-11 15:14:03 +08002996 up_write(&trace_event_sem);
Steven Rostedt277ba042012-08-03 16:10:49 -04002997
Steven Rostedt (VMware)12ecef02017-09-21 16:22:49 -04002998 out:
Steven Rostedt77248222013-02-27 16:28:06 -05002999 return ret;
3000}
3001
3002/*
3003 * The top trace array already had its file descriptors created.
3004 * Now the files themselves need to be created.
3005 */
3006static __init int
3007early_event_add_tracer(struct dentry *parent, struct trace_array *tr)
3008{
3009 int ret;
3010
3011 mutex_lock(&event_mutex);
3012
3013 ret = create_event_toplevel_files(parent, tr);
3014 if (ret)
3015 goto out_unlock;
3016
zhangwei(Jovi)52f6ad62013-03-11 15:14:03 +08003017 down_write(&trace_event_sem);
Steven Rostedt77248222013-02-27 16:28:06 -05003018 __trace_early_add_event_dirs(tr);
zhangwei(Jovi)52f6ad62013-03-11 15:14:03 +08003019 up_write(&trace_event_sem);
Steven Rostedt77248222013-02-27 16:28:06 -05003020
3021 out_unlock:
3022 mutex_unlock(&event_mutex);
3023
3024 return ret;
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003025}
3026
Steven Rostedt (VMware)12ecef02017-09-21 16:22:49 -04003027/* Must be called with event_mutex held */
Steven Rostedt0c8916c2012-08-07 16:14:16 -04003028int event_trace_del_tracer(struct trace_array *tr)
3029{
Steven Rostedt (VMware)12ecef02017-09-21 16:22:49 -04003030 lockdep_assert_held(&event_mutex);
Steven Rostedt0c8916c2012-08-07 16:14:16 -04003031
Tom Zanussi85f2b082013-10-24 08:59:24 -05003032 /* Disable any event triggers and associated soft-disabled events */
3033 clear_event_triggers(tr);
3034
Steven Rostedt (Red Hat)49090102015-09-24 11:33:26 -04003035 /* Clear the pid list */
3036 __ftrace_clear_event_pids(tr);
3037
Steven Rostedt (Red Hat)2a6c24a2013-07-02 14:48:23 -04003038 /* Disable any running events */
3039 __ftrace_set_clr_event_nolock(tr, NULL, NULL, NULL, 0);
3040
Steven Rostedt (VMware)e0a568d2018-08-09 15:31:48 -04003041 /* Make sure no more events are being executed */
3042 tracepoint_synchronize_unregister();
Steven Rostedt3ccb0122013-12-03 12:41:20 -05003043
zhangwei(Jovi)52f6ad62013-03-11 15:14:03 +08003044 down_write(&trace_event_sem);
Steven Rostedt0c8916c2012-08-07 16:14:16 -04003045 __trace_remove_event_dirs(tr);
Steven Rostedt (Red Hat)8434dc92015-01-20 12:13:40 -05003046 tracefs_remove_recursive(tr->event_dir);
zhangwei(Jovi)52f6ad62013-03-11 15:14:03 +08003047 up_write(&trace_event_sem);
Steven Rostedt0c8916c2012-08-07 16:14:16 -04003048
3049 tr->event_dir = NULL;
3050
Steven Rostedt0c8916c2012-08-07 16:14:16 -04003051 return 0;
3052}
3053
Steven Rostedtd1a29142013-02-27 20:23:57 -05003054static __init int event_trace_memsetup(void)
3055{
3056 field_cachep = KMEM_CACHE(ftrace_event_field, SLAB_PANIC);
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04003057 file_cachep = KMEM_CACHE(trace_event_file, SLAB_PANIC);
Steven Rostedtd1a29142013-02-27 20:23:57 -05003058 return 0;
3059}
3060
Steven Rostedt (Red Hat)ce1039b2015-01-14 12:53:45 -05003061static __init void
3062early_enable_events(struct trace_array *tr, bool disable_first)
3063{
3064 char *buf = bootup_event_buf;
3065 char *token;
3066 int ret;
3067
3068 while (true) {
3069 token = strsep(&buf, ",");
3070
3071 if (!token)
3072 break;
Steven Rostedt (Red Hat)ce1039b2015-01-14 12:53:45 -05003073
Steven Rostedt (Red Hat)43ed3842015-11-03 22:15:14 -05003074 if (*token) {
3075 /* Restarting syscalls requires that we stop them first */
3076 if (disable_first)
3077 ftrace_set_clr_event(tr, token, 0);
Steven Rostedt (Red Hat)ce1039b2015-01-14 12:53:45 -05003078
Steven Rostedt (Red Hat)43ed3842015-11-03 22:15:14 -05003079 ret = ftrace_set_clr_event(tr, token, 1);
3080 if (ret)
3081 pr_warn("Failed to enable trace event: %s\n", token);
3082 }
Steven Rostedt (Red Hat)ce1039b2015-01-14 12:53:45 -05003083
3084 /* Put back the comma to allow this to be called again */
3085 if (buf)
3086 *(buf - 1) = ',';
3087 }
3088}
3089
Ezequiel Garcia87819152012-09-12 11:47:57 -03003090static __init int event_trace_enable(void)
3091{
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003092 struct trace_array *tr = top_trace_array();
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04003093 struct trace_event_call **iter, *call;
Ezequiel Garcia87819152012-09-12 11:47:57 -03003094 int ret;
3095
Yoshihiro YUNOMAEdc81e5e2014-06-06 07:35:17 +09003096 if (!tr)
3097 return -ENODEV;
3098
Ezequiel Garcia87819152012-09-12 11:47:57 -03003099 for_each_event(iter, __start_ftrace_events, __stop_ftrace_events) {
3100
3101 call = *iter;
3102 ret = event_init(call);
3103 if (!ret)
3104 list_add(&call->list, &ftrace_events);
3105 }
3106
Steven Rostedt77248222013-02-27 16:28:06 -05003107 /*
3108 * We need the top trace array to have a working set of trace
3109 * points at early init, before the debug files and directories
3110 * are created. Create the file entries now, and attach them
3111 * to the actual file dentries later.
3112 */
3113 __trace_early_add_events(tr);
3114
Steven Rostedt (Red Hat)ce1039b2015-01-14 12:53:45 -05003115 early_enable_events(tr, false);
Steven Rostedt81698832012-10-11 10:15:05 -04003116
3117 trace_printk_start_comm();
3118
Steven Rostedt (Red Hat)3cd715d2013-03-12 19:35:13 -04003119 register_event_cmds();
3120
Tom Zanussi85f2b082013-10-24 08:59:24 -05003121 register_trigger_cmds();
3122
Ezequiel Garcia87819152012-09-12 11:47:57 -03003123 return 0;
3124}
3125
Steven Rostedt (Red Hat)ce1039b2015-01-14 12:53:45 -05003126/*
3127 * event_trace_enable() is called from trace_event_init() first to
3128 * initialize events and perhaps start any events that are on the
3129 * command line. Unfortunately, there are some events that will not
3130 * start this early, like the system call tracepoints that need
3131 * to set the TIF_SYSCALL_TRACEPOINT flag of pid 1. But event_trace_enable()
3132 * is called before pid 1 starts, and this flag is never set, making
3133 * the syscall tracepoint never get reached, but the event is enabled
3134 * regardless (and not doing anything).
3135 */
3136static __init int event_trace_enable_again(void)
3137{
3138 struct trace_array *tr;
3139
3140 tr = top_trace_array();
3141 if (!tr)
3142 return -ENODEV;
3143
3144 early_enable_events(tr, true);
3145
3146 return 0;
3147}
3148
3149early_initcall(event_trace_enable_again);
3150
Steven Rostedt (VMware)58b92542018-05-08 15:09:27 -04003151__init int event_trace_init(void)
Steven Rostedtb77e38a2009-02-24 10:21:36 -05003152{
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003153 struct trace_array *tr;
Steven Rostedtb77e38a2009-02-24 10:21:36 -05003154 struct dentry *d_tracer;
3155 struct dentry *entry;
Steven Rostedt6d723732009-04-10 14:53:50 -04003156 int ret;
Steven Rostedtb77e38a2009-02-24 10:21:36 -05003157
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003158 tr = top_trace_array();
Yoshihiro YUNOMAEdc81e5e2014-06-06 07:35:17 +09003159 if (!tr)
3160 return -ENODEV;
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003161
Steven Rostedtb77e38a2009-02-24 10:21:36 -05003162 d_tracer = tracing_init_dentry();
Steven Rostedt (Red Hat)14a5ae42015-01-20 11:14:16 -05003163 if (IS_ERR(d_tracer))
Steven Rostedtb77e38a2009-02-24 10:21:36 -05003164 return 0;
3165
Steven Rostedt (Red Hat)8434dc92015-01-20 12:13:40 -05003166 entry = tracefs_create_file("available_events", 0444, d_tracer,
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003167 tr, &ftrace_avail_fops);
Steven Rostedt2314c4a2009-03-10 12:04:02 -04003168 if (!entry)
Steven Rostedt (Red Hat)8434dc92015-01-20 12:13:40 -05003169 pr_warn("Could not create tracefs 'available_events' entry\n");
Steven Rostedt2314c4a2009-03-10 12:04:02 -04003170
Daniel Wagner9f616682015-08-10 14:35:46 +02003171 if (trace_define_generic_fields())
3172 pr_warn("tracing: Failed to allocated generic fields");
3173
Li Zefan8728fe52010-05-24 16:22:49 +08003174 if (trace_define_common_fields())
Fabian Frederick3448bac2014-06-07 13:43:08 +02003175 pr_warn("tracing: Failed to allocate common fields");
Li Zefan8728fe52010-05-24 16:22:49 +08003176
Steven Rostedt77248222013-02-27 16:28:06 -05003177 ret = early_event_add_tracer(d_tracer, tr);
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003178 if (ret)
3179 return ret;
Li Zefan020e5f82009-07-01 10:47:05 +08003180
Oleg Nesterov836d4812013-07-31 19:31:37 +02003181#ifdef CONFIG_MODULES
Steven Rostedt6d723732009-04-10 14:53:50 -04003182 ret = register_module_notifier(&trace_module_nb);
Ming Lei55379372009-05-18 23:04:46 +08003183 if (ret)
Fabian Frederick3448bac2014-06-07 13:43:08 +02003184 pr_warn("Failed to register trace events module notifier\n");
Oleg Nesterov836d4812013-07-31 19:31:37 +02003185#endif
Steven Rostedtb77e38a2009-02-24 10:21:36 -05003186 return 0;
3187}
Steven Rostedt (Red Hat)5f893b22014-12-12 20:05:10 -05003188
3189void __init trace_event_init(void)
3190{
3191 event_trace_memsetup();
3192 init_ftrace_syscalls();
3193 event_trace_enable();
3194}
3195
Steven Rostedte6187002009-04-15 13:36:40 -04003196#ifdef CONFIG_FTRACE_STARTUP_TEST
3197
3198static DEFINE_SPINLOCK(test_spinlock);
3199static DEFINE_SPINLOCK(test_spinlock_irq);
3200static DEFINE_MUTEX(test_mutex);
3201
3202static __init void test_work(struct work_struct *dummy)
3203{
3204 spin_lock(&test_spinlock);
3205 spin_lock_irq(&test_spinlock_irq);
3206 udelay(1);
3207 spin_unlock_irq(&test_spinlock_irq);
3208 spin_unlock(&test_spinlock);
3209
3210 mutex_lock(&test_mutex);
3211 msleep(1);
3212 mutex_unlock(&test_mutex);
3213}
3214
3215static __init int event_test_thread(void *unused)
3216{
3217 void *test_malloc;
3218
3219 test_malloc = kmalloc(1234, GFP_KERNEL);
3220 if (!test_malloc)
3221 pr_info("failed to kmalloc\n");
3222
3223 schedule_on_each_cpu(test_work);
3224
3225 kfree(test_malloc);
3226
3227 set_current_state(TASK_INTERRUPTIBLE);
Peter Zijlstrafe0e01c2014-10-08 18:51:10 +02003228 while (!kthread_should_stop()) {
Steven Rostedte6187002009-04-15 13:36:40 -04003229 schedule();
Peter Zijlstrafe0e01c2014-10-08 18:51:10 +02003230 set_current_state(TASK_INTERRUPTIBLE);
3231 }
3232 __set_current_state(TASK_RUNNING);
Steven Rostedte6187002009-04-15 13:36:40 -04003233
3234 return 0;
3235}
3236
3237/*
3238 * Do various things that may trigger events.
3239 */
3240static __init void event_test_stuff(void)
3241{
3242 struct task_struct *test_thread;
3243
3244 test_thread = kthread_run(event_test_thread, NULL, "test-events");
3245 msleep(1);
3246 kthread_stop(test_thread);
3247}
3248
3249/*
3250 * For every trace event defined, we will test each trace point separately,
3251 * and then by groups, and finally all trace points.
3252 */
Steven Rostedt9ea21c12009-04-16 12:15:44 -04003253static __init void event_trace_self_tests(void)
Steven Rostedte6187002009-04-15 13:36:40 -04003254{
Steven Rostedt (Red Hat)7967b3e2015-05-13 14:59:40 -04003255 struct trace_subsystem_dir *dir;
Steven Rostedt (Red Hat)7f1d2f82015-05-05 10:09:53 -04003256 struct trace_event_file *file;
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -04003257 struct trace_event_call *call;
Steven Rostedte6187002009-04-15 13:36:40 -04003258 struct event_subsystem *system;
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003259 struct trace_array *tr;
Steven Rostedte6187002009-04-15 13:36:40 -04003260 int ret;
3261
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003262 tr = top_trace_array();
Yoshihiro YUNOMAEdc81e5e2014-06-06 07:35:17 +09003263 if (!tr)
3264 return;
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003265
Steven Rostedte6187002009-04-15 13:36:40 -04003266 pr_info("Running tests on trace events:\n");
3267
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003268 list_for_each_entry(file, &tr->events, list) {
3269
3270 call = file->event_call;
Steven Rostedte6187002009-04-15 13:36:40 -04003271
Steven Rostedt22392912010-04-21 12:27:06 -04003272 /* Only test those that have a probe */
3273 if (!call->class || !call->class->probe)
Steven Rostedte6187002009-04-15 13:36:40 -04003274 continue;
3275
Steven Rostedt1f5a6b42009-09-14 11:58:24 -04003276/*
3277 * Testing syscall events here is pretty useless, but
3278 * we still do it if configured. But this is time consuming.
3279 * What we really need is a user thread to perform the
3280 * syscalls as we test.
3281 */
3282#ifndef CONFIG_EVENT_TRACE_TEST_SYSCALLS
Steven Rostedt8f082012010-04-20 10:47:33 -04003283 if (call->class->system &&
3284 strcmp(call->class->system, "syscalls") == 0)
Steven Rostedt1f5a6b42009-09-14 11:58:24 -04003285 continue;
3286#endif
3287
Steven Rostedt (Red Hat)687fcc42015-05-13 14:20:14 -04003288 pr_info("Testing event %s: ", trace_event_name(call));
Steven Rostedte6187002009-04-15 13:36:40 -04003289
3290 /*
3291 * If an event is already enabled, someone is using
3292 * it and the self test should not be on.
3293 */
Steven Rostedt (Red Hat)5d6ad962015-05-13 15:12:33 -04003294 if (file->flags & EVENT_FILE_FL_ENABLED) {
Fabian Frederick3448bac2014-06-07 13:43:08 +02003295 pr_warn("Enabled event during self test!\n");
Steven Rostedte6187002009-04-15 13:36:40 -04003296 WARN_ON_ONCE(1);
3297 continue;
3298 }
3299
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003300 ftrace_event_enable_disable(file, 1);
Steven Rostedte6187002009-04-15 13:36:40 -04003301 event_test_stuff();
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003302 ftrace_event_enable_disable(file, 0);
Steven Rostedte6187002009-04-15 13:36:40 -04003303
3304 pr_cont("OK\n");
3305 }
3306
3307 /* Now test at the sub system level */
3308
3309 pr_info("Running tests on trace event systems:\n");
3310
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003311 list_for_each_entry(dir, &tr->systems, list) {
3312
3313 system = dir->subsystem;
Steven Rostedte6187002009-04-15 13:36:40 -04003314
3315 /* the ftrace system is special, skip it */
3316 if (strcmp(system->name, "ftrace") == 0)
3317 continue;
3318
3319 pr_info("Testing event system %s: ", system->name);
3320
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003321 ret = __ftrace_set_clr_event(tr, NULL, system->name, NULL, 1);
Steven Rostedte6187002009-04-15 13:36:40 -04003322 if (WARN_ON_ONCE(ret)) {
Fabian Frederick3448bac2014-06-07 13:43:08 +02003323 pr_warn("error enabling system %s\n",
3324 system->name);
Steven Rostedte6187002009-04-15 13:36:40 -04003325 continue;
3326 }
3327
3328 event_test_stuff();
3329
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003330 ret = __ftrace_set_clr_event(tr, NULL, system->name, NULL, 0);
Yuanhan Liu76bab1b2012-08-27 15:13:45 +08003331 if (WARN_ON_ONCE(ret)) {
Fabian Frederick3448bac2014-06-07 13:43:08 +02003332 pr_warn("error disabling system %s\n",
3333 system->name);
Yuanhan Liu76bab1b2012-08-27 15:13:45 +08003334 continue;
3335 }
Steven Rostedte6187002009-04-15 13:36:40 -04003336
3337 pr_cont("OK\n");
3338 }
3339
3340 /* Test with all events enabled */
3341
3342 pr_info("Running tests on all trace events:\n");
3343 pr_info("Testing all events: ");
3344
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003345 ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, 1);
Steven Rostedte6187002009-04-15 13:36:40 -04003346 if (WARN_ON_ONCE(ret)) {
Fabian Frederick3448bac2014-06-07 13:43:08 +02003347 pr_warn("error enabling all events\n");
Steven Rostedt9ea21c12009-04-16 12:15:44 -04003348 return;
Steven Rostedte6187002009-04-15 13:36:40 -04003349 }
3350
3351 event_test_stuff();
3352
3353 /* reset sysname */
Steven Rostedtae63b31e2012-05-03 23:09:03 -04003354 ret = __ftrace_set_clr_event(tr, NULL, NULL, NULL, 0);
Steven Rostedte6187002009-04-15 13:36:40 -04003355 if (WARN_ON_ONCE(ret)) {
Fabian Frederick3448bac2014-06-07 13:43:08 +02003356 pr_warn("error disabling all events\n");
Steven Rostedt9ea21c12009-04-16 12:15:44 -04003357 return;
Steven Rostedte6187002009-04-15 13:36:40 -04003358 }
3359
3360 pr_cont("OK\n");
Steven Rostedt9ea21c12009-04-16 12:15:44 -04003361}
3362
3363#ifdef CONFIG_FUNCTION_TRACER
3364
Tejun Heo245b2e72009-06-24 15:13:48 +09003365static DEFINE_PER_CPU(atomic_t, ftrace_test_event_disable);
Steven Rostedt9ea21c12009-04-16 12:15:44 -04003366
Steven Rostedt (Red Hat)9b9db272016-04-29 18:10:21 -04003367static struct trace_event_file event_trace_file __initdata;
Steven Rostedt (Red Hat)b7f0c952015-09-25 17:38:44 -04003368
3369static void __init
Steven Rostedt2f5f6ad2011-08-08 16:57:47 -04003370function_test_events_call(unsigned long ip, unsigned long parent_ip,
Steven Rostedta1e2e312011-08-09 12:50:46 -04003371 struct ftrace_ops *op, struct pt_regs *pt_regs)
Steven Rostedt9ea21c12009-04-16 12:15:44 -04003372{
3373 struct ring_buffer_event *event;
Steven Rostedte77405a2009-09-02 14:17:06 -04003374 struct ring_buffer *buffer;
Steven Rostedt9ea21c12009-04-16 12:15:44 -04003375 struct ftrace_entry *entry;
3376 unsigned long flags;
3377 long disabled;
Steven Rostedt9ea21c12009-04-16 12:15:44 -04003378 int cpu;
3379 int pc;
3380
3381 pc = preempt_count();
Steven Rostedt5168ae52010-06-03 09:36:50 -04003382 preempt_disable_notrace();
Steven Rostedt9ea21c12009-04-16 12:15:44 -04003383 cpu = raw_smp_processor_id();
Tejun Heo245b2e72009-06-24 15:13:48 +09003384 disabled = atomic_inc_return(&per_cpu(ftrace_test_event_disable, cpu));
Steven Rostedt9ea21c12009-04-16 12:15:44 -04003385
3386 if (disabled != 1)
3387 goto out;
3388
3389 local_save_flags(flags);
3390
Steven Rostedt (Red Hat)9b9db272016-04-29 18:10:21 -04003391 event = trace_event_buffer_lock_reserve(&buffer, &event_trace_file,
3392 TRACE_FN, sizeof(*entry),
3393 flags, pc);
Steven Rostedt9ea21c12009-04-16 12:15:44 -04003394 if (!event)
3395 goto out;
3396 entry = ring_buffer_event_data(event);
3397 entry->ip = ip;
3398 entry->parent_ip = parent_ip;
3399
Steven Rostedt (Red Hat)9b9db272016-04-29 18:10:21 -04003400 event_trigger_unlock_commit(&event_trace_file, buffer, event,
3401 entry, flags, pc);
Steven Rostedt9ea21c12009-04-16 12:15:44 -04003402 out:
Tejun Heo245b2e72009-06-24 15:13:48 +09003403 atomic_dec(&per_cpu(ftrace_test_event_disable, cpu));
Steven Rostedt5168ae52010-06-03 09:36:50 -04003404 preempt_enable_notrace();
Steven Rostedt9ea21c12009-04-16 12:15:44 -04003405}
3406
3407static struct ftrace_ops trace_ops __initdata =
3408{
3409 .func = function_test_events_call,
Steven Rostedt47409742012-07-20 11:04:44 -04003410 .flags = FTRACE_OPS_FL_RECURSION_SAFE,
Steven Rostedt9ea21c12009-04-16 12:15:44 -04003411};
3412
3413static __init void event_trace_self_test_with_function(void)
3414{
Steven Rostedt17bb6152011-05-23 15:27:46 -04003415 int ret;
Steven Rostedt (Red Hat)9b9db272016-04-29 18:10:21 -04003416
3417 event_trace_file.tr = top_trace_array();
3418 if (WARN_ON(!event_trace_file.tr))
Steven Rostedt (Red Hat)2d34f482015-09-30 11:45:22 -04003419 return;
Steven Rostedt (Red Hat)9b9db272016-04-29 18:10:21 -04003420
Steven Rostedt17bb6152011-05-23 15:27:46 -04003421 ret = register_ftrace_function(&trace_ops);
3422 if (WARN_ON(ret < 0)) {
3423 pr_info("Failed to enable function tracer for event tests\n");
3424 return;
3425 }
Steven Rostedt9ea21c12009-04-16 12:15:44 -04003426 pr_info("Running tests again, along with the function tracer\n");
3427 event_trace_self_tests();
3428 unregister_ftrace_function(&trace_ops);
3429}
3430#else
3431static __init void event_trace_self_test_with_function(void)
3432{
3433}
3434#endif
3435
3436static __init int event_trace_self_tests_init(void)
3437{
Li Zefan020e5f82009-07-01 10:47:05 +08003438 if (!tracing_selftest_disabled) {
3439 event_trace_self_tests();
3440 event_trace_self_test_with_function();
3441 }
Steven Rostedte6187002009-04-15 13:36:40 -04003442
3443 return 0;
3444}
3445
Steven Rostedt28d20e22009-04-20 12:12:44 -04003446late_initcall(event_trace_self_tests_init);
Steven Rostedte6187002009-04-15 13:36:40 -04003447
3448#endif