ftrace_event.h 20.1 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

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

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

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

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

34 35 36 37 38 39 40
#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

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

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

47 48 49 50 51 52
struct trace_iterator;
struct trace_event;

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

53 54 55 56 57 58 59
/*
 * 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 {
60
	unsigned short		type;
61 62 63 64 65
	unsigned char		flags;
	unsigned char		preempt_count;
	int			pid;
};

66 67 68
#define FTRACE_MAX_EVENT						\
	((1 << (sizeof(((struct trace_entry *)0)->type) * 8)) - 1)

69 70 71 72 73 74 75
/*
 * 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;
76
	struct trace_buffer	*trace_buffer;
77 78 79
	void			*private;
	int			cpu_file;
	struct mutex		mutex;
80
	struct ring_buffer_iter	**buffer_iter;
81
	unsigned long		iter_flags;
82

83 84 85
	/* trace_seq for __print_flags() and __print_symbolic() etc. */
	struct trace_seq	tmp_seq;

86 87 88 89 90
	cpumask_var_t		started;

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

91 92 93
	/* The below is zeroed out in pipe_read */
	struct trace_seq	seq;
	struct trace_entry	*ent;
94
	unsigned long		lost_events;
95
	int			leftover;
96
	int			ent_size;
97 98 99 100 101 102
	int			cpu;
	u64			ts;

	loff_t			pos;
	long			idx;

103
	/* All new field here will be zeroed out in pipe_read */
104 105
};

106 107 108 109 110 111
enum trace_iter_flags {
	TRACE_FILE_LAT_FMT	= 1,
	TRACE_FILE_ANNOTATE	= 2,
	TRACE_FILE_TIME_IN_NS	= 4,
};

112 113

typedef enum print_line_t (*trace_print_func)(struct trace_iterator *iter,
114 115 116
				      int flags, struct trace_event *event);

struct trace_event_functions {
117 118 119 120 121 122
	trace_print_func	trace;
	trace_print_func	raw;
	trace_print_func	hex;
	trace_print_func	binary;
};

123 124 125 126 127 128 129
struct trace_event {
	struct hlist_node		node;
	struct list_head		list;
	int				type;
	struct trace_event_functions	*funcs;
};

130 131 132 133 134 135 136 137 138 139 140
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 */
};

141 142 143
void tracing_generic_entry_update(struct trace_entry *entry,
				  unsigned long flags,
				  int pc);
144 145 146 147 148 149 150
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);
151
struct ring_buffer_event *
152 153
trace_current_buffer_lock_reserve(struct ring_buffer **current_buffer,
				  int type, unsigned long len,
154
				  unsigned long flags, int pc);
155 156
void trace_current_buffer_unlock_commit(struct ring_buffer *buffer,
					struct ring_buffer_event *event,
157
					unsigned long flags, int pc);
158 159 160 161 162 163 164
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);
165 166
void trace_current_buffer_discard_commit(struct ring_buffer *buffer,
					 struct ring_buffer_event *event);
167 168 169

void tracing_record_cmdline(struct task_struct *tsk);

170 171
int ftrace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...);

172 173
struct event_filter;

174 175 176
enum trace_reg {
	TRACE_REG_REGISTER,
	TRACE_REG_UNREGISTER,
177
#ifdef CONFIG_PERF_EVENTS
178 179
	TRACE_REG_PERF_REGISTER,
	TRACE_REG_PERF_UNREGISTER,
180 181
	TRACE_REG_PERF_OPEN,
	TRACE_REG_PERF_CLOSE,
182 183
	TRACE_REG_PERF_ADD,
	TRACE_REG_PERF_DEL,
184
#endif
185 186 187 188
};

struct ftrace_event_call;

189 190
struct ftrace_event_class {
	char			*system;
191 192 193 194 195
	void			*probe;
#ifdef CONFIG_PERF_EVENTS
	void			*perf_probe;
#endif
	int			(*reg)(struct ftrace_event_call *event,
196
				       enum trace_reg type, void *data);
197 198 199
	int			(*define_fields)(struct ftrace_event_call *);
	struct list_head	*(*get_fields)(struct ftrace_event_call *);
	struct list_head	fields;
200
	int			(*raw_init)(struct ftrace_event_call *);
201 202
};

203
extern int ftrace_event_reg(struct ftrace_event_call *event,
204
			    enum trace_reg type, void *data);
205

206 207 208
int ftrace_output_event(struct trace_iterator *iter, struct ftrace_event_call *event,
			char *fmt, ...);

209 210 211 212
int ftrace_event_define_field(struct ftrace_event_call *call,
			      char *type, int len, char *item, int offset,
			      int field_size, int sign, int filter);

213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
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);

228 229 230 231
int ftrace_event_define_field(struct ftrace_event_call *call,
			      char *type, int len, char *item, int offset,
			      int field_size, int sign, int filter);

232 233
enum {
	TRACE_EVENT_FL_FILTERED_BIT,
234
	TRACE_EVENT_FL_CAP_ANY_BIT,
L
Li Zefan 已提交
235
	TRACE_EVENT_FL_NO_SET_FILTER_BIT,
236
	TRACE_EVENT_FL_IGNORE_ENABLE_BIT,
237
	TRACE_EVENT_FL_WAS_ENABLED_BIT,
238
	TRACE_EVENT_FL_USE_CALL_FILTER_BIT,
239
	TRACE_EVENT_FL_TRACEPOINT_BIT,
240 241
};

242 243 244 245 246
/*
 * 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
247
 *  IGNORE_ENABLE - For ftrace internal events, do not enable with debugfs file
248 249 250
 *  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).
251
 *  USE_CALL_FILTER - For ftrace internal events, don't use file filter
252
 *  TRACEPOINT    - Event is a tracepoint
253
 */
254
enum {
255
	TRACE_EVENT_FL_FILTERED		= (1 << TRACE_EVENT_FL_FILTERED_BIT),
256
	TRACE_EVENT_FL_CAP_ANY		= (1 << TRACE_EVENT_FL_CAP_ANY_BIT),
L
Li Zefan 已提交
257
	TRACE_EVENT_FL_NO_SET_FILTER	= (1 << TRACE_EVENT_FL_NO_SET_FILTER_BIT),
258
	TRACE_EVENT_FL_IGNORE_ENABLE	= (1 << TRACE_EVENT_FL_IGNORE_ENABLE_BIT),
259
	TRACE_EVENT_FL_WAS_ENABLED	= (1 << TRACE_EVENT_FL_WAS_ENABLED_BIT),
260
	TRACE_EVENT_FL_USE_CALL_FILTER	= (1 << TRACE_EVENT_FL_USE_CALL_FILTER_BIT),
261
	TRACE_EVENT_FL_TRACEPOINT	= (1 << TRACE_EVENT_FL_TRACEPOINT_BIT),
262 263
};

264
struct ftrace_event_call {
265
	struct list_head	list;
266
	struct ftrace_event_class *class;
267 268 269 270 271
	union {
		char			*name;
		/* Set TRACE_EVENT_FL_TRACEPOINT flag when using "tp" */
		struct tracepoint	*tp;
	};
272
	struct trace_event	event;
L
Lai Jiangshan 已提交
273
	const char		*print_fmt;
274
	struct event_filter	*filter;
275
	struct list_head	*files;
276
	void			*mod;
277
	void			*data;
278 279 280 281 282 283
	/*
	 *   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
284
	 *   bit 5:		use call filter rather than file filter
285
	 *   bit 6:		Event is a tracepoint
286
	 */
287 288 289 290 291
	int			flags; /* static flags of different events */

#ifdef CONFIG_PERF_EVENTS
	int				perf_refcount;
	struct hlist_head __percpu	*perf_events;
292 293 294

	int	(*perf_perm)(struct ftrace_event_call *,
			     struct perf_event *);
295 296 297
#endif
};

298 299 300 301 302 303 304 305 306
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;
}

307 308 309 310 311 312
struct trace_array;
struct ftrace_subsystem_dir;

enum {
	FTRACE_EVENT_FL_ENABLED_BIT,
	FTRACE_EVENT_FL_RECORDED_CMD_BIT,
313 314
	FTRACE_EVENT_FL_FILTERED_BIT,
	FTRACE_EVENT_FL_NO_SET_FILTER_BIT,
315 316
	FTRACE_EVENT_FL_SOFT_MODE_BIT,
	FTRACE_EVENT_FL_SOFT_DISABLED_BIT,
317
	FTRACE_EVENT_FL_TRIGGER_MODE_BIT,
318
	FTRACE_EVENT_FL_TRIGGER_COND_BIT,
319 320 321 322
};

/*
 * Ftrace event file flags:
323
 *  ENABLED	  - The event is enabled
324
 *  RECORDED_CMD  - The comms should be recorded at sched_switch
325 326
 *  FILTERED	  - The event has a filter attached
 *  NO_SET_FILTER - Set when filter has error and is to be ignored
327 328 329
 *  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)
330
 *  TRIGGER_MODE  - When set, invoke the triggers associated with the event
331
 *  TRIGGER_COND  - When set, one or more triggers has an associated filter
332 333 334 335
 */
enum {
	FTRACE_EVENT_FL_ENABLED		= (1 << FTRACE_EVENT_FL_ENABLED_BIT),
	FTRACE_EVENT_FL_RECORDED_CMD	= (1 << FTRACE_EVENT_FL_RECORDED_CMD_BIT),
336 337
	FTRACE_EVENT_FL_FILTERED	= (1 << FTRACE_EVENT_FL_FILTERED_BIT),
	FTRACE_EVENT_FL_NO_SET_FILTER	= (1 << FTRACE_EVENT_FL_NO_SET_FILTER_BIT),
338 339
	FTRACE_EVENT_FL_SOFT_MODE	= (1 << FTRACE_EVENT_FL_SOFT_MODE_BIT),
	FTRACE_EVENT_FL_SOFT_DISABLED	= (1 << FTRACE_EVENT_FL_SOFT_DISABLED_BIT),
340
	FTRACE_EVENT_FL_TRIGGER_MODE	= (1 << FTRACE_EVENT_FL_TRIGGER_MODE_BIT),
341
	FTRACE_EVENT_FL_TRIGGER_COND	= (1 << FTRACE_EVENT_FL_TRIGGER_COND_BIT),
342 343 344 345 346
};

struct ftrace_event_file {
	struct list_head		list;
	struct ftrace_event_call	*event_call;
347
	struct event_filter		*filter;
348 349 350
	struct dentry			*dir;
	struct trace_array		*tr;
	struct ftrace_subsystem_dir	*system;
351
	struct list_head		triggers;
352

353 354
	/*
	 * 32 bit flags:
355 356
	 *   bit 0:		enabled
	 *   bit 1:		enabled cmd record
357 358
	 *   bit 2:		enable/disable with the soft disable bit
	 *   bit 3:		soft disabled
359
	 *   bit 4:		trigger enabled
360
	 *
361 362 363
	 * 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
364
	 * is currently used, these changes do not affect the code
365 366
	 * except that when a change is made, it may have a slight
	 * delay in propagating the changes to other CPUs due to
367
	 * caching and such. Which is mostly OK ;-)
368
	 */
369
	unsigned long		flags;
370
	atomic_t		sm_ref;	/* soft-mode reference counter */
371
	atomic_t		tm_ref;	/* trigger-mode reference counter */
372 373
};

374 375 376
#define __TRACE_EVENT_FLAGS(name, value)				\
	static int __init trace_init_flags_##name(void)			\
	{								\
377
		event_##name.flags |= value;				\
378 379 380 381
		return 0;						\
	}								\
	early_initcall(trace_init_flags_##name);

382 383 384 385 386 387 388 389 390 391 392 393 394
#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);

395
#define PERF_MAX_TRACE_SIZE	2048
396

397
#define MAX_FILTER_STR_VAL	256	/* Should handle KSYM_SYMBOL_LEN */
398

399 400
enum event_trigger_type {
	ETT_NONE		= (0),
401
	ETT_TRACE_ONOFF		= (1 << 0),
402
	ETT_SNAPSHOT		= (1 << 1),
403
	ETT_STACKTRACE		= (1 << 2),
404
	ETT_EVENT_ENABLE	= (1 << 3),
405 406
};

407 408
extern void destroy_preds(struct ftrace_event_file *file);
extern void destroy_call_preds(struct ftrace_event_call *call);
L
Li Zefan 已提交
409
extern int filter_match_preds(struct event_filter *filter, void *rec);
410 411 412 413 414 415 416

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);
417 418 419 420
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);
421

422 423 424 425 426 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
/**
 * 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);
}

539 540 541 542
enum {
	FILTER_OTHER = 0,
	FILTER_STATIC_STRING,
	FILTER_DYN_STRING,
543
	FILTER_PTR_STRING,
544
	FILTER_TRACE_FN,
545 546
};

547
extern int trace_event_raw_init(struct ftrace_event_call *call);
548 549 550
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);
551
extern int trace_add_event_call(struct ftrace_event_call *call);
552
extern int trace_remove_event_call(struct ftrace_event_call *call);
553

554
#define is_signed_type(type)	(((type)(-1)) < (type)1)
555

556 557
int trace_set_clr_event(const char *system, const char *event, int set);

558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576
/*
 * 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)

577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610
/**
 * tracepoint_string - register constant persistent string to trace system
 * @str - a constant persistent string that will be referenced in tracepoints
 *
 * If constant strings are being used in tracepoints, it is faster and
 * more efficient to just save the pointer to the string and reference
 * that with a printf "%s" instead of saving the string in the ring buffer
 * and wasting space and time.
 *
 * The problem with the above approach is that userspace tools that read
 * the binary output of the trace buffers do not have access to the string.
 * Instead they just show the address of the string which is not very
 * useful to users.
 *
 * With tracepoint_string(), the string will be registered to the tracing
 * system and exported to userspace via the debugfs/tracing/printk_formats
 * file that maps the string address to the string text. This way userspace
 * tools that read the binary buffers have a way to map the pointers to
 * the ASCII strings they represent.
 *
 * The @str used must be a constant string and persistent as it would not
 * make sense to show a string that no longer exists. But it is still fine
 * to be used with modules, because when modules are unloaded, if they
 * had tracepoints, the ring buffers are cleared too. As long as the string
 * does not change during the life of the module, it is fine to use
 * tracepoint_string() within a module.
 */
#define tracepoint_string(str)						\
	({								\
		static const char *___tp_str __tracepoint_string = str; \
		___tp_str;						\
	})
#define __tracepoint_string	__attribute__((section("__tracepoint_str")))

611
#ifdef CONFIG_PERF_EVENTS
L
Li Zefan 已提交
612
struct perf_event;
613 614 615

DECLARE_PER_CPU(struct pt_regs, perf_trace_regs);

616 617
extern int  perf_trace_init(struct perf_event *event);
extern void perf_trace_destroy(struct perf_event *event);
P
Peter Zijlstra 已提交
618 619
extern int  perf_trace_add(struct perf_event *event, int flags);
extern void perf_trace_del(struct perf_event *event, int flags);
620
extern int  ftrace_profile_set_filter(struct perf_event *event, int event_id,
L
Li Zefan 已提交
621 622
				     char *filter_str);
extern void ftrace_profile_free_filter(struct perf_event *event);
623 624
extern void *perf_trace_buf_prepare(int size, unsigned short type,
				    struct pt_regs *regs, int *rctxp);
625 626

static inline void
627
perf_trace_buf_submit(void *raw_data, int size, int rctx, u64 addr,
628 629
		       u64 count, struct pt_regs *regs, void *head,
		       struct task_struct *task)
630
{
631
	perf_tp_event(addr, count, raw_data, size, regs, head, rctx, task);
632
}
L
Li Zefan 已提交
633 634
#endif

635
#endif /* _LINUX_FTRACE_EVENT_H */