trace.h 17.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

13 14 15 16 17 18
enum trace_type {
	__TRACE_FIRST_TYPE = 0,

	TRACE_FN,
	TRACE_CTX,
	TRACE_WAKE,
19
	TRACE_CONT,
20
	TRACE_STACK,
21
	TRACE_PRINT,
22
	TRACE_SPECIAL,
P
Pekka Paalanen 已提交
23 24
	TRACE_MMIO_RW,
	TRACE_MMIO_MAP,
25
	TRACE_BRANCH,
26 27
	TRACE_BOOT_CALL,
	TRACE_BOOT_RET,
28 29
	TRACE_GRAPH_RET,
	TRACE_GRAPH_ENT,
30
	TRACE_USER_STACK,
31
	TRACE_BTS,
32
	TRACE_POWER,
33 34 35 36

	__TRACE_LAST_TYPE
};

37 38 39 40 41 42 43 44 45 46 47 48
/*
 * 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		cpu;
	unsigned char		flags;
	unsigned char		preempt_count;
	int			pid;
49
	int			tgid;
50 51
};

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

61 62 63 64 65 66
/* Function call entry */
struct ftrace_graph_ent_entry {
	struct trace_entry			ent;
	struct ftrace_graph_ent		graph_ent;
};

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

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

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

I
Ingo Molnar 已提交
98 99 100 101
/*
 * Stack-trace entry:
 */

I
Ingo Molnar 已提交
102
#define FTRACE_STACK_ENTRIES	8
I
Ingo Molnar 已提交
103 104

struct stack_entry {
105
	struct trace_entry	ent;
I
Ingo Molnar 已提交
106 107 108
	unsigned long		caller[FTRACE_STACK_ENTRIES];
};

109 110 111 112 113
struct userstack_entry {
	struct trace_entry	ent;
	unsigned long		caller[FTRACE_STACK_ENTRIES];
};

114 115 116 117
/*
 * ftrace_printk entry:
 */
struct print_entry {
118
	struct trace_entry	ent;
119 120 121 122
	unsigned long		ip;
	char			buf[];
};

123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
#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;
};

141
struct trace_boot_call {
142
	struct trace_entry	ent;
143 144 145 146 147 148
	struct boot_trace_call boot_call;
};

struct trace_boot_ret {
	struct trace_entry	ent;
	struct boot_trace_ret boot_ret;
149 150
};

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

161 162 163 164 165 166
struct bts_entry {
	struct trace_entry	ent;
	unsigned long		from;
	unsigned long		to;
};

167 168 169 170 171
struct trace_power {
	struct trace_entry	ent;
	struct power_trace	state_data;
};

172 173 174
/*
 * trace_flag_type is an enumeration that holds different
 * states when a trace occurs. These are:
175 176 177 178 179 180
 *  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
 *  CONT		- multiple entries hold the trace item
181 182 183
 */
enum trace_flag_type {
	TRACE_FLAG_IRQS_OFF		= 0x01,
184 185 186 187 188
	TRACE_FLAG_IRQS_NOSUPPORT	= 0x02,
	TRACE_FLAG_NEED_RESCHED		= 0x04,
	TRACE_FLAG_HARDIRQ		= 0x08,
	TRACE_FLAG_SOFTIRQ		= 0x10,
	TRACE_FLAG_CONT			= 0x20,
189 190
};

191
#define TRACE_BUF_SIZE		1024
192 193 194 195 196 197 198 199

/*
 * 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;
I
Ingo Molnar 已提交
200

I
Ingo Molnar 已提交
201 202
	/* these fields get copied into max-trace: */
	unsigned long		trace_idx;
203
	unsigned long		overrun;
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224
	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 {
225
	struct ring_buffer	*buffer;
226 227 228
	unsigned long		entries;
	int			cpu;
	cycle_t			time_start;
229
	struct task_struct	*waiter;
230 231 232
	struct trace_array_cpu	*data[NR_CPUS];
};

S
Steven Rostedt 已提交
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
#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 trace_field_cont, TRACE_CONT); \
		IF_ASSIGN(var, ent, struct stack_entry, TRACE_STACK);	\
266
		IF_ASSIGN(var, ent, struct userstack_entry, TRACE_USER_STACK);\
S
Steven Rostedt 已提交
267 268 269 270 271 272
		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);				\
273 274
		IF_ASSIGN(var, ent, struct trace_boot_call, TRACE_BOOT_CALL);\
		IF_ASSIGN(var, ent, struct trace_boot_ret, TRACE_BOOT_RET);\
275
		IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \
276 277 278 279
		IF_ASSIGN(var, ent, struct ftrace_graph_ent_entry,	\
			  TRACE_GRAPH_ENT);		\
		IF_ASSIGN(var, ent, struct ftrace_graph_ret_entry,	\
			  TRACE_GRAPH_RET);		\
280
		IF_ASSIGN(var, ent, struct bts_entry, TRACE_BTS);\
281
 		IF_ASSIGN(var, ent, struct trace_power, TRACE_POWER); \
S
Steven Rostedt 已提交
282 283
		__ftrace_bad_type();					\
	} while (0)
284 285 286 287 288 289 290 291

/* Return values for print_line callback */
enum print_line_t {
	TRACE_TYPE_PARTIAL_LINE	= 0,	/* Retry after flushing the seq */
	TRACE_TYPE_HANDLED	= 1,
	TRACE_TYPE_UNHANDLED	= 2	/* Relay to other output functions */
};

292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314

/*
 * 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

315 316 317 318 319
/*
 * A specific tracer, represented by methods that operate on a trace array:
 */
struct tracer {
	const char		*name;
320 321
	/* Your tracer should raise a warning if init fails */
	int			(*init)(struct trace_array *tr);
322
	void			(*reset)(struct trace_array *tr);
323 324
	void			(*start)(struct trace_array *tr);
	void			(*stop)(struct trace_array *tr);
325
	void			(*open)(struct trace_iterator *iter);
326
	void			(*pipe_open)(struct trace_iterator *iter);
327
	void			(*close)(struct trace_iterator *iter);
328 329 330
	ssize_t			(*read)(struct trace_iterator *iter,
					struct file *filp, char __user *ubuf,
					size_t cnt, loff_t *ppos);
S
Steven Rostedt 已提交
331 332 333 334
#ifdef CONFIG_FTRACE_STARTUP_TEST
	int			(*selftest)(struct tracer *trace,
					    struct trace_array *tr);
#endif
335
	void			(*print_header)(struct seq_file *m);
336
	enum print_line_t	(*print_line)(struct trace_iterator *iter);
337 338
	/* If you handled the flag setting, return 0 */
	int			(*set_flag)(u32 old_flags, u32 bit, int set);
339 340
	struct tracer		*next;
	int			print_max;
341
	struct tracer_flags 	*flags;
342 343
};

S
Steven Rostedt 已提交
344 345 346
struct trace_seq {
	unsigned char		buffer[PAGE_SIZE];
	unsigned int		len;
347
	unsigned int		readpos;
S
Steven Rostedt 已提交
348 349
};

350 351 352 353 354 355 356
/*
 * 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;
357
	void			*private;
358
	struct ring_buffer_iter	*buffer_iter[NR_CPUS];
I
Ingo Molnar 已提交
359

360 361
	/* The below is zeroed out in pipe_read */
	struct trace_seq	seq;
362
	struct trace_entry	*ent;
I
Ingo Molnar 已提交
363
	int			cpu;
364
	u64			ts;
I
Ingo Molnar 已提交
365

366 367
	unsigned long		iter_flags;
	loff_t			pos;
368
	long			idx;
369 370

	cpumask_t		started;
371 372
};

373
int tracing_is_enabled(void);
374
void trace_wake_up(void);
375
void tracing_reset(struct trace_array *tr, int cpu);
376 377
int tracing_open_generic(struct inode *inode, struct file *filp);
struct dentry *tracing_init_dentry(void);
I
Ingo Molnar 已提交
378 379
void init_tracer_sysprof_debugfs(struct dentry *d_tracer);

380 381 382
struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
						struct trace_array_cpu *data);
void tracing_generic_entry_update(struct trace_entry *entry,
383 384
				  unsigned long flags,
				  int pc);
385

386 387 388 389
void ftrace(struct trace_array *tr,
			    struct trace_array_cpu *data,
			    unsigned long ip,
			    unsigned long parent_ip,
390
			    unsigned long flags, int pc);
391 392 393 394
void tracing_sched_switch_trace(struct trace_array *tr,
				struct trace_array_cpu *data,
				struct task_struct *prev,
				struct task_struct *next,
395
				unsigned long flags, int pc);
396
void tracing_record_cmdline(struct task_struct *tsk);
397 398 399 400 401

void tracing_sched_wakeup_trace(struct trace_array *tr,
				struct trace_array_cpu *data,
				struct task_struct *wakee,
				struct task_struct *cur,
402
				unsigned long flags, int pc);
I
Ingo Molnar 已提交
403 404 405 406
void trace_special(struct trace_array *tr,
		   struct trace_array_cpu *data,
		   unsigned long arg1,
		   unsigned long arg2,
407
		   unsigned long arg3, int pc);
408 409 410 411
void trace_function(struct trace_array *tr,
		    struct trace_array_cpu *data,
		    unsigned long ip,
		    unsigned long parent_ip,
412
		    unsigned long flags, int pc);
413

414
void trace_graph_return(struct ftrace_graph_ret *trace);
415
int trace_graph_entry(struct ftrace_graph_ent *trace);
416 417 418 419
void trace_bts(struct trace_array *tr,
	       unsigned long from,
	       unsigned long to);

420 421
void tracing_start_cmdline_record(void);
void tracing_stop_cmdline_record(void);
S
Steven Rostedt 已提交
422 423 424
void tracing_sched_switch_assign_trace(struct trace_array *tr);
void tracing_stop_sched_switch_record(void);
void tracing_start_sched_switch_record(void);
425 426 427 428 429 430 431 432 433 434 435 436
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);

I
Ingo Molnar 已提交
437
extern cycle_t ftrace_now(int cpu);
438

439
#ifdef CONFIG_FUNCTION_TRACER
440 441 442 443 444 445 446
void tracing_start_function_trace(void);
void tracing_stop_function_trace(void);
#else
# define tracing_start_function_trace()		do { } while (0)
# define tracing_stop_function_trace()		do { } while (0)
#endif

447 448 449
#ifdef CONFIG_CONTEXT_SWITCH_TRACER
typedef void
(*tracer_switch_func_t)(void *private,
M
Mathieu Desnoyers 已提交
450
			void *__rq,
451 452 453 454 455 456 457 458 459
			struct task_struct *prev,
			struct task_struct *next);

struct tracer_switch_ops {
	tracer_switch_func_t		func;
	void				*private;
	struct tracer_switch_ops	*next;
};

460
char *trace_find_cmdline(int pid);
461 462 463 464
#endif /* CONFIG_CONTEXT_SWITCH_TRACER */

#ifdef CONFIG_DYNAMIC_FTRACE
extern unsigned long ftrace_update_tot_cnt;
465 466
#define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func
extern int DYN_FTRACE_TEST_NAME(void);
467 468
#endif

S
Steven Rostedt 已提交
469 470 471 472 473 474 475 476 477 478 479
#ifdef CONFIG_FTRACE_STARTUP_TEST
extern int trace_selftest_startup_function(struct tracer *trace,
					   struct trace_array *tr);
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 已提交
480 481
extern int trace_selftest_startup_nop(struct tracer *trace,
					 struct trace_array *tr);
S
Steven Rostedt 已提交
482 483
extern int trace_selftest_startup_sched_switch(struct tracer *trace,
					       struct trace_array *tr);
484 485
extern int trace_selftest_startup_sysprof(struct tracer *trace,
					       struct trace_array *tr);
S
Steven Rostedt 已提交
486 487
extern int trace_selftest_startup_branch(struct tracer *trace,
					 struct trace_array *tr);
S
Steven Rostedt 已提交
488 489
#endif /* CONFIG_FTRACE_STARTUP_TEST */

I
Ingo Molnar 已提交
490
extern void *head_page(struct trace_array_cpu *data);
491
extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...);
492 493
extern void trace_seq_print_cont(struct trace_seq *s,
				 struct trace_iterator *iter);
494 495 496 497

extern int
seq_print_ip_sym(struct trace_seq *s, unsigned long ip,
		unsigned long sym_flags);
498 499
extern ssize_t trace_seq_to_user(struct trace_seq *s, char __user *ubuf,
				 size_t cnt);
500
extern long ns2usecs(cycle_t nsec);
P
Pekka Paalanen 已提交
501
extern int trace_vprintk(unsigned long ip, const char *fmt, va_list args);
I
Ingo Molnar 已提交
502

503 504
extern unsigned long trace_flags;

505
/* Standard output formatting function used for function return traces */
506 507
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
extern enum print_line_t print_graph_function(struct trace_iterator *iter);
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528

#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;
}
529
#else
530 531 532 533 534 535 536
static inline int ftrace_trace_addr(unsigned long addr)
{
	return 1
}
#endif /* CONFIG_DYNAMIC_FTRACE */

#else /* CONFIG_FUNCTION_GRAPH_TRACER */
537
static inline enum print_line_t
538
print_graph_function(struct trace_iterator *iter)
539 540 541
{
	return TRACE_TYPE_UNHANDLED;
}
542
#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
543

S
Steven Rostedt 已提交
544
extern struct pid *ftrace_pid_trace;
545 546 547

static inline int ftrace_trace_task(struct task_struct *task)
{
S
Steven Rostedt 已提交
548
	if (ftrace_pid_trace)
549 550 551 552 553
		return 1;

	return test_tsk_trace_trace(task);
}

S
Steven Rostedt 已提交
554 555 556 557 558 559 560
/*
 * 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.
 */
561 562 563 564 565 566 567 568 569 570
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 已提交
571
	TRACE_ITER_SCHED_TREE		= 0x200,
572
	TRACE_ITER_PRINTK		= 0x400,
573
	TRACE_ITER_PREEMPTONLY		= 0x800,
574
	TRACE_ITER_BRANCH		= 0x1000,
575
	TRACE_ITER_ANNOTATE		= 0x2000,
576 577
	TRACE_ITER_USERSTACKTRACE       = 0x4000,
	TRACE_ITER_SYM_USEROBJ          = 0x8000
578 579
};

580 581 582 583 584 585 586
/*
 * 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)

587 588
extern struct tracer nop_trace;

589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
/**
 * 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.
 *
 * To prevent this, we read the need_recshed flag before
 * 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.
 *
 * The rational for doing the above is that if need resched is set
 * 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.
 * If resched is set, then we were either inside an atomic or
 * 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();
}

637
#ifdef CONFIG_BRANCH_TRACER
638 639 640
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)
641
{
642 643
	if (trace_flags & TRACE_ITER_BRANCH)
		return enable_branch_tracing(tr);
644 645
	return 0;
}
646
static inline void trace_branch_disable(void)
647 648
{
	/* due to races, always disable */
649
	disable_branch_tracing();
650 651
}
#else
652
static inline int trace_branch_enable(struct trace_array *tr)
653 654 655
{
	return 0;
}
656
static inline void trace_branch_disable(void)
657 658
{
}
659
#endif /* CONFIG_BRANCH_TRACER */
660

661
#endif /* _LINUX_KERNEL_TRACE_H */