blob: 0725eeab1937ef24a301f2c0b0404f64ce95e026 [file] [log] [blame]
Steven Rostedtb77e38a2009-02-24 10:21:36 -05001/*
2 * event tracer
3 *
4 * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
5 *
Steven Rostedt981d0812009-03-02 13:53:59 -05006 * - Added format output of fields of the trace point.
7 * This was based off of work by Tom Zanussi <tzanussi@gmail.com>.
8 *
Steven Rostedtb77e38a2009-02-24 10:21:36 -05009 */
10
Steven Rostedte6187002009-04-15 13:36:40 -040011#include <linux/workqueue.h>
12#include <linux/spinlock.h>
13#include <linux/kthread.h>
Steven Rostedtb77e38a2009-02-24 10:21:36 -050014#include <linux/debugfs.h>
15#include <linux/uaccess.h>
16#include <linux/module.h>
17#include <linux/ctype.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090018#include <linux/slab.h>
Steven Rostedte6187002009-04-15 13:36:40 -040019#include <linux/delay.h>
Steven Rostedtb77e38a2009-02-24 10:21:36 -050020
Li Zefan020e5f82009-07-01 10:47:05 +080021#include <asm/setup.h>
22
Steven Rostedt91729ef92009-03-02 15:03:01 -050023#include "trace_output.h"
Steven Rostedtb77e38a2009-02-24 10:21:36 -050024
Steven Rostedt4e5292e2009-09-12 19:26:21 -040025#undef TRACE_SYSTEM
Steven Rostedtb628b3e2009-02-27 23:32:58 -050026#define TRACE_SYSTEM "TRACE_SYSTEM"
27
Li Zefan20c89282009-05-06 10:33:45 +080028DEFINE_MUTEX(event_mutex);
Steven Rostedt11a241a2009-03-02 11:49:04 -050029
Steven Rostedta59fd602009-04-10 13:52:20 -040030LIST_HEAD(ftrace_events);
Li Zefan8728fe52010-05-24 16:22:49 +080031LIST_HEAD(ftrace_common_fields);
Steven Rostedta59fd602009-04-10 13:52:20 -040032
Steven Rostedt2e33af02010-04-22 10:35:55 -040033struct list_head *
34trace_get_fields(struct ftrace_event_call *event_call)
35{
36 if (!event_call->class->get_fields)
37 return &event_call->class->fields;
38 return event_call->class->get_fields(event_call);
39}
40
Li Zefan8728fe52010-05-24 16:22:49 +080041static int __trace_define_field(struct list_head *head, const char *type,
42 const char *name, int offset, int size,
43 int is_signed, int filter_type)
Tom Zanussicf027f62009-03-22 03:30:39 -050044{
45 struct ftrace_event_field *field;
46
Ingo Molnarfe9f57f22009-03-22 18:41:59 +010047 field = kzalloc(sizeof(*field), GFP_KERNEL);
Tom Zanussicf027f62009-03-22 03:30:39 -050048 if (!field)
49 goto err;
Ingo Molnarfe9f57f22009-03-22 18:41:59 +010050
Tom Zanussicf027f62009-03-22 03:30:39 -050051 field->name = kstrdup(name, GFP_KERNEL);
52 if (!field->name)
53 goto err;
Ingo Molnarfe9f57f22009-03-22 18:41:59 +010054
Tom Zanussicf027f62009-03-22 03:30:39 -050055 field->type = kstrdup(type, GFP_KERNEL);
56 if (!field->type)
57 goto err;
Ingo Molnarfe9f57f22009-03-22 18:41:59 +010058
Li Zefan43b51ea2009-08-07 10:33:22 +080059 if (filter_type == FILTER_OTHER)
60 field->filter_type = filter_assign_type(type);
61 else
62 field->filter_type = filter_type;
63
Tom Zanussicf027f62009-03-22 03:30:39 -050064 field->offset = offset;
65 field->size = size;
Tom Zanussia118e4d2009-04-28 03:04:53 -050066 field->is_signed = is_signed;
Li Zefanaa38e9f2009-08-07 10:33:02 +080067
Steven Rostedt2e33af02010-04-22 10:35:55 -040068 list_add(&field->link, head);
Tom Zanussicf027f62009-03-22 03:30:39 -050069
70 return 0;
Ingo Molnarfe9f57f22009-03-22 18:41:59 +010071
Tom Zanussicf027f62009-03-22 03:30:39 -050072err:
Wenji Huang7b60997f2010-02-24 15:40:26 +080073 if (field)
Tom Zanussicf027f62009-03-22 03:30:39 -050074 kfree(field->name);
Tom Zanussicf027f62009-03-22 03:30:39 -050075 kfree(field);
Ingo Molnarfe9f57f22009-03-22 18:41:59 +010076
Tom Zanussicf027f62009-03-22 03:30:39 -050077 return -ENOMEM;
78}
Li Zefan8728fe52010-05-24 16:22:49 +080079
80int trace_define_field(struct ftrace_event_call *call, const char *type,
81 const char *name, int offset, int size, int is_signed,
82 int filter_type)
83{
84 struct list_head *head;
85
86 if (WARN_ON(!call->class))
87 return 0;
88
89 head = trace_get_fields(call);
90 return __trace_define_field(head, type, name, offset, size,
91 is_signed, filter_type);
92}
Steven Rostedt17c873e2009-04-10 18:12:50 -040093EXPORT_SYMBOL_GPL(trace_define_field);
Tom Zanussicf027f62009-03-22 03:30:39 -050094
Li Zefane647d6b2009-08-19 15:54:32 +080095#define __common_field(type, item) \
Li Zefan8728fe52010-05-24 16:22:49 +080096 ret = __trace_define_field(&ftrace_common_fields, #type, \
97 "common_" #item, \
98 offsetof(typeof(ent), item), \
99 sizeof(ent.item), \
100 is_signed_type(type), FILTER_OTHER); \
Li Zefane647d6b2009-08-19 15:54:32 +0800101 if (ret) \
102 return ret;
103
Li Zefan8728fe52010-05-24 16:22:49 +0800104static int trace_define_common_fields(void)
Li Zefane647d6b2009-08-19 15:54:32 +0800105{
106 int ret;
107 struct trace_entry ent;
108
109 __common_field(unsigned short, type);
110 __common_field(unsigned char, flags);
111 __common_field(unsigned char, preempt_count);
112 __common_field(int, pid);
Steven Rostedt637e7e82009-09-11 13:55:35 -0400113 __common_field(int, lock_depth);
Li Zefane647d6b2009-08-19 15:54:32 +0800114
115 return ret;
116}
117
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -0400118void trace_destroy_fields(struct ftrace_event_call *call)
Li Zefan2df75e42009-05-06 10:33:04 +0800119{
120 struct ftrace_event_field *field, *next;
Steven Rostedt2e33af02010-04-22 10:35:55 -0400121 struct list_head *head;
Li Zefan2df75e42009-05-06 10:33:04 +0800122
Steven Rostedt2e33af02010-04-22 10:35:55 -0400123 head = trace_get_fields(call);
124 list_for_each_entry_safe(field, next, head, link) {
Li Zefan2df75e42009-05-06 10:33:04 +0800125 list_del(&field->link);
126 kfree(field->type);
127 kfree(field->name);
128 kfree(field);
129 }
130}
131
Li Zefan87d9b4e2009-12-08 11:14:20 +0800132int trace_event_raw_init(struct ftrace_event_call *call)
133{
134 int id;
135
Steven Rostedt80decc72010-04-23 10:00:22 -0400136 id = register_ftrace_event(&call->event);
Li Zefan87d9b4e2009-12-08 11:14:20 +0800137 if (!id)
138 return -ENODEV;
Li Zefan87d9b4e2009-12-08 11:14:20 +0800139
140 return 0;
141}
142EXPORT_SYMBOL_GPL(trace_event_raw_init);
143
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400144int ftrace_event_reg(struct ftrace_event_call *call, enum trace_reg type)
145{
146 switch (type) {
147 case TRACE_REG_REGISTER:
148 return tracepoint_probe_register(call->name,
149 call->class->probe,
150 call);
151 case TRACE_REG_UNREGISTER:
152 tracepoint_probe_unregister(call->name,
153 call->class->probe,
154 call);
155 return 0;
156
157#ifdef CONFIG_PERF_EVENTS
158 case TRACE_REG_PERF_REGISTER:
159 return tracepoint_probe_register(call->name,
160 call->class->perf_probe,
161 call);
162 case TRACE_REG_PERF_UNREGISTER:
163 tracepoint_probe_unregister(call->name,
164 call->class->perf_probe,
165 call);
166 return 0;
167#endif
168 }
169 return 0;
170}
171EXPORT_SYMBOL_GPL(ftrace_event_reg);
172
Li Zefane870e9a2010-07-02 11:07:32 +0800173void trace_event_enable_cmd_record(bool enable)
174{
175 struct ftrace_event_call *call;
176
177 mutex_lock(&event_mutex);
178 list_for_each_entry(call, &ftrace_events, list) {
179 if (!(call->flags & TRACE_EVENT_FL_ENABLED))
180 continue;
181
182 if (enable) {
183 tracing_start_cmdline_record();
184 call->flags |= TRACE_EVENT_FL_RECORDED_CMD;
185 } else {
186 tracing_stop_cmdline_record();
187 call->flags &= ~TRACE_EVENT_FL_RECORDED_CMD;
188 }
189 }
190 mutex_unlock(&event_mutex);
191}
192
Li Zefan3b8e4272009-12-08 11:14:52 +0800193static int ftrace_event_enable_disable(struct ftrace_event_call *call,
Steven Rostedtfd994982009-02-28 02:41:25 -0500194 int enable)
195{
Li Zefan3b8e4272009-12-08 11:14:52 +0800196 int ret = 0;
197
Steven Rostedtfd994982009-02-28 02:41:25 -0500198 switch (enable) {
199 case 0:
Steven Rostedt553552c2010-04-23 11:12:36 -0400200 if (call->flags & TRACE_EVENT_FL_ENABLED) {
201 call->flags &= ~TRACE_EVENT_FL_ENABLED;
Li Zefane870e9a2010-07-02 11:07:32 +0800202 if (call->flags & TRACE_EVENT_FL_RECORDED_CMD) {
203 tracing_stop_cmdline_record();
204 call->flags &= ~TRACE_EVENT_FL_RECORDED_CMD;
205 }
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400206 call->class->reg(call, TRACE_REG_UNREGISTER);
Steven Rostedtfd994982009-02-28 02:41:25 -0500207 }
Steven Rostedtfd994982009-02-28 02:41:25 -0500208 break;
209 case 1:
Steven Rostedt553552c2010-04-23 11:12:36 -0400210 if (!(call->flags & TRACE_EVENT_FL_ENABLED)) {
Li Zefane870e9a2010-07-02 11:07:32 +0800211 if (trace_flags & TRACE_ITER_RECORD_CMD) {
212 tracing_start_cmdline_record();
213 call->flags |= TRACE_EVENT_FL_RECORDED_CMD;
214 }
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400215 ret = call->class->reg(call, TRACE_REG_REGISTER);
Li Zefan3b8e4272009-12-08 11:14:52 +0800216 if (ret) {
217 tracing_stop_cmdline_record();
218 pr_info("event trace: Could not enable event "
219 "%s\n", call->name);
220 break;
221 }
Steven Rostedt553552c2010-04-23 11:12:36 -0400222 call->flags |= TRACE_EVENT_FL_ENABLED;
Steven Rostedtfd994982009-02-28 02:41:25 -0500223 }
Steven Rostedtfd994982009-02-28 02:41:25 -0500224 break;
225 }
Li Zefan3b8e4272009-12-08 11:14:52 +0800226
227 return ret;
Steven Rostedtfd994982009-02-28 02:41:25 -0500228}
229
Zhaolei0e907c92009-05-25 18:13:59 +0800230static void ftrace_clear_events(void)
231{
232 struct ftrace_event_call *call;
233
234 mutex_lock(&event_mutex);
235 list_for_each_entry(call, &ftrace_events, list) {
236 ftrace_event_enable_disable(call, 0);
237 }
238 mutex_unlock(&event_mutex);
239}
240
Li Zefan8f31bfe2009-05-08 10:31:42 +0800241/*
242 * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events.
243 */
244static int __ftrace_set_clr_event(const char *match, const char *sub,
245 const char *event, int set)
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500246{
Steven Rostedta59fd602009-04-10 13:52:20 -0400247 struct ftrace_event_call *call;
Steven Rostedt29f93942009-05-08 16:06:47 -0400248 int ret = -EINVAL;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500249
Steven Rostedt11a241a2009-03-02 11:49:04 -0500250 mutex_lock(&event_mutex);
Steven Rostedta59fd602009-04-10 13:52:20 -0400251 list_for_each_entry(call, &ftrace_events, list) {
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500252
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400253 if (!call->name || !call->class || !call->class->reg)
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500254 continue;
Steven Rostedt1473e442009-02-24 14:15:08 -0500255
Steven Rostedtb628b3e2009-02-27 23:32:58 -0500256 if (match &&
257 strcmp(match, call->name) != 0 &&
Steven Rostedt8f082012010-04-20 10:47:33 -0400258 strcmp(match, call->class->system) != 0)
Steven Rostedtb628b3e2009-02-27 23:32:58 -0500259 continue;
260
Steven Rostedt8f082012010-04-20 10:47:33 -0400261 if (sub && strcmp(sub, call->class->system) != 0)
Steven Rostedtb628b3e2009-02-27 23:32:58 -0500262 continue;
263
264 if (event && strcmp(event, call->name) != 0)
Steven Rostedt1473e442009-02-24 14:15:08 -0500265 continue;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500266
Steven Rostedtfd994982009-02-28 02:41:25 -0500267 ftrace_event_enable_disable(call, set);
268
Steven Rostedtb628b3e2009-02-27 23:32:58 -0500269 ret = 0;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500270 }
Steven Rostedt11a241a2009-03-02 11:49:04 -0500271 mutex_unlock(&event_mutex);
272
Steven Rostedtb628b3e2009-02-27 23:32:58 -0500273 return ret;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500274}
275
Li Zefan8f31bfe2009-05-08 10:31:42 +0800276static int ftrace_set_clr_event(char *buf, int set)
277{
278 char *event = NULL, *sub = NULL, *match;
279
280 /*
281 * The buf format can be <subsystem>:<event-name>
282 * *:<event-name> means any event by that name.
283 * :<event-name> is the same.
284 *
285 * <subsystem>:* means all events in that subsystem
286 * <subsystem>: means the same.
287 *
288 * <name> (no ':') means all events in a subsystem with
289 * the name <name> or any event that matches <name>
290 */
291
292 match = strsep(&buf, ":");
293 if (buf) {
294 sub = match;
295 event = buf;
296 match = NULL;
297
298 if (!strlen(sub) || strcmp(sub, "*") == 0)
299 sub = NULL;
300 if (!strlen(event) || strcmp(event, "*") == 0)
301 event = NULL;
302 }
303
304 return __ftrace_set_clr_event(match, sub, event, set);
305}
306
Steven Rostedt4671c792009-05-08 16:27:41 -0400307/**
308 * trace_set_clr_event - enable or disable an event
309 * @system: system name to match (NULL for any system)
310 * @event: event name to match (NULL for all events, within system)
311 * @set: 1 to enable, 0 to disable
312 *
313 * This is a way for other parts of the kernel to enable or disable
314 * event recording.
315 *
316 * Returns 0 on success, -EINVAL if the parameters do not match any
317 * registered events.
318 */
319int trace_set_clr_event(const char *system, const char *event, int set)
320{
321 return __ftrace_set_clr_event(NULL, system, event, set);
322}
323
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500324/* 128 should be much more than enough */
325#define EVENT_BUF_SIZE 127
326
327static ssize_t
328ftrace_event_write(struct file *file, const char __user *ubuf,
329 size_t cnt, loff_t *ppos)
330{
jolsa@redhat.com48966362009-09-11 17:29:28 +0200331 struct trace_parser parser;
Li Zefan4ba79782009-09-22 13:52:20 +0800332 ssize_t read, ret;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500333
Li Zefan4ba79782009-09-22 13:52:20 +0800334 if (!cnt)
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500335 return 0;
336
Steven Rostedt1852fcc2009-03-11 14:33:00 -0400337 ret = tracing_update_buffers();
338 if (ret < 0)
339 return ret;
340
jolsa@redhat.com48966362009-09-11 17:29:28 +0200341 if (trace_parser_get_init(&parser, EVENT_BUF_SIZE + 1))
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500342 return -ENOMEM;
343
jolsa@redhat.com48966362009-09-11 17:29:28 +0200344 read = trace_get_user(&parser, ubuf, cnt, ppos);
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500345
Li Zefan4ba79782009-09-22 13:52:20 +0800346 if (read >= 0 && trace_parser_loaded((&parser))) {
jolsa@redhat.com48966362009-09-11 17:29:28 +0200347 int set = 1;
348
349 if (*parser.buffer == '!')
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500350 set = 0;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500351
jolsa@redhat.com48966362009-09-11 17:29:28 +0200352 parser.buffer[parser.idx] = 0;
353
354 ret = ftrace_set_clr_event(parser.buffer + !set, set);
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500355 if (ret)
jolsa@redhat.com48966362009-09-11 17:29:28 +0200356 goto out_put;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500357 }
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500358
359 ret = read;
360
jolsa@redhat.com48966362009-09-11 17:29:28 +0200361 out_put:
362 trace_parser_put(&parser);
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500363
364 return ret;
365}
366
367static void *
368t_next(struct seq_file *m, void *v, loff_t *pos)
369{
Li Zefan30bd39c2009-09-18 14:07:05 +0800370 struct ftrace_event_call *call = v;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500371
372 (*pos)++;
373
Li Zefan30bd39c2009-09-18 14:07:05 +0800374 list_for_each_entry_continue(call, &ftrace_events, list) {
Steven Rostedt40e26812009-03-10 11:32:40 -0400375 /*
376 * The ftrace subsystem is for showing formats only.
377 * They can not be enabled or disabled via the event files.
378 */
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400379 if (call->class && call->class->reg)
Li Zefan30bd39c2009-09-18 14:07:05 +0800380 return call;
Steven Rostedt40e26812009-03-10 11:32:40 -0400381 }
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500382
Li Zefan30bd39c2009-09-18 14:07:05 +0800383 return NULL;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500384}
385
386static void *t_start(struct seq_file *m, loff_t *pos)
387{
Li Zefan30bd39c2009-09-18 14:07:05 +0800388 struct ftrace_event_call *call;
Li Zefane1c7e2a2009-06-24 09:52:29 +0800389 loff_t l;
390
Li Zefan20c89282009-05-06 10:33:45 +0800391 mutex_lock(&event_mutex);
Li Zefane1c7e2a2009-06-24 09:52:29 +0800392
Li Zefan30bd39c2009-09-18 14:07:05 +0800393 call = list_entry(&ftrace_events, struct ftrace_event_call, list);
Li Zefane1c7e2a2009-06-24 09:52:29 +0800394 for (l = 0; l <= *pos; ) {
Li Zefan30bd39c2009-09-18 14:07:05 +0800395 call = t_next(m, call, &l);
Li Zefane1c7e2a2009-06-24 09:52:29 +0800396 if (!call)
397 break;
398 }
399 return call;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500400}
401
402static void *
403s_next(struct seq_file *m, void *v, loff_t *pos)
404{
Li Zefan30bd39c2009-09-18 14:07:05 +0800405 struct ftrace_event_call *call = v;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500406
407 (*pos)++;
408
Li Zefan30bd39c2009-09-18 14:07:05 +0800409 list_for_each_entry_continue(call, &ftrace_events, list) {
Steven Rostedt553552c2010-04-23 11:12:36 -0400410 if (call->flags & TRACE_EVENT_FL_ENABLED)
Li Zefan30bd39c2009-09-18 14:07:05 +0800411 return call;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500412 }
413
Li Zefan30bd39c2009-09-18 14:07:05 +0800414 return NULL;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500415}
416
417static void *s_start(struct seq_file *m, loff_t *pos)
418{
Li Zefan30bd39c2009-09-18 14:07:05 +0800419 struct ftrace_event_call *call;
Li Zefane1c7e2a2009-06-24 09:52:29 +0800420 loff_t l;
421
Li Zefan20c89282009-05-06 10:33:45 +0800422 mutex_lock(&event_mutex);
Li Zefane1c7e2a2009-06-24 09:52:29 +0800423
Li Zefan30bd39c2009-09-18 14:07:05 +0800424 call = list_entry(&ftrace_events, struct ftrace_event_call, list);
Li Zefane1c7e2a2009-06-24 09:52:29 +0800425 for (l = 0; l <= *pos; ) {
Li Zefan30bd39c2009-09-18 14:07:05 +0800426 call = s_next(m, call, &l);
Li Zefane1c7e2a2009-06-24 09:52:29 +0800427 if (!call)
428 break;
429 }
430 return call;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500431}
432
433static int t_show(struct seq_file *m, void *v)
434{
435 struct ftrace_event_call *call = v;
436
Steven Rostedt8f082012010-04-20 10:47:33 -0400437 if (strcmp(call->class->system, TRACE_SYSTEM) != 0)
438 seq_printf(m, "%s:", call->class->system);
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500439 seq_printf(m, "%s\n", call->name);
440
441 return 0;
442}
443
444static void t_stop(struct seq_file *m, void *p)
445{
Li Zefan20c89282009-05-06 10:33:45 +0800446 mutex_unlock(&event_mutex);
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500447}
448
449static int
450ftrace_event_seq_open(struct inode *inode, struct file *file)
451{
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500452 const struct seq_operations *seq_ops;
453
454 if ((file->f_mode & FMODE_WRITE) &&
Steven Rostedt8650ae32009-07-22 23:29:30 -0400455 (file->f_flags & O_TRUNC))
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500456 ftrace_clear_events();
457
458 seq_ops = inode->i_private;
Li Zefan20c89282009-05-06 10:33:45 +0800459 return seq_open(file, seq_ops);
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500460}
461
Steven Rostedt1473e442009-02-24 14:15:08 -0500462static ssize_t
463event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
464 loff_t *ppos)
465{
466 struct ftrace_event_call *call = filp->private_data;
467 char *buf;
468
Steven Rostedt553552c2010-04-23 11:12:36 -0400469 if (call->flags & TRACE_EVENT_FL_ENABLED)
Steven Rostedt1473e442009-02-24 14:15:08 -0500470 buf = "1\n";
471 else
472 buf = "0\n";
473
474 return simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
475}
476
477static ssize_t
478event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
479 loff_t *ppos)
480{
481 struct ftrace_event_call *call = filp->private_data;
482 char buf[64];
483 unsigned long val;
484 int ret;
485
486 if (cnt >= sizeof(buf))
487 return -EINVAL;
488
489 if (copy_from_user(&buf, ubuf, cnt))
490 return -EFAULT;
491
492 buf[cnt] = 0;
493
494 ret = strict_strtoul(buf, 10, &val);
495 if (ret < 0)
496 return ret;
497
Steven Rostedt1852fcc2009-03-11 14:33:00 -0400498 ret = tracing_update_buffers();
499 if (ret < 0)
500 return ret;
501
Steven Rostedt1473e442009-02-24 14:15:08 -0500502 switch (val) {
503 case 0:
Steven Rostedt1473e442009-02-24 14:15:08 -0500504 case 1:
Steven Rostedt11a241a2009-03-02 11:49:04 -0500505 mutex_lock(&event_mutex);
Li Zefan3b8e4272009-12-08 11:14:52 +0800506 ret = ftrace_event_enable_disable(call, val);
Steven Rostedt11a241a2009-03-02 11:49:04 -0500507 mutex_unlock(&event_mutex);
Steven Rostedt1473e442009-02-24 14:15:08 -0500508 break;
509
510 default:
511 return -EINVAL;
512 }
513
514 *ppos += cnt;
515
Li Zefan3b8e4272009-12-08 11:14:52 +0800516 return ret ? ret : cnt;
Steven Rostedt1473e442009-02-24 14:15:08 -0500517}
518
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400519static ssize_t
520system_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
521 loff_t *ppos)
522{
Li Zefanc142b152009-05-08 10:32:05 +0800523 const char set_to_char[4] = { '?', '0', '1', 'X' };
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400524 const char *system = filp->private_data;
525 struct ftrace_event_call *call;
526 char buf[2];
Li Zefanc142b152009-05-08 10:32:05 +0800527 int set = 0;
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400528 int ret;
529
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400530 mutex_lock(&event_mutex);
531 list_for_each_entry(call, &ftrace_events, list) {
Steven Rostedta1d0ce82010-06-08 11:22:06 -0400532 if (!call->name || !call->class || !call->class->reg)
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400533 continue;
534
Steven Rostedt8f082012010-04-20 10:47:33 -0400535 if (system && strcmp(call->class->system, system) != 0)
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400536 continue;
537
538 /*
539 * We need to find out if all the events are set
540 * or if all events or cleared, or if we have
541 * a mixture.
542 */
Steven Rostedt553552c2010-04-23 11:12:36 -0400543 set |= (1 << !!(call->flags & TRACE_EVENT_FL_ENABLED));
Li Zefanc142b152009-05-08 10:32:05 +0800544
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400545 /*
546 * If we have a mixture, no need to look further.
547 */
Li Zefanc142b152009-05-08 10:32:05 +0800548 if (set == 3)
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400549 break;
550 }
551 mutex_unlock(&event_mutex);
552
Li Zefanc142b152009-05-08 10:32:05 +0800553 buf[0] = set_to_char[set];
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400554 buf[1] = '\n';
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400555
556 ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
557
558 return ret;
559}
560
561static ssize_t
562system_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
563 loff_t *ppos)
564{
565 const char *system = filp->private_data;
566 unsigned long val;
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400567 char buf[64];
568 ssize_t ret;
569
570 if (cnt >= sizeof(buf))
571 return -EINVAL;
572
573 if (copy_from_user(&buf, ubuf, cnt))
574 return -EFAULT;
575
576 buf[cnt] = 0;
577
578 ret = strict_strtoul(buf, 10, &val);
579 if (ret < 0)
580 return ret;
581
582 ret = tracing_update_buffers();
583 if (ret < 0)
584 return ret;
585
Li Zefan8f31bfe2009-05-08 10:31:42 +0800586 if (val != 0 && val != 1)
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400587 return -EINVAL;
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400588
Li Zefan8f31bfe2009-05-08 10:31:42 +0800589 ret = __ftrace_set_clr_event(NULL, system, NULL, val);
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400590 if (ret)
Li Zefan8f31bfe2009-05-08 10:31:42 +0800591 goto out;
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400592
593 ret = cnt;
594
Li Zefan8f31bfe2009-05-08 10:31:42 +0800595out:
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400596 *ppos += cnt;
597
598 return ret;
599}
600
Steven Rostedt2a37a3d2010-06-03 15:21:34 -0400601enum {
602 FORMAT_HEADER = 1,
Li Zefan86397dc2010-08-17 13:53:06 +0800603 FORMAT_FIELD_SEPERATOR = 2,
604 FORMAT_PRINTFMT = 3,
Steven Rostedt2a37a3d2010-06-03 15:21:34 -0400605};
606
607static void *f_next(struct seq_file *m, void *v, loff_t *pos)
Steven Rostedt981d0812009-03-02 13:53:59 -0500608{
Steven Rostedt2a37a3d2010-06-03 15:21:34 -0400609 struct ftrace_event_call *call = m->private;
Lai Jiangshan5a65e952009-12-15 15:39:53 +0800610 struct ftrace_event_field *field;
Li Zefan86397dc2010-08-17 13:53:06 +0800611 struct list_head *common_head = &ftrace_common_fields;
612 struct list_head *head = trace_get_fields(call);
Steven Rostedt981d0812009-03-02 13:53:59 -0500613
Steven Rostedt2a37a3d2010-06-03 15:21:34 -0400614 (*pos)++;
Lai Jiangshan5a65e952009-12-15 15:39:53 +0800615
Steven Rostedt2a37a3d2010-06-03 15:21:34 -0400616 switch ((unsigned long)v) {
617 case FORMAT_HEADER:
Li Zefan86397dc2010-08-17 13:53:06 +0800618 if (unlikely(list_empty(common_head)))
619 return NULL;
Lai Jiangshan5a65e952009-12-15 15:39:53 +0800620
Li Zefan86397dc2010-08-17 13:53:06 +0800621 field = list_entry(common_head->prev,
622 struct ftrace_event_field, link);
623 return field;
624
625 case FORMAT_FIELD_SEPERATOR:
Steven Rostedt2a37a3d2010-06-03 15:21:34 -0400626 if (unlikely(list_empty(head)))
627 return NULL;
Lai Jiangshan5a65e952009-12-15 15:39:53 +0800628
Steven Rostedt2a37a3d2010-06-03 15:21:34 -0400629 field = list_entry(head->prev, struct ftrace_event_field, link);
630 return field;
Lai Jiangshan5a65e952009-12-15 15:39:53 +0800631
Steven Rostedt2a37a3d2010-06-03 15:21:34 -0400632 case FORMAT_PRINTFMT:
633 /* all done */
634 return NULL;
Lai Jiangshan5a65e952009-12-15 15:39:53 +0800635 }
636
Steven Rostedt2a37a3d2010-06-03 15:21:34 -0400637 field = v;
Li Zefan86397dc2010-08-17 13:53:06 +0800638 if (field->link.prev == common_head)
639 return (void *)FORMAT_FIELD_SEPERATOR;
640 else if (field->link.prev == head)
Steven Rostedt2a37a3d2010-06-03 15:21:34 -0400641 return (void *)FORMAT_PRINTFMT;
642
643 field = list_entry(field->link.prev, struct ftrace_event_field, link);
644
Steven Rostedt2a37a3d2010-06-03 15:21:34 -0400645 return field;
Li Zefan8728fe52010-05-24 16:22:49 +0800646}
Lai Jiangshan5a65e952009-12-15 15:39:53 +0800647
Steven Rostedt2a37a3d2010-06-03 15:21:34 -0400648static void *f_start(struct seq_file *m, loff_t *pos)
Li Zefan8728fe52010-05-24 16:22:49 +0800649{
Steven Rostedt2a37a3d2010-06-03 15:21:34 -0400650 loff_t l = 0;
651 void *p;
Li Zefan8728fe52010-05-24 16:22:49 +0800652
Steven Rostedt2a37a3d2010-06-03 15:21:34 -0400653 /* Start by showing the header */
654 if (!*pos)
655 return (void *)FORMAT_HEADER;
656
657 p = (void *)FORMAT_HEADER;
658 do {
659 p = f_next(m, p, &l);
660 } while (p && l < *pos);
661
662 return p;
663}
664
665static int f_show(struct seq_file *m, void *v)
666{
667 struct ftrace_event_call *call = m->private;
668 struct ftrace_event_field *field;
669 const char *array_descriptor;
670
671 switch ((unsigned long)v) {
672 case FORMAT_HEADER:
673 seq_printf(m, "name: %s\n", call->name);
674 seq_printf(m, "ID: %d\n", call->event.type);
675 seq_printf(m, "format:\n");
Li Zefan8728fe52010-05-24 16:22:49 +0800676 return 0;
677
Li Zefan86397dc2010-08-17 13:53:06 +0800678 case FORMAT_FIELD_SEPERATOR:
679 seq_putc(m, '\n');
680 return 0;
681
Steven Rostedt2a37a3d2010-06-03 15:21:34 -0400682 case FORMAT_PRINTFMT:
683 seq_printf(m, "\nprint fmt: %s\n",
684 call->print_fmt);
685 return 0;
Steven Rostedt981d0812009-03-02 13:53:59 -0500686 }
687
Steven Rostedt2a37a3d2010-06-03 15:21:34 -0400688 field = v;
689
690 /*
691 * Smartly shows the array type(except dynamic array).
692 * Normal:
693 * field:TYPE VAR
694 * If TYPE := TYPE[LEN], it is shown:
695 * field:TYPE VAR[LEN]
696 */
697 array_descriptor = strchr(field->type, '[');
698
699 if (!strncmp(field->type, "__data_loc", 10))
700 array_descriptor = NULL;
701
702 if (!array_descriptor)
703 seq_printf(m, "\tfield:%s %s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
704 field->type, field->name, field->offset,
705 field->size, !!field->is_signed);
706 else
707 seq_printf(m, "\tfield:%.*s %s%s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
708 (int)(array_descriptor - field->type),
709 field->type, field->name,
710 array_descriptor, field->offset,
711 field->size, !!field->is_signed);
712
713 return 0;
714}
715
716static void f_stop(struct seq_file *m, void *p)
717{
718}
719
720static const struct seq_operations trace_format_seq_ops = {
721 .start = f_start,
722 .next = f_next,
723 .stop = f_stop,
724 .show = f_show,
725};
726
727static int trace_format_open(struct inode *inode, struct file *file)
728{
729 struct ftrace_event_call *call = inode->i_private;
730 struct seq_file *m;
731 int ret;
732
733 ret = seq_open(file, &trace_format_seq_ops);
734 if (ret < 0)
735 return ret;
736
737 m = file->private_data;
738 m->private = call;
739
740 return 0;
Steven Rostedt981d0812009-03-02 13:53:59 -0500741}
742
Peter Zijlstra23725ae2009-03-19 20:26:13 +0100743static ssize_t
744event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
745{
746 struct ftrace_event_call *call = filp->private_data;
747 struct trace_seq *s;
748 int r;
749
750 if (*ppos)
751 return 0;
752
753 s = kmalloc(sizeof(*s), GFP_KERNEL);
754 if (!s)
755 return -ENOMEM;
756
757 trace_seq_init(s);
Steven Rostedt32c0eda2010-04-23 10:38:03 -0400758 trace_seq_printf(s, "%d\n", call->event.type);
Peter Zijlstra23725ae2009-03-19 20:26:13 +0100759
760 r = simple_read_from_buffer(ubuf, cnt, ppos,
761 s->buffer, s->len);
762 kfree(s);
763 return r;
764}
765
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500766static ssize_t
767event_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
768 loff_t *ppos)
769{
770 struct ftrace_event_call *call = filp->private_data;
771 struct trace_seq *s;
772 int r;
773
774 if (*ppos)
775 return 0;
776
777 s = kmalloc(sizeof(*s), GFP_KERNEL);
778 if (!s)
779 return -ENOMEM;
780
781 trace_seq_init(s);
782
Tom Zanussi8b372562009-04-28 03:04:59 -0500783 print_event_filter(call, s);
Tom Zanussi4bda2d52009-03-24 02:14:31 -0500784 r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500785
786 kfree(s);
787
788 return r;
789}
790
791static ssize_t
792event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
793 loff_t *ppos)
794{
795 struct ftrace_event_call *call = filp->private_data;
Tom Zanussi8b372562009-04-28 03:04:59 -0500796 char *buf;
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500797 int err;
798
Tom Zanussi8b372562009-04-28 03:04:59 -0500799 if (cnt >= PAGE_SIZE)
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500800 return -EINVAL;
801
Tom Zanussi8b372562009-04-28 03:04:59 -0500802 buf = (char *)__get_free_page(GFP_TEMPORARY);
803 if (!buf)
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500804 return -ENOMEM;
805
Tom Zanussi8b372562009-04-28 03:04:59 -0500806 if (copy_from_user(buf, ubuf, cnt)) {
807 free_page((unsigned long) buf);
808 return -EFAULT;
809 }
810 buf[cnt] = '\0';
811
812 err = apply_event_filter(call, buf);
813 free_page((unsigned long) buf);
814 if (err < 0)
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500815 return err;
Tom Zanussi0a19e532009-04-13 03:17:50 -0500816
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500817 *ppos += cnt;
818
819 return cnt;
820}
821
Tom Zanussicfb180f2009-03-22 03:31:17 -0500822static ssize_t
823subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
824 loff_t *ppos)
825{
826 struct event_subsystem *system = filp->private_data;
827 struct trace_seq *s;
828 int r;
829
830 if (*ppos)
831 return 0;
832
833 s = kmalloc(sizeof(*s), GFP_KERNEL);
834 if (!s)
835 return -ENOMEM;
836
837 trace_seq_init(s);
838
Tom Zanussi8b372562009-04-28 03:04:59 -0500839 print_subsystem_event_filter(system, s);
Tom Zanussi4bda2d52009-03-24 02:14:31 -0500840 r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
Tom Zanussicfb180f2009-03-22 03:31:17 -0500841
842 kfree(s);
843
844 return r;
845}
846
847static ssize_t
848subsystem_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
849 loff_t *ppos)
850{
851 struct event_subsystem *system = filp->private_data;
Tom Zanussi8b372562009-04-28 03:04:59 -0500852 char *buf;
Tom Zanussicfb180f2009-03-22 03:31:17 -0500853 int err;
854
Tom Zanussi8b372562009-04-28 03:04:59 -0500855 if (cnt >= PAGE_SIZE)
Tom Zanussicfb180f2009-03-22 03:31:17 -0500856 return -EINVAL;
857
Tom Zanussi8b372562009-04-28 03:04:59 -0500858 buf = (char *)__get_free_page(GFP_TEMPORARY);
859 if (!buf)
Tom Zanussicfb180f2009-03-22 03:31:17 -0500860 return -ENOMEM;
861
Tom Zanussi8b372562009-04-28 03:04:59 -0500862 if (copy_from_user(buf, ubuf, cnt)) {
863 free_page((unsigned long) buf);
864 return -EFAULT;
Tom Zanussicfb180f2009-03-22 03:31:17 -0500865 }
Tom Zanussi8b372562009-04-28 03:04:59 -0500866 buf[cnt] = '\0';
Tom Zanussicfb180f2009-03-22 03:31:17 -0500867
Tom Zanussi8b372562009-04-28 03:04:59 -0500868 err = apply_subsystem_event_filter(system, buf);
869 free_page((unsigned long) buf);
870 if (err < 0)
Li Zefan44e9c8b2009-04-11 15:55:28 +0800871 return err;
Tom Zanussicfb180f2009-03-22 03:31:17 -0500872
873 *ppos += cnt;
874
875 return cnt;
876}
877
Steven Rostedtd1b182a2009-04-15 16:53:47 -0400878static ssize_t
879show_header(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
880{
881 int (*func)(struct trace_seq *s) = filp->private_data;
882 struct trace_seq *s;
883 int r;
884
885 if (*ppos)
886 return 0;
887
888 s = kmalloc(sizeof(*s), GFP_KERNEL);
889 if (!s)
890 return -ENOMEM;
891
892 trace_seq_init(s);
893
894 func(s);
895 r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
896
897 kfree(s);
898
899 return r;
900}
901
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500902static const struct seq_operations show_event_seq_ops = {
903 .start = t_start,
904 .next = t_next,
905 .show = t_show,
906 .stop = t_stop,
907};
908
909static const struct seq_operations show_set_event_seq_ops = {
910 .start = s_start,
911 .next = s_next,
912 .show = t_show,
913 .stop = t_stop,
914};
915
Steven Rostedt2314c4a2009-03-10 12:04:02 -0400916static const struct file_operations ftrace_avail_fops = {
917 .open = ftrace_event_seq_open,
918 .read = seq_read,
919 .llseek = seq_lseek,
920 .release = seq_release,
921};
922
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500923static const struct file_operations ftrace_set_event_fops = {
924 .open = ftrace_event_seq_open,
925 .read = seq_read,
926 .write = ftrace_event_write,
927 .llseek = seq_lseek,
928 .release = seq_release,
929};
930
Steven Rostedt1473e442009-02-24 14:15:08 -0500931static const struct file_operations ftrace_enable_fops = {
932 .open = tracing_open_generic,
933 .read = event_enable_read,
934 .write = event_enable_write,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200935 .llseek = default_llseek,
Steven Rostedt1473e442009-02-24 14:15:08 -0500936};
937
Steven Rostedt981d0812009-03-02 13:53:59 -0500938static const struct file_operations ftrace_event_format_fops = {
Steven Rostedt2a37a3d2010-06-03 15:21:34 -0400939 .open = trace_format_open,
940 .read = seq_read,
941 .llseek = seq_lseek,
942 .release = seq_release,
Steven Rostedt981d0812009-03-02 13:53:59 -0500943};
944
Peter Zijlstra23725ae2009-03-19 20:26:13 +0100945static const struct file_operations ftrace_event_id_fops = {
946 .open = tracing_open_generic,
947 .read = event_id_read,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200948 .llseek = default_llseek,
Peter Zijlstra23725ae2009-03-19 20:26:13 +0100949};
950
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500951static const struct file_operations ftrace_event_filter_fops = {
952 .open = tracing_open_generic,
953 .read = event_filter_read,
954 .write = event_filter_write,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200955 .llseek = default_llseek,
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500956};
957
Tom Zanussicfb180f2009-03-22 03:31:17 -0500958static const struct file_operations ftrace_subsystem_filter_fops = {
959 .open = tracing_open_generic,
960 .read = subsystem_filter_read,
961 .write = subsystem_filter_write,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200962 .llseek = default_llseek,
Tom Zanussicfb180f2009-03-22 03:31:17 -0500963};
964
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400965static const struct file_operations ftrace_system_enable_fops = {
966 .open = tracing_open_generic,
967 .read = system_enable_read,
968 .write = system_enable_write,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200969 .llseek = default_llseek,
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400970};
971
Steven Rostedtd1b182a2009-04-15 16:53:47 -0400972static const struct file_operations ftrace_show_header_fops = {
973 .open = tracing_open_generic,
974 .read = show_header,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200975 .llseek = default_llseek,
Steven Rostedtd1b182a2009-04-15 16:53:47 -0400976};
977
Steven Rostedt1473e442009-02-24 14:15:08 -0500978static struct dentry *event_trace_events_dir(void)
979{
980 static struct dentry *d_tracer;
981 static struct dentry *d_events;
982
983 if (d_events)
984 return d_events;
985
986 d_tracer = tracing_init_dentry();
987 if (!d_tracer)
988 return NULL;
989
990 d_events = debugfs_create_dir("events", d_tracer);
991 if (!d_events)
992 pr_warning("Could not create debugfs "
993 "'events' directory\n");
994
995 return d_events;
996}
997
Steven Rostedt6ecc2d12009-02-27 21:33:02 -0500998static LIST_HEAD(event_subsystems);
999
1000static struct dentry *
1001event_subsystem_dir(const char *name, struct dentry *d_events)
1002{
1003 struct event_subsystem *system;
Tom Zanussie1112b42009-03-31 00:48:49 -05001004 struct dentry *entry;
Steven Rostedt6ecc2d12009-02-27 21:33:02 -05001005
1006 /* First see if we did not already create this dir */
1007 list_for_each_entry(system, &event_subsystems, list) {
Xiao Guangrongdc82ec98a2009-07-09 16:22:22 +08001008 if (strcmp(system->name, name) == 0) {
1009 system->nr_events++;
Steven Rostedt6ecc2d12009-02-27 21:33:02 -05001010 return system->entry;
Xiao Guangrongdc82ec98a2009-07-09 16:22:22 +08001011 }
Steven Rostedt6ecc2d12009-02-27 21:33:02 -05001012 }
1013
1014 /* need to create new entry */
1015 system = kmalloc(sizeof(*system), GFP_KERNEL);
1016 if (!system) {
1017 pr_warning("No memory to create event subsystem %s\n",
1018 name);
1019 return d_events;
1020 }
1021
1022 system->entry = debugfs_create_dir(name, d_events);
1023 if (!system->entry) {
1024 pr_warning("Could not create event subsystem %s\n",
1025 name);
1026 kfree(system);
1027 return d_events;
1028 }
1029
Xiao Guangrongdc82ec98a2009-07-09 16:22:22 +08001030 system->nr_events = 1;
Steven Rostedt6d723732009-04-10 14:53:50 -04001031 system->name = kstrdup(name, GFP_KERNEL);
1032 if (!system->name) {
1033 debugfs_remove(system->entry);
1034 kfree(system);
1035 return d_events;
1036 }
1037
Steven Rostedt6ecc2d12009-02-27 21:33:02 -05001038 list_add(&system->list, &event_subsystems);
1039
Tom Zanussi30e673b2009-04-28 03:04:47 -05001040 system->filter = NULL;
Tom Zanussicfb180f2009-03-22 03:31:17 -05001041
Tom Zanussi8b372562009-04-28 03:04:59 -05001042 system->filter = kzalloc(sizeof(struct event_filter), GFP_KERNEL);
1043 if (!system->filter) {
1044 pr_warning("Could not allocate filter for subsystem "
1045 "'%s'\n", name);
1046 return system->entry;
1047 }
1048
Tom Zanussie1112b42009-03-31 00:48:49 -05001049 entry = debugfs_create_file("filter", 0644, system->entry, system,
1050 &ftrace_subsystem_filter_fops);
Tom Zanussi8b372562009-04-28 03:04:59 -05001051 if (!entry) {
1052 kfree(system->filter);
1053 system->filter = NULL;
Tom Zanussie1112b42009-03-31 00:48:49 -05001054 pr_warning("Could not create debugfs "
1055 "'%s/filter' entry\n", name);
Tom Zanussi8b372562009-04-28 03:04:59 -05001056 }
Tom Zanussie1112b42009-03-31 00:48:49 -05001057
Frederic Weisbeckerf3f3f002009-09-24 15:27:41 +02001058 trace_create_file("enable", 0644, system->entry,
1059 (void *)system->name,
1060 &ftrace_system_enable_fops);
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001061
Steven Rostedt6ecc2d12009-02-27 21:33:02 -05001062 return system->entry;
1063}
1064
Steven Rostedt1473e442009-02-24 14:15:08 -05001065static int
Steven Rostedt701970b2009-04-24 23:11:22 -04001066event_create_dir(struct ftrace_event_call *call, struct dentry *d_events,
1067 const struct file_operations *id,
1068 const struct file_operations *enable,
1069 const struct file_operations *filter,
1070 const struct file_operations *format)
Steven Rostedt1473e442009-02-24 14:15:08 -05001071{
Steven Rostedt2e33af02010-04-22 10:35:55 -04001072 struct list_head *head;
Steven Rostedtfd994982009-02-28 02:41:25 -05001073 int ret;
Steven Rostedt1473e442009-02-24 14:15:08 -05001074
Steven Rostedt6ecc2d12009-02-27 21:33:02 -05001075 /*
1076 * If the trace point header did not define TRACE_SYSTEM
1077 * then the system would be called "TRACE_SYSTEM".
1078 */
Steven Rostedt8f082012010-04-20 10:47:33 -04001079 if (strcmp(call->class->system, TRACE_SYSTEM) != 0)
1080 d_events = event_subsystem_dir(call->class->system, d_events);
Steven Rostedt6ecc2d12009-02-27 21:33:02 -05001081
Steven Rostedt1473e442009-02-24 14:15:08 -05001082 call->dir = debugfs_create_dir(call->name, d_events);
1083 if (!call->dir) {
1084 pr_warning("Could not create debugfs "
1085 "'%s' directory\n", call->name);
1086 return -1;
1087 }
1088
Steven Rostedta1d0ce82010-06-08 11:22:06 -04001089 if (call->class->reg)
Frederic Weisbeckerf3f3f002009-09-24 15:27:41 +02001090 trace_create_file("enable", 0644, call->dir, call,
1091 enable);
Steven Rostedt1473e442009-02-24 14:15:08 -05001092
Steven Rostedt22392912010-04-21 12:27:06 -04001093#ifdef CONFIG_PERF_EVENTS
Steven Rostedta1d0ce82010-06-08 11:22:06 -04001094 if (call->event.type && call->class->reg)
Frederic Weisbeckerf3f3f002009-09-24 15:27:41 +02001095 trace_create_file("id", 0444, call->dir, call,
1096 id);
Steven Rostedt22392912010-04-21 12:27:06 -04001097#endif
Peter Zijlstra23725ae2009-03-19 20:26:13 +01001098
Li Zefanc9d932c2010-05-24 16:24:28 +08001099 /*
1100 * Other events may have the same class. Only update
1101 * the fields if they are not already defined.
1102 */
1103 head = trace_get_fields(call);
1104 if (list_empty(head)) {
1105 ret = call->class->define_fields(call);
1106 if (ret < 0) {
1107 pr_warning("Could not initialize trace point"
1108 " events/%s\n", call->name);
1109 return ret;
Tom Zanussicf027f62009-03-22 03:30:39 -05001110 }
1111 }
Li Zefanc9d932c2010-05-24 16:24:28 +08001112 trace_create_file("filter", 0644, call->dir, call,
1113 filter);
Tom Zanussicf027f62009-03-22 03:30:39 -05001114
Frederic Weisbeckerf3f3f002009-09-24 15:27:41 +02001115 trace_create_file("format", 0444, call->dir, call,
1116 format);
Steven Rostedtfd994982009-02-28 02:41:25 -05001117
Steven Rostedt1473e442009-02-24 14:15:08 -05001118 return 0;
1119}
1120
Li Zefan67ead0a2010-05-24 16:25:13 +08001121static int
1122__trace_add_event_call(struct ftrace_event_call *call, struct module *mod,
1123 const struct file_operations *id,
1124 const struct file_operations *enable,
1125 const struct file_operations *filter,
1126 const struct file_operations *format)
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04001127{
1128 struct dentry *d_events;
1129 int ret;
Steven Rostedt6d723732009-04-10 14:53:50 -04001130
Li Zefan67ead0a2010-05-24 16:25:13 +08001131 /* The linker may leave blanks */
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04001132 if (!call->name)
1133 return -EINVAL;
Steven Rostedt701970b2009-04-24 23:11:22 -04001134
Steven Rostedt0405ab82010-04-22 11:46:44 -04001135 if (call->class->raw_init) {
1136 ret = call->class->raw_init(call);
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04001137 if (ret < 0) {
1138 if (ret != -ENOSYS)
Li Zefan67ead0a2010-05-24 16:25:13 +08001139 pr_warning("Could not initialize trace events/%s\n",
1140 call->name);
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04001141 return ret;
1142 }
1143 }
Steven Rostedt701970b2009-04-24 23:11:22 -04001144
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04001145 d_events = event_trace_events_dir();
1146 if (!d_events)
1147 return -ENOENT;
1148
Li Zefan67ead0a2010-05-24 16:25:13 +08001149 ret = event_create_dir(call, d_events, id, enable, filter, format);
Masami Hiramatsu88f70d72009-09-25 11:20:54 -07001150 if (!ret)
1151 list_add(&call->list, &ftrace_events);
Li Zefan67ead0a2010-05-24 16:25:13 +08001152 call->mod = mod;
Masami Hiramatsu88f70d72009-09-25 11:20:54 -07001153
Masami Hiramatsu588bebb2009-09-16 11:42:55 -04001154 return ret;
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04001155}
1156
1157/* Add an additional event_call dynamically */
1158int trace_add_event_call(struct ftrace_event_call *call)
1159{
1160 int ret;
1161 mutex_lock(&event_mutex);
Li Zefan67ead0a2010-05-24 16:25:13 +08001162 ret = __trace_add_event_call(call, NULL, &ftrace_event_id_fops,
1163 &ftrace_enable_fops,
1164 &ftrace_event_filter_fops,
1165 &ftrace_event_format_fops);
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04001166 mutex_unlock(&event_mutex);
1167 return ret;
1168}
Steven Rostedt701970b2009-04-24 23:11:22 -04001169
Frederic Weisbeckera2ca5e02009-08-06 07:32:21 +02001170static void remove_subsystem_dir(const char *name)
1171{
1172 struct event_subsystem *system;
1173
1174 if (strcmp(name, TRACE_SYSTEM) == 0)
1175 return;
1176
1177 list_for_each_entry(system, &event_subsystems, list) {
1178 if (strcmp(system->name, name) == 0) {
1179 if (!--system->nr_events) {
1180 struct event_filter *filter = system->filter;
1181
1182 debugfs_remove_recursive(system->entry);
1183 list_del(&system->list);
1184 if (filter) {
1185 kfree(filter->filter_string);
1186 kfree(filter);
1187 }
1188 kfree(system->name);
1189 kfree(system);
1190 }
1191 break;
1192 }
1193 }
1194}
1195
Masami Hiramatsu4fead8e2009-09-14 16:49:12 -04001196/*
1197 * Must be called under locking both of event_mutex and trace_event_mutex.
1198 */
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04001199static void __trace_remove_event_call(struct ftrace_event_call *call)
1200{
1201 ftrace_event_enable_disable(call, 0);
Steven Rostedt80decc72010-04-23 10:00:22 -04001202 if (call->event.funcs)
1203 __unregister_ftrace_event(&call->event);
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04001204 debugfs_remove_recursive(call->dir);
1205 list_del(&call->list);
1206 trace_destroy_fields(call);
1207 destroy_preds(call);
Steven Rostedt8f082012010-04-20 10:47:33 -04001208 remove_subsystem_dir(call->class->system);
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04001209}
1210
1211/* Remove an event_call */
1212void trace_remove_event_call(struct ftrace_event_call *call)
1213{
1214 mutex_lock(&event_mutex);
Masami Hiramatsu4fead8e2009-09-14 16:49:12 -04001215 down_write(&trace_event_mutex);
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04001216 __trace_remove_event_call(call);
Masami Hiramatsu4fead8e2009-09-14 16:49:12 -04001217 up_write(&trace_event_mutex);
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04001218 mutex_unlock(&event_mutex);
1219}
1220
1221#define for_each_event(event, start, end) \
1222 for (event = start; \
1223 (unsigned long)event < (unsigned long)end; \
1224 event++)
1225
1226#ifdef CONFIG_MODULES
1227
1228static LIST_HEAD(ftrace_module_file_list);
1229
1230/*
1231 * Modules must own their file_operations to keep up with
1232 * reference counting.
1233 */
1234struct ftrace_module_file_ops {
1235 struct list_head list;
1236 struct module *mod;
1237 struct file_operations id;
1238 struct file_operations enable;
1239 struct file_operations format;
1240 struct file_operations filter;
1241};
1242
Steven Rostedt701970b2009-04-24 23:11:22 -04001243static struct ftrace_module_file_ops *
1244trace_create_file_ops(struct module *mod)
1245{
1246 struct ftrace_module_file_ops *file_ops;
1247
1248 /*
1249 * This is a bit of a PITA. To allow for correct reference
1250 * counting, modules must "own" their file_operations.
1251 * To do this, we allocate the file operations that will be
1252 * used in the event directory.
1253 */
1254
1255 file_ops = kmalloc(sizeof(*file_ops), GFP_KERNEL);
1256 if (!file_ops)
1257 return NULL;
1258
1259 file_ops->mod = mod;
1260
1261 file_ops->id = ftrace_event_id_fops;
1262 file_ops->id.owner = mod;
1263
1264 file_ops->enable = ftrace_enable_fops;
1265 file_ops->enable.owner = mod;
1266
1267 file_ops->filter = ftrace_event_filter_fops;
1268 file_ops->filter.owner = mod;
1269
1270 file_ops->format = ftrace_event_format_fops;
1271 file_ops->format.owner = mod;
1272
1273 list_add(&file_ops->list, &ftrace_module_file_list);
1274
1275 return file_ops;
1276}
1277
Steven Rostedt6d723732009-04-10 14:53:50 -04001278static void trace_module_add_events(struct module *mod)
1279{
Steven Rostedt701970b2009-04-24 23:11:22 -04001280 struct ftrace_module_file_ops *file_ops = NULL;
Steven Rostedt6d723732009-04-10 14:53:50 -04001281 struct ftrace_event_call *call, *start, *end;
Steven Rostedt6d723732009-04-10 14:53:50 -04001282
1283 start = mod->trace_events;
1284 end = mod->trace_events + mod->num_trace_events;
1285
1286 if (start == end)
1287 return;
1288
Li Zefan67ead0a2010-05-24 16:25:13 +08001289 file_ops = trace_create_file_ops(mod);
1290 if (!file_ops)
Steven Rostedt6d723732009-04-10 14:53:50 -04001291 return;
1292
1293 for_each_event(call, start, end) {
Li Zefan67ead0a2010-05-24 16:25:13 +08001294 __trace_add_event_call(call, mod,
Masami Hiramatsu88f70d72009-09-25 11:20:54 -07001295 &file_ops->id, &file_ops->enable,
1296 &file_ops->filter, &file_ops->format);
Steven Rostedt6d723732009-04-10 14:53:50 -04001297 }
1298}
1299
1300static void trace_module_remove_events(struct module *mod)
1301{
Steven Rostedt701970b2009-04-24 23:11:22 -04001302 struct ftrace_module_file_ops *file_ops;
Steven Rostedt6d723732009-04-10 14:53:50 -04001303 struct ftrace_event_call *call, *p;
Steven Rostedt9456f0f2009-05-06 21:54:09 -04001304 bool found = false;
Steven Rostedt6d723732009-04-10 14:53:50 -04001305
Steven Rostedt110bf2b2009-06-09 17:29:07 -04001306 down_write(&trace_event_mutex);
Steven Rostedt6d723732009-04-10 14:53:50 -04001307 list_for_each_entry_safe(call, p, &ftrace_events, list) {
1308 if (call->mod == mod) {
Steven Rostedt9456f0f2009-05-06 21:54:09 -04001309 found = true;
Masami Hiramatsubd1a5c82009-08-13 16:34:53 -04001310 __trace_remove_event_call(call);
Steven Rostedt6d723732009-04-10 14:53:50 -04001311 }
1312 }
Steven Rostedt701970b2009-04-24 23:11:22 -04001313
1314 /* Now free the file_operations */
1315 list_for_each_entry(file_ops, &ftrace_module_file_list, list) {
1316 if (file_ops->mod == mod)
1317 break;
1318 }
1319 if (&file_ops->list != &ftrace_module_file_list) {
1320 list_del(&file_ops->list);
1321 kfree(file_ops);
1322 }
Steven Rostedt9456f0f2009-05-06 21:54:09 -04001323
1324 /*
1325 * It is safest to reset the ring buffer if the module being unloaded
1326 * registered any events.
1327 */
1328 if (found)
1329 tracing_reset_current_online_cpus();
Steven Rostedt110bf2b2009-06-09 17:29:07 -04001330 up_write(&trace_event_mutex);
Steven Rostedt6d723732009-04-10 14:53:50 -04001331}
1332
Steven Rostedt61f919a2009-04-14 18:22:32 -04001333static int trace_module_notify(struct notifier_block *self,
1334 unsigned long val, void *data)
Steven Rostedt6d723732009-04-10 14:53:50 -04001335{
1336 struct module *mod = data;
1337
1338 mutex_lock(&event_mutex);
1339 switch (val) {
1340 case MODULE_STATE_COMING:
1341 trace_module_add_events(mod);
1342 break;
1343 case MODULE_STATE_GOING:
1344 trace_module_remove_events(mod);
1345 break;
1346 }
1347 mutex_unlock(&event_mutex);
1348
1349 return 0;
1350}
Steven Rostedt61f919a2009-04-14 18:22:32 -04001351#else
1352static int trace_module_notify(struct notifier_block *self,
1353 unsigned long val, void *data)
1354{
1355 return 0;
1356}
1357#endif /* CONFIG_MODULES */
Steven Rostedt6d723732009-04-10 14:53:50 -04001358
Steven Rostedtec827c72009-09-14 10:50:23 -04001359static struct notifier_block trace_module_nb = {
Steven Rostedt6d723732009-04-10 14:53:50 -04001360 .notifier_call = trace_module_notify,
1361 .priority = 0,
1362};
1363
Steven Rostedta59fd602009-04-10 13:52:20 -04001364extern struct ftrace_event_call __start_ftrace_events[];
1365extern struct ftrace_event_call __stop_ftrace_events[];
1366
Li Zefan020e5f82009-07-01 10:47:05 +08001367static char bootup_event_buf[COMMAND_LINE_SIZE] __initdata;
1368
1369static __init int setup_trace_event(char *str)
1370{
1371 strlcpy(bootup_event_buf, str, COMMAND_LINE_SIZE);
1372 ring_buffer_expanded = 1;
1373 tracing_selftest_disabled = 1;
1374
1375 return 1;
1376}
1377__setup("trace_event=", setup_trace_event);
1378
Steven Rostedtb77e38a2009-02-24 10:21:36 -05001379static __init int event_trace_init(void)
1380{
Steven Rostedta59fd602009-04-10 13:52:20 -04001381 struct ftrace_event_call *call;
Steven Rostedtb77e38a2009-02-24 10:21:36 -05001382 struct dentry *d_tracer;
1383 struct dentry *entry;
Steven Rostedt1473e442009-02-24 14:15:08 -05001384 struct dentry *d_events;
Steven Rostedt6d723732009-04-10 14:53:50 -04001385 int ret;
Li Zefan020e5f82009-07-01 10:47:05 +08001386 char *buf = bootup_event_buf;
1387 char *token;
Steven Rostedtb77e38a2009-02-24 10:21:36 -05001388
1389 d_tracer = tracing_init_dentry();
1390 if (!d_tracer)
1391 return 0;
1392
Steven Rostedt2314c4a2009-03-10 12:04:02 -04001393 entry = debugfs_create_file("available_events", 0444, d_tracer,
1394 (void *)&show_event_seq_ops,
1395 &ftrace_avail_fops);
1396 if (!entry)
1397 pr_warning("Could not create debugfs "
1398 "'available_events' entry\n");
1399
Steven Rostedtb77e38a2009-02-24 10:21:36 -05001400 entry = debugfs_create_file("set_event", 0644, d_tracer,
1401 (void *)&show_set_event_seq_ops,
1402 &ftrace_set_event_fops);
1403 if (!entry)
1404 pr_warning("Could not create debugfs "
1405 "'set_event' entry\n");
1406
Steven Rostedt1473e442009-02-24 14:15:08 -05001407 d_events = event_trace_events_dir();
1408 if (!d_events)
1409 return 0;
1410
Steven Rostedtd1b182a2009-04-15 16:53:47 -04001411 /* ring buffer internal formats */
1412 trace_create_file("header_page", 0444, d_events,
1413 ring_buffer_print_page_header,
1414 &ftrace_show_header_fops);
1415
1416 trace_create_file("header_event", 0444, d_events,
1417 ring_buffer_print_entry_header,
1418 &ftrace_show_header_fops);
1419
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001420 trace_create_file("enable", 0644, d_events,
Li Zefan8f31bfe2009-05-08 10:31:42 +08001421 NULL, &ftrace_system_enable_fops);
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001422
Li Zefan8728fe52010-05-24 16:22:49 +08001423 if (trace_define_common_fields())
1424 pr_warning("tracing: Failed to allocate common fields");
1425
Steven Rostedt6d723732009-04-10 14:53:50 -04001426 for_each_event(call, __start_ftrace_events, __stop_ftrace_events) {
Li Zefan67ead0a2010-05-24 16:25:13 +08001427 __trace_add_event_call(call, NULL, &ftrace_event_id_fops,
Masami Hiramatsu88f70d72009-09-25 11:20:54 -07001428 &ftrace_enable_fops,
1429 &ftrace_event_filter_fops,
1430 &ftrace_event_format_fops);
Steven Rostedt1473e442009-02-24 14:15:08 -05001431 }
1432
Li Zefan020e5f82009-07-01 10:47:05 +08001433 while (true) {
1434 token = strsep(&buf, ",");
1435
1436 if (!token)
1437 break;
1438 if (!*token)
1439 continue;
1440
1441 ret = ftrace_set_clr_event(token, 1);
1442 if (ret)
1443 pr_warning("Failed to enable trace event: %s\n", token);
1444 }
1445
Steven Rostedt6d723732009-04-10 14:53:50 -04001446 ret = register_module_notifier(&trace_module_nb);
Ming Lei55379372009-05-18 23:04:46 +08001447 if (ret)
Steven Rostedt6d723732009-04-10 14:53:50 -04001448 pr_warning("Failed to register trace events module notifier\n");
1449
Steven Rostedtb77e38a2009-02-24 10:21:36 -05001450 return 0;
1451}
1452fs_initcall(event_trace_init);
Steven Rostedte6187002009-04-15 13:36:40 -04001453
1454#ifdef CONFIG_FTRACE_STARTUP_TEST
1455
1456static DEFINE_SPINLOCK(test_spinlock);
1457static DEFINE_SPINLOCK(test_spinlock_irq);
1458static DEFINE_MUTEX(test_mutex);
1459
1460static __init void test_work(struct work_struct *dummy)
1461{
1462 spin_lock(&test_spinlock);
1463 spin_lock_irq(&test_spinlock_irq);
1464 udelay(1);
1465 spin_unlock_irq(&test_spinlock_irq);
1466 spin_unlock(&test_spinlock);
1467
1468 mutex_lock(&test_mutex);
1469 msleep(1);
1470 mutex_unlock(&test_mutex);
1471}
1472
1473static __init int event_test_thread(void *unused)
1474{
1475 void *test_malloc;
1476
1477 test_malloc = kmalloc(1234, GFP_KERNEL);
1478 if (!test_malloc)
1479 pr_info("failed to kmalloc\n");
1480
1481 schedule_on_each_cpu(test_work);
1482
1483 kfree(test_malloc);
1484
1485 set_current_state(TASK_INTERRUPTIBLE);
1486 while (!kthread_should_stop())
1487 schedule();
1488
1489 return 0;
1490}
1491
1492/*
1493 * Do various things that may trigger events.
1494 */
1495static __init void event_test_stuff(void)
1496{
1497 struct task_struct *test_thread;
1498
1499 test_thread = kthread_run(event_test_thread, NULL, "test-events");
1500 msleep(1);
1501 kthread_stop(test_thread);
1502}
1503
1504/*
1505 * For every trace event defined, we will test each trace point separately,
1506 * and then by groups, and finally all trace points.
1507 */
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001508static __init void event_trace_self_tests(void)
Steven Rostedte6187002009-04-15 13:36:40 -04001509{
1510 struct ftrace_event_call *call;
1511 struct event_subsystem *system;
Steven Rostedte6187002009-04-15 13:36:40 -04001512 int ret;
1513
1514 pr_info("Running tests on trace events:\n");
1515
1516 list_for_each_entry(call, &ftrace_events, list) {
1517
Steven Rostedt22392912010-04-21 12:27:06 -04001518 /* Only test those that have a probe */
1519 if (!call->class || !call->class->probe)
Steven Rostedte6187002009-04-15 13:36:40 -04001520 continue;
1521
Steven Rostedt1f5a6b42009-09-14 11:58:24 -04001522/*
1523 * Testing syscall events here is pretty useless, but
1524 * we still do it if configured. But this is time consuming.
1525 * What we really need is a user thread to perform the
1526 * syscalls as we test.
1527 */
1528#ifndef CONFIG_EVENT_TRACE_TEST_SYSCALLS
Steven Rostedt8f082012010-04-20 10:47:33 -04001529 if (call->class->system &&
1530 strcmp(call->class->system, "syscalls") == 0)
Steven Rostedt1f5a6b42009-09-14 11:58:24 -04001531 continue;
1532#endif
1533
Steven Rostedte6187002009-04-15 13:36:40 -04001534 pr_info("Testing event %s: ", call->name);
1535
1536 /*
1537 * If an event is already enabled, someone is using
1538 * it and the self test should not be on.
1539 */
Steven Rostedt553552c2010-04-23 11:12:36 -04001540 if (call->flags & TRACE_EVENT_FL_ENABLED) {
Steven Rostedte6187002009-04-15 13:36:40 -04001541 pr_warning("Enabled event during self test!\n");
1542 WARN_ON_ONCE(1);
1543 continue;
1544 }
1545
Zhaolei0e907c92009-05-25 18:13:59 +08001546 ftrace_event_enable_disable(call, 1);
Steven Rostedte6187002009-04-15 13:36:40 -04001547 event_test_stuff();
Zhaolei0e907c92009-05-25 18:13:59 +08001548 ftrace_event_enable_disable(call, 0);
Steven Rostedte6187002009-04-15 13:36:40 -04001549
1550 pr_cont("OK\n");
1551 }
1552
1553 /* Now test at the sub system level */
1554
1555 pr_info("Running tests on trace event systems:\n");
1556
1557 list_for_each_entry(system, &event_subsystems, list) {
1558
1559 /* the ftrace system is special, skip it */
1560 if (strcmp(system->name, "ftrace") == 0)
1561 continue;
1562
1563 pr_info("Testing event system %s: ", system->name);
1564
Li Zefan8f31bfe2009-05-08 10:31:42 +08001565 ret = __ftrace_set_clr_event(NULL, system->name, NULL, 1);
Steven Rostedte6187002009-04-15 13:36:40 -04001566 if (WARN_ON_ONCE(ret)) {
1567 pr_warning("error enabling system %s\n",
1568 system->name);
1569 continue;
1570 }
1571
1572 event_test_stuff();
1573
Li Zefan8f31bfe2009-05-08 10:31:42 +08001574 ret = __ftrace_set_clr_event(NULL, system->name, NULL, 0);
Steven Rostedte6187002009-04-15 13:36:40 -04001575 if (WARN_ON_ONCE(ret))
1576 pr_warning("error disabling system %s\n",
1577 system->name);
1578
1579 pr_cont("OK\n");
1580 }
1581
1582 /* Test with all events enabled */
1583
1584 pr_info("Running tests on all trace events:\n");
1585 pr_info("Testing all events: ");
1586
Li Zefan8f31bfe2009-05-08 10:31:42 +08001587 ret = __ftrace_set_clr_event(NULL, NULL, NULL, 1);
Steven Rostedte6187002009-04-15 13:36:40 -04001588 if (WARN_ON_ONCE(ret)) {
Steven Rostedte6187002009-04-15 13:36:40 -04001589 pr_warning("error enabling all events\n");
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001590 return;
Steven Rostedte6187002009-04-15 13:36:40 -04001591 }
1592
1593 event_test_stuff();
1594
1595 /* reset sysname */
Li Zefan8f31bfe2009-05-08 10:31:42 +08001596 ret = __ftrace_set_clr_event(NULL, NULL, NULL, 0);
Steven Rostedte6187002009-04-15 13:36:40 -04001597 if (WARN_ON_ONCE(ret)) {
1598 pr_warning("error disabling all events\n");
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001599 return;
Steven Rostedte6187002009-04-15 13:36:40 -04001600 }
1601
1602 pr_cont("OK\n");
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001603}
1604
1605#ifdef CONFIG_FUNCTION_TRACER
1606
Tejun Heo245b2e72009-06-24 15:13:48 +09001607static DEFINE_PER_CPU(atomic_t, ftrace_test_event_disable);
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001608
1609static void
1610function_test_events_call(unsigned long ip, unsigned long parent_ip)
1611{
1612 struct ring_buffer_event *event;
Steven Rostedte77405a2009-09-02 14:17:06 -04001613 struct ring_buffer *buffer;
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001614 struct ftrace_entry *entry;
1615 unsigned long flags;
1616 long disabled;
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001617 int cpu;
1618 int pc;
1619
1620 pc = preempt_count();
Steven Rostedt5168ae52010-06-03 09:36:50 -04001621 preempt_disable_notrace();
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001622 cpu = raw_smp_processor_id();
Tejun Heo245b2e72009-06-24 15:13:48 +09001623 disabled = atomic_inc_return(&per_cpu(ftrace_test_event_disable, cpu));
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001624
1625 if (disabled != 1)
1626 goto out;
1627
1628 local_save_flags(flags);
1629
Steven Rostedte77405a2009-09-02 14:17:06 -04001630 event = trace_current_buffer_lock_reserve(&buffer,
1631 TRACE_FN, sizeof(*entry),
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001632 flags, pc);
1633 if (!event)
1634 goto out;
1635 entry = ring_buffer_event_data(event);
1636 entry->ip = ip;
1637 entry->parent_ip = parent_ip;
1638
Steven Rostedte77405a2009-09-02 14:17:06 -04001639 trace_nowake_buffer_unlock_commit(buffer, event, flags, pc);
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001640
1641 out:
Tejun Heo245b2e72009-06-24 15:13:48 +09001642 atomic_dec(&per_cpu(ftrace_test_event_disable, cpu));
Steven Rostedt5168ae52010-06-03 09:36:50 -04001643 preempt_enable_notrace();
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001644}
1645
1646static struct ftrace_ops trace_ops __initdata =
1647{
1648 .func = function_test_events_call,
1649};
1650
1651static __init void event_trace_self_test_with_function(void)
1652{
1653 register_ftrace_function(&trace_ops);
1654 pr_info("Running tests again, along with the function tracer\n");
1655 event_trace_self_tests();
1656 unregister_ftrace_function(&trace_ops);
1657}
1658#else
1659static __init void event_trace_self_test_with_function(void)
1660{
1661}
1662#endif
1663
1664static __init int event_trace_self_tests_init(void)
1665{
Li Zefan020e5f82009-07-01 10:47:05 +08001666 if (!tracing_selftest_disabled) {
1667 event_trace_self_tests();
1668 event_trace_self_test_with_function();
1669 }
Steven Rostedte6187002009-04-15 13:36:40 -04001670
1671 return 0;
1672}
1673
Steven Rostedt28d20e22009-04-20 12:12:44 -04001674late_initcall(event_trace_self_tests_init);
Steven Rostedte6187002009-04-15 13:36:40 -04001675
1676#endif