blob: 8c91b7c8f04731e488bb1131538d378176c8d1bf [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>
Steven Rostedte6187002009-04-15 13:36:40 -040018#include <linux/delay.h>
Steven Rostedtb77e38a2009-02-24 10:21:36 -050019
Li Zefan020e5f82009-07-01 10:47:05 +080020#include <asm/setup.h>
21
Steven Rostedt91729ef2009-03-02 15:03:01 -050022#include "trace_output.h"
Steven Rostedtb77e38a2009-02-24 10:21:36 -050023
Steven Rostedt4e5292e2009-09-12 19:26:21 -040024#undef TRACE_SYSTEM
Steven Rostedtb628b3e2009-02-27 23:32:58 -050025#define TRACE_SYSTEM "TRACE_SYSTEM"
26
Li Zefan20c89282009-05-06 10:33:45 +080027DEFINE_MUTEX(event_mutex);
Steven Rostedt11a241a2009-03-02 11:49:04 -050028
Steven Rostedta59fd602009-04-10 13:52:20 -040029LIST_HEAD(ftrace_events);
30
Li Zefan540b7b82009-08-19 15:54:51 +080031int trace_define_field(struct ftrace_event_call *call, const char *type,
Li Zefan43b51ea2009-08-07 10:33:22 +080032 const char *name, int offset, int size, int is_signed,
33 int filter_type)
Tom Zanussicf027f62009-03-22 03:30:39 -050034{
35 struct ftrace_event_field *field;
36
Ingo Molnarfe9f57f2009-03-22 18:41:59 +010037 field = kzalloc(sizeof(*field), GFP_KERNEL);
Tom Zanussicf027f62009-03-22 03:30:39 -050038 if (!field)
39 goto err;
Ingo Molnarfe9f57f2009-03-22 18:41:59 +010040
Tom Zanussicf027f62009-03-22 03:30:39 -050041 field->name = kstrdup(name, GFP_KERNEL);
42 if (!field->name)
43 goto err;
Ingo Molnarfe9f57f2009-03-22 18:41:59 +010044
Tom Zanussicf027f62009-03-22 03:30:39 -050045 field->type = kstrdup(type, GFP_KERNEL);
46 if (!field->type)
47 goto err;
Ingo Molnarfe9f57f2009-03-22 18:41:59 +010048
Li Zefan43b51ea2009-08-07 10:33:22 +080049 if (filter_type == FILTER_OTHER)
50 field->filter_type = filter_assign_type(type);
51 else
52 field->filter_type = filter_type;
53
Tom Zanussicf027f62009-03-22 03:30:39 -050054 field->offset = offset;
55 field->size = size;
Tom Zanussia118e4d2009-04-28 03:04:53 -050056 field->is_signed = is_signed;
Li Zefanaa38e9f2009-08-07 10:33:02 +080057
Tom Zanussicf027f62009-03-22 03:30:39 -050058 list_add(&field->link, &call->fields);
59
60 return 0;
Ingo Molnarfe9f57f2009-03-22 18:41:59 +010061
Tom Zanussicf027f62009-03-22 03:30:39 -050062err:
63 if (field) {
64 kfree(field->name);
65 kfree(field->type);
66 }
67 kfree(field);
Ingo Molnarfe9f57f2009-03-22 18:41:59 +010068
Tom Zanussicf027f62009-03-22 03:30:39 -050069 return -ENOMEM;
70}
Steven Rostedt17c873e2009-04-10 18:12:50 -040071EXPORT_SYMBOL_GPL(trace_define_field);
Tom Zanussicf027f62009-03-22 03:30:39 -050072
Li Zefane647d6b2009-08-19 15:54:32 +080073#define __common_field(type, item) \
74 ret = trace_define_field(call, #type, "common_" #item, \
75 offsetof(typeof(ent), item), \
76 sizeof(ent.item), \
Li Zefan43b51ea2009-08-07 10:33:22 +080077 is_signed_type(type), FILTER_OTHER); \
Li Zefane647d6b2009-08-19 15:54:32 +080078 if (ret) \
79 return ret;
80
81int trace_define_common_fields(struct ftrace_event_call *call)
82{
83 int ret;
84 struct trace_entry ent;
85
86 __common_field(unsigned short, type);
87 __common_field(unsigned char, flags);
88 __common_field(unsigned char, preempt_count);
89 __common_field(int, pid);
Steven Rostedt637e7e82009-09-11 13:55:35 -040090 __common_field(int, lock_depth);
Li Zefane647d6b2009-08-19 15:54:32 +080091
92 return ret;
93}
Li Zefan540b7b82009-08-19 15:54:51 +080094EXPORT_SYMBOL_GPL(trace_define_common_fields);
Li Zefane647d6b2009-08-19 15:54:32 +080095
Li Zefan2df75e42009-05-06 10:33:04 +080096#ifdef CONFIG_MODULES
97
98static void trace_destroy_fields(struct ftrace_event_call *call)
99{
100 struct ftrace_event_field *field, *next;
101
102 list_for_each_entry_safe(field, next, &call->fields, link) {
103 list_del(&field->link);
104 kfree(field->type);
105 kfree(field->name);
106 kfree(field);
107 }
108}
109
110#endif /* CONFIG_MODULES */
111
Steven Rostedtfd994982009-02-28 02:41:25 -0500112static void ftrace_event_enable_disable(struct ftrace_event_call *call,
113 int enable)
114{
Steven Rostedtfd994982009-02-28 02:41:25 -0500115 switch (enable) {
116 case 0:
117 if (call->enabled) {
118 call->enabled = 0;
Zhaoleib11c53e2009-05-25 18:11:59 +0800119 tracing_stop_cmdline_record();
Jason Baron69fd4f02009-08-10 16:52:44 -0400120 call->unregfunc(call->data);
Steven Rostedtfd994982009-02-28 02:41:25 -0500121 }
Steven Rostedtfd994982009-02-28 02:41:25 -0500122 break;
123 case 1:
Steven Rostedtda4d0302009-03-09 17:14:30 -0400124 if (!call->enabled) {
Steven Rostedtfd994982009-02-28 02:41:25 -0500125 call->enabled = 1;
Zhaoleib11c53e2009-05-25 18:11:59 +0800126 tracing_start_cmdline_record();
Jason Baron69fd4f02009-08-10 16:52:44 -0400127 call->regfunc(call->data);
Steven Rostedtfd994982009-02-28 02:41:25 -0500128 }
Steven Rostedtfd994982009-02-28 02:41:25 -0500129 break;
130 }
131}
132
Zhaolei0e907c92009-05-25 18:13:59 +0800133static void ftrace_clear_events(void)
134{
135 struct ftrace_event_call *call;
136
137 mutex_lock(&event_mutex);
138 list_for_each_entry(call, &ftrace_events, list) {
139 ftrace_event_enable_disable(call, 0);
140 }
141 mutex_unlock(&event_mutex);
142}
143
Li Zefan8f31bfe2009-05-08 10:31:42 +0800144/*
145 * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events.
146 */
147static int __ftrace_set_clr_event(const char *match, const char *sub,
148 const char *event, int set)
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500149{
Steven Rostedta59fd602009-04-10 13:52:20 -0400150 struct ftrace_event_call *call;
Steven Rostedt29f93942009-05-08 16:06:47 -0400151 int ret = -EINVAL;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500152
Steven Rostedt11a241a2009-03-02 11:49:04 -0500153 mutex_lock(&event_mutex);
Steven Rostedta59fd602009-04-10 13:52:20 -0400154 list_for_each_entry(call, &ftrace_events, list) {
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500155
Steven Rostedt40e26812009-03-10 11:32:40 -0400156 if (!call->name || !call->regfunc)
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500157 continue;
Steven Rostedt1473e442009-02-24 14:15:08 -0500158
Steven Rostedtb628b3e2009-02-27 23:32:58 -0500159 if (match &&
160 strcmp(match, call->name) != 0 &&
161 strcmp(match, call->system) != 0)
162 continue;
163
164 if (sub && strcmp(sub, call->system) != 0)
165 continue;
166
167 if (event && strcmp(event, call->name) != 0)
Steven Rostedt1473e442009-02-24 14:15:08 -0500168 continue;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500169
Steven Rostedtfd994982009-02-28 02:41:25 -0500170 ftrace_event_enable_disable(call, set);
171
Steven Rostedtb628b3e2009-02-27 23:32:58 -0500172 ret = 0;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500173 }
Steven Rostedt11a241a2009-03-02 11:49:04 -0500174 mutex_unlock(&event_mutex);
175
Steven Rostedtb628b3e2009-02-27 23:32:58 -0500176 return ret;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500177}
178
Li Zefan8f31bfe2009-05-08 10:31:42 +0800179static int ftrace_set_clr_event(char *buf, int set)
180{
181 char *event = NULL, *sub = NULL, *match;
182
183 /*
184 * The buf format can be <subsystem>:<event-name>
185 * *:<event-name> means any event by that name.
186 * :<event-name> is the same.
187 *
188 * <subsystem>:* means all events in that subsystem
189 * <subsystem>: means the same.
190 *
191 * <name> (no ':') means all events in a subsystem with
192 * the name <name> or any event that matches <name>
193 */
194
195 match = strsep(&buf, ":");
196 if (buf) {
197 sub = match;
198 event = buf;
199 match = NULL;
200
201 if (!strlen(sub) || strcmp(sub, "*") == 0)
202 sub = NULL;
203 if (!strlen(event) || strcmp(event, "*") == 0)
204 event = NULL;
205 }
206
207 return __ftrace_set_clr_event(match, sub, event, set);
208}
209
Steven Rostedt4671c792009-05-08 16:27:41 -0400210/**
211 * trace_set_clr_event - enable or disable an event
212 * @system: system name to match (NULL for any system)
213 * @event: event name to match (NULL for all events, within system)
214 * @set: 1 to enable, 0 to disable
215 *
216 * This is a way for other parts of the kernel to enable or disable
217 * event recording.
218 *
219 * Returns 0 on success, -EINVAL if the parameters do not match any
220 * registered events.
221 */
222int trace_set_clr_event(const char *system, const char *event, int set)
223{
224 return __ftrace_set_clr_event(NULL, system, event, set);
225}
226
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500227/* 128 should be much more than enough */
228#define EVENT_BUF_SIZE 127
229
230static ssize_t
231ftrace_event_write(struct file *file, const char __user *ubuf,
232 size_t cnt, loff_t *ppos)
233{
jolsa@redhat.com48966362009-09-11 17:29:28 +0200234 struct trace_parser parser;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500235 size_t read = 0;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500236 ssize_t ret;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500237
238 if (!cnt || cnt < 0)
239 return 0;
240
Steven Rostedt1852fcc2009-03-11 14:33:00 -0400241 ret = tracing_update_buffers();
242 if (ret < 0)
243 return ret;
244
jolsa@redhat.com48966362009-09-11 17:29:28 +0200245 if (trace_parser_get_init(&parser, EVENT_BUF_SIZE + 1))
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500246 return -ENOMEM;
247
jolsa@redhat.com48966362009-09-11 17:29:28 +0200248 read = trace_get_user(&parser, ubuf, cnt, ppos);
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500249
jolsa@redhat.com48966362009-09-11 17:29:28 +0200250 if (trace_parser_loaded((&parser))) {
251 int set = 1;
252
253 if (*parser.buffer == '!')
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500254 set = 0;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500255
jolsa@redhat.com48966362009-09-11 17:29:28 +0200256 parser.buffer[parser.idx] = 0;
257
258 ret = ftrace_set_clr_event(parser.buffer + !set, set);
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500259 if (ret)
jolsa@redhat.com48966362009-09-11 17:29:28 +0200260 goto out_put;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500261 }
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500262
263 ret = read;
264
jolsa@redhat.com48966362009-09-11 17:29:28 +0200265 out_put:
266 trace_parser_put(&parser);
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500267
268 return ret;
269}
270
271static void *
272t_next(struct seq_file *m, void *v, loff_t *pos)
273{
Steven Rostedta59fd602009-04-10 13:52:20 -0400274 struct list_head *list = m->private;
275 struct ftrace_event_call *call;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500276
277 (*pos)++;
278
Steven Rostedt40e26812009-03-10 11:32:40 -0400279 for (;;) {
Steven Rostedta59fd602009-04-10 13:52:20 -0400280 if (list == &ftrace_events)
Steven Rostedt40e26812009-03-10 11:32:40 -0400281 return NULL;
282
Steven Rostedta59fd602009-04-10 13:52:20 -0400283 call = list_entry(list, struct ftrace_event_call, list);
284
Steven Rostedt40e26812009-03-10 11:32:40 -0400285 /*
286 * The ftrace subsystem is for showing formats only.
287 * They can not be enabled or disabled via the event files.
288 */
289 if (call->regfunc)
290 break;
291
Steven Rostedta59fd602009-04-10 13:52:20 -0400292 list = list->next;
Steven Rostedt40e26812009-03-10 11:32:40 -0400293 }
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500294
Steven Rostedta59fd602009-04-10 13:52:20 -0400295 m->private = list->next;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500296
297 return call;
298}
299
300static void *t_start(struct seq_file *m, loff_t *pos)
301{
Li Zefane1c7e2a2009-06-24 09:52:29 +0800302 struct ftrace_event_call *call = NULL;
303 loff_t l;
304
Li Zefan20c89282009-05-06 10:33:45 +0800305 mutex_lock(&event_mutex);
Li Zefane1c7e2a2009-06-24 09:52:29 +0800306
307 m->private = ftrace_events.next;
308 for (l = 0; l <= *pos; ) {
309 call = t_next(m, NULL, &l);
310 if (!call)
311 break;
312 }
313 return call;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500314}
315
316static void *
317s_next(struct seq_file *m, void *v, loff_t *pos)
318{
Steven Rostedta59fd602009-04-10 13:52:20 -0400319 struct list_head *list = m->private;
320 struct ftrace_event_call *call;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500321
322 (*pos)++;
323
324 retry:
Steven Rostedta59fd602009-04-10 13:52:20 -0400325 if (list == &ftrace_events)
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500326 return NULL;
327
Steven Rostedta59fd602009-04-10 13:52:20 -0400328 call = list_entry(list, struct ftrace_event_call, list);
329
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500330 if (!call->enabled) {
Steven Rostedta59fd602009-04-10 13:52:20 -0400331 list = list->next;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500332 goto retry;
333 }
334
Steven Rostedta59fd602009-04-10 13:52:20 -0400335 m->private = list->next;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500336
337 return call;
338}
339
340static void *s_start(struct seq_file *m, loff_t *pos)
341{
Li Zefane1c7e2a2009-06-24 09:52:29 +0800342 struct ftrace_event_call *call = NULL;
343 loff_t l;
344
Li Zefan20c89282009-05-06 10:33:45 +0800345 mutex_lock(&event_mutex);
Li Zefane1c7e2a2009-06-24 09:52:29 +0800346
347 m->private = ftrace_events.next;
348 for (l = 0; l <= *pos; ) {
349 call = s_next(m, NULL, &l);
350 if (!call)
351 break;
352 }
353 return call;
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500354}
355
356static int t_show(struct seq_file *m, void *v)
357{
358 struct ftrace_event_call *call = v;
359
Steven Rostedtb628b3e2009-02-27 23:32:58 -0500360 if (strcmp(call->system, TRACE_SYSTEM) != 0)
361 seq_printf(m, "%s:", call->system);
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500362 seq_printf(m, "%s\n", call->name);
363
364 return 0;
365}
366
367static void t_stop(struct seq_file *m, void *p)
368{
Li Zefan20c89282009-05-06 10:33:45 +0800369 mutex_unlock(&event_mutex);
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500370}
371
372static int
373ftrace_event_seq_open(struct inode *inode, struct file *file)
374{
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500375 const struct seq_operations *seq_ops;
376
377 if ((file->f_mode & FMODE_WRITE) &&
Steven Rostedt8650ae32009-07-22 23:29:30 -0400378 (file->f_flags & O_TRUNC))
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500379 ftrace_clear_events();
380
381 seq_ops = inode->i_private;
Li Zefan20c89282009-05-06 10:33:45 +0800382 return seq_open(file, seq_ops);
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500383}
384
Steven Rostedt1473e442009-02-24 14:15:08 -0500385static ssize_t
386event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
387 loff_t *ppos)
388{
389 struct ftrace_event_call *call = filp->private_data;
390 char *buf;
391
Steven Rostedtda4d0302009-03-09 17:14:30 -0400392 if (call->enabled)
Steven Rostedt1473e442009-02-24 14:15:08 -0500393 buf = "1\n";
394 else
395 buf = "0\n";
396
397 return simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
398}
399
400static ssize_t
401event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
402 loff_t *ppos)
403{
404 struct ftrace_event_call *call = filp->private_data;
405 char buf[64];
406 unsigned long val;
407 int ret;
408
409 if (cnt >= sizeof(buf))
410 return -EINVAL;
411
412 if (copy_from_user(&buf, ubuf, cnt))
413 return -EFAULT;
414
415 buf[cnt] = 0;
416
417 ret = strict_strtoul(buf, 10, &val);
418 if (ret < 0)
419 return ret;
420
Steven Rostedt1852fcc2009-03-11 14:33:00 -0400421 ret = tracing_update_buffers();
422 if (ret < 0)
423 return ret;
424
Steven Rostedt1473e442009-02-24 14:15:08 -0500425 switch (val) {
426 case 0:
Steven Rostedt1473e442009-02-24 14:15:08 -0500427 case 1:
Steven Rostedt11a241a2009-03-02 11:49:04 -0500428 mutex_lock(&event_mutex);
Steven Rostedtfd994982009-02-28 02:41:25 -0500429 ftrace_event_enable_disable(call, val);
Steven Rostedt11a241a2009-03-02 11:49:04 -0500430 mutex_unlock(&event_mutex);
Steven Rostedt1473e442009-02-24 14:15:08 -0500431 break;
432
433 default:
434 return -EINVAL;
435 }
436
437 *ppos += cnt;
438
439 return cnt;
440}
441
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400442static ssize_t
443system_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
444 loff_t *ppos)
445{
Li Zefanc142b152009-05-08 10:32:05 +0800446 const char set_to_char[4] = { '?', '0', '1', 'X' };
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400447 const char *system = filp->private_data;
448 struct ftrace_event_call *call;
449 char buf[2];
Li Zefanc142b152009-05-08 10:32:05 +0800450 int set = 0;
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400451 int ret;
452
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400453 mutex_lock(&event_mutex);
454 list_for_each_entry(call, &ftrace_events, list) {
455 if (!call->name || !call->regfunc)
456 continue;
457
Li Zefan8f31bfe2009-05-08 10:31:42 +0800458 if (system && strcmp(call->system, system) != 0)
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400459 continue;
460
461 /*
462 * We need to find out if all the events are set
463 * or if all events or cleared, or if we have
464 * a mixture.
465 */
Li Zefanc142b152009-05-08 10:32:05 +0800466 set |= (1 << !!call->enabled);
467
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400468 /*
469 * If we have a mixture, no need to look further.
470 */
Li Zefanc142b152009-05-08 10:32:05 +0800471 if (set == 3)
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400472 break;
473 }
474 mutex_unlock(&event_mutex);
475
Li Zefanc142b152009-05-08 10:32:05 +0800476 buf[0] = set_to_char[set];
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400477 buf[1] = '\n';
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400478
479 ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
480
481 return ret;
482}
483
484static ssize_t
485system_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
486 loff_t *ppos)
487{
488 const char *system = filp->private_data;
489 unsigned long val;
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400490 char buf[64];
491 ssize_t ret;
492
493 if (cnt >= sizeof(buf))
494 return -EINVAL;
495
496 if (copy_from_user(&buf, ubuf, cnt))
497 return -EFAULT;
498
499 buf[cnt] = 0;
500
501 ret = strict_strtoul(buf, 10, &val);
502 if (ret < 0)
503 return ret;
504
505 ret = tracing_update_buffers();
506 if (ret < 0)
507 return ret;
508
Li Zefan8f31bfe2009-05-08 10:31:42 +0800509 if (val != 0 && val != 1)
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400510 return -EINVAL;
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400511
Li Zefan8f31bfe2009-05-08 10:31:42 +0800512 ret = __ftrace_set_clr_event(NULL, system, NULL, val);
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400513 if (ret)
Li Zefan8f31bfe2009-05-08 10:31:42 +0800514 goto out;
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400515
516 ret = cnt;
517
Li Zefan8f31bfe2009-05-08 10:31:42 +0800518out:
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400519 *ppos += cnt;
520
521 return ret;
522}
523
Steven Rostedt75db37d2009-03-26 11:43:36 -0400524extern char *__bad_type_size(void);
525
Steven Rostedt91729ef2009-03-02 15:03:01 -0500526#undef FIELD
Steven Rostedt156b5f12009-03-06 10:50:53 -0500527#define FIELD(type, name) \
Steven Rostedt75db37d2009-03-26 11:43:36 -0400528 sizeof(type) != sizeof(field.name) ? __bad_type_size() : \
Tom Zanussicf027f62009-03-22 03:30:39 -0500529 #type, "common_" #name, offsetof(typeof(field), name), \
530 sizeof(field.name)
Steven Rostedt91729ef2009-03-02 15:03:01 -0500531
532static int trace_write_header(struct trace_seq *s)
533{
534 struct trace_entry field;
535
536 /* struct trace_entry */
537 return trace_seq_printf(s,
Steven Rostedtce8eb2b2009-03-10 10:14:35 -0400538 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
539 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
540 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
541 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
Steven Rostedt637e7e82009-09-11 13:55:35 -0400542 "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
Steven Rostedt91729ef2009-03-02 15:03:01 -0500543 "\n",
Steven Rostedt89ec0de2009-03-26 11:03:29 -0400544 FIELD(unsigned short, type),
Steven Rostedt91729ef2009-03-02 15:03:01 -0500545 FIELD(unsigned char, flags),
546 FIELD(unsigned char, preempt_count),
Steven Rostedt637e7e82009-09-11 13:55:35 -0400547 FIELD(int, pid),
548 FIELD(int, lock_depth));
Steven Rostedt91729ef2009-03-02 15:03:01 -0500549}
Steven Rostedtda4d0302009-03-09 17:14:30 -0400550
Steven Rostedt981d0812009-03-02 13:53:59 -0500551static ssize_t
552event_format_read(struct file *filp, char __user *ubuf, size_t cnt,
553 loff_t *ppos)
554{
555 struct ftrace_event_call *call = filp->private_data;
556 struct trace_seq *s;
557 char *buf;
558 int r;
559
Tom Zanussic269fc82009-03-17 01:20:59 -0500560 if (*ppos)
561 return 0;
562
Steven Rostedt981d0812009-03-02 13:53:59 -0500563 s = kmalloc(sizeof(*s), GFP_KERNEL);
564 if (!s)
565 return -ENOMEM;
566
567 trace_seq_init(s);
568
Steven Rostedtc5e4e192009-03-02 15:10:02 -0500569 /* If any of the first writes fail, so will the show_format. */
570
571 trace_seq_printf(s, "name: %s\n", call->name);
572 trace_seq_printf(s, "ID: %d\n", call->id);
573 trace_seq_printf(s, "format:\n");
Steven Rostedt91729ef2009-03-02 15:03:01 -0500574 trace_write_header(s);
575
Frederic Weisbeckere8f9f4d2009-08-11 17:42:52 +0200576 r = call->show_format(call, s);
Steven Rostedt981d0812009-03-02 13:53:59 -0500577 if (!r) {
578 /*
579 * ug! The format output is bigger than a PAGE!!
580 */
581 buf = "FORMAT TOO BIG\n";
582 r = simple_read_from_buffer(ubuf, cnt, ppos,
583 buf, strlen(buf));
584 goto out;
585 }
586
587 r = simple_read_from_buffer(ubuf, cnt, ppos,
588 s->buffer, s->len);
589 out:
590 kfree(s);
591 return r;
592}
593
Peter Zijlstra23725ae2009-03-19 20:26:13 +0100594static ssize_t
595event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
596{
597 struct ftrace_event_call *call = filp->private_data;
598 struct trace_seq *s;
599 int r;
600
601 if (*ppos)
602 return 0;
603
604 s = kmalloc(sizeof(*s), GFP_KERNEL);
605 if (!s)
606 return -ENOMEM;
607
608 trace_seq_init(s);
609 trace_seq_printf(s, "%d\n", call->id);
610
611 r = simple_read_from_buffer(ubuf, cnt, ppos,
612 s->buffer, s->len);
613 kfree(s);
614 return r;
615}
616
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500617static ssize_t
618event_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
619 loff_t *ppos)
620{
621 struct ftrace_event_call *call = filp->private_data;
622 struct trace_seq *s;
623 int r;
624
625 if (*ppos)
626 return 0;
627
628 s = kmalloc(sizeof(*s), GFP_KERNEL);
629 if (!s)
630 return -ENOMEM;
631
632 trace_seq_init(s);
633
Tom Zanussi8b372562009-04-28 03:04:59 -0500634 print_event_filter(call, s);
Tom Zanussi4bda2d52009-03-24 02:14:31 -0500635 r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500636
637 kfree(s);
638
639 return r;
640}
641
642static ssize_t
643event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
644 loff_t *ppos)
645{
646 struct ftrace_event_call *call = filp->private_data;
Tom Zanussi8b372562009-04-28 03:04:59 -0500647 char *buf;
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500648 int err;
649
Tom Zanussi8b372562009-04-28 03:04:59 -0500650 if (cnt >= PAGE_SIZE)
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500651 return -EINVAL;
652
Tom Zanussi8b372562009-04-28 03:04:59 -0500653 buf = (char *)__get_free_page(GFP_TEMPORARY);
654 if (!buf)
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500655 return -ENOMEM;
656
Tom Zanussi8b372562009-04-28 03:04:59 -0500657 if (copy_from_user(buf, ubuf, cnt)) {
658 free_page((unsigned long) buf);
659 return -EFAULT;
660 }
661 buf[cnt] = '\0';
662
663 err = apply_event_filter(call, buf);
664 free_page((unsigned long) buf);
665 if (err < 0)
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500666 return err;
Tom Zanussi0a19e532009-04-13 03:17:50 -0500667
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500668 *ppos += cnt;
669
670 return cnt;
671}
672
Tom Zanussicfb180f2009-03-22 03:31:17 -0500673static ssize_t
674subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
675 loff_t *ppos)
676{
677 struct event_subsystem *system = filp->private_data;
678 struct trace_seq *s;
679 int r;
680
681 if (*ppos)
682 return 0;
683
684 s = kmalloc(sizeof(*s), GFP_KERNEL);
685 if (!s)
686 return -ENOMEM;
687
688 trace_seq_init(s);
689
Tom Zanussi8b372562009-04-28 03:04:59 -0500690 print_subsystem_event_filter(system, s);
Tom Zanussi4bda2d52009-03-24 02:14:31 -0500691 r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
Tom Zanussicfb180f2009-03-22 03:31:17 -0500692
693 kfree(s);
694
695 return r;
696}
697
698static ssize_t
699subsystem_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
700 loff_t *ppos)
701{
702 struct event_subsystem *system = filp->private_data;
Tom Zanussi8b372562009-04-28 03:04:59 -0500703 char *buf;
Tom Zanussicfb180f2009-03-22 03:31:17 -0500704 int err;
705
Tom Zanussi8b372562009-04-28 03:04:59 -0500706 if (cnt >= PAGE_SIZE)
Tom Zanussicfb180f2009-03-22 03:31:17 -0500707 return -EINVAL;
708
Tom Zanussi8b372562009-04-28 03:04:59 -0500709 buf = (char *)__get_free_page(GFP_TEMPORARY);
710 if (!buf)
Tom Zanussicfb180f2009-03-22 03:31:17 -0500711 return -ENOMEM;
712
Tom Zanussi8b372562009-04-28 03:04:59 -0500713 if (copy_from_user(buf, ubuf, cnt)) {
714 free_page((unsigned long) buf);
715 return -EFAULT;
Tom Zanussicfb180f2009-03-22 03:31:17 -0500716 }
Tom Zanussi8b372562009-04-28 03:04:59 -0500717 buf[cnt] = '\0';
Tom Zanussicfb180f2009-03-22 03:31:17 -0500718
Tom Zanussi8b372562009-04-28 03:04:59 -0500719 err = apply_subsystem_event_filter(system, buf);
720 free_page((unsigned long) buf);
721 if (err < 0)
Li Zefan44e9c8b2009-04-11 15:55:28 +0800722 return err;
Tom Zanussicfb180f2009-03-22 03:31:17 -0500723
724 *ppos += cnt;
725
726 return cnt;
727}
728
Steven Rostedtd1b182a2009-04-15 16:53:47 -0400729static ssize_t
730show_header(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
731{
732 int (*func)(struct trace_seq *s) = filp->private_data;
733 struct trace_seq *s;
734 int r;
735
736 if (*ppos)
737 return 0;
738
739 s = kmalloc(sizeof(*s), GFP_KERNEL);
740 if (!s)
741 return -ENOMEM;
742
743 trace_seq_init(s);
744
745 func(s);
746 r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
747
748 kfree(s);
749
750 return r;
751}
752
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500753static const struct seq_operations show_event_seq_ops = {
754 .start = t_start,
755 .next = t_next,
756 .show = t_show,
757 .stop = t_stop,
758};
759
760static const struct seq_operations show_set_event_seq_ops = {
761 .start = s_start,
762 .next = s_next,
763 .show = t_show,
764 .stop = t_stop,
765};
766
Steven Rostedt2314c4a2009-03-10 12:04:02 -0400767static const struct file_operations ftrace_avail_fops = {
768 .open = ftrace_event_seq_open,
769 .read = seq_read,
770 .llseek = seq_lseek,
771 .release = seq_release,
772};
773
Steven Rostedtb77e38a2009-02-24 10:21:36 -0500774static const struct file_operations ftrace_set_event_fops = {
775 .open = ftrace_event_seq_open,
776 .read = seq_read,
777 .write = ftrace_event_write,
778 .llseek = seq_lseek,
779 .release = seq_release,
780};
781
Steven Rostedt1473e442009-02-24 14:15:08 -0500782static const struct file_operations ftrace_enable_fops = {
783 .open = tracing_open_generic,
784 .read = event_enable_read,
785 .write = event_enable_write,
786};
787
Steven Rostedt981d0812009-03-02 13:53:59 -0500788static const struct file_operations ftrace_event_format_fops = {
789 .open = tracing_open_generic,
790 .read = event_format_read,
791};
792
Peter Zijlstra23725ae2009-03-19 20:26:13 +0100793static const struct file_operations ftrace_event_id_fops = {
794 .open = tracing_open_generic,
795 .read = event_id_read,
796};
797
Tom Zanussi7ce7e422009-03-22 03:31:04 -0500798static const struct file_operations ftrace_event_filter_fops = {
799 .open = tracing_open_generic,
800 .read = event_filter_read,
801 .write = event_filter_write,
802};
803
Tom Zanussicfb180f2009-03-22 03:31:17 -0500804static const struct file_operations ftrace_subsystem_filter_fops = {
805 .open = tracing_open_generic,
806 .read = subsystem_filter_read,
807 .write = subsystem_filter_write,
808};
809
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400810static const struct file_operations ftrace_system_enable_fops = {
811 .open = tracing_open_generic,
812 .read = system_enable_read,
813 .write = system_enable_write,
814};
815
Steven Rostedtd1b182a2009-04-15 16:53:47 -0400816static const struct file_operations ftrace_show_header_fops = {
817 .open = tracing_open_generic,
818 .read = show_header,
819};
820
Steven Rostedt1473e442009-02-24 14:15:08 -0500821static struct dentry *event_trace_events_dir(void)
822{
823 static struct dentry *d_tracer;
824 static struct dentry *d_events;
825
826 if (d_events)
827 return d_events;
828
829 d_tracer = tracing_init_dentry();
830 if (!d_tracer)
831 return NULL;
832
833 d_events = debugfs_create_dir("events", d_tracer);
834 if (!d_events)
835 pr_warning("Could not create debugfs "
836 "'events' directory\n");
837
838 return d_events;
839}
840
Steven Rostedt6ecc2d12009-02-27 21:33:02 -0500841static LIST_HEAD(event_subsystems);
842
843static struct dentry *
844event_subsystem_dir(const char *name, struct dentry *d_events)
845{
846 struct event_subsystem *system;
Tom Zanussie1112b42009-03-31 00:48:49 -0500847 struct dentry *entry;
Steven Rostedt6ecc2d12009-02-27 21:33:02 -0500848
849 /* First see if we did not already create this dir */
850 list_for_each_entry(system, &event_subsystems, list) {
Xiao Guangrongdc82ec92009-07-09 16:22:22 +0800851 if (strcmp(system->name, name) == 0) {
852 system->nr_events++;
Steven Rostedt6ecc2d12009-02-27 21:33:02 -0500853 return system->entry;
Xiao Guangrongdc82ec92009-07-09 16:22:22 +0800854 }
Steven Rostedt6ecc2d12009-02-27 21:33:02 -0500855 }
856
857 /* need to create new entry */
858 system = kmalloc(sizeof(*system), GFP_KERNEL);
859 if (!system) {
860 pr_warning("No memory to create event subsystem %s\n",
861 name);
862 return d_events;
863 }
864
865 system->entry = debugfs_create_dir(name, d_events);
866 if (!system->entry) {
867 pr_warning("Could not create event subsystem %s\n",
868 name);
869 kfree(system);
870 return d_events;
871 }
872
Xiao Guangrongdc82ec92009-07-09 16:22:22 +0800873 system->nr_events = 1;
Steven Rostedt6d723732009-04-10 14:53:50 -0400874 system->name = kstrdup(name, GFP_KERNEL);
875 if (!system->name) {
876 debugfs_remove(system->entry);
877 kfree(system);
878 return d_events;
879 }
880
Steven Rostedt6ecc2d12009-02-27 21:33:02 -0500881 list_add(&system->list, &event_subsystems);
882
Tom Zanussi30e673b2009-04-28 03:04:47 -0500883 system->filter = NULL;
Tom Zanussicfb180f2009-03-22 03:31:17 -0500884
Tom Zanussi8b372562009-04-28 03:04:59 -0500885 system->filter = kzalloc(sizeof(struct event_filter), GFP_KERNEL);
886 if (!system->filter) {
887 pr_warning("Could not allocate filter for subsystem "
888 "'%s'\n", name);
889 return system->entry;
890 }
891
Tom Zanussie1112b42009-03-31 00:48:49 -0500892 entry = debugfs_create_file("filter", 0644, system->entry, system,
893 &ftrace_subsystem_filter_fops);
Tom Zanussi8b372562009-04-28 03:04:59 -0500894 if (!entry) {
895 kfree(system->filter);
896 system->filter = NULL;
Tom Zanussie1112b42009-03-31 00:48:49 -0500897 pr_warning("Could not create debugfs "
898 "'%s/filter' entry\n", name);
Tom Zanussi8b372562009-04-28 03:04:59 -0500899 }
Tom Zanussie1112b42009-03-31 00:48:49 -0500900
Frederic Weisbeckerf3f3f002009-09-24 15:27:41 +0200901 trace_create_file("enable", 0644, system->entry,
902 (void *)system->name,
903 &ftrace_system_enable_fops);
Steven Rostedt8ae79a12009-05-06 22:52:15 -0400904
Steven Rostedt6ecc2d12009-02-27 21:33:02 -0500905 return system->entry;
906}
907
Steven Rostedt1473e442009-02-24 14:15:08 -0500908static int
Steven Rostedt701970b2009-04-24 23:11:22 -0400909event_create_dir(struct ftrace_event_call *call, struct dentry *d_events,
910 const struct file_operations *id,
911 const struct file_operations *enable,
912 const struct file_operations *filter,
913 const struct file_operations *format)
Steven Rostedt1473e442009-02-24 14:15:08 -0500914{
Steven Rostedtfd994982009-02-28 02:41:25 -0500915 int ret;
Steven Rostedt1473e442009-02-24 14:15:08 -0500916
Steven Rostedt6ecc2d12009-02-27 21:33:02 -0500917 /*
918 * If the trace point header did not define TRACE_SYSTEM
919 * then the system would be called "TRACE_SYSTEM".
920 */
Steven Rostedt6d723732009-04-10 14:53:50 -0400921 if (strcmp(call->system, TRACE_SYSTEM) != 0)
Steven Rostedt6ecc2d12009-02-27 21:33:02 -0500922 d_events = event_subsystem_dir(call->system, d_events);
923
Steven Rostedt1473e442009-02-24 14:15:08 -0500924 call->dir = debugfs_create_dir(call->name, d_events);
925 if (!call->dir) {
926 pr_warning("Could not create debugfs "
927 "'%s' directory\n", call->name);
928 return -1;
929 }
930
Steven Rostedt6d723732009-04-10 14:53:50 -0400931 if (call->regfunc)
Frederic Weisbeckerf3f3f002009-09-24 15:27:41 +0200932 trace_create_file("enable", 0644, call->dir, call,
933 enable);
Steven Rostedt1473e442009-02-24 14:15:08 -0500934
Peter Zijlstraaf6af302009-08-05 20:41:04 +0200935 if (call->id && call->profile_enable)
Frederic Weisbeckerf3f3f002009-09-24 15:27:41 +0200936 trace_create_file("id", 0444, call->dir, call,
937 id);
Peter Zijlstra23725ae2009-03-19 20:26:13 +0100938
Tom Zanussicf027f62009-03-22 03:30:39 -0500939 if (call->define_fields) {
Li Zefan14be96c2009-08-19 15:53:52 +0800940 ret = call->define_fields(call);
Tom Zanussicf027f62009-03-22 03:30:39 -0500941 if (ret < 0) {
942 pr_warning("Could not initialize trace point"
943 " events/%s\n", call->name);
944 return ret;
945 }
Frederic Weisbeckerf3f3f002009-09-24 15:27:41 +0200946 trace_create_file("filter", 0644, call->dir, call,
947 filter);
Tom Zanussicf027f62009-03-22 03:30:39 -0500948 }
949
Steven Rostedt981d0812009-03-02 13:53:59 -0500950 /* A trace may not want to export its format */
951 if (!call->show_format)
952 return 0;
953
Frederic Weisbeckerf3f3f002009-09-24 15:27:41 +0200954 trace_create_file("format", 0444, call->dir, call,
955 format);
Steven Rostedtfd994982009-02-28 02:41:25 -0500956
Steven Rostedt1473e442009-02-24 14:15:08 -0500957 return 0;
958}
959
Steven Rostedt6d723732009-04-10 14:53:50 -0400960#define for_each_event(event, start, end) \
961 for (event = start; \
962 (unsigned long)event < (unsigned long)end; \
963 event++)
964
Steven Rostedt61f919a2009-04-14 18:22:32 -0400965#ifdef CONFIG_MODULES
Steven Rostedt701970b2009-04-24 23:11:22 -0400966
967static LIST_HEAD(ftrace_module_file_list);
968
969/*
970 * Modules must own their file_operations to keep up with
971 * reference counting.
972 */
973struct ftrace_module_file_ops {
974 struct list_head list;
975 struct module *mod;
976 struct file_operations id;
977 struct file_operations enable;
978 struct file_operations format;
979 struct file_operations filter;
980};
981
Frederic Weisbeckera2ca5e02009-08-06 07:32:21 +0200982static void remove_subsystem_dir(const char *name)
983{
984 struct event_subsystem *system;
985
986 if (strcmp(name, TRACE_SYSTEM) == 0)
987 return;
988
989 list_for_each_entry(system, &event_subsystems, list) {
990 if (strcmp(system->name, name) == 0) {
991 if (!--system->nr_events) {
992 struct event_filter *filter = system->filter;
993
994 debugfs_remove_recursive(system->entry);
995 list_del(&system->list);
996 if (filter) {
997 kfree(filter->filter_string);
998 kfree(filter);
999 }
1000 kfree(system->name);
1001 kfree(system);
1002 }
1003 break;
1004 }
1005 }
1006}
1007
Steven Rostedt701970b2009-04-24 23:11:22 -04001008static struct ftrace_module_file_ops *
1009trace_create_file_ops(struct module *mod)
1010{
1011 struct ftrace_module_file_ops *file_ops;
1012
1013 /*
1014 * This is a bit of a PITA. To allow for correct reference
1015 * counting, modules must "own" their file_operations.
1016 * To do this, we allocate the file operations that will be
1017 * used in the event directory.
1018 */
1019
1020 file_ops = kmalloc(sizeof(*file_ops), GFP_KERNEL);
1021 if (!file_ops)
1022 return NULL;
1023
1024 file_ops->mod = mod;
1025
1026 file_ops->id = ftrace_event_id_fops;
1027 file_ops->id.owner = mod;
1028
1029 file_ops->enable = ftrace_enable_fops;
1030 file_ops->enable.owner = mod;
1031
1032 file_ops->filter = ftrace_event_filter_fops;
1033 file_ops->filter.owner = mod;
1034
1035 file_ops->format = ftrace_event_format_fops;
1036 file_ops->format.owner = mod;
1037
1038 list_add(&file_ops->list, &ftrace_module_file_list);
1039
1040 return file_ops;
1041}
1042
Steven Rostedt6d723732009-04-10 14:53:50 -04001043static void trace_module_add_events(struct module *mod)
1044{
Steven Rostedt701970b2009-04-24 23:11:22 -04001045 struct ftrace_module_file_ops *file_ops = NULL;
Steven Rostedt6d723732009-04-10 14:53:50 -04001046 struct ftrace_event_call *call, *start, *end;
1047 struct dentry *d_events;
Jason Baronf744bd52009-08-10 16:52:39 -04001048 int ret;
Steven Rostedt6d723732009-04-10 14:53:50 -04001049
1050 start = mod->trace_events;
1051 end = mod->trace_events + mod->num_trace_events;
1052
1053 if (start == end)
1054 return;
1055
1056 d_events = event_trace_events_dir();
1057 if (!d_events)
1058 return;
1059
1060 for_each_event(call, start, end) {
1061 /* The linker may leave blanks */
1062 if (!call->name)
1063 continue;
Jason Baronf744bd52009-08-10 16:52:39 -04001064 if (call->raw_init) {
1065 ret = call->raw_init();
1066 if (ret < 0) {
1067 if (ret != -ENOSYS)
1068 pr_warning("Could not initialize trace "
1069 "point events/%s\n", call->name);
1070 continue;
1071 }
1072 }
Steven Rostedt701970b2009-04-24 23:11:22 -04001073 /*
1074 * This module has events, create file ops for this module
1075 * if not already done.
1076 */
1077 if (!file_ops) {
1078 file_ops = trace_create_file_ops(mod);
1079 if (!file_ops)
1080 return;
1081 }
Steven Rostedt6d723732009-04-10 14:53:50 -04001082 call->mod = mod;
1083 list_add(&call->list, &ftrace_events);
Steven Rostedt701970b2009-04-24 23:11:22 -04001084 event_create_dir(call, d_events,
1085 &file_ops->id, &file_ops->enable,
1086 &file_ops->filter, &file_ops->format);
Steven Rostedt6d723732009-04-10 14:53:50 -04001087 }
1088}
1089
1090static void trace_module_remove_events(struct module *mod)
1091{
Steven Rostedt701970b2009-04-24 23:11:22 -04001092 struct ftrace_module_file_ops *file_ops;
Steven Rostedt6d723732009-04-10 14:53:50 -04001093 struct ftrace_event_call *call, *p;
Steven Rostedt9456f0f2009-05-06 21:54:09 -04001094 bool found = false;
Steven Rostedt6d723732009-04-10 14:53:50 -04001095
Steven Rostedt110bf2b2009-06-09 17:29:07 -04001096 down_write(&trace_event_mutex);
Steven Rostedt6d723732009-04-10 14:53:50 -04001097 list_for_each_entry_safe(call, p, &ftrace_events, list) {
1098 if (call->mod == mod) {
Steven Rostedt9456f0f2009-05-06 21:54:09 -04001099 found = true;
Zhaolei0e907c92009-05-25 18:13:59 +08001100 ftrace_event_enable_disable(call, 0);
Steven Rostedt6d723732009-04-10 14:53:50 -04001101 if (call->event)
Steven Rostedt110bf2b2009-06-09 17:29:07 -04001102 __unregister_ftrace_event(call->event);
Steven Rostedt6d723732009-04-10 14:53:50 -04001103 debugfs_remove_recursive(call->dir);
1104 list_del(&call->list);
Li Zefan2df75e42009-05-06 10:33:04 +08001105 trace_destroy_fields(call);
1106 destroy_preds(call);
Xiao Guangrongdc82ec92009-07-09 16:22:22 +08001107 remove_subsystem_dir(call->system);
Steven Rostedt6d723732009-04-10 14:53:50 -04001108 }
1109 }
Steven Rostedt701970b2009-04-24 23:11:22 -04001110
1111 /* Now free the file_operations */
1112 list_for_each_entry(file_ops, &ftrace_module_file_list, list) {
1113 if (file_ops->mod == mod)
1114 break;
1115 }
1116 if (&file_ops->list != &ftrace_module_file_list) {
1117 list_del(&file_ops->list);
1118 kfree(file_ops);
1119 }
Steven Rostedt9456f0f2009-05-06 21:54:09 -04001120
1121 /*
1122 * It is safest to reset the ring buffer if the module being unloaded
1123 * registered any events.
1124 */
1125 if (found)
1126 tracing_reset_current_online_cpus();
Steven Rostedt110bf2b2009-06-09 17:29:07 -04001127 up_write(&trace_event_mutex);
Steven Rostedt6d723732009-04-10 14:53:50 -04001128}
1129
Steven Rostedt61f919a2009-04-14 18:22:32 -04001130static int trace_module_notify(struct notifier_block *self,
1131 unsigned long val, void *data)
Steven Rostedt6d723732009-04-10 14:53:50 -04001132{
1133 struct module *mod = data;
1134
1135 mutex_lock(&event_mutex);
1136 switch (val) {
1137 case MODULE_STATE_COMING:
1138 trace_module_add_events(mod);
1139 break;
1140 case MODULE_STATE_GOING:
1141 trace_module_remove_events(mod);
1142 break;
1143 }
1144 mutex_unlock(&event_mutex);
1145
1146 return 0;
1147}
Steven Rostedt61f919a2009-04-14 18:22:32 -04001148#else
1149static int trace_module_notify(struct notifier_block *self,
1150 unsigned long val, void *data)
1151{
1152 return 0;
1153}
1154#endif /* CONFIG_MODULES */
Steven Rostedt6d723732009-04-10 14:53:50 -04001155
Steven Rostedtec827c72009-09-14 10:50:23 -04001156static struct notifier_block trace_module_nb = {
Steven Rostedt6d723732009-04-10 14:53:50 -04001157 .notifier_call = trace_module_notify,
1158 .priority = 0,
1159};
1160
Steven Rostedta59fd602009-04-10 13:52:20 -04001161extern struct ftrace_event_call __start_ftrace_events[];
1162extern struct ftrace_event_call __stop_ftrace_events[];
1163
Li Zefan020e5f82009-07-01 10:47:05 +08001164static char bootup_event_buf[COMMAND_LINE_SIZE] __initdata;
1165
1166static __init int setup_trace_event(char *str)
1167{
1168 strlcpy(bootup_event_buf, str, COMMAND_LINE_SIZE);
1169 ring_buffer_expanded = 1;
1170 tracing_selftest_disabled = 1;
1171
1172 return 1;
1173}
1174__setup("trace_event=", setup_trace_event);
1175
Steven Rostedtb77e38a2009-02-24 10:21:36 -05001176static __init int event_trace_init(void)
1177{
Steven Rostedta59fd602009-04-10 13:52:20 -04001178 struct ftrace_event_call *call;
Steven Rostedtb77e38a2009-02-24 10:21:36 -05001179 struct dentry *d_tracer;
1180 struct dentry *entry;
Steven Rostedt1473e442009-02-24 14:15:08 -05001181 struct dentry *d_events;
Steven Rostedt6d723732009-04-10 14:53:50 -04001182 int ret;
Li Zefan020e5f82009-07-01 10:47:05 +08001183 char *buf = bootup_event_buf;
1184 char *token;
Steven Rostedtb77e38a2009-02-24 10:21:36 -05001185
1186 d_tracer = tracing_init_dentry();
1187 if (!d_tracer)
1188 return 0;
1189
Steven Rostedt2314c4a2009-03-10 12:04:02 -04001190 entry = debugfs_create_file("available_events", 0444, d_tracer,
1191 (void *)&show_event_seq_ops,
1192 &ftrace_avail_fops);
1193 if (!entry)
1194 pr_warning("Could not create debugfs "
1195 "'available_events' entry\n");
1196
Steven Rostedtb77e38a2009-02-24 10:21:36 -05001197 entry = debugfs_create_file("set_event", 0644, d_tracer,
1198 (void *)&show_set_event_seq_ops,
1199 &ftrace_set_event_fops);
1200 if (!entry)
1201 pr_warning("Could not create debugfs "
1202 "'set_event' entry\n");
1203
Steven Rostedt1473e442009-02-24 14:15:08 -05001204 d_events = event_trace_events_dir();
1205 if (!d_events)
1206 return 0;
1207
Steven Rostedtd1b182a2009-04-15 16:53:47 -04001208 /* ring buffer internal formats */
1209 trace_create_file("header_page", 0444, d_events,
1210 ring_buffer_print_page_header,
1211 &ftrace_show_header_fops);
1212
1213 trace_create_file("header_event", 0444, d_events,
1214 ring_buffer_print_entry_header,
1215 &ftrace_show_header_fops);
1216
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001217 trace_create_file("enable", 0644, d_events,
Li Zefan8f31bfe2009-05-08 10:31:42 +08001218 NULL, &ftrace_system_enable_fops);
Steven Rostedt8ae79a12009-05-06 22:52:15 -04001219
Steven Rostedt6d723732009-04-10 14:53:50 -04001220 for_each_event(call, __start_ftrace_events, __stop_ftrace_events) {
Steven Rostedt1473e442009-02-24 14:15:08 -05001221 /* The linker may leave blanks */
1222 if (!call->name)
1223 continue;
Jason Baronf744bd52009-08-10 16:52:39 -04001224 if (call->raw_init) {
1225 ret = call->raw_init();
1226 if (ret < 0) {
1227 if (ret != -ENOSYS)
1228 pr_warning("Could not initialize trace "
1229 "point events/%s\n", call->name);
1230 continue;
1231 }
1232 }
Steven Rostedta59fd602009-04-10 13:52:20 -04001233 list_add(&call->list, &ftrace_events);
Steven Rostedt701970b2009-04-24 23:11:22 -04001234 event_create_dir(call, d_events, &ftrace_event_id_fops,
1235 &ftrace_enable_fops, &ftrace_event_filter_fops,
1236 &ftrace_event_format_fops);
Steven Rostedt1473e442009-02-24 14:15:08 -05001237 }
1238
Li Zefan020e5f82009-07-01 10:47:05 +08001239 while (true) {
1240 token = strsep(&buf, ",");
1241
1242 if (!token)
1243 break;
1244 if (!*token)
1245 continue;
1246
1247 ret = ftrace_set_clr_event(token, 1);
1248 if (ret)
1249 pr_warning("Failed to enable trace event: %s\n", token);
1250 }
1251
Steven Rostedt6d723732009-04-10 14:53:50 -04001252 ret = register_module_notifier(&trace_module_nb);
Ming Lei55379372009-05-18 23:04:46 +08001253 if (ret)
Steven Rostedt6d723732009-04-10 14:53:50 -04001254 pr_warning("Failed to register trace events module notifier\n");
1255
Steven Rostedtb77e38a2009-02-24 10:21:36 -05001256 return 0;
1257}
1258fs_initcall(event_trace_init);
Steven Rostedte6187002009-04-15 13:36:40 -04001259
1260#ifdef CONFIG_FTRACE_STARTUP_TEST
1261
1262static DEFINE_SPINLOCK(test_spinlock);
1263static DEFINE_SPINLOCK(test_spinlock_irq);
1264static DEFINE_MUTEX(test_mutex);
1265
1266static __init void test_work(struct work_struct *dummy)
1267{
1268 spin_lock(&test_spinlock);
1269 spin_lock_irq(&test_spinlock_irq);
1270 udelay(1);
1271 spin_unlock_irq(&test_spinlock_irq);
1272 spin_unlock(&test_spinlock);
1273
1274 mutex_lock(&test_mutex);
1275 msleep(1);
1276 mutex_unlock(&test_mutex);
1277}
1278
1279static __init int event_test_thread(void *unused)
1280{
1281 void *test_malloc;
1282
1283 test_malloc = kmalloc(1234, GFP_KERNEL);
1284 if (!test_malloc)
1285 pr_info("failed to kmalloc\n");
1286
1287 schedule_on_each_cpu(test_work);
1288
1289 kfree(test_malloc);
1290
1291 set_current_state(TASK_INTERRUPTIBLE);
1292 while (!kthread_should_stop())
1293 schedule();
1294
1295 return 0;
1296}
1297
1298/*
1299 * Do various things that may trigger events.
1300 */
1301static __init void event_test_stuff(void)
1302{
1303 struct task_struct *test_thread;
1304
1305 test_thread = kthread_run(event_test_thread, NULL, "test-events");
1306 msleep(1);
1307 kthread_stop(test_thread);
1308}
1309
1310/*
1311 * For every trace event defined, we will test each trace point separately,
1312 * and then by groups, and finally all trace points.
1313 */
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001314static __init void event_trace_self_tests(void)
Steven Rostedte6187002009-04-15 13:36:40 -04001315{
1316 struct ftrace_event_call *call;
1317 struct event_subsystem *system;
Steven Rostedte6187002009-04-15 13:36:40 -04001318 int ret;
1319
1320 pr_info("Running tests on trace events:\n");
1321
1322 list_for_each_entry(call, &ftrace_events, list) {
1323
1324 /* Only test those that have a regfunc */
1325 if (!call->regfunc)
1326 continue;
1327
Steven Rostedt1f5a6b42009-09-14 11:58:24 -04001328/*
1329 * Testing syscall events here is pretty useless, but
1330 * we still do it if configured. But this is time consuming.
1331 * What we really need is a user thread to perform the
1332 * syscalls as we test.
1333 */
1334#ifndef CONFIG_EVENT_TRACE_TEST_SYSCALLS
1335 if (call->system &&
1336 strcmp(call->system, "syscalls") == 0)
1337 continue;
1338#endif
1339
Steven Rostedte6187002009-04-15 13:36:40 -04001340 pr_info("Testing event %s: ", call->name);
1341
1342 /*
1343 * If an event is already enabled, someone is using
1344 * it and the self test should not be on.
1345 */
1346 if (call->enabled) {
1347 pr_warning("Enabled event during self test!\n");
1348 WARN_ON_ONCE(1);
1349 continue;
1350 }
1351
Zhaolei0e907c92009-05-25 18:13:59 +08001352 ftrace_event_enable_disable(call, 1);
Steven Rostedte6187002009-04-15 13:36:40 -04001353 event_test_stuff();
Zhaolei0e907c92009-05-25 18:13:59 +08001354 ftrace_event_enable_disable(call, 0);
Steven Rostedte6187002009-04-15 13:36:40 -04001355
1356 pr_cont("OK\n");
1357 }
1358
1359 /* Now test at the sub system level */
1360
1361 pr_info("Running tests on trace event systems:\n");
1362
1363 list_for_each_entry(system, &event_subsystems, list) {
1364
1365 /* the ftrace system is special, skip it */
1366 if (strcmp(system->name, "ftrace") == 0)
1367 continue;
1368
1369 pr_info("Testing event system %s: ", system->name);
1370
Li Zefan8f31bfe2009-05-08 10:31:42 +08001371 ret = __ftrace_set_clr_event(NULL, system->name, NULL, 1);
Steven Rostedte6187002009-04-15 13:36:40 -04001372 if (WARN_ON_ONCE(ret)) {
1373 pr_warning("error enabling system %s\n",
1374 system->name);
1375 continue;
1376 }
1377
1378 event_test_stuff();
1379
Li Zefan8f31bfe2009-05-08 10:31:42 +08001380 ret = __ftrace_set_clr_event(NULL, system->name, NULL, 0);
Steven Rostedte6187002009-04-15 13:36:40 -04001381 if (WARN_ON_ONCE(ret))
1382 pr_warning("error disabling system %s\n",
1383 system->name);
1384
1385 pr_cont("OK\n");
1386 }
1387
1388 /* Test with all events enabled */
1389
1390 pr_info("Running tests on all trace events:\n");
1391 pr_info("Testing all events: ");
1392
Li Zefan8f31bfe2009-05-08 10:31:42 +08001393 ret = __ftrace_set_clr_event(NULL, NULL, NULL, 1);
Steven Rostedte6187002009-04-15 13:36:40 -04001394 if (WARN_ON_ONCE(ret)) {
Steven Rostedte6187002009-04-15 13:36:40 -04001395 pr_warning("error enabling all events\n");
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001396 return;
Steven Rostedte6187002009-04-15 13:36:40 -04001397 }
1398
1399 event_test_stuff();
1400
1401 /* reset sysname */
Li Zefan8f31bfe2009-05-08 10:31:42 +08001402 ret = __ftrace_set_clr_event(NULL, NULL, NULL, 0);
Steven Rostedte6187002009-04-15 13:36:40 -04001403 if (WARN_ON_ONCE(ret)) {
1404 pr_warning("error disabling all events\n");
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001405 return;
Steven Rostedte6187002009-04-15 13:36:40 -04001406 }
1407
1408 pr_cont("OK\n");
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001409}
1410
1411#ifdef CONFIG_FUNCTION_TRACER
1412
Tejun Heo245b2e72009-06-24 15:13:48 +09001413static DEFINE_PER_CPU(atomic_t, ftrace_test_event_disable);
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001414
1415static void
1416function_test_events_call(unsigned long ip, unsigned long parent_ip)
1417{
1418 struct ring_buffer_event *event;
Steven Rostedte77405a2009-09-02 14:17:06 -04001419 struct ring_buffer *buffer;
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001420 struct ftrace_entry *entry;
1421 unsigned long flags;
1422 long disabled;
1423 int resched;
1424 int cpu;
1425 int pc;
1426
1427 pc = preempt_count();
1428 resched = ftrace_preempt_disable();
1429 cpu = raw_smp_processor_id();
Tejun Heo245b2e72009-06-24 15:13:48 +09001430 disabled = atomic_inc_return(&per_cpu(ftrace_test_event_disable, cpu));
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001431
1432 if (disabled != 1)
1433 goto out;
1434
1435 local_save_flags(flags);
1436
Steven Rostedte77405a2009-09-02 14:17:06 -04001437 event = trace_current_buffer_lock_reserve(&buffer,
1438 TRACE_FN, sizeof(*entry),
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001439 flags, pc);
1440 if (!event)
1441 goto out;
1442 entry = ring_buffer_event_data(event);
1443 entry->ip = ip;
1444 entry->parent_ip = parent_ip;
1445
Steven Rostedte77405a2009-09-02 14:17:06 -04001446 trace_nowake_buffer_unlock_commit(buffer, event, flags, pc);
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001447
1448 out:
Tejun Heo245b2e72009-06-24 15:13:48 +09001449 atomic_dec(&per_cpu(ftrace_test_event_disable, cpu));
Steven Rostedt9ea21c12009-04-16 12:15:44 -04001450 ftrace_preempt_enable(resched);
1451}
1452
1453static struct ftrace_ops trace_ops __initdata =
1454{
1455 .func = function_test_events_call,
1456};
1457
1458static __init void event_trace_self_test_with_function(void)
1459{
1460 register_ftrace_function(&trace_ops);
1461 pr_info("Running tests again, along with the function tracer\n");
1462 event_trace_self_tests();
1463 unregister_ftrace_function(&trace_ops);
1464}
1465#else
1466static __init void event_trace_self_test_with_function(void)
1467{
1468}
1469#endif
1470
1471static __init int event_trace_self_tests_init(void)
1472{
Li Zefan020e5f82009-07-01 10:47:05 +08001473 if (!tracing_selftest_disabled) {
1474 event_trace_self_tests();
1475 event_trace_self_test_with_function();
1476 }
Steven Rostedte6187002009-04-15 13:36:40 -04001477
1478 return 0;
1479}
1480
Steven Rostedt28d20e22009-04-20 12:12:44 -04001481late_initcall(event_trace_self_tests_init);
Steven Rostedte6187002009-04-15 13:36:40 -04001482
1483#endif