trace_events.h 18.8 KB
Newer Older
1

2 3 4 5
#ifndef _LINUX_FTRACE_EVENT_H
#define _LINUX_FTRACE_EVENT_H

#include <linux/ring_buffer.h>
6
#include <linux/trace_seq.h>
7
#include <linux/percpu.h>
8
#include <linux/hardirq.h>
9
#include <linux/perf_event.h>
10
#include <linux/tracepoint.h>
11 12

struct trace_array;
13
struct trace_buffer;
14
struct tracer;
15
struct dentry;
16
struct bpf_prog;
17

18 19 20 21 22
struct trace_print_flags {
	unsigned long		mask;
	const char		*name;
};

23 24 25 26 27
struct trace_print_flags_u64 {
	unsigned long long	mask;
	const char		*name;
};

28 29 30 31
const char *ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
				   unsigned long flags,
				   const struct trace_print_flags *flag_array);

32 33 34
const char *ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
				     const struct trace_print_flags *symbol_array);

35 36 37 38 39 40 41
#if BITS_PER_LONG == 32
const char *ftrace_print_symbols_seq_u64(struct trace_seq *p,
					 unsigned long long val,
					 const struct trace_print_flags_u64
								 *symbol_array);
#endif

42 43 44
const char *ftrace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr,
				     unsigned int bitmask_size);

K
Kei Tokunaga 已提交
45 46 47
const char *ftrace_print_hex_seq(struct trace_seq *p,
				 const unsigned char *buf, int len);

D
Dave Martin 已提交
48
const char *ftrace_print_array_seq(struct trace_seq *p,
49
				   const void *buf, int count,
D
Dave Martin 已提交
50 51
				   size_t el_size);

52 53 54 55 56 57
struct trace_iterator;
struct trace_event;

int ftrace_raw_output_prep(struct trace_iterator *iter,
			   struct trace_event *event);

58 59 60 61 62 63 64
/*
 * 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 {
65
	unsigned short		type;
66 67 68 69 70
	unsigned char		flags;
	unsigned char		preempt_count;
	int			pid;
};

71 72 73
#define FTRACE_MAX_EVENT						\
	((1 << (sizeof(((struct trace_entry *)0)->type) * 8)) - 1)

74 75 76 77 78 79 80
/*
 * 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;
81
	struct trace_buffer	*trace_buffer;
82 83 84
	void			*private;
	int			cpu_file;
	struct mutex		mutex;
85
	struct ring_buffer_iter	**buffer_iter;
86
	unsigned long		iter_flags;
87

88 89 90
	/* trace_seq for __print_flags() and __print_symbolic() etc. */
	struct trace_seq	tmp_seq;

91 92 93 94 95
	cpumask_var_t		started;

	/* it's true when current open file is snapshot */
	bool			snapshot;

96 97 98
	/* The below is zeroed out in pipe_read */
	struct trace_seq	seq;
	struct trace_entry	*ent;
99
	unsigned long		lost_events;
100
	int			leftover;
101
	int			ent_size;
102 103 104 105 106 107
	int			cpu;
	u64			ts;

	loff_t			pos;
	long			idx;

108
	/* All new field here will be zeroed out in pipe_read */
109 110
};

111 112 113 114 115 116
enum trace_iter_flags {
	TRACE_FILE_LAT_FMT	= 1,
	TRACE_FILE_ANNOTATE	= 2,
	TRACE_FILE_TIME_IN_NS	= 4,
};

117 118

typedef enum print_line_t (*trace_print_func)(struct trace_iterator *iter,
119 120 121
				      int flags, struct trace_event *event);

struct trace_event_functions {
122 123 124 125 126 127
	trace_print_func	trace;
	trace_print_func	raw;
	trace_print_func	hex;
	trace_print_func	binary;
};

128 129 130 131 132 133 134
struct trace_event {
	struct hlist_node		node;
	struct list_head		list;
	int				type;
	struct trace_event_functions	*funcs;
};

135 136 137 138 139 140 141 142 143 144 145
extern int register_ftrace_event(struct trace_event *event);
extern int unregister_ftrace_event(struct trace_event *event);

/* 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 */
	TRACE_TYPE_NO_CONSUME	= 3	/* Handled but ask to not consume */
};

146 147 148 149 150 151 152 153 154 155 156
/*
 * Several functions return TRACE_TYPE_PARTIAL_LINE if the trace_seq
 * overflowed, and TRACE_TYPE_HANDLED otherwise. This helper function
 * simplifies those functions and keeps them in sync.
 */
static inline enum print_line_t trace_handle_return(struct trace_seq *s)
{
	return trace_seq_has_overflowed(s) ?
		TRACE_TYPE_PARTIAL_LINE : TRACE_TYPE_HANDLED;
}

157 158 159
void tracing_generic_entry_update(struct trace_entry *entry,
				  unsigned long flags,
				  int pc);
160 161 162 163 164 165 166
struct ftrace_event_file;

struct ring_buffer_event *
trace_event_buffer_lock_reserve(struct ring_buffer **current_buffer,
				struct ftrace_event_file *ftrace_file,
				int type, unsigned long len,
				unsigned long flags, int pc);
167
struct ring_buffer_event *
168 169
trace_current_buffer_lock_reserve(struct ring_buffer **current_buffer,
				  int type, unsigned long len,
170
				  unsigned long flags, int pc);
171 172
void trace_current_buffer_unlock_commit(struct ring_buffer *buffer,
					struct ring_buffer_event *event,
173
					unsigned long flags, int pc);
174 175 176 177 178 179 180
void trace_buffer_unlock_commit(struct ring_buffer *buffer,
				struct ring_buffer_event *event,
				unsigned long flags, int pc);
void trace_buffer_unlock_commit_regs(struct ring_buffer *buffer,
				     struct ring_buffer_event *event,
				     unsigned long flags, int pc,
				     struct pt_regs *regs);
181 182
void trace_current_buffer_discard_commit(struct ring_buffer *buffer,
					 struct ring_buffer_event *event);
183 184 185

void tracing_record_cmdline(struct task_struct *tsk);

186 187
int ftrace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...);

188 189
struct event_filter;

190 191 192
enum trace_reg {
	TRACE_REG_REGISTER,
	TRACE_REG_UNREGISTER,
193
#ifdef CONFIG_PERF_EVENTS
194 195
	TRACE_REG_PERF_REGISTER,
	TRACE_REG_PERF_UNREGISTER,
196 197
	TRACE_REG_PERF_OPEN,
	TRACE_REG_PERF_CLOSE,
198 199
	TRACE_REG_PERF_ADD,
	TRACE_REG_PERF_DEL,
200
#endif
201 202 203 204
};

struct ftrace_event_call;

205
struct ftrace_event_class {
206
	const char		*system;
207 208 209 210 211
	void			*probe;
#ifdef CONFIG_PERF_EVENTS
	void			*perf_probe;
#endif
	int			(*reg)(struct ftrace_event_call *event,
212
				       enum trace_reg type, void *data);
213 214 215
	int			(*define_fields)(struct ftrace_event_call *);
	struct list_head	*(*get_fields)(struct ftrace_event_call *);
	struct list_head	fields;
216
	int			(*raw_init)(struct ftrace_event_call *);
217 218
};

219
extern int ftrace_event_reg(struct ftrace_event_call *event,
220
			    enum trace_reg type, void *data);
221

222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
struct ftrace_event_buffer {
	struct ring_buffer		*buffer;
	struct ring_buffer_event	*event;
	struct ftrace_event_file	*ftrace_file;
	void				*entry;
	unsigned long			flags;
	int				pc;
};

void *ftrace_event_buffer_reserve(struct ftrace_event_buffer *fbuffer,
				  struct ftrace_event_file *ftrace_file,
				  unsigned long len);

void ftrace_event_buffer_commit(struct ftrace_event_buffer *fbuffer);

237 238
enum {
	TRACE_EVENT_FL_FILTERED_BIT,
239
	TRACE_EVENT_FL_CAP_ANY_BIT,
L
Li Zefan 已提交
240
	TRACE_EVENT_FL_NO_SET_FILTER_BIT,
241
	TRACE_EVENT_FL_IGNORE_ENABLE_BIT,
242
	TRACE_EVENT_FL_WAS_ENABLED_BIT,
243
	TRACE_EVENT_FL_USE_CALL_FILTER_BIT,
244
	TRACE_EVENT_FL_TRACEPOINT_BIT,
A
Alexei Starovoitov 已提交
245
	TRACE_EVENT_FL_KPROBE_BIT,
246 247
};

248 249 250 251 252
/*
 * Event flags:
 *  FILTERED	  - The event has a filter attached
 *  CAP_ANY	  - Any user can enable for perf
 *  NO_SET_FILTER - Set when filter has error and is to be ignored
253
 *  IGNORE_ENABLE - For ftrace internal events, do not enable with debugfs file
254 255 256
 *  WAS_ENABLED   - Set and stays set when an event was ever enabled
 *                    (used for module unloading, if a module event is enabled,
 *                     it is best to clear the buffers that used it).
257
 *  USE_CALL_FILTER - For ftrace internal events, don't use file filter
258
 *  TRACEPOINT    - Event is a tracepoint
A
Alexei Starovoitov 已提交
259
 *  KPROBE        - Event is a kprobe
260
 */
261
enum {
262
	TRACE_EVENT_FL_FILTERED		= (1 << TRACE_EVENT_FL_FILTERED_BIT),
263
	TRACE_EVENT_FL_CAP_ANY		= (1 << TRACE_EVENT_FL_CAP_ANY_BIT),
L
Li Zefan 已提交
264
	TRACE_EVENT_FL_NO_SET_FILTER	= (1 << TRACE_EVENT_FL_NO_SET_FILTER_BIT),
265
	TRACE_EVENT_FL_IGNORE_ENABLE	= (1 << TRACE_EVENT_FL_IGNORE_ENABLE_BIT),
266
	TRACE_EVENT_FL_WAS_ENABLED	= (1 << TRACE_EVENT_FL_WAS_ENABLED_BIT),
267
	TRACE_EVENT_FL_USE_CALL_FILTER	= (1 << TRACE_EVENT_FL_USE_CALL_FILTER_BIT),
268
	TRACE_EVENT_FL_TRACEPOINT	= (1 << TRACE_EVENT_FL_TRACEPOINT_BIT),
A
Alexei Starovoitov 已提交
269
	TRACE_EVENT_FL_KPROBE		= (1 << TRACE_EVENT_FL_KPROBE_BIT),
270 271
};

272
struct ftrace_event_call {
273
	struct list_head	list;
274
	struct ftrace_event_class *class;
275 276 277 278 279
	union {
		char			*name;
		/* Set TRACE_EVENT_FL_TRACEPOINT flag when using "tp" */
		struct tracepoint	*tp;
	};
280
	struct trace_event	event;
281
	char			*print_fmt;
282
	struct event_filter	*filter;
283
	void			*mod;
284
	void			*data;
285 286 287 288 289 290
	/*
	 *   bit 0:		filter_active
	 *   bit 1:		allow trace by non root (cap any)
	 *   bit 2:		failed to apply filter
	 *   bit 3:		ftrace internal event (do not enable)
	 *   bit 4:		Event was enabled by module
291
	 *   bit 5:		use call filter rather than file filter
292
	 *   bit 6:		Event is a tracepoint
293
	 */
294 295 296 297 298
	int			flags; /* static flags of different events */

#ifdef CONFIG_PERF_EVENTS
	int				perf_refcount;
	struct hlist_head __percpu	*perf_events;
299
	struct bpf_prog			*prog;
300 301 302

	int	(*perf_perm)(struct ftrace_event_call *,
			     struct perf_event *);
303 304 305
#endif
};

306 307 308 309 310 311 312 313 314
static inline const char *
ftrace_event_name(struct ftrace_event_call *call)
{
	if (call->flags & TRACE_EVENT_FL_TRACEPOINT)
		return call->tp ? call->tp->name : NULL;
	else
		return call->name;
}

315 316 317 318 319 320
struct trace_array;
struct ftrace_subsystem_dir;

enum {
	FTRACE_EVENT_FL_ENABLED_BIT,
	FTRACE_EVENT_FL_RECORDED_CMD_BIT,
321 322
	FTRACE_EVENT_FL_FILTERED_BIT,
	FTRACE_EVENT_FL_NO_SET_FILTER_BIT,
323 324
	FTRACE_EVENT_FL_SOFT_MODE_BIT,
	FTRACE_EVENT_FL_SOFT_DISABLED_BIT,
325
	FTRACE_EVENT_FL_TRIGGER_MODE_BIT,
326
	FTRACE_EVENT_FL_TRIGGER_COND_BIT,
327 328 329 330
};

/*
 * Ftrace event file flags:
331
 *  ENABLED	  - The event is enabled
332
 *  RECORDED_CMD  - The comms should be recorded at sched_switch
333 334
 *  FILTERED	  - The event has a filter attached
 *  NO_SET_FILTER - Set when filter has error and is to be ignored
335 336 337
 *  SOFT_MODE     - The event is enabled/disabled by SOFT_DISABLED
 *  SOFT_DISABLED - When set, do not trace the event (even though its
 *                   tracepoint may be enabled)
338
 *  TRIGGER_MODE  - When set, invoke the triggers associated with the event
339
 *  TRIGGER_COND  - When set, one or more triggers has an associated filter
340 341 342 343
 */
enum {
	FTRACE_EVENT_FL_ENABLED		= (1 << FTRACE_EVENT_FL_ENABLED_BIT),
	FTRACE_EVENT_FL_RECORDED_CMD	= (1 << FTRACE_EVENT_FL_RECORDED_CMD_BIT),
344 345
	FTRACE_EVENT_FL_FILTERED	= (1 << FTRACE_EVENT_FL_FILTERED_BIT),
	FTRACE_EVENT_FL_NO_SET_FILTER	= (1 << FTRACE_EVENT_FL_NO_SET_FILTER_BIT),
346 347
	FTRACE_EVENT_FL_SOFT_MODE	= (1 << FTRACE_EVENT_FL_SOFT_MODE_BIT),
	FTRACE_EVENT_FL_SOFT_DISABLED	= (1 << FTRACE_EVENT_FL_SOFT_DISABLED_BIT),
348
	FTRACE_EVENT_FL_TRIGGER_MODE	= (1 << FTRACE_EVENT_FL_TRIGGER_MODE_BIT),
349
	FTRACE_EVENT_FL_TRIGGER_COND	= (1 << FTRACE_EVENT_FL_TRIGGER_COND_BIT),
350 351 352 353 354
};

struct ftrace_event_file {
	struct list_head		list;
	struct ftrace_event_call	*event_call;
355
	struct event_filter		*filter;
356 357 358
	struct dentry			*dir;
	struct trace_array		*tr;
	struct ftrace_subsystem_dir	*system;
359
	struct list_head		triggers;
360

361 362
	/*
	 * 32 bit flags:
363 364
	 *   bit 0:		enabled
	 *   bit 1:		enabled cmd record
365 366
	 *   bit 2:		enable/disable with the soft disable bit
	 *   bit 3:		soft disabled
367
	 *   bit 4:		trigger enabled
368
	 *
369 370 371
	 * Note: The bits must be set atomically to prevent races
	 * from other writers. Reads of flags do not need to be in
	 * sync as they occur in critical sections. But the way flags
372
	 * is currently used, these changes do not affect the code
373 374
	 * except that when a change is made, it may have a slight
	 * delay in propagating the changes to other CPUs due to
375
	 * caching and such. Which is mostly OK ;-)
376
	 */
377
	unsigned long		flags;
378
	atomic_t		sm_ref;	/* soft-mode reference counter */
379
	atomic_t		tm_ref;	/* trigger-mode reference counter */
380 381
};

382 383 384
#define __TRACE_EVENT_FLAGS(name, value)				\
	static int __init trace_init_flags_##name(void)			\
	{								\
385
		event_##name.flags |= value;				\
386 387 388 389
		return 0;						\
	}								\
	early_initcall(trace_init_flags_##name);

390 391 392 393 394 395 396 397 398 399 400 401 402
#define __TRACE_EVENT_PERF_PERM(name, expr...)				\
	static int perf_perm_##name(struct ftrace_event_call *tp_event, \
				    struct perf_event *p_event)		\
	{								\
		return ({ expr; });					\
	}								\
	static int __init trace_init_perf_perm_##name(void)		\
	{								\
		event_##name.perf_perm = &perf_perm_##name;		\
		return 0;						\
	}								\
	early_initcall(trace_init_perf_perm_##name);

403
#define PERF_MAX_TRACE_SIZE	2048
404

405
#define MAX_FILTER_STR_VAL	256	/* Should handle KSYM_SYMBOL_LEN */
406

407 408
enum event_trigger_type {
	ETT_NONE		= (0),
409
	ETT_TRACE_ONOFF		= (1 << 0),
410
	ETT_SNAPSHOT		= (1 << 1),
411
	ETT_STACKTRACE		= (1 << 2),
412
	ETT_EVENT_ENABLE	= (1 << 3),
413 414
};

L
Li Zefan 已提交
415
extern int filter_match_preds(struct event_filter *filter, void *rec);
416 417 418 419 420 421 422

extern int filter_check_discard(struct ftrace_event_file *file, void *rec,
				struct ring_buffer *buffer,
				struct ring_buffer_event *event);
extern int call_filter_check_discard(struct ftrace_event_call *call, void *rec,
				     struct ring_buffer *buffer,
				     struct ring_buffer_event *event);
423 424 425 426
extern enum event_trigger_type event_triggers_call(struct ftrace_event_file *file,
						   void *rec);
extern void event_triggers_post_call(struct ftrace_event_file *file,
				     enum event_trigger_type tt);
427

428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544
/**
 * ftrace_trigger_soft_disabled - do triggers and test if soft disabled
 * @file: The file pointer of the event to test
 *
 * If any triggers without filters are attached to this event, they
 * will be called here. If the event is soft disabled and has no
 * triggers that require testing the fields, it will return true,
 * otherwise false.
 */
static inline bool
ftrace_trigger_soft_disabled(struct ftrace_event_file *file)
{
	unsigned long eflags = file->flags;

	if (!(eflags & FTRACE_EVENT_FL_TRIGGER_COND)) {
		if (eflags & FTRACE_EVENT_FL_TRIGGER_MODE)
			event_triggers_call(file, NULL);
		if (eflags & FTRACE_EVENT_FL_SOFT_DISABLED)
			return true;
	}
	return false;
}

/*
 * Helper function for event_trigger_unlock_commit{_regs}().
 * If there are event triggers attached to this event that requires
 * filtering against its fields, then they wil be called as the
 * entry already holds the field information of the current event.
 *
 * It also checks if the event should be discarded or not.
 * It is to be discarded if the event is soft disabled and the
 * event was only recorded to process triggers, or if the event
 * filter is active and this event did not match the filters.
 *
 * Returns true if the event is discarded, false otherwise.
 */
static inline bool
__event_trigger_test_discard(struct ftrace_event_file *file,
			     struct ring_buffer *buffer,
			     struct ring_buffer_event *event,
			     void *entry,
			     enum event_trigger_type *tt)
{
	unsigned long eflags = file->flags;

	if (eflags & FTRACE_EVENT_FL_TRIGGER_COND)
		*tt = event_triggers_call(file, entry);

	if (test_bit(FTRACE_EVENT_FL_SOFT_DISABLED_BIT, &file->flags))
		ring_buffer_discard_commit(buffer, event);
	else if (!filter_check_discard(file, entry, buffer, event))
		return false;

	return true;
}

/**
 * event_trigger_unlock_commit - handle triggers and finish event commit
 * @file: The file pointer assoctiated to the event
 * @buffer: The ring buffer that the event is being written to
 * @event: The event meta data in the ring buffer
 * @entry: The event itself
 * @irq_flags: The state of the interrupts at the start of the event
 * @pc: The state of the preempt count at the start of the event.
 *
 * This is a helper function to handle triggers that require data
 * from the event itself. It also tests the event against filters and
 * if the event is soft disabled and should be discarded.
 */
static inline void
event_trigger_unlock_commit(struct ftrace_event_file *file,
			    struct ring_buffer *buffer,
			    struct ring_buffer_event *event,
			    void *entry, unsigned long irq_flags, int pc)
{
	enum event_trigger_type tt = ETT_NONE;

	if (!__event_trigger_test_discard(file, buffer, event, entry, &tt))
		trace_buffer_unlock_commit(buffer, event, irq_flags, pc);

	if (tt)
		event_triggers_post_call(file, tt);
}

/**
 * event_trigger_unlock_commit_regs - handle triggers and finish event commit
 * @file: The file pointer assoctiated to the event
 * @buffer: The ring buffer that the event is being written to
 * @event: The event meta data in the ring buffer
 * @entry: The event itself
 * @irq_flags: The state of the interrupts at the start of the event
 * @pc: The state of the preempt count at the start of the event.
 *
 * This is a helper function to handle triggers that require data
 * from the event itself. It also tests the event against filters and
 * if the event is soft disabled and should be discarded.
 *
 * Same as event_trigger_unlock_commit() but calls
 * trace_buffer_unlock_commit_regs() instead of trace_buffer_unlock_commit().
 */
static inline void
event_trigger_unlock_commit_regs(struct ftrace_event_file *file,
				 struct ring_buffer *buffer,
				 struct ring_buffer_event *event,
				 void *entry, unsigned long irq_flags, int pc,
				 struct pt_regs *regs)
{
	enum event_trigger_type tt = ETT_NONE;

	if (!__event_trigger_test_discard(file, buffer, event, entry, &tt))
		trace_buffer_unlock_commit_regs(buffer, event,
						irq_flags, pc, regs);

	if (tt)
		event_triggers_post_call(file, tt);
}

545 546 547 548 549 550 551 552 553
#ifdef CONFIG_BPF_SYSCALL
unsigned int trace_call_bpf(struct bpf_prog *prog, void *ctx);
#else
static inline unsigned int trace_call_bpf(struct bpf_prog *prog, void *ctx)
{
	return 1;
}
#endif

554 555 556 557
enum {
	FILTER_OTHER = 0,
	FILTER_STATIC_STRING,
	FILTER_DYN_STRING,
558
	FILTER_PTR_STRING,
559
	FILTER_TRACE_FN,
560 561
};

562
extern int trace_event_raw_init(struct ftrace_event_call *call);
563 564 565
extern int trace_define_field(struct ftrace_event_call *call, const char *type,
			      const char *name, int offset, int size,
			      int is_signed, int filter_type);
566
extern int trace_add_event_call(struct ftrace_event_call *call);
567
extern int trace_remove_event_call(struct ftrace_event_call *call);
568

569
#define is_signed_type(type)	(((type)(-1)) < (type)1)
570

571 572
int trace_set_clr_event(const char *system, const char *event, int set);

573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
/*
 * The double __builtin_constant_p is because gcc will give us an error
 * if we try to allocate the static variable to fmt if it is not a
 * constant. Even with the outer if statement optimizing out.
 */
#define event_trace_printk(ip, fmt, args...)				\
do {									\
	__trace_printk_check_format(fmt, ##args);			\
	tracing_record_cmdline(current);				\
	if (__builtin_constant_p(fmt)) {				\
		static const char *trace_printk_fmt			\
		  __attribute__((section("__trace_printk_fmt"))) =	\
			__builtin_constant_p(fmt) ? fmt : NULL;		\
									\
		__trace_bprintk(ip, trace_printk_fmt, ##args);		\
	} else								\
		__trace_printk(ip, fmt, ##args);			\
} while (0)

592
#ifdef CONFIG_PERF_EVENTS
L
Li Zefan 已提交
593
struct perf_event;
594 595 596

DECLARE_PER_CPU(struct pt_regs, perf_trace_regs);

597 598
extern int  perf_trace_init(struct perf_event *event);
extern void perf_trace_destroy(struct perf_event *event);
P
Peter Zijlstra 已提交
599 600
extern int  perf_trace_add(struct perf_event *event, int flags);
extern void perf_trace_del(struct perf_event *event, int flags);
601
extern int  ftrace_profile_set_filter(struct perf_event *event, int event_id,
L
Li Zefan 已提交
602 603
				     char *filter_str);
extern void ftrace_profile_free_filter(struct perf_event *event);
604
extern void *perf_trace_buf_prepare(int size, unsigned short type,
605
				    struct pt_regs **regs, int *rctxp);
606 607

static inline void
608
perf_trace_buf_submit(void *raw_data, int size, int rctx, u64 addr,
609 610
		       u64 count, struct pt_regs *regs, void *head,
		       struct task_struct *task)
611
{
612
	perf_tp_event(addr, count, raw_data, size, regs, head, rctx, task);
613
}
L
Li Zefan 已提交
614 615
#endif

616
#endif /* _LINUX_FTRACE_EVENT_H */