blob: 412b790f5da62f19ed085c0255495367bda111ed [file] [log] [blame]
Thomas Gleixner0793a612008-12-04 20:12:29 +01001/*
Ingo Molnar57c0c152009-09-21 12:20:38 +02002 * Performance events:
Thomas Gleixner0793a612008-12-04 20:12:29 +01003 *
Ingo Molnara3084442009-06-11 14:44:26 +02004 * Copyright (C) 2008-2009, Thomas Gleixner <tglx@linutronix.de>
Ingo Molnare7e7ee22011-05-04 08:42:29 +02005 * Copyright (C) 2008-2011, Red Hat, Inc., Ingo Molnar
6 * Copyright (C) 2008-2011, Red Hat, Inc., Peter Zijlstra
Thomas Gleixner0793a612008-12-04 20:12:29 +01007 *
Ingo Molnar57c0c152009-09-21 12:20:38 +02008 * Data type definitions, declarations, prototypes.
Thomas Gleixner0793a612008-12-04 20:12:29 +01009 *
Ingo Molnara3084442009-06-11 14:44:26 +020010 * Started by: Thomas Gleixner and Ingo Molnar
Thomas Gleixner0793a612008-12-04 20:12:29 +010011 *
Ingo Molnar57c0c152009-09-21 12:20:38 +020012 * For licencing details see kernel-base/COPYING
Thomas Gleixner0793a612008-12-04 20:12:29 +010013 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +020014#ifndef _LINUX_PERF_EVENT_H
15#define _LINUX_PERF_EVENT_H
Thomas Gleixner0793a612008-12-04 20:12:29 +010016
Paul Mackerrasf3dfd262009-02-26 22:43:46 +110017#include <linux/types.h>
18#include <linux/ioctl.h>
Paul Mackerras9aaa1312009-03-21 15:31:47 +110019#include <asm/byteorder.h>
Thomas Gleixner0793a612008-12-04 20:12:29 +010020
21/*
Ingo Molnar9f66a382008-12-10 12:33:23 +010022 * User-space ABI bits:
23 */
24
25/*
Peter Zijlstra0d486962009-06-02 19:22:16 +020026 * attr.type
Peter Zijlstrab8e83512009-03-19 20:26:18 +010027 */
Peter Zijlstra1c432d82009-06-11 13:19:29 +020028enum perf_type_id {
Ingo Molnara3084442009-06-11 14:44:26 +020029 PERF_TYPE_HARDWARE = 0,
30 PERF_TYPE_SOFTWARE = 1,
31 PERF_TYPE_TRACEPOINT = 2,
32 PERF_TYPE_HW_CACHE = 3,
33 PERF_TYPE_RAW = 4,
Frederic Weisbecker24f1e32c2009-09-09 19:22:48 +020034 PERF_TYPE_BREAKPOINT = 5,
Peter Zijlstrab8e83512009-03-19 20:26:18 +010035
Ingo Molnara3084442009-06-11 14:44:26 +020036 PERF_TYPE_MAX, /* non-ABI */
Peter Zijlstrab8e83512009-03-19 20:26:18 +010037};
38
39/*
Ingo Molnarcdd6c482009-09-21 12:02:48 +020040 * Generalized performance event event_id types, used by the
41 * attr.event_id parameter of the sys_perf_event_open()
Ingo Molnara3084442009-06-11 14:44:26 +020042 * syscall:
Thomas Gleixner0793a612008-12-04 20:12:29 +010043 */
Peter Zijlstra1c432d82009-06-11 13:19:29 +020044enum perf_hw_id {
Thomas Gleixner0793a612008-12-04 20:12:29 +010045 /*
Ingo Molnar9f66a382008-12-10 12:33:23 +010046 * Common hardware events, generalized by the kernel:
Thomas Gleixner0793a612008-12-04 20:12:29 +010047 */
Peter Zijlstraf4dbfa82009-06-11 14:06:28 +020048 PERF_COUNT_HW_CPU_CYCLES = 0,
49 PERF_COUNT_HW_INSTRUCTIONS = 1,
50 PERF_COUNT_HW_CACHE_REFERENCES = 2,
51 PERF_COUNT_HW_CACHE_MISSES = 3,
52 PERF_COUNT_HW_BRANCH_INSTRUCTIONS = 4,
53 PERF_COUNT_HW_BRANCH_MISSES = 5,
54 PERF_COUNT_HW_BUS_CYCLES = 6,
Ingo Molnar8f622422011-04-29 13:19:47 +020055 PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 7,
56 PERF_COUNT_HW_STALLED_CYCLES_BACKEND = 8,
Stephane Eranianc37e1742011-12-11 00:28:52 +010057 PERF_COUNT_HW_REF_CPU_CYCLES = 9,
Ingo Molnar9f66a382008-12-10 12:33:23 +010058
Ingo Molnara3084442009-06-11 14:44:26 +020059 PERF_COUNT_HW_MAX, /* non-ABI */
Peter Zijlstrab8e83512009-03-19 20:26:18 +010060};
Ingo Molnar6c594c22008-12-14 12:34:15 +010061
Peter Zijlstrab8e83512009-03-19 20:26:18 +010062/*
Ingo Molnarcdd6c482009-09-21 12:02:48 +020063 * Generalized hardware cache events:
Ingo Molnar8326f442009-06-05 20:22:46 +020064 *
Peter Zijlstra89d6c0b2011-04-22 23:37:06 +020065 * { L1-D, L1-I, LLC, ITLB, DTLB, BPU, NODE } x
Ingo Molnar8326f442009-06-05 20:22:46 +020066 * { read, write, prefetch } x
67 * { accesses, misses }
68 */
Peter Zijlstra1c432d82009-06-11 13:19:29 +020069enum perf_hw_cache_id {
Ingo Molnara3084442009-06-11 14:44:26 +020070 PERF_COUNT_HW_CACHE_L1D = 0,
71 PERF_COUNT_HW_CACHE_L1I = 1,
72 PERF_COUNT_HW_CACHE_LL = 2,
73 PERF_COUNT_HW_CACHE_DTLB = 3,
74 PERF_COUNT_HW_CACHE_ITLB = 4,
75 PERF_COUNT_HW_CACHE_BPU = 5,
Peter Zijlstra89d6c0b2011-04-22 23:37:06 +020076 PERF_COUNT_HW_CACHE_NODE = 6,
Ingo Molnar8326f442009-06-05 20:22:46 +020077
Ingo Molnara3084442009-06-11 14:44:26 +020078 PERF_COUNT_HW_CACHE_MAX, /* non-ABI */
Ingo Molnar8326f442009-06-05 20:22:46 +020079};
80
Peter Zijlstra1c432d82009-06-11 13:19:29 +020081enum perf_hw_cache_op_id {
Ingo Molnara3084442009-06-11 14:44:26 +020082 PERF_COUNT_HW_CACHE_OP_READ = 0,
83 PERF_COUNT_HW_CACHE_OP_WRITE = 1,
84 PERF_COUNT_HW_CACHE_OP_PREFETCH = 2,
Ingo Molnar8326f442009-06-05 20:22:46 +020085
Ingo Molnara3084442009-06-11 14:44:26 +020086 PERF_COUNT_HW_CACHE_OP_MAX, /* non-ABI */
Ingo Molnar8326f442009-06-05 20:22:46 +020087};
88
Peter Zijlstra1c432d82009-06-11 13:19:29 +020089enum perf_hw_cache_op_result_id {
90 PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0,
91 PERF_COUNT_HW_CACHE_RESULT_MISS = 1,
Ingo Molnar8326f442009-06-05 20:22:46 +020092
Ingo Molnara3084442009-06-11 14:44:26 +020093 PERF_COUNT_HW_CACHE_RESULT_MAX, /* non-ABI */
Ingo Molnar8326f442009-06-05 20:22:46 +020094};
95
96/*
Ingo Molnarcdd6c482009-09-21 12:02:48 +020097 * Special "software" events provided by the kernel, even if the hardware
98 * does not support performance events. These events measure various
Peter Zijlstrab8e83512009-03-19 20:26:18 +010099 * physical and sw events of the kernel (and allow the profiling of them as
100 * well):
101 */
Peter Zijlstra1c432d82009-06-11 13:19:29 +0200102enum perf_sw_ids {
Ingo Molnara3084442009-06-11 14:44:26 +0200103 PERF_COUNT_SW_CPU_CLOCK = 0,
104 PERF_COUNT_SW_TASK_CLOCK = 1,
105 PERF_COUNT_SW_PAGE_FAULTS = 2,
106 PERF_COUNT_SW_CONTEXT_SWITCHES = 3,
107 PERF_COUNT_SW_CPU_MIGRATIONS = 4,
108 PERF_COUNT_SW_PAGE_FAULTS_MIN = 5,
109 PERF_COUNT_SW_PAGE_FAULTS_MAJ = 6,
Anton Blanchardf7d79862009-10-18 01:09:29 +0000110 PERF_COUNT_SW_ALIGNMENT_FAULTS = 7,
111 PERF_COUNT_SW_EMULATION_FAULTS = 8,
Ingo Molnar6c594c22008-12-14 12:34:15 +0100112
Ingo Molnara3084442009-06-11 14:44:26 +0200113 PERF_COUNT_SW_MAX, /* non-ABI */
Thomas Gleixner0793a612008-12-04 20:12:29 +0100114};
115
Ingo Molnar9f66a382008-12-10 12:33:23 +0100116/*
Peter Zijlstra0d486962009-06-02 19:22:16 +0200117 * Bits that can be set in attr.sample_type to request information
Peter Zijlstra8a057d82009-04-02 11:11:59 +0200118 * in the overflow packets.
119 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200120enum perf_event_sample_format {
Ingo Molnara3084442009-06-11 14:44:26 +0200121 PERF_SAMPLE_IP = 1U << 0,
122 PERF_SAMPLE_TID = 1U << 1,
123 PERF_SAMPLE_TIME = 1U << 2,
124 PERF_SAMPLE_ADDR = 1U << 3,
Peter Zijlstra3dab77f2009-08-13 11:47:53 +0200125 PERF_SAMPLE_READ = 1U << 4,
Ingo Molnara3084442009-06-11 14:44:26 +0200126 PERF_SAMPLE_CALLCHAIN = 1U << 5,
127 PERF_SAMPLE_ID = 1U << 6,
128 PERF_SAMPLE_CPU = 1U << 7,
129 PERF_SAMPLE_PERIOD = 1U << 8,
Peter Zijlstra7f453c22009-07-21 13:19:40 +0200130 PERF_SAMPLE_STREAM_ID = 1U << 9,
Frederic Weisbecker3a43ce62009-08-08 04:26:37 +0200131 PERF_SAMPLE_RAW = 1U << 10,
Peter Zijlstra974802e2009-06-12 12:46:55 +0200132
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200133 PERF_SAMPLE_MAX = 1U << 11, /* non-ABI */
Peter Zijlstra8a057d82009-04-02 11:11:59 +0200134};
135
136/*
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200137 * The format of the data returned by read() on a perf event fd,
Peter Zijlstra3dab77f2009-08-13 11:47:53 +0200138 * as specified by attr.read_format:
139 *
140 * struct read_format {
Ingo Molnar57c0c152009-09-21 12:20:38 +0200141 * { u64 value;
Vince Weaverd7ebe752011-06-03 17:59:51 -0400142 * { u64 time_enabled; } && PERF_FORMAT_TOTAL_TIME_ENABLED
143 * { u64 time_running; } && PERF_FORMAT_TOTAL_TIME_RUNNING
Ingo Molnar57c0c152009-09-21 12:20:38 +0200144 * { u64 id; } && PERF_FORMAT_ID
145 * } && !PERF_FORMAT_GROUP
Peter Zijlstra3dab77f2009-08-13 11:47:53 +0200146 *
Ingo Molnar57c0c152009-09-21 12:20:38 +0200147 * { u64 nr;
Vince Weaverd7ebe752011-06-03 17:59:51 -0400148 * { u64 time_enabled; } && PERF_FORMAT_TOTAL_TIME_ENABLED
149 * { u64 time_running; } && PERF_FORMAT_TOTAL_TIME_RUNNING
Ingo Molnar57c0c152009-09-21 12:20:38 +0200150 * { u64 value;
151 * { u64 id; } && PERF_FORMAT_ID
152 * } cntr[nr];
153 * } && PERF_FORMAT_GROUP
Peter Zijlstra3dab77f2009-08-13 11:47:53 +0200154 * };
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100155 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200156enum perf_event_read_format {
Ingo Molnara3084442009-06-11 14:44:26 +0200157 PERF_FORMAT_TOTAL_TIME_ENABLED = 1U << 0,
158 PERF_FORMAT_TOTAL_TIME_RUNNING = 1U << 1,
159 PERF_FORMAT_ID = 1U << 2,
Peter Zijlstra3dab77f2009-08-13 11:47:53 +0200160 PERF_FORMAT_GROUP = 1U << 3,
Peter Zijlstra974802e2009-06-12 12:46:55 +0200161
Ingo Molnar57c0c152009-09-21 12:20:38 +0200162 PERF_FORMAT_MAX = 1U << 4, /* non-ABI */
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100163};
164
Peter Zijlstra974802e2009-06-12 12:46:55 +0200165#define PERF_ATTR_SIZE_VER0 64 /* sizeof first published struct */
166
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100167/*
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200168 * Hardware event_id to monitor via a performance monitoring event:
Ingo Molnar9f66a382008-12-10 12:33:23 +0100169 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200170struct perf_event_attr {
Peter Zijlstra974802e2009-06-12 12:46:55 +0200171
Peter Zijlstraf4a2deb2009-03-23 18:22:06 +0100172 /*
Ingo Molnara21ca2c2009-06-06 09:58:57 +0200173 * Major type: hardware/software/tracepoint/etc.
174 */
175 __u32 type;
Peter Zijlstra974802e2009-06-12 12:46:55 +0200176
177 /*
178 * Size of the attr structure, for fwd/bwd compat.
179 */
180 __u32 size;
Ingo Molnara21ca2c2009-06-06 09:58:57 +0200181
182 /*
183 * Type specific configuration information.
Peter Zijlstraf4a2deb2009-03-23 18:22:06 +0100184 */
185 __u64 config;
Ingo Molnar9f66a382008-12-10 12:33:23 +0100186
Peter Zijlstra60db5e02009-05-15 15:19:28 +0200187 union {
Peter Zijlstrab23f3322009-06-02 15:13:03 +0200188 __u64 sample_period;
189 __u64 sample_freq;
Peter Zijlstra60db5e02009-05-15 15:19:28 +0200190 };
191
Peter Zijlstrab23f3322009-06-02 15:13:03 +0200192 __u64 sample_type;
193 __u64 read_format;
Ingo Molnar9f66a382008-12-10 12:33:23 +0100194
Paul Mackerras2743a5b2009-03-04 20:36:51 +1100195 __u64 disabled : 1, /* off by default */
Paul Mackerras0475f9e2009-02-11 14:35:35 +1100196 inherit : 1, /* children inherit it */
197 pinned : 1, /* must always be on PMU */
198 exclusive : 1, /* only group on PMU */
199 exclude_user : 1, /* don't count user */
200 exclude_kernel : 1, /* ditto kernel */
201 exclude_hv : 1, /* ditto hypervisor */
Paul Mackerras2743a5b2009-03-04 20:36:51 +1100202 exclude_idle : 1, /* don't count when idle */
Peter Zijlstra0a4a9392009-03-30 19:07:05 +0200203 mmap : 1, /* include mmap data */
Peter Zijlstra8d1b2d92009-04-08 15:01:30 +0200204 comm : 1, /* include comm data */
Peter Zijlstra60db5e02009-05-15 15:19:28 +0200205 freq : 1, /* use freq, not period */
Peter Zijlstrabfbd3382009-06-24 21:11:59 +0200206 inherit_stat : 1, /* per task counts */
Paul Mackerras57e79862009-06-30 16:07:19 +1000207 enable_on_exec : 1, /* next exec enables */
Peter Zijlstra9f498cc2009-07-23 14:46:33 +0200208 task : 1, /* trace fork/exit */
Peter Zijlstra2667de812009-09-17 19:01:10 +0200209 watermark : 1, /* wakeup_watermark */
Peter Zijlstraab608342010-04-08 23:03:20 +0200210 /*
211 * precise_ip:
212 *
213 * 0 - SAMPLE_IP can have arbitrary skid
214 * 1 - SAMPLE_IP must have constant skid
215 * 2 - SAMPLE_IP requested to have 0 skid
216 * 3 - SAMPLE_IP must have 0 skid
217 *
218 * See also PERF_RECORD_MISC_EXACT_IP
219 */
220 precise_ip : 2, /* skid constraint */
Eric B Munson3af9e852010-05-18 15:30:49 +0100221 mmap_data : 1, /* non-exec mmap data */
Arnaldo Carvalho de Meloc980d102010-12-04 23:02:20 -0200222 sample_id_all : 1, /* sample_type all events */
Paul Mackerras3b6f9e52009-01-14 21:00:30 +1100223
Joerg Roedela240f762011-10-05 14:01:16 +0200224 exclude_host : 1, /* don't count in host */
225 exclude_guest : 1, /* don't count in guest */
226
227 __reserved_1 : 43;
Paul Mackerras2743a5b2009-03-04 20:36:51 +1100228
Peter Zijlstra2667de812009-09-17 19:01:10 +0200229 union {
230 __u32 wakeup_events; /* wakeup every n events */
231 __u32 wakeup_watermark; /* bytes before wakeup */
232 };
Frederic Weisbecker24f1e32c2009-09-09 19:22:48 +0200233
Peter Zijlstraf13c12c2009-12-15 19:43:11 +0100234 __u32 bp_type;
Andi Kleena7e3ed12011-03-03 10:34:47 +0800235 union {
236 __u64 bp_addr;
237 __u64 config1; /* extension of config */
238 };
239 union {
240 __u64 bp_len;
241 __u64 config2; /* extension of config1 */
242 };
Thomas Gleixnereab656a2008-12-08 19:26:59 +0100243};
244
Ingo Molnar9f66a382008-12-10 12:33:23 +0100245/*
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200246 * Ioctls that can be done on a perf event fd:
Paul Mackerrasd859e292009-01-17 18:10:22 +1100247 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200248#define PERF_EVENT_IOC_ENABLE _IO ('$', 0)
Ingo Molnar57c0c152009-09-21 12:20:38 +0200249#define PERF_EVENT_IOC_DISABLE _IO ('$', 1)
250#define PERF_EVENT_IOC_REFRESH _IO ('$', 2)
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200251#define PERF_EVENT_IOC_RESET _IO ('$', 3)
Arjan van de Ven4c49b122009-11-13 21:47:33 -0800252#define PERF_EVENT_IOC_PERIOD _IOW('$', 4, __u64)
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200253#define PERF_EVENT_IOC_SET_OUTPUT _IO ('$', 5)
Li Zefan6fb29152009-10-15 11:21:42 +0800254#define PERF_EVENT_IOC_SET_FILTER _IOW('$', 6, char *)
Peter Zijlstra3df5eda2009-05-08 18:52:22 +0200255
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200256enum perf_event_ioc_flags {
Peter Zijlstra3df5eda2009-05-08 18:52:22 +0200257 PERF_IOC_FLAG_GROUP = 1U << 0,
258};
Paul Mackerrasd859e292009-01-17 18:10:22 +1100259
Paul Mackerras37d81822009-03-23 18:22:08 +0100260/*
261 * Structure of the page that can be mapped via mmap
262 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200263struct perf_event_mmap_page {
Paul Mackerras37d81822009-03-23 18:22:08 +0100264 __u32 version; /* version number of this structure */
265 __u32 compat_version; /* lowest version this is compat with */
Peter Zijlstra38ff6672009-03-30 19:07:03 +0200266
267 /*
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200268 * Bits needed to read the hw events in user-space.
Peter Zijlstra38ff6672009-03-30 19:07:03 +0200269 *
Peter Zijlstra92f22a32009-04-02 11:12:04 +0200270 * u32 seq;
271 * s64 count;
Peter Zijlstra38ff6672009-03-30 19:07:03 +0200272 *
Peter Zijlstraa2e87d02009-04-06 11:44:59 +0200273 * do {
274 * seq = pc->lock;
Peter Zijlstra38ff6672009-03-30 19:07:03 +0200275 *
Peter Zijlstraa2e87d02009-04-06 11:44:59 +0200276 * barrier()
277 * if (pc->index) {
278 * count = pmc_read(pc->index - 1);
279 * count += pc->offset;
280 * } else
281 * goto regular_read;
Peter Zijlstra38ff6672009-03-30 19:07:03 +0200282 *
Peter Zijlstraa2e87d02009-04-06 11:44:59 +0200283 * barrier();
284 * } while (pc->lock != seq);
Peter Zijlstra38ff6672009-03-30 19:07:03 +0200285 *
Peter Zijlstra92f22a32009-04-02 11:12:04 +0200286 * NOTE: for obvious reason this only works on self-monitoring
287 * processes.
Peter Zijlstra38ff6672009-03-30 19:07:03 +0200288 */
Paul Mackerras37d81822009-03-23 18:22:08 +0100289 __u32 lock; /* seqlock for synchronization */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200290 __u32 index; /* hardware event identifier */
291 __s64 offset; /* add to hardware event value */
292 __u64 time_enabled; /* time event active */
293 __u64 time_running; /* time event on cpu */
Peter Zijlstrae3f35412011-11-21 11:43:53 +0100294 __u32 time_mult, time_shift;
295 __u64 time_offset;
Peter Zijlstra7b732a72009-03-23 18:22:10 +0100296
Peter Zijlstra41f95332009-06-23 17:55:18 +0200297 /*
298 * Hole for extension of the self monitor capabilities
299 */
300
Peter Zijlstrae3f35412011-11-21 11:43:53 +0100301 __u64 __reserved[121]; /* align to 1k */
Peter Zijlstra41f95332009-06-23 17:55:18 +0200302
Peter Zijlstra38ff6672009-03-30 19:07:03 +0200303 /*
304 * Control data for the mmap() data buffer.
305 *
Peter Zijlstra43a21ea2009-03-25 19:39:37 +0100306 * User-space reading the @data_head value should issue an rmb(), on
307 * SMP capable platforms, after reading this value -- see
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200308 * perf_event_wakeup().
Peter Zijlstra43a21ea2009-03-25 19:39:37 +0100309 *
310 * When the mapping is PROT_WRITE the @data_tail value should be
311 * written by userspace to reflect the last read data. In this case
312 * the kernel will not over-write unread data.
Peter Zijlstra38ff6672009-03-30 19:07:03 +0200313 */
Peter Zijlstra8e3747c2009-06-02 16:16:02 +0200314 __u64 data_head; /* head in the data section */
Peter Zijlstra43a21ea2009-03-25 19:39:37 +0100315 __u64 data_tail; /* user-space written tail */
Paul Mackerras37d81822009-03-23 18:22:08 +0100316};
317
Zhang, Yanmin39447b32010-04-19 13:32:41 +0800318#define PERF_RECORD_MISC_CPUMODE_MASK (7 << 0)
Ingo Molnar184f4122010-01-27 08:39:39 +0100319#define PERF_RECORD_MISC_CPUMODE_UNKNOWN (0 << 0)
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200320#define PERF_RECORD_MISC_KERNEL (1 << 0)
321#define PERF_RECORD_MISC_USER (2 << 0)
322#define PERF_RECORD_MISC_HYPERVISOR (3 << 0)
Zhang, Yanmin39447b32010-04-19 13:32:41 +0800323#define PERF_RECORD_MISC_GUEST_KERNEL (4 << 0)
324#define PERF_RECORD_MISC_GUEST_USER (5 << 0)
Peter Zijlstra6fab0192009-04-08 15:01:26 +0200325
Peter Zijlstraab608342010-04-08 23:03:20 +0200326/*
327 * Indicates that the content of PERF_SAMPLE_IP points to
328 * the actual instruction that triggered the event. See also
329 * perf_event_attr::precise_ip.
330 */
331#define PERF_RECORD_MISC_EXACT_IP (1 << 14)
Peter Zijlstraef21f682010-03-03 13:12:23 +0100332/*
333 * Reserve the last bit to indicate some extended misc field
334 */
335#define PERF_RECORD_MISC_EXT_RESERVED (1 << 15)
336
Peter Zijlstra5c148192009-03-25 12:30:23 +0100337struct perf_event_header {
338 __u32 type;
Peter Zijlstra6fab0192009-04-08 15:01:26 +0200339 __u16 misc;
340 __u16 size;
Peter Zijlstra5c148192009-03-25 12:30:23 +0100341};
342
343enum perf_event_type {
Peter Zijlstra5ed00412009-03-30 19:07:12 +0200344
Peter Zijlstra0c593b32009-04-06 11:45:08 +0200345 /*
Arnaldo Carvalho de Meloc980d102010-12-04 23:02:20 -0200346 * If perf_event_attr.sample_id_all is set then all event types will
347 * have the sample_type selected fields related to where/when
348 * (identity) an event took place (TID, TIME, ID, CPU, STREAM_ID)
349 * described in PERF_RECORD_SAMPLE below, it will be stashed just after
350 * the perf_event_header and the fields already present for the existing
351 * fields, i.e. at the end of the payload. That way a newer perf.data
352 * file will be supported by older perf tools, with these new optional
353 * fields being ignored.
354 *
Peter Zijlstra0c593b32009-04-06 11:45:08 +0200355 * The MMAP events record the PROT_EXEC mappings so that we can
356 * correlate userspace IPs to code. They have the following structure:
357 *
358 * struct {
Ingo Molnar0127c3e2009-05-25 22:03:26 +0200359 * struct perf_event_header header;
Peter Zijlstra0c593b32009-04-06 11:45:08 +0200360 *
Ingo Molnar0127c3e2009-05-25 22:03:26 +0200361 * u32 pid, tid;
362 * u64 addr;
363 * u64 len;
364 * u64 pgoff;
365 * char filename[];
Peter Zijlstra0c593b32009-04-06 11:45:08 +0200366 * };
367 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200368 PERF_RECORD_MMAP = 1,
Peter Zijlstraea5d20c2009-03-25 12:30:25 +0100369
Peter Zijlstra8a057d82009-04-02 11:11:59 +0200370 /*
Peter Zijlstra8d1b2d92009-04-08 15:01:30 +0200371 * struct {
Ingo Molnar57c0c152009-09-21 12:20:38 +0200372 * struct perf_event_header header;
373 * u64 id;
374 * u64 lost;
Peter Zijlstra43a21ea2009-03-25 19:39:37 +0100375 * };
376 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200377 PERF_RECORD_LOST = 2,
Peter Zijlstra43a21ea2009-03-25 19:39:37 +0100378
379 /*
380 * struct {
Ingo Molnar0127c3e2009-05-25 22:03:26 +0200381 * struct perf_event_header header;
Peter Zijlstra8d1b2d92009-04-08 15:01:30 +0200382 *
Ingo Molnar0127c3e2009-05-25 22:03:26 +0200383 * u32 pid, tid;
384 * char comm[];
Peter Zijlstra8d1b2d92009-04-08 15:01:30 +0200385 * };
386 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200387 PERF_RECORD_COMM = 3,
Peter Zijlstra8d1b2d92009-04-08 15:01:30 +0200388
389 /*
Peter Zijlstra26b119b2009-05-20 12:21:20 +0200390 * struct {
Ingo Molnar0127c3e2009-05-25 22:03:26 +0200391 * struct perf_event_header header;
Peter Zijlstra9f498cc2009-07-23 14:46:33 +0200392 * u32 pid, ppid;
393 * u32 tid, ptid;
Arjan van de Ven393b2ad2009-09-12 07:52:47 +0200394 * u64 time;
Peter Zijlstra9f498cc2009-07-23 14:46:33 +0200395 * };
396 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200397 PERF_RECORD_EXIT = 4,
Peter Zijlstra9f498cc2009-07-23 14:46:33 +0200398
399 /*
400 * struct {
401 * struct perf_event_header header;
Ingo Molnar0127c3e2009-05-25 22:03:26 +0200402 * u64 time;
Peter Zijlstra689802b2009-06-05 15:05:43 +0200403 * u64 id;
Peter Zijlstra7f453c22009-07-21 13:19:40 +0200404 * u64 stream_id;
Peter Zijlstraa78ac322009-05-25 17:39:05 +0200405 * };
406 */
Ingo Molnar184f4122010-01-27 08:39:39 +0100407 PERF_RECORD_THROTTLE = 5,
408 PERF_RECORD_UNTHROTTLE = 6,
Peter Zijlstraa78ac322009-05-25 17:39:05 +0200409
410 /*
Peter Zijlstra60313eb2009-06-04 16:53:44 +0200411 * struct {
Ingo Molnara21ca2c2009-06-06 09:58:57 +0200412 * struct perf_event_header header;
413 * u32 pid, ppid;
Peter Zijlstra9f498cc2009-07-23 14:46:33 +0200414 * u32 tid, ptid;
Anton Blancharda6f10a22009-09-22 22:34:24 +1000415 * u64 time;
Peter Zijlstra60313eb2009-06-04 16:53:44 +0200416 * };
417 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200418 PERF_RECORD_FORK = 7,
Peter Zijlstra60313eb2009-06-04 16:53:44 +0200419
420 /*
Peter Zijlstra38b200d2009-06-23 20:13:11 +0200421 * struct {
Ingo Molnar184f4122010-01-27 08:39:39 +0100422 * struct perf_event_header header;
423 * u32 pid, tid;
Peter Zijlstra3dab77f2009-08-13 11:47:53 +0200424 *
Ingo Molnar184f4122010-01-27 08:39:39 +0100425 * struct read_format values;
Peter Zijlstra38b200d2009-06-23 20:13:11 +0200426 * };
427 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200428 PERF_RECORD_READ = 8,
Peter Zijlstra38b200d2009-06-23 20:13:11 +0200429
430 /*
Peter Zijlstra0c593b32009-04-06 11:45:08 +0200431 * struct {
Ingo Molnar0127c3e2009-05-25 22:03:26 +0200432 * struct perf_event_header header;
Peter Zijlstra0c593b32009-04-06 11:45:08 +0200433 *
Peter Zijlstra43a21ea2009-03-25 19:39:37 +0100434 * { u64 ip; } && PERF_SAMPLE_IP
435 * { u32 pid, tid; } && PERF_SAMPLE_TID
436 * { u64 time; } && PERF_SAMPLE_TIME
437 * { u64 addr; } && PERF_SAMPLE_ADDR
Peter Zijlstrae6e18ec2009-06-25 11:27:12 +0200438 * { u64 id; } && PERF_SAMPLE_ID
Peter Zijlstra7f453c22009-07-21 13:19:40 +0200439 * { u64 stream_id;} && PERF_SAMPLE_STREAM_ID
Peter Zijlstra43a21ea2009-03-25 19:39:37 +0100440 * { u32 cpu, res; } && PERF_SAMPLE_CPU
Ingo Molnar57c0c152009-09-21 12:20:38 +0200441 * { u64 period; } && PERF_SAMPLE_PERIOD
Peter Zijlstra0c593b32009-04-06 11:45:08 +0200442 *
Peter Zijlstra3dab77f2009-08-13 11:47:53 +0200443 * { struct read_format values; } && PERF_SAMPLE_READ
Peter Zijlstra0c593b32009-04-06 11:45:08 +0200444 *
Peter Zijlstraf9188e02009-06-18 22:20:52 +0200445 * { u64 nr,
Peter Zijlstra43a21ea2009-03-25 19:39:37 +0100446 * u64 ips[nr]; } && PERF_SAMPLE_CALLCHAIN
Peter Zijlstra3dab77f2009-08-13 11:47:53 +0200447 *
Ingo Molnar57c0c152009-09-21 12:20:38 +0200448 * #
449 * # The RAW record below is opaque data wrt the ABI
450 * #
451 * # That is, the ABI doesn't make any promises wrt to
452 * # the stability of its content, it may vary depending
453 * # on event, hardware, kernel version and phase of
454 * # the moon.
455 * #
456 * # In other words, PERF_SAMPLE_RAW contents are not an ABI.
457 * #
Peter Zijlstra3dab77f2009-08-13 11:47:53 +0200458 *
Peter Zijlstraa0445602009-08-10 11:16:52 +0200459 * { u32 size;
460 * char data[size];}&& PERF_SAMPLE_RAW
Peter Zijlstra0c593b32009-04-06 11:45:08 +0200461 * };
Peter Zijlstra8a057d82009-04-02 11:11:59 +0200462 */
Ingo Molnar184f4122010-01-27 08:39:39 +0100463 PERF_RECORD_SAMPLE = 9,
Peter Zijlstrae6e18ec2009-06-25 11:27:12 +0200464
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200465 PERF_RECORD_MAX, /* non-ABI */
Peter Zijlstra5c148192009-03-25 12:30:23 +0100466};
467
Peter Zijlstraf9188e02009-06-18 22:20:52 +0200468enum perf_callchain_context {
469 PERF_CONTEXT_HV = (__u64)-32,
470 PERF_CONTEXT_KERNEL = (__u64)-128,
471 PERF_CONTEXT_USER = (__u64)-512,
Ingo Molnar75220602009-06-18 08:00:17 +0200472
Peter Zijlstraf9188e02009-06-18 22:20:52 +0200473 PERF_CONTEXT_GUEST = (__u64)-2048,
474 PERF_CONTEXT_GUEST_KERNEL = (__u64)-2176,
475 PERF_CONTEXT_GUEST_USER = (__u64)-2560,
476
477 PERF_CONTEXT_MAX = (__u64)-4095,
Ingo Molnar75220602009-06-18 08:00:17 +0200478};
479
Ingo Molnare7e7ee22011-05-04 08:42:29 +0200480#define PERF_FLAG_FD_NO_GROUP (1U << 0)
481#define PERF_FLAG_FD_OUTPUT (1U << 1)
482#define PERF_FLAG_PID_CGROUP (1U << 2) /* pid=cgroup id, per-cpu mode only */
Peter Zijlstraa4be7c22009-08-19 11:18:27 +0200483
Paul Mackerrasf3dfd262009-02-26 22:43:46 +1100484#ifdef __KERNEL__
Paul Mackerrasd859e292009-01-17 18:10:22 +1100485/*
Paul Mackerrasf3dfd262009-02-26 22:43:46 +1100486 * Kernel-internal data types and definitions:
Ingo Molnar9f66a382008-12-10 12:33:23 +0100487 */
488
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200489#ifdef CONFIG_PERF_EVENTS
Stephane Eraniane5d13672011-02-14 11:20:01 +0200490# include <linux/cgroup.h>
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200491# include <asm/perf_event.h>
Peter Zijlstra7be79232010-06-09 11:57:23 +0200492# include <asm/local64.h>
Paul Mackerrasf3dfd262009-02-26 22:43:46 +1100493#endif
494
Zhang, Yanmin39447b32010-04-19 13:32:41 +0800495struct perf_guest_info_callbacks {
Ingo Molnare7e7ee22011-05-04 08:42:29 +0200496 int (*is_in_guest)(void);
497 int (*is_user_mode)(void);
498 unsigned long (*get_guest_ip)(void);
Zhang, Yanmin39447b32010-04-19 13:32:41 +0800499};
500
Arnd Bergmann2ff6cfd2009-12-07 17:12:58 +0100501#ifdef CONFIG_HAVE_HW_BREAKPOINT
502#include <asm/hw_breakpoint.h>
503#endif
504
Paul Mackerrasf3dfd262009-02-26 22:43:46 +1100505#include <linux/list.h>
506#include <linux/mutex.h>
507#include <linux/rculist.h>
508#include <linux/rcupdate.h>
509#include <linux/spinlock.h>
Peter Zijlstrad6d020e2009-03-13 12:21:35 +0100510#include <linux/hrtimer.h>
Peter Zijlstra3c446b32009-04-06 11:45:01 +0200511#include <linux/fs.h>
Peter Zijlstra709e50c2009-06-02 14:13:15 +0200512#include <linux/pid_namespace.h>
Peter Zijlstra906010b2009-09-21 16:08:49 +0200513#include <linux/workqueue.h>
Frederic Weisbecker5331d7b2010-03-04 21:15:56 +0100514#include <linux/ftrace.h>
Peter Zijlstra85cfabb2010-03-11 13:06:56 +0100515#include <linux/cpu.h>
Peter Zijlstrae360adb2010-10-14 14:01:34 +0800516#include <linux/irq_work.h>
Jason Barond430d3d2011-03-16 17:29:47 -0400517#include <linux/jump_label.h>
Arun Sharma60063492011-07-26 16:09:06 -0700518#include <linux/atomic.h>
Peter Zijlstrafa588152010-05-18 10:54:20 +0200519#include <asm/local.h>
Paul Mackerrasf3dfd262009-02-26 22:43:46 +1100520
Peter Zijlstraf9188e02009-06-18 22:20:52 +0200521#define PERF_MAX_STACK_DEPTH 255
522
523struct perf_callchain_entry {
524 __u64 nr;
525 __u64 ip[PERF_MAX_STACK_DEPTH];
526};
527
Frederic Weisbecker3a43ce62009-08-08 04:26:37 +0200528struct perf_raw_record {
529 u32 size;
530 void *data;
Frederic Weisbeckerf413cdb2009-08-07 01:25:54 +0200531};
532
Peter Zijlstracaff2be2010-03-03 12:02:30 +0100533struct perf_branch_entry {
534 __u64 from;
535 __u64 to;
536 __u64 flags;
537};
538
539struct perf_branch_stack {
540 __u64 nr;
541 struct perf_branch_entry entries[0];
542};
543
Paul Mackerrasf3dfd262009-02-26 22:43:46 +1100544struct task_struct;
545
Stephane Eranianefc9f052011-06-06 16:57:03 +0200546/*
547 * extra PMU register associated with an event
548 */
549struct hw_perf_event_extra {
550 u64 config; /* register value */
551 unsigned int reg; /* register address or index */
552 int alloc; /* extra register already allocated */
553 int idx; /* index in shared_regs->regs[] */
554};
555
Thomas Gleixner0793a612008-12-04 20:12:29 +0100556/**
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200557 * struct hw_perf_event - performance event hardware details:
Thomas Gleixner0793a612008-12-04 20:12:29 +0100558 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200559struct hw_perf_event {
560#ifdef CONFIG_PERF_EVENTS
Peter Zijlstrad6d020e2009-03-13 12:21:35 +0100561 union {
562 struct { /* hardware */
Ingo Molnara3084442009-06-11 14:44:26 +0200563 u64 config;
Stephane Eranian447a1942010-02-01 14:50:01 +0200564 u64 last_tag;
Ingo Molnara3084442009-06-11 14:44:26 +0200565 unsigned long config_base;
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200566 unsigned long event_base;
Ingo Molnara3084442009-06-11 14:44:26 +0200567 int idx;
Stephane Eranian447a1942010-02-01 14:50:01 +0200568 int last_cpu;
Stephane Eranianefc9f052011-06-06 16:57:03 +0200569 struct hw_perf_event_extra extra_reg;
Peter Zijlstrad6d020e2009-03-13 12:21:35 +0100570 };
Soeren Sandmann721a6692009-09-15 14:33:08 +0200571 struct { /* software */
Ingo Molnara3084442009-06-11 14:44:26 +0200572 struct hrtimer hrtimer;
Peter Zijlstrad6d020e2009-03-13 12:21:35 +0100573 };
Frederic Weisbecker24f1e32c2009-09-09 19:22:48 +0200574#ifdef CONFIG_HAVE_HW_BREAKPOINT
Frederic Weisbecker45a73372010-06-23 23:00:37 +0200575 struct { /* breakpoint */
576 struct arch_hw_breakpoint info;
577 struct list_head bp_list;
Peter Zijlstrad580ff82010-10-14 17:43:23 +0200578 /*
579 * Crufty hack to avoid the chicken and egg
580 * problem hw_breakpoint has with context
581 * creation and event initalization.
582 */
583 struct task_struct *bp_target;
Frederic Weisbecker45a73372010-06-23 23:00:37 +0200584 };
Frederic Weisbecker24f1e32c2009-09-09 19:22:48 +0200585#endif
Peter Zijlstrad6d020e2009-03-13 12:21:35 +0100586 };
Peter Zijlstraa4eaf7f2010-06-16 14:37:10 +0200587 int state;
Peter Zijlstrae7850592010-05-21 14:43:08 +0200588 local64_t prev_count;
Peter Zijlstrab23f3322009-06-02 15:13:03 +0200589 u64 sample_period;
Peter Zijlstra9e350de2009-06-10 21:34:59 +0200590 u64 last_period;
Peter Zijlstrae7850592010-05-21 14:43:08 +0200591 local64_t period_left;
Stephane Eraniane050e3f2012-01-26 17:03:19 +0100592 u64 interrupts_seq;
Peter Zijlstra60db5e02009-05-15 15:19:28 +0200593 u64 interrupts;
Peter Zijlstra6a24ed6c2009-06-05 18:01:29 +0200594
Peter Zijlstraabd50712010-01-26 18:50:16 +0100595 u64 freq_time_stamp;
596 u64 freq_count_stamp;
Ingo Molnaree060942008-12-13 09:00:03 +0100597#endif
Thomas Gleixner0793a612008-12-04 20:12:29 +0100598};
599
Peter Zijlstraa4eaf7f2010-06-16 14:37:10 +0200600/*
601 * hw_perf_event::state flags
602 */
603#define PERF_HES_STOPPED 0x01 /* the counter is stopped */
604#define PERF_HES_UPTODATE 0x02 /* event->count up-to-date */
605#define PERF_HES_ARCH 0x04
606
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200607struct perf_event;
Ingo Molnar621a01e2008-12-11 12:46:46 +0100608
Peter Zijlstra8d2cacb2010-05-25 17:49:05 +0200609/*
610 * Common implementation detail of pmu::{start,commit,cancel}_txn
611 */
612#define PERF_EVENT_TXN 0x1
Lin Ming6bde9b62010-04-23 13:56:00 +0800613
Ingo Molnar621a01e2008-12-11 12:46:46 +0100614/**
Robert Richter4aeb0b42009-04-29 12:47:03 +0200615 * struct pmu - generic performance monitoring unit
Ingo Molnar621a01e2008-12-11 12:46:46 +0100616 */
Robert Richter4aeb0b42009-04-29 12:47:03 +0200617struct pmu {
Peter Zijlstrab0a873e2010-06-11 13:35:08 +0200618 struct list_head entry;
619
Peter Zijlstraabe43402010-11-17 23:17:37 +0100620 struct device *dev;
Peter Zijlstra0c9d42e2011-11-20 23:30:47 +0100621 const struct attribute_group **attr_groups;
Peter Zijlstra2e80a822010-11-17 23:17:36 +0100622 char *name;
623 int type;
624
Peter Zijlstra108b02c2010-09-06 14:32:03 +0200625 int * __percpu pmu_disable_count;
626 struct perf_cpu_context * __percpu pmu_cpu_context;
Peter Zijlstra8dc85d52010-09-02 16:50:03 +0200627 int task_ctx_nr;
Peter Zijlstra33696fc2010-06-14 08:49:00 +0200628
Peter Zijlstraa4eaf7f2010-06-16 14:37:10 +0200629 /*
630 * Fully disable/enable this PMU, can be used to protect from the PMI
631 * as well as for lazy/batch writing of the MSRs.
632 */
Peter Zijlstraad5133b2010-06-15 12:22:39 +0200633 void (*pmu_enable) (struct pmu *pmu); /* optional */
634 void (*pmu_disable) (struct pmu *pmu); /* optional */
Peter Zijlstra33696fc2010-06-14 08:49:00 +0200635
Peter Zijlstrab0a873e2010-06-11 13:35:08 +0200636 /*
Peter Zijlstraa4eaf7f2010-06-16 14:37:10 +0200637 * Try and initialize the event for this PMU.
Peter Zijlstra24cd7f52010-06-11 17:32:03 +0200638 * Should return -ENOENT when the @event doesn't match this PMU.
Peter Zijlstrab0a873e2010-06-11 13:35:08 +0200639 */
640 int (*event_init) (struct perf_event *event);
641
Peter Zijlstraa4eaf7f2010-06-16 14:37:10 +0200642#define PERF_EF_START 0x01 /* start the counter when adding */
643#define PERF_EF_RELOAD 0x02 /* reload the counter when starting */
644#define PERF_EF_UPDATE 0x04 /* update the counter when stopping */
645
646 /*
647 * Adds/Removes a counter to/from the PMU, can be done inside
648 * a transaction, see the ->*_txn() methods.
649 */
650 int (*add) (struct perf_event *event, int flags);
651 void (*del) (struct perf_event *event, int flags);
652
653 /*
654 * Starts/Stops a counter present on the PMU. The PMI handler
655 * should stop the counter when perf_event_overflow() returns
656 * !0. ->start() will be used to continue.
657 */
658 void (*start) (struct perf_event *event, int flags);
659 void (*stop) (struct perf_event *event, int flags);
660
661 /*
662 * Updates the counter value of the event.
663 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200664 void (*read) (struct perf_event *event);
Lin Ming6bde9b62010-04-23 13:56:00 +0800665
666 /*
Peter Zijlstra24cd7f52010-06-11 17:32:03 +0200667 * Group events scheduling is treated as a transaction, add
668 * group events as a whole and perform one schedulability test.
669 * If the test fails, roll back the whole group
Peter Zijlstraa4eaf7f2010-06-16 14:37:10 +0200670 *
671 * Start the transaction, after this ->add() doesn't need to
Peter Zijlstra24cd7f52010-06-11 17:32:03 +0200672 * do schedulability tests.
Lin Ming6bde9b62010-04-23 13:56:00 +0800673 */
Ingo Molnare7e7ee22011-05-04 08:42:29 +0200674 void (*start_txn) (struct pmu *pmu); /* optional */
Peter Zijlstra8d2cacb2010-05-25 17:49:05 +0200675 /*
Peter Zijlstraa4eaf7f2010-06-16 14:37:10 +0200676 * If ->start_txn() disabled the ->add() schedulability test
Peter Zijlstra8d2cacb2010-05-25 17:49:05 +0200677 * then ->commit_txn() is required to perform one. On success
678 * the transaction is closed. On error the transaction is kept
679 * open until ->cancel_txn() is called.
680 */
Ingo Molnare7e7ee22011-05-04 08:42:29 +0200681 int (*commit_txn) (struct pmu *pmu); /* optional */
Peter Zijlstra8d2cacb2010-05-25 17:49:05 +0200682 /*
Peter Zijlstraa4eaf7f2010-06-16 14:37:10 +0200683 * Will cancel the transaction, assumes ->del() is called
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300684 * for each successful ->add() during the transaction.
Peter Zijlstra8d2cacb2010-05-25 17:49:05 +0200685 */
Ingo Molnare7e7ee22011-05-04 08:42:29 +0200686 void (*cancel_txn) (struct pmu *pmu); /* optional */
Peter Zijlstra35edc2a2011-11-20 20:36:02 +0100687
688 /*
689 * Will return the value for perf_event_mmap_page::index for this event,
690 * if no implementation is provided it will default to: event->hw.idx + 1.
691 */
692 int (*event_idx) (struct perf_event *event); /*optional */
Ingo Molnar621a01e2008-12-11 12:46:46 +0100693};
694
Thomas Gleixner0793a612008-12-04 20:12:29 +0100695/**
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200696 * enum perf_event_active_state - the states of a event
Ingo Molnar6a930702008-12-11 15:17:03 +0100697 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200698enum perf_event_active_state {
Ingo Molnar57c0c152009-09-21 12:20:38 +0200699 PERF_EVENT_STATE_ERROR = -2,
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200700 PERF_EVENT_STATE_OFF = -1,
701 PERF_EVENT_STATE_INACTIVE = 0,
Ingo Molnar57c0c152009-09-21 12:20:38 +0200702 PERF_EVENT_STATE_ACTIVE = 1,
Ingo Molnar6a930702008-12-11 15:17:03 +0100703};
704
Ingo Molnar9b51f662008-12-12 13:49:45 +0100705struct file;
Peter Zijlstra453f19e2009-11-20 22:19:43 +0100706struct perf_sample_data;
707
Peter Zijlstraa8b0ca12011-06-27 14:41:57 +0200708typedef void (*perf_overflow_handler_t)(struct perf_event *,
Frederic Weisbeckerb326e952009-12-05 09:44:31 +0100709 struct perf_sample_data *,
710 struct pt_regs *regs);
711
Frederic Weisbeckerd6f962b2010-01-10 01:25:51 +0100712enum perf_group_flag {
Ingo Molnare7e7ee22011-05-04 08:42:29 +0200713 PERF_GROUP_SOFTWARE = 0x1,
Frederic Weisbeckerd6f962b2010-01-10 01:25:51 +0100714};
715
Ingo Molnare7e7ee22011-05-04 08:42:29 +0200716#define SWEVENT_HLIST_BITS 8
717#define SWEVENT_HLIST_SIZE (1 << SWEVENT_HLIST_BITS)
Frederic Weisbecker76e1d902010-04-05 15:35:57 +0200718
719struct swevent_hlist {
Ingo Molnare7e7ee22011-05-04 08:42:29 +0200720 struct hlist_head heads[SWEVENT_HLIST_SIZE];
721 struct rcu_head rcu_head;
Frederic Weisbecker76e1d902010-04-05 15:35:57 +0200722};
723
Peter Zijlstra8a495422010-05-27 15:47:49 +0200724#define PERF_ATTACH_CONTEXT 0x01
725#define PERF_ATTACH_GROUP 0x02
Peter Zijlstrad580ff82010-10-14 17:43:23 +0200726#define PERF_ATTACH_TASK 0x04
Peter Zijlstra8a495422010-05-27 15:47:49 +0200727
Stephane Eraniane5d13672011-02-14 11:20:01 +0200728#ifdef CONFIG_CGROUP_PERF
729/*
730 * perf_cgroup_info keeps track of time_enabled for a cgroup.
731 * This is a per-cpu dynamically allocated data structure.
732 */
733struct perf_cgroup_info {
Ingo Molnare7e7ee22011-05-04 08:42:29 +0200734 u64 time;
735 u64 timestamp;
Stephane Eraniane5d13672011-02-14 11:20:01 +0200736};
737
738struct perf_cgroup {
Ingo Molnare7e7ee22011-05-04 08:42:29 +0200739 struct cgroup_subsys_state css;
740 struct perf_cgroup_info *info; /* timing info, one per cpu */
Stephane Eraniane5d13672011-02-14 11:20:01 +0200741};
742#endif
743
Frederic Weisbecker76369132011-05-19 19:55:04 +0200744struct ring_buffer;
745
Ingo Molnar6a930702008-12-11 15:17:03 +0100746/**
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200747 * struct perf_event - performance event kernel representation:
Thomas Gleixner0793a612008-12-04 20:12:29 +0100748 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200749struct perf_event {
750#ifdef CONFIG_PERF_EVENTS
Ingo Molnar65abc862009-09-21 10:18:27 +0200751 struct list_head group_entry;
Peter Zijlstra592903c2009-03-13 12:21:36 +0100752 struct list_head event_entry;
Ingo Molnar04289bb2008-12-11 08:38:42 +0100753 struct list_head sibling_list;
Frederic Weisbecker76e1d902010-04-05 15:35:57 +0200754 struct hlist_node hlist_entry;
Ingo Molnar0127c3e2009-05-25 22:03:26 +0200755 int nr_siblings;
Frederic Weisbeckerd6f962b2010-01-10 01:25:51 +0100756 int group_flags;
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200757 struct perf_event *group_leader;
Peter Zijlstraa4eaf7f2010-06-16 14:37:10 +0200758 struct pmu *pmu;
Ingo Molnar04289bb2008-12-11 08:38:42 +0100759
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200760 enum perf_event_active_state state;
Peter Zijlstra8a495422010-05-27 15:47:49 +0200761 unsigned int attach_state;
Peter Zijlstrae7850592010-05-21 14:43:08 +0200762 local64_t count;
Peter Zijlstraa6e6dea2010-05-21 14:27:58 +0200763 atomic64_t child_count;
Ingo Molnaree060942008-12-13 09:00:03 +0100764
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100765 /*
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200766 * These are the total time in nanoseconds that the event
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100767 * has been enabled (i.e. eligible to run, and the task has
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200768 * been scheduled in, if this is a per-task event)
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100769 * and running (scheduled onto the CPU), respectively.
770 *
771 * They are computed from tstamp_enabled, tstamp_running and
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200772 * tstamp_stopped when the event is in INACTIVE or ACTIVE state.
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100773 */
774 u64 total_time_enabled;
775 u64 total_time_running;
776
777 /*
778 * These are timestamps used for computing total_time_enabled
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200779 * and total_time_running when the event is in INACTIVE or
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100780 * ACTIVE state, measured in nanoseconds from an arbitrary point
781 * in time.
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200782 * tstamp_enabled: the notional time when the event was enabled
783 * tstamp_running: the notional time when the event was scheduled on
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100784 * tstamp_stopped: in INACTIVE state, the notional time when the
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200785 * event was scheduled off.
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100786 */
787 u64 tstamp_enabled;
788 u64 tstamp_running;
789 u64 tstamp_stopped;
790
Stephane Eranianeed01522010-10-26 16:08:01 +0200791 /*
792 * timestamp shadows the actual context timing but it can
793 * be safely used in NMI interrupt context. It reflects the
794 * context time as it was when the event was last scheduled in.
795 *
796 * ctx_time already accounts for ctx->timestamp. Therefore to
797 * compute ctx_time for a sample, simply add perf_clock().
798 */
799 u64 shadow_ctx_time;
800
Frederic Weisbecker24f1e32c2009-09-09 19:22:48 +0200801 struct perf_event_attr attr;
Arnaldo Carvalho de Meloc320c7b2010-10-20 12:50:11 -0200802 u16 header_size;
Arnaldo Carvalho de Melo6844c092010-12-03 16:36:35 -0200803 u16 id_header_size;
Arnaldo Carvalho de Meloc320c7b2010-10-20 12:50:11 -0200804 u16 read_size;
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200805 struct hw_perf_event hw;
Thomas Gleixner0793a612008-12-04 20:12:29 +0100806
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200807 struct perf_event_context *ctx;
Ingo Molnar9b51f662008-12-12 13:49:45 +0100808 struct file *filp;
Thomas Gleixner0793a612008-12-04 20:12:29 +0100809
810 /*
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100811 * These accumulate total time (in nanoseconds) that children
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200812 * events have been enabled and running, respectively.
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100813 */
814 atomic64_t child_total_time_enabled;
815 atomic64_t child_total_time_running;
816
817 /*
Paul Mackerrasd859e292009-01-17 18:10:22 +1100818 * Protect attach/detach and child_list:
Thomas Gleixner0793a612008-12-04 20:12:29 +0100819 */
Peter Zijlstrafccc7142009-05-23 18:28:56 +0200820 struct mutex child_mutex;
821 struct list_head child_list;
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200822 struct perf_event *parent;
Thomas Gleixner0793a612008-12-04 20:12:29 +0100823
824 int oncpu;
825 int cpu;
826
Peter Zijlstra082ff5a2009-05-23 18:29:00 +0200827 struct list_head owner_entry;
828 struct task_struct *owner;
829
Peter Zijlstra7b732a72009-03-23 18:22:10 +0100830 /* mmap bits */
831 struct mutex mmap_mutex;
832 atomic_t mmap_count;
Peter Zijlstraac9721f2010-05-27 12:54:41 +0200833 int mmap_locked;
834 struct user_struct *mmap_user;
Frederic Weisbecker76369132011-05-19 19:55:04 +0200835 struct ring_buffer *rb;
Peter Zijlstra10c6db12011-11-26 02:47:31 +0100836 struct list_head rb_entry;
Paul Mackerras37d81822009-03-23 18:22:08 +0100837
Peter Zijlstra7b732a72009-03-23 18:22:10 +0100838 /* poll related */
Thomas Gleixner0793a612008-12-04 20:12:29 +0100839 wait_queue_head_t waitq;
Peter Zijlstra3c446b32009-04-06 11:45:01 +0200840 struct fasync_struct *fasync;
Peter Zijlstra79f14642009-04-06 11:45:07 +0200841
842 /* delayed work for NMIs and such */
843 int pending_wakeup;
Peter Zijlstra4c9e2542009-04-06 11:45:09 +0200844 int pending_kill;
Peter Zijlstra79f14642009-04-06 11:45:07 +0200845 int pending_disable;
Peter Zijlstrae360adb2010-10-14 14:01:34 +0800846 struct irq_work pending;
Peter Zijlstra592903c2009-03-13 12:21:36 +0100847
Peter Zijlstra79f14642009-04-06 11:45:07 +0200848 atomic_t event_limit;
849
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200850 void (*destroy)(struct perf_event *);
Peter Zijlstra592903c2009-03-13 12:21:36 +0100851 struct rcu_head rcu_head;
Peter Zijlstra709e50c2009-06-02 14:13:15 +0200852
853 struct pid_namespace *ns;
Peter Zijlstra8e5799b2009-06-02 15:08:15 +0200854 u64 id;
Li Zefan6fb29152009-10-15 11:21:42 +0800855
Frederic Weisbeckerb326e952009-12-05 09:44:31 +0100856 perf_overflow_handler_t overflow_handler;
Avi Kivity4dc0da82011-06-29 18:42:35 +0300857 void *overflow_handler_context;
Peter Zijlstra453f19e2009-11-20 22:19:43 +0100858
Li Zefan07b139c2009-12-21 14:27:35 +0800859#ifdef CONFIG_EVENT_TRACING
Peter Zijlstra1c024eca2010-05-19 14:02:22 +0200860 struct ftrace_event_call *tp_event;
Li Zefan6fb29152009-10-15 11:21:42 +0800861 struct event_filter *filter;
Ingo Molnaree060942008-12-13 09:00:03 +0100862#endif
Li Zefan6fb29152009-10-15 11:21:42 +0800863
Stephane Eraniane5d13672011-02-14 11:20:01 +0200864#ifdef CONFIG_CGROUP_PERF
865 struct perf_cgroup *cgrp; /* cgroup event is attach to */
866 int cgrp_defer_enabled;
867#endif
868
Li Zefan6fb29152009-10-15 11:21:42 +0800869#endif /* CONFIG_PERF_EVENTS */
Thomas Gleixner0793a612008-12-04 20:12:29 +0100870};
871
Peter Zijlstrab04243e2010-09-17 11:28:48 +0200872enum perf_event_context_type {
873 task_context,
874 cpu_context,
875};
876
Thomas Gleixner0793a612008-12-04 20:12:29 +0100877/**
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200878 * struct perf_event_context - event context structure
Thomas Gleixner0793a612008-12-04 20:12:29 +0100879 *
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200880 * Used as a container for task events and CPU events as well:
Thomas Gleixner0793a612008-12-04 20:12:29 +0100881 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200882struct perf_event_context {
Peter Zijlstra108b02c2010-09-06 14:32:03 +0200883 struct pmu *pmu;
Richard Kennedyee643c42011-03-07 15:46:59 +0000884 enum perf_event_context_type type;
Thomas Gleixner0793a612008-12-04 20:12:29 +0100885 /*
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200886 * Protect the states of the events in the list,
Paul Mackerrasd859e292009-01-17 18:10:22 +1100887 * nr_active, and the list:
Thomas Gleixner0793a612008-12-04 20:12:29 +0100888 */
Thomas Gleixnere625cce2009-11-17 18:02:06 +0100889 raw_spinlock_t lock;
Paul Mackerrasd859e292009-01-17 18:10:22 +1100890 /*
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200891 * Protect the list of events. Locking either mutex or lock
Paul Mackerrasd859e292009-01-17 18:10:22 +1100892 * is sufficient to ensure the list doesn't change; to change
893 * the list you need to lock both the mutex and the spinlock.
894 */
Ingo Molnara3084442009-06-11 14:44:26 +0200895 struct mutex mutex;
Ingo Molnar04289bb2008-12-11 08:38:42 +0100896
Frederic Weisbecker889ff012010-01-09 20:04:47 +0100897 struct list_head pinned_groups;
898 struct list_head flexible_groups;
Ingo Molnara3084442009-06-11 14:44:26 +0200899 struct list_head event_list;
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200900 int nr_events;
Ingo Molnara3084442009-06-11 14:44:26 +0200901 int nr_active;
902 int is_active;
Peter Zijlstrabfbd3382009-06-24 21:11:59 +0200903 int nr_stat;
Peter Zijlstra0f5a2602011-11-16 14:38:16 +0100904 int nr_freq;
Thomas Gleixnerdddd3372010-11-24 10:05:55 +0100905 int rotate_disable;
Ingo Molnara3084442009-06-11 14:44:26 +0200906 atomic_t refcount;
907 struct task_struct *task;
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100908
909 /*
Peter Zijlstra4af49982009-04-06 11:45:10 +0200910 * Context clock, runs when context enabled.
Paul Mackerras53cfbf52009-03-25 22:46:58 +1100911 */
Ingo Molnara3084442009-06-11 14:44:26 +0200912 u64 time;
913 u64 timestamp;
Paul Mackerras564c2b22009-05-22 14:27:22 +1000914
915 /*
916 * These fields let us detect when two contexts have both
917 * been cloned (inherited) from a common ancestor.
918 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200919 struct perf_event_context *parent_ctx;
Ingo Molnara3084442009-06-11 14:44:26 +0200920 u64 parent_gen;
921 u64 generation;
922 int pin_count;
Stephane Eraniane5d13672011-02-14 11:20:01 +0200923 int nr_cgroups; /* cgroup events present */
Richard Kennedy28009ce2011-06-07 16:33:38 +0100924 struct rcu_head rcu_head;
Thomas Gleixner0793a612008-12-04 20:12:29 +0100925};
926
Frederic Weisbecker7ae07ea2010-08-14 20:45:13 +0200927/*
928 * Number of contexts where an event can trigger:
Ingo Molnare7e7ee22011-05-04 08:42:29 +0200929 * task, softirq, hardirq, nmi.
Frederic Weisbecker7ae07ea2010-08-14 20:45:13 +0200930 */
931#define PERF_NR_CONTEXTS 4
932
Thomas Gleixner0793a612008-12-04 20:12:29 +0100933/**
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200934 * struct perf_event_cpu_context - per cpu event context structure
Thomas Gleixner0793a612008-12-04 20:12:29 +0100935 */
936struct perf_cpu_context {
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200937 struct perf_event_context ctx;
938 struct perf_event_context *task_ctx;
Thomas Gleixner0793a612008-12-04 20:12:29 +0100939 int active_oncpu;
Paul Mackerras3b6f9e52009-01-14 21:00:30 +1100940 int exclusive;
Peter Zijlstrae9d2b062010-09-17 11:28:50 +0200941 struct list_head rotation_list;
942 int jiffies_interval;
Peter Zijlstra51676952010-12-07 14:18:20 +0100943 struct pmu *active_pmu;
Stephane Eraniane5d13672011-02-14 11:20:01 +0200944 struct perf_cgroup *cgrp;
Thomas Gleixner0793a612008-12-04 20:12:29 +0100945};
946
Markus Metzger5622f292009-09-15 13:00:23 +0200947struct perf_output_handle {
Ingo Molnar57c0c152009-09-21 12:20:38 +0200948 struct perf_event *event;
Frederic Weisbecker76369132011-05-19 19:55:04 +0200949 struct ring_buffer *rb;
Peter Zijlstra6d1acfd2010-05-18 11:12:48 +0200950 unsigned long wakeup;
Peter Zijlstra5d967a82010-05-20 16:46:39 +0200951 unsigned long size;
952 void *addr;
953 int page;
Markus Metzger5622f292009-09-15 13:00:23 +0200954};
955
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200956#ifdef CONFIG_PERF_EVENTS
Robert Richter829b42d2009-04-29 12:46:59 +0200957
Peter Zijlstra2e80a822010-11-17 23:17:36 +0100958extern int perf_pmu_register(struct pmu *pmu, char *name, int type);
Peter Zijlstrab0a873e2010-06-11 13:35:08 +0200959extern void perf_pmu_unregister(struct pmu *pmu);
Ingo Molnar621a01e2008-12-11 12:46:46 +0100960
Matt Fleming3bf101b2010-09-27 20:22:24 +0100961extern int perf_num_counters(void);
Matt Fleming84c79912010-10-03 21:41:13 +0100962extern const char *perf_pmu_name(void);
Stephane Eraniana8d757e2011-08-25 15:58:03 +0200963extern void __perf_event_task_sched_in(struct task_struct *prev,
964 struct task_struct *task);
965extern void __perf_event_task_sched_out(struct task_struct *prev,
966 struct task_struct *next);
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200967extern int perf_event_init_task(struct task_struct *child);
968extern void perf_event_exit_task(struct task_struct *child);
969extern void perf_event_free_task(struct task_struct *task);
Peter Zijlstra4e231c72010-09-09 21:01:59 +0200970extern void perf_event_delayed_put(struct task_struct *task);
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200971extern void perf_event_print_debug(void);
Peter Zijlstra33696fc2010-06-14 08:49:00 +0200972extern void perf_pmu_disable(struct pmu *pmu);
973extern void perf_pmu_enable(struct pmu *pmu);
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200974extern int perf_event_task_disable(void);
975extern int perf_event_task_enable(void);
Avi Kivity26ca5c12011-06-29 18:42:37 +0300976extern int perf_event_refresh(struct perf_event *event, int refresh);
Ingo Molnarcdd6c482009-09-21 12:02:48 +0200977extern void perf_event_update_userpage(struct perf_event *event);
Arjan van de Venfb0459d2009-09-25 12:25:56 +0200978extern int perf_event_release_kernel(struct perf_event *event);
979extern struct perf_event *
980perf_event_create_kernel_counter(struct perf_event_attr *attr,
981 int cpu,
Matt Helsley38a81da2010-09-13 13:01:20 -0700982 struct task_struct *task,
Avi Kivity4dc0da82011-06-29 18:42:35 +0300983 perf_overflow_handler_t callback,
984 void *context);
Peter Zijlstra59ed4462009-11-20 22:19:55 +0100985extern u64 perf_event_read_value(struct perf_event *event,
986 u64 *enabled, u64 *running);
Ingo Molnar5c92d122008-12-11 13:21:10 +0100987
Peter Zijlstradf1a1322009-06-10 21:02:22 +0200988struct perf_sample_data {
Markus Metzger5622f292009-09-15 13:00:23 +0200989 u64 type;
990
991 u64 ip;
992 struct {
993 u32 pid;
994 u32 tid;
995 } tid_entry;
996 u64 time;
Ingo Molnara3084442009-06-11 14:44:26 +0200997 u64 addr;
Markus Metzger5622f292009-09-15 13:00:23 +0200998 u64 id;
999 u64 stream_id;
1000 struct {
1001 u32 cpu;
1002 u32 reserved;
1003 } cpu_entry;
Ingo Molnara3084442009-06-11 14:44:26 +02001004 u64 period;
Markus Metzger5622f292009-09-15 13:00:23 +02001005 struct perf_callchain_entry *callchain;
Frederic Weisbecker3a43ce62009-08-08 04:26:37 +02001006 struct perf_raw_record *raw;
Peter Zijlstradf1a1322009-06-10 21:02:22 +02001007};
1008
Ingo Molnare7e7ee22011-05-04 08:42:29 +02001009static inline void perf_sample_data_init(struct perf_sample_data *data, u64 addr)
Peter Zijlstradc1d6282010-03-03 15:55:04 +01001010{
1011 data->addr = addr;
1012 data->raw = NULL;
1013}
1014
Markus Metzger5622f292009-09-15 13:00:23 +02001015extern void perf_output_sample(struct perf_output_handle *handle,
1016 struct perf_event_header *header,
1017 struct perf_sample_data *data,
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001018 struct perf_event *event);
Markus Metzger5622f292009-09-15 13:00:23 +02001019extern void perf_prepare_sample(struct perf_event_header *header,
1020 struct perf_sample_data *data,
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001021 struct perf_event *event,
Markus Metzger5622f292009-09-15 13:00:23 +02001022 struct pt_regs *regs);
1023
Peter Zijlstraa8b0ca12011-06-27 14:41:57 +02001024extern int perf_event_overflow(struct perf_event *event,
Markus Metzger5622f292009-09-15 13:00:23 +02001025 struct perf_sample_data *data,
1026 struct pt_regs *regs);
Peter Zijlstradf1a1322009-06-10 21:02:22 +02001027
Franck Bui-Huu6c7e5502010-11-23 16:21:43 +01001028static inline bool is_sampling_event(struct perf_event *event)
1029{
1030 return event->attr.sample_period != 0;
1031}
1032
Paul Mackerras3b6f9e52009-01-14 21:00:30 +11001033/*
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001034 * Return 1 for a software event, 0 for a hardware event
Paul Mackerras3b6f9e52009-01-14 21:00:30 +11001035 */
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001036static inline int is_software_event(struct perf_event *event)
Paul Mackerras3b6f9e52009-01-14 21:00:30 +11001037{
Peter Zijlstra89a1e182010-09-07 17:34:50 +02001038 return event->pmu->task_ctx_nr == perf_sw_context;
Paul Mackerras3b6f9e52009-01-14 21:00:30 +11001039}
1040
Jason Barond430d3d2011-03-16 17:29:47 -04001041extern struct jump_label_key perf_swevent_enabled[PERF_COUNT_SW_MAX];
Peter Zijlstraf29ac752009-06-19 18:27:26 +02001042
Peter Zijlstraa8b0ca12011-06-27 14:41:57 +02001043extern void __perf_sw_event(u32, u64, struct pt_regs *, u64);
Peter Zijlstraf29ac752009-06-19 18:27:26 +02001044
Frederic Weisbeckerb0f82b82010-05-20 07:47:21 +02001045#ifndef perf_arch_fetch_caller_regs
Ingo Molnare7e7ee22011-05-04 08:42:29 +02001046static inline void perf_arch_fetch_caller_regs(struct pt_regs *regs, unsigned long ip) { }
Frederic Weisbeckerb0f82b82010-05-20 07:47:21 +02001047#endif
Frederic Weisbecker5331d7b2010-03-04 21:15:56 +01001048
1049/*
1050 * Take a snapshot of the regs. Skip ip and frame pointer to
1051 * the nth caller. We only need a few of the regs:
1052 * - ip for PERF_SAMPLE_IP
1053 * - cs for user_mode() tests
1054 * - bp for callchains
1055 * - eflags, for future purposes, just in case
1056 */
Frederic Weisbeckerb0f82b82010-05-20 07:47:21 +02001057static inline void perf_fetch_caller_regs(struct pt_regs *regs)
Frederic Weisbecker5331d7b2010-03-04 21:15:56 +01001058{
Frederic Weisbecker5331d7b2010-03-04 21:15:56 +01001059 memset(regs, 0, sizeof(*regs));
1060
Frederic Weisbeckerb0f82b82010-05-20 07:47:21 +02001061 perf_arch_fetch_caller_regs(regs, CALLER_ADDR0);
Frederic Weisbecker5331d7b2010-03-04 21:15:56 +01001062}
1063
Peter Zijlstra7e54a5a2010-10-14 22:32:45 +02001064static __always_inline void
Peter Zijlstraa8b0ca12011-06-27 14:41:57 +02001065perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)
Frederic Weisbeckere49a5bd2010-03-22 19:40:03 +01001066{
Peter Zijlstra7e54a5a2010-10-14 22:32:45 +02001067 struct pt_regs hot_regs;
Frederic Weisbeckere49a5bd2010-03-22 19:40:03 +01001068
Jason Barond430d3d2011-03-16 17:29:47 -04001069 if (static_branch(&perf_swevent_enabled[event_id])) {
1070 if (!regs) {
1071 perf_fetch_caller_regs(&hot_regs);
1072 regs = &hot_regs;
1073 }
Peter Zijlstraa8b0ca12011-06-27 14:41:57 +02001074 __perf_sw_event(event_id, nr, regs, addr);
Frederic Weisbeckere49a5bd2010-03-22 19:40:03 +01001075 }
1076}
1077
Gleb Natapovb2029522011-11-27 17:59:09 +02001078extern struct jump_label_key_deferred perf_sched_events;
Peter Zijlstraee6dcfa2010-11-26 13:49:04 +01001079
Stephane Eraniana8d757e2011-08-25 15:58:03 +02001080static inline void perf_event_task_sched_in(struct task_struct *prev,
1081 struct task_struct *task)
Peter Zijlstraee6dcfa2010-11-26 13:49:04 +01001082{
Gleb Natapovb2029522011-11-27 17:59:09 +02001083 if (static_branch(&perf_sched_events.key))
Stephane Eraniana8d757e2011-08-25 15:58:03 +02001084 __perf_event_task_sched_in(prev, task);
Peter Zijlstraee6dcfa2010-11-26 13:49:04 +01001085}
1086
Stephane Eraniana8d757e2011-08-25 15:58:03 +02001087static inline void perf_event_task_sched_out(struct task_struct *prev,
1088 struct task_struct *next)
Peter Zijlstraee6dcfa2010-11-26 13:49:04 +01001089{
Peter Zijlstraa8b0ca12011-06-27 14:41:57 +02001090 perf_sw_event(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, NULL, 0);
Peter Zijlstraee6dcfa2010-11-26 13:49:04 +01001091
Gleb Natapovb2029522011-11-27 17:59:09 +02001092 if (static_branch(&perf_sched_events.key))
Stephane Eraniana8d757e2011-08-25 15:58:03 +02001093 __perf_event_task_sched_out(prev, next);
Peter Zijlstraee6dcfa2010-11-26 13:49:04 +01001094}
1095
Eric B Munson3af9e852010-05-18 15:30:49 +01001096extern void perf_event_mmap(struct vm_area_struct *vma);
Zhang, Yanmin39447b32010-04-19 13:32:41 +08001097extern struct perf_guest_info_callbacks *perf_guest_cbs;
Zhang, Yanmindcf46b92010-04-20 10:13:58 +08001098extern int perf_register_guest_info_callbacks(struct perf_guest_info_callbacks *callbacks);
1099extern int perf_unregister_guest_info_callbacks(struct perf_guest_info_callbacks *callbacks);
Zhang, Yanmin39447b32010-04-19 13:32:41 +08001100
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001101extern void perf_event_comm(struct task_struct *tsk);
1102extern void perf_event_fork(struct task_struct *tsk);
Peter Zijlstra8d1b2d92009-04-08 15:01:30 +02001103
Frederic Weisbecker56962b42010-06-30 23:03:51 +02001104/* Callchains */
1105DECLARE_PER_CPU(struct perf_callchain_entry, perf_callchain_entry);
1106
Ingo Molnare7e7ee22011-05-04 08:42:29 +02001107extern void perf_callchain_user(struct perf_callchain_entry *entry, struct pt_regs *regs);
1108extern void perf_callchain_kernel(struct perf_callchain_entry *entry, struct pt_regs *regs);
Frederic Weisbecker56962b42010-06-30 23:03:51 +02001109
Ingo Molnare7e7ee22011-05-04 08:42:29 +02001110static inline void perf_callchain_store(struct perf_callchain_entry *entry, u64 ip)
Frederic Weisbecker70791ce2010-06-29 19:34:05 +02001111{
1112 if (entry->nr < PERF_MAX_STACK_DEPTH)
1113 entry->ip[entry->nr++] = ip;
1114}
Peter Zijlstra394ee072009-03-30 19:07:14 +02001115
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001116extern int sysctl_perf_event_paranoid;
1117extern int sysctl_perf_event_mlock;
1118extern int sysctl_perf_event_sample_rate;
Peter Zijlstra1ccd1542009-04-09 10:53:45 +02001119
Peter Zijlstra163ec432011-02-16 11:22:34 +01001120extern int perf_proc_update_handler(struct ctl_table *table, int write,
1121 void __user *buffer, size_t *lenp,
1122 loff_t *ppos);
1123
Peter Zijlstra320ebf02010-03-02 12:35:37 +01001124static inline bool perf_paranoid_tracepoint_raw(void)
1125{
1126 return sysctl_perf_event_paranoid > -1;
1127}
1128
1129static inline bool perf_paranoid_cpu(void)
1130{
1131 return sysctl_perf_event_paranoid > 0;
1132}
1133
1134static inline bool perf_paranoid_kernel(void)
1135{
1136 return sysctl_perf_event_paranoid > 1;
1137}
1138
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001139extern void perf_event_init(void);
Peter Zijlstra1c024eca2010-05-19 14:02:22 +02001140extern void perf_tp_event(u64 addr, u64 count, void *record,
1141 int entry_size, struct pt_regs *regs,
Peter Zijlstraecc55f82010-05-21 15:11:34 +02001142 struct hlist_head *head, int rctx);
Frederic Weisbecker24f1e32c2009-09-09 19:22:48 +02001143extern void perf_bp_event(struct perf_event *event, void *data);
Ingo Molnar0d905bc2009-05-04 19:13:30 +02001144
Paul Mackerras9d23a902009-05-14 21:48:08 +10001145#ifndef perf_misc_flags
Ingo Molnare7e7ee22011-05-04 08:42:29 +02001146# define perf_misc_flags(regs) \
1147 (user_mode(regs) ? PERF_RECORD_MISC_USER : PERF_RECORD_MISC_KERNEL)
1148# define perf_instruction_pointer(regs) instruction_pointer(regs)
Paul Mackerras9d23a902009-05-14 21:48:08 +10001149#endif
1150
Markus Metzger5622f292009-09-15 13:00:23 +02001151extern int perf_output_begin(struct perf_output_handle *handle,
Peter Zijlstraa7ac67e2011-06-27 16:47:16 +02001152 struct perf_event *event, unsigned int size);
Markus Metzger5622f292009-09-15 13:00:23 +02001153extern void perf_output_end(struct perf_output_handle *handle);
1154extern void perf_output_copy(struct perf_output_handle *handle,
1155 const void *buf, unsigned int len);
Peter Zijlstra4ed7c922009-11-23 11:37:29 +01001156extern int perf_swevent_get_recursion_context(void);
1157extern void perf_swevent_put_recursion_context(int rctx);
Frederic Weisbecker44234ad2009-12-09 09:25:48 +01001158extern void perf_event_enable(struct perf_event *event);
1159extern void perf_event_disable(struct perf_event *event);
Peter Zijlstrae9d2b062010-09-17 11:28:50 +02001160extern void perf_event_task_tick(void);
Thomas Gleixner0793a612008-12-04 20:12:29 +01001161#else
1162static inline void
Stephane Eraniana8d757e2011-08-25 15:58:03 +02001163perf_event_task_sched_in(struct task_struct *prev,
1164 struct task_struct *task) { }
Thomas Gleixner0793a612008-12-04 20:12:29 +01001165static inline void
Stephane Eraniana8d757e2011-08-25 15:58:03 +02001166perf_event_task_sched_out(struct task_struct *prev,
1167 struct task_struct *next) { }
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001168static inline int perf_event_init_task(struct task_struct *child) { return 0; }
1169static inline void perf_event_exit_task(struct task_struct *child) { }
1170static inline void perf_event_free_task(struct task_struct *task) { }
Peter Zijlstra4e231c72010-09-09 21:01:59 +02001171static inline void perf_event_delayed_put(struct task_struct *task) { }
Ingo Molnar57c0c152009-09-21 12:20:38 +02001172static inline void perf_event_print_debug(void) { }
Ingo Molnar57c0c152009-09-21 12:20:38 +02001173static inline int perf_event_task_disable(void) { return -EINVAL; }
1174static inline int perf_event_task_enable(void) { return -EINVAL; }
Avi Kivity26ca5c12011-06-29 18:42:37 +03001175static inline int perf_event_refresh(struct perf_event *event, int refresh)
1176{
1177 return -EINVAL;
1178}
Peter Zijlstra15dbf272009-03-13 12:21:32 +01001179
Peter Zijlstra925d5192009-03-30 19:07:02 +02001180static inline void
Peter Zijlstraa8b0ca12011-06-27 14:41:57 +02001181perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr) { }
Frederic Weisbecker24f1e32c2009-09-09 19:22:48 +02001182static inline void
Ingo Molnar184f4122010-01-27 08:39:39 +01001183perf_bp_event(struct perf_event *event, void *data) { }
Peter Zijlstra0a4a9392009-03-30 19:07:05 +02001184
Zhang, Yanmin39447b32010-04-19 13:32:41 +08001185static inline int perf_register_guest_info_callbacks
Ingo Molnare7e7ee22011-05-04 08:42:29 +02001186(struct perf_guest_info_callbacks *callbacks) { return 0; }
Zhang, Yanmin39447b32010-04-19 13:32:41 +08001187static inline int perf_unregister_guest_info_callbacks
Ingo Molnare7e7ee22011-05-04 08:42:29 +02001188(struct perf_guest_info_callbacks *callbacks) { return 0; }
Zhang, Yanmin39447b32010-04-19 13:32:41 +08001189
Ingo Molnar57c0c152009-09-21 12:20:38 +02001190static inline void perf_event_mmap(struct vm_area_struct *vma) { }
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001191static inline void perf_event_comm(struct task_struct *tsk) { }
1192static inline void perf_event_fork(struct task_struct *tsk) { }
1193static inline void perf_event_init(void) { }
Ingo Molnar184f4122010-01-27 08:39:39 +01001194static inline int perf_swevent_get_recursion_context(void) { return -1; }
Peter Zijlstra4ed7c922009-11-23 11:37:29 +01001195static inline void perf_swevent_put_recursion_context(int rctx) { }
Frederic Weisbecker44234ad2009-12-09 09:25:48 +01001196static inline void perf_event_enable(struct perf_event *event) { }
1197static inline void perf_event_disable(struct perf_event *event) { }
Peter Zijlstrae9d2b062010-09-17 11:28:50 +02001198static inline void perf_event_task_tick(void) { }
Thomas Gleixner0793a612008-12-04 20:12:29 +01001199#endif
1200
Ingo Molnare7e7ee22011-05-04 08:42:29 +02001201#define perf_output_put(handle, x) perf_output_copy((handle), &(x), sizeof(x))
Markus Metzger5622f292009-09-15 13:00:23 +02001202
Peter Zijlstra3f6da392010-03-05 13:01:18 +01001203/*
1204 * This has to have a higher priority than migration_notifier in sched.c.
1205 */
Ingo Molnare7e7ee22011-05-04 08:42:29 +02001206#define perf_cpu_notifier(fn) \
1207do { \
1208 static struct notifier_block fn##_nb __cpuinitdata = \
1209 { .notifier_call = fn, .priority = CPU_PRI_PERF }; \
1210 fn(&fn##_nb, (unsigned long)CPU_UP_PREPARE, \
1211 (void *)(unsigned long)smp_processor_id()); \
1212 fn(&fn##_nb, (unsigned long)CPU_STARTING, \
1213 (void *)(unsigned long)smp_processor_id()); \
1214 fn(&fn##_nb, (unsigned long)CPU_ONLINE, \
1215 (void *)(unsigned long)smp_processor_id()); \
1216 register_cpu_notifier(&fn##_nb); \
Peter Zijlstra3f6da392010-03-05 13:01:18 +01001217} while (0)
1218
Paul Mackerrasf3dfd262009-02-26 22:43:46 +11001219#endif /* __KERNEL__ */
Ingo Molnarcdd6c482009-09-21 12:02:48 +02001220#endif /* _LINUX_PERF_EVENT_H */