trace_events.c 37.2 KB
Newer Older
1
2
3
4
5
/*
 * event tracer
 *
 * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
 *
6
7
8
 *  - Added format output of fields of the trace point.
 *    This was based off of work by Tom Zanussi <tzanussi@gmail.com>.
 *
9
10
 */

11
12
13
#include <linux/workqueue.h>
#include <linux/spinlock.h>
#include <linux/kthread.h>
14
15
16
17
#include <linux/debugfs.h>
#include <linux/uaccess.h>
#include <linux/module.h>
#include <linux/ctype.h>
18
#include <linux/slab.h>
19
#include <linux/delay.h>
20

21
22
#include <asm/setup.h>

23
#include "trace_output.h"
24

25
#undef TRACE_SYSTEM
26
27
#define TRACE_SYSTEM "TRACE_SYSTEM"

28
DEFINE_MUTEX(event_mutex);
29

30
31
32
33
34
35
DEFINE_MUTEX(event_storage_mutex);
EXPORT_SYMBOL_GPL(event_storage_mutex);

char event_storage[EVENT_STORAGE_SIZE];
EXPORT_SYMBOL_GPL(event_storage);

36
LIST_HEAD(ftrace_events);
37
LIST_HEAD(ftrace_common_fields);
38

39
40
41
42
43
44
45
46
struct list_head *
trace_get_fields(struct ftrace_event_call *event_call)
{
	if (!event_call->class->get_fields)
		return &event_call->class->fields;
	return event_call->class->get_fields(event_call);
}

47
48
49
static int __trace_define_field(struct list_head *head, const char *type,
				const char *name, int offset, int size,
				int is_signed, int filter_type)
50
51
52
{
	struct ftrace_event_field *field;

53
	field = kzalloc(sizeof(*field), GFP_KERNEL);
54
55
	if (!field)
		goto err;
56

57
58
59
	field->name = kstrdup(name, GFP_KERNEL);
	if (!field->name)
		goto err;
60

61
62
63
	field->type = kstrdup(type, GFP_KERNEL);
	if (!field->type)
		goto err;
64

65
66
67
68
69
	if (filter_type == FILTER_OTHER)
		field->filter_type = filter_assign_type(type);
	else
		field->filter_type = filter_type;

70
71
	field->offset = offset;
	field->size = size;
72
	field->is_signed = is_signed;
73

74
	list_add(&field->link, head);
75
76

	return 0;
77

78
err:
79
	if (field)
80
81
		kfree(field->name);
	kfree(field);
82

83
84
	return -ENOMEM;
}
85
86
87
88
89
90
91
92
93
94
95
96
97
98

int trace_define_field(struct ftrace_event_call *call, const char *type,
		       const char *name, int offset, int size, int is_signed,
		       int filter_type)
{
	struct list_head *head;

	if (WARN_ON(!call->class))
		return 0;

	head = trace_get_fields(call);
	return __trace_define_field(head, type, name, offset, size,
				    is_signed, filter_type);
}
99
EXPORT_SYMBOL_GPL(trace_define_field);
100

101
#define __common_field(type, item)					\
102
103
104
105
106
	ret = __trace_define_field(&ftrace_common_fields, #type,	\
				   "common_" #item,			\
				   offsetof(typeof(ent), item),		\
				   sizeof(ent.item),			\
				   is_signed_type(type), FILTER_OTHER);	\
107
108
109
	if (ret)							\
		return ret;

110
static int trace_define_common_fields(void)
111
112
113
114
115
116
117
118
{
	int ret;
	struct trace_entry ent;

	__common_field(unsigned short, type);
	__common_field(unsigned char, flags);
	__common_field(unsigned char, preempt_count);
	__common_field(int, pid);
119
	__common_field(int, padding);
120
121
122
123

	return ret;
}

124
void trace_destroy_fields(struct ftrace_event_call *call)
125
126
{
	struct ftrace_event_field *field, *next;
127
	struct list_head *head;
128

129
130
	head = trace_get_fields(call);
	list_for_each_entry_safe(field, next, head, link) {
131
132
133
134
135
136
137
		list_del(&field->link);
		kfree(field->type);
		kfree(field->name);
		kfree(field);
	}
}

138
139
140
141
int trace_event_raw_init(struct ftrace_event_call *call)
{
	int id;

142
	id = register_ftrace_event(&call->event);
143
144
145
146
147
148
149
	if (!id)
		return -ENODEV;

	return 0;
}
EXPORT_SYMBOL_GPL(trace_event_raw_init);

150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
int ftrace_event_reg(struct ftrace_event_call *call, enum trace_reg type)
{
	switch (type) {
	case TRACE_REG_REGISTER:
		return tracepoint_probe_register(call->name,
						 call->class->probe,
						 call);
	case TRACE_REG_UNREGISTER:
		tracepoint_probe_unregister(call->name,
					    call->class->probe,
					    call);
		return 0;

#ifdef CONFIG_PERF_EVENTS
	case TRACE_REG_PERF_REGISTER:
		return tracepoint_probe_register(call->name,
						 call->class->perf_probe,
						 call);
	case TRACE_REG_PERF_UNREGISTER:
		tracepoint_probe_unregister(call->name,
					    call->class->perf_probe,
					    call);
		return 0;
#endif
	}
	return 0;
}
EXPORT_SYMBOL_GPL(ftrace_event_reg);

179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
void trace_event_enable_cmd_record(bool enable)
{
	struct ftrace_event_call *call;

	mutex_lock(&event_mutex);
	list_for_each_entry(call, &ftrace_events, list) {
		if (!(call->flags & TRACE_EVENT_FL_ENABLED))
			continue;

		if (enable) {
			tracing_start_cmdline_record();
			call->flags |= TRACE_EVENT_FL_RECORDED_CMD;
		} else {
			tracing_stop_cmdline_record();
			call->flags &= ~TRACE_EVENT_FL_RECORDED_CMD;
		}
	}
	mutex_unlock(&event_mutex);
}

199
static int ftrace_event_enable_disable(struct ftrace_event_call *call,
200
201
					int enable)
{
202
203
	int ret = 0;

204
205
	switch (enable) {
	case 0:
206
207
		if (call->flags & TRACE_EVENT_FL_ENABLED) {
			call->flags &= ~TRACE_EVENT_FL_ENABLED;
208
209
210
211
			if (call->flags & TRACE_EVENT_FL_RECORDED_CMD) {
				tracing_stop_cmdline_record();
				call->flags &= ~TRACE_EVENT_FL_RECORDED_CMD;
			}
212
			call->class->reg(call, TRACE_REG_UNREGISTER);
213
214
215
		}
		break;
	case 1:
216
		if (!(call->flags & TRACE_EVENT_FL_ENABLED)) {
217
218
219
220
			if (trace_flags & TRACE_ITER_RECORD_CMD) {
				tracing_start_cmdline_record();
				call->flags |= TRACE_EVENT_FL_RECORDED_CMD;
			}
221
			ret = call->class->reg(call, TRACE_REG_REGISTER);
222
223
224
225
226
227
			if (ret) {
				tracing_stop_cmdline_record();
				pr_info("event trace: Could not enable event "
					"%s\n", call->name);
				break;
			}
228
			call->flags |= TRACE_EVENT_FL_ENABLED;
229
230
231
		}
		break;
	}
232
233

	return ret;
234
235
}

236
237
238
239
240
241
242
243
244
245
246
static void ftrace_clear_events(void)
{
	struct ftrace_event_call *call;

	mutex_lock(&event_mutex);
	list_for_each_entry(call, &ftrace_events, list) {
		ftrace_event_enable_disable(call, 0);
	}
	mutex_unlock(&event_mutex);
}

247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
static void __put_system(struct event_subsystem *system)
{
	struct event_filter *filter = system->filter;

	WARN_ON_ONCE(system->ref_count == 0);
	if (--system->ref_count)
		return;

	if (filter) {
		kfree(filter->filter_string);
		kfree(filter);
	}
	kfree(system->name);
	kfree(system);
}

static void __get_system(struct event_subsystem *system)
{
	WARN_ON_ONCE(system->ref_count == 0);
	system->ref_count++;
}

static void put_system(struct event_subsystem *system)
{
	mutex_lock(&event_mutex);
	__put_system(system);
	mutex_unlock(&event_mutex);
}

276
277
278
279
280
/*
 * __ftrace_set_clr_event(NULL, NULL, NULL, set) will set/unset all events.
 */
static int __ftrace_set_clr_event(const char *match, const char *sub,
				  const char *event, int set)
281
{
282
	struct ftrace_event_call *call;
283
	int ret = -EINVAL;
284
285
286
287

	mutex_lock(&event_mutex);
	list_for_each_entry(call, &ftrace_events, list) {

288
		if (!call->name || !call->class || !call->class->reg)
289
290
291
292
			continue;

		if (match &&
		    strcmp(match, call->name) != 0 &&
293
		    strcmp(match, call->class->system) != 0)
294
295
			continue;

296
		if (sub && strcmp(sub, call->class->system) != 0)
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
			continue;

		if (event && strcmp(event, call->name) != 0)
			continue;

		ftrace_event_enable_disable(call, set);

		ret = 0;
	}
	mutex_unlock(&event_mutex);

	return ret;
}

static int ftrace_set_clr_event(char *buf, int set)
{
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
	char *event = NULL, *sub = NULL, *match;

	/*
	 * The buf format can be <subsystem>:<event-name>
	 *  *:<event-name> means any event by that name.
	 *  :<event-name> is the same.
	 *
	 *  <subsystem>:* means all events in that subsystem
	 *  <subsystem>: means the same.
	 *
	 *  <name> (no ':') means all events in a subsystem with
	 *  the name <name> or any event that matches <name>
	 */

	match = strsep(&buf, ":");
	if (buf) {
		sub = match;
		event = buf;
		match = NULL;

		if (!strlen(sub) || strcmp(sub, "*") == 0)
			sub = NULL;
		if (!strlen(event) || strcmp(event, "*") == 0)
			event = NULL;
	}
338

339
	return __ftrace_set_clr_event(match, sub, event, set);
340
341
}

342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
/**
 * trace_set_clr_event - enable or disable an event
 * @system: system name to match (NULL for any system)
 * @event: event name to match (NULL for all events, within system)
 * @set: 1 to enable, 0 to disable
 *
 * This is a way for other parts of the kernel to enable or disable
 * event recording.
 *
 * Returns 0 on success, -EINVAL if the parameters do not match any
 * registered events.
 */
int trace_set_clr_event(const char *system, const char *event, int set)
{
	return __ftrace_set_clr_event(NULL, system, event, set);
}
358
EXPORT_SYMBOL_GPL(trace_set_clr_event);
359

360
361
362
363
364
365
366
/* 128 should be much more than enough */
#define EVENT_BUF_SIZE		127

static ssize_t
ftrace_event_write(struct file *file, const char __user *ubuf,
		   size_t cnt, loff_t *ppos)
{
367
	struct trace_parser parser;
368
	ssize_t read, ret;
369

370
	if (!cnt)
371
372
		return 0;

373
374
375
376
	ret = tracing_update_buffers();
	if (ret < 0)
		return ret;

377
	if (trace_parser_get_init(&parser, EVENT_BUF_SIZE + 1))
378
379
		return -ENOMEM;

380
381
	read = trace_get_user(&parser, ubuf, cnt, ppos);

382
	if (read >= 0 && trace_parser_loaded((&parser))) {
383
		int set = 1;
384

385
		if (*parser.buffer == '!')
386
387
			set = 0;

388
389
390
		parser.buffer[parser.idx] = 0;

		ret = ftrace_set_clr_event(parser.buffer + !set, set);
391
		if (ret)
392
			goto out_put;
393
394
395
396
	}

	ret = read;

397
398
 out_put:
	trace_parser_put(&parser);
399
400
401
402
403
404
405

	return ret;
}

static void *
t_next(struct seq_file *m, void *v, loff_t *pos)
{
406
	struct ftrace_event_call *call = v;
407
408
409

	(*pos)++;

410
	list_for_each_entry_continue(call, &ftrace_events, list) {
411
412
413
414
		/*
		 * The ftrace subsystem is for showing formats only.
		 * They can not be enabled or disabled via the event files.
		 */
415
		if (call->class && call->class->reg)
416
			return call;
417
	}
418

419
	return NULL;
420
421
422
423
}

static void *t_start(struct seq_file *m, loff_t *pos)
{
424
	struct ftrace_event_call *call;
425
426
	loff_t l;

427
	mutex_lock(&event_mutex);
428

429
	call = list_entry(&ftrace_events, struct ftrace_event_call, list);
430
	for (l = 0; l <= *pos; ) {
431
		call = t_next(m, call, &l);
432
433
434
435
		if (!call)
			break;
	}
	return call;
436
437
438
439
440
}

static void *
s_next(struct seq_file *m, void *v, loff_t *pos)
{
441
	struct ftrace_event_call *call = v;
442
443
444

	(*pos)++;

445
	list_for_each_entry_continue(call, &ftrace_events, list) {
446
		if (call->flags & TRACE_EVENT_FL_ENABLED)
447
			return call;
448
449
	}

450
	return NULL;
451
452
453
454
}

static void *s_start(struct seq_file *m, loff_t *pos)
{
455
	struct ftrace_event_call *call;
456
457
	loff_t l;

458
	mutex_lock(&event_mutex);
459

460
	call = list_entry(&ftrace_events, struct ftrace_event_call, list);
461
	for (l = 0; l <= *pos; ) {
462
		call = s_next(m, call, &l);
463
464
465
466
		if (!call)
			break;
	}
	return call;
467
468
469
470
471
472
}

static int t_show(struct seq_file *m, void *v)
{
	struct ftrace_event_call *call = v;

473
474
	if (strcmp(call->class->system, TRACE_SYSTEM) != 0)
		seq_printf(m, "%s:", call->class->system);
475
476
477
478
479
480
481
	seq_printf(m, "%s\n", call->name);

	return 0;
}

static void t_stop(struct seq_file *m, void *p)
{
482
	mutex_unlock(&event_mutex);
483
484
485
486
487
488
489
490
}

static int
ftrace_event_seq_open(struct inode *inode, struct file *file)
{
	const struct seq_operations *seq_ops;

	if ((file->f_mode & FMODE_WRITE) &&
491
	    (file->f_flags & O_TRUNC))
492
493
494
		ftrace_clear_events();

	seq_ops = inode->i_private;
495
	return seq_open(file, seq_ops);
496
497
}

498
499
500
501
502
503
504
static ssize_t
event_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
		  loff_t *ppos)
{
	struct ftrace_event_call *call = filp->private_data;
	char *buf;

505
	if (call->flags & TRACE_EVENT_FL_ENABLED)
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
		buf = "1\n";
	else
		buf = "0\n";

	return simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);
}

static ssize_t
event_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
		   loff_t *ppos)
{
	struct ftrace_event_call *call = filp->private_data;
	char buf[64];
	unsigned long val;
	int ret;

	if (cnt >= sizeof(buf))
		return -EINVAL;

	if (copy_from_user(&buf, ubuf, cnt))
		return -EFAULT;

	buf[cnt] = 0;

	ret = strict_strtoul(buf, 10, &val);
	if (ret < 0)
		return ret;

534
535
536
537
	ret = tracing_update_buffers();
	if (ret < 0)
		return ret;

538
539
540
	switch (val) {
	case 0:
	case 1:
541
		mutex_lock(&event_mutex);
542
		ret = ftrace_event_enable_disable(call, val);
543
		mutex_unlock(&event_mutex);
544
545
546
547
548
549
550
551
		break;

	default:
		return -EINVAL;
	}

	*ppos += cnt;

552
	return ret ? ret : cnt;
553
554
}

555
556
557
558
static ssize_t
system_enable_read(struct file *filp, char __user *ubuf, size_t cnt,
		   loff_t *ppos)
{
559
	const char set_to_char[4] = { '?', '0', '1', 'X' };
560
	struct event_subsystem *system = filp->private_data;
561
562
	struct ftrace_event_call *call;
	char buf[2];
563
	int set = 0;
564
565
566
567
	int ret;

	mutex_lock(&event_mutex);
	list_for_each_entry(call, &ftrace_events, list) {
568
		if (!call->name || !call->class || !call->class->reg)
569
570
			continue;

571
		if (system && strcmp(call->class->system, system->name) != 0)
572
573
574
575
576
577
578
			continue;

		/*
		 * We need to find out if all the events are set
		 * or if all events or cleared, or if we have
		 * a mixture.
		 */
579
		set |= (1 << !!(call->flags & TRACE_EVENT_FL_ENABLED));
580

581
582
583
		/*
		 * If we have a mixture, no need to look further.
		 */
584
		if (set == 3)
585
586
587
588
			break;
	}
	mutex_unlock(&event_mutex);

589
	buf[0] = set_to_char[set];
590
591
592
593
594
595
596
597
598
599
600
	buf[1] = '\n';

	ret = simple_read_from_buffer(ubuf, cnt, ppos, buf, 2);

	return ret;
}

static ssize_t
system_enable_write(struct file *filp, const char __user *ubuf, size_t cnt,
		    loff_t *ppos)
{
601
602
	struct event_subsystem *system = filp->private_data;
	const char *name = NULL;
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
	unsigned long val;
	char buf[64];
	ssize_t ret;

	if (cnt >= sizeof(buf))
		return -EINVAL;

	if (copy_from_user(&buf, ubuf, cnt))
		return -EFAULT;

	buf[cnt] = 0;

	ret = strict_strtoul(buf, 10, &val);
	if (ret < 0)
		return ret;

	ret = tracing_update_buffers();
	if (ret < 0)
		return ret;

623
	if (val != 0 && val != 1)
624
625
		return -EINVAL;

626
627
628
629
630
631
632
633
	/*
	 * Opening of "enable" adds a ref count to system,
	 * so the name is safe to use.
	 */
	if (system)
		name = system->name;

	ret = __ftrace_set_clr_event(NULL, name, NULL, val);
634
	if (ret)
635
		goto out;
636
637
638

	ret = cnt;

639
out:
640
641
642
643
644
	*ppos += cnt;

	return ret;
}

645
646
enum {
	FORMAT_HEADER		= 1,
647
648
	FORMAT_FIELD_SEPERATOR	= 2,
	FORMAT_PRINTFMT		= 3,
649
650
651
};

static void *f_next(struct seq_file *m, void *v, loff_t *pos)
652
{
653
	struct ftrace_event_call *call = m->private;
654
	struct ftrace_event_field *field;
655
656
	struct list_head *common_head = &ftrace_common_fields;
	struct list_head *head = trace_get_fields(call);
657

658
	(*pos)++;
659

660
661
	switch ((unsigned long)v) {
	case FORMAT_HEADER:
662
663
664
665
666
667
		if (unlikely(list_empty(common_head)))
			return NULL;

		field = list_entry(common_head->prev,
				   struct ftrace_event_field, link);
		return field;
668

669
	case FORMAT_FIELD_SEPERATOR:
670
671
		if (unlikely(list_empty(head)))
			return NULL;
672

673
674
		field = list_entry(head->prev, struct ftrace_event_field, link);
		return field;
675

676
677
678
	case FORMAT_PRINTFMT:
		/* all done */
		return NULL;
679
680
	}

681
	field = v;
682
683
684
	if (field->link.prev == common_head)
		return (void *)FORMAT_FIELD_SEPERATOR;
	else if (field->link.prev == head)
685
686
687
688
689
		return (void *)FORMAT_PRINTFMT;

	field = list_entry(field->link.prev, struct ftrace_event_field, link);

	return field;
690
}
691

692
static void *f_start(struct seq_file *m, loff_t *pos)
693
{
694
695
	loff_t l = 0;
	void *p;
696

697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
	/* Start by showing the header */
	if (!*pos)
		return (void *)FORMAT_HEADER;

	p = (void *)FORMAT_HEADER;
	do {
		p = f_next(m, p, &l);
	} while (p && l < *pos);

	return p;
}

static int f_show(struct seq_file *m, void *v)
{
	struct ftrace_event_call *call = m->private;
	struct ftrace_event_field *field;
	const char *array_descriptor;

	switch ((unsigned long)v) {
	case FORMAT_HEADER:
		seq_printf(m, "name: %s\n", call->name);
		seq_printf(m, "ID: %d\n", call->event.type);
		seq_printf(m, "format:\n");
720
		return 0;
721

722
723
724
725
	case FORMAT_FIELD_SEPERATOR:
		seq_putc(m, '\n');
		return 0;

726
727
728
729
	case FORMAT_PRINTFMT:
		seq_printf(m, "\nprint fmt: %s\n",
			   call->print_fmt);
		return 0;
730
	}
731

732
	field = v;
733

734
735
736
737
738
739
740
741
	/*
	 * Smartly shows the array type(except dynamic array).
	 * Normal:
	 *	field:TYPE VAR
	 * If TYPE := TYPE[LEN], it is shown:
	 *	field:TYPE VAR[LEN]
	 */
	array_descriptor = strchr(field->type, '[');
742

743
744
	if (!strncmp(field->type, "__data_loc", 10))
		array_descriptor = NULL;
745

746
747
748
749
750
751
752
753
754
755
	if (!array_descriptor)
		seq_printf(m, "\tfield:%s %s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
			   field->type, field->name, field->offset,
			   field->size, !!field->is_signed);
	else
		seq_printf(m, "\tfield:%.*s %s%s;\toffset:%u;\tsize:%u;\tsigned:%d;\n",
			   (int)(array_descriptor - field->type),
			   field->type, field->name,
			   array_descriptor, field->offset,
			   field->size, !!field->is_signed);
756

757
758
	return 0;
}
759

760
761
762
static void f_stop(struct seq_file *m, void *p)
{
}
763

764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
static const struct seq_operations trace_format_seq_ops = {
	.start		= f_start,
	.next		= f_next,
	.stop		= f_stop,
	.show		= f_show,
};

static int trace_format_open(struct inode *inode, struct file *file)
{
	struct ftrace_event_call *call = inode->i_private;
	struct seq_file *m;
	int ret;

	ret = seq_open(file, &trace_format_seq_ops);
	if (ret < 0)
		return ret;

	m = file->private_data;
	m->private = call;

	return 0;
785
786
}

787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
static ssize_t
event_id_read(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
{
	struct ftrace_event_call *call = filp->private_data;
	struct trace_seq *s;
	int r;

	if (*ppos)
		return 0;

	s = kmalloc(sizeof(*s), GFP_KERNEL);
	if (!s)
		return -ENOMEM;

	trace_seq_init(s);
802
	trace_seq_printf(s, "%d\n", call->event.type);
803
804
805
806
807
808
809

	r = simple_read_from_buffer(ubuf, cnt, ppos,
				    s->buffer, s->len);
	kfree(s);
	return r;
}

Tom Zanussi's avatar
Tom Zanussi committed
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
static ssize_t
event_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
		  loff_t *ppos)
{
	struct ftrace_event_call *call = filp->private_data;
	struct trace_seq *s;
	int r;

	if (*ppos)
		return 0;

	s = kmalloc(sizeof(*s), GFP_KERNEL);
	if (!s)
		return -ENOMEM;

	trace_seq_init(s);

827
	print_event_filter(call, s);
828
	r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
Tom Zanussi's avatar
Tom Zanussi committed
829
830
831
832
833
834
835
836
837
838
839

	kfree(s);

	return r;
}

static ssize_t
event_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
		   loff_t *ppos)
{
	struct ftrace_event_call *call = filp->private_data;
840
	char *buf;
Tom Zanussi's avatar
Tom Zanussi committed
841
842
	int err;

843
	if (cnt >= PAGE_SIZE)
Tom Zanussi's avatar
Tom Zanussi committed
844
845
		return -EINVAL;

846
847
	buf = (char *)__get_free_page(GFP_TEMPORARY);
	if (!buf)
Tom Zanussi's avatar
Tom Zanussi committed
848
849
		return -ENOMEM;

850
851
852
	if (copy_from_user(buf, ubuf, cnt)) {
		free_page((unsigned long) buf);
		return -EFAULT;
Tom Zanussi's avatar
Tom Zanussi committed
853
	}
854
	buf[cnt] = '\0';
Tom Zanussi's avatar
Tom Zanussi committed
855

856
857
858
	err = apply_event_filter(call, buf);
	free_page((unsigned long) buf);
	if (err < 0)
859
		return err;
860

Tom Zanussi's avatar
Tom Zanussi committed
861
862
863
864
865
	*ppos += cnt;

	return cnt;
}

866
867
868
869
870
871
872
static LIST_HEAD(event_subsystems);

static int subsystem_open(struct inode *inode, struct file *filp)
{
	struct event_subsystem *system = NULL;
	int ret;

873
874
875
	if (!inode->i_private)
		goto skip_search;

876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
	/* Make sure the system still exists */
	mutex_lock(&event_mutex);
	list_for_each_entry(system, &event_subsystems, list) {
		if (system == inode->i_private) {
			/* Don't open systems with no events */
			if (!system->nr_events) {
				system = NULL;
				break;
			}
			__get_system(system);
			break;
		}
	}
	mutex_unlock(&event_mutex);

	if (system != inode->i_private)
		return -ENODEV;

894
 skip_search:
895
	ret = tracing_open_generic(inode, filp);
896
	if (ret < 0 && system)
897
898
899
900
901
902
903
904
905
		put_system(system);

	return ret;
}

static int subsystem_release(struct inode *inode, struct file *file)
{
	struct event_subsystem *system = inode->i_private;

906
907
	if (system)
		put_system(system);
908
909
910
911

	return 0;
}

912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
static ssize_t
subsystem_filter_read(struct file *filp, char __user *ubuf, size_t cnt,
		      loff_t *ppos)
{
	struct event_subsystem *system = filp->private_data;
	struct trace_seq *s;
	int r;

	if (*ppos)
		return 0;

	s = kmalloc(sizeof(*s), GFP_KERNEL);
	if (!s)
		return -ENOMEM;

	trace_seq_init(s);

929
	print_subsystem_event_filter(system, s);
930
	r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);
931
932
933
934
935
936
937
938
939
940
941

	kfree(s);

	return r;
}

static ssize_t
subsystem_filter_write(struct file *filp, const char __user *ubuf, size_t cnt,
		       loff_t *ppos)
{
	struct event_subsystem *system = filp->private_data;
942
	char *buf;
943
944
	int err;

945
	if (cnt >= PAGE_SIZE)
946
947
		return -EINVAL;

948
949
	buf = (char *)__get_free_page(GFP_TEMPORARY);
	if (!buf)
950
951
		return -ENOMEM;

952
953
954
	if (copy_from_user(buf, ubuf, cnt)) {
		free_page((unsigned long) buf);
		return -EFAULT;
955
	}
956
	buf[cnt] = '\0';
957

958
959
960
	err = apply_subsystem_event_filter(system, buf);
	free_page((unsigned long) buf);
	if (err < 0)
961
		return err;
962
963
964
965
966
967

	*ppos += cnt;

	return cnt;
}

968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
static ssize_t
show_header(struct file *filp, char __user *ubuf, size_t cnt, loff_t *ppos)
{
	int (*func)(struct trace_seq *s) = filp->private_data;
	struct trace_seq *s;
	int r;

	if (*ppos)
		return 0;

	s = kmalloc(sizeof(*s), GFP_KERNEL);
	if (!s)
		return -ENOMEM;

	trace_seq_init(s);

	func(s);
	r = simple_read_from_buffer(ubuf, cnt, ppos, s->buffer, s->len);

	kfree(s);

	return r;
}

992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
static const struct seq_operations show_event_seq_ops = {
	.start = t_start,
	.next = t_next,
	.show = t_show,
	.stop = t_stop,
};

static const struct seq_operations show_set_event_seq_ops = {
	.start = s_start,
	.next = s_next,
	.show = t_show,
	.stop = t_stop,
};

1006
1007
1008
1009
1010
1011
1012
static const struct file_operations ftrace_avail_fops = {
	.open = ftrace_event_seq_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = seq_release,
};

1013
1014
1015
1016
1017
1018
1019
1020
static const struct file_operations ftrace_set_event_fops = {
	.open = ftrace_event_seq_open,
	.read = seq_read,
	.write = ftrace_event_write,
	.llseek = seq_lseek,
	.release = seq_release,
};

1021
1022
1023
1024
static const struct file_operations ftrace_enable_fops = {
	.open = tracing_open_generic,
	.read = event_enable_read,
	.write = event_enable_write,
1025
	.llseek = default_llseek,
1026
1027
};

1028
static const struct file_operations ftrace_event_format_fops = {
1029
1030
1031
1032
	.open = trace_format_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = seq_release,
1033
1034
};

1035
1036
1037
static const struct file_operations ftrace_event_id_fops = {
	.open = tracing_open_generic,
	.read = event_id_read,
1038
	.llseek = default_llseek,
1039
1040
};

Tom Zanussi's avatar
Tom Zanussi committed
1041
1042
1043
1044
static const struct file_operations ftrace_event_filter_fops = {
	.open = tracing_open_generic,
	.read = event_filter_read,
	.write = event_filter_write,
1045
	.llseek = default_llseek,
Tom Zanussi's avatar
Tom Zanussi committed
1046
1047
};

1048
static const struct file_operations ftrace_subsystem_filter_fops = {
1049
	.open = subsystem_open,
1050
1051
	.read = subsystem_filter_read,
	.write = subsystem_filter_write,
1052
	.llseek = default_llseek,
1053
	.release = subsystem_release,
1054
1055
};

1056
static const struct file_operations ftrace_system_enable_fops = {
1057
	.open = subsystem_open,
1058
1059
	.read = system_enable_read,
	.write = system_enable_write,
1060
	.llseek = default_llseek,
1061
	.release = subsystem_release,
1062
1063
};

1064
1065
1066
static const struct file_operations ftrace_show_header_fops = {
	.open = tracing_open_generic,
	.read = show_header,
1067
	.llseek = default_llseek,
1068
1069
};

1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
static struct dentry *event_trace_events_dir(void)
{
	static struct dentry *d_tracer;
	static struct dentry *d_events;

	if (d_events)
		return d_events;

	d_tracer = tracing_init_dentry();
	if (!d_tracer)
		return NULL;

	d_events = debugfs_create_dir("events", d_tracer);
	if (!d_events)
		pr_warning("Could not create debugfs "
			   "'events' directory\n");

	return d_events;
}

1090
1091
1092
1093
static struct dentry *
event_subsystem_dir(const char *name, struct dentry *d_events)
{
	struct event_subsystem *system;
1094
	struct dentry *entry;
1095
1096
1097

	/* First see if we did not already create this dir */
	list_for_each_entry(system, &event_subsystems, list) {
1098
		if (strcmp(system->name, name) == 0) {
1099
			__get_system(system);
1100
			system->nr_events++;
1101
			return system->entry;
1102
		}
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
	}

	/* need to create new entry */
	system = kmalloc(sizeof(*system), GFP_KERNEL);
	if (!system) {
		pr_warning("No memory to create event subsystem %s\n",
			   name);
		return d_events;
	}

	system->entry = debugfs_create_dir(name, d_events);
	if (!system->entry) {
		pr_warning("Could not create event subsystem %s\n",
			   name);
		kfree(system);
		return d_events;
	}

1121
	system->nr_events = 1;
1122
	system->ref_count = 1;
1123
1124
1125
1126
1127
1128
1129
	system->name = kstrdup(name, GFP_KERNEL);
	if (!system->name) {
		debugfs_remove(system->entry);
		kfree(system);
		return d_events;
	}

1130
1131
	list_add(&system->list, &event_subsystems);

1132
	system->filter = NULL;
1133

1134
1135
1136
1137
1138
1139
1140
	system->filter = kzalloc(sizeof(struct event_filter), GFP_KERNEL);
	if (!system->filter) {
		pr_warning("Could not allocate filter for subsystem "
			   "'%s'\n", name);
		return system->entry;
	}

1141
1142
	entry = debugfs_create_file("filter", 0644, system->entry, system,
				    &ftrace_subsystem_filter_fops);
1143
1144
1145
	if (!entry) {
		kfree(system->filter);
		system->filter = NULL;
1146
1147
		pr_warning("Could not create debugfs "
			   "'%s/filter' entry\n", name);
1148
	}
1149

1150
	trace_create_file("enable", 0644, system->entry, system,
1151
			  &ftrace_system_enable_fops);
1152

1153
1154
1155
	return system->entry;
}

1156
static int
1157
1158
1159
1160
1161
event_create_dir(struct ftrace_event_call *call, struct dentry *d_events,
		 const struct file_operations *id,
		 const struct file_operations *enable,
		 const struct file_operations *filter,
		 const struct file_operations *format)
1162
{
1163
	struct list_head *head;
1164
	int ret;
1165

1166
1167
1168
1169
	/*
	 * If the trace point header did not define TRACE_SYSTEM
	 * then the system would be called "TRACE_SYSTEM".
	 */
1170
1171
	if (strcmp(call->class->system, TRACE_SYSTEM) != 0)
		d_events = event_subsystem_dir(call->class->system, d_events);
1172

1173
1174
1175
1176
1177
1178
1179
	call->dir = debugfs_create_dir(call->name, d_events);
	if (!call->dir) {
		pr_warning("Could not create debugfs "
			   "'%s' directory\n", call->name);
		return -1;
	}

1180
	if (call->class->reg)
1181
1182
		trace_create_file("enable", 0644, call->dir, call,
				  enable);
1183

1184
#ifdef CONFIG_PERF_EVENTS
1185
	if (call->event.type && call->class->reg)
1186
1187
		trace_create_file("id", 0444, call->dir, call,
		 		  id);
1188
#endif
1189

1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
	/*
	 * Other events may have the same class. Only update
	 * the fields if they are not already defined.
	 */
	head = trace_get_fields(call);
	if (list_empty(head)) {
		ret = call->class->define_fields(call);
		if (ret < 0) {
			pr_warning("Could not initialize trace point"
				   " events/%s\n", call->name);
			return ret;
1201
1202
		}
	}
1203
1204
	trace_create_file("filter", 0644, call->dir, call,
			  filter);
1205

1206
1207
	trace_create_file("format", 0444, call->dir, call,
			  format);
1208
1209
1210
1211

	return 0;
}

1212
1213
1214
1215
1216
1217
static int
__trace_add_event_call(struct ftrace_event_call *call, struct module *mod,
		       const struct file_operations *id,
		       const struct file_operations *enable,
		       const struct file_operations *filter,
		       const struct file_operations *format)
1218
1219
1220
{
	struct dentry *d_events;
	int ret;
1221

1222
	/* The linker may leave blanks */
1223
1224
	if (!call->name)
		return -EINVAL;
1225

1226
1227
	if (call->class->raw_init) {
		ret = call->class->raw_init(call);
1228
1229
		if (ret < 0) {
			if (ret != -ENOSYS)
1230
1231
				pr_warning("Could not initialize trace events/%s\n",
					   call->name);
1232
1233
1234
			return ret;
		}
	}
1235

1236
1237
1238
1239
	d_events = event_trace_events_dir();
	if (!d_events)
		return -ENOENT;

1240
	ret = event_create_dir(call, d_events, id, enable, filter, format);
1241
1242
	if (!ret)
		list_add(&call->list, &ftrace_events);
1243
	call->mod = mod;
Masami Hiramatsu's avatar