perf_event.h 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869
  1. /*
  2. * Performance events:
  3. *
  4. * Copyright (C) 2008-2009, Thomas Gleixner <tglx@linutronix.de>
  5. * Copyright (C) 2008-2009, Red Hat, Inc., Ingo Molnar
  6. * Copyright (C) 2008-2009, 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. #include <linux/types.h>
  17. #include <linux/ioctl.h>
  18. #include <asm/byteorder.h>
  19. /*
  20. * User-space ABI bits:
  21. */
  22. /*
  23. * attr.type
  24. */
  25. enum perf_type_id {
  26. PERF_TYPE_HARDWARE = 0,
  27. PERF_TYPE_SOFTWARE = 1,
  28. PERF_TYPE_TRACEPOINT = 2,
  29. PERF_TYPE_HW_CACHE = 3,
  30. PERF_TYPE_RAW = 4,
  31. PERF_TYPE_MAX, /* non-ABI */
  32. };
  33. /*
  34. * Generalized performance event event_id types, used by the
  35. * attr.event_id parameter of the sys_perf_event_open()
  36. * syscall:
  37. */
  38. enum perf_hw_id {
  39. /*
  40. * Common hardware events, generalized by the kernel:
  41. */
  42. PERF_COUNT_HW_CPU_CYCLES = 0,
  43. PERF_COUNT_HW_INSTRUCTIONS = 1,
  44. PERF_COUNT_HW_CACHE_REFERENCES = 2,
  45. PERF_COUNT_HW_CACHE_MISSES = 3,
  46. PERF_COUNT_HW_BRANCH_INSTRUCTIONS = 4,
  47. PERF_COUNT_HW_BRANCH_MISSES = 5,
  48. PERF_COUNT_HW_BUS_CYCLES = 6,
  49. PERF_COUNT_HW_MAX, /* non-ABI */
  50. };
  51. /*
  52. * Generalized hardware cache events:
  53. *
  54. * { L1-D, L1-I, LLC, ITLB, DTLB, BPU } x
  55. * { read, write, prefetch } x
  56. * { accesses, misses }
  57. */
  58. enum perf_hw_cache_id {
  59. PERF_COUNT_HW_CACHE_L1D = 0,
  60. PERF_COUNT_HW_CACHE_L1I = 1,
  61. PERF_COUNT_HW_CACHE_LL = 2,
  62. PERF_COUNT_HW_CACHE_DTLB = 3,
  63. PERF_COUNT_HW_CACHE_ITLB = 4,
  64. PERF_COUNT_HW_CACHE_BPU = 5,
  65. PERF_COUNT_HW_CACHE_MAX, /* non-ABI */
  66. };
  67. enum perf_hw_cache_op_id {
  68. PERF_COUNT_HW_CACHE_OP_READ = 0,
  69. PERF_COUNT_HW_CACHE_OP_WRITE = 1,
  70. PERF_COUNT_HW_CACHE_OP_PREFETCH = 2,
  71. PERF_COUNT_HW_CACHE_OP_MAX, /* non-ABI */
  72. };
  73. enum perf_hw_cache_op_result_id {
  74. PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0,
  75. PERF_COUNT_HW_CACHE_RESULT_MISS = 1,
  76. PERF_COUNT_HW_CACHE_RESULT_MAX, /* non-ABI */
  77. };
  78. /*
  79. * Special "software" events provided by the kernel, even if the hardware
  80. * does not support performance events. These events measure various
  81. * physical and sw events of the kernel (and allow the profiling of them as
  82. * well):
  83. */
  84. enum perf_sw_ids {
  85. PERF_COUNT_SW_CPU_CLOCK = 0,
  86. PERF_COUNT_SW_TASK_CLOCK = 1,
  87. PERF_COUNT_SW_PAGE_FAULTS = 2,
  88. PERF_COUNT_SW_CONTEXT_SWITCHES = 3,
  89. PERF_COUNT_SW_CPU_MIGRATIONS = 4,
  90. PERF_COUNT_SW_PAGE_FAULTS_MIN = 5,
  91. PERF_COUNT_SW_PAGE_FAULTS_MAJ = 6,
  92. PERF_COUNT_SW_MAX, /* non-ABI */
  93. };
  94. /*
  95. * Bits that can be set in attr.sample_type to request information
  96. * in the overflow packets.
  97. */
  98. enum perf_event_sample_format {
  99. PERF_SAMPLE_IP = 1U << 0,
  100. PERF_SAMPLE_TID = 1U << 1,
  101. PERF_SAMPLE_TIME = 1U << 2,
  102. PERF_SAMPLE_ADDR = 1U << 3,
  103. PERF_SAMPLE_READ = 1U << 4,
  104. PERF_SAMPLE_CALLCHAIN = 1U << 5,
  105. PERF_SAMPLE_ID = 1U << 6,
  106. PERF_SAMPLE_CPU = 1U << 7,
  107. PERF_SAMPLE_PERIOD = 1U << 8,
  108. PERF_SAMPLE_STREAM_ID = 1U << 9,
  109. PERF_SAMPLE_RAW = 1U << 10,
  110. PERF_SAMPLE_MAX = 1U << 11, /* non-ABI */
  111. };
  112. /*
  113. * The format of the data returned by read() on a perf event fd,
  114. * as specified by attr.read_format:
  115. *
  116. * struct read_format {
  117. * { u64 value;
  118. * { u64 time_enabled; } && PERF_FORMAT_ENABLED
  119. * { u64 time_running; } && PERF_FORMAT_RUNNING
  120. * { u64 id; } && PERF_FORMAT_ID
  121. * } && !PERF_FORMAT_GROUP
  122. *
  123. * { u64 nr;
  124. * { u64 time_enabled; } && PERF_FORMAT_ENABLED
  125. * { u64 time_running; } && PERF_FORMAT_RUNNING
  126. * { u64 value;
  127. * { u64 id; } && PERF_FORMAT_ID
  128. * } cntr[nr];
  129. * } && PERF_FORMAT_GROUP
  130. * };
  131. */
  132. enum perf_event_read_format {
  133. PERF_FORMAT_TOTAL_TIME_ENABLED = 1U << 0,
  134. PERF_FORMAT_TOTAL_TIME_RUNNING = 1U << 1,
  135. PERF_FORMAT_ID = 1U << 2,
  136. PERF_FORMAT_GROUP = 1U << 3,
  137. PERF_FORMAT_MAX = 1U << 4, /* non-ABI */
  138. };
  139. #define PERF_ATTR_SIZE_VER0 64 /* sizeof first published struct */
  140. /*
  141. * Hardware event_id to monitor via a performance monitoring event:
  142. */
  143. struct perf_event_attr {
  144. /*
  145. * Major type: hardware/software/tracepoint/etc.
  146. */
  147. __u32 type;
  148. /*
  149. * Size of the attr structure, for fwd/bwd compat.
  150. */
  151. __u32 size;
  152. /*
  153. * Type specific configuration information.
  154. */
  155. __u64 config;
  156. union {
  157. __u64 sample_period;
  158. __u64 sample_freq;
  159. };
  160. __u64 sample_type;
  161. __u64 read_format;
  162. __u64 disabled : 1, /* off by default */
  163. inherit : 1, /* children inherit it */
  164. pinned : 1, /* must always be on PMU */
  165. exclusive : 1, /* only group on PMU */
  166. exclude_user : 1, /* don't count user */
  167. exclude_kernel : 1, /* ditto kernel */
  168. exclude_hv : 1, /* ditto hypervisor */
  169. exclude_idle : 1, /* don't count when idle */
  170. mmap : 1, /* include mmap data */
  171. comm : 1, /* include comm data */
  172. freq : 1, /* use freq, not period */
  173. inherit_stat : 1, /* per task counts */
  174. enable_on_exec : 1, /* next exec enables */
  175. task : 1, /* trace fork/exit */
  176. watermark : 1, /* wakeup_watermark */
  177. __reserved_1 : 49;
  178. union {
  179. __u32 wakeup_events; /* wakeup every n events */
  180. __u32 wakeup_watermark; /* bytes before wakeup */
  181. };
  182. __u32 __reserved_2;
  183. __u64 __reserved_3;
  184. };
  185. /*
  186. * Ioctls that can be done on a perf event fd:
  187. */
  188. #define PERF_EVENT_IOC_ENABLE _IO ('$', 0)
  189. #define PERF_EVENT_IOC_DISABLE _IO ('$', 1)
  190. #define PERF_EVENT_IOC_REFRESH _IO ('$', 2)
  191. #define PERF_EVENT_IOC_RESET _IO ('$', 3)
  192. #define PERF_EVENT_IOC_PERIOD _IOW('$', 4, u64)
  193. #define PERF_EVENT_IOC_SET_OUTPUT _IO ('$', 5)
  194. #define PERF_EVENT_IOC_SET_FILTER _IOW('$', 6, char *)
  195. enum perf_event_ioc_flags {
  196. PERF_IOC_FLAG_GROUP = 1U << 0,
  197. };
  198. /*
  199. * Structure of the page that can be mapped via mmap
  200. */
  201. struct perf_event_mmap_page {
  202. __u32 version; /* version number of this structure */
  203. __u32 compat_version; /* lowest version this is compat with */
  204. /*
  205. * Bits needed to read the hw events in user-space.
  206. *
  207. * u32 seq;
  208. * s64 count;
  209. *
  210. * do {
  211. * seq = pc->lock;
  212. *
  213. * barrier()
  214. * if (pc->index) {
  215. * count = pmc_read(pc->index - 1);
  216. * count += pc->offset;
  217. * } else
  218. * goto regular_read;
  219. *
  220. * barrier();
  221. * } while (pc->lock != seq);
  222. *
  223. * NOTE: for obvious reason this only works on self-monitoring
  224. * processes.
  225. */
  226. __u32 lock; /* seqlock for synchronization */
  227. __u32 index; /* hardware event identifier */
  228. __s64 offset; /* add to hardware event value */
  229. __u64 time_enabled; /* time event active */
  230. __u64 time_running; /* time event on cpu */
  231. /*
  232. * Hole for extension of the self monitor capabilities
  233. */
  234. __u64 __reserved[123]; /* align to 1k */
  235. /*
  236. * Control data for the mmap() data buffer.
  237. *
  238. * User-space reading the @data_head value should issue an rmb(), on
  239. * SMP capable platforms, after reading this value -- see
  240. * perf_event_wakeup().
  241. *
  242. * When the mapping is PROT_WRITE the @data_tail value should be
  243. * written by userspace to reflect the last read data. In this case
  244. * the kernel will not over-write unread data.
  245. */
  246. __u64 data_head; /* head in the data section */
  247. __u64 data_tail; /* user-space written tail */
  248. };
  249. #define PERF_RECORD_MISC_CPUMODE_MASK (3 << 0)
  250. #define PERF_RECORD_MISC_CPUMODE_UNKNOWN (0 << 0)
  251. #define PERF_RECORD_MISC_KERNEL (1 << 0)
  252. #define PERF_RECORD_MISC_USER (2 << 0)
  253. #define PERF_RECORD_MISC_HYPERVISOR (3 << 0)
  254. struct perf_event_header {
  255. __u32 type;
  256. __u16 misc;
  257. __u16 size;
  258. };
  259. enum perf_event_type {
  260. /*
  261. * The MMAP events record the PROT_EXEC mappings so that we can
  262. * correlate userspace IPs to code. They have the following structure:
  263. *
  264. * struct {
  265. * struct perf_event_header header;
  266. *
  267. * u32 pid, tid;
  268. * u64 addr;
  269. * u64 len;
  270. * u64 pgoff;
  271. * char filename[];
  272. * };
  273. */
  274. PERF_RECORD_MMAP = 1,
  275. /*
  276. * struct {
  277. * struct perf_event_header header;
  278. * u64 id;
  279. * u64 lost;
  280. * };
  281. */
  282. PERF_RECORD_LOST = 2,
  283. /*
  284. * struct {
  285. * struct perf_event_header header;
  286. *
  287. * u32 pid, tid;
  288. * char comm[];
  289. * };
  290. */
  291. PERF_RECORD_COMM = 3,
  292. /*
  293. * struct {
  294. * struct perf_event_header header;
  295. * u32 pid, ppid;
  296. * u32 tid, ptid;
  297. * u64 time;
  298. * };
  299. */
  300. PERF_RECORD_EXIT = 4,
  301. /*
  302. * struct {
  303. * struct perf_event_header header;
  304. * u64 time;
  305. * u64 id;
  306. * u64 stream_id;
  307. * };
  308. */
  309. PERF_RECORD_THROTTLE = 5,
  310. PERF_RECORD_UNTHROTTLE = 6,
  311. /*
  312. * struct {
  313. * struct perf_event_header header;
  314. * u32 pid, ppid;
  315. * u32 tid, ptid;
  316. * u64 time;
  317. * };
  318. */
  319. PERF_RECORD_FORK = 7,
  320. /*
  321. * struct {
  322. * struct perf_event_header header;
  323. * u32 pid, tid;
  324. *
  325. * struct read_format values;
  326. * };
  327. */
  328. PERF_RECORD_READ = 8,
  329. /*
  330. * struct {
  331. * struct perf_event_header header;
  332. *
  333. * { u64 ip; } && PERF_SAMPLE_IP
  334. * { u32 pid, tid; } && PERF_SAMPLE_TID
  335. * { u64 time; } && PERF_SAMPLE_TIME
  336. * { u64 addr; } && PERF_SAMPLE_ADDR
  337. * { u64 id; } && PERF_SAMPLE_ID
  338. * { u64 stream_id;} && PERF_SAMPLE_STREAM_ID
  339. * { u32 cpu, res; } && PERF_SAMPLE_CPU
  340. * { u64 period; } && PERF_SAMPLE_PERIOD
  341. *
  342. * { struct read_format values; } && PERF_SAMPLE_READ
  343. *
  344. * { u64 nr,
  345. * u64 ips[nr]; } && PERF_SAMPLE_CALLCHAIN
  346. *
  347. * #
  348. * # The RAW record below is opaque data wrt the ABI
  349. * #
  350. * # That is, the ABI doesn't make any promises wrt to
  351. * # the stability of its content, it may vary depending
  352. * # on event, hardware, kernel version and phase of
  353. * # the moon.
  354. * #
  355. * # In other words, PERF_SAMPLE_RAW contents are not an ABI.
  356. * #
  357. *
  358. * { u32 size;
  359. * char data[size];}&& PERF_SAMPLE_RAW
  360. * };
  361. */
  362. PERF_RECORD_SAMPLE = 9,
  363. PERF_RECORD_MAX, /* non-ABI */
  364. };
  365. enum perf_callchain_context {
  366. PERF_CONTEXT_HV = (__u64)-32,
  367. PERF_CONTEXT_KERNEL = (__u64)-128,
  368. PERF_CONTEXT_USER = (__u64)-512,
  369. PERF_CONTEXT_GUEST = (__u64)-2048,
  370. PERF_CONTEXT_GUEST_KERNEL = (__u64)-2176,
  371. PERF_CONTEXT_GUEST_USER = (__u64)-2560,
  372. PERF_CONTEXT_MAX = (__u64)-4095,
  373. };
  374. #define PERF_FLAG_FD_NO_GROUP (1U << 0)
  375. #define PERF_FLAG_FD_OUTPUT (1U << 1)
  376. #ifdef __KERNEL__
  377. /*
  378. * Kernel-internal data types and definitions:
  379. */
  380. #ifdef CONFIG_PERF_EVENTS
  381. # include <asm/perf_event.h>
  382. #endif
  383. #include <linux/list.h>
  384. #include <linux/mutex.h>
  385. #include <linux/rculist.h>
  386. #include <linux/rcupdate.h>
  387. #include <linux/spinlock.h>
  388. #include <linux/hrtimer.h>
  389. #include <linux/fs.h>
  390. #include <linux/pid_namespace.h>
  391. #include <linux/workqueue.h>
  392. #include <asm/atomic.h>
  393. #define PERF_MAX_STACK_DEPTH 255
  394. struct perf_callchain_entry {
  395. __u64 nr;
  396. __u64 ip[PERF_MAX_STACK_DEPTH];
  397. };
  398. struct perf_raw_record {
  399. u32 size;
  400. void *data;
  401. };
  402. struct task_struct;
  403. /**
  404. * struct hw_perf_event - performance event hardware details:
  405. */
  406. struct hw_perf_event {
  407. #ifdef CONFIG_PERF_EVENTS
  408. union {
  409. struct { /* hardware */
  410. u64 config;
  411. unsigned long config_base;
  412. unsigned long event_base;
  413. int idx;
  414. };
  415. union { /* software */
  416. atomic64_t count;
  417. struct hrtimer hrtimer;
  418. };
  419. };
  420. atomic64_t prev_count;
  421. u64 sample_period;
  422. u64 last_period;
  423. atomic64_t period_left;
  424. u64 interrupts;
  425. u64 freq_count;
  426. u64 freq_interrupts;
  427. u64 freq_stamp;
  428. #endif
  429. };
  430. struct perf_event;
  431. /**
  432. * struct pmu - generic performance monitoring unit
  433. */
  434. struct pmu {
  435. int (*enable) (struct perf_event *event);
  436. void (*disable) (struct perf_event *event);
  437. void (*read) (struct perf_event *event);
  438. void (*unthrottle) (struct perf_event *event);
  439. };
  440. /**
  441. * enum perf_event_active_state - the states of a event
  442. */
  443. enum perf_event_active_state {
  444. PERF_EVENT_STATE_ERROR = -2,
  445. PERF_EVENT_STATE_OFF = -1,
  446. PERF_EVENT_STATE_INACTIVE = 0,
  447. PERF_EVENT_STATE_ACTIVE = 1,
  448. };
  449. struct file;
  450. struct perf_mmap_data {
  451. struct rcu_head rcu_head;
  452. #ifdef CONFIG_PERF_USE_VMALLOC
  453. struct work_struct work;
  454. #endif
  455. int data_order;
  456. int nr_pages; /* nr of data pages */
  457. int writable; /* are we writable */
  458. int nr_locked; /* nr pages mlocked */
  459. atomic_t poll; /* POLL_ for wakeups */
  460. atomic_t events; /* event_id limit */
  461. atomic_long_t head; /* write position */
  462. atomic_long_t done_head; /* completed head */
  463. atomic_t lock; /* concurrent writes */
  464. atomic_t wakeup; /* needs a wakeup */
  465. atomic_t lost; /* nr records lost */
  466. long watermark; /* wakeup watermark */
  467. struct perf_event_mmap_page *user_page;
  468. void *data_pages[0];
  469. };
  470. struct perf_pending_entry {
  471. struct perf_pending_entry *next;
  472. void (*func)(struct perf_pending_entry *);
  473. };
  474. /**
  475. * struct perf_event - performance event kernel representation:
  476. */
  477. struct perf_event {
  478. #ifdef CONFIG_PERF_EVENTS
  479. struct list_head group_entry;
  480. struct list_head event_entry;
  481. struct list_head sibling_list;
  482. int nr_siblings;
  483. struct perf_event *group_leader;
  484. struct perf_event *output;
  485. const struct pmu *pmu;
  486. enum perf_event_active_state state;
  487. atomic64_t count;
  488. /*
  489. * These are the total time in nanoseconds that the event
  490. * has been enabled (i.e. eligible to run, and the task has
  491. * been scheduled in, if this is a per-task event)
  492. * and running (scheduled onto the CPU), respectively.
  493. *
  494. * They are computed from tstamp_enabled, tstamp_running and
  495. * tstamp_stopped when the event is in INACTIVE or ACTIVE state.
  496. */
  497. u64 total_time_enabled;
  498. u64 total_time_running;
  499. /*
  500. * These are timestamps used for computing total_time_enabled
  501. * and total_time_running when the event is in INACTIVE or
  502. * ACTIVE state, measured in nanoseconds from an arbitrary point
  503. * in time.
  504. * tstamp_enabled: the notional time when the event was enabled
  505. * tstamp_running: the notional time when the event was scheduled on
  506. * tstamp_stopped: in INACTIVE state, the notional time when the
  507. * event was scheduled off.
  508. */
  509. u64 tstamp_enabled;
  510. u64 tstamp_running;
  511. u64 tstamp_stopped;
  512. struct perf_event_attr attr;
  513. struct hw_perf_event hw;
  514. struct perf_event_context *ctx;
  515. struct file *filp;
  516. /*
  517. * These accumulate total time (in nanoseconds) that children
  518. * events have been enabled and running, respectively.
  519. */
  520. atomic64_t child_total_time_enabled;
  521. atomic64_t child_total_time_running;
  522. /*
  523. * Protect attach/detach and child_list:
  524. */
  525. struct mutex child_mutex;
  526. struct list_head child_list;
  527. struct perf_event *parent;
  528. int oncpu;
  529. int cpu;
  530. struct list_head owner_entry;
  531. struct task_struct *owner;
  532. /* mmap bits */
  533. struct mutex mmap_mutex;
  534. atomic_t mmap_count;
  535. struct perf_mmap_data *data;
  536. /* poll related */
  537. wait_queue_head_t waitq;
  538. struct fasync_struct *fasync;
  539. /* delayed work for NMIs and such */
  540. int pending_wakeup;
  541. int pending_kill;
  542. int pending_disable;
  543. struct perf_pending_entry pending;
  544. atomic_t event_limit;
  545. void (*destroy)(struct perf_event *);
  546. struct rcu_head rcu_head;
  547. struct pid_namespace *ns;
  548. u64 id;
  549. #ifdef CONFIG_EVENT_PROFILE
  550. struct event_filter *filter;
  551. #endif
  552. #endif /* CONFIG_PERF_EVENTS */
  553. };
  554. /**
  555. * struct perf_event_context - event context structure
  556. *
  557. * Used as a container for task events and CPU events as well:
  558. */
  559. struct perf_event_context {
  560. /*
  561. * Protect the states of the events in the list,
  562. * nr_active, and the list:
  563. */
  564. spinlock_t lock;
  565. /*
  566. * Protect the list of events. Locking either mutex or lock
  567. * is sufficient to ensure the list doesn't change; to change
  568. * the list you need to lock both the mutex and the spinlock.
  569. */
  570. struct mutex mutex;
  571. struct list_head group_list;
  572. struct list_head event_list;
  573. int nr_events;
  574. int nr_active;
  575. int is_active;
  576. int nr_stat;
  577. atomic_t refcount;
  578. struct task_struct *task;
  579. /*
  580. * Context clock, runs when context enabled.
  581. */
  582. u64 time;
  583. u64 timestamp;
  584. /*
  585. * These fields let us detect when two contexts have both
  586. * been cloned (inherited) from a common ancestor.
  587. */
  588. struct perf_event_context *parent_ctx;
  589. u64 parent_gen;
  590. u64 generation;
  591. int pin_count;
  592. struct rcu_head rcu_head;
  593. };
  594. /**
  595. * struct perf_event_cpu_context - per cpu event context structure
  596. */
  597. struct perf_cpu_context {
  598. struct perf_event_context ctx;
  599. struct perf_event_context *task_ctx;
  600. int active_oncpu;
  601. int max_pertask;
  602. int exclusive;
  603. /*
  604. * Recursion avoidance:
  605. *
  606. * task, softirq, irq, nmi context
  607. */
  608. int recursion[4];
  609. };
  610. struct perf_output_handle {
  611. struct perf_event *event;
  612. struct perf_mmap_data *data;
  613. unsigned long head;
  614. unsigned long offset;
  615. int nmi;
  616. int sample;
  617. int locked;
  618. unsigned long flags;
  619. };
  620. #ifdef CONFIG_PERF_EVENTS
  621. /*
  622. * Set by architecture code:
  623. */
  624. extern int perf_max_events;
  625. extern const struct pmu *hw_perf_event_init(struct perf_event *event);
  626. extern void perf_event_task_sched_in(struct task_struct *task, int cpu);
  627. extern void perf_event_task_sched_out(struct task_struct *task,
  628. struct task_struct *next, int cpu);
  629. extern void perf_event_task_tick(struct task_struct *task, int cpu);
  630. extern int perf_event_init_task(struct task_struct *child);
  631. extern void perf_event_exit_task(struct task_struct *child);
  632. extern void perf_event_free_task(struct task_struct *task);
  633. extern void set_perf_event_pending(void);
  634. extern void perf_event_do_pending(void);
  635. extern void perf_event_print_debug(void);
  636. extern void __perf_disable(void);
  637. extern bool __perf_enable(void);
  638. extern void perf_disable(void);
  639. extern void perf_enable(void);
  640. extern int perf_event_task_disable(void);
  641. extern int perf_event_task_enable(void);
  642. extern int hw_perf_group_sched_in(struct perf_event *group_leader,
  643. struct perf_cpu_context *cpuctx,
  644. struct perf_event_context *ctx, int cpu);
  645. extern void perf_event_update_userpage(struct perf_event *event);
  646. struct perf_sample_data {
  647. u64 type;
  648. u64 ip;
  649. struct {
  650. u32 pid;
  651. u32 tid;
  652. } tid_entry;
  653. u64 time;
  654. u64 addr;
  655. u64 id;
  656. u64 stream_id;
  657. struct {
  658. u32 cpu;
  659. u32 reserved;
  660. } cpu_entry;
  661. u64 period;
  662. struct perf_callchain_entry *callchain;
  663. struct perf_raw_record *raw;
  664. };
  665. extern void perf_output_sample(struct perf_output_handle *handle,
  666. struct perf_event_header *header,
  667. struct perf_sample_data *data,
  668. struct perf_event *event);
  669. extern void perf_prepare_sample(struct perf_event_header *header,
  670. struct perf_sample_data *data,
  671. struct perf_event *event,
  672. struct pt_regs *regs);
  673. extern int perf_event_overflow(struct perf_event *event, int nmi,
  674. struct perf_sample_data *data,
  675. struct pt_regs *regs);
  676. /*
  677. * Return 1 for a software event, 0 for a hardware event
  678. */
  679. static inline int is_software_event(struct perf_event *event)
  680. {
  681. return (event->attr.type != PERF_TYPE_RAW) &&
  682. (event->attr.type != PERF_TYPE_HARDWARE) &&
  683. (event->attr.type != PERF_TYPE_HW_CACHE);
  684. }
  685. extern atomic_t perf_swevent_enabled[PERF_COUNT_SW_MAX];
  686. extern void __perf_sw_event(u32, u64, int, struct pt_regs *, u64);
  687. static inline void
  688. perf_sw_event(u32 event_id, u64 nr, int nmi, struct pt_regs *regs, u64 addr)
  689. {
  690. if (atomic_read(&perf_swevent_enabled[event_id]))
  691. __perf_sw_event(event_id, nr, nmi, regs, addr);
  692. }
  693. extern void __perf_event_mmap(struct vm_area_struct *vma);
  694. static inline void perf_event_mmap(struct vm_area_struct *vma)
  695. {
  696. if (vma->vm_flags & VM_EXEC)
  697. __perf_event_mmap(vma);
  698. }
  699. extern void perf_event_comm(struct task_struct *tsk);
  700. extern void perf_event_fork(struct task_struct *tsk);
  701. extern struct perf_callchain_entry *perf_callchain(struct pt_regs *regs);
  702. extern int sysctl_perf_event_paranoid;
  703. extern int sysctl_perf_event_mlock;
  704. extern int sysctl_perf_event_sample_rate;
  705. extern void perf_event_init(void);
  706. extern void perf_tp_event(int event_id, u64 addr, u64 count,
  707. void *record, int entry_size);
  708. #ifndef perf_misc_flags
  709. #define perf_misc_flags(regs) (user_mode(regs) ? PERF_RECORD_MISC_USER : \
  710. PERF_RECORD_MISC_KERNEL)
  711. #define perf_instruction_pointer(regs) instruction_pointer(regs)
  712. #endif
  713. extern int perf_output_begin(struct perf_output_handle *handle,
  714. struct perf_event *event, unsigned int size,
  715. int nmi, int sample);
  716. extern void perf_output_end(struct perf_output_handle *handle);
  717. extern void perf_output_copy(struct perf_output_handle *handle,
  718. const void *buf, unsigned int len);
  719. #else
  720. static inline void
  721. perf_event_task_sched_in(struct task_struct *task, int cpu) { }
  722. static inline void
  723. perf_event_task_sched_out(struct task_struct *task,
  724. struct task_struct *next, int cpu) { }
  725. static inline void
  726. perf_event_task_tick(struct task_struct *task, int cpu) { }
  727. static inline int perf_event_init_task(struct task_struct *child) { return 0; }
  728. static inline void perf_event_exit_task(struct task_struct *child) { }
  729. static inline void perf_event_free_task(struct task_struct *task) { }
  730. static inline void perf_event_do_pending(void) { }
  731. static inline void perf_event_print_debug(void) { }
  732. static inline void perf_disable(void) { }
  733. static inline void perf_enable(void) { }
  734. static inline int perf_event_task_disable(void) { return -EINVAL; }
  735. static inline int perf_event_task_enable(void) { return -EINVAL; }
  736. static inline void
  737. perf_sw_event(u32 event_id, u64 nr, int nmi,
  738. struct pt_regs *regs, u64 addr) { }
  739. static inline void perf_event_mmap(struct vm_area_struct *vma) { }
  740. static inline void perf_event_comm(struct task_struct *tsk) { }
  741. static inline void perf_event_fork(struct task_struct *tsk) { }
  742. static inline void perf_event_init(void) { }
  743. #endif
  744. #define perf_output_put(handle, x) \
  745. perf_output_copy((handle), &(x), sizeof(x))
  746. #endif /* __KERNEL__ */
  747. #endif /* _LINUX_PERF_EVENT_H */