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->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 } 1438