blob: 06a6fba9f53184ea9c2bce427f13c0500e68dcd8 [file] [log] [blame]
Thomas Gleixner0793a612008-12-04 20:12:29 +01001/*
2 * Performance counters:
3 *
4 * Copyright(C) 2008, Thomas Gleixner <tglx@linutronix.de>
5 * Copyright(C) 2008, Red Hat, Inc., Ingo Molnar
6 *
7 * Data type definitions, declarations, prototypes.
8 *
9 * Started by: Thomas Gleixner and Ingo Molnar
10 *
11 * For licencing details see kernel-base/COPYING
12 */
13#ifndef _LINUX_PERF_COUNTER_H
14#define _LINUX_PERF_COUNTER_H
15
Paul Mackerrasf3dfd262009-02-26 22:43:46 +110016#include <linux/types.h>
17#include <linux/ioctl.h>
Paul Mackerras9aaa1312009-03-21 15:31:47 +110018#include <asm/byteorder.h>
Thomas Gleixner0793a612008-12-04 20:12:29 +010019
20/*
Ingo Molnar9f66a382008-12-10 12:33:23 +010021 * User-space ABI bits:
22 */
23
24/*
Peter Zijlstrab8e83512009-03-19 20:26:18 +010025 * hw_event.type
26 */
27enum perf_event_types {
28 PERF_TYPE_HARDWARE = 0,
29 PERF_TYPE_SOFTWARE = 1,
30 PERF_TYPE_TRACEPOINT = 2,
31
32 /*
33 * available TYPE space, raw is the max value.
34 */
35
36 PERF_TYPE_RAW = 128,
37};
38
39/*
40 * Generalized performance counter event types, used by the hw_event.event_id
Ingo Molnar9f66a382008-12-10 12:33:23 +010041 * parameter of the sys_perf_counter_open() syscall:
Thomas Gleixner0793a612008-12-04 20:12:29 +010042 */
Peter Zijlstrab8e83512009-03-19 20:26:18 +010043enum hw_event_ids {
Thomas Gleixner0793a612008-12-04 20:12:29 +010044 /*
Ingo Molnar9f66a382008-12-10 12:33:23 +010045 * Common hardware events, generalized by the kernel:
Thomas Gleixner0793a612008-12-04 20:12:29 +010046 */
Peter Zijlstrab8e83512009-03-19 20:26:18 +010047 PERF_COUNT_CPU_CYCLES = 0,
48 PERF_COUNT_INSTRUCTIONS = 1,
49 PERF_COUNT_CACHE_REFERENCES = 2,
50 PERF_COUNT_CACHE_MISSES = 3,
51 PERF_COUNT_BRANCH_INSTRUCTIONS = 4,
52 PERF_COUNT_BRANCH_MISSES = 5,
53 PERF_COUNT_BUS_CYCLES = 6,
Ingo Molnar9f66a382008-12-10 12:33:23 +010054
Peter Zijlstrab8e83512009-03-19 20:26:18 +010055 PERF_HW_EVENTS_MAX = 7,
56};
Ingo Molnar6c594c22008-12-14 12:34:15 +010057
Peter Zijlstrab8e83512009-03-19 20:26:18 +010058/*
59 * Special "software" counters provided by the kernel, even if the hardware
60 * does not support performance counters. These counters measure various
61 * physical and sw events of the kernel (and allow the profiling of them as
62 * well):
63 */
64enum sw_event_ids {
65 PERF_COUNT_CPU_CLOCK = 0,
66 PERF_COUNT_TASK_CLOCK = 1,
67 PERF_COUNT_PAGE_FAULTS = 2,
68 PERF_COUNT_CONTEXT_SWITCHES = 3,
69 PERF_COUNT_CPU_MIGRATIONS = 4,
70 PERF_COUNT_PAGE_FAULTS_MIN = 5,
71 PERF_COUNT_PAGE_FAULTS_MAJ = 6,
Ingo Molnar6c594c22008-12-14 12:34:15 +010072
Peter Zijlstrab8e83512009-03-19 20:26:18 +010073 PERF_SW_EVENTS_MAX = 7,
Thomas Gleixner0793a612008-12-04 20:12:29 +010074};
75
Peter Zijlstraf4a2deb42009-03-23 18:22:06 +010076#define __PERF_COUNTER_MASK(name) \
77 (((1ULL << PERF_COUNTER_##name##_BITS) - 1) << \
78 PERF_COUNTER_##name##_SHIFT)
79
80#define PERF_COUNTER_RAW_BITS 1
81#define PERF_COUNTER_RAW_SHIFT 63
82#define PERF_COUNTER_RAW_MASK __PERF_COUNTER_MASK(RAW)
83
84#define PERF_COUNTER_CONFIG_BITS 63
85#define PERF_COUNTER_CONFIG_SHIFT 0
86#define PERF_COUNTER_CONFIG_MASK __PERF_COUNTER_MASK(CONFIG)
87
88#define PERF_COUNTER_TYPE_BITS 7
89#define PERF_COUNTER_TYPE_SHIFT 56
90#define PERF_COUNTER_TYPE_MASK __PERF_COUNTER_MASK(TYPE)
91
92#define PERF_COUNTER_EVENT_BITS 56
93#define PERF_COUNTER_EVENT_SHIFT 0
94#define PERF_COUNTER_EVENT_MASK __PERF_COUNTER_MASK(EVENT)
95
Ingo Molnar9f66a382008-12-10 12:33:23 +010096/*
Peter Zijlstra8a057d82009-04-02 11:11:59 +020097 * Bits that can be set in hw_event.record_type to request information
98 * in the overflow packets.
99 */
100enum perf_counter_record_format {
101 PERF_RECORD_IP = 1U << 0,
102 PERF_RECORD_TID = 1U << 1,
103 PERF_RECORD_GROUP = 1U << 2,
104 PERF_RECORD_CALLCHAIN = 1U << 3,
105};
106
107/*
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100108 * Bits that can be set in hw_event.read_format to request that
109 * reads on the counter should return the indicated quantities,
110 * in increasing order of bit value, after the counter value.
111 */
112enum perf_counter_read_format {
113 PERF_FORMAT_TOTAL_TIME_ENABLED = 1,
114 PERF_FORMAT_TOTAL_TIME_RUNNING = 2,
115};
116
117/*
Ingo Molnar9f66a382008-12-10 12:33:23 +0100118 * Hardware event to monitor via a performance monitoring counter:
119 */
120struct perf_counter_hw_event {
Peter Zijlstraf4a2deb42009-03-23 18:22:06 +0100121 /*
122 * The MSB of the config word signifies if the rest contains cpu
123 * specific (raw) counter configuration data, if unset, the next
124 * 7 bits are an event type and the rest of the bits are the event
125 * identifier.
126 */
127 __u64 config;
Ingo Molnar9f66a382008-12-10 12:33:23 +0100128
Paul Mackerrasf3dfd262009-02-26 22:43:46 +1100129 __u64 irq_period;
Peter Zijlstra8a057d82009-04-02 11:11:59 +0200130 __u32 record_type;
131 __u32 read_format;
Ingo Molnar9f66a382008-12-10 12:33:23 +0100132
Paul Mackerras2743a5b2009-03-04 20:36:51 +1100133 __u64 disabled : 1, /* off by default */
Paul Mackerras0475f9e2009-02-11 14:35:35 +1100134 nmi : 1, /* NMI sampling */
Paul Mackerras0475f9e2009-02-11 14:35:35 +1100135 inherit : 1, /* children inherit it */
136 pinned : 1, /* must always be on PMU */
137 exclusive : 1, /* only group on PMU */
138 exclude_user : 1, /* don't count user */
139 exclude_kernel : 1, /* ditto kernel */
140 exclude_hv : 1, /* ditto hypervisor */
Paul Mackerras2743a5b2009-03-04 20:36:51 +1100141 exclude_idle : 1, /* don't count when idle */
Peter Zijlstra0a4a9392009-03-30 19:07:05 +0200142 mmap : 1, /* include mmap data */
143 munmap : 1, /* include munmap data */
Paul Mackerras3b6f9e52009-01-14 21:00:30 +1100144
Peter Zijlstra8a057d82009-04-02 11:11:59 +0200145 __reserved_1 : 53;
Paul Mackerras2743a5b2009-03-04 20:36:51 +1100146
147 __u32 extra_config_len;
148 __u32 __reserved_4;
Ingo Molnar9f66a382008-12-10 12:33:23 +0100149
Paul Mackerrasf3dfd262009-02-26 22:43:46 +1100150 __u64 __reserved_2;
Paul Mackerras2743a5b2009-03-04 20:36:51 +1100151 __u64 __reserved_3;
Thomas Gleixnereab656a2008-12-08 19:26:59 +0100152};
153
Ingo Molnar9f66a382008-12-10 12:33:23 +0100154/*
Paul Mackerrasd859e292009-01-17 18:10:22 +1100155 * Ioctls that can be done on a perf counter fd:
156 */
157#define PERF_COUNTER_IOC_ENABLE _IO('$', 0)
158#define PERF_COUNTER_IOC_DISABLE _IO('$', 1)
159
Paul Mackerras37d81822009-03-23 18:22:08 +0100160/*
161 * Structure of the page that can be mapped via mmap
162 */
163struct perf_counter_mmap_page {
164 __u32 version; /* version number of this structure */
165 __u32 compat_version; /* lowest version this is compat with */
Peter Zijlstra38ff6672009-03-30 19:07:03 +0200166
167 /*
168 * Bits needed to read the hw counters in user-space.
169 *
170 * The index and offset should be read atomically using the seqlock:
171 *
172 * __u32 seq, index;
173 * __s64 offset;
174 *
175 * again:
176 * rmb();
177 * seq = pc->lock;
178 *
179 * if (unlikely(seq & 1)) {
180 * cpu_relax();
181 * goto again;
182 * }
183 *
184 * index = pc->index;
185 * offset = pc->offset;
186 *
187 * rmb();
188 * if (pc->lock != seq)
189 * goto again;
190 *
191 * After this, index contains architecture specific counter index + 1,
192 * so that 0 means unavailable, offset contains the value to be added
193 * to the result of the raw timer read to obtain this counter's value.
194 */
Paul Mackerras37d81822009-03-23 18:22:08 +0100195 __u32 lock; /* seqlock for synchronization */
196 __u32 index; /* hardware counter identifier */
197 __s64 offset; /* add to hardware counter value */
Peter Zijlstra7b732a72009-03-23 18:22:10 +0100198
Peter Zijlstra38ff6672009-03-30 19:07:03 +0200199 /*
200 * Control data for the mmap() data buffer.
201 *
202 * User-space reading this value should issue an rmb(), on SMP capable
203 * platforms, after reading this value -- see perf_counter_wakeup().
204 */
Peter Zijlstra7b732a72009-03-23 18:22:10 +0100205 __u32 data_head; /* head in the data section */
Paul Mackerras37d81822009-03-23 18:22:08 +0100206};
207
Peter Zijlstra5c148192009-03-25 12:30:23 +0100208struct perf_event_header {
209 __u32 type;
210 __u32 size;
211};
212
213enum perf_event_type {
Peter Zijlstra5ed00412009-03-30 19:07:12 +0200214
Peter Zijlstra8a057d82009-04-02 11:11:59 +0200215 PERF_EVENT_MMAP = 1,
216 PERF_EVENT_MUNMAP = 2,
Peter Zijlstraea5d20c2009-03-25 12:30:25 +0100217
Peter Zijlstra8a057d82009-04-02 11:11:59 +0200218 /*
219 * Half the event type space is reserved for the counter overflow
220 * bitfields, as found in hw_event.record_type.
221 *
222 * These events will have types of the form:
223 * PERF_EVENT_COUNTER_OVERFLOW { | __PERF_EVENT_* } *
224 */
225 PERF_EVENT_COUNTER_OVERFLOW = 1UL << 31,
226 __PERF_EVENT_IP = PERF_RECORD_IP,
227 __PERF_EVENT_TID = PERF_RECORD_TID,
228 __PERF_EVENT_GROUP = PERF_RECORD_GROUP,
229 __PERF_EVENT_CALLCHAIN = PERF_RECORD_CALLCHAIN,
Peter Zijlstra5c148192009-03-25 12:30:23 +0100230};
231
Paul Mackerrasf3dfd262009-02-26 22:43:46 +1100232#ifdef __KERNEL__
Paul Mackerrasd859e292009-01-17 18:10:22 +1100233/*
Paul Mackerrasf3dfd262009-02-26 22:43:46 +1100234 * Kernel-internal data types and definitions:
Ingo Molnar9f66a382008-12-10 12:33:23 +0100235 */
236
Paul Mackerrasf3dfd262009-02-26 22:43:46 +1100237#ifdef CONFIG_PERF_COUNTERS
238# include <asm/perf_counter.h>
239#endif
240
241#include <linux/list.h>
242#include <linux/mutex.h>
243#include <linux/rculist.h>
244#include <linux/rcupdate.h>
245#include <linux/spinlock.h>
Peter Zijlstrad6d020e2009-03-13 12:21:35 +0100246#include <linux/hrtimer.h>
Paul Mackerrasf3dfd262009-02-26 22:43:46 +1100247#include <asm/atomic.h>
248
249struct task_struct;
250
Peter Zijlstraf4a2deb42009-03-23 18:22:06 +0100251static inline u64 perf_event_raw(struct perf_counter_hw_event *hw_event)
252{
253 return hw_event->config & PERF_COUNTER_RAW_MASK;
254}
255
256static inline u64 perf_event_config(struct perf_counter_hw_event *hw_event)
257{
258 return hw_event->config & PERF_COUNTER_CONFIG_MASK;
259}
260
261static inline u64 perf_event_type(struct perf_counter_hw_event *hw_event)
262{
263 return (hw_event->config & PERF_COUNTER_TYPE_MASK) >>
264 PERF_COUNTER_TYPE_SHIFT;
265}
266
267static inline u64 perf_event_id(struct perf_counter_hw_event *hw_event)
268{
269 return hw_event->config & PERF_COUNTER_EVENT_MASK;
270}
271
Thomas Gleixner0793a612008-12-04 20:12:29 +0100272/**
Ingo Molnar9f66a382008-12-10 12:33:23 +0100273 * struct hw_perf_counter - performance counter hardware details:
Thomas Gleixner0793a612008-12-04 20:12:29 +0100274 */
275struct hw_perf_counter {
Ingo Molnaree060942008-12-13 09:00:03 +0100276#ifdef CONFIG_PERF_COUNTERS
Peter Zijlstrad6d020e2009-03-13 12:21:35 +0100277 union {
278 struct { /* hardware */
279 u64 config;
280 unsigned long config_base;
281 unsigned long counter_base;
282 int nmi;
283 unsigned int idx;
284 };
285 union { /* software */
286 atomic64_t count;
287 struct hrtimer hrtimer;
288 };
289 };
Ingo Molnaree060942008-12-13 09:00:03 +0100290 atomic64_t prev_count;
Ingo Molnar9f66a382008-12-10 12:33:23 +0100291 u64 irq_period;
Ingo Molnaree060942008-12-13 09:00:03 +0100292 atomic64_t period_left;
293#endif
Thomas Gleixner0793a612008-12-04 20:12:29 +0100294};
295
Ingo Molnar621a01e2008-12-11 12:46:46 +0100296struct perf_counter;
297
298/**
299 * struct hw_perf_counter_ops - performance counter hw ops
300 */
301struct hw_perf_counter_ops {
Ingo Molnar95cdd2e2008-12-21 13:50:42 +0100302 int (*enable) (struct perf_counter *counter);
Ingo Molnar76715812008-12-17 14:20:28 +0100303 void (*disable) (struct perf_counter *counter);
304 void (*read) (struct perf_counter *counter);
Ingo Molnar621a01e2008-12-11 12:46:46 +0100305};
306
Thomas Gleixner0793a612008-12-04 20:12:29 +0100307/**
Ingo Molnar6a930702008-12-11 15:17:03 +0100308 * enum perf_counter_active_state - the states of a counter
309 */
310enum perf_counter_active_state {
Paul Mackerras3b6f9e52009-01-14 21:00:30 +1100311 PERF_COUNTER_STATE_ERROR = -2,
Ingo Molnar6a930702008-12-11 15:17:03 +0100312 PERF_COUNTER_STATE_OFF = -1,
313 PERF_COUNTER_STATE_INACTIVE = 0,
314 PERF_COUNTER_STATE_ACTIVE = 1,
315};
316
Ingo Molnar9b51f662008-12-12 13:49:45 +0100317struct file;
318
Peter Zijlstra7b732a72009-03-23 18:22:10 +0100319struct perf_mmap_data {
320 struct rcu_head rcu_head;
321 int nr_pages;
Peter Zijlstrac7138f32009-03-24 13:18:16 +0100322 atomic_t wakeup;
Peter Zijlstra7b732a72009-03-23 18:22:10 +0100323 atomic_t head;
324 struct perf_counter_mmap_page *user_page;
325 void *data_pages[0];
326};
327
Peter Zijlstra925d5192009-03-30 19:07:02 +0200328struct perf_wakeup_entry {
329 struct perf_wakeup_entry *next;
330};
331
Ingo Molnar6a930702008-12-11 15:17:03 +0100332/**
Thomas Gleixner0793a612008-12-04 20:12:29 +0100333 * struct perf_counter - performance counter kernel representation:
334 */
335struct perf_counter {
Ingo Molnaree060942008-12-13 09:00:03 +0100336#ifdef CONFIG_PERF_COUNTERS
Ingo Molnar04289bb2008-12-11 08:38:42 +0100337 struct list_head list_entry;
Peter Zijlstra592903c2009-03-13 12:21:36 +0100338 struct list_head event_entry;
Ingo Molnar04289bb2008-12-11 08:38:42 +0100339 struct list_head sibling_list;
Peter Zijlstra5c148192009-03-25 12:30:23 +0100340 int nr_siblings;
Ingo Molnar04289bb2008-12-11 08:38:42 +0100341 struct perf_counter *group_leader;
Ingo Molnar5c92d122008-12-11 13:21:10 +0100342 const struct hw_perf_counter_ops *hw_ops;
Ingo Molnar04289bb2008-12-11 08:38:42 +0100343
Ingo Molnar6a930702008-12-11 15:17:03 +0100344 enum perf_counter_active_state state;
Paul Mackerrasc07c99b2009-02-13 22:10:34 +1100345 enum perf_counter_active_state prev_state;
Thomas Gleixner0793a612008-12-04 20:12:29 +0100346 atomic64_t count;
Ingo Molnaree060942008-12-13 09:00:03 +0100347
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100348 /*
349 * These are the total time in nanoseconds that the counter
350 * has been enabled (i.e. eligible to run, and the task has
351 * been scheduled in, if this is a per-task counter)
352 * and running (scheduled onto the CPU), respectively.
353 *
354 * They are computed from tstamp_enabled, tstamp_running and
355 * tstamp_stopped when the counter is in INACTIVE or ACTIVE state.
356 */
357 u64 total_time_enabled;
358 u64 total_time_running;
359
360 /*
361 * These are timestamps used for computing total_time_enabled
362 * and total_time_running when the counter is in INACTIVE or
363 * ACTIVE state, measured in nanoseconds from an arbitrary point
364 * in time.
365 * tstamp_enabled: the notional time when the counter was enabled
366 * tstamp_running: the notional time when the counter was scheduled on
367 * tstamp_stopped: in INACTIVE state, the notional time when the
368 * counter was scheduled off.
369 */
370 u64 tstamp_enabled;
371 u64 tstamp_running;
372 u64 tstamp_stopped;
373
Ingo Molnar9f66a382008-12-10 12:33:23 +0100374 struct perf_counter_hw_event hw_event;
Thomas Gleixner0793a612008-12-04 20:12:29 +0100375 struct hw_perf_counter hw;
376
377 struct perf_counter_context *ctx;
378 struct task_struct *task;
Ingo Molnar9b51f662008-12-12 13:49:45 +0100379 struct file *filp;
Thomas Gleixner0793a612008-12-04 20:12:29 +0100380
Ingo Molnar9b51f662008-12-12 13:49:45 +0100381 struct perf_counter *parent;
Paul Mackerrasd859e292009-01-17 18:10:22 +1100382 struct list_head child_list;
383
Thomas Gleixner0793a612008-12-04 20:12:29 +0100384 /*
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100385 * These accumulate total time (in nanoseconds) that children
386 * counters have been enabled and running, respectively.
387 */
388 atomic64_t child_total_time_enabled;
389 atomic64_t child_total_time_running;
390
391 /*
Paul Mackerrasd859e292009-01-17 18:10:22 +1100392 * Protect attach/detach and child_list:
Thomas Gleixner0793a612008-12-04 20:12:29 +0100393 */
394 struct mutex mutex;
395
396 int oncpu;
397 int cpu;
398
Peter Zijlstra7b732a72009-03-23 18:22:10 +0100399 /* mmap bits */
400 struct mutex mmap_mutex;
401 atomic_t mmap_count;
402 struct perf_mmap_data *data;
Paul Mackerras37d81822009-03-23 18:22:08 +0100403
Peter Zijlstra7b732a72009-03-23 18:22:10 +0100404 /* poll related */
Thomas Gleixner0793a612008-12-04 20:12:29 +0100405 wait_queue_head_t waitq;
406 /* optional: for NMIs */
Peter Zijlstra925d5192009-03-30 19:07:02 +0200407 struct perf_wakeup_entry wakeup;
Peter Zijlstra592903c2009-03-13 12:21:36 +0100408
Peter Zijlstrae077df42009-03-19 20:26:17 +0100409 void (*destroy)(struct perf_counter *);
Peter Zijlstra592903c2009-03-13 12:21:36 +0100410 struct rcu_head rcu_head;
Ingo Molnaree060942008-12-13 09:00:03 +0100411#endif
Thomas Gleixner0793a612008-12-04 20:12:29 +0100412};
413
414/**
415 * struct perf_counter_context - counter context structure
416 *
417 * Used as a container for task counters and CPU counters as well:
418 */
419struct perf_counter_context {
420#ifdef CONFIG_PERF_COUNTERS
421 /*
Paul Mackerrasd859e292009-01-17 18:10:22 +1100422 * Protect the states of the counters in the list,
423 * nr_active, and the list:
Thomas Gleixner0793a612008-12-04 20:12:29 +0100424 */
425 spinlock_t lock;
Paul Mackerrasd859e292009-01-17 18:10:22 +1100426 /*
427 * Protect the list of counters. Locking either mutex or lock
428 * is sufficient to ensure the list doesn't change; to change
429 * the list you need to lock both the mutex and the spinlock.
430 */
431 struct mutex mutex;
Ingo Molnar04289bb2008-12-11 08:38:42 +0100432
433 struct list_head counter_list;
Peter Zijlstra592903c2009-03-13 12:21:36 +0100434 struct list_head event_list;
Thomas Gleixner0793a612008-12-04 20:12:29 +0100435 int nr_counters;
436 int nr_active;
Paul Mackerrasd859e292009-01-17 18:10:22 +1100437 int is_active;
Thomas Gleixner0793a612008-12-04 20:12:29 +0100438 struct task_struct *task;
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100439
440 /*
441 * time_now is the current time in nanoseconds since an arbitrary
442 * point in the past. For per-task counters, this is based on the
443 * task clock, and for per-cpu counters it is based on the cpu clock.
444 * time_lost is an offset from the task/cpu clock, used to make it
445 * appear that time only passes while the context is scheduled in.
446 */
447 u64 time_now;
448 u64 time_lost;
Thomas Gleixner0793a612008-12-04 20:12:29 +0100449#endif
450};
451
452/**
453 * struct perf_counter_cpu_context - per cpu counter context structure
454 */
455struct perf_cpu_context {
456 struct perf_counter_context ctx;
457 struct perf_counter_context *task_ctx;
458 int active_oncpu;
459 int max_pertask;
Paul Mackerras3b6f9e52009-01-14 21:00:30 +1100460 int exclusive;
Peter Zijlstra96f6d442009-03-23 18:22:07 +0100461
462 /*
463 * Recursion avoidance:
464 *
465 * task, softirq, irq, nmi context
466 */
467 int recursion[4];
Thomas Gleixner0793a612008-12-04 20:12:29 +0100468};
469
470/*
471 * Set by architecture code:
472 */
473extern int perf_max_counters;
474
475#ifdef CONFIG_PERF_COUNTERS
Ingo Molnar5c92d122008-12-11 13:21:10 +0100476extern const struct hw_perf_counter_ops *
Ingo Molnar621a01e2008-12-11 12:46:46 +0100477hw_perf_counter_init(struct perf_counter *counter);
478
Thomas Gleixner0793a612008-12-04 20:12:29 +0100479extern void perf_counter_task_sched_in(struct task_struct *task, int cpu);
480extern void perf_counter_task_sched_out(struct task_struct *task, int cpu);
481extern void perf_counter_task_tick(struct task_struct *task, int cpu);
Ingo Molnar9b51f662008-12-12 13:49:45 +0100482extern void perf_counter_init_task(struct task_struct *child);
483extern void perf_counter_exit_task(struct task_struct *child);
Peter Zijlstra925d5192009-03-30 19:07:02 +0200484extern void perf_counter_do_pending(void);
Thomas Gleixner0793a612008-12-04 20:12:29 +0100485extern void perf_counter_print_debug(void);
Mike Galbraith1b023a92009-01-23 10:13:01 +0100486extern void perf_counter_unthrottle(void);
Ingo Molnar01b28382008-12-11 13:45:51 +0100487extern u64 hw_perf_save_disable(void);
488extern void hw_perf_restore(u64 ctrl);
Ingo Molnar1d1c7dd2008-12-11 14:59:31 +0100489extern int perf_counter_task_disable(void);
490extern int perf_counter_task_enable(void);
Paul Mackerras3cbed422009-01-09 16:43:42 +1100491extern int hw_perf_group_sched_in(struct perf_counter *group_leader,
492 struct perf_cpu_context *cpuctx,
493 struct perf_counter_context *ctx, int cpu);
Paul Mackerras37d81822009-03-23 18:22:08 +0100494extern void perf_counter_update_userpage(struct perf_counter *counter);
Ingo Molnar5c92d122008-12-11 13:21:10 +0100495
Peter Zijlstra0322cd62009-03-19 20:26:19 +0100496extern void perf_counter_output(struct perf_counter *counter,
497 int nmi, struct pt_regs *regs);
Paul Mackerras3b6f9e52009-01-14 21:00:30 +1100498/*
499 * Return 1 for a software counter, 0 for a hardware counter
500 */
501static inline int is_software_counter(struct perf_counter *counter)
502{
Peter Zijlstraf4a2deb42009-03-23 18:22:06 +0100503 return !perf_event_raw(&counter->hw_event) &&
504 perf_event_type(&counter->hw_event) != PERF_TYPE_HARDWARE;
Paul Mackerras3b6f9e52009-01-14 21:00:30 +1100505}
506
Peter Zijlstrab8e83512009-03-19 20:26:18 +0100507extern void perf_swcounter_event(u32, u64, int, struct pt_regs *);
Peter Zijlstra15dbf272009-03-13 12:21:32 +0100508
Peter Zijlstra0a4a9392009-03-30 19:07:05 +0200509extern void perf_counter_mmap(unsigned long addr, unsigned long len,
510 unsigned long pgoff, struct file *file);
511
512extern void perf_counter_munmap(unsigned long addr, unsigned long len,
513 unsigned long pgoff, struct file *file);
514
Peter Zijlstra394ee072009-03-30 19:07:14 +0200515#define MAX_STACK_DEPTH 255
516
517struct perf_callchain_entry {
518 u64 nr;
519 u64 ip[MAX_STACK_DEPTH];
520};
521
522extern struct perf_callchain_entry *perf_callchain(struct pt_regs *regs);
523
Thomas Gleixner0793a612008-12-04 20:12:29 +0100524#else
525static inline void
526perf_counter_task_sched_in(struct task_struct *task, int cpu) { }
527static inline void
528perf_counter_task_sched_out(struct task_struct *task, int cpu) { }
529static inline void
530perf_counter_task_tick(struct task_struct *task, int cpu) { }
Ingo Molnar9b51f662008-12-12 13:49:45 +0100531static inline void perf_counter_init_task(struct task_struct *child) { }
532static inline void perf_counter_exit_task(struct task_struct *child) { }
Peter Zijlstra925d5192009-03-30 19:07:02 +0200533static inline void perf_counter_do_pending(void) { }
Thomas Gleixner0793a612008-12-04 20:12:29 +0100534static inline void perf_counter_print_debug(void) { }
Mike Galbraith1b023a92009-01-23 10:13:01 +0100535static inline void perf_counter_unthrottle(void) { }
Peter Zijlstra15dbf272009-03-13 12:21:32 +0100536static inline void hw_perf_restore(u64 ctrl) { }
Ingo Molnar01b28382008-12-11 13:45:51 +0100537static inline u64 hw_perf_save_disable(void) { return 0; }
Ingo Molnar1d1c7dd2008-12-11 14:59:31 +0100538static inline int perf_counter_task_disable(void) { return -EINVAL; }
539static inline int perf_counter_task_enable(void) { return -EINVAL; }
Peter Zijlstra15dbf272009-03-13 12:21:32 +0100540
Peter Zijlstra925d5192009-03-30 19:07:02 +0200541static inline void
542perf_swcounter_event(u32 event, u64 nr, int nmi, struct pt_regs *regs) { }
543
Peter Zijlstra0a4a9392009-03-30 19:07:05 +0200544
545static inline void
546perf_counter_mmap(unsigned long addr, unsigned long len,
547 unsigned long pgoff, struct file *file) { }
548
549static inline void
550perf_counter_munmap(unsigned long addr, unsigned long len,
551 unsigned long pgoff, struct file *file) { }
552
Thomas Gleixner0793a612008-12-04 20:12:29 +0100553#endif
554
Paul Mackerrasf3dfd262009-02-26 22:43:46 +1100555#endif /* __KERNEL__ */
Thomas Gleixner0793a612008-12-04 20:12:29 +0100556#endif /* _LINUX_PERF_COUNTER_H */