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 }