trace.h 22.6 KB
Newer Older
1 2 3 4 5 6 7
#ifndef _LINUX_KERNEL_TRACE_H
#define _LINUX_KERNEL_TRACE_H

#include <linux/fs.h>
#include <asm/atomic.h>
#include <linux/sched.h>
#include <linux/clocksource.h>
8
#include <linux/ring_buffer.h>
P
Pekka Paalanen 已提交
9
#include <linux/mmiotrace.h>
10
#include <linux/tracepoint.h>
11
#include <linux/ftrace.h>
12
#include <trace/boot.h>
13
#include <linux/kmemtrace.h>
14
#include <linux/hw_breakpoint.h>
15

16
#include <linux/trace_seq.h>
17
#include <linux/ftrace_event.h>
18

19 20 21 22 23 24 25
enum trace_type {
	__TRACE_FIRST_TYPE = 0,

	TRACE_FN,
	TRACE_CTX,
	TRACE_WAKE,
	TRACE_STACK,
26
	TRACE_PRINT,
27
	TRACE_BPRINT,
28
	TRACE_SPECIAL,
P
Pekka Paalanen 已提交
29 30
	TRACE_MMIO_RW,
	TRACE_MMIO_MAP,
31
	TRACE_BRANCH,
32 33
	TRACE_BOOT_CALL,
	TRACE_BOOT_RET,
34 35
	TRACE_GRAPH_RET,
	TRACE_GRAPH_ENT,
36
	TRACE_USER_STACK,
37
	TRACE_HW_BRANCHES,
38 39
	TRACE_KMEM_ALLOC,
	TRACE_KMEM_FREE,
40
	TRACE_BLK,
41
	TRACE_KSYM,
42

43
	__TRACE_LAST_TYPE,
44 45
};

46 47 48 49
enum kmemtrace_type_id {
	KMEMTRACE_TYPE_KMALLOC = 0,	/* kmalloc() or kfree(). */
	KMEMTRACE_TYPE_CACHE,		/* kmem_cache_*(). */
	KMEMTRACE_TYPE_PAGES,		/* __get_free_pages() and friends. */
50 51
};

52
extern struct tracer boot_tracer;
53

54 55
#undef __field
#define __field(type, item)		type	item;
I
Ingo Molnar 已提交
56

57 58
#undef __field_struct
#define __field_struct(type, item)	__field(type, item)
I
Ingo Molnar 已提交
59

60 61
#undef __field_desc
#define __field_desc(type, container, item)
62

63 64
#undef __array
#define __array(type, item, size)	type	item[size];
65

66 67
#undef __array_desc
#define __array_desc(type, container, item, size)
68

69 70
#undef __dynamic_array
#define __dynamic_array(type, item)	type	item[];
71

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

75 76 77 78 79 80
#undef FTRACE_ENTRY
#define FTRACE_ENTRY(name, struct_name, id, tstruct, print)	\
	struct struct_name {					\
		struct trace_entry	ent;			\
		tstruct						\
	}
81

82 83
#undef TP_ARGS
#define TP_ARGS(args...)	args
84

85 86
#undef FTRACE_ENTRY_DUP
#define FTRACE_ENTRY_DUP(name, name_struct, id, tstruct, printk)
87

88
#include "trace_entries.h"
89

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

struct syscall_trace_exit {
	struct trace_entry	ent;
	int			nr;
103
	long			ret;
104 105
};

106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
struct kprobe_trace_entry {
	struct trace_entry	ent;
	unsigned long		ip;
	int			nargs;
	unsigned long		args[];
};

#define SIZEOF_KPROBE_TRACE_ENTRY(n)			\
	(offsetof(struct kprobe_trace_entry, args) +	\
	(sizeof(unsigned long) * (n)))

struct kretprobe_trace_entry {
	struct trace_entry	ent;
	unsigned long		func;
	unsigned long		ret_ip;
	int			nargs;
	unsigned long		args[];
};

#define SIZEOF_KRETPROBE_TRACE_ENTRY(n)			\
	(offsetof(struct kretprobe_trace_entry, args) +	\
	(sizeof(unsigned long) * (n)))

129 130 131
/*
 * trace_flag_type is an enumeration that holds different
 * states when a trace occurs. These are:
132
 *  IRQS_OFF		- interrupts were disabled
I
Ingo Molnar 已提交
133
 *  IRQS_NOSUPPORT	- arch does not support irqs_disabled_flags
L
Li Zefan 已提交
134
 *  NEED_RESCHED	- reschedule is requested
135 136
 *  HARDIRQ		- inside an interrupt handler
 *  SOFTIRQ		- inside a softirq handler
137 138 139
 */
enum trace_flag_type {
	TRACE_FLAG_IRQS_OFF		= 0x01,
140 141 142 143
	TRACE_FLAG_IRQS_NOSUPPORT	= 0x02,
	TRACE_FLAG_NEED_RESCHED		= 0x04,
	TRACE_FLAG_HARDIRQ		= 0x08,
	TRACE_FLAG_SOFTIRQ		= 0x10,
144 145
};

146
#define TRACE_BUF_SIZE		1024
147 148 149 150 151 152 153 154

/*
 * 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;
155
	void			*buffer_page;	/* ring buffer spare */
I
Ingo Molnar 已提交
156

157 158 159 160 161 162 163
	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;
164
	unsigned long		skipped_entries;
165 166 167 168 169 170 171 172 173 174 175 176
	cycle_t			preempt_timestamp;
	pid_t			pid;
	uid_t			uid;
	char			comm[TASK_COMM_LEN];
};

/*
 * 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 {
177
	struct ring_buffer	*buffer;
178 179 180
	unsigned long		entries;
	int			cpu;
	cycle_t			time_start;
181
	struct task_struct	*waiter;
182 183 184
	struct trace_array_cpu	*data[NR_CPUS];
};

S
Steven Rostedt 已提交
185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
#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);	\
217
		IF_ASSIGN(var, ent, struct userstack_entry, TRACE_USER_STACK);\
S
Steven Rostedt 已提交
218
		IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT);	\
219
		IF_ASSIGN(var, ent, struct bprint_entry, TRACE_BPRINT);	\
S
Steven Rostedt 已提交
220 221 222 223 224
		IF_ASSIGN(var, ent, struct special_entry, 0);		\
		IF_ASSIGN(var, ent, struct trace_mmiotrace_rw,		\
			  TRACE_MMIO_RW);				\
		IF_ASSIGN(var, ent, struct trace_mmiotrace_map,		\
			  TRACE_MMIO_MAP);				\
225 226
		IF_ASSIGN(var, ent, struct trace_boot_call, TRACE_BOOT_CALL);\
		IF_ASSIGN(var, ent, struct trace_boot_ret, TRACE_BOOT_RET);\
227
		IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \
228 229 230 231
		IF_ASSIGN(var, ent, struct ftrace_graph_ent_entry,	\
			  TRACE_GRAPH_ENT);		\
		IF_ASSIGN(var, ent, struct ftrace_graph_ret_entry,	\
			  TRACE_GRAPH_RET);		\
232
		IF_ASSIGN(var, ent, struct hw_branch_entry, TRACE_HW_BRANCHES);\
233 234 235 236
		IF_ASSIGN(var, ent, struct kmemtrace_alloc_entry,	\
			  TRACE_KMEM_ALLOC);	\
		IF_ASSIGN(var, ent, struct kmemtrace_free_entry,	\
			  TRACE_KMEM_FREE);	\
237
		IF_ASSIGN(var, ent, struct ksym_trace_entry, TRACE_KSYM);\
S
Steven Rostedt 已提交
238 239
		__ftrace_bad_type();					\
	} while (0)
240

241 242 243 244 245 246
/*
 * 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 {
I
Ingo Molnar 已提交
247 248
	const char	*name; /* Will appear on the trace_options file */
	u32		bit; /* Mask assigned in val field in tracer_flags */
249 250 251 252 253 254 255 256
};

/*
 * 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;
I
Ingo Molnar 已提交
257
	struct tracer_opt	*opts;
258 259 260 261 262
};

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

263

264 265 266 267 268 269 270 271 272 273 274
/**
 * 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
S
Steven Rostedt 已提交
275
 * @pipe_close: called when the trace_pipe file is released
276 277 278 279 280 281 282
 * @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
283 284 285
 */
struct tracer {
	const char		*name;
286
	int			(*init)(struct trace_array *tr);
287
	void			(*reset)(struct trace_array *tr);
288 289
	void			(*start)(struct trace_array *tr);
	void			(*stop)(struct trace_array *tr);
290
	void			(*open)(struct trace_iterator *iter);
291
	void			(*pipe_open)(struct trace_iterator *iter);
292
	void			(*wait_pipe)(struct trace_iterator *iter);
293
	void			(*close)(struct trace_iterator *iter);
S
Steven Rostedt 已提交
294
	void			(*pipe_close)(struct trace_iterator *iter);
295 296 297
	ssize_t			(*read)(struct trace_iterator *iter,
					struct file *filp, char __user *ubuf,
					size_t cnt, loff_t *ppos);
298 299 300 301 302 303
	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);
S
Steven Rostedt 已提交
304 305 306 307
#ifdef CONFIG_FTRACE_STARTUP_TEST
	int			(*selftest)(struct tracer *trace,
					    struct trace_array *tr);
#endif
308
	void			(*print_header)(struct seq_file *m);
309
	enum print_line_t	(*print_line)(struct trace_iterator *iter);
310 311
	/* If you handled the flag setting, return 0 */
	int			(*set_flag)(u32 old_flags, u32 bit, int set);
312 313
	struct tracer		*next;
	int			print_max;
I
Ingo Molnar 已提交
314
	struct tracer_flags	*flags;
315 316
};

317

318 319
#define TRACE_PIPE_ALL_CPU	-1

320
int tracer_init(struct tracer *t, struct trace_array *tr);
321
int tracing_is_enabled(void);
322
void trace_wake_up(void);
323
void tracing_reset(struct trace_array *tr, int cpu);
324
void tracing_reset_online_cpus(struct trace_array *tr);
325 326
void tracing_reset_current(int cpu);
void tracing_reset_current_online_cpus(void);
327
int tracing_open_generic(struct inode *inode, struct file *filp);
328 329 330 331 332 333
struct dentry *trace_create_file(const char *name,
				 mode_t mode,
				 struct dentry *parent,
				 void *data,
				 const struct file_operations *fops);

334
struct dentry *tracing_init_dentry(void);
I
Ingo Molnar 已提交
335 336
void init_tracer_sysprof_debugfs(struct dentry *d_tracer);

337 338
struct ring_buffer_event;

339 340 341 342 343 344 345
struct ring_buffer_event *
trace_buffer_lock_reserve(struct ring_buffer *buffer,
			  int type,
			  unsigned long len,
			  unsigned long flags,
			  int pc);
void trace_buffer_unlock_commit(struct ring_buffer *buffer,
346 347 348
				struct ring_buffer_event *event,
				unsigned long flags, int pc);

349 350
struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
						struct trace_array_cpu *data);
351 352 353 354

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

355 356 357
void default_wait_pipe(struct trace_iterator *iter);
void poll_wait_pipe(struct trace_iterator *iter);

358 359 360 361
void ftrace(struct trace_array *tr,
			    struct trace_array_cpu *data,
			    unsigned long ip,
			    unsigned long parent_ip,
362
			    unsigned long flags, int pc);
363 364 365
void tracing_sched_switch_trace(struct trace_array *tr,
				struct task_struct *prev,
				struct task_struct *next,
366
				unsigned long flags, int pc);
367 368 369 370

void tracing_sched_wakeup_trace(struct trace_array *tr,
				struct task_struct *wakee,
				struct task_struct *cur,
371
				unsigned long flags, int pc);
I
Ingo Molnar 已提交
372 373 374 375
void trace_special(struct trace_array *tr,
		   struct trace_array_cpu *data,
		   unsigned long arg1,
		   unsigned long arg2,
376
		   unsigned long arg3, int pc);
377 378 379
void trace_function(struct trace_array *tr,
		    unsigned long ip,
		    unsigned long parent_ip,
380
		    unsigned long flags, int pc);
381

382
void trace_graph_return(struct ftrace_graph_ret *trace);
383
int trace_graph_entry(struct ftrace_graph_ent *trace);
384
void set_graph_array(struct trace_array *tr);
385

386 387
void tracing_start_cmdline_record(void);
void tracing_stop_cmdline_record(void);
S
Steven Rostedt 已提交
388 389 390
void tracing_sched_switch_assign_trace(struct trace_array *tr);
void tracing_stop_sched_switch_record(void);
void tracing_start_sched_switch_record(void);
391 392
int register_tracer(struct tracer *type);
void unregister_tracer(struct tracer *type);
393
int is_tracing_stopped(void);
394

395
extern int process_new_ksym_entry(char *ksymname, int op, unsigned long addr);
396 397 398

extern unsigned long nsecs_to_usecs(unsigned long nsecs);

399
#ifdef CONFIG_TRACER_MAX_TRACE
400 401 402 403 404 405
extern unsigned long tracing_max_latency;
extern unsigned long tracing_thresh;

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);
406
#endif /* CONFIG_TRACER_MAX_TRACE */
407

408
#ifdef CONFIG_STACKTRACE
409
void ftrace_trace_stack(struct ring_buffer *buffer, unsigned long flags,
410 411
			int skip, int pc);

412
void ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags,
413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
			    int pc);

void __trace_stack(struct trace_array *tr, unsigned long flags, int skip,
		   int pc);
#else
static inline void ftrace_trace_stack(struct trace_array *tr,
				      unsigned long flags, int skip, int pc)
{
}

static inline void ftrace_trace_userstack(struct trace_array *tr,
					  unsigned long flags, int pc)
{
}

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

I
Ingo Molnar 已提交
434
extern cycle_t ftrace_now(int cpu);
435

436
extern void trace_find_cmdline(int pid, char comm[]);
437

438 439
#ifdef CONFIG_DYNAMIC_FTRACE
extern unsigned long ftrace_update_tot_cnt;
440 441
#define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func
extern int DYN_FTRACE_TEST_NAME(void);
442 443
#endif

444 445
extern int ring_buffer_expanded;
extern bool tracing_selftest_disabled;
446
DECLARE_PER_CPU(int, ftrace_cpu_disabled);
447

S
Steven Rostedt 已提交
448 449 450
#ifdef CONFIG_FTRACE_STARTUP_TEST
extern int trace_selftest_startup_function(struct tracer *trace,
					   struct trace_array *tr);
451 452
extern int trace_selftest_startup_function_graph(struct tracer *trace,
						 struct trace_array *tr);
S
Steven Rostedt 已提交
453 454 455 456 457 458 459 460
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);
S
Steven Noonan 已提交
461 462
extern int trace_selftest_startup_nop(struct tracer *trace,
					 struct trace_array *tr);
S
Steven Rostedt 已提交
463 464
extern int trace_selftest_startup_sched_switch(struct tracer *trace,
					       struct trace_array *tr);
465 466
extern int trace_selftest_startup_sysprof(struct tracer *trace,
					       struct trace_array *tr);
S
Steven Rostedt 已提交
467 468
extern int trace_selftest_startup_branch(struct tracer *trace,
					 struct trace_array *tr);
469 470
extern int trace_selftest_startup_hw_branches(struct tracer *trace,
					      struct trace_array *tr);
471 472
extern int trace_selftest_startup_ksym(struct tracer *trace,
					 struct trace_array *tr);
S
Steven Rostedt 已提交
473 474
#endif /* CONFIG_FTRACE_STARTUP_TEST */

I
Ingo Molnar 已提交
475
extern void *head_page(struct trace_array_cpu *data);
476
extern unsigned long long ns2usecs(cycle_t nsec);
477
extern int
478
trace_vbprintk(unsigned long ip, const char *fmt, va_list args);
479
extern int
480
trace_vprintk(unsigned long ip, const char *fmt, va_list args);
481 482 483 484 485
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, ...);
I
Ingo Molnar 已提交
486

487 488
extern unsigned long trace_flags;

489 490
extern int trace_clock_id;

491
/* Standard output formatting function used for function return traces */
492 493
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
extern enum print_line_t print_graph_function(struct trace_iterator *iter);
494 495
extern enum print_line_t
trace_print_graph_duration(unsigned long long duration, struct trace_seq *s);
496 497 498 499

#ifdef CONFIG_DYNAMIC_FTRACE
/* TODO: make this variable */
#define FTRACE_GRAPH_MAX_FUNCS		32
500
extern int ftrace_graph_filter_enabled;
501 502 503 504 505 506 507
extern int ftrace_graph_count;
extern unsigned long ftrace_graph_funcs[FTRACE_GRAPH_MAX_FUNCS];

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

508
	if (!ftrace_graph_filter_enabled)
509 510 511 512 513 514 515 516 517
		return 1;

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

	return 0;
}
518
#else
519 520 521
static inline int ftrace_graph_addr(unsigned long addr)
{
	return 1;
522 523 524
}
#endif /* CONFIG_DYNAMIC_FTRACE */
#else /* CONFIG_FUNCTION_GRAPH_TRACER */
525
static inline enum print_line_t
526
print_graph_function(struct trace_iterator *iter)
527 528 529
{
	return TRACE_TYPE_UNHANDLED;
}
530
#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
531

532
extern struct list_head ftrace_pids;
533

534
#ifdef CONFIG_FUNCTION_TRACER
535 536
static inline int ftrace_trace_task(struct task_struct *task)
{
537
	if (list_empty(&ftrace_pids))
538 539 540 541
		return 1;

	return test_tsk_trace_trace(task);
}
542 543 544 545 546 547
#else
static inline int ftrace_trace_task(struct task_struct *task)
{
	return 1;
}
#endif
548

549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583
/*
 * 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
 * @idx: user input lenght
 * @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);

S
Steven Rostedt 已提交
584 585 586 587 588 589 590
/*
 * 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.
 */
591 592 593 594 595 596 597 598 599 600
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,
L
Li Zefan 已提交
601 602 603 604 605 606 607 608 609 610 611
	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,
612 613
};

614 615 616 617 618 619 620
/*
 * 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)

621 622
extern struct tracer nop_trace;

623 624 625 626 627 628 629 630 631
/**
 * ftrace_preempt_disable - disable preemption scheduler safe
 *
 * When tracing can happen inside the scheduler, there exists
 * cases that the tracing might happen before the need_resched
 * flag is checked. If this happens and the tracer calls
 * preempt_enable (after a disable), a schedule might take place
 * causing an infinite recursion.
 *
632
 * To prevent this, we read the need_resched flag before
633 634 635 636
 * disabling preemption. When we want to enable preemption we
 * check the flag, if it is set, then we call preempt_enable_no_resched.
 * Otherwise, we call preempt_enable.
 *
637
 * The rational for doing the above is that if need_resched is set
638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657
 * and we have yet to reschedule, we are either in an atomic location
 * (where we do not need to check for scheduling) or we are inside
 * the scheduler and do not want to resched.
 */
static inline int ftrace_preempt_disable(void)
{
	int resched;

	resched = need_resched();
	preempt_disable_notrace();

	return resched;
}

/**
 * ftrace_preempt_enable - enable preemption scheduler safe
 * @resched: the return value from ftrace_preempt_disable
 *
 * This is a scheduler safe way to enable preemption and not miss
 * any preemption checks. The disabled saved the state of preemption.
658
 * If resched is set, then we are either inside an atomic or
659 660 661 662 663 664 665 666 667 668 669 670
 * are inside the scheduler (we would have already scheduled
 * otherwise). In this case, we do not want to call normal
 * preempt_enable, but preempt_enable_no_resched instead.
 */
static inline void ftrace_preempt_enable(int resched)
{
	if (resched)
		preempt_enable_no_resched_notrace();
	else
		preempt_enable_notrace();
}

671
#ifdef CONFIG_BRANCH_TRACER
672 673 674
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)
675
{
676 677
	if (trace_flags & TRACE_ITER_BRANCH)
		return enable_branch_tracing(tr);
678 679
	return 0;
}
680
static inline void trace_branch_disable(void)
681 682
{
	/* due to races, always disable */
683
	disable_branch_tracing();
684 685
}
#else
686
static inline int trace_branch_enable(struct trace_array *tr)
687 688 689
{
	return 0;
}
690
static inline void trace_branch_disable(void)
691 692
{
}
693
#endif /* CONFIG_BRANCH_TRACER */
694

695 696 697
/* set ring buffers to default size if not already done so */
int tracing_update_buffers(void);

698 699 700 701 702 703
/* trace event type bit fields, not numeric */
enum {
	TRACE_EVENT_TYPE_PRINTF		= 1,
	TRACE_EVENT_TYPE_RAW		= 2,
};

704 705 706 707
struct ftrace_event_field {
	struct list_head	link;
	char			*name;
	char			*type;
708
	int			filter_type;
709 710
	int			offset;
	int			size;
711
	int			is_signed;
712 713
};

714 715 716
struct event_filter {
	int			n_preds;
	struct filter_pred	**preds;
717
	char			*filter_string;
718 719
};

720 721 722 723
struct event_subsystem {
	struct list_head	list;
	const char		*name;
	struct dentry		*entry;
724
	struct event_filter	*filter;
725
	int			nr_events;
726 727
};

T
Tom Zanussi 已提交
728
struct filter_pred;
729
struct regex;
T
Tom Zanussi 已提交
730

731 732
typedef int (*filter_pred_fn_t) (struct filter_pred *pred, void *event,
				 int val1, int val2);
T
Tom Zanussi 已提交
733

734 735
typedef int (*regex_match_func)(char *str, struct regex *r, int len);

736
enum regex_type {
737
	MATCH_FULL = 0,
738 739 740 741 742
	MATCH_FRONT_ONLY,
	MATCH_MIDDLE_ONLY,
	MATCH_END_ONLY,
};

743 744 745 746 747 748 749
struct regex {
	char			pattern[MAX_FILTER_STR_VAL];
	int			len;
	int			field_len;
	regex_match_func	match;
};

T
Tom Zanussi 已提交
750
struct filter_pred {
751 752 753 754 755 756 757 758
	filter_pred_fn_t 	fn;
	u64 			val;
	struct regex		regex;
	char 			*field_name;
	int 			offset;
	int 			not;
	int 			op;
	int 			pop_n;
T
Tom Zanussi 已提交
759 760
};

761 762
extern enum regex_type
filter_parse_regex(char *buff, int len, char **search, int *not);
763
extern void print_event_filter(struct ftrace_event_call *call,
764
			       struct trace_seq *s);
765 766 767 768 769
extern int apply_event_filter(struct ftrace_event_call *call,
			      char *filter_string);
extern int apply_subsystem_event_filter(struct event_subsystem *system,
					char *filter_string);
extern void print_subsystem_event_filter(struct event_subsystem *system,
770
					 struct trace_seq *s);
771
extern int filter_assign_type(const char *type);
T
Tom Zanussi 已提交
772

773
static inline int
774
filter_check_discard(struct ftrace_event_call *call, void *rec,
775
		     struct ring_buffer *buffer,
776 777
		     struct ring_buffer_event *event)
{
L
Li Zefan 已提交
778 779
	if (unlikely(call->filter_active) &&
	    !filter_match_preds(call->filter, rec)) {
780 781 782 783 784
		ring_buffer_discard_commit(buffer, event);
		return 1;
	}

	return 0;
785 786
}

787
extern struct mutex event_mutex;
788
extern struct list_head ftrace_events;
P
Peter Zijlstra 已提交
789

790 791 792
extern const char *__start___trace_bprintk_fmt[];
extern const char *__stop___trace_bprintk_fmt[];

793 794
#undef FTRACE_ENTRY
#define FTRACE_ENTRY(call, struct_name, id, tstruct, print)		\
795 796
	extern struct ftrace_event_call					\
	__attribute__((__aligned__(4))) event_##call;
797 798 799 800
#undef FTRACE_ENTRY_DUP
#define FTRACE_ENTRY_DUP(call, struct_name, id, tstruct, print)		\
	FTRACE_ENTRY(call, struct_name, id, PARAMS(tstruct), PARAMS(print))
#include "trace_entries.h"
801

802
#endif /* _LINUX_KERNEL_TRACE_H */