trace.h 23.0 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/ftrace.h>
11
#include <trace/boot.h>
12
#include <linux/kmemtrace.h>
13
#include <trace/power.h>
14

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

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

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

44
	__TRACE_LAST_TYPE,
45 46
};

47 48 49 50
/*
 * Function trace entry - function address and parent function addres:
 */
struct ftrace_entry {
51
	struct trace_entry	ent;
52 53 54
	unsigned long		ip;
	unsigned long		parent_ip;
};
55

56 57
/* Function call entry */
struct ftrace_graph_ent_entry {
58
	struct trace_entry		ent;
59 60 61
	struct ftrace_graph_ent		graph_ent;
};

62
/* Function return entry */
63
struct ftrace_graph_ret_entry {
64
	struct trace_entry		ent;
65
	struct ftrace_graph_ret		ret;
66
};
67
extern struct tracer boot_tracer;
68 69 70 71 72

/*
 * Context switch trace entry - which task (and prio) we switched from/to:
 */
struct ctx_switch_entry {
73
	struct trace_entry	ent;
74 75 76 77 78
	unsigned int		prev_pid;
	unsigned char		prev_prio;
	unsigned char		prev_state;
	unsigned int		next_pid;
	unsigned char		next_prio;
P
Peter Zijlstra 已提交
79
	unsigned char		next_state;
80
	unsigned int		next_cpu;
81 82
};

I
Ingo Molnar 已提交
83 84 85 86
/*
 * Special (free-form) trace entry:
 */
struct special_entry {
87
	struct trace_entry	ent;
I
Ingo Molnar 已提交
88 89 90 91 92
	unsigned long		arg1;
	unsigned long		arg2;
	unsigned long		arg3;
};

I
Ingo Molnar 已提交
93 94 95 96
/*
 * Stack-trace entry:
 */

I
Ingo Molnar 已提交
97
#define FTRACE_STACK_ENTRIES	8
I
Ingo Molnar 已提交
98 99

struct stack_entry {
100
	struct trace_entry	ent;
I
Ingo Molnar 已提交
101 102 103
	unsigned long		caller[FTRACE_STACK_ENTRIES];
};

104 105 106 107 108
struct userstack_entry {
	struct trace_entry	ent;
	unsigned long		caller[FTRACE_STACK_ENTRIES];
};

109
/*
110
 * trace_printk entry:
111
 */
112
struct bprint_entry {
113
	struct trace_entry	ent;
I
Ingo Molnar 已提交
114
	unsigned long		ip;
115
	const char		*fmt;
I
Ingo Molnar 已提交
116
	u32			buf[];
117 118
};

119 120 121 122 123 124
struct print_entry {
	struct trace_entry	ent;
	unsigned long		ip;
	char			buf[];
};

125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
#define TRACE_OLD_SIZE		88

struct trace_field_cont {
	unsigned char		type;
	/* Temporary till we get rid of this completely */
	char			buf[TRACE_OLD_SIZE - 1];
};

struct trace_mmiotrace_rw {
	struct trace_entry	ent;
	struct mmiotrace_rw	rw;
};

struct trace_mmiotrace_map {
	struct trace_entry	ent;
	struct mmiotrace_map	map;
};

143
struct trace_boot_call {
144
	struct trace_entry	ent;
145 146 147 148 149 150
	struct boot_trace_call boot_call;
};

struct trace_boot_ret {
	struct trace_entry	ent;
	struct boot_trace_ret boot_ret;
151 152
};

153 154
#define TRACE_FUNC_SIZE 30
#define TRACE_FILE_SIZE 20
155
struct trace_branch {
156 157 158 159 160 161 162
	struct trace_entry	ent;
	unsigned	        line;
	char			func[TRACE_FUNC_SIZE+1];
	char			file[TRACE_FILE_SIZE+1];
	char			correct;
};

163
struct hw_branch_entry {
164
	struct trace_entry	ent;
165 166
	u64			from;
	u64			to;
167 168
};

169 170 171 172 173
struct trace_power {
	struct trace_entry	ent;
	struct power_trace	state_data;
};

174 175 176 177 178 179
enum kmemtrace_type_id {
	KMEMTRACE_TYPE_KMALLOC = 0,	/* kmalloc() or kfree(). */
	KMEMTRACE_TYPE_CACHE,		/* kmem_cache_*(). */
	KMEMTRACE_TYPE_PAGES,		/* __get_free_pages() and friends. */
};

180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
struct kmemtrace_alloc_entry {
	struct trace_entry	ent;
	enum kmemtrace_type_id type_id;
	unsigned long call_site;
	const void *ptr;
	size_t bytes_req;
	size_t bytes_alloc;
	gfp_t gfp_flags;
	int node;
};

struct kmemtrace_free_entry {
	struct trace_entry	ent;
	enum kmemtrace_type_id type_id;
	unsigned long call_site;
	const void *ptr;
};

198 199 200 201 202 203 204 205 206 207 208 209 210
struct syscall_trace_enter {
	struct trace_entry	ent;
	int			nr;
	unsigned long		args[];
};

struct syscall_trace_exit {
	struct trace_entry	ent;
	int			nr;
	unsigned long		ret;
};


211 212 213
/*
 * trace_flag_type is an enumeration that holds different
 * states when a trace occurs. These are:
214
 *  IRQS_OFF		- interrupts were disabled
I
Ingo Molnar 已提交
215
 *  IRQS_NOSUPPORT	- arch does not support irqs_disabled_flags
216 217 218
 *  NEED_RESCED		- reschedule is requested
 *  HARDIRQ		- inside an interrupt handler
 *  SOFTIRQ		- inside a softirq handler
219 220 221
 */
enum trace_flag_type {
	TRACE_FLAG_IRQS_OFF		= 0x01,
222 223 224 225
	TRACE_FLAG_IRQS_NOSUPPORT	= 0x02,
	TRACE_FLAG_NEED_RESCHED		= 0x04,
	TRACE_FLAG_HARDIRQ		= 0x08,
	TRACE_FLAG_SOFTIRQ		= 0x10,
226 227
};

228
#define TRACE_BUF_SIZE		1024
229 230 231 232 233 234 235 236

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

I
Ingo Molnar 已提交
239 240
	/* these fields get copied into max-trace: */
	unsigned long		trace_idx;
241
	unsigned long		overrun;
242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260
	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;
	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 {
261
	struct ring_buffer	*buffer;
262 263 264
	unsigned long		entries;
	int			cpu;
	cycle_t			time_start;
265
	struct task_struct	*waiter;
266 267 268
	struct trace_array_cpu	*data[NR_CPUS];
};

S
Steven Rostedt 已提交
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
#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);	\
301
		IF_ASSIGN(var, ent, struct userstack_entry, TRACE_USER_STACK);\
S
Steven Rostedt 已提交
302
		IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT);	\
303
		IF_ASSIGN(var, ent, struct bprint_entry, TRACE_BPRINT);	\
S
Steven Rostedt 已提交
304 305 306 307 308
		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);				\
309 310
		IF_ASSIGN(var, ent, struct trace_boot_call, TRACE_BOOT_CALL);\
		IF_ASSIGN(var, ent, struct trace_boot_ret, TRACE_BOOT_RET);\
311
		IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \
312 313 314 315
		IF_ASSIGN(var, ent, struct ftrace_graph_ent_entry,	\
			  TRACE_GRAPH_ENT);		\
		IF_ASSIGN(var, ent, struct ftrace_graph_ret_entry,	\
			  TRACE_GRAPH_RET);		\
316
		IF_ASSIGN(var, ent, struct hw_branch_entry, TRACE_HW_BRANCHES);\
I
Ingo Molnar 已提交
317
		IF_ASSIGN(var, ent, struct trace_power, TRACE_POWER); \
318 319 320 321
		IF_ASSIGN(var, ent, struct kmemtrace_alloc_entry,	\
			  TRACE_KMEM_ALLOC);	\
		IF_ASSIGN(var, ent, struct kmemtrace_free_entry,	\
			  TRACE_KMEM_FREE);	\
322 323 324 325
		IF_ASSIGN(var, ent, struct syscall_trace_enter,		\
			  TRACE_SYSCALL_ENTER);				\
		IF_ASSIGN(var, ent, struct syscall_trace_exit,		\
			  TRACE_SYSCALL_EXIT);				\
S
Steven Rostedt 已提交
326 327
		__ftrace_bad_type();					\
	} while (0)
328

329 330 331 332 333 334
/*
 * 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 已提交
335 336
	const char	*name; /* Will appear on the trace_options file */
	u32		bit; /* Mask assigned in val field in tracer_flags */
337 338 339 340 341 342 343 344
};

/*
 * 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 已提交
345
	struct tracer_opt	*opts;
346 347 348 349 350
};

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

351

352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369
/**
 * 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
 * @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
370 371 372
 */
struct tracer {
	const char		*name;
373
	int			(*init)(struct trace_array *tr);
374
	void			(*reset)(struct trace_array *tr);
375 376
	void			(*start)(struct trace_array *tr);
	void			(*stop)(struct trace_array *tr);
377
	void			(*open)(struct trace_iterator *iter);
378
	void			(*pipe_open)(struct trace_iterator *iter);
379
	void			(*wait_pipe)(struct trace_iterator *iter);
380
	void			(*close)(struct trace_iterator *iter);
381 382 383
	ssize_t			(*read)(struct trace_iterator *iter,
					struct file *filp, char __user *ubuf,
					size_t cnt, loff_t *ppos);
384 385 386 387 388 389
	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 已提交
390 391 392 393
#ifdef CONFIG_FTRACE_STARTUP_TEST
	int			(*selftest)(struct tracer *trace,
					    struct trace_array *tr);
#endif
394
	void			(*print_header)(struct seq_file *m);
395
	enum print_line_t	(*print_line)(struct trace_iterator *iter);
396 397
	/* If you handled the flag setting, return 0 */
	int			(*set_flag)(u32 old_flags, u32 bit, int set);
398 399
	struct tracer		*next;
	int			print_max;
I
Ingo Molnar 已提交
400
	struct tracer_flags	*flags;
401
	struct tracer_stat	*stats;
402 403
};

404

405 406
#define TRACE_PIPE_ALL_CPU	-1

407
int tracer_init(struct tracer *t, struct trace_array *tr);
408
int tracing_is_enabled(void);
409
void trace_wake_up(void);
410
void tracing_reset(struct trace_array *tr, int cpu);
411
void tracing_reset_online_cpus(struct trace_array *tr);
412 413
void tracing_reset_current(int cpu);
void tracing_reset_current_online_cpus(void);
414
int tracing_open_generic(struct inode *inode, struct file *filp);
415 416 417 418 419 420
struct dentry *trace_create_file(const char *name,
				 mode_t mode,
				 struct dentry *parent,
				 void *data,
				 const struct file_operations *fops);

421
struct dentry *tracing_init_dentry(void);
I
Ingo Molnar 已提交
422 423
void init_tracer_sysprof_debugfs(struct dentry *d_tracer);

424 425 426
struct ring_buffer_event;

struct ring_buffer_event *trace_buffer_lock_reserve(struct trace_array *tr,
427
						    int type,
428 429 430 431 432 433 434
						    unsigned long len,
						    unsigned long flags,
						    int pc);
void trace_buffer_unlock_commit(struct trace_array *tr,
				struct ring_buffer_event *event,
				unsigned long flags, int pc);

435 436
struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
						struct trace_array_cpu *data);
437 438 439 440

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

441
void tracing_generic_entry_update(struct trace_entry *entry,
442 443
				  unsigned long flags,
				  int pc);
444

445 446 447
void default_wait_pipe(struct trace_iterator *iter);
void poll_wait_pipe(struct trace_iterator *iter);

448 449 450 451
void ftrace(struct trace_array *tr,
			    struct trace_array_cpu *data,
			    unsigned long ip,
			    unsigned long parent_ip,
452
			    unsigned long flags, int pc);
453 454 455
void tracing_sched_switch_trace(struct trace_array *tr,
				struct task_struct *prev,
				struct task_struct *next,
456
				unsigned long flags, int pc);
457 458 459 460

void tracing_sched_wakeup_trace(struct trace_array *tr,
				struct task_struct *wakee,
				struct task_struct *cur,
461
				unsigned long flags, int pc);
I
Ingo Molnar 已提交
462 463 464 465
void trace_special(struct trace_array *tr,
		   struct trace_array_cpu *data,
		   unsigned long arg1,
		   unsigned long arg2,
466
		   unsigned long arg3, int pc);
467 468 469
void trace_function(struct trace_array *tr,
		    unsigned long ip,
		    unsigned long parent_ip,
470
		    unsigned long flags, int pc);
471

472
void trace_graph_return(struct ftrace_graph_ret *trace);
473
int trace_graph_entry(struct ftrace_graph_ent *trace);
474

475 476
void tracing_start_cmdline_record(void);
void tracing_stop_cmdline_record(void);
S
Steven Rostedt 已提交
477 478 479
void tracing_sched_switch_assign_trace(struct trace_array *tr);
void tracing_stop_sched_switch_record(void);
void tracing_start_sched_switch_record(void);
480 481 482 483 484 485 486 487 488 489 490 491
int register_tracer(struct tracer *type);
void unregister_tracer(struct tracer *type);

extern unsigned long nsecs_to_usecs(unsigned long nsecs);

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);

492 493 494 495
void __trace_stack(struct trace_array *tr,
		   unsigned long flags,
		   int skip, int pc);

I
Ingo Molnar 已提交
496
extern cycle_t ftrace_now(int cpu);
497 498 499 500

#ifdef CONFIG_CONTEXT_SWITCH_TRACER
typedef void
(*tracer_switch_func_t)(void *private,
M
Mathieu Desnoyers 已提交
501
			void *__rq,
502 503 504 505 506 507 508 509 510 511
			struct task_struct *prev,
			struct task_struct *next);

struct tracer_switch_ops {
	tracer_switch_func_t		func;
	void				*private;
	struct tracer_switch_ops	*next;
};
#endif /* CONFIG_CONTEXT_SWITCH_TRACER */

512
extern void trace_find_cmdline(int pid, char comm[]);
513

514 515
#ifdef CONFIG_DYNAMIC_FTRACE
extern unsigned long ftrace_update_tot_cnt;
516 517
#define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func
extern int DYN_FTRACE_TEST_NAME(void);
518 519
#endif

520 521
extern int ring_buffer_expanded;
extern bool tracing_selftest_disabled;
522
DECLARE_PER_CPU(local_t, ftrace_cpu_disabled);
523

S
Steven Rostedt 已提交
524 525 526
#ifdef CONFIG_FTRACE_STARTUP_TEST
extern int trace_selftest_startup_function(struct tracer *trace,
					   struct trace_array *tr);
527 528
extern int trace_selftest_startup_function_graph(struct tracer *trace,
						 struct trace_array *tr);
S
Steven Rostedt 已提交
529 530 531 532 533 534 535 536
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 已提交
537 538
extern int trace_selftest_startup_nop(struct tracer *trace,
					 struct trace_array *tr);
S
Steven Rostedt 已提交
539 540
extern int trace_selftest_startup_sched_switch(struct tracer *trace,
					       struct trace_array *tr);
541 542
extern int trace_selftest_startup_sysprof(struct tracer *trace,
					       struct trace_array *tr);
S
Steven Rostedt 已提交
543 544
extern int trace_selftest_startup_branch(struct tracer *trace,
					 struct trace_array *tr);
545 546
extern int trace_selftest_startup_hw_branches(struct tracer *trace,
					      struct trace_array *tr);
S
Steven Rostedt 已提交
547 548
#endif /* CONFIG_FTRACE_STARTUP_TEST */

I
Ingo Molnar 已提交
549
extern void *head_page(struct trace_array_cpu *data);
550
extern unsigned long long ns2usecs(cycle_t nsec);
551
extern int
552
trace_vbprintk(unsigned long ip, const char *fmt, va_list args);
553
extern int
554
trace_vprintk(unsigned long ip, const char *fmt, va_list args);
I
Ingo Molnar 已提交
555

556 557
extern unsigned long trace_flags;

558
/* Standard output formatting function used for function return traces */
559 560
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
extern enum print_line_t print_graph_function(struct trace_iterator *iter);
561 562
extern enum print_line_t
trace_print_graph_duration(unsigned long long duration, struct trace_seq *s);
563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583

#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];

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

	if (!ftrace_graph_count || test_tsk_trace_graph(current))
		return 1;

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

	return 0;
}
584
#else
585 586
static inline int ftrace_trace_addr(unsigned long addr)
{
587 588 589 590 591
	return 1;
}
static inline int ftrace_graph_addr(unsigned long addr)
{
	return 1;
592 593 594
}
#endif /* CONFIG_DYNAMIC_FTRACE */
#else /* CONFIG_FUNCTION_GRAPH_TRACER */
595
static inline enum print_line_t
596
print_graph_function(struct trace_iterator *iter)
597 598 599
{
	return TRACE_TYPE_UNHANDLED;
}
600
#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
601

S
Steven Rostedt 已提交
602
extern struct pid *ftrace_pid_trace;
603

604
#ifdef CONFIG_FUNCTION_TRACER
605 606
static inline int ftrace_trace_task(struct task_struct *task)
{
607
	if (!ftrace_pid_trace)
608 609 610 611
		return 1;

	return test_tsk_trace_trace(task);
}
612 613 614 615 616 617
#else
static inline int ftrace_trace_task(struct task_struct *task)
{
	return 1;
}
#endif
618

S
Steven Rostedt 已提交
619 620 621 622 623 624 625
/*
 * 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.
 */
626 627 628 629 630 631 632 633 634 635
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,
I
Ingo Molnar 已提交
636
	TRACE_ITER_SCHED_TREE		= 0x200,
637
	TRACE_ITER_PRINTK		= 0x400,
638
	TRACE_ITER_PREEMPTONLY		= 0x800,
639
	TRACE_ITER_BRANCH		= 0x1000,
640
	TRACE_ITER_ANNOTATE		= 0x2000,
641
	TRACE_ITER_USERSTACKTRACE       = 0x4000,
642
	TRACE_ITER_SYM_USEROBJ          = 0x8000,
643
	TRACE_ITER_PRINTK_MSGONLY	= 0x10000,
644 645
	TRACE_ITER_CONTEXT_INFO		= 0x20000, /* Print pid/cpu/time */
	TRACE_ITER_LATENCY_FMT		= 0x40000,
646
	TRACE_ITER_GLOBAL_CLK		= 0x80000,
647
	TRACE_ITER_SLEEP_TIME		= 0x100000,
648
	TRACE_ITER_GRAPH_TIME		= 0x200000,
649 650
};

651 652 653 654 655 656 657
/*
 * 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)

658 659
extern struct tracer nop_trace;

660 661 662 663 664 665 666 667 668
/**
 * 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.
 *
669
 * To prevent this, we read the need_resched flag before
670 671 672 673
 * 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.
 *
674
 * The rational for doing the above is that if need_resched is set
675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
 * 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.
695
 * If resched is set, then we are either inside an atomic or
696 697 698 699 700 701 702 703 704 705 706 707
 * 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();
}

708
#ifdef CONFIG_BRANCH_TRACER
709 710 711
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)
712
{
713 714
	if (trace_flags & TRACE_ITER_BRANCH)
		return enable_branch_tracing(tr);
715 716
	return 0;
}
717
static inline void trace_branch_disable(void)
718 719
{
	/* due to races, always disable */
720
	disable_branch_tracing();
721 722
}
#else
723
static inline int trace_branch_enable(struct trace_array *tr)
724 725 726
{
	return 0;
}
727
static inline void trace_branch_disable(void)
728 729
{
}
730
#endif /* CONFIG_BRANCH_TRACER */
731

732 733 734
/* set ring buffers to default size if not already done so */
int tracing_update_buffers(void);

735 736 737 738 739 740
/* trace event type bit fields, not numeric */
enum {
	TRACE_EVENT_TYPE_PRINTF		= 1,
	TRACE_EVENT_TYPE_RAW		= 2,
};

741 742 743 744 745 746
struct ftrace_event_field {
	struct list_head	link;
	char			*name;
	char			*type;
	int			offset;
	int			size;
747
	int			is_signed;
748 749
};

750 751 752
struct event_filter {
	int			n_preds;
	struct filter_pred	**preds;
753
	char			*filter_string;
754
	bool			no_reset;
755 756
};

757 758 759 760
struct event_subsystem {
	struct list_head	list;
	const char		*name;
	struct dentry		*entry;
761
	struct event_filter	*filter;
762
	int			nr_events;
763 764
};

T
Tom Zanussi 已提交
765 766
struct filter_pred;

767 768
typedef int (*filter_pred_fn_t) (struct filter_pred *pred, void *event,
				 int val1, int val2);
T
Tom Zanussi 已提交
769 770 771 772

struct filter_pred {
	filter_pred_fn_t fn;
	u64 val;
773
	char str_val[MAX_FILTER_STR_VAL];
T
Tom Zanussi 已提交
774 775 776 777
	int str_len;
	char *field_name;
	int offset;
	int not;
778 779
	int op;
	int pop_n;
T
Tom Zanussi 已提交
780 781
};

782
extern void print_event_filter(struct ftrace_event_call *call,
783
			       struct trace_seq *s);
784 785 786 787 788
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,
789
					 struct trace_seq *s);
T
Tom Zanussi 已提交
790

791
static inline int
792
filter_check_discard(struct ftrace_event_call *call, void *rec,
793
		     struct ring_buffer *buffer,
794 795
		     struct ring_buffer_event *event)
{
796
	if (unlikely(call->filter_active) && !filter_match_preds(call, rec)) {
797 798 799 800 801
		ring_buffer_discard_commit(buffer, event);
		return 1;
	}

	return 0;
802 803
}

804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844
#define DEFINE_COMPARISON_PRED(type)					\
static int filter_pred_##type(struct filter_pred *pred, void *event,	\
			      int val1, int val2)			\
{									\
	type *addr = (type *)(event + pred->offset);			\
	type val = (type)pred->val;					\
	int match = 0;							\
									\
	switch (pred->op) {						\
	case OP_LT:							\
		match = (*addr < val);					\
		break;							\
	case OP_LE:							\
		match = (*addr <= val);					\
		break;							\
	case OP_GT:							\
		match = (*addr > val);					\
		break;							\
	case OP_GE:							\
		match = (*addr >= val);					\
		break;							\
	default:							\
		break;							\
	}								\
									\
	return match;							\
}

#define DEFINE_EQUALITY_PRED(size)					\
static int filter_pred_##size(struct filter_pred *pred, void *event,	\
			      int val1, int val2)			\
{									\
	u##size *addr = (u##size *)(event + pred->offset);		\
	u##size val = (u##size)pred->val;				\
	int match;							\
									\
	match = (val == *addr) ^ pred->not;				\
									\
	return match;							\
}

845
extern struct mutex event_mutex;
846
extern struct list_head ftrace_events;
P
Peter Zijlstra 已提交
847

848 849 850
extern const char *__start___trace_bprintk_fmt[];
extern const char *__stop___trace_bprintk_fmt[];

851 852 853
#undef TRACE_EVENT_FORMAT
#define TRACE_EVENT_FORMAT(call, proto, args, fmt, tstruct, tpfmt)	\
	extern struct ftrace_event_call event_##call;
854 855
#undef TRACE_EVENT_FORMAT_NOFILTER
#define TRACE_EVENT_FORMAT_NOFILTER(call, proto, args, fmt, tstruct, tpfmt)
856 857
#include "trace_event_types.h"

858
#endif /* _LINUX_KERNEL_TRACE_H */