Merge tag 'linux-kselftest-kunit-5.15-rc1' of git://git.kernel.org/pub/scm/linux...
[linux-2.6-microblaze.git] / tools / perf / util / python.c
1 // SPDX-License-Identifier: GPL-2.0
2 #include <Python.h>
3 #include <structmember.h>
4 #include <inttypes.h>
5 #include <poll.h>
6 #include <linux/err.h>
7 #include <perf/cpumap.h>
8 #include <traceevent/event-parse.h>
9 #include <perf/mmap.h>
10 #include "evlist.h"
11 #include "callchain.h"
12 #include "evsel.h"
13 #include "event.h"
14 #include "print_binary.h"
15 #include "thread_map.h"
16 #include "trace-event.h"
17 #include "mmap.h"
18 #include "stat.h"
19 #include "metricgroup.h"
20 #include "util/env.h"
21 #include <internal/lib.h>
22 #include "util.h"
23
24 #if PY_MAJOR_VERSION < 3
25 #define _PyUnicode_FromString(arg) \
26   PyString_FromString(arg)
27 #define _PyUnicode_AsString(arg) \
28   PyString_AsString(arg)
29 #define _PyUnicode_FromFormat(...) \
30   PyString_FromFormat(__VA_ARGS__)
31 #define _PyLong_FromLong(arg) \
32   PyInt_FromLong(arg)
33
34 #else
35
36 #define _PyUnicode_FromString(arg) \
37   PyUnicode_FromString(arg)
38 #define _PyUnicode_FromFormat(...) \
39   PyUnicode_FromFormat(__VA_ARGS__)
40 #define _PyLong_FromLong(arg) \
41   PyLong_FromLong(arg)
42 #endif
43
44 #ifndef Py_TYPE
45 #define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)
46 #endif
47
48 /*
49  * Provide these two so that we don't have to link against callchain.c and
50  * start dragging hist.c, etc.
51  */
52 struct callchain_param callchain_param;
53
54 int parse_callchain_record(const char *arg __maybe_unused,
55                            struct callchain_param *param __maybe_unused)
56 {
57         return 0;
58 }
59
60 /*
61  * Add this one here not to drag util/env.c
62  */
63 struct perf_env perf_env;
64
65 /*
66  * Add this one here not to drag util/stat-shadow.c
67  */
68 void perf_stat__collect_metric_expr(struct evlist *evsel_list)
69 {
70 }
71
72 /*
73  * Add this one here not to drag util/metricgroup.c
74  */
75 int metricgroup__copy_metric_events(struct evlist *evlist, struct cgroup *cgrp,
76                                     struct rblist *new_metric_events,
77                                     struct rblist *old_metric_events)
78 {
79         return 0;
80 }
81
82 /*
83  * XXX: All these evsel destructors need some better mechanism, like a linked
84  * list of destructors registered when the relevant code indeed is used instead
85  * of having more and more calls in perf_evsel__delete(). -- acme
86  *
87  * For now, add some more:
88  *
89  * Not to drag the BPF bandwagon...
90  */
91 void bpf_counter__destroy(struct evsel *evsel);
92 int bpf_counter__install_pe(struct evsel *evsel, int cpu, int fd);
93 int bpf_counter__disable(struct evsel *evsel);
94
95 void bpf_counter__destroy(struct evsel *evsel __maybe_unused)
96 {
97 }
98
99 int bpf_counter__install_pe(struct evsel *evsel __maybe_unused, int cpu __maybe_unused, int fd __maybe_unused)
100 {
101         return 0;
102 }
103
104 int bpf_counter__disable(struct evsel *evsel __maybe_unused)
105 {
106         return 0;
107 }
108
109 /*
110  * Support debug printing even though util/debug.c is not linked.  That means
111  * implementing 'verbose' and 'eprintf'.
112  */
113 int verbose;
114 int debug_peo_args;
115
116 int eprintf(int level, int var, const char *fmt, ...);
117
118 int eprintf(int level, int var, const char *fmt, ...)
119 {
120         va_list args;
121         int ret = 0;
122
123         if (var >= level) {
124                 va_start(args, fmt);
125                 ret = vfprintf(stderr, fmt, args);
126                 va_end(args);
127         }
128
129         return ret;
130 }
131
132 /* Define PyVarObject_HEAD_INIT for python 2.5 */
133 #ifndef PyVarObject_HEAD_INIT
134 # define PyVarObject_HEAD_INIT(type, size) PyObject_HEAD_INIT(type) size,
135 #endif
136
137 #if PY_MAJOR_VERSION < 3
138 PyMODINIT_FUNC initperf(void);
139 #else
140 PyMODINIT_FUNC PyInit_perf(void);
141 #endif
142
143 #define member_def(type, member, ptype, help) \
144         { #member, ptype, \
145           offsetof(struct pyrf_event, event) + offsetof(struct type, member), \
146           0, help }
147
148 #define sample_member_def(name, member, ptype, help) \
149         { #name, ptype, \
150           offsetof(struct pyrf_event, sample) + offsetof(struct perf_sample, member), \
151           0, help }
152
153 struct pyrf_event {
154         PyObject_HEAD
155         struct evsel *evsel;
156         struct perf_sample sample;
157         union perf_event   event;
158 };
159
160 #define sample_members \
161         sample_member_def(sample_ip, ip, T_ULONGLONG, "event type"),                     \
162         sample_member_def(sample_pid, pid, T_INT, "event pid"),                  \
163         sample_member_def(sample_tid, tid, T_INT, "event tid"),                  \
164         sample_member_def(sample_time, time, T_ULONGLONG, "event timestamp"),            \
165         sample_member_def(sample_addr, addr, T_ULONGLONG, "event addr"),                 \
166         sample_member_def(sample_id, id, T_ULONGLONG, "event id"),                       \
167         sample_member_def(sample_stream_id, stream_id, T_ULONGLONG, "event stream id"), \
168         sample_member_def(sample_period, period, T_ULONGLONG, "event period"),           \
169         sample_member_def(sample_cpu, cpu, T_UINT, "event cpu"),
170
171 static char pyrf_mmap_event__doc[] = PyDoc_STR("perf mmap event object.");
172
173 static PyMemberDef pyrf_mmap_event__members[] = {
174         sample_members
175         member_def(perf_event_header, type, T_UINT, "event type"),
176         member_def(perf_event_header, misc, T_UINT, "event misc"),
177         member_def(perf_record_mmap, pid, T_UINT, "event pid"),
178         member_def(perf_record_mmap, tid, T_UINT, "event tid"),
179         member_def(perf_record_mmap, start, T_ULONGLONG, "start of the map"),
180         member_def(perf_record_mmap, len, T_ULONGLONG, "map length"),
181         member_def(perf_record_mmap, pgoff, T_ULONGLONG, "page offset"),
182         member_def(perf_record_mmap, filename, T_STRING_INPLACE, "backing store"),
183         { .name = NULL, },
184 };
185
186 static PyObject *pyrf_mmap_event__repr(struct pyrf_event *pevent)
187 {
188         PyObject *ret;
189         char *s;
190
191         if (asprintf(&s, "{ type: mmap, pid: %u, tid: %u, start: %#" PRI_lx64 ", "
192                          "length: %#" PRI_lx64 ", offset: %#" PRI_lx64 ", "
193                          "filename: %s }",
194                      pevent->event.mmap.pid, pevent->event.mmap.tid,
195                      pevent->event.mmap.start, pevent->event.mmap.len,
196                      pevent->event.mmap.pgoff, pevent->event.mmap.filename) < 0) {
197                 ret = PyErr_NoMemory();
198         } else {
199                 ret = _PyUnicode_FromString(s);
200                 free(s);
201         }
202         return ret;
203 }
204
205 static PyTypeObject pyrf_mmap_event__type = {
206         PyVarObject_HEAD_INIT(NULL, 0)
207         .tp_name        = "perf.mmap_event",
208         .tp_basicsize   = sizeof(struct pyrf_event),
209         .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
210         .tp_doc         = pyrf_mmap_event__doc,
211         .tp_members     = pyrf_mmap_event__members,
212         .tp_repr        = (reprfunc)pyrf_mmap_event__repr,
213 };
214
215 static char pyrf_task_event__doc[] = PyDoc_STR("perf task (fork/exit) event object.");
216
217 static PyMemberDef pyrf_task_event__members[] = {
218         sample_members
219         member_def(perf_event_header, type, T_UINT, "event type"),
220         member_def(perf_record_fork, pid, T_UINT, "event pid"),
221         member_def(perf_record_fork, ppid, T_UINT, "event ppid"),
222         member_def(perf_record_fork, tid, T_UINT, "event tid"),
223         member_def(perf_record_fork, ptid, T_UINT, "event ptid"),
224         member_def(perf_record_fork, time, T_ULONGLONG, "timestamp"),
225         { .name = NULL, },
226 };
227
228 static PyObject *pyrf_task_event__repr(struct pyrf_event *pevent)
229 {
230         return _PyUnicode_FromFormat("{ type: %s, pid: %u, ppid: %u, tid: %u, "
231                                    "ptid: %u, time: %" PRI_lu64 "}",
232                                    pevent->event.header.type == PERF_RECORD_FORK ? "fork" : "exit",
233                                    pevent->event.fork.pid,
234                                    pevent->event.fork.ppid,
235                                    pevent->event.fork.tid,
236                                    pevent->event.fork.ptid,
237                                    pevent->event.fork.time);
238 }
239
240 static PyTypeObject pyrf_task_event__type = {
241         PyVarObject_HEAD_INIT(NULL, 0)
242         .tp_name        = "perf.task_event",
243         .tp_basicsize   = sizeof(struct pyrf_event),
244         .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
245         .tp_doc         = pyrf_task_event__doc,
246         .tp_members     = pyrf_task_event__members,
247         .tp_repr        = (reprfunc)pyrf_task_event__repr,
248 };
249
250 static char pyrf_comm_event__doc[] = PyDoc_STR("perf comm event object.");
251
252 static PyMemberDef pyrf_comm_event__members[] = {
253         sample_members
254         member_def(perf_event_header, type, T_UINT, "event type"),
255         member_def(perf_record_comm, pid, T_UINT, "event pid"),
256         member_def(perf_record_comm, tid, T_UINT, "event tid"),
257         member_def(perf_record_comm, comm, T_STRING_INPLACE, "process name"),
258         { .name = NULL, },
259 };
260
261 static PyObject *pyrf_comm_event__repr(struct pyrf_event *pevent)
262 {
263         return _PyUnicode_FromFormat("{ type: comm, pid: %u, tid: %u, comm: %s }",
264                                    pevent->event.comm.pid,
265                                    pevent->event.comm.tid,
266                                    pevent->event.comm.comm);
267 }
268
269 static PyTypeObject pyrf_comm_event__type = {
270         PyVarObject_HEAD_INIT(NULL, 0)
271         .tp_name        = "perf.comm_event",
272         .tp_basicsize   = sizeof(struct pyrf_event),
273         .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
274         .tp_doc         = pyrf_comm_event__doc,
275         .tp_members     = pyrf_comm_event__members,
276         .tp_repr        = (reprfunc)pyrf_comm_event__repr,
277 };
278
279 static char pyrf_throttle_event__doc[] = PyDoc_STR("perf throttle event object.");
280
281 static PyMemberDef pyrf_throttle_event__members[] = {
282         sample_members
283         member_def(perf_event_header, type, T_UINT, "event type"),
284         member_def(perf_record_throttle, time, T_ULONGLONG, "timestamp"),
285         member_def(perf_record_throttle, id, T_ULONGLONG, "event id"),
286         member_def(perf_record_throttle, stream_id, T_ULONGLONG, "event stream id"),
287         { .name = NULL, },
288 };
289
290 static PyObject *pyrf_throttle_event__repr(struct pyrf_event *pevent)
291 {
292         struct perf_record_throttle *te = (struct perf_record_throttle *)(&pevent->event.header + 1);
293
294         return _PyUnicode_FromFormat("{ type: %sthrottle, time: %" PRI_lu64 ", id: %" PRI_lu64
295                                    ", stream_id: %" PRI_lu64 " }",
296                                    pevent->event.header.type == PERF_RECORD_THROTTLE ? "" : "un",
297                                    te->time, te->id, te->stream_id);
298 }
299
300 static PyTypeObject pyrf_throttle_event__type = {
301         PyVarObject_HEAD_INIT(NULL, 0)
302         .tp_name        = "perf.throttle_event",
303         .tp_basicsize   = sizeof(struct pyrf_event),
304         .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
305         .tp_doc         = pyrf_throttle_event__doc,
306         .tp_members     = pyrf_throttle_event__members,
307         .tp_repr        = (reprfunc)pyrf_throttle_event__repr,
308 };
309
310 static char pyrf_lost_event__doc[] = PyDoc_STR("perf lost event object.");
311
312 static PyMemberDef pyrf_lost_event__members[] = {
313         sample_members
314         member_def(perf_record_lost, id, T_ULONGLONG, "event id"),
315         member_def(perf_record_lost, lost, T_ULONGLONG, "number of lost events"),
316         { .name = NULL, },
317 };
318
319 static PyObject *pyrf_lost_event__repr(struct pyrf_event *pevent)
320 {
321         PyObject *ret;
322         char *s;
323
324         if (asprintf(&s, "{ type: lost, id: %#" PRI_lx64 ", "
325                          "lost: %#" PRI_lx64 " }",
326                      pevent->event.lost.id, pevent->event.lost.lost) < 0) {
327                 ret = PyErr_NoMemory();
328         } else {
329                 ret = _PyUnicode_FromString(s);
330                 free(s);
331         }
332         return ret;
333 }
334
335 static PyTypeObject pyrf_lost_event__type = {
336         PyVarObject_HEAD_INIT(NULL, 0)
337         .tp_name        = "perf.lost_event",
338         .tp_basicsize   = sizeof(struct pyrf_event),
339         .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
340         .tp_doc         = pyrf_lost_event__doc,
341         .tp_members     = pyrf_lost_event__members,
342         .tp_repr        = (reprfunc)pyrf_lost_event__repr,
343 };
344
345 static char pyrf_read_event__doc[] = PyDoc_STR("perf read event object.");
346
347 static PyMemberDef pyrf_read_event__members[] = {
348         sample_members
349         member_def(perf_record_read, pid, T_UINT, "event pid"),
350         member_def(perf_record_read, tid, T_UINT, "event tid"),
351         { .name = NULL, },
352 };
353
354 static PyObject *pyrf_read_event__repr(struct pyrf_event *pevent)
355 {
356         return _PyUnicode_FromFormat("{ type: read, pid: %u, tid: %u }",
357                                    pevent->event.read.pid,
358                                    pevent->event.read.tid);
359         /*
360          * FIXME: return the array of read values,
361          * making this method useful ;-)
362          */
363 }
364
365 static PyTypeObject pyrf_read_event__type = {
366         PyVarObject_HEAD_INIT(NULL, 0)
367         .tp_name        = "perf.read_event",
368         .tp_basicsize   = sizeof(struct pyrf_event),
369         .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
370         .tp_doc         = pyrf_read_event__doc,
371         .tp_members     = pyrf_read_event__members,
372         .tp_repr        = (reprfunc)pyrf_read_event__repr,
373 };
374
375 static char pyrf_sample_event__doc[] = PyDoc_STR("perf sample event object.");
376
377 static PyMemberDef pyrf_sample_event__members[] = {
378         sample_members
379         member_def(perf_event_header, type, T_UINT, "event type"),
380         { .name = NULL, },
381 };
382
383 static PyObject *pyrf_sample_event__repr(struct pyrf_event *pevent)
384 {
385         PyObject *ret;
386         char *s;
387
388         if (asprintf(&s, "{ type: sample }") < 0) {
389                 ret = PyErr_NoMemory();
390         } else {
391                 ret = _PyUnicode_FromString(s);
392                 free(s);
393         }
394         return ret;
395 }
396
397 static bool is_tracepoint(struct pyrf_event *pevent)
398 {
399         return pevent->evsel->core.attr.type == PERF_TYPE_TRACEPOINT;
400 }
401
402 static PyObject*
403 tracepoint_field(struct pyrf_event *pe, struct tep_format_field *field)
404 {
405         struct tep_handle *pevent = field->event->tep;
406         void *data = pe->sample.raw_data;
407         PyObject *ret = NULL;
408         unsigned long long val;
409         unsigned int offset, len;
410
411         if (field->flags & TEP_FIELD_IS_ARRAY) {
412                 offset = field->offset;
413                 len    = field->size;
414                 if (field->flags & TEP_FIELD_IS_DYNAMIC) {
415                         val     = tep_read_number(pevent, data + offset, len);
416                         offset  = val;
417                         len     = offset >> 16;
418                         offset &= 0xffff;
419                 }
420                 if (field->flags & TEP_FIELD_IS_STRING &&
421                     is_printable_array(data + offset, len)) {
422                         ret = _PyUnicode_FromString((char *)data + offset);
423                 } else {
424                         ret = PyByteArray_FromStringAndSize((const char *) data + offset, len);
425                         field->flags &= ~TEP_FIELD_IS_STRING;
426                 }
427         } else {
428                 val = tep_read_number(pevent, data + field->offset,
429                                       field->size);
430                 if (field->flags & TEP_FIELD_IS_POINTER)
431                         ret = PyLong_FromUnsignedLong((unsigned long) val);
432                 else if (field->flags & TEP_FIELD_IS_SIGNED)
433                         ret = PyLong_FromLong((long) val);
434                 else
435                         ret = PyLong_FromUnsignedLong((unsigned long) val);
436         }
437
438         return ret;
439 }
440
441 static PyObject*
442 get_tracepoint_field(struct pyrf_event *pevent, PyObject *attr_name)
443 {
444         const char *str = _PyUnicode_AsString(PyObject_Str(attr_name));
445         struct evsel *evsel = pevent->evsel;
446         struct tep_format_field *field;
447
448         if (!evsel->tp_format) {
449                 struct tep_event *tp_format;
450
451                 tp_format = trace_event__tp_format_id(evsel->core.attr.config);
452                 if (!tp_format)
453                         return NULL;
454
455                 evsel->tp_format = tp_format;
456         }
457
458         field = tep_find_any_field(evsel->tp_format, str);
459         if (!field)
460                 return NULL;
461
462         return tracepoint_field(pevent, field);
463 }
464
465 static PyObject*
466 pyrf_sample_event__getattro(struct pyrf_event *pevent, PyObject *attr_name)
467 {
468         PyObject *obj = NULL;
469
470         if (is_tracepoint(pevent))
471                 obj = get_tracepoint_field(pevent, attr_name);
472
473         return obj ?: PyObject_GenericGetAttr((PyObject *) pevent, attr_name);
474 }
475
476 static PyTypeObject pyrf_sample_event__type = {
477         PyVarObject_HEAD_INIT(NULL, 0)
478         .tp_name        = "perf.sample_event",
479         .tp_basicsize   = sizeof(struct pyrf_event),
480         .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
481         .tp_doc         = pyrf_sample_event__doc,
482         .tp_members     = pyrf_sample_event__members,
483         .tp_repr        = (reprfunc)pyrf_sample_event__repr,
484         .tp_getattro    = (getattrofunc) pyrf_sample_event__getattro,
485 };
486
487 static char pyrf_context_switch_event__doc[] = PyDoc_STR("perf context_switch event object.");
488
489 static PyMemberDef pyrf_context_switch_event__members[] = {
490         sample_members
491         member_def(perf_event_header, type, T_UINT, "event type"),
492         member_def(perf_record_switch, next_prev_pid, T_UINT, "next/prev pid"),
493         member_def(perf_record_switch, next_prev_tid, T_UINT, "next/prev tid"),
494         { .name = NULL, },
495 };
496
497 static PyObject *pyrf_context_switch_event__repr(struct pyrf_event *pevent)
498 {
499         PyObject *ret;
500         char *s;
501
502         if (asprintf(&s, "{ type: context_switch, next_prev_pid: %u, next_prev_tid: %u, switch_out: %u }",
503                      pevent->event.context_switch.next_prev_pid,
504                      pevent->event.context_switch.next_prev_tid,
505                      !!(pevent->event.header.misc & PERF_RECORD_MISC_SWITCH_OUT)) < 0) {
506                 ret = PyErr_NoMemory();
507         } else {
508                 ret = _PyUnicode_FromString(s);
509                 free(s);
510         }
511         return ret;
512 }
513
514 static PyTypeObject pyrf_context_switch_event__type = {
515         PyVarObject_HEAD_INIT(NULL, 0)
516         .tp_name        = "perf.context_switch_event",
517         .tp_basicsize   = sizeof(struct pyrf_event),
518         .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
519         .tp_doc         = pyrf_context_switch_event__doc,
520         .tp_members     = pyrf_context_switch_event__members,
521         .tp_repr        = (reprfunc)pyrf_context_switch_event__repr,
522 };
523
524 static int pyrf_event__setup_types(void)
525 {
526         int err;
527         pyrf_mmap_event__type.tp_new =
528         pyrf_task_event__type.tp_new =
529         pyrf_comm_event__type.tp_new =
530         pyrf_lost_event__type.tp_new =
531         pyrf_read_event__type.tp_new =
532         pyrf_sample_event__type.tp_new =
533         pyrf_context_switch_event__type.tp_new =
534         pyrf_throttle_event__type.tp_new = PyType_GenericNew;
535         err = PyType_Ready(&pyrf_mmap_event__type);
536         if (err < 0)
537                 goto out;
538         err = PyType_Ready(&pyrf_lost_event__type);
539         if (err < 0)
540                 goto out;
541         err = PyType_Ready(&pyrf_task_event__type);
542         if (err < 0)
543                 goto out;
544         err = PyType_Ready(&pyrf_comm_event__type);
545         if (err < 0)
546                 goto out;
547         err = PyType_Ready(&pyrf_throttle_event__type);
548         if (err < 0)
549                 goto out;
550         err = PyType_Ready(&pyrf_read_event__type);
551         if (err < 0)
552                 goto out;
553         err = PyType_Ready(&pyrf_sample_event__type);
554         if (err < 0)
555                 goto out;
556         err = PyType_Ready(&pyrf_context_switch_event__type);
557         if (err < 0)
558                 goto out;
559 out:
560         return err;
561 }
562
563 static PyTypeObject *pyrf_event__type[] = {
564         [PERF_RECORD_MMAP]       = &pyrf_mmap_event__type,
565         [PERF_RECORD_LOST]       = &pyrf_lost_event__type,
566         [PERF_RECORD_COMM]       = &pyrf_comm_event__type,
567         [PERF_RECORD_EXIT]       = &pyrf_task_event__type,
568         [PERF_RECORD_THROTTLE]   = &pyrf_throttle_event__type,
569         [PERF_RECORD_UNTHROTTLE] = &pyrf_throttle_event__type,
570         [PERF_RECORD_FORK]       = &pyrf_task_event__type,
571         [PERF_RECORD_READ]       = &pyrf_read_event__type,
572         [PERF_RECORD_SAMPLE]     = &pyrf_sample_event__type,
573         [PERF_RECORD_SWITCH]     = &pyrf_context_switch_event__type,
574         [PERF_RECORD_SWITCH_CPU_WIDE]  = &pyrf_context_switch_event__type,
575 };
576
577 static PyObject *pyrf_event__new(union perf_event *event)
578 {
579         struct pyrf_event *pevent;
580         PyTypeObject *ptype;
581
582         if ((event->header.type < PERF_RECORD_MMAP ||
583              event->header.type > PERF_RECORD_SAMPLE) &&
584             !(event->header.type == PERF_RECORD_SWITCH ||
585               event->header.type == PERF_RECORD_SWITCH_CPU_WIDE))
586                 return NULL;
587
588         ptype = pyrf_event__type[event->header.type];
589         pevent = PyObject_New(struct pyrf_event, ptype);
590         if (pevent != NULL)
591                 memcpy(&pevent->event, event, event->header.size);
592         return (PyObject *)pevent;
593 }
594
595 struct pyrf_cpu_map {
596         PyObject_HEAD
597
598         struct perf_cpu_map *cpus;
599 };
600
601 static int pyrf_cpu_map__init(struct pyrf_cpu_map *pcpus,
602                               PyObject *args, PyObject *kwargs)
603 {
604         static char *kwlist[] = { "cpustr", NULL };
605         char *cpustr = NULL;
606
607         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|s",
608                                          kwlist, &cpustr))
609                 return -1;
610
611         pcpus->cpus = perf_cpu_map__new(cpustr);
612         if (pcpus->cpus == NULL)
613                 return -1;
614         return 0;
615 }
616
617 static void pyrf_cpu_map__delete(struct pyrf_cpu_map *pcpus)
618 {
619         perf_cpu_map__put(pcpus->cpus);
620         Py_TYPE(pcpus)->tp_free((PyObject*)pcpus);
621 }
622
623 static Py_ssize_t pyrf_cpu_map__length(PyObject *obj)
624 {
625         struct pyrf_cpu_map *pcpus = (void *)obj;
626
627         return pcpus->cpus->nr;
628 }
629
630 static PyObject *pyrf_cpu_map__item(PyObject *obj, Py_ssize_t i)
631 {
632         struct pyrf_cpu_map *pcpus = (void *)obj;
633
634         if (i >= pcpus->cpus->nr)
635                 return NULL;
636
637         return Py_BuildValue("i", pcpus->cpus->map[i]);
638 }
639
640 static PySequenceMethods pyrf_cpu_map__sequence_methods = {
641         .sq_length = pyrf_cpu_map__length,
642         .sq_item   = pyrf_cpu_map__item,
643 };
644
645 static char pyrf_cpu_map__doc[] = PyDoc_STR("cpu map object.");
646
647 static PyTypeObject pyrf_cpu_map__type = {
648         PyVarObject_HEAD_INIT(NULL, 0)
649         .tp_name        = "perf.cpu_map",
650         .tp_basicsize   = sizeof(struct pyrf_cpu_map),
651         .tp_dealloc     = (destructor)pyrf_cpu_map__delete,
652         .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
653         .tp_doc         = pyrf_cpu_map__doc,
654         .tp_as_sequence = &pyrf_cpu_map__sequence_methods,
655         .tp_init        = (initproc)pyrf_cpu_map__init,
656 };
657
658 static int pyrf_cpu_map__setup_types(void)
659 {
660         pyrf_cpu_map__type.tp_new = PyType_GenericNew;
661         return PyType_Ready(&pyrf_cpu_map__type);
662 }
663
664 struct pyrf_thread_map {
665         PyObject_HEAD
666
667         struct perf_thread_map *threads;
668 };
669
670 static int pyrf_thread_map__init(struct pyrf_thread_map *pthreads,
671                                  PyObject *args, PyObject *kwargs)
672 {
673         static char *kwlist[] = { "pid", "tid", "uid", NULL };
674         int pid = -1, tid = -1, uid = UINT_MAX;
675
676         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|iii",
677                                          kwlist, &pid, &tid, &uid))
678                 return -1;
679
680         pthreads->threads = thread_map__new(pid, tid, uid);
681         if (pthreads->threads == NULL)
682                 return -1;
683         return 0;
684 }
685
686 static void pyrf_thread_map__delete(struct pyrf_thread_map *pthreads)
687 {
688         perf_thread_map__put(pthreads->threads);
689         Py_TYPE(pthreads)->tp_free((PyObject*)pthreads);
690 }
691
692 static Py_ssize_t pyrf_thread_map__length(PyObject *obj)
693 {
694         struct pyrf_thread_map *pthreads = (void *)obj;
695
696         return pthreads->threads->nr;
697 }
698
699 static PyObject *pyrf_thread_map__item(PyObject *obj, Py_ssize_t i)
700 {
701         struct pyrf_thread_map *pthreads = (void *)obj;
702
703         if (i >= pthreads->threads->nr)
704                 return NULL;
705
706         return Py_BuildValue("i", pthreads->threads->map[i]);
707 }
708
709 static PySequenceMethods pyrf_thread_map__sequence_methods = {
710         .sq_length = pyrf_thread_map__length,
711         .sq_item   = pyrf_thread_map__item,
712 };
713
714 static char pyrf_thread_map__doc[] = PyDoc_STR("thread map object.");
715
716 static PyTypeObject pyrf_thread_map__type = {
717         PyVarObject_HEAD_INIT(NULL, 0)
718         .tp_name        = "perf.thread_map",
719         .tp_basicsize   = sizeof(struct pyrf_thread_map),
720         .tp_dealloc     = (destructor)pyrf_thread_map__delete,
721         .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
722         .tp_doc         = pyrf_thread_map__doc,
723         .tp_as_sequence = &pyrf_thread_map__sequence_methods,
724         .tp_init        = (initproc)pyrf_thread_map__init,
725 };
726
727 static int pyrf_thread_map__setup_types(void)
728 {
729         pyrf_thread_map__type.tp_new = PyType_GenericNew;
730         return PyType_Ready(&pyrf_thread_map__type);
731 }
732
733 struct pyrf_evsel {
734         PyObject_HEAD
735
736         struct evsel evsel;
737 };
738
739 static int pyrf_evsel__init(struct pyrf_evsel *pevsel,
740                             PyObject *args, PyObject *kwargs)
741 {
742         struct perf_event_attr attr = {
743                 .type = PERF_TYPE_HARDWARE,
744                 .config = PERF_COUNT_HW_CPU_CYCLES,
745                 .sample_type = PERF_SAMPLE_PERIOD | PERF_SAMPLE_TID,
746         };
747         static char *kwlist[] = {
748                 "type",
749                 "config",
750                 "sample_freq",
751                 "sample_period",
752                 "sample_type",
753                 "read_format",
754                 "disabled",
755                 "inherit",
756                 "pinned",
757                 "exclusive",
758                 "exclude_user",
759                 "exclude_kernel",
760                 "exclude_hv",
761                 "exclude_idle",
762                 "mmap",
763                 "context_switch",
764                 "comm",
765                 "freq",
766                 "inherit_stat",
767                 "enable_on_exec",
768                 "task",
769                 "watermark",
770                 "precise_ip",
771                 "mmap_data",
772                 "sample_id_all",
773                 "wakeup_events",
774                 "bp_type",
775                 "bp_addr",
776                 "bp_len",
777                  NULL
778         };
779         u64 sample_period = 0;
780         u32 disabled = 0,
781             inherit = 0,
782             pinned = 0,
783             exclusive = 0,
784             exclude_user = 0,
785             exclude_kernel = 0,
786             exclude_hv = 0,
787             exclude_idle = 0,
788             mmap = 0,
789             context_switch = 0,
790             comm = 0,
791             freq = 1,
792             inherit_stat = 0,
793             enable_on_exec = 0,
794             task = 0,
795             watermark = 0,
796             precise_ip = 0,
797             mmap_data = 0,
798             sample_id_all = 1;
799         int idx = 0;
800
801         if (!PyArg_ParseTupleAndKeywords(args, kwargs,
802                                          "|iKiKKiiiiiiiiiiiiiiiiiiiiiiKK", kwlist,
803                                          &attr.type, &attr.config, &attr.sample_freq,
804                                          &sample_period, &attr.sample_type,
805                                          &attr.read_format, &disabled, &inherit,
806                                          &pinned, &exclusive, &exclude_user,
807                                          &exclude_kernel, &exclude_hv, &exclude_idle,
808                                          &mmap, &context_switch, &comm, &freq, &inherit_stat,
809                                          &enable_on_exec, &task, &watermark,
810                                          &precise_ip, &mmap_data, &sample_id_all,
811                                          &attr.wakeup_events, &attr.bp_type,
812                                          &attr.bp_addr, &attr.bp_len, &idx))
813                 return -1;
814
815         /* union... */
816         if (sample_period != 0) {
817                 if (attr.sample_freq != 0)
818                         return -1; /* FIXME: throw right exception */
819                 attr.sample_period = sample_period;
820         }
821
822         /* Bitfields */
823         attr.disabled       = disabled;
824         attr.inherit        = inherit;
825         attr.pinned         = pinned;
826         attr.exclusive      = exclusive;
827         attr.exclude_user   = exclude_user;
828         attr.exclude_kernel = exclude_kernel;
829         attr.exclude_hv     = exclude_hv;
830         attr.exclude_idle   = exclude_idle;
831         attr.mmap           = mmap;
832         attr.context_switch = context_switch;
833         attr.comm           = comm;
834         attr.freq           = freq;
835         attr.inherit_stat   = inherit_stat;
836         attr.enable_on_exec = enable_on_exec;
837         attr.task           = task;
838         attr.watermark      = watermark;
839         attr.precise_ip     = precise_ip;
840         attr.mmap_data      = mmap_data;
841         attr.sample_id_all  = sample_id_all;
842         attr.size           = sizeof(attr);
843
844         evsel__init(&pevsel->evsel, &attr, idx);
845         return 0;
846 }
847
848 static void pyrf_evsel__delete(struct pyrf_evsel *pevsel)
849 {
850         evsel__exit(&pevsel->evsel);
851         Py_TYPE(pevsel)->tp_free((PyObject*)pevsel);
852 }
853
854 static PyObject *pyrf_evsel__open(struct pyrf_evsel *pevsel,
855                                   PyObject *args, PyObject *kwargs)
856 {
857         struct evsel *evsel = &pevsel->evsel;
858         struct perf_cpu_map *cpus = NULL;
859         struct perf_thread_map *threads = NULL;
860         PyObject *pcpus = NULL, *pthreads = NULL;
861         int group = 0, inherit = 0;
862         static char *kwlist[] = { "cpus", "threads", "group", "inherit", NULL };
863
864         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOii", kwlist,
865                                          &pcpus, &pthreads, &group, &inherit))
866                 return NULL;
867
868         if (pthreads != NULL)
869                 threads = ((struct pyrf_thread_map *)pthreads)->threads;
870
871         if (pcpus != NULL)
872                 cpus = ((struct pyrf_cpu_map *)pcpus)->cpus;
873
874         evsel->core.attr.inherit = inherit;
875         /*
876          * This will group just the fds for this single evsel, to group
877          * multiple events, use evlist.open().
878          */
879         if (evsel__open(evsel, cpus, threads) < 0) {
880                 PyErr_SetFromErrno(PyExc_OSError);
881                 return NULL;
882         }
883
884         Py_INCREF(Py_None);
885         return Py_None;
886 }
887
888 static PyMethodDef pyrf_evsel__methods[] = {
889         {
890                 .ml_name  = "open",
891                 .ml_meth  = (PyCFunction)pyrf_evsel__open,
892                 .ml_flags = METH_VARARGS | METH_KEYWORDS,
893                 .ml_doc   = PyDoc_STR("open the event selector file descriptor table.")
894         },
895         { .ml_name = NULL, }
896 };
897
898 static char pyrf_evsel__doc[] = PyDoc_STR("perf event selector list object.");
899
900 static PyTypeObject pyrf_evsel__type = {
901         PyVarObject_HEAD_INIT(NULL, 0)
902         .tp_name        = "perf.evsel",
903         .tp_basicsize   = sizeof(struct pyrf_evsel),
904         .tp_dealloc     = (destructor)pyrf_evsel__delete,
905         .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
906         .tp_doc         = pyrf_evsel__doc,
907         .tp_methods     = pyrf_evsel__methods,
908         .tp_init        = (initproc)pyrf_evsel__init,
909 };
910
911 static int pyrf_evsel__setup_types(void)
912 {
913         pyrf_evsel__type.tp_new = PyType_GenericNew;
914         return PyType_Ready(&pyrf_evsel__type);
915 }
916
917 struct pyrf_evlist {
918         PyObject_HEAD
919
920         struct evlist evlist;
921 };
922
923 static int pyrf_evlist__init(struct pyrf_evlist *pevlist,
924                              PyObject *args, PyObject *kwargs __maybe_unused)
925 {
926         PyObject *pcpus = NULL, *pthreads = NULL;
927         struct perf_cpu_map *cpus;
928         struct perf_thread_map *threads;
929
930         if (!PyArg_ParseTuple(args, "OO", &pcpus, &pthreads))
931                 return -1;
932
933         threads = ((struct pyrf_thread_map *)pthreads)->threads;
934         cpus = ((struct pyrf_cpu_map *)pcpus)->cpus;
935         evlist__init(&pevlist->evlist, cpus, threads);
936         return 0;
937 }
938
939 static void pyrf_evlist__delete(struct pyrf_evlist *pevlist)
940 {
941         evlist__exit(&pevlist->evlist);
942         Py_TYPE(pevlist)->tp_free((PyObject*)pevlist);
943 }
944
945 static PyObject *pyrf_evlist__mmap(struct pyrf_evlist *pevlist,
946                                    PyObject *args, PyObject *kwargs)
947 {
948         struct evlist *evlist = &pevlist->evlist;
949         static char *kwlist[] = { "pages", "overwrite", NULL };
950         int pages = 128, overwrite = false;
951
952         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ii", kwlist,
953                                          &pages, &overwrite))
954                 return NULL;
955
956         if (evlist__mmap(evlist, pages) < 0) {
957                 PyErr_SetFromErrno(PyExc_OSError);
958                 return NULL;
959         }
960
961         Py_INCREF(Py_None);
962         return Py_None;
963 }
964
965 static PyObject *pyrf_evlist__poll(struct pyrf_evlist *pevlist,
966                                    PyObject *args, PyObject *kwargs)
967 {
968         struct evlist *evlist = &pevlist->evlist;
969         static char *kwlist[] = { "timeout", NULL };
970         int timeout = -1, n;
971
972         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i", kwlist, &timeout))
973                 return NULL;
974
975         n = evlist__poll(evlist, timeout);
976         if (n < 0) {
977                 PyErr_SetFromErrno(PyExc_OSError);
978                 return NULL;
979         }
980
981         return Py_BuildValue("i", n);
982 }
983
984 static PyObject *pyrf_evlist__get_pollfd(struct pyrf_evlist *pevlist,
985                                          PyObject *args __maybe_unused,
986                                          PyObject *kwargs __maybe_unused)
987 {
988         struct evlist *evlist = &pevlist->evlist;
989         PyObject *list = PyList_New(0);
990         int i;
991
992         for (i = 0; i < evlist->core.pollfd.nr; ++i) {
993                 PyObject *file;
994 #if PY_MAJOR_VERSION < 3
995                 FILE *fp = fdopen(evlist->core.pollfd.entries[i].fd, "r");
996
997                 if (fp == NULL)
998                         goto free_list;
999
1000                 file = PyFile_FromFile(fp, "perf", "r", NULL);
1001 #else
1002                 file = PyFile_FromFd(evlist->core.pollfd.entries[i].fd, "perf", "r", -1,
1003                                      NULL, NULL, NULL, 0);
1004 #endif
1005                 if (file == NULL)
1006                         goto free_list;
1007
1008                 if (PyList_Append(list, file) != 0) {
1009                         Py_DECREF(file);
1010                         goto free_list;
1011                 }
1012
1013                 Py_DECREF(file);
1014         }
1015
1016         return list;
1017 free_list:
1018         return PyErr_NoMemory();
1019 }
1020
1021
1022 static PyObject *pyrf_evlist__add(struct pyrf_evlist *pevlist,
1023                                   PyObject *args,
1024                                   PyObject *kwargs __maybe_unused)
1025 {
1026         struct evlist *evlist = &pevlist->evlist;
1027         PyObject *pevsel;
1028         struct evsel *evsel;
1029
1030         if (!PyArg_ParseTuple(args, "O", &pevsel))
1031                 return NULL;
1032
1033         Py_INCREF(pevsel);
1034         evsel = &((struct pyrf_evsel *)pevsel)->evsel;
1035         evsel->core.idx = evlist->core.nr_entries;
1036         evlist__add(evlist, evsel);
1037
1038         return Py_BuildValue("i", evlist->core.nr_entries);
1039 }
1040
1041 static struct mmap *get_md(struct evlist *evlist, int cpu)
1042 {
1043         int i;
1044
1045         for (i = 0; i < evlist->core.nr_mmaps; i++) {
1046                 struct mmap *md = &evlist->mmap[i];
1047
1048                 if (md->core.cpu == cpu)
1049                         return md;
1050         }
1051
1052         return NULL;
1053 }
1054
1055 static PyObject *pyrf_evlist__read_on_cpu(struct pyrf_evlist *pevlist,
1056                                           PyObject *args, PyObject *kwargs)
1057 {
1058         struct evlist *evlist = &pevlist->evlist;
1059         union perf_event *event;
1060         int sample_id_all = 1, cpu;
1061         static char *kwlist[] = { "cpu", "sample_id_all", NULL };
1062         struct mmap *md;
1063         int err;
1064
1065         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|i", kwlist,
1066                                          &cpu, &sample_id_all))
1067                 return NULL;
1068
1069         md = get_md(evlist, cpu);
1070         if (!md)
1071                 return NULL;
1072
1073         if (perf_mmap__read_init(&md->core) < 0)
1074                 goto end;
1075
1076         event = perf_mmap__read_event(&md->core);
1077         if (event != NULL) {
1078                 PyObject *pyevent = pyrf_event__new(event);
1079                 struct pyrf_event *pevent = (struct pyrf_event *)pyevent;
1080                 struct evsel *evsel;
1081
1082                 if (pyevent == NULL)
1083                         return PyErr_NoMemory();
1084
1085                 evsel = evlist__event2evsel(evlist, event);
1086                 if (!evsel) {
1087                         Py_INCREF(Py_None);
1088                         return Py_None;
1089                 }
1090
1091                 pevent->evsel = evsel;
1092
1093                 err = evsel__parse_sample(evsel, event, &pevent->sample);
1094
1095                 /* Consume the even only after we parsed it out. */
1096                 perf_mmap__consume(&md->core);
1097
1098                 if (err)
1099                         return PyErr_Format(PyExc_OSError,
1100                                             "perf: can't parse sample, err=%d", err);
1101                 return pyevent;
1102         }
1103 end:
1104         Py_INCREF(Py_None);
1105         return Py_None;
1106 }
1107
1108 static PyObject *pyrf_evlist__open(struct pyrf_evlist *pevlist,
1109                                    PyObject *args, PyObject *kwargs)
1110 {
1111         struct evlist *evlist = &pevlist->evlist;
1112         int group = 0;
1113         static char *kwlist[] = { "group", NULL };
1114
1115         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOii", kwlist, &group))
1116                 return NULL;
1117
1118         if (group)
1119                 evlist__set_leader(evlist);
1120
1121         if (evlist__open(evlist) < 0) {
1122                 PyErr_SetFromErrno(PyExc_OSError);
1123                 return NULL;
1124         }
1125
1126         Py_INCREF(Py_None);
1127         return Py_None;
1128 }
1129
1130 static PyMethodDef pyrf_evlist__methods[] = {
1131         {
1132                 .ml_name  = "mmap",
1133                 .ml_meth  = (PyCFunction)pyrf_evlist__mmap,
1134                 .ml_flags = METH_VARARGS | METH_KEYWORDS,
1135                 .ml_doc   = PyDoc_STR("mmap the file descriptor table.")
1136         },
1137         {
1138                 .ml_name  = "open",
1139                 .ml_meth  = (PyCFunction)pyrf_evlist__open,
1140                 .ml_flags = METH_VARARGS | METH_KEYWORDS,
1141                 .ml_doc   = PyDoc_STR("open the file descriptors.")
1142         },
1143         {
1144                 .ml_name  = "poll",
1145                 .ml_meth  = (PyCFunction)pyrf_evlist__poll,
1146                 .ml_flags = METH_VARARGS | METH_KEYWORDS,
1147                 .ml_doc   = PyDoc_STR("poll the file descriptor table.")
1148         },
1149         {
1150                 .ml_name  = "get_pollfd",
1151                 .ml_meth  = (PyCFunction)pyrf_evlist__get_pollfd,
1152                 .ml_flags = METH_VARARGS | METH_KEYWORDS,
1153                 .ml_doc   = PyDoc_STR("get the poll file descriptor table.")
1154         },
1155         {
1156                 .ml_name  = "add",
1157                 .ml_meth  = (PyCFunction)pyrf_evlist__add,
1158                 .ml_flags = METH_VARARGS | METH_KEYWORDS,
1159                 .ml_doc   = PyDoc_STR("adds an event selector to the list.")
1160         },
1161         {
1162                 .ml_name  = "read_on_cpu",
1163                 .ml_meth  = (PyCFunction)pyrf_evlist__read_on_cpu,
1164                 .ml_flags = METH_VARARGS | METH_KEYWORDS,
1165                 .ml_doc   = PyDoc_STR("reads an event.")
1166         },
1167         { .ml_name = NULL, }
1168 };
1169
1170 static Py_ssize_t pyrf_evlist__length(PyObject *obj)
1171 {
1172         struct pyrf_evlist *pevlist = (void *)obj;
1173
1174         return pevlist->evlist.core.nr_entries;
1175 }
1176
1177 static PyObject *pyrf_evlist__item(PyObject *obj, Py_ssize_t i)
1178 {
1179         struct pyrf_evlist *pevlist = (void *)obj;
1180         struct evsel *pos;
1181
1182         if (i >= pevlist->evlist.core.nr_entries)
1183                 return NULL;
1184
1185         evlist__for_each_entry(&pevlist->evlist, pos) {
1186                 if (i-- == 0)
1187                         break;
1188         }
1189
1190         return Py_BuildValue("O", container_of(pos, struct pyrf_evsel, evsel));
1191 }
1192
1193 static PySequenceMethods pyrf_evlist__sequence_methods = {
1194         .sq_length = pyrf_evlist__length,
1195         .sq_item   = pyrf_evlist__item,
1196 };
1197
1198 static char pyrf_evlist__doc[] = PyDoc_STR("perf event selector list object.");
1199
1200 static PyTypeObject pyrf_evlist__type = {
1201         PyVarObject_HEAD_INIT(NULL, 0)
1202         .tp_name        = "perf.evlist",
1203         .tp_basicsize   = sizeof(struct pyrf_evlist),
1204         .tp_dealloc     = (destructor)pyrf_evlist__delete,
1205         .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
1206         .tp_as_sequence = &pyrf_evlist__sequence_methods,
1207         .tp_doc         = pyrf_evlist__doc,
1208         .tp_methods     = pyrf_evlist__methods,
1209         .tp_init        = (initproc)pyrf_evlist__init,
1210 };
1211
1212 static int pyrf_evlist__setup_types(void)
1213 {
1214         pyrf_evlist__type.tp_new = PyType_GenericNew;
1215         return PyType_Ready(&pyrf_evlist__type);
1216 }
1217
1218 #define PERF_CONST(name) { #name, PERF_##name }
1219
1220 static struct {
1221         const char *name;
1222         int         value;
1223 } perf__constants[] = {
1224         PERF_CONST(TYPE_HARDWARE),
1225         PERF_CONST(TYPE_SOFTWARE),
1226         PERF_CONST(TYPE_TRACEPOINT),
1227         PERF_CONST(TYPE_HW_CACHE),
1228         PERF_CONST(TYPE_RAW),
1229         PERF_CONST(TYPE_BREAKPOINT),
1230
1231         PERF_CONST(COUNT_HW_CPU_CYCLES),
1232         PERF_CONST(COUNT_HW_INSTRUCTIONS),
1233         PERF_CONST(COUNT_HW_CACHE_REFERENCES),
1234         PERF_CONST(COUNT_HW_CACHE_MISSES),
1235         PERF_CONST(COUNT_HW_BRANCH_INSTRUCTIONS),
1236         PERF_CONST(COUNT_HW_BRANCH_MISSES),
1237         PERF_CONST(COUNT_HW_BUS_CYCLES),
1238         PERF_CONST(COUNT_HW_CACHE_L1D),
1239         PERF_CONST(COUNT_HW_CACHE_L1I),
1240         PERF_CONST(COUNT_HW_CACHE_LL),
1241         PERF_CONST(COUNT_HW_CACHE_DTLB),
1242         PERF_CONST(COUNT_HW_CACHE_ITLB),
1243         PERF_CONST(COUNT_HW_CACHE_BPU),
1244         PERF_CONST(COUNT_HW_CACHE_OP_READ),
1245         PERF_CONST(COUNT_HW_CACHE_OP_WRITE),
1246         PERF_CONST(COUNT_HW_CACHE_OP_PREFETCH),
1247         PERF_CONST(COUNT_HW_CACHE_RESULT_ACCESS),
1248         PERF_CONST(COUNT_HW_CACHE_RESULT_MISS),
1249
1250         PERF_CONST(COUNT_HW_STALLED_CYCLES_FRONTEND),
1251         PERF_CONST(COUNT_HW_STALLED_CYCLES_BACKEND),
1252
1253         PERF_CONST(COUNT_SW_CPU_CLOCK),
1254         PERF_CONST(COUNT_SW_TASK_CLOCK),
1255         PERF_CONST(COUNT_SW_PAGE_FAULTS),
1256         PERF_CONST(COUNT_SW_CONTEXT_SWITCHES),
1257         PERF_CONST(COUNT_SW_CPU_MIGRATIONS),
1258         PERF_CONST(COUNT_SW_PAGE_FAULTS_MIN),
1259         PERF_CONST(COUNT_SW_PAGE_FAULTS_MAJ),
1260         PERF_CONST(COUNT_SW_ALIGNMENT_FAULTS),
1261         PERF_CONST(COUNT_SW_EMULATION_FAULTS),
1262         PERF_CONST(COUNT_SW_DUMMY),
1263
1264         PERF_CONST(SAMPLE_IP),
1265         PERF_CONST(SAMPLE_TID),
1266         PERF_CONST(SAMPLE_TIME),
1267         PERF_CONST(SAMPLE_ADDR),
1268         PERF_CONST(SAMPLE_READ),
1269         PERF_CONST(SAMPLE_CALLCHAIN),
1270         PERF_CONST(SAMPLE_ID),
1271         PERF_CONST(SAMPLE_CPU),
1272         PERF_CONST(SAMPLE_PERIOD),
1273         PERF_CONST(SAMPLE_STREAM_ID),
1274         PERF_CONST(SAMPLE_RAW),
1275
1276         PERF_CONST(FORMAT_TOTAL_TIME_ENABLED),
1277         PERF_CONST(FORMAT_TOTAL_TIME_RUNNING),
1278         PERF_CONST(FORMAT_ID),
1279         PERF_CONST(FORMAT_GROUP),
1280
1281         PERF_CONST(RECORD_MMAP),
1282         PERF_CONST(RECORD_LOST),
1283         PERF_CONST(RECORD_COMM),
1284         PERF_CONST(RECORD_EXIT),
1285         PERF_CONST(RECORD_THROTTLE),
1286         PERF_CONST(RECORD_UNTHROTTLE),
1287         PERF_CONST(RECORD_FORK),
1288         PERF_CONST(RECORD_READ),
1289         PERF_CONST(RECORD_SAMPLE),
1290         PERF_CONST(RECORD_MMAP2),
1291         PERF_CONST(RECORD_AUX),
1292         PERF_CONST(RECORD_ITRACE_START),
1293         PERF_CONST(RECORD_LOST_SAMPLES),
1294         PERF_CONST(RECORD_SWITCH),
1295         PERF_CONST(RECORD_SWITCH_CPU_WIDE),
1296
1297         PERF_CONST(RECORD_MISC_SWITCH_OUT),
1298         { .name = NULL, },
1299 };
1300
1301 static PyObject *pyrf__tracepoint(struct pyrf_evsel *pevsel,
1302                                   PyObject *args, PyObject *kwargs)
1303 {
1304         struct tep_event *tp_format;
1305         static char *kwlist[] = { "sys", "name", NULL };
1306         char *sys  = NULL;
1307         char *name = NULL;
1308
1309         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ss", kwlist,
1310                                          &sys, &name))
1311                 return NULL;
1312
1313         tp_format = trace_event__tp_format(sys, name);
1314         if (IS_ERR(tp_format))
1315                 return _PyLong_FromLong(-1);
1316
1317         return _PyLong_FromLong(tp_format->id);
1318 }
1319
1320 static PyMethodDef perf__methods[] = {
1321         {
1322                 .ml_name  = "tracepoint",
1323                 .ml_meth  = (PyCFunction) pyrf__tracepoint,
1324                 .ml_flags = METH_VARARGS | METH_KEYWORDS,
1325                 .ml_doc   = PyDoc_STR("Get tracepoint config.")
1326         },
1327         { .ml_name = NULL, }
1328 };
1329
1330 #if PY_MAJOR_VERSION < 3
1331 PyMODINIT_FUNC initperf(void)
1332 #else
1333 PyMODINIT_FUNC PyInit_perf(void)
1334 #endif
1335 {
1336         PyObject *obj;
1337         int i;
1338         PyObject *dict;
1339 #if PY_MAJOR_VERSION < 3
1340         PyObject *module = Py_InitModule("perf", perf__methods);
1341 #else
1342         static struct PyModuleDef moduledef = {
1343                 PyModuleDef_HEAD_INIT,
1344                 "perf",                 /* m_name */
1345                 "",                     /* m_doc */
1346                 -1,                     /* m_size */
1347                 perf__methods,          /* m_methods */
1348                 NULL,                   /* m_reload */
1349                 NULL,                   /* m_traverse */
1350                 NULL,                   /* m_clear */
1351                 NULL,                   /* m_free */
1352         };
1353         PyObject *module = PyModule_Create(&moduledef);
1354 #endif
1355
1356         if (module == NULL ||
1357             pyrf_event__setup_types() < 0 ||
1358             pyrf_evlist__setup_types() < 0 ||
1359             pyrf_evsel__setup_types() < 0 ||
1360             pyrf_thread_map__setup_types() < 0 ||
1361             pyrf_cpu_map__setup_types() < 0)
1362 #if PY_MAJOR_VERSION < 3
1363                 return;
1364 #else
1365                 return module;
1366 #endif
1367
1368         /* The page_size is placed in util object. */
1369         page_size = sysconf(_SC_PAGE_SIZE);
1370
1371         Py_INCREF(&pyrf_evlist__type);
1372         PyModule_AddObject(module, "evlist", (PyObject*)&pyrf_evlist__type);
1373
1374         Py_INCREF(&pyrf_evsel__type);
1375         PyModule_AddObject(module, "evsel", (PyObject*)&pyrf_evsel__type);
1376
1377         Py_INCREF(&pyrf_mmap_event__type);
1378         PyModule_AddObject(module, "mmap_event", (PyObject *)&pyrf_mmap_event__type);
1379
1380         Py_INCREF(&pyrf_lost_event__type);
1381         PyModule_AddObject(module, "lost_event", (PyObject *)&pyrf_lost_event__type);
1382
1383         Py_INCREF(&pyrf_comm_event__type);
1384         PyModule_AddObject(module, "comm_event", (PyObject *)&pyrf_comm_event__type);
1385
1386         Py_INCREF(&pyrf_task_event__type);
1387         PyModule_AddObject(module, "task_event", (PyObject *)&pyrf_task_event__type);
1388
1389         Py_INCREF(&pyrf_throttle_event__type);
1390         PyModule_AddObject(module, "throttle_event", (PyObject *)&pyrf_throttle_event__type);
1391
1392         Py_INCREF(&pyrf_task_event__type);
1393         PyModule_AddObject(module, "task_event", (PyObject *)&pyrf_task_event__type);
1394
1395         Py_INCREF(&pyrf_read_event__type);
1396         PyModule_AddObject(module, "read_event", (PyObject *)&pyrf_read_event__type);
1397
1398         Py_INCREF(&pyrf_sample_event__type);
1399         PyModule_AddObject(module, "sample_event", (PyObject *)&pyrf_sample_event__type);
1400
1401         Py_INCREF(&pyrf_context_switch_event__type);
1402         PyModule_AddObject(module, "switch_event", (PyObject *)&pyrf_context_switch_event__type);
1403
1404         Py_INCREF(&pyrf_thread_map__type);
1405         PyModule_AddObject(module, "thread_map", (PyObject*)&pyrf_thread_map__type);
1406
1407         Py_INCREF(&pyrf_cpu_map__type);
1408         PyModule_AddObject(module, "cpu_map", (PyObject*)&pyrf_cpu_map__type);
1409
1410         dict = PyModule_GetDict(module);
1411         if (dict == NULL)
1412                 goto error;
1413
1414         for (i = 0; perf__constants[i].name != NULL; i++) {
1415                 obj = _PyLong_FromLong(perf__constants[i].value);
1416                 if (obj == NULL)
1417                         goto error;
1418                 PyDict_SetItemString(dict, perf__constants[i].name, obj);
1419                 Py_DECREF(obj);
1420         }
1421
1422 error:
1423         if (PyErr_Occurred())
1424                 PyErr_SetString(PyExc_ImportError, "perf: Init failed!");
1425 #if PY_MAJOR_VERSION >= 3
1426         return module;
1427 #endif
1428 }
1429
1430 /*
1431  * Dummy, to avoid dragging all the test_attr infrastructure in the python
1432  * binding.
1433  */
1434 void test_attr__open(struct perf_event_attr *attr, pid_t pid, int cpu,
1435                      int fd, int group_fd, unsigned long flags)
1436 {
1437 }