trace.h 39.4 KB
Newer Older
1

2
3
4
5
#ifndef _LINUX_KERNEL_TRACE_H
#define _LINUX_KERNEL_TRACE_H

#include <linux/fs.h>
Arun Sharma's avatar
Arun Sharma committed
6
#include <linux/atomic.h>
7
8
#include <linux/sched.h>
#include <linux/clocksource.h>
9
#include <linux/ring_buffer.h>
Pekka Paalanen's avatar
Pekka Paalanen committed
10
#include <linux/mmiotrace.h>
11
#include <linux/tracepoint.h>
12
#include <linux/ftrace.h>
13
#include <linux/hw_breakpoint.h>
14
#include <linux/trace_seq.h>
15
#include <linux/ftrace_event.h>
16

17
18
19
20
21
#ifdef CONFIG_FTRACE_SYSCALLS
#include <asm/unistd.h>		/* For NR_SYSCALLS	     */
#include <asm/syscall.h>	/* some archs define it here */
#endif

22
23
24
25
26
27
28
enum trace_type {
	__TRACE_FIRST_TYPE = 0,

	TRACE_FN,
	TRACE_CTX,
	TRACE_WAKE,
	TRACE_STACK,
29
	TRACE_PRINT,
30
	TRACE_BPRINT,
Pekka Paalanen's avatar
Pekka Paalanen committed
31
32
	TRACE_MMIO_RW,
	TRACE_MMIO_MAP,
33
	TRACE_BRANCH,
34
35
	TRACE_GRAPH_RET,
	TRACE_GRAPH_ENT,
36
	TRACE_USER_STACK,
37
	TRACE_BLK,
38
	TRACE_BPUTS,
39

40
	__TRACE_LAST_TYPE,
41
42
};

43

44
45
#undef __field
#define __field(type, item)		type	item;
Ingo Molnar's avatar
Ingo Molnar committed
46

47
48
#undef __field_struct
#define __field_struct(type, item)	__field(type, item)
Ingo Molnar's avatar
Ingo Molnar committed
49

50
51
#undef __field_desc
#define __field_desc(type, container, item)
52

53
54
#undef __array
#define __array(type, item, size)	type	item[size];
55

56
57
#undef __array_desc
#define __array_desc(type, container, item, size)
58

59
60
#undef __dynamic_array
#define __dynamic_array(type, item)	type	item[];
61

62
63
#undef F_STRUCT
#define F_STRUCT(args...)		args
64

65
#undef FTRACE_ENTRY
66
67
68
69
#define FTRACE_ENTRY(name, struct_name, id, tstruct, print, filter)	\
	struct struct_name {						\
		struct trace_entry	ent;				\
		tstruct							\
70
	}
71

72
73
#undef TP_ARGS
#define TP_ARGS(args...)	args
74

75
#undef FTRACE_ENTRY_DUP
76
#define FTRACE_ENTRY_DUP(name, name_struct, id, tstruct, printk, filter)
77

78
#undef FTRACE_ENTRY_REG
79
80
81
82
#define FTRACE_ENTRY_REG(name, struct_name, id, tstruct, print,	\
			 filter, regfn) \
	FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print), \
		     filter)
83

84
#include "trace_entries.h"
85

86
87
88
89
/*
 * syscalls are special, and need special handling, this is why
 * they are not included in trace_entries.h
 */
90
91
92
93
94
95
96
97
98
struct syscall_trace_enter {
	struct trace_entry	ent;
	int			nr;
	unsigned long		args[];
};

struct syscall_trace_exit {
	struct trace_entry	ent;
	int			nr;
99
	long			ret;
100
101
};

102
struct kprobe_trace_entry_head {
103
104
105
106
	struct trace_entry	ent;
	unsigned long		ip;
};

107
struct kretprobe_trace_entry_head {
108
109
110
111
112
	struct trace_entry	ent;
	unsigned long		func;
	unsigned long		ret_ip;
};

113
114
115
/*
 * trace_flag_type is an enumeration that holds different
 * states when a trace occurs. These are:
116
 *  IRQS_OFF		- interrupts were disabled
117
 *  IRQS_NOSUPPORT	- arch does not support irqs_disabled_flags
Li Zefan's avatar
Li Zefan committed
118
 *  NEED_RESCHED	- reschedule is requested
119
120
 *  HARDIRQ		- inside an interrupt handler
 *  SOFTIRQ		- inside a softirq handler
121
122
123
 */
enum trace_flag_type {
	TRACE_FLAG_IRQS_OFF		= 0x01,
124
125
126
127
	TRACE_FLAG_IRQS_NOSUPPORT	= 0x02,
	TRACE_FLAG_NEED_RESCHED		= 0x04,
	TRACE_FLAG_HARDIRQ		= 0x08,
	TRACE_FLAG_SOFTIRQ		= 0x10,
128
	TRACE_FLAG_PREEMPT_RESCHED	= 0x20,
129
130
};

131
#define TRACE_BUF_SIZE		1024
132

133
134
struct trace_array;

135
136
137
138
139
140
141
/*
 * The CPU trace array - it consists of thousands of trace entries
 * plus some other descriptor data: (for example which task started
 * the trace, etc.)
 */
struct trace_array_cpu {
	atomic_t		disabled;
142
	void			*buffer_page;	/* ring buffer spare */
Ingo Molnar's avatar
Ingo Molnar committed
143

144
	unsigned long		entries;
145
146
147
148
149
150
151
	unsigned long		saved_latency;
	unsigned long		critical_start;
	unsigned long		critical_end;
	unsigned long		critical_sequence;
	unsigned long		nice;
	unsigned long		policy;
	unsigned long		rt_priority;
152
	unsigned long		skipped_entries;
153
154
	cycle_t			preempt_timestamp;
	pid_t			pid;
155
	kuid_t			uid;
156
157
158
	char			comm[TASK_COMM_LEN];
};

159
160
struct tracer;

161
162
163
164
165
166
167
168
struct trace_buffer {
	struct trace_array		*tr;
	struct ring_buffer		*buffer;
	struct trace_array_cpu __percpu	*data;
	cycle_t				time_start;
	int				cpu;
};

169
170
171
172
173
174
/*
 * The trace array - an array of per-CPU trace arrays. This is the
 * highest level data structure that individual tracers deal with.
 * They have on/off state as well:
 */
struct trace_array {
175
	struct list_head	list;
176
	char			*name;
177
178
179
180
181
182
183
184
185
186
187
188
189
190
	struct trace_buffer	trace_buffer;
#ifdef CONFIG_TRACER_MAX_TRACE
	/*
	 * The max_buffer is used to snapshot the trace when a maximum
	 * latency is reached, or when the user initiates a snapshot.
	 * Some tracers will use this to store a maximum trace while
	 * it continues examining live traces.
	 *
	 * The buffers for the max_buffer are set up the same as the trace_buffer
	 * When a snapshot is taken, the buffer of the max_buffer is swapped
	 * with the buffer of the trace_buffer and the buffers are reset for
	 * the trace_buffer so the tracing can continue.
	 */
	struct trace_buffer	max_buffer;
191
	bool			allocated_snapshot;
192
#endif
193
	int			buffer_disabled;
194
195
196
#ifdef CONFIG_FTRACE_SYSCALLS
	int			sys_refcount_enter;
	int			sys_refcount_exit;
197
198
	struct ftrace_event_file __rcu *enter_syscall_files[NR_syscalls];
	struct ftrace_event_file __rcu *exit_syscall_files[NR_syscalls];
199
#endif
200
201
202
	int			stop_count;
	int			clock_id;
	struct tracer		*current_trace;
203
	unsigned int		flags;
204
	raw_spinlock_t		start_lock;
205
	struct dentry		*dir;
206
207
	struct dentry		*options;
	struct dentry		*percpu_dir;
208
209
210
	struct dentry		*event_dir;
	struct list_head	systems;
	struct list_head	events;
211
	cpumask_var_t		tracing_cpumask; /* only trace on set CPUs */
212
	int			ref;
213
214
215
216
217
#ifdef CONFIG_FUNCTION_TRACER
	struct ftrace_ops	*ops;
	/* function tracing enabled */
	int			function_enabled;
#endif
218
219
};

220
221
222
223
224
225
enum {
	TRACE_ARRAY_FL_GLOBAL	= (1 << 0)
};

extern struct list_head ftrace_trace_arrays;

226
227
extern struct mutex trace_types_lock;

228
229
230
extern int trace_array_get(struct trace_array *tr);
extern void trace_array_put(struct trace_array *tr);

231
232
233
234
235
236
237
238
239
240
241
242
243
244
/*
 * The global tracer (top) should be the first trace array added,
 * but we check the flag anyway.
 */
static inline struct trace_array *top_trace_array(void)
{
	struct trace_array *tr;

	tr = list_entry(ftrace_trace_arrays.prev,
			typeof(*tr), list);
	WARN_ON(!(tr->flags & TRACE_ARRAY_FL_GLOBAL));
	return tr;
}

245
246
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
276
#define FTRACE_CMP_TYPE(var, type) \
	__builtin_types_compatible_p(typeof(var), type *)

#undef IF_ASSIGN
#define IF_ASSIGN(var, entry, etype, id)		\
	if (FTRACE_CMP_TYPE(var, etype)) {		\
		var = (typeof(var))(entry);		\
		WARN_ON(id && (entry)->type != id);	\
		break;					\
	}

/* Will cause compile errors if type is not found. */
extern void __ftrace_bad_type(void);

/*
 * The trace_assign_type is a verifier that the entry type is
 * the same as the type being assigned. To add new types simply
 * add a line with the following format:
 *
 * IF_ASSIGN(var, ent, type, id);
 *
 *  Where "type" is the trace type that includes the trace_entry
 *  as the "ent" item. And "id" is the trace identifier that is
 *  used in the trace_type enum.
 *
 *  If the type can have more than one id, then use zero.
 */
#define trace_assign_type(var, ent)					\
	do {								\
		IF_ASSIGN(var, ent, struct ftrace_entry, TRACE_FN);	\
		IF_ASSIGN(var, ent, struct ctx_switch_entry, 0);	\
		IF_ASSIGN(var, ent, struct stack_entry, TRACE_STACK);	\
277
		IF_ASSIGN(var, ent, struct userstack_entry, TRACE_USER_STACK);\
278
		IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT);	\
279
		IF_ASSIGN(var, ent, struct bprint_entry, TRACE_BPRINT);	\
280
		IF_ASSIGN(var, ent, struct bputs_entry, TRACE_BPUTS);	\
281
282
283
284
		IF_ASSIGN(var, ent, struct trace_mmiotrace_rw,		\
			  TRACE_MMIO_RW);				\
		IF_ASSIGN(var, ent, struct trace_mmiotrace_map,		\
			  TRACE_MMIO_MAP);				\
285
		IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \
286
287
288
289
		IF_ASSIGN(var, ent, struct ftrace_graph_ent_entry,	\
			  TRACE_GRAPH_ENT);		\
		IF_ASSIGN(var, ent, struct ftrace_graph_ret_entry,	\
			  TRACE_GRAPH_RET);		\
290
291
		__ftrace_bad_type();					\
	} while (0)
292

293
294
295
296
297
298
/*
 * An option specific to a tracer. This is a boolean value.
 * The bit is the bit index that sets its value on the
 * flags value in struct tracer_flags.
 */
struct tracer_opt {
299
300
	const char	*name; /* Will appear on the trace_options file */
	u32		bit; /* Mask assigned in val field in tracer_flags */
301
302
303
304
305
306
307
308
};

/*
 * The set of specific options for a tracer. Your tracer
 * have to set the initial value of the flags val.
 */
struct tracer_flags {
	u32			val;
309
	struct tracer_opt	*opts;
310
311
312
313
314
};

/* Makes more easy to define a tracer opt */
#define TRACER_OPT(s, b)	.name = #s, .bit = b

315

316
317
318
319
320
321
322
323
324
325
326
/**
 * struct tracer - a specific tracer and its callbacks to interact with debugfs
 * @name: the name chosen to select it on the available_tracers file
 * @init: called when one switches to this tracer (echo name > current_tracer)
 * @reset: called when one switches to another tracer
 * @start: called when tracing is unpaused (echo 1 > tracing_enabled)
 * @stop: called when tracing is paused (echo 0 > tracing_enabled)
 * @open: called when the trace file is opened
 * @pipe_open: called when the trace_pipe file is opened
 * @wait_pipe: override how the user waits for traces on trace_pipe
 * @close: called when the trace file is released
327
 * @pipe_close: called when the trace_pipe file is released
328
329
330
331
332
333
334
 * @read: override the default read callback on trace_pipe
 * @splice_read: override the default splice_read callback on trace_pipe
 * @selftest: selftest to run on boot (see trace_selftest.c)
 * @print_headers: override the first lines that describe your columns
 * @print_line: callback that prints a trace
 * @set_flag: signals one of your private flags changed (trace_options file)
 * @flags: your private flags
335
336
337
 */
struct tracer {
	const char		*name;
338
	int			(*init)(struct trace_array *tr);
339
	void			(*reset)(struct trace_array *tr);
340
341
	void			(*start)(struct trace_array *tr);
	void			(*stop)(struct trace_array *tr);
342
	void			(*open)(struct trace_iterator *iter);
343
	void			(*pipe_open)(struct trace_iterator *iter);
344
	void			(*wait_pipe)(struct trace_iterator *iter);
345
	void			(*close)(struct trace_iterator *iter);
346
	void			(*pipe_close)(struct trace_iterator *iter);
347
348
349
	ssize_t			(*read)(struct trace_iterator *iter,
					struct file *filp, char __user *ubuf,
					size_t cnt, loff_t *ppos);
350
351
352
353
354
355
	ssize_t			(*splice_read)(struct trace_iterator *iter,
					       struct file *filp,
					       loff_t *ppos,
					       struct pipe_inode_info *pipe,
					       size_t len,
					       unsigned int flags);
Steven Rostedt's avatar
Steven Rostedt committed
356
357
358
359
#ifdef CONFIG_FTRACE_STARTUP_TEST
	int			(*selftest)(struct tracer *trace,
					    struct trace_array *tr);
#endif
360
	void			(*print_header)(struct seq_file *m);
361
	enum print_line_t	(*print_line)(struct trace_iterator *iter);
362
	/* If you handled the flag setting, return 0 */
363
364
	int			(*set_flag)(struct trace_array *tr,
					    u32 old_flags, u32 bit, int set);
365
	/* Return 0 if OK with change, else return non-zero */
366
	int			(*flag_changed)(struct trace_array *tr,
367
						u32 mask, int set);
368
	struct tracer		*next;
369
	struct tracer_flags	*flags;
370
	int			enabled;
371
	bool			print_max;
372
	bool			allow_instances;
373
#ifdef CONFIG_TRACER_MAX_TRACE
374
	bool			use_max_tr;
375
#endif
376
377
};

378

379
380
/* Only current can touch trace_recursion */

381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
/*
 * For function tracing recursion:
 *  The order of these bits are important.
 *
 *  When function tracing occurs, the following steps are made:
 *   If arch does not support a ftrace feature:
 *    call internal function (uses INTERNAL bits) which calls...
 *   If callback is registered to the "global" list, the list
 *    function is called and recursion checks the GLOBAL bits.
 *    then this function calls...
 *   The function callback, which can use the FTRACE bits to
 *    check for recursion.
 *
 * Now if the arch does not suppport a feature, and it calls
 * the global list function which calls the ftrace callback
 * all three of these steps will do a recursion protection.
 * There's no reason to do one if the previous caller already
 * did. The recursion that we are protecting against will
 * go through the same steps again.
 *
 * To prevent the multiple recursion checks, if a recursion
 * bit is set that is higher than the MAX bit of the current
 * check, then we know that the check was made by the previous
 * caller, and we can skip the current check.
 */
406
enum {
407
408
409
410
411
412
413
	TRACE_BUFFER_BIT,
	TRACE_BUFFER_NMI_BIT,
	TRACE_BUFFER_IRQ_BIT,
	TRACE_BUFFER_SIRQ_BIT,

	/* Start of function recursion bits */
	TRACE_FTRACE_BIT,
414
415
416
	TRACE_FTRACE_NMI_BIT,
	TRACE_FTRACE_IRQ_BIT,
	TRACE_FTRACE_SIRQ_BIT,
417

418
	/* GLOBAL_BITs must be greater than FTRACE_BITs */
419
420
421
422
423
	TRACE_GLOBAL_BIT,
	TRACE_GLOBAL_NMI_BIT,
	TRACE_GLOBAL_IRQ_BIT,
	TRACE_GLOBAL_SIRQ_BIT,

424
425
426
427
428
429
	/* INTERNAL_BITs must be greater than GLOBAL_BITs */
	TRACE_INTERNAL_BIT,
	TRACE_INTERNAL_NMI_BIT,
	TRACE_INTERNAL_IRQ_BIT,
	TRACE_INTERNAL_SIRQ_BIT,

430
	TRACE_CONTROL_BIT,
431

432
433
434
435
436
437
438
/*
 * Abuse of the trace_recursion.
 * As we need a way to maintain state if we are tracing the function
 * graph in irq because we want to trace a particular function that
 * was called in irq context but we have irq tracing off. Since this
 * can only be modified by current, we can reuse trace_recursion.
 */
439
440
	TRACE_IRQ_BIT,
};
441

442
443
444
#define trace_recursion_set(bit)	do { (current)->trace_recursion |= (1<<(bit)); } while (0)
#define trace_recursion_clear(bit)	do { (current)->trace_recursion &= ~(1<<(bit)); } while (0)
#define trace_recursion_test(bit)	((current)->trace_recursion & (1<<(bit)))
445

446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
#define TRACE_CONTEXT_BITS	4

#define TRACE_FTRACE_START	TRACE_FTRACE_BIT
#define TRACE_FTRACE_MAX	((1 << (TRACE_FTRACE_START + TRACE_CONTEXT_BITS)) - 1)

#define TRACE_GLOBAL_START	TRACE_GLOBAL_BIT
#define TRACE_GLOBAL_MAX	((1 << (TRACE_GLOBAL_START + TRACE_CONTEXT_BITS)) - 1)

#define TRACE_LIST_START	TRACE_INTERNAL_BIT
#define TRACE_LIST_MAX		((1 << (TRACE_LIST_START + TRACE_CONTEXT_BITS)) - 1)

#define TRACE_CONTEXT_MASK	TRACE_LIST_MAX

static __always_inline int trace_get_context_bit(void)
{
	int bit;

	if (in_interrupt()) {
		if (in_nmi())
			bit = 0;

		else if (in_irq())
			bit = 1;
		else
			bit = 2;
	} else
		bit = 3;

	return bit;
}

static __always_inline int trace_test_and_set_recursion(int start, int max)
{
	unsigned int val = current->trace_recursion;
	int bit;

	/* A previous recursion check was made */
	if ((val & TRACE_CONTEXT_MASK) > max)
		return 0;

	bit = trace_get_context_bit() + start;
	if (unlikely(val & (1 << bit)))
		return -1;

	val |= 1 << bit;
	current->trace_recursion = val;
	barrier();

	return bit;
}

static __always_inline void trace_clear_recursion(int bit)
{
	unsigned int val = current->trace_recursion;

	if (!bit)
		return;

	bit = 1 << bit;
	val &= ~bit;

	barrier();
	current->trace_recursion = val;
}

511
512
513
514
515
516
517
518
static inline struct ring_buffer_iter *
trace_buffer_iter(struct trace_iterator *iter, int cpu)
{
	if (iter->buffer_iter && iter->buffer_iter[cpu])
		return iter->buffer_iter[cpu];
	return NULL;
}

519
int tracer_init(struct tracer *t, struct trace_array *tr);
520
int tracing_is_enabled(void);
521
522
void tracing_reset(struct trace_buffer *buf, int cpu);
void tracing_reset_online_cpus(struct trace_buffer *buf);
523
void tracing_reset_current(int cpu);
524
void tracing_reset_all_online_cpus(void);
525
int tracing_open_generic(struct inode *inode, struct file *filp);
526
bool tracing_is_disabled(void);
527
struct dentry *trace_create_file(const char *name,
Al Viro's avatar
Al Viro committed
528
				 umode_t mode,
529
530
531
532
				 struct dentry *parent,
				 void *data,
				 const struct file_operations *fops);

533
struct dentry *tracing_init_dentry_tr(struct trace_array *tr);
534
struct dentry *tracing_init_dentry(void);
Ingo Molnar's avatar
Ingo Molnar committed
535

536
537
struct ring_buffer_event;

538
539
540
541
542
543
struct ring_buffer_event *
trace_buffer_lock_reserve(struct ring_buffer *buffer,
			  int type,
			  unsigned long len,
			  unsigned long flags,
			  int pc);
544

545
546
struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
						struct trace_array_cpu *data);
547
548
549
550

struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,
					  int *ent_cpu, u64 *ent_ts);

551
552
553
void __buffer_unlock_commit(struct ring_buffer *buffer,
			    struct ring_buffer_event *event);

554
555
556
557
558
559
560
561
int trace_empty(struct trace_iterator *iter);

void *trace_find_next_entry_inc(struct trace_iterator *iter);

void trace_init_global_iter(struct trace_iterator *iter);

void tracing_iter_reset(struct trace_iterator *iter, int cpu);

562
563
void poll_wait_pipe(struct trace_iterator *iter);

564
565
566
void tracing_sched_switch_trace(struct trace_array *tr,
				struct task_struct *prev,
				struct task_struct *next,
567
				unsigned long flags, int pc);
568
569
570
571

void tracing_sched_wakeup_trace(struct trace_array *tr,
				struct task_struct *wakee,
				struct task_struct *cur,
572
				unsigned long flags, int pc);
573
574
575
void trace_function(struct trace_array *tr,
		    unsigned long ip,
		    unsigned long parent_ip,
576
		    unsigned long flags, int pc);
577
578
579
580
void trace_graph_function(struct trace_array *tr,
		    unsigned long ip,
		    unsigned long parent_ip,
		    unsigned long flags, int pc);
581
void trace_latency_header(struct seq_file *m);
582
583
584
void trace_default_header(struct seq_file *m);
void print_trace_header(struct seq_file *m, struct trace_iterator *iter);
int trace_empty(struct trace_iterator *iter);
585

586
void trace_graph_return(struct ftrace_graph_ret *trace);
587
int trace_graph_entry(struct ftrace_graph_ent *trace);
588
void set_graph_array(struct trace_array *tr);
589

590
591
void tracing_start_cmdline_record(void);
void tracing_stop_cmdline_record(void);
Steven Rostedt's avatar
Steven Rostedt committed
592
593
594
void tracing_sched_switch_assign_trace(struct trace_array *tr);
void tracing_stop_sched_switch_record(void);
void tracing_start_sched_switch_record(void);
595
int register_tracer(struct tracer *type);
596
int is_tracing_stopped(void);
597

598
599
loff_t tracing_lseek(struct file *file, loff_t offset, int whence);

600
601
602
603
extern cpumask_var_t __read_mostly tracing_buffer_mask;

#define for_each_tracing_cpu(cpu)	\
	for_each_cpu(cpu, tracing_buffer_mask)
604
605
606

extern unsigned long nsecs_to_usecs(unsigned long nsecs);

607
608
extern unsigned long tracing_thresh;

609
#ifdef CONFIG_TRACER_MAX_TRACE
610
611
612
613
614
extern unsigned long tracing_max_latency;

void update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu);
void update_max_tr_single(struct trace_array *tr,
			  struct task_struct *tsk, int cpu);
615
#endif /* CONFIG_TRACER_MAX_TRACE */
616

617
#ifdef CONFIG_STACKTRACE
618
void ftrace_trace_stack(struct ring_buffer *buffer, unsigned long flags,
619
620
			int skip, int pc);

621
622
623
void ftrace_trace_stack_regs(struct ring_buffer *buffer, unsigned long flags,
			     int skip, int pc, struct pt_regs *regs);

624
void ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags,
625
626
627
628
629
			    int pc);

void __trace_stack(struct trace_array *tr, unsigned long flags, int skip,
		   int pc);
#else
630
static inline void ftrace_trace_stack(struct ring_buffer *buffer,
631
632
633
634
				      unsigned long flags, int skip, int pc)
{
}

635
636
637
638
639
640
static inline void ftrace_trace_stack_regs(struct ring_buffer *buffer,
					   unsigned long flags, int skip,
					   int pc, struct pt_regs *regs)
{
}

641
static inline void ftrace_trace_userstack(struct ring_buffer *buffer,
642
643
644
645
646
647
648
649
650
					  unsigned long flags, int pc)
{
}

static inline void __trace_stack(struct trace_array *tr, unsigned long flags,
				 int skip, int pc)
{
}
#endif /* CONFIG_STACKTRACE */
651

Ingo Molnar's avatar
Ingo Molnar committed
652
extern cycle_t ftrace_now(int cpu);
653

654
extern void trace_find_cmdline(int pid, char comm[]);
655

656
657
#ifdef CONFIG_DYNAMIC_FTRACE
extern unsigned long ftrace_update_tot_cnt;
658
#endif
659
660
#define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func
extern int DYN_FTRACE_TEST_NAME(void);
661
662
#define DYN_FTRACE_TEST_NAME2 trace_selftest_dynamic_test_func2
extern int DYN_FTRACE_TEST_NAME2(void);
663

664
extern bool ring_buffer_expanded;
665
extern bool tracing_selftest_disabled;
666
DECLARE_PER_CPU(int, ftrace_cpu_disabled);
667

Steven Rostedt's avatar
Steven Rostedt committed
668
669
670
#ifdef CONFIG_FTRACE_STARTUP_TEST
extern int trace_selftest_startup_function(struct tracer *trace,
					   struct trace_array *tr);
671
672
extern int trace_selftest_startup_function_graph(struct tracer *trace,
						 struct trace_array *tr);
Steven Rostedt's avatar
Steven Rostedt committed
673
674
675
676
677
678
679
680
extern int trace_selftest_startup_irqsoff(struct tracer *trace,
					  struct trace_array *tr);
extern int trace_selftest_startup_preemptoff(struct tracer *trace,
					     struct trace_array *tr);
extern int trace_selftest_startup_preemptirqsoff(struct tracer *trace,
						 struct trace_array *tr);
extern int trace_selftest_startup_wakeup(struct tracer *trace,
					 struct trace_array *tr);
Steven Noonan's avatar
Steven Noonan committed
681
682
extern int trace_selftest_startup_nop(struct tracer *trace,
					 struct trace_array *tr);
Steven Rostedt's avatar
Steven Rostedt committed
683
684
extern int trace_selftest_startup_sched_switch(struct tracer *trace,
					       struct trace_array *tr);
685
686
extern int trace_selftest_startup_branch(struct tracer *trace,
					 struct trace_array *tr);
687
688
689
690
691
692
693
694
695
/*
 * Tracer data references selftest functions that only occur
 * on boot up. These can be __init functions. Thus, when selftests
 * are enabled, then the tracers need to reference __init functions.
 */
#define __tracer_data		__refdata
#else
/* Tracers are seldom changed. Optimize when selftests are disabled. */
#define __tracer_data		__read_mostly
Steven Rostedt's avatar
Steven Rostedt committed
696
697
#endif /* CONFIG_FTRACE_STARTUP_TEST */

Ingo Molnar's avatar
Ingo Molnar committed
698
extern void *head_page(struct trace_array_cpu *data);
699
extern unsigned long long ns2usecs(cycle_t nsec);
700
extern int
701
trace_vbprintk(unsigned long ip, const char *fmt, va_list args);
702
extern int
703
trace_vprintk(unsigned long ip, const char *fmt, va_list args);
704
705
706
707
708
extern int
trace_array_vprintk(struct trace_array *tr,
		    unsigned long ip, const char *fmt, va_list args);
int trace_array_printk(struct trace_array *tr,
		       unsigned long ip, const char *fmt, ...);
709
710
int trace_array_printk_buf(struct ring_buffer *buffer,
			   unsigned long ip, const char *fmt, ...);
711
712
void trace_printk_seq(struct trace_seq *s);
enum print_line_t print_trace_line(struct trace_iterator *iter);
Ingo Molnar's avatar
Ingo Molnar committed
713

714
715
extern unsigned long trace_flags;

716
/* Standard output formatting function used for function return traces */
717
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
718
719
720
721
722
723
724
725

/* Flag options */
#define TRACE_GRAPH_PRINT_OVERRUN       0x1
#define TRACE_GRAPH_PRINT_CPU           0x2
#define TRACE_GRAPH_PRINT_OVERHEAD      0x4
#define TRACE_GRAPH_PRINT_PROC          0x8
#define TRACE_GRAPH_PRINT_DURATION      0x10
#define TRACE_GRAPH_PRINT_ABS_TIME      0x20
726
727
#define TRACE_GRAPH_PRINT_FILL_SHIFT	28
#define TRACE_GRAPH_PRINT_FILL_MASK	(0x3 << TRACE_GRAPH_PRINT_FILL_SHIFT)
728

729
730
731
extern enum print_line_t
print_graph_function_flags(struct trace_iterator *iter, u32 flags);
extern void print_graph_headers_flags(struct seq_file *s, u32 flags);
732
733
extern enum print_line_t
trace_print_graph_duration(unsigned long long duration, struct trace_seq *s);
734
735
736
737
738
739
740
741
742
extern void graph_trace_open(struct trace_iterator *iter);
extern void graph_trace_close(struct trace_iterator *iter);
extern int __trace_graph_entry(struct trace_array *tr,
			       struct ftrace_graph_ent *trace,
			       unsigned long flags, int pc);
extern void __trace_graph_return(struct trace_array *tr,
				 struct ftrace_graph_ret *trace,
				 unsigned long flags, int pc);

743
744
745
746
747
748

#ifdef CONFIG_DYNAMIC_FTRACE
/* TODO: make this variable */
#define FTRACE_GRAPH_MAX_FUNCS		32
extern int ftrace_graph_count;
extern unsigned long ftrace_graph_funcs[FTRACE_GRAPH_MAX_FUNCS];
749
750
extern int ftrace_graph_notrace_count;
extern unsigned long ftrace_graph_notrace_funcs[FTRACE_GRAPH_MAX_FUNCS];
751
752
753
754
755

static inline int ftrace_graph_addr(unsigned long addr)
{
	int i;

756
	if (!ftrace_graph_count)
757
758
759
		return 1;

	for (i = 0; i < ftrace_graph_count; i++) {
760
761
762
763
764
765
766
767
768
769
		if (addr == ftrace_graph_funcs[i]) {
			/*
			 * If no irqs are to be traced, but a set_graph_function
			 * is set, and called by an interrupt handler, we still
			 * want to trace it.
			 */
			if (in_irq())
				trace_recursion_set(TRACE_IRQ_BIT);
			else
				trace_recursion_clear(TRACE_IRQ_BIT);
770
			return 1;
771
		}
772
773
774
775
	}

	return 0;
}
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790

static inline int ftrace_graph_notrace_addr(unsigned long addr)
{
	int i;

	if (!ftrace_graph_notrace_count)
		return 0;

	for (i = 0; i < ftrace_graph_notrace_count; i++) {
		if (addr == ftrace_graph_notrace_funcs[i])
			return 1;
	}

	return 0;
}
791
#else
792
793
794
static inline int ftrace_graph_addr(unsigned long addr)
{
	return 1;
795
}
796
797
798
799
800

static inline int ftrace_graph_notrace_addr(unsigned long addr)
{
	return 0;
}
801
802
#endif /* CONFIG_DYNAMIC_FTRACE */
#else /* CONFIG_FUNCTION_GRAPH_TRACER */
803
static inline enum print_line_t
804
print_graph_function_flags(struct trace_iterator *iter, u32 flags)
805
806
807
{
	return TRACE_TYPE_UNHANDLED;
}
808
#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
809

810
extern struct list_head ftrace_pids;
811

812
#ifdef CONFIG_FUNCTION_TRACER
813
extern bool ftrace_filter_param __initdata;
814
815
static inline int ftrace_trace_task(struct task_struct *task)
{
816
	if (list_empty(&ftrace_pids))
817
818
819
820
		return 1;

	return test_tsk_trace_trace(task);
}
821
extern int ftrace_is_dead(void);
822
823
824
int ftrace_create_function_files(struct trace_array *tr,
				 struct dentry *parent);
void ftrace_destroy_function_files(struct trace_array *tr);
825
826
827
828
829
#else
static inline int ftrace_trace_task(struct task_struct *task)
{
	return 1;
}
830
static inline int ftrace_is_dead(void) { return 0; }
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
static inline int
ftrace_create_function_files(struct trace_array *tr,
			     struct dentry *parent)
{
	return 0;
}
static inline void ftrace_destroy_function_files(struct trace_array *tr) { }
#endif /* CONFIG_FUNCTION_TRACER */

#if defined(CONFIG_FUNCTION_TRACER) && defined(CONFIG_DYNAMIC_FTRACE)
void ftrace_create_filter_files(struct ftrace_ops *ops,
				struct dentry *parent);
void ftrace_destroy_filter_files(struct ftrace_ops *ops);
#else
/*
 * The ops parameter passed in is usually undefined.
 * This must be a macro.
 */
#define ftrace_create_filter_files(ops, parent) do { } while (0)
#define ftrace_destroy_filter_files(ops) do { } while (0)
#endif /* CONFIG_FUNCTION_TRACER && CONFIG_DYNAMIC_FTRACE */
852

853
854
int ftrace_event_is_function(struct ftrace_event_call *call);

855
856
857
858
/*
 * struct trace_parser - servers for reading the user input separated by spaces
 * @cont: set if the input is not complete - no final space char was found
 * @buffer: holds the parsed user input
859
 * @idx: user input length
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
 * @size: buffer size
 */
struct trace_parser {
	bool		cont;
	char		*buffer;
	unsigned	idx;
	unsigned	size;
};

static inline bool trace_parser_loaded(struct trace_parser *parser)
{
	return (parser->idx != 0);
}

static inline bool trace_parser_cont(struct trace_parser *parser)
{
	return parser->cont;
}

static inline void trace_parser_clear(struct trace_parser *parser)
{
	parser->cont = false;
	parser->idx = 0;
}

extern int trace_parser_get_init(struct trace_parser *parser, int size);
extern void trace_parser_put(struct trace_parser *parser);
extern int trace_get_user(struct trace_parser *parser, const char __user *ubuf,
	size_t cnt, loff_t *ppos);

Steven Rostedt's avatar
Steven Rostedt committed
890
891
892
893
894
895
896
/*
 * trace_iterator_flags is an enumeration that defines bit
 * positions into trace_flags that controls the output.
 *
 * NOTE: These bits must match the trace_options array in
 *       trace.c.
 */
897
898
899
900
901
902
903
904
905
906
enum trace_iterator_flags {
	TRACE_ITER_PRINT_PARENT		= 0x01,
	TRACE_ITER_SYM_OFFSET		= 0x02,
	TRACE_ITER_SYM_ADDR		= 0x04,
	TRACE_ITER_VERBOSE		= 0x08,
	TRACE_ITER_RAW			= 0x10,
	TRACE_ITER_HEX			= 0x20,
	TRACE_ITER_BIN			= 0x40,
	TRACE_ITER_BLOCK		= 0x80,
	TRACE_ITER_STACKTRACE		= 0x100,
907
908
909
910
911
912
913
914
915
916
917
	TRACE_ITER_PRINTK		= 0x200,
	TRACE_ITER_PREEMPTONLY		= 0x400,
	TRACE_ITER_BRANCH		= 0x800,
	TRACE_ITER_ANNOTATE		= 0x1000,
	TRACE_ITER_USERSTACKTRACE       = 0x2000,
	TRACE_ITER_SYM_USEROBJ          = 0x4000,
	TRACE_ITER_PRINTK_MSGONLY	= 0x8000,
	TRACE_ITER_CONTEXT_INFO		= 0x10000, /* Print pid/cpu/time */
	TRACE_ITER_LATENCY_FMT		= 0x20000,
	TRACE_ITER_SLEEP_TIME		= 0x40000,
	TRACE_ITER_GRAPH_TIME		= 0x80000,
918
	TRACE_ITER_RECORD_CMD		= 0x100000,
919
	TRACE_ITER_OVERWRITE		= 0x200000,
920
	TRACE_ITER_STOP_ON_FREE		= 0x400000,
921
	TRACE_ITER_IRQ_INFO		= 0x800000,
922
	TRACE_ITER_MARKERS		= 0x1000000,
923
	TRACE_ITER_FUNCTION		= 0x2000000,
924
925
};

926
927
928
929
930
931
932
/*
 * TRACE_ITER_SYM_MASK masks the options in trace_flags that
 * control the output of kernel symbols.
 */
#define TRACE_ITER_SYM_MASK \
	(TRACE_ITER_PRINT_PARENT|TRACE_ITER_SYM_OFFSET|TRACE_ITER_SYM_ADDR)

933
934
extern struct tracer nop_trace;

935
#ifdef CONFIG_BRANCH_TRACER
936
937
938
extern int enable_branch_tracing(struct trace_array *tr);
extern void disable_branch_tracing(void);
static inline int trace_branch_enable(struct trace_array *tr)
939
{
940
941
	if (trace_flags & TRACE_ITER_BRANCH)
		return enable_branch_tracing(tr);
942
943
	return 0;
}
944
static inline void trace_branch_disable(void)
945
946
{
	/* due to races, always disable */
947
	disable_branch_tracing();
948
949
}
#else
950
static inline int trace_branch_enable(struct trace_array *tr)
951
952
953
{
	return 0;
}
954
static inline void trace_branch_disable(void)
955
956
{
}
957
#endif /* CONFIG_BRANCH_TRACER */
958

959
960
961
/* set ring buffers to default size if not already done so */
int tracing_update_buffers(void);

962
963
struct ftrace_event_field {
	struct list_head	link;
964
965
	const char		*name;
	const char		*type;
966
	int			filter_type;
967
968
	int			offset;
	int			size;
969
	int			is_signed;
970
971
};

972
struct event_filter {
973
974
	int			n_preds;	/* Number assigned */
	int			a_preds;	/* allocated */
975
	struct filter_pred	*preds;
976
	struct filter_pred	*root;
977
	char			*filter_string;
978
979
};

980
981
982
struct event_subsystem {
	struct list_head	list;
	const char		*name;
983
	struct event_filter	*filter;
984
	int			ref_count;
985
986
};

987
988
989
990
991
992
993
994
995
struct ftrace_subsystem_dir {
	struct list_head		list;
	struct event_subsystem		*subsystem;
	struct trace_array		*tr;
	struct dentry			*entry;
	int				ref_count;
	int				nr_events;
};

996
997
#define FILTER_PRED_INVALID	((unsigned short)-1)
#define FILTER_PRED_IS_RIGHT	(1 << 15)
998
#define FILTER_PRED_FOLD	(1 << 15)
999

1000
1001
1002
1003
1004
1005
1006
1007
/*
 * The max preds is the size of unsigned short with
 * two flags at the MSBs. One bit is used for both the IS_RIGHT
 * and FOLD flags. The other is reserved.
 *
 * 2^14 preds is way more than enough.
 */
#define MAX_FILTER_PRED		16384
1008

Tom Zanussi's avatar
Tom Zanussi committed
1009
struct filter_pred;
1010
struct regex;
Tom Zanussi's avatar
Tom Zanussi committed
1011

1012
typedef int (*filter_pred_fn_t) (struct filter_pred *pred, void *event);
Tom Zanussi's avatar
Tom Zanussi committed
1013

1014
1015
typedef int (*regex_match_func)(char *str, struct regex *r, int len);

1016
enum regex_type {
1017
	MATCH_FULL = 0,
1018
1019
1020
1021
1022
	MATCH_FRONT_ONLY,
	MATCH_MIDDLE_ONLY,
	MATCH_END_ONLY,
};

1023
1024
1025
1026
1027
1028
1029
struct regex {
	char			pattern[MAX_FILTER_STR_VAL];
	int			len;
	int			field_len;
	regex_match_func	match;
};

Tom Zanussi's avatar
Tom Zanussi committed
1030
struct filter_pred {
1031
1032
1033
	filter_pred_fn_t 	fn;
	u64 			val;
	struct regex		regex;
1034
	unsigned short		*ops;
1035
	struct ftrace_event_field *field;
1036
1037
1038
	int 			offset;
	int 			not;
	int 			op;
1039
1040
1041
1042
	unsigned short		index;
	unsigned short		parent;
	unsigned short		left;
	unsigned short		right;
Tom Zanussi's avatar
Tom Zanussi committed
1043
1044
};

1045
1046
extern enum regex_type
filter_parse_regex(char *buff, int len, char **search, int *not);
1047
extern void print_event_filter(struct ftrace_event_file *file,
1048
			       struct trace_seq *s);
1049
extern int apply_event_filter(struct ftrace_event_file *file,
1050
			      char *filter_string);
1051
extern int apply_subsystem_event_filter(struct ftrace_subsystem_dir *dir,
1052
1053
					char *filter_string);
extern void print_subsystem_event_filter(struct event_subsystem *system,
1054
					 struct trace_seq *s);
1055
extern int filter_assign_type(const char *type);
1056
1057
1058
1059
extern int create_event_filter(struct ftrace_event_call *call,
			       char *filter_str, bool set_str,
			       struct event_filter **filterp);
extern void free_event_filter(struct event_filter *filter);
Tom Zanussi's avatar
Tom Zanussi committed
1060

1061
1062
struct ftrace_event_field *
trace_find_event_field(struct ftrace_event_call *call, char *name);
1063

1064
extern void trace_event_enable_cmd_record(bool enable);
1065
extern int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr);
1066
extern int event_trace_del_tracer(struct trace_array *tr);
1067

1068
1069
1070
1071
extern struct ftrace_event_file *find_event_file(struct trace_array *tr,
						 const char *system,
						 const char *event);

1072
1073
1074
1075
1076
static inline void *event_file_data(struct file *filp)
{
	return ACCESS_ONCE(file_inode(filp)->i_private);
}

1077
extern struct mutex event_mutex;
1078
extern struct list_head ftrace_events;
Peter Zijlstra's avatar
Peter Zijlstra committed
1079

1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
extern const struct file_operations event_trigger_fops;

extern int register_trigger_cmds(void);
extern void clear_event_triggers(struct trace_array *tr);

struct event_trigger_data {
	unsigned long			count;
	int				ref;
	struct event_trigger_ops	*ops;
	struct event_command		*cmd_ops;
1090
	struct event_filter __rcu	*filter;
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
	char				*filter_str;
	void				*private_data;
	struct list_head		list;
};

/**
 * struct event_trigger_ops - callbacks for trace event triggers
 *
 * The methods in this structure provide per-event trigger hooks for
 * various trigger operations.
 *
 * All the methods below, except for @init() and @free(), must be
 * implemented.
 *
 * @func: The trigger 'probe' function called when the triggering
 *	event occurs.  The data passed into this callback is the data
 *	that was supplied to the event_command @reg() function that
 *	registered the trigger (see struct event_command).
 *
 * @init: An optional initialization function called for the trigger
 *	when the trigger is registered (via the event_command reg()
 *	function).  This can be used to perform per-trigger
 *	initialization such as incrementing a per-trigger reference
 *	count, for instance.  This is usually implemented by the
 *	generic utility function @event_trigger_init() (see
 *	trace_event_triggers.c).
 *
 * @free: An optional de-initialization function called for the
 *	trigger when the trigger is unregistered (via the
 *	event_command @reg() function).  This can be used to perform
 *	per-trigger de-initialization such as decrementing a
 *	per-trigger reference count and freeing corresponding trigger
 *	data, for instance.  This is usually implemented by the
 *	generic utility function @event_trigger_free() (see
 *	trace_event_triggers.c).
 *
 * @print: The callback function invoked to have the trigger print
 *	itself.  This is usually implemented by a wrapper function
 *	that calls the generic utility function @event_trigger_print()
 *	(see trace_event_triggers.c).
 */
struct event_trigger_ops {
	void			(*func)(struct event_trigger_data *data);
	int			(*init)(struct event_trigger_ops *ops,
					struct event_trigger_data *data);
	void			(*free)(struct event_trigger_ops *ops,
					struct event_trigger_data *data);
	int			(*print)(struct seq_file *m,
					 struct event_trigger_ops *ops,
					 struct event_trigger_data *data);
};

/**
 * struct event_command - callbacks and data members for event commands
 *
 * Event commands are invoked by users by writing the command name
 * into the 'trigger' file associated with a trace event.  The
 * parameters associated with a specific invocation of an event
 * command are used to create an event trigger instance, which is
 * added to the list of trigger instances associated with that trace
 * event.  When the event is hit, the set of triggers associated with
 * that event is invoked.
 *
 * The data members in this structure provide per-event command data
 * for various event commands.
 *
 * All the data members below, except for @post_trigger, must be set
 * for each event command.
 *
 * @name: The unique name that identifies the event command.  This is
 *	the name used when setting triggers via trigger files.
 *
 * @trigger_type: A unique id that identifies the event command
 *	'type'.  This value has two purposes, the first to ensure that
 *	only one trigger of the same type can be set at a given time
 *	for a particular event e.g. it doesn't make sense to have both
 *	a traceon and traceoff trigger attached to a single event at
 *	the same time, so traceon and traceoff have the same type
 *	though they have different names.  The @trigger_type value is
 *	also used as a bit value for deferring the actual trigger
 *	action until after the current event is finished.  Some
 *	commands need to do this if they themselves log to the trace
 *	buffer (see the @post_trigger() member below).  @trigger_type
 *	values are defined by adding new values to the trigger_type
 *	enum in include/linux/ftrace_event.h.
 *
 * @post_trigger: A flag that says whether or not this command needs
 *	to have its action delayed until after the current event has
 *	been closed.  Some triggers need to avoid being invoked while
 *	an event is currently in the process of being logged, since
 *	the trigger may itself log data into the trace buffer.  Thus
 *	we make sure the current event is committed before invoking
 *	those triggers.  To do that, the trigger invocation is split
 *	in two - the first part checks the filter using the current
 *	trace record; if a command has the @post_trigger flag set, it
 *	sets a bit for itself in the return value, otherwise it
 *	directly invokes the trigger.  Once all commands have been
 *	either invoked or set their return flag, the current record is
 *	either committed or discarded.  At that point, if any commands
 *	have deferred their triggers, those commands are finally
 *	invoked following the close of the current event.  In other
 *	words, if the event_trigger_ops @func() probe implementation
 *	itself logs to the trace buffer, this flag should be set,
 *	otherwise it can be left unspecified.
 *
 * All the methods below, except for @set_filter(), must be
 * implemented.
 *
 * @func: The callback function responsible for parsing and
 *	registering the trigger written to the 'trigger' file by the
 *	user.  It allocates the trigger instance and registers it with
 *	the appropriate trace event.  It makes use of the other
 *	event_command callback functions to orchestrate this, and is
 *	usually implemented by the generic utility function
 *	@event_trigger_callback() (see trace_event_triggers.c).
 *
 * @reg: Adds the trigger to the list of triggers associated with the
 *	event, and enables the event trigger itself, after
 *	initializing it (via the event_trigger_ops @init() function).
 *	This is also where commands can use the @trigger_type value to
 *	make the decision as to whether or not multiple instances of
 *	the trigger should be allowed.  This is usually implemented by
 *	the generic utility function @register_trigger() (see
 *	trace_event_triggers.c).
 *
 * @unreg: Removes the trigger from the list of triggers associated
 *	with the event, and disables the event trigger itself, after
 *	initializing it (via the event_trigger_ops @free() function).
 *	This is usually implemented by the generic utility function
 *	@unregister_trigger() (see trace_event_triggers.c).
 *
 * @set_filter: An optional function called to parse and set a filter
 *	for the trigger.  If no @set_filter() method is set for the
 *	event command, filters set by the user for the command will be
 *	ignored.  This is usually implemented by the generic utility
 *	function @set_trigger_filter() (see trace_event_triggers.c).
 *
 * @get_trigger_ops: The callback function invoked to retrieve the
 *	event_trigger_ops implementation associated with the command.
 */
struct event_command {
	struct list_head	list;
	char			*name;
	enum event_trigger_type	trigger_type;
	bool			post_trigger;
	int			(*func)(struct event_command *cmd_ops,
					struct ftrace_event_file *file,
					char *glob, char *cmd, char *params);
	int			(*reg)(char *glob,
				       struct event_trigger_ops *ops,
				       struct event_trigger_data *data,
				       struct ftrace_event_file *file);
	void			(*unreg)(char *glob,
					 struct event_trigger_ops *ops,
					 struct event_trigger_data *data,
					 struct ftrace_event_file *file);
	int			(*set_filter)(char *filter_str,
					      struct event_trigger_data *data,
					      struct ftrace_event_file *file);
	struct event_trigger_ops *(*get_trigger_ops)(char *cmd, char *param);
};

extern int trace_event_enable_disable(struct ftrace_event_file *file,
				      int enable, int soft_disable);
1255
extern int tracing_alloc_snapshot(void);
1256

1257
1258
1259
extern const char *__start___trace_bprintk_fmt[];
extern const char *__stop___trace_bprintk_fmt[];

1260
1261
1262
extern const char *__start___tracepoint_str[];
extern const char *__stop___tracepoint_str[];

1263
void trace_printk_init_buffers(void);
1264
void trace_printk_start_comm(void);
1265
int trace_keep_overwrite(struct tracer *tracer, u32 mask, int set);
1266
int set_tracer_flag(struct trace_array *tr, unsigned int mask, int enabled);
1267