Branch data Line data Source code
1 : : /*
2 : : * Performance events:
3 : : *
4 : : * Copyright (C) 2008-2009, Thomas Gleixner <tglx@linutronix.de>
5 : : * Copyright (C) 2008-2011, Red Hat, Inc., Ingo Molnar
6 : : * Copyright (C) 2008-2011, Red Hat, Inc., Peter Zijlstra
7 : : *
8 : : * Data type definitions, declarations, prototypes.
9 : : *
10 : : * Started by: Thomas Gleixner and Ingo Molnar
11 : : *
12 : : * For licencing details see kernel-base/COPYING
13 : : */
14 : : #ifndef _LINUX_PERF_EVENT_H
15 : : #define _LINUX_PERF_EVENT_H
16 : :
17 : : #include <uapi/linux/perf_event.h>
18 : :
19 : : /*
20 : : * Kernel-internal data types and definitions:
21 : : */
22 : :
23 : : #ifdef CONFIG_PERF_EVENTS
24 : : # include <asm/perf_event.h>
25 : : # include <asm/local64.h>
26 : : #endif
27 : :
28 : : struct perf_guest_info_callbacks {
29 : : int (*is_in_guest)(void);
30 : : int (*is_user_mode)(void);
31 : : unsigned long (*get_guest_ip)(void);
32 : : };
33 : :
34 : : #ifdef CONFIG_HAVE_HW_BREAKPOINT
35 : : #include <asm/hw_breakpoint.h>
36 : : #endif
37 : :
38 : : #include <linux/list.h>
39 : : #include <linux/mutex.h>
40 : : #include <linux/rculist.h>
41 : : #include <linux/rcupdate.h>
42 : : #include <linux/spinlock.h>
43 : : #include <linux/hrtimer.h>
44 : : #include <linux/fs.h>
45 : : #include <linux/pid_namespace.h>
46 : : #include <linux/workqueue.h>
47 : : #include <linux/ftrace.h>
48 : : #include <linux/cpu.h>
49 : : #include <linux/irq_work.h>
50 : : #include <linux/static_key.h>
51 : : #include <linux/jump_label_ratelimit.h>
52 : : #include <linux/atomic.h>
53 : : #include <linux/sysfs.h>
54 : : #include <linux/perf_regs.h>
55 : : #include <asm/local.h>
56 : :
57 : : struct perf_callchain_entry {
58 : : __u64 nr;
59 : : __u64 ip[PERF_MAX_STACK_DEPTH];
60 : : };
61 : :
62 : : struct perf_raw_record {
63 : : u32 size;
64 : : void *data;
65 : : };
66 : :
67 : : /*
68 : : * branch stack layout:
69 : : * nr: number of taken branches stored in entries[]
70 : : *
71 : : * Note that nr can vary from sample to sample
72 : : * branches (to, from) are stored from most recent
73 : : * to least recent, i.e., entries[0] contains the most
74 : : * recent branch.
75 : : */
76 : : struct perf_branch_stack {
77 : : __u64 nr;
78 : : struct perf_branch_entry entries[0];
79 : : };
80 : :
81 : : struct perf_regs_user {
82 : : __u64 abi;
83 : : struct pt_regs *regs;
84 : : };
85 : :
86 : : struct task_struct;
87 : :
88 : : /*
89 : : * extra PMU register associated with an event
90 : : */
91 : : struct hw_perf_event_extra {
92 : : u64 config; /* register value */
93 : : unsigned int reg; /* register address or index */
94 : : int alloc; /* extra register already allocated */
95 : : int idx; /* index in shared_regs->regs[] */
96 : : };
97 : :
98 : : struct event_constraint;
99 : :
100 : : /**
101 : : * struct hw_perf_event - performance event hardware details:
102 : : */
103 : : struct hw_perf_event {
104 : : #ifdef CONFIG_PERF_EVENTS
105 : : union {
106 : : struct { /* hardware */
107 : : u64 config;
108 : : u64 last_tag;
109 : : unsigned long config_base;
110 : : unsigned long event_base;
111 : : int event_base_rdpmc;
112 : : int idx;
113 : : int last_cpu;
114 : : int flags;
115 : :
116 : : struct hw_perf_event_extra extra_reg;
117 : : struct hw_perf_event_extra branch_reg;
118 : :
119 : : struct event_constraint *constraint;
120 : : };
121 : : struct { /* software */
122 : : struct hrtimer hrtimer;
123 : : };
124 : : struct { /* tracepoint */
125 : : struct task_struct *tp_target;
126 : : /* for tp_event->class */
127 : : struct list_head tp_list;
128 : : };
129 : : #ifdef CONFIG_HAVE_HW_BREAKPOINT
130 : : struct { /* breakpoint */
131 : : /*
132 : : * Crufty hack to avoid the chicken and egg
133 : : * problem hw_breakpoint has with context
134 : : * creation and event initalization.
135 : : */
136 : : struct task_struct *bp_target;
137 : : struct arch_hw_breakpoint info;
138 : : struct list_head bp_list;
139 : : };
140 : : #endif
141 : : };
142 : : int state;
143 : : local64_t prev_count;
144 : : u64 sample_period;
145 : : u64 last_period;
146 : : local64_t period_left;
147 : : u64 interrupts_seq;
148 : : u64 interrupts;
149 : :
150 : : u64 freq_time_stamp;
151 : : u64 freq_count_stamp;
152 : : #endif
153 : : };
154 : :
155 : : /*
156 : : * hw_perf_event::state flags
157 : : */
158 : : #define PERF_HES_STOPPED 0x01 /* the counter is stopped */
159 : : #define PERF_HES_UPTODATE 0x02 /* event->count up-to-date */
160 : : #define PERF_HES_ARCH 0x04
161 : :
162 : : struct perf_event;
163 : :
164 : : /*
165 : : * Common implementation detail of pmu::{start,commit,cancel}_txn
166 : : */
167 : : #define PERF_EVENT_TXN 0x1
168 : :
169 : : /**
170 : : * struct pmu - generic performance monitoring unit
171 : : */
172 : : struct pmu {
173 : : struct list_head entry;
174 : :
175 : : struct device *dev;
176 : : const struct attribute_group **attr_groups;
177 : : const char *name;
178 : : int type;
179 : :
180 : : int * __percpu pmu_disable_count;
181 : : struct perf_cpu_context * __percpu pmu_cpu_context;
182 : : int task_ctx_nr;
183 : : int hrtimer_interval_ms;
184 : :
185 : : /*
186 : : * Fully disable/enable this PMU, can be used to protect from the PMI
187 : : * as well as for lazy/batch writing of the MSRs.
188 : : */
189 : : void (*pmu_enable) (struct pmu *pmu); /* optional */
190 : : void (*pmu_disable) (struct pmu *pmu); /* optional */
191 : :
192 : : /*
193 : : * Try and initialize the event for this PMU.
194 : : * Should return -ENOENT when the @event doesn't match this PMU.
195 : : */
196 : : int (*event_init) (struct perf_event *event);
197 : :
198 : : #define PERF_EF_START 0x01 /* start the counter when adding */
199 : : #define PERF_EF_RELOAD 0x02 /* reload the counter when starting */
200 : : #define PERF_EF_UPDATE 0x04 /* update the counter when stopping */
201 : :
202 : : /*
203 : : * Adds/Removes a counter to/from the PMU, can be done inside
204 : : * a transaction, see the ->*_txn() methods.
205 : : */
206 : : int (*add) (struct perf_event *event, int flags);
207 : : void (*del) (struct perf_event *event, int flags);
208 : :
209 : : /*
210 : : * Starts/Stops a counter present on the PMU. The PMI handler
211 : : * should stop the counter when perf_event_overflow() returns
212 : : * !0. ->start() will be used to continue.
213 : : */
214 : : void (*start) (struct perf_event *event, int flags);
215 : : void (*stop) (struct perf_event *event, int flags);
216 : :
217 : : /*
218 : : * Updates the counter value of the event.
219 : : */
220 : : void (*read) (struct perf_event *event);
221 : :
222 : : /*
223 : : * Group events scheduling is treated as a transaction, add
224 : : * group events as a whole and perform one schedulability test.
225 : : * If the test fails, roll back the whole group
226 : : *
227 : : * Start the transaction, after this ->add() doesn't need to
228 : : * do schedulability tests.
229 : : */
230 : : void (*start_txn) (struct pmu *pmu); /* optional */
231 : : /*
232 : : * If ->start_txn() disabled the ->add() schedulability test
233 : : * then ->commit_txn() is required to perform one. On success
234 : : * the transaction is closed. On error the transaction is kept
235 : : * open until ->cancel_txn() is called.
236 : : */
237 : : int (*commit_txn) (struct pmu *pmu); /* optional */
238 : : /*
239 : : * Will cancel the transaction, assumes ->del() is called
240 : : * for each successful ->add() during the transaction.
241 : : */
242 : : void (*cancel_txn) (struct pmu *pmu); /* optional */
243 : :
244 : : /*
245 : : * Will return the value for perf_event_mmap_page::index for this event,
246 : : * if no implementation is provided it will default to: event->hw.idx + 1.
247 : : */
248 : : int (*event_idx) (struct perf_event *event); /*optional */
249 : :
250 : : /*
251 : : * flush branch stack on context-switches (needed in cpu-wide mode)
252 : : */
253 : : void (*flush_branch_stack) (void);
254 : : };
255 : :
256 : : /**
257 : : * enum perf_event_active_state - the states of a event
258 : : */
259 : : enum perf_event_active_state {
260 : : PERF_EVENT_STATE_ERROR = -2,
261 : : PERF_EVENT_STATE_OFF = -1,
262 : : PERF_EVENT_STATE_INACTIVE = 0,
263 : : PERF_EVENT_STATE_ACTIVE = 1,
264 : : };
265 : :
266 : : struct file;
267 : : struct perf_sample_data;
268 : :
269 : : typedef void (*perf_overflow_handler_t)(struct perf_event *,
270 : : struct perf_sample_data *,
271 : : struct pt_regs *regs);
272 : :
273 : : enum perf_group_flag {
274 : : PERF_GROUP_SOFTWARE = 0x1,
275 : : };
276 : :
277 : : #define SWEVENT_HLIST_BITS 8
278 : : #define SWEVENT_HLIST_SIZE (1 << SWEVENT_HLIST_BITS)
279 : :
280 : : struct swevent_hlist {
281 : : struct hlist_head heads[SWEVENT_HLIST_SIZE];
282 : : struct rcu_head rcu_head;
283 : : };
284 : :
285 : : #define PERF_ATTACH_CONTEXT 0x01
286 : : #define PERF_ATTACH_GROUP 0x02
287 : : #define PERF_ATTACH_TASK 0x04
288 : :
289 : : struct perf_cgroup;
290 : : struct ring_buffer;
291 : :
292 : : /**
293 : : * struct perf_event - performance event kernel representation:
294 : : */
295 : : struct perf_event {
296 : : #ifdef CONFIG_PERF_EVENTS
297 : : /*
298 : : * entry onto perf_event_context::event_list;
299 : : * modifications require ctx->lock
300 : : * RCU safe iterations.
301 : : */
302 : : struct list_head event_entry;
303 : :
304 : : /*
305 : : * XXX: group_entry and sibling_list should be mutually exclusive;
306 : : * either you're a sibling on a group, or you're the group leader.
307 : : * Rework the code to always use the same list element.
308 : : *
309 : : * Locked for modification by both ctx->mutex and ctx->lock; holding
310 : : * either sufficies for read.
311 : : */
312 : : struct list_head group_entry;
313 : : struct list_head sibling_list;
314 : :
315 : : /*
316 : : * We need storage to track the entries in perf_pmu_migrate_context; we
317 : : * cannot use the event_entry because of RCU and we want to keep the
318 : : * group in tact which avoids us using the other two entries.
319 : : */
320 : : struct list_head migrate_entry;
321 : :
322 : : struct hlist_node hlist_entry;
323 : : struct list_head active_entry;
324 : : int nr_siblings;
325 : : int group_flags;
326 : : struct perf_event *group_leader;
327 : : struct pmu *pmu;
328 : :
329 : : enum perf_event_active_state state;
330 : : unsigned int attach_state;
331 : : local64_t count;
332 : : atomic64_t child_count;
333 : :
334 : : /*
335 : : * These are the total time in nanoseconds that the event
336 : : * has been enabled (i.e. eligible to run, and the task has
337 : : * been scheduled in, if this is a per-task event)
338 : : * and running (scheduled onto the CPU), respectively.
339 : : *
340 : : * They are computed from tstamp_enabled, tstamp_running and
341 : : * tstamp_stopped when the event is in INACTIVE or ACTIVE state.
342 : : */
343 : : u64 total_time_enabled;
344 : : u64 total_time_running;
345 : :
346 : : /*
347 : : * These are timestamps used for computing total_time_enabled
348 : : * and total_time_running when the event is in INACTIVE or
349 : : * ACTIVE state, measured in nanoseconds from an arbitrary point
350 : : * in time.
351 : : * tstamp_enabled: the notional time when the event was enabled
352 : : * tstamp_running: the notional time when the event was scheduled on
353 : : * tstamp_stopped: in INACTIVE state, the notional time when the
354 : : * event was scheduled off.
355 : : */
356 : : u64 tstamp_enabled;
357 : : u64 tstamp_running;
358 : : u64 tstamp_stopped;
359 : :
360 : : /*
361 : : * timestamp shadows the actual context timing but it can
362 : : * be safely used in NMI interrupt context. It reflects the
363 : : * context time as it was when the event was last scheduled in.
364 : : *
365 : : * ctx_time already accounts for ctx->timestamp. Therefore to
366 : : * compute ctx_time for a sample, simply add perf_clock().
367 : : */
368 : : u64 shadow_ctx_time;
369 : :
370 : : struct perf_event_attr attr;
371 : : u16 header_size;
372 : : u16 id_header_size;
373 : : u16 read_size;
374 : : struct hw_perf_event hw;
375 : :
376 : : struct perf_event_context *ctx;
377 : : atomic_long_t refcount;
378 : :
379 : : /*
380 : : * These accumulate total time (in nanoseconds) that children
381 : : * events have been enabled and running, respectively.
382 : : */
383 : : atomic64_t child_total_time_enabled;
384 : : atomic64_t child_total_time_running;
385 : :
386 : : /*
387 : : * Protect attach/detach and child_list:
388 : : */
389 : : struct mutex child_mutex;
390 : : struct list_head child_list;
391 : : struct perf_event *parent;
392 : :
393 : : int oncpu;
394 : : int cpu;
395 : :
396 : : struct list_head owner_entry;
397 : : struct task_struct *owner;
398 : :
399 : : /* mmap bits */
400 : : struct mutex mmap_mutex;
401 : : atomic_t mmap_count;
402 : :
403 : : struct ring_buffer *rb;
404 : : struct list_head rb_entry;
405 : :
406 : : /* poll related */
407 : : wait_queue_head_t waitq;
408 : : struct fasync_struct *fasync;
409 : :
410 : : /* delayed work for NMIs and such */
411 : : int pending_wakeup;
412 : : int pending_kill;
413 : : int pending_disable;
414 : : struct irq_work pending;
415 : :
416 : : atomic_t event_limit;
417 : :
418 : : void (*destroy)(struct perf_event *);
419 : : struct rcu_head rcu_head;
420 : :
421 : : struct pid_namespace *ns;
422 : : u64 id;
423 : :
424 : : perf_overflow_handler_t overflow_handler;
425 : : void *overflow_handler_context;
426 : :
427 : : #ifdef CONFIG_EVENT_TRACING
428 : : struct ftrace_event_call *tp_event;
429 : : struct event_filter *filter;
430 : : #ifdef CONFIG_FUNCTION_TRACER
431 : : struct ftrace_ops ftrace_ops;
432 : : #endif
433 : : #endif
434 : :
435 : : #ifdef CONFIG_CGROUP_PERF
436 : : struct perf_cgroup *cgrp; /* cgroup event is attach to */
437 : : int cgrp_defer_enabled;
438 : : #endif
439 : :
440 : : #endif /* CONFIG_PERF_EVENTS */
441 : : };
442 : :
443 : : enum perf_event_context_type {
444 : : task_context,
445 : : cpu_context,
446 : : };
447 : :
448 : : /**
449 : : * struct perf_event_context - event context structure
450 : : *
451 : : * Used as a container for task events and CPU events as well:
452 : : */
453 : : struct perf_event_context {
454 : : struct pmu *pmu;
455 : : enum perf_event_context_type type;
456 : : /*
457 : : * Protect the states of the events in the list,
458 : : * nr_active, and the list:
459 : : */
460 : : raw_spinlock_t lock;
461 : : /*
462 : : * Protect the list of events. Locking either mutex or lock
463 : : * is sufficient to ensure the list doesn't change; to change
464 : : * the list you need to lock both the mutex and the spinlock.
465 : : */
466 : : struct mutex mutex;
467 : :
468 : : struct list_head pinned_groups;
469 : : struct list_head flexible_groups;
470 : : struct list_head event_list;
471 : : int nr_events;
472 : : int nr_active;
473 : : int is_active;
474 : : int nr_stat;
475 : : int nr_freq;
476 : : int rotate_disable;
477 : : atomic_t refcount;
478 : : struct task_struct *task;
479 : :
480 : : /*
481 : : * Context clock, runs when context enabled.
482 : : */
483 : : u64 time;
484 : : u64 timestamp;
485 : :
486 : : /*
487 : : * These fields let us detect when two contexts have both
488 : : * been cloned (inherited) from a common ancestor.
489 : : */
490 : : struct perf_event_context *parent_ctx;
491 : : u64 parent_gen;
492 : : u64 generation;
493 : : int pin_count;
494 : : int nr_cgroups; /* cgroup evts */
495 : : int nr_branch_stack; /* branch_stack evt */
496 : : struct rcu_head rcu_head;
497 : : };
498 : :
499 : : /*
500 : : * Number of contexts where an event can trigger:
501 : : * task, softirq, hardirq, nmi.
502 : : */
503 : : #define PERF_NR_CONTEXTS 4
504 : :
505 : : /**
506 : : * struct perf_event_cpu_context - per cpu event context structure
507 : : */
508 : : struct perf_cpu_context {
509 : : struct perf_event_context ctx;
510 : : struct perf_event_context *task_ctx;
511 : : int active_oncpu;
512 : : int exclusive;
513 : : struct hrtimer hrtimer;
514 : : ktime_t hrtimer_interval;
515 : : struct list_head rotation_list;
516 : : struct pmu *unique_pmu;
517 : : struct perf_cgroup *cgrp;
518 : : };
519 : :
520 : : struct perf_output_handle {
521 : : struct perf_event *event;
522 : : struct ring_buffer *rb;
523 : : unsigned long wakeup;
524 : : unsigned long size;
525 : : void *addr;
526 : : int page;
527 : : };
528 : :
529 : : #ifdef CONFIG_PERF_EVENTS
530 : :
531 : : extern int perf_pmu_register(struct pmu *pmu, const char *name, int type);
532 : : extern void perf_pmu_unregister(struct pmu *pmu);
533 : :
534 : : extern int perf_num_counters(void);
535 : : extern const char *perf_pmu_name(void);
536 : : extern void __perf_event_task_sched_in(struct task_struct *prev,
537 : : struct task_struct *task);
538 : : extern void __perf_event_task_sched_out(struct task_struct *prev,
539 : : struct task_struct *next);
540 : : extern int perf_event_init_task(struct task_struct *child);
541 : : extern void perf_event_exit_task(struct task_struct *child);
542 : : extern void perf_event_free_task(struct task_struct *task);
543 : : extern void perf_event_delayed_put(struct task_struct *task);
544 : : extern void perf_event_print_debug(void);
545 : : extern void perf_pmu_disable(struct pmu *pmu);
546 : : extern void perf_pmu_enable(struct pmu *pmu);
547 : : extern int perf_event_task_disable(void);
548 : : extern int perf_event_task_enable(void);
549 : : extern int perf_event_refresh(struct perf_event *event, int refresh);
550 : : extern void perf_event_update_userpage(struct perf_event *event);
551 : : extern int perf_event_release_kernel(struct perf_event *event);
552 : : extern struct perf_event *
553 : : perf_event_create_kernel_counter(struct perf_event_attr *attr,
554 : : int cpu,
555 : : struct task_struct *task,
556 : : perf_overflow_handler_t callback,
557 : : void *context);
558 : : extern void perf_pmu_migrate_context(struct pmu *pmu,
559 : : int src_cpu, int dst_cpu);
560 : : extern u64 perf_event_read_value(struct perf_event *event,
561 : : u64 *enabled, u64 *running);
562 : :
563 : :
564 : : struct perf_sample_data {
565 : : u64 type;
566 : :
567 : : u64 ip;
568 : : struct {
569 : : u32 pid;
570 : : u32 tid;
571 : : } tid_entry;
572 : : u64 time;
573 : : u64 addr;
574 : : u64 id;
575 : : u64 stream_id;
576 : : struct {
577 : : u32 cpu;
578 : : u32 reserved;
579 : : } cpu_entry;
580 : : u64 period;
581 : : union perf_mem_data_src data_src;
582 : : struct perf_callchain_entry *callchain;
583 : : struct perf_raw_record *raw;
584 : : struct perf_branch_stack *br_stack;
585 : : struct perf_regs_user regs_user;
586 : : u64 stack_user_size;
587 : : u64 weight;
588 : : /*
589 : : * Transaction flags for abort events:
590 : : */
591 : : u64 txn;
592 : : };
593 : :
594 : : static inline void perf_sample_data_init(struct perf_sample_data *data,
595 : : u64 addr, u64 period)
596 : : {
597 : : /* remaining struct members initialized in perf_prepare_sample() */
598 : 0 : data->addr = addr;
599 : 0 : data->raw = NULL;
600 : 0 : data->br_stack = NULL;
601 : 0 : data->period = period;
602 : 0 : data->regs_user.abi = PERF_SAMPLE_REGS_ABI_NONE;
603 : 0 : data->regs_user.regs = NULL;
604 : 0 : data->stack_user_size = 0;
605 : 0 : data->weight = 0;
606 : 0 : data->data_src.val = 0;
607 : 0 : data->txn = 0;
608 : : }
609 : :
610 : : extern void perf_output_sample(struct perf_output_handle *handle,
611 : : struct perf_event_header *header,
612 : : struct perf_sample_data *data,
613 : : struct perf_event *event);
614 : : extern void perf_prepare_sample(struct perf_event_header *header,
615 : : struct perf_sample_data *data,
616 : : struct perf_event *event,
617 : : struct pt_regs *regs);
618 : :
619 : : extern int perf_event_overflow(struct perf_event *event,
620 : : struct perf_sample_data *data,
621 : : struct pt_regs *regs);
622 : :
623 : : static inline bool is_sampling_event(struct perf_event *event)
624 : : {
625 : : return event->attr.sample_period != 0;
626 : : }
627 : :
628 : : /*
629 : : * Return 1 for a software event, 0 for a hardware event
630 : : */
631 : : static inline int is_software_event(struct perf_event *event)
632 : : {
633 : 0 : return event->pmu->task_ctx_nr == perf_sw_context;
634 : : }
635 : :
636 : : extern struct static_key perf_swevent_enabled[PERF_COUNT_SW_MAX];
637 : :
638 : : extern void __perf_sw_event(u32, u64, struct pt_regs *, u64);
639 : :
640 : : #ifndef perf_arch_fetch_caller_regs
641 : : static inline void perf_arch_fetch_caller_regs(struct pt_regs *regs, unsigned long ip) { }
642 : : #endif
643 : :
644 : : /*
645 : : * Take a snapshot of the regs. Skip ip and frame pointer to
646 : : * the nth caller. We only need a few of the regs:
647 : : * - ip for PERF_SAMPLE_IP
648 : : * - cs for user_mode() tests
649 : : * - bp for callchains
650 : : * - eflags, for future purposes, just in case
651 : : */
652 : : static inline void perf_fetch_caller_regs(struct pt_regs *regs)
653 : : {
654 : 0 : memset(regs, 0, sizeof(*regs));
655 : :
656 : 0 : perf_arch_fetch_caller_regs(regs, CALLER_ADDR0);
657 : : }
658 : :
659 : : static __always_inline void
660 : : perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)
661 : : {
662 : : struct pt_regs hot_regs;
663 : :
664 [ - + ][ - + ]: 156047104 : if (static_key_false(&perf_swevent_enabled[event_id])) {
[ - + ]
665 [ # # ][ # # ]: 0 : if (!regs) {
[ # # ]
666 : : perf_fetch_caller_regs(&hot_regs);
667 : : regs = &hot_regs;
668 : : }
669 : 67580754 : __perf_sw_event(event_id, nr, regs, addr);
670 : : }
671 : : }
672 : :
673 : : extern struct static_key_deferred perf_sched_events;
674 : :
675 : : static inline void perf_event_task_sched_in(struct task_struct *prev,
676 : : struct task_struct *task)
677 : : {
678 [ - + ]: 23411510 : if (static_key_false(&perf_sched_events.key))
679 : 0 : __perf_event_task_sched_in(prev, task);
680 : : }
681 : :
682 : : static inline void perf_event_task_sched_out(struct task_struct *prev,
683 : : struct task_struct *next)
684 : : {
685 : : perf_sw_event(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, NULL, 0);
686 : :
687 [ - + ]: 23572555 : if (static_key_false(&perf_sched_events.key))
688 : 0 : __perf_event_task_sched_out(prev, next);
689 : : }
690 : :
691 : : extern void perf_event_mmap(struct vm_area_struct *vma);
692 : : extern struct perf_guest_info_callbacks *perf_guest_cbs;
693 : : extern int perf_register_guest_info_callbacks(struct perf_guest_info_callbacks *callbacks);
694 : : extern int perf_unregister_guest_info_callbacks(struct perf_guest_info_callbacks *callbacks);
695 : :
696 : : extern void perf_event_comm(struct task_struct *tsk);
697 : : extern void perf_event_fork(struct task_struct *tsk);
698 : :
699 : : /* Callchains */
700 : : DECLARE_PER_CPU(struct perf_callchain_entry, perf_callchain_entry);
701 : :
702 : : extern void perf_callchain_user(struct perf_callchain_entry *entry, struct pt_regs *regs);
703 : : extern void perf_callchain_kernel(struct perf_callchain_entry *entry, struct pt_regs *regs);
704 : :
705 : : static inline void perf_callchain_store(struct perf_callchain_entry *entry, u64 ip)
706 : : {
707 [ # # ][ # # ]: 0 : if (entry->nr < PERF_MAX_STACK_DEPTH)
[ # # ]
708 : 0 : entry->ip[entry->nr++] = ip;
709 : : }
710 : :
711 : : extern int sysctl_perf_event_paranoid;
712 : : extern int sysctl_perf_event_mlock;
713 : : extern int sysctl_perf_event_sample_rate;
714 : : extern int sysctl_perf_cpu_time_max_percent;
715 : :
716 : : extern void perf_sample_event_took(u64 sample_len_ns);
717 : :
718 : : extern int perf_proc_update_handler(struct ctl_table *table, int write,
719 : : void __user *buffer, size_t *lenp,
720 : : loff_t *ppos);
721 : : extern int perf_cpu_time_max_percent_handler(struct ctl_table *table, int write,
722 : : void __user *buffer, size_t *lenp,
723 : : loff_t *ppos);
724 : :
725 : :
726 : : static inline bool perf_paranoid_tracepoint_raw(void)
727 : : {
728 : 0 : return sysctl_perf_event_paranoid > -1;
729 : : }
730 : :
731 : : static inline bool perf_paranoid_cpu(void)
732 : : {
733 : 0 : return sysctl_perf_event_paranoid > 0;
734 : : }
735 : :
736 : : static inline bool perf_paranoid_kernel(void)
737 : : {
738 : 0 : return sysctl_perf_event_paranoid > 1;
739 : : }
740 : :
741 : : extern void perf_event_init(void);
742 : : extern void perf_tp_event(u64 addr, u64 count, void *record,
743 : : int entry_size, struct pt_regs *regs,
744 : : struct hlist_head *head, int rctx,
745 : : struct task_struct *task);
746 : : extern void perf_bp_event(struct perf_event *event, void *data);
747 : :
748 : : #ifndef perf_misc_flags
749 : : # define perf_misc_flags(regs) \
750 : : (user_mode(regs) ? PERF_RECORD_MISC_USER : PERF_RECORD_MISC_KERNEL)
751 : : # define perf_instruction_pointer(regs) instruction_pointer(regs)
752 : : #endif
753 : :
754 : : static inline bool has_branch_stack(struct perf_event *event)
755 : : {
756 : 0 : return event->attr.sample_type & PERF_SAMPLE_BRANCH_STACK;
757 : : }
758 : :
759 : : extern int perf_output_begin(struct perf_output_handle *handle,
760 : : struct perf_event *event, unsigned int size);
761 : : extern void perf_output_end(struct perf_output_handle *handle);
762 : : extern unsigned int perf_output_copy(struct perf_output_handle *handle,
763 : : const void *buf, unsigned int len);
764 : : extern unsigned int perf_output_skip(struct perf_output_handle *handle,
765 : : unsigned int len);
766 : : extern int perf_swevent_get_recursion_context(void);
767 : : extern void perf_swevent_put_recursion_context(int rctx);
768 : : extern u64 perf_swevent_set_period(struct perf_event *event);
769 : : extern void perf_event_enable(struct perf_event *event);
770 : : extern void perf_event_disable(struct perf_event *event);
771 : : extern int __perf_event_disable(void *info);
772 : : extern void perf_event_task_tick(void);
773 : : #else
774 : : static inline void
775 : : perf_event_task_sched_in(struct task_struct *prev,
776 : : struct task_struct *task) { }
777 : : static inline void
778 : : perf_event_task_sched_out(struct task_struct *prev,
779 : : struct task_struct *next) { }
780 : : static inline int perf_event_init_task(struct task_struct *child) { return 0; }
781 : : static inline void perf_event_exit_task(struct task_struct *child) { }
782 : : static inline void perf_event_free_task(struct task_struct *task) { }
783 : : static inline void perf_event_delayed_put(struct task_struct *task) { }
784 : : static inline void perf_event_print_debug(void) { }
785 : : static inline int perf_event_task_disable(void) { return -EINVAL; }
786 : : static inline int perf_event_task_enable(void) { return -EINVAL; }
787 : : static inline int perf_event_refresh(struct perf_event *event, int refresh)
788 : : {
789 : : return -EINVAL;
790 : : }
791 : :
792 : : static inline void
793 : : perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr) { }
794 : : static inline void
795 : : perf_bp_event(struct perf_event *event, void *data) { }
796 : :
797 : : static inline int perf_register_guest_info_callbacks
798 : : (struct perf_guest_info_callbacks *callbacks) { return 0; }
799 : : static inline int perf_unregister_guest_info_callbacks
800 : : (struct perf_guest_info_callbacks *callbacks) { return 0; }
801 : :
802 : : static inline void perf_event_mmap(struct vm_area_struct *vma) { }
803 : : static inline void perf_event_comm(struct task_struct *tsk) { }
804 : : static inline void perf_event_fork(struct task_struct *tsk) { }
805 : : static inline void perf_event_init(void) { }
806 : : static inline int perf_swevent_get_recursion_context(void) { return -1; }
807 : : static inline void perf_swevent_put_recursion_context(int rctx) { }
808 : : static inline u64 perf_swevent_set_period(struct perf_event *event) { return 0; }
809 : : static inline void perf_event_enable(struct perf_event *event) { }
810 : : static inline void perf_event_disable(struct perf_event *event) { }
811 : : static inline int __perf_event_disable(void *info) { return -1; }
812 : : static inline void perf_event_task_tick(void) { }
813 : : #endif
814 : :
815 : : #if defined(CONFIG_PERF_EVENTS) && defined(CONFIG_NO_HZ_FULL)
816 : : extern bool perf_event_can_stop_tick(void);
817 : : #else
818 : : static inline bool perf_event_can_stop_tick(void) { return true; }
819 : : #endif
820 : :
821 : : #if defined(CONFIG_PERF_EVENTS) && defined(CONFIG_CPU_SUP_INTEL)
822 : : extern void perf_restore_debug_store(void);
823 : : #else
824 : : static inline void perf_restore_debug_store(void) { }
825 : : #endif
826 : :
827 : : #define perf_output_put(handle, x) perf_output_copy((handle), &(x), sizeof(x))
828 : :
829 : : /*
830 : : * This has to have a higher priority than migration_notifier in sched/core.c.
831 : : */
832 : : #define perf_cpu_notifier(fn) \
833 : : do { \
834 : : static struct notifier_block fn##_nb = \
835 : : { .notifier_call = fn, .priority = CPU_PRI_PERF }; \
836 : : unsigned long cpu = smp_processor_id(); \
837 : : unsigned long flags; \
838 : : fn(&fn##_nb, (unsigned long)CPU_UP_PREPARE, \
839 : : (void *)(unsigned long)cpu); \
840 : : local_irq_save(flags); \
841 : : fn(&fn##_nb, (unsigned long)CPU_STARTING, \
842 : : (void *)(unsigned long)cpu); \
843 : : local_irq_restore(flags); \
844 : : fn(&fn##_nb, (unsigned long)CPU_ONLINE, \
845 : : (void *)(unsigned long)cpu); \
846 : : register_cpu_notifier(&fn##_nb); \
847 : : } while (0)
848 : :
849 : :
850 : : struct perf_pmu_events_attr {
851 : : struct device_attribute attr;
852 : : u64 id;
853 : : const char *event_str;
854 : : };
855 : :
856 : : #define PMU_EVENT_ATTR(_name, _var, _id, _show) \
857 : : static struct perf_pmu_events_attr _var = { \
858 : : .attr = __ATTR(_name, 0444, _show, NULL), \
859 : : .id = _id, \
860 : : };
861 : :
862 : : #define PMU_FORMAT_ATTR(_name, _format) \
863 : : static ssize_t \
864 : : _name##_show(struct device *dev, \
865 : : struct device_attribute *attr, \
866 : : char *page) \
867 : : { \
868 : : BUILD_BUG_ON(sizeof(_format) >= PAGE_SIZE); \
869 : : return sprintf(page, _format "\n"); \
870 : : } \
871 : : \
872 : : static struct device_attribute format_attr_##_name = __ATTR_RO(_name)
873 : :
874 : : #endif /* _LINUX_PERF_EVENT_H */
|
