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

15 16 17 18 19 20 21
enum trace_type {
	__TRACE_FIRST_TYPE = 0,

	TRACE_FN,
	TRACE_CTX,
	TRACE_WAKE,
	TRACE_STACK,
22
	TRACE_PRINT,
23
	TRACE_SPECIAL,
P
Pekka Paalanen 已提交
24 25
	TRACE_MMIO_RW,
	TRACE_MMIO_MAP,
26
	TRACE_BRANCH,
27 28
	TRACE_BOOT_CALL,
	TRACE_BOOT_RET,
29 30
	TRACE_GRAPH_RET,
	TRACE_GRAPH_ENT,
31
	TRACE_USER_STACK,
32
	TRACE_HW_BRANCHES,
33 34
	TRACE_KMEM_ALLOC,
	TRACE_KMEM_FREE,
35
	TRACE_POWER,
36
	TRACE_BLK,
37

38
	__TRACE_LAST_TYPE,
39 40
};

41 42 43 44 45 46 47 48 49 50 51
/*
 * The trace entry - the most basic unit of tracing. This is what
 * is printed in the end as a single line in the trace output, such as:
 *
 *     bash-15816 [01]   235.197585: idle_cpu <- irq_enter
 */
struct trace_entry {
	unsigned char		type;
	unsigned char		flags;
	unsigned char		preempt_count;
	int			pid;
52
	int			tgid;
53 54
};

55 56 57 58
/*
 * Function trace entry - function address and parent function addres:
 */
struct ftrace_entry {
59
	struct trace_entry	ent;
60 61 62
	unsigned long		ip;
	unsigned long		parent_ip;
};
63

64 65
/* Function call entry */
struct ftrace_graph_ent_entry {
66
	struct trace_entry		ent;
67 68 69
	struct ftrace_graph_ent		graph_ent;
};

70
/* Function return entry */
71
struct ftrace_graph_ret_entry {
72
	struct trace_entry		ent;
73
	struct ftrace_graph_ret		ret;
74
};
75
extern struct tracer boot_tracer;
76 77 78 79 80

/*
 * Context switch trace entry - which task (and prio) we switched from/to:
 */
struct ctx_switch_entry {
81
	struct trace_entry	ent;
82 83 84 85 86
	unsigned int		prev_pid;
	unsigned char		prev_prio;
	unsigned char		prev_state;
	unsigned int		next_pid;
	unsigned char		next_prio;
P
Peter Zijlstra 已提交
87
	unsigned char		next_state;
88
	unsigned int		next_cpu;
89 90
};

I
Ingo Molnar 已提交
91 92 93 94
/*
 * Special (free-form) trace entry:
 */
struct special_entry {
95
	struct trace_entry	ent;
I
Ingo Molnar 已提交
96 97 98 99 100
	unsigned long		arg1;
	unsigned long		arg2;
	unsigned long		arg3;
};

I
Ingo Molnar 已提交
101 102 103 104
/*
 * Stack-trace entry:
 */

I
Ingo Molnar 已提交
105
#define FTRACE_STACK_ENTRIES	8
I
Ingo Molnar 已提交
106 107

struct stack_entry {
108
	struct trace_entry	ent;
I
Ingo Molnar 已提交
109 110 111
	unsigned long		caller[FTRACE_STACK_ENTRIES];
};

112 113 114 115 116
struct userstack_entry {
	struct trace_entry	ent;
	unsigned long		caller[FTRACE_STACK_ENTRIES];
};

117 118 119 120
/*
 * ftrace_printk entry:
 */
struct print_entry {
121
	struct trace_entry	ent;
122
	unsigned long		ip;
123
	int			depth;
124 125 126
	char			buf[];
};

127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
#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;
};

145
struct trace_boot_call {
146
	struct trace_entry	ent;
147 148 149 150 151 152
	struct boot_trace_call boot_call;
};

struct trace_boot_ret {
	struct trace_entry	ent;
	struct boot_trace_ret boot_ret;
153 154
};

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

165
struct hw_branch_entry {
166
	struct trace_entry	ent;
167 168
	u64			from;
	u64			to;
169 170
};

171 172 173 174 175
struct trace_power {
	struct trace_entry	ent;
	struct power_trace	state_data;
};

176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193
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;
};

194 195 196
/*
 * trace_flag_type is an enumeration that holds different
 * states when a trace occurs. These are:
197 198 199 200 201
 *  IRQS_OFF		- interrupts were disabled
 *  IRQS_NOSUPPORT 	- arch does not support irqs_disabled_flags
 *  NEED_RESCED		- reschedule is requested
 *  HARDIRQ		- inside an interrupt handler
 *  SOFTIRQ		- inside a softirq handler
202 203 204
 */
enum trace_flag_type {
	TRACE_FLAG_IRQS_OFF		= 0x01,
205 206 207 208
	TRACE_FLAG_IRQS_NOSUPPORT	= 0x02,
	TRACE_FLAG_NEED_RESCHED		= 0x04,
	TRACE_FLAG_HARDIRQ		= 0x08,
	TRACE_FLAG_SOFTIRQ		= 0x10,
209 210
};

211
#define TRACE_BUF_SIZE		1024
212 213 214 215 216 217 218 219

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

I
Ingo Molnar 已提交
222 223
	/* these fields get copied into max-trace: */
	unsigned long		trace_idx;
224
	unsigned long		overrun;
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
	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];
};

struct trace_iterator;

/*
 * 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 {
246
	struct ring_buffer	*buffer;
247 248 249
	unsigned long		entries;
	int			cpu;
	cycle_t			time_start;
250
	struct task_struct	*waiter;
251 252 253
	struct trace_array_cpu	*data[NR_CPUS];
};

S
Steven Rostedt 已提交
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285
#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);	\
286
		IF_ASSIGN(var, ent, struct userstack_entry, TRACE_USER_STACK);\
S
Steven Rostedt 已提交
287 288 289 290 291 292
		IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT);	\
		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);				\
293 294
		IF_ASSIGN(var, ent, struct trace_boot_call, TRACE_BOOT_CALL);\
		IF_ASSIGN(var, ent, struct trace_boot_ret, TRACE_BOOT_RET);\
295
		IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \
296 297 298 299
		IF_ASSIGN(var, ent, struct ftrace_graph_ent_entry,	\
			  TRACE_GRAPH_ENT);		\
		IF_ASSIGN(var, ent, struct ftrace_graph_ret_entry,	\
			  TRACE_GRAPH_RET);		\
300
		IF_ASSIGN(var, ent, struct hw_branch_entry, TRACE_HW_BRANCHES);\
301
 		IF_ASSIGN(var, ent, struct trace_power, TRACE_POWER); \
302 303 304 305
		IF_ASSIGN(var, ent, struct kmemtrace_alloc_entry,	\
			  TRACE_KMEM_ALLOC);	\
		IF_ASSIGN(var, ent, struct kmemtrace_free_entry,	\
			  TRACE_KMEM_FREE);	\
S
Steven Rostedt 已提交
306 307
		__ftrace_bad_type();					\
	} while (0)
308 309 310 311 312

/* Return values for print_line callback */
enum print_line_t {
	TRACE_TYPE_PARTIAL_LINE	= 0,	/* Retry after flushing the seq */
	TRACE_TYPE_HANDLED	= 1,
313 314
	TRACE_TYPE_UNHANDLED	= 2,	/* Relay to other output functions */
	TRACE_TYPE_NO_CONSUME	= 3	/* Handled but ask to not consume */
315 316
};

317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339

/*
 * 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 {
	const char 	*name; /* Will appear on the trace_options file */
	u32 		bit; /* Mask assigned in val field in tracer_flags */
};

/*
 * 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;
	struct tracer_opt 	*opts;
};

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

340

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

S
Steven Rostedt 已提交
393 394 395
struct trace_seq {
	unsigned char		buffer[PAGE_SIZE];
	unsigned int		len;
396
	unsigned int		readpos;
S
Steven Rostedt 已提交
397 398
};

399 400 401 402 403 404 405 406
static inline void
trace_seq_init(struct trace_seq *s)
{
	s->len = 0;
	s->readpos = 0;
}


407 408
#define TRACE_PIPE_ALL_CPU	-1

409 410 411 412 413 414 415
/*
 * Trace iterator - used by printout routines who present trace
 * results to users and which routines might sleep, etc:
 */
struct trace_iterator {
	struct trace_array	*tr;
	struct tracer		*trace;
416
	void			*private;
417
	int			cpu_file;
418 419
	struct mutex		mutex;
	struct ring_buffer_iter	*buffer_iter[NR_CPUS];
I
Ingo Molnar 已提交
420

421 422
	/* The below is zeroed out in pipe_read */
	struct trace_seq	seq;
423
	struct trace_entry	*ent;
I
Ingo Molnar 已提交
424
	int			cpu;
425
	u64			ts;
I
Ingo Molnar 已提交
426

427 428
	unsigned long		iter_flags;
	loff_t			pos;
429
	long			idx;
430

431
	cpumask_var_t		started;
432 433
};

434
int tracer_init(struct tracer *t, struct trace_array *tr);
435
int tracing_is_enabled(void);
436
void trace_wake_up(void);
437
void tracing_reset(struct trace_array *tr, int cpu);
438
void tracing_reset_online_cpus(struct trace_array *tr);
439 440
int tracing_open_generic(struct inode *inode, struct file *filp);
struct dentry *tracing_init_dentry(void);
I
Ingo Molnar 已提交
441 442
void init_tracer_sysprof_debugfs(struct dentry *d_tracer);

443 444 445 446 447 448 449 450 451 452 453
struct ring_buffer_event;

struct ring_buffer_event *trace_buffer_lock_reserve(struct trace_array *tr,
						    unsigned char type,
						    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);

454 455 456 457 458 459
struct ring_buffer_event *
trace_current_buffer_lock_reserve(unsigned char type, unsigned long len,
				  unsigned long flags, int pc);
void trace_current_buffer_unlock_commit(struct ring_buffer_event *event,
					unsigned long flags, int pc);

460 461
struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
						struct trace_array_cpu *data);
462 463 464 465

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

466
void tracing_generic_entry_update(struct trace_entry *entry,
467 468
				  unsigned long flags,
				  int pc);
469

470 471 472
void default_wait_pipe(struct trace_iterator *iter);
void poll_wait_pipe(struct trace_iterator *iter);

473 474 475 476
void ftrace(struct trace_array *tr,
			    struct trace_array_cpu *data,
			    unsigned long ip,
			    unsigned long parent_ip,
477
			    unsigned long flags, int pc);
478 479 480
void tracing_sched_switch_trace(struct trace_array *tr,
				struct task_struct *prev,
				struct task_struct *next,
481
				unsigned long flags, int pc);
482
void tracing_record_cmdline(struct task_struct *tsk);
483 484 485 486

void tracing_sched_wakeup_trace(struct trace_array *tr,
				struct task_struct *wakee,
				struct task_struct *cur,
487
				unsigned long flags, int pc);
I
Ingo Molnar 已提交
488 489 490 491
void trace_special(struct trace_array *tr,
		   struct trace_array_cpu *data,
		   unsigned long arg1,
		   unsigned long arg2,
492
		   unsigned long arg3, int pc);
493 494 495
void trace_function(struct trace_array *tr,
		    unsigned long ip,
		    unsigned long parent_ip,
496
		    unsigned long flags, int pc);
497

498
void trace_graph_return(struct ftrace_graph_ret *trace);
499
int trace_graph_entry(struct ftrace_graph_ent *trace);
500

501 502
void tracing_start_cmdline_record(void);
void tracing_stop_cmdline_record(void);
S
Steven Rostedt 已提交
503 504 505
void tracing_sched_switch_assign_trace(struct trace_array *tr);
void tracing_stop_sched_switch_record(void);
void tracing_start_sched_switch_record(void);
506 507 508 509 510 511 512 513 514 515 516 517
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);

518 519 520 521
void __trace_stack(struct trace_array *tr,
		   unsigned long flags,
		   int skip, int pc);

I
Ingo Molnar 已提交
522
extern cycle_t ftrace_now(int cpu);
523 524 525 526

#ifdef CONFIG_CONTEXT_SWITCH_TRACER
typedef void
(*tracer_switch_func_t)(void *private,
M
Mathieu Desnoyers 已提交
527
			void *__rq,
528 529 530 531 532 533 534 535 536 537
			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 */

538 539
extern char *trace_find_cmdline(int pid);

540 541
#ifdef CONFIG_DYNAMIC_FTRACE
extern unsigned long ftrace_update_tot_cnt;
542 543
#define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func
extern int DYN_FTRACE_TEST_NAME(void);
544 545
#endif

S
Steven Rostedt 已提交
546 547 548
#ifdef CONFIG_FTRACE_STARTUP_TEST
extern int trace_selftest_startup_function(struct tracer *trace,
					   struct trace_array *tr);
549 550
extern int trace_selftest_startup_function_graph(struct tracer *trace,
						 struct trace_array *tr);
S
Steven Rostedt 已提交
551 552 553 554 555 556 557 558
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 已提交
559 560
extern int trace_selftest_startup_nop(struct tracer *trace,
					 struct trace_array *tr);
S
Steven Rostedt 已提交
561 562
extern int trace_selftest_startup_sched_switch(struct tracer *trace,
					       struct trace_array *tr);
563 564
extern int trace_selftest_startup_sysprof(struct tracer *trace,
					       struct trace_array *tr);
S
Steven Rostedt 已提交
565 566
extern int trace_selftest_startup_branch(struct tracer *trace,
					 struct trace_array *tr);
S
Steven Rostedt 已提交
567 568
#endif /* CONFIG_FTRACE_STARTUP_TEST */

I
Ingo Molnar 已提交
569
extern void *head_page(struct trace_array_cpu *data);
570
extern long ns2usecs(cycle_t nsec);
571 572
extern int
trace_vprintk(unsigned long ip, int depth, const char *fmt, va_list args);
I
Ingo Molnar 已提交
573

574 575
extern unsigned long trace_flags;

576
/* Standard output formatting function used for function return traces */
577 578
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
extern enum print_line_t print_graph_function(struct trace_iterator *iter);
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599

#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;
}
600
#else
601 602
static inline int ftrace_trace_addr(unsigned long addr)
{
603 604 605 606 607
	return 1;
}
static inline int ftrace_graph_addr(unsigned long addr)
{
	return 1;
608 609 610 611
}
#endif /* CONFIG_DYNAMIC_FTRACE */

#else /* CONFIG_FUNCTION_GRAPH_TRACER */
612
static inline enum print_line_t
613
print_graph_function(struct trace_iterator *iter)
614 615 616
{
	return TRACE_TYPE_UNHANDLED;
}
617
#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
618

S
Steven Rostedt 已提交
619
extern struct pid *ftrace_pid_trace;
620 621 622

static inline int ftrace_trace_task(struct task_struct *task)
{
623
	if (!ftrace_pid_trace)
624 625 626 627 628
		return 1;

	return test_tsk_trace_trace(task);
}

S
Steven Rostedt 已提交
629 630 631 632 633 634 635
/*
 * 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.
 */
636 637 638 639 640 641 642 643 644 645
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 已提交
646
	TRACE_ITER_SCHED_TREE		= 0x200,
647
	TRACE_ITER_PRINTK		= 0x400,
648
	TRACE_ITER_PREEMPTONLY		= 0x800,
649
	TRACE_ITER_BRANCH		= 0x1000,
650
	TRACE_ITER_ANNOTATE		= 0x2000,
651
	TRACE_ITER_USERSTACKTRACE       = 0x4000,
652
	TRACE_ITER_SYM_USEROBJ          = 0x8000,
653 654
	TRACE_ITER_PRINTK_MSGONLY	= 0x10000,
	TRACE_ITER_CONTEXT_INFO		= 0x20000 /* Print pid/cpu/time */
655 656
};

657 658 659 660 661 662 663
/*
 * 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)

664 665
extern struct tracer nop_trace;

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

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

738 739 740 741 742 743
/* trace event type bit fields, not numeric */
enum {
	TRACE_EVENT_TYPE_PRINTF		= 1,
	TRACE_EVENT_TYPE_RAW		= 2,
};

744 745 746 747 748 749 750 751 752 753
struct ftrace_event_call {
	char		*name;
	char		*system;
	struct dentry	*dir;
	int		enabled;
	int		(*regfunc)(void);
	void		(*unregfunc)(void);
	int		id;
	struct dentry	*raw_dir;
	int		raw_enabled;
754
	int		type;
755 756 757
	int		(*raw_init)(void);
	int		(*raw_reg)(void);
	void		(*raw_unreg)(void);
758
	int		(*show_format)(struct trace_seq *s);
759 760 761 762 763 764
};

void event_trace_printk(unsigned long ip, const char *fmt, ...);
extern struct ftrace_event_call __start_ftrace_events[];
extern struct ftrace_event_call __stop_ftrace_events[];

765
#endif /* _LINUX_KERNEL_TRACE_H */