1 #include <Python.h> 2 #include <structmember.h> 3 #include <inttypes.h> 4 #include <poll.h> 5 #include "evlist.h" 6 #include "evsel.h" 7 #include "event.h" 8 #include "cpumap.h" 9 #include "thread_map.h" 10 11 /* 12 * Support debug printing even though util/debug.c is not linked. That means 13 * implementing 'verbose' and 'eprintf'. 14 */ 15 int verbose; 16 17 int eprintf(int level, int var, const char *fmt, ...) 18 { 19 va_list args; 20 int ret = 0; 21 22 if (var >= level) { 23 va_start(args, fmt); 24 ret = vfprintf(stderr, fmt, args); 25 va_end(args); 26 } 27 28 return ret; 29 } 30 31 /* Define PyVarObject_HEAD_INIT for python 2.5 */ 32 #ifndef PyVarObject_HEAD_INIT 33 # define PyVarObject_HEAD_INIT(type, size) PyObject_HEAD_INIT(type) size, 34 #endif 35 36 PyMODINIT_FUNC initperf(void); 37 38 #define member_def(type, member, ptype, help) \ 39 { #member, ptype, \ 40 offsetof(struct pyrf_event, event) + offsetof(struct type, member), \ 41 0, help } 42 43 #define sample_member_def(name, member, ptype, help) \ 44 { #name, ptype, \ 45 offsetof(struct pyrf_event, sample) + offsetof(struct perf_sample, member), \ 46 0, help } 47 48 struct pyrf_event { 49 PyObject_HEAD 50 struct perf_sample sample; 51 union perf_event event; 52 }; 53 54 #define sample_members \ 55 sample_member_def(sample_ip, ip, T_ULONGLONG, "event type"), \ 56 sample_member_def(sample_pid, pid, T_INT, "event pid"), \ 57 sample_member_def(sample_tid, tid, T_INT, "event tid"), \ 58 sample_member_def(sample_time, time, T_ULONGLONG, "event timestamp"), \ 59 sample_member_def(sample_addr, addr, T_ULONGLONG, "event addr"), \ 60 sample_member_def(sample_id, id, T_ULONGLONG, "event id"), \ 61 sample_member_def(sample_stream_id, stream_id, T_ULONGLONG, "event stream id"), \ 62 sample_member_def(sample_period, period, T_ULONGLONG, "event period"), \ 63 sample_member_def(sample_cpu, cpu, T_UINT, "event cpu"), 64 65 static char pyrf_mmap_event__doc[] = PyDoc_STR("perf mmap event object."); 66 67 static PyMemberDef pyrf_mmap_event__members[] = { 68 sample_members 69 member_def(perf_event_header, type, T_UINT, "event type"), 70 member_def(mmap_event, pid, T_UINT, "event pid"), 71 member_def(mmap_event, tid, T_UINT, "event tid"), 72 member_def(mmap_event, start, T_ULONGLONG, "start of the map"), 73 member_def(mmap_event, len, T_ULONGLONG, "map length"), 74 member_def(mmap_event, pgoff, T_ULONGLONG, "page offset"), 75 member_def(mmap_event, filename, T_STRING_INPLACE, "backing store"), 76 { .name = NULL, }, 77 }; 78 79 static PyObject *pyrf_mmap_event__repr(struct pyrf_event *pevent) 80 { 81 PyObject *ret; 82 char *s; 83 84 if (asprintf(&s, "{ type: mmap, pid: %u, tid: %u, start: %#" PRIx64 ", " 85 "length: %#" PRIx64 ", offset: %#" PRIx64 ", " 86 "filename: %s }", 87 pevent->event.mmap.pid, pevent->event.mmap.tid, 88 pevent->event.mmap.start, pevent->event.mmap.len, 89 pevent->event.mmap.pgoff, pevent->event.mmap.filename) < 0) { 90 ret = PyErr_NoMemory(); 91 } else { 92 ret = PyString_FromString(s); 93 free(s); 94 } 95 return ret; 96 } 97 98 static PyTypeObject pyrf_mmap_event__type = { 99 PyVarObject_HEAD_INIT(NULL, 0) 100 .tp_name = "perf.mmap_event", 101 .tp_basicsize = sizeof(struct pyrf_event), 102 .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, 103 .tp_doc = pyrf_mmap_event__doc, 104 .tp_members = pyrf_mmap_event__members, 105 .tp_repr = (reprfunc)pyrf_mmap_event__repr, 106 }; 107 108 static char pyrf_task_event__doc[] = PyDoc_STR("perf task (fork/exit) event object."); 109 110 static PyMemberDef pyrf_task_event__members[] = { 111 sample_members 112 member_def(perf_event_header, type, T_UINT, "event type"), 113 member_def(fork_event, pid, T_UINT, "event pid"), 114 member_def(fork_event, ppid, T_UINT, "event ppid"), 115 member_def(fork_event, tid, T_UINT, "event tid"), 116 member_def(fork_event, ptid, T_UINT, "event ptid"), 117 member_def(fork_event, time, T_ULONGLONG, "timestamp"), 118 { .name = NULL, }, 119 }; 120 121 static PyObject *pyrf_task_event__repr(struct pyrf_event *pevent) 122 { 123 return PyString_FromFormat("{ type: %s, pid: %u, ppid: %u, tid: %u, " 124 "ptid: %u, time: %" PRIu64 "}", 125 pevent->event.header.type == PERF_RECORD_FORK ? "fork" : "exit", 126 pevent->event.fork.pid, 127 pevent->event.fork.ppid, 128 pevent->event.fork.tid, 129 pevent->event.fork.ptid, 130 pevent->event.fork.time); 131 } 132 133 static PyTypeObject pyrf_task_event__type = { 134 PyVarObject_HEAD_INIT(NULL, 0) 135 .tp_name = "perf.task_event", 136 .tp_basicsize = sizeof(struct pyrf_event), 137 .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, 138 .tp_doc = pyrf_task_event__doc, 139 .tp_members = pyrf_task_event__members, 140 .tp_repr = (reprfunc)pyrf_task_event__repr, 141 }; 142 143 static char pyrf_comm_event__doc[] = PyDoc_STR("perf comm event object."); 144 145 static PyMemberDef pyrf_comm_event__members[] = { 146 sample_members 147 member_def(perf_event_header, type, T_UINT, "event type"), 148 member_def(comm_event, pid, T_UINT, "event pid"), 149 member_def(comm_event, tid, T_UINT, "event tid"), 150 member_def(comm_event, comm, T_STRING_INPLACE, "process name"), 151 { .name = NULL, }, 152 }; 153 154 static PyObject *pyrf_comm_event__repr(struct pyrf_event *pevent) 155 { 156 return PyString_FromFormat("{ type: comm, pid: %u, tid: %u, comm: %s }", 157 pevent->event.comm.pid, 158 pevent->event.comm.tid, 159 pevent->event.comm.comm); 160 } 161 162 static PyTypeObject pyrf_comm_event__type = { 163 PyVarObject_HEAD_INIT(NULL, 0) 164 .tp_name = "perf.comm_event", 165 .tp_basicsize = sizeof(struct pyrf_event), 166 .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, 167 .tp_doc = pyrf_comm_event__doc, 168 .tp_members = pyrf_comm_event__members, 169 .tp_repr = (reprfunc)pyrf_comm_event__repr, 170 }; 171 172 static char pyrf_throttle_event__doc[] = PyDoc_STR("perf throttle event object."); 173 174 static PyMemberDef pyrf_throttle_event__members[] = { 175 sample_members 176 member_def(perf_event_header, type, T_UINT, "event type"), 177 member_def(throttle_event, time, T_ULONGLONG, "timestamp"), 178 member_def(throttle_event, id, T_ULONGLONG, "event id"), 179 member_def(throttle_event, stream_id, T_ULONGLONG, "event stream id"), 180 { .name = NULL, }, 181 }; 182 183 static PyObject *pyrf_throttle_event__repr(struct pyrf_event *pevent) 184 { 185 struct throttle_event *te = (struct throttle_event *)(&pevent->event.header + 1); 186 187 return PyString_FromFormat("{ type: %sthrottle, time: %" PRIu64 ", id: %" PRIu64 188 ", stream_id: %" PRIu64 " }", 189 pevent->event.header.type == PERF_RECORD_THROTTLE ? "" : "un", 190 te->time, te->id, te->stream_id); 191 } 192 193 static PyTypeObject pyrf_throttle_event__type = { 194 PyVarObject_HEAD_INIT(NULL, 0) 195 .tp_name = "perf.throttle_event", 196 .tp_basicsize = sizeof(struct pyrf_event), 197 .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, 198 .tp_doc = pyrf_throttle_event__doc, 199 .tp_members = pyrf_throttle_event__members, 200 .tp_repr = (reprfunc)pyrf_throttle_event__repr, 201 }; 202 203 static char pyrf_lost_event__doc[] = PyDoc_STR("perf lost event object."); 204 205 static PyMemberDef pyrf_lost_event__members[] = { 206 sample_members 207 member_def(lost_event, id, T_ULONGLONG, "event id"), 208 member_def(lost_event, lost, T_ULONGLONG, "number of lost events"), 209 { .name = NULL, }, 210 }; 211 212 static PyObject *pyrf_lost_event__repr(struct pyrf_event *pevent) 213 { 214 PyObject *ret; 215 char *s; 216 217 if (asprintf(&s, "{ type: lost, id: %#" PRIx64 ", " 218 "lost: %#" PRIx64 " }", 219 pevent->event.lost.id, pevent->event.lost.lost) < 0) { 220 ret = PyErr_NoMemory(); 221 } else { 222 ret = PyString_FromString(s); 223 free(s); 224 } 225 return ret; 226 } 227 228 static PyTypeObject pyrf_lost_event__type = { 229 PyVarObject_HEAD_INIT(NULL, 0) 230 .tp_name = "perf.lost_event", 231 .tp_basicsize = sizeof(struct pyrf_event), 232 .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, 233 .tp_doc = pyrf_lost_event__doc, 234 .tp_members = pyrf_lost_event__members, 235 .tp_repr = (reprfunc)pyrf_lost_event__repr, 236 }; 237 238 static char pyrf_read_event__doc[] = PyDoc_STR("perf read event object."); 239 240 static PyMemberDef pyrf_read_event__members[] = { 241 sample_members 242 member_def(read_event, pid, T_UINT, "event pid"), 243 member_def(read_event, tid, T_UINT, "event tid"), 244 { .name = NULL, }, 245 }; 246 247 static PyObject *pyrf_read_event__repr(struct pyrf_event *pevent) 248 { 249 return PyString_FromFormat("{ type: read, pid: %u, tid: %u }", 250 pevent->event.read.pid, 251 pevent->event.read.tid); 252 /* 253 * FIXME: return the array of read values, 254 * making this method useful ;-) 255 */ 256 } 257 258 static PyTypeObject pyrf_read_event__type = { 259 PyVarObject_HEAD_INIT(NULL, 0) 260 .tp_name = "perf.read_event", 261 .tp_basicsize = sizeof(struct pyrf_event), 262 .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, 263 .tp_doc = pyrf_read_event__doc, 264 .tp_members = pyrf_read_event__members, 265 .tp_repr = (reprfunc)pyrf_read_event__repr, 266 }; 267 268 static char pyrf_sample_event__doc[] = PyDoc_STR("perf sample event object."); 269 270 static PyMemberDef pyrf_sample_event__members[] = { 271 sample_members 272 member_def(perf_event_header, type, T_UINT, "event type"), 273 { .name = NULL, }, 274 }; 275 276 static PyObject *pyrf_sample_event__repr(struct pyrf_event *pevent) 277 { 278 PyObject *ret; 279 char *s; 280 281 if (asprintf(&s, "{ type: sample }") < 0) { 282 ret = PyErr_NoMemory(); 283 } else { 284 ret = PyString_FromString(s); 285 free(s); 286 } 287 return ret; 288 } 289 290 static PyTypeObject pyrf_sample_event__type = { 291 PyVarObject_HEAD_INIT(NULL, 0) 292 .tp_name = "perf.sample_event", 293 .tp_basicsize = sizeof(struct pyrf_event), 294 .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, 295 .tp_doc = pyrf_sample_event__doc, 296 .tp_members = pyrf_sample_event__members, 297 .tp_repr = (reprfunc)pyrf_sample_event__repr, 298 }; 299 300 static int pyrf_event__setup_types(void) 301 { 302 int err; 303 pyrf_mmap_event__type.tp_new = 304 pyrf_task_event__type.tp_new = 305 pyrf_comm_event__type.tp_new = 306 pyrf_lost_event__type.tp_new = 307 pyrf_read_event__type.tp_new = 308 pyrf_sample_event__type.tp_new = 309 pyrf_throttle_event__type.tp_new = PyType_GenericNew; 310 err = PyType_Ready(&pyrf_mmap_event__type); 311 if (err < 0) 312 goto out; 313 err = PyType_Ready(&pyrf_lost_event__type); 314 if (err < 0) 315 goto out; 316 err = PyType_Ready(&pyrf_task_event__type); 317 if (err < 0) 318 goto out; 319 err = PyType_Ready(&pyrf_comm_event__type); 320 if (err < 0) 321 goto out; 322 err = PyType_Ready(&pyrf_throttle_event__type); 323 if (err < 0) 324 goto out; 325 err = PyType_Ready(&pyrf_read_event__type); 326 if (err < 0) 327 goto out; 328 err = PyType_Ready(&pyrf_sample_event__type); 329 if (err < 0) 330 goto out; 331 out: 332 return err; 333 } 334 335 static PyTypeObject *pyrf_event__type[] = { 336 [PERF_RECORD_MMAP] = &pyrf_mmap_event__type, 337 [PERF_RECORD_LOST] = &pyrf_lost_event__type, 338 [PERF_RECORD_COMM] = &pyrf_comm_event__type, 339 [PERF_RECORD_EXIT] = &pyrf_task_event__type, 340 [PERF_RECORD_THROTTLE] = &pyrf_throttle_event__type, 341 [PERF_RECORD_UNTHROTTLE] = &pyrf_throttle_event__type, 342 [PERF_RECORD_FORK] = &pyrf_task_event__type, 343 [PERF_RECORD_READ] = &pyrf_read_event__type, 344 [PERF_RECORD_SAMPLE] = &pyrf_sample_event__type, 345 }; 346 347 static PyObject *pyrf_event__new(union perf_event *event) 348 { 349 struct pyrf_event *pevent; 350 PyTypeObject *ptype; 351 352 if (event->header.type < PERF_RECORD_MMAP || 353 event->header.type > PERF_RECORD_SAMPLE) 354 return NULL; 355 356 ptype = pyrf_event__type[event->header.type]; 357 pevent = PyObject_New(struct pyrf_event, ptype); 358 if (pevent != NULL) 359 memcpy(&pevent->event, event, event->header.size); 360 return (PyObject *)pevent; 361 } 362 363 struct pyrf_cpu_map { 364 PyObject_HEAD 365 366 struct cpu_map *cpus; 367 }; 368 369 static int pyrf_cpu_map__init(struct pyrf_cpu_map *pcpus, 370 PyObject *args, PyObject *kwargs) 371 { 372 static char *kwlist[] = { "cpustr", NULL }; 373 char *cpustr = NULL; 374 375 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|s", 376 kwlist, &cpustr)) 377 return -1; 378 379 pcpus->cpus = cpu_map__new(cpustr); 380 if (pcpus->cpus == NULL) 381 return -1; 382 return 0; 383 } 384 385 static void pyrf_cpu_map__delete(struct pyrf_cpu_map *pcpus) 386 { 387 cpu_map__put(pcpus->cpus); 388 pcpus->ob_type->tp_free((PyObject*)pcpus); 389 } 390 391 static Py_ssize_t pyrf_cpu_map__length(PyObject *obj) 392 { 393 struct pyrf_cpu_map *pcpus = (void *)obj; 394 395 return pcpus->cpus->nr; 396 } 397 398 static PyObject *pyrf_cpu_map__item(PyObject *obj, Py_ssize_t i) 399 { 400 struct pyrf_cpu_map *pcpus = (void *)obj; 401 402 if (i >= pcpus->cpus->nr) 403 return NULL; 404 405 return Py_BuildValue("i", pcpus->cpus->map[i]); 406 } 407 408 static PySequenceMethods pyrf_cpu_map__sequence_methods = { 409 .sq_length = pyrf_cpu_map__length, 410 .sq_item = pyrf_cpu_map__item, 411 }; 412 413 static char pyrf_cpu_map__doc[] = PyDoc_STR("cpu map object."); 414 415 static PyTypeObject pyrf_cpu_map__type = { 416 PyVarObject_HEAD_INIT(NULL, 0) 417 .tp_name = "perf.cpu_map", 418 .tp_basicsize = sizeof(struct pyrf_cpu_map), 419 .tp_dealloc = (destructor)pyrf_cpu_map__delete, 420 .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, 421 .tp_doc = pyrf_cpu_map__doc, 422 .tp_as_sequence = &pyrf_cpu_map__sequence_methods, 423 .tp_init = (initproc)pyrf_cpu_map__init, 424 }; 425 426 static int pyrf_cpu_map__setup_types(void) 427 { 428 pyrf_cpu_map__type.tp_new = PyType_GenericNew; 429 return PyType_Ready(&pyrf_cpu_map__type); 430 } 431 432 struct pyrf_thread_map { 433 PyObject_HEAD 434 435 struct thread_map *threads; 436 }; 437 438 static int pyrf_thread_map__init(struct pyrf_thread_map *pthreads, 439 PyObject *args, PyObject *kwargs) 440 { 441 static char *kwlist[] = { "pid", "tid", "uid", NULL }; 442 int pid = -1, tid = -1, uid = UINT_MAX; 443 444 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|iii", 445 kwlist, &pid, &tid, &uid)) 446 return -1; 447 448 pthreads->threads = thread_map__new(pid, tid, uid); 449 if (pthreads->threads == NULL) 450 return -1; 451 return 0; 452 } 453 454 static void pyrf_thread_map__delete(struct pyrf_thread_map *pthreads) 455 { 456 thread_map__put(pthreads->threads); 457 pthreads->ob_type->tp_free((PyObject*)pthreads); 458 } 459 460 static Py_ssize_t pyrf_thread_map__length(PyObject *obj) 461 { 462 struct pyrf_thread_map *pthreads = (void *)obj; 463 464 return pthreads->threads->nr; 465 } 466 467 static PyObject *pyrf_thread_map__item(PyObject *obj, Py_ssize_t i) 468 { 469 struct pyrf_thread_map *pthreads = (void *)obj; 470 471 if (i >= pthreads->threads->nr) 472 return NULL; 473 474 return Py_BuildValue("i", pthreads->threads->map[i]); 475 } 476 477 static PySequenceMethods pyrf_thread_map__sequence_methods = { 478 .sq_length = pyrf_thread_map__length, 479 .sq_item = pyrf_thread_map__item, 480 }; 481 482 static char pyrf_thread_map__doc[] = PyDoc_STR("thread map object."); 483 484 static PyTypeObject pyrf_thread_map__type = { 485 PyVarObject_HEAD_INIT(NULL, 0) 486 .tp_name = "perf.thread_map", 487 .tp_basicsize = sizeof(struct pyrf_thread_map), 488 .tp_dealloc = (destructor)pyrf_thread_map__delete, 489 .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, 490 .tp_doc = pyrf_thread_map__doc, 491 .tp_as_sequence = &pyrf_thread_map__sequence_methods, 492 .tp_init = (initproc)pyrf_thread_map__init, 493 }; 494 495 static int pyrf_thread_map__setup_types(void) 496 { 497 pyrf_thread_map__type.tp_new = PyType_GenericNew; 498 return PyType_Ready(&pyrf_thread_map__type); 499 } 500 501 struct pyrf_evsel { 502 PyObject_HEAD 503 504 struct perf_evsel evsel; 505 }; 506 507 static int pyrf_evsel__init(struct pyrf_evsel *pevsel, 508 PyObject *args, PyObject *kwargs) 509 { 510 struct perf_event_attr attr = { 511 .type = PERF_TYPE_HARDWARE, 512 .config = PERF_COUNT_HW_CPU_CYCLES, 513 .sample_type = PERF_SAMPLE_PERIOD | PERF_SAMPLE_TID, 514 }; 515 static char *kwlist[] = { 516 "type", 517 "config", 518 "sample_freq", 519 "sample_period", 520 "sample_type", 521 "read_format", 522 "disabled", 523 "inherit", 524 "pinned", 525 "exclusive", 526 "exclude_user", 527 "exclude_kernel", 528 "exclude_hv", 529 "exclude_idle", 530 "mmap", 531 "comm", 532 "freq", 533 "inherit_stat", 534 "enable_on_exec", 535 "task", 536 "watermark", 537 "precise_ip", 538 "mmap_data", 539 "sample_id_all", 540 "wakeup_events", 541 "bp_type", 542 "bp_addr", 543 "bp_len", 544 NULL 545 }; 546 u64 sample_period = 0; 547 u32 disabled = 0, 548 inherit = 0, 549 pinned = 0, 550 exclusive = 0, 551 exclude_user = 0, 552 exclude_kernel = 0, 553 exclude_hv = 0, 554 exclude_idle = 0, 555 mmap = 0, 556 comm = 0, 557 freq = 1, 558 inherit_stat = 0, 559 enable_on_exec = 0, 560 task = 0, 561 watermark = 0, 562 precise_ip = 0, 563 mmap_data = 0, 564 sample_id_all = 1; 565 int idx = 0; 566 567 if (!PyArg_ParseTupleAndKeywords(args, kwargs, 568 "|iKiKKiiiiiiiiiiiiiiiiiiiiiKK", kwlist, 569 &attr.type, &attr.config, &attr.sample_freq, 570 &sample_period, &attr.sample_type, 571 &attr.read_format, &disabled, &inherit, 572 &pinned, &exclusive, &exclude_user, 573 &exclude_kernel, &exclude_hv, &exclude_idle, 574 &mmap, &comm, &freq, &inherit_stat, 575 &enable_on_exec, &task, &watermark, 576 &precise_ip, &mmap_data, &sample_id_all, 577 &attr.wakeup_events, &attr.bp_type, 578 &attr.bp_addr, &attr.bp_len, &idx)) 579 return -1; 580 581 /* union... */ 582 if (sample_period != 0) { 583 if (attr.sample_freq != 0) 584 return -1; /* FIXME: throw right exception */ 585 attr.sample_period = sample_period; 586 } 587 588 /* Bitfields */ 589 attr.disabled = disabled; 590 attr.inherit = inherit; 591 attr.pinned = pinned; 592 attr.exclusive = exclusive; 593 attr.exclude_user = exclude_user; 594 attr.exclude_kernel = exclude_kernel; 595 attr.exclude_hv = exclude_hv; 596 attr.exclude_idle = exclude_idle; 597 attr.mmap = mmap; 598 attr.comm = comm; 599 attr.freq = freq; 600 attr.inherit_stat = inherit_stat; 601 attr.enable_on_exec = enable_on_exec; 602 attr.task = task; 603 attr.watermark = watermark; 604 attr.precise_ip = precise_ip; 605 attr.mmap_data = mmap_data; 606 attr.sample_id_all = sample_id_all; 607 608 perf_evsel__init(&pevsel->evsel, &attr, idx); 609 return 0; 610 } 611 612 static void pyrf_evsel__delete(struct pyrf_evsel *pevsel) 613 { 614 perf_evsel__exit(&pevsel->evsel); 615 pevsel->ob_type->tp_free((PyObject*)pevsel); 616 } 617 618 static PyObject *pyrf_evsel__open(struct pyrf_evsel *pevsel, 619 PyObject *args, PyObject *kwargs) 620 { 621 struct perf_evsel *evsel = &pevsel->evsel; 622 struct cpu_map *cpus = NULL; 623 struct thread_map *threads = NULL; 624 PyObject *pcpus = NULL, *pthreads = NULL; 625 int group = 0, inherit = 0; 626 static char *kwlist[] = { "cpus", "threads", "group", "inherit", NULL }; 627 628 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOii", kwlist, 629 &pcpus, &pthreads, &group, &inherit)) 630 return NULL; 631 632 if (pthreads != NULL) 633 threads = ((struct pyrf_thread_map *)pthreads)->threads; 634 635 if (pcpus != NULL) 636 cpus = ((struct pyrf_cpu_map *)pcpus)->cpus; 637 638 evsel->attr.inherit = inherit; 639 /* 640 * This will group just the fds for this single evsel, to group 641 * multiple events, use evlist.open(). 642 */ 643 if (perf_evsel__open(evsel, cpus, threads) < 0) { 644 PyErr_SetFromErrno(PyExc_OSError); 645 return NULL; 646 } 647 648 Py_INCREF(Py_None); 649 return Py_None; 650 } 651 652 static PyMethodDef pyrf_evsel__methods[] = { 653 { 654 .ml_name = "open", 655 .ml_meth = (PyCFunction)pyrf_evsel__open, 656 .ml_flags = METH_VARARGS | METH_KEYWORDS, 657 .ml_doc = PyDoc_STR("open the event selector file descriptor table.") 658 }, 659 { .ml_name = NULL, } 660 }; 661 662 static char pyrf_evsel__doc[] = PyDoc_STR("perf event selector list object."); 663 664 static PyTypeObject pyrf_evsel__type = { 665 PyVarObject_HEAD_INIT(NULL, 0) 666 .tp_name = "perf.evsel", 667 .tp_basicsize = sizeof(struct pyrf_evsel), 668 .tp_dealloc = (destructor)pyrf_evsel__delete, 669 .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, 670 .tp_doc = pyrf_evsel__doc, 671 .tp_methods = pyrf_evsel__methods, 672 .tp_init = (initproc)pyrf_evsel__init, 673 }; 674 675 static int pyrf_evsel__setup_types(void) 676 { 677 pyrf_evsel__type.tp_new = PyType_GenericNew; 678 return PyType_Ready(&pyrf_evsel__type); 679 } 680 681 struct pyrf_evlist { 682 PyObject_HEAD 683 684 struct perf_evlist evlist; 685 }; 686 687 static int pyrf_evlist__init(struct pyrf_evlist *pevlist, 688 PyObject *args, PyObject *kwargs __maybe_unused) 689 { 690 PyObject *pcpus = NULL, *pthreads = NULL; 691 struct cpu_map *cpus; 692 struct thread_map *threads; 693 694 if (!PyArg_ParseTuple(args, "OO", &pcpus, &pthreads)) 695 return -1; 696 697 threads = ((struct pyrf_thread_map *)pthreads)->threads; 698 cpus = ((struct pyrf_cpu_map *)pcpus)->cpus; 699 perf_evlist__init(&pevlist->evlist, cpus, threads); 700 return 0; 701 } 702 703 static void pyrf_evlist__delete(struct pyrf_evlist *pevlist) 704 { 705 perf_evlist__exit(&pevlist->evlist); 706 pevlist->ob_type->tp_free((PyObject*)pevlist); 707 } 708 709 static PyObject *pyrf_evlist__mmap(struct pyrf_evlist *pevlist, 710 PyObject *args, PyObject *kwargs) 711 { 712 struct perf_evlist *evlist = &pevlist->evlist; 713 static char *kwlist[] = { "pages", "overwrite", NULL }; 714 int pages = 128, overwrite = false; 715 716 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ii", kwlist, 717 &pages, &overwrite)) 718 return NULL; 719 720 if (perf_evlist__mmap(evlist, pages, overwrite) < 0) { 721 PyErr_SetFromErrno(PyExc_OSError); 722 return NULL; 723 } 724 725 Py_INCREF(Py_None); 726 return Py_None; 727 } 728 729 static PyObject *pyrf_evlist__poll(struct pyrf_evlist *pevlist, 730 PyObject *args, PyObject *kwargs) 731 { 732 struct perf_evlist *evlist = &pevlist->evlist; 733 static char *kwlist[] = { "timeout", NULL }; 734 int timeout = -1, n; 735 736 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i", kwlist, &timeout)) 737 return NULL; 738 739 n = perf_evlist__poll(evlist, timeout); 740 if (n < 0) { 741 PyErr_SetFromErrno(PyExc_OSError); 742 return NULL; 743 } 744 745 return Py_BuildValue("i", n); 746 } 747 748 static PyObject *pyrf_evlist__get_pollfd(struct pyrf_evlist *pevlist, 749 PyObject *args __maybe_unused, 750 PyObject *kwargs __maybe_unused) 751 { 752 struct perf_evlist *evlist = &pevlist->evlist; 753 PyObject *list = PyList_New(0); 754 int i; 755 756 for (i = 0; i < evlist->pollfd.nr; ++i) { 757 PyObject *file; 758 FILE *fp = fdopen(evlist->pollfd.entries[i].fd, "r"); 759 760 if (fp == NULL) 761 goto free_list; 762 763 file = PyFile_FromFile(fp, "perf", "r", NULL); 764 if (file == NULL) 765 goto free_list; 766 767 if (PyList_Append(list, file) != 0) { 768 Py_DECREF(file); 769 goto free_list; 770 } 771 772 Py_DECREF(file); 773 } 774 775 return list; 776 free_list: 777 return PyErr_NoMemory(); 778 } 779 780 781 static PyObject *pyrf_evlist__add(struct pyrf_evlist *pevlist, 782 PyObject *args, 783 PyObject *kwargs __maybe_unused) 784 { 785 struct perf_evlist *evlist = &pevlist->evlist; 786 PyObject *pevsel; 787 struct perf_evsel *evsel; 788 789 if (!PyArg_ParseTuple(args, "O", &pevsel)) 790 return NULL; 791 792 Py_INCREF(pevsel); 793 evsel = &((struct pyrf_evsel *)pevsel)->evsel; 794 evsel->idx = evlist->nr_entries; 795 perf_evlist__add(evlist, evsel); 796 797 return Py_BuildValue("i", evlist->nr_entries); 798 } 799 800 static PyObject *pyrf_evlist__read_on_cpu(struct pyrf_evlist *pevlist, 801 PyObject *args, PyObject *kwargs) 802 { 803 struct perf_evlist *evlist = &pevlist->evlist; 804 union perf_event *event; 805 int sample_id_all = 1, cpu; 806 static char *kwlist[] = { "cpu", "sample_id_all", NULL }; 807 int err; 808 809 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|i", kwlist, 810 &cpu, &sample_id_all)) 811 return NULL; 812 813 event = perf_evlist__mmap_read(evlist, cpu); 814 if (event != NULL) { 815 PyObject *pyevent = pyrf_event__new(event); 816 struct pyrf_event *pevent = (struct pyrf_event *)pyevent; 817 818 perf_evlist__mmap_consume(evlist, cpu); 819 820 if (pyevent == NULL) 821 return PyErr_NoMemory(); 822 823 err = perf_evlist__parse_sample(evlist, event, &pevent->sample); 824 if (err) 825 return PyErr_Format(PyExc_OSError, 826 "perf: can't parse sample, err=%d", err); 827 return pyevent; 828 } 829 830 Py_INCREF(Py_None); 831 return Py_None; 832 } 833 834 static PyObject *pyrf_evlist__open(struct pyrf_evlist *pevlist, 835 PyObject *args, PyObject *kwargs) 836 { 837 struct perf_evlist *evlist = &pevlist->evlist; 838 int group = 0; 839 static char *kwlist[] = { "group", NULL }; 840 841 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOii", kwlist, &group)) 842 return NULL; 843 844 if (group) 845 perf_evlist__set_leader(evlist); 846 847 if (perf_evlist__open(evlist) < 0) { 848 PyErr_SetFromErrno(PyExc_OSError); 849 return NULL; 850 } 851 852 Py_INCREF(Py_None); 853 return Py_None; 854 } 855 856 static PyMethodDef pyrf_evlist__methods[] = { 857 { 858 .ml_name = "mmap", 859 .ml_meth = (PyCFunction)pyrf_evlist__mmap, 860 .ml_flags = METH_VARARGS | METH_KEYWORDS, 861 .ml_doc = PyDoc_STR("mmap the file descriptor table.") 862 }, 863 { 864 .ml_name = "open", 865 .ml_meth = (PyCFunction)pyrf_evlist__open, 866 .ml_flags = METH_VARARGS | METH_KEYWORDS, 867 .ml_doc = PyDoc_STR("open the file descriptors.") 868 }, 869 { 870 .ml_name = "poll", 871 .ml_meth = (PyCFunction)pyrf_evlist__poll, 872 .ml_flags = METH_VARARGS | METH_KEYWORDS, 873 .ml_doc = PyDoc_STR("poll the file descriptor table.") 874 }, 875 { 876 .ml_name = "get_pollfd", 877 .ml_meth = (PyCFunction)pyrf_evlist__get_pollfd, 878 .ml_flags = METH_VARARGS | METH_KEYWORDS, 879 .ml_doc = PyDoc_STR("get the poll file descriptor table.") 880 }, 881 { 882 .ml_name = "add", 883 .ml_meth = (PyCFunction)pyrf_evlist__add, 884 .ml_flags = METH_VARARGS | METH_KEYWORDS, 885 .ml_doc = PyDoc_STR("adds an event selector to the list.") 886 }, 887 { 888 .ml_name = "read_on_cpu", 889 .ml_meth = (PyCFunction)pyrf_evlist__read_on_cpu, 890 .ml_flags = METH_VARARGS | METH_KEYWORDS, 891 .ml_doc = PyDoc_STR("reads an event.") 892 }, 893 { .ml_name = NULL, } 894 }; 895 896 static Py_ssize_t pyrf_evlist__length(PyObject *obj) 897 { 898 struct pyrf_evlist *pevlist = (void *)obj; 899 900 return pevlist->evlist.nr_entries; 901 } 902 903 static PyObject *pyrf_evlist__item(PyObject *obj, Py_ssize_t i) 904 { 905 struct pyrf_evlist *pevlist = (void *)obj; 906 struct perf_evsel *pos; 907 908 if (i >= pevlist->evlist.nr_entries) 909 return NULL; 910 911 evlist__for_each(&pevlist->evlist, pos) { 912 if (i-- == 0) 913 break; 914 } 915 916 return Py_BuildValue("O", container_of(pos, struct pyrf_evsel, evsel)); 917 } 918 919 static PySequenceMethods pyrf_evlist__sequence_methods = { 920 .sq_length = pyrf_evlist__length, 921 .sq_item = pyrf_evlist__item, 922 }; 923 924 static char pyrf_evlist__doc[] = PyDoc_STR("perf event selector list object."); 925 926 static PyTypeObject pyrf_evlist__type = { 927 PyVarObject_HEAD_INIT(NULL, 0) 928 .tp_name = "perf.evlist", 929 .tp_basicsize = sizeof(struct pyrf_evlist), 930 .tp_dealloc = (destructor)pyrf_evlist__delete, 931 .tp_flags = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, 932 .tp_as_sequence = &pyrf_evlist__sequence_methods, 933 .tp_doc = pyrf_evlist__doc, 934 .tp_methods = pyrf_evlist__methods, 935 .tp_init = (initproc)pyrf_evlist__init, 936 }; 937 938 static int pyrf_evlist__setup_types(void) 939 { 940 pyrf_evlist__type.tp_new = PyType_GenericNew; 941 return PyType_Ready(&pyrf_evlist__type); 942 } 943 944 #define PERF_CONST(name) { #name, PERF_##name } 945 946 static struct { 947 const char *name; 948 int value; 949 } perf__constants[] = { 950 PERF_CONST(TYPE_HARDWARE), 951 PERF_CONST(TYPE_SOFTWARE), 952 PERF_CONST(TYPE_TRACEPOINT), 953 PERF_CONST(TYPE_HW_CACHE), 954 PERF_CONST(TYPE_RAW), 955 PERF_CONST(TYPE_BREAKPOINT), 956 957 PERF_CONST(COUNT_HW_CPU_CYCLES), 958 PERF_CONST(COUNT_HW_INSTRUCTIONS), 959 PERF_CONST(COUNT_HW_CACHE_REFERENCES), 960 PERF_CONST(COUNT_HW_CACHE_MISSES), 961 PERF_CONST(COUNT_HW_BRANCH_INSTRUCTIONS), 962 PERF_CONST(COUNT_HW_BRANCH_MISSES), 963 PERF_CONST(COUNT_HW_BUS_CYCLES), 964 PERF_CONST(COUNT_HW_CACHE_L1D), 965 PERF_CONST(COUNT_HW_CACHE_L1I), 966 PERF_CONST(COUNT_HW_CACHE_LL), 967 PERF_CONST(COUNT_HW_CACHE_DTLB), 968 PERF_CONST(COUNT_HW_CACHE_ITLB), 969 PERF_CONST(COUNT_HW_CACHE_BPU), 970 PERF_CONST(COUNT_HW_CACHE_OP_READ), 971 PERF_CONST(COUNT_HW_CACHE_OP_WRITE), 972 PERF_CONST(COUNT_HW_CACHE_OP_PREFETCH), 973 PERF_CONST(COUNT_HW_CACHE_RESULT_ACCESS), 974 PERF_CONST(COUNT_HW_CACHE_RESULT_MISS), 975 976 PERF_CONST(COUNT_HW_STALLED_CYCLES_FRONTEND), 977 PERF_CONST(COUNT_HW_STALLED_CYCLES_BACKEND), 978 979 PERF_CONST(COUNT_SW_CPU_CLOCK), 980 PERF_CONST(COUNT_SW_TASK_CLOCK), 981 PERF_CONST(COUNT_SW_PAGE_FAULTS), 982 PERF_CONST(COUNT_SW_CONTEXT_SWITCHES), 983 PERF_CONST(COUNT_SW_CPU_MIGRATIONS), 984 PERF_CONST(COUNT_SW_PAGE_FAULTS_MIN), 985 PERF_CONST(COUNT_SW_PAGE_FAULTS_MAJ), 986 PERF_CONST(COUNT_SW_ALIGNMENT_FAULTS), 987 PERF_CONST(COUNT_SW_EMULATION_FAULTS), 988 PERF_CONST(COUNT_SW_DUMMY), 989 990 PERF_CONST(SAMPLE_IP), 991 PERF_CONST(SAMPLE_TID), 992 PERF_CONST(SAMPLE_TIME), 993 PERF_CONST(SAMPLE_ADDR), 994 PERF_CONST(SAMPLE_READ), 995 PERF_CONST(SAMPLE_CALLCHAIN), 996 PERF_CONST(SAMPLE_ID), 997 PERF_CONST(SAMPLE_CPU), 998 PERF_CONST(SAMPLE_PERIOD), 999 PERF_CONST(SAMPLE_STREAM_ID), 1000 PERF_CONST(SAMPLE_RAW), 1001 1002 PERF_CONST(FORMAT_TOTAL_TIME_ENABLED), 1003 PERF_CONST(FORMAT_TOTAL_TIME_RUNNING), 1004 PERF_CONST(FORMAT_ID), 1005 PERF_CONST(FORMAT_GROUP), 1006 1007 PERF_CONST(RECORD_MMAP), 1008 PERF_CONST(RECORD_LOST), 1009 PERF_CONST(RECORD_COMM), 1010 PERF_CONST(RECORD_EXIT), 1011 PERF_CONST(RECORD_THROTTLE), 1012 PERF_CONST(RECORD_UNTHROTTLE), 1013 PERF_CONST(RECORD_FORK), 1014 PERF_CONST(RECORD_READ), 1015 PERF_CONST(RECORD_SAMPLE), 1016 PERF_CONST(RECORD_MMAP2), 1017 PERF_CONST(RECORD_AUX), 1018 PERF_CONST(RECORD_ITRACE_START), 1019 PERF_CONST(RECORD_LOST_SAMPLES), 1020 PERF_CONST(RECORD_SWITCH), 1021 PERF_CONST(RECORD_SWITCH_CPU_WIDE), 1022 { .name = NULL, }, 1023 }; 1024 1025 static PyMethodDef perf__methods[] = { 1026 { .ml_name = NULL, } 1027 }; 1028 1029 PyMODINIT_FUNC initperf(void) 1030 { 1031 PyObject *obj; 1032 int i; 1033 PyObject *dict, *module = Py_InitModule("perf", perf__methods); 1034 1035 if (module == NULL || 1036 pyrf_event__setup_types() < 0 || 1037 pyrf_evlist__setup_types() < 0 || 1038 pyrf_evsel__setup_types() < 0 || 1039 pyrf_thread_map__setup_types() < 0 || 1040 pyrf_cpu_map__setup_types() < 0) 1041 return; 1042 1043 /* The page_size is placed in util object. */ 1044 page_size = sysconf(_SC_PAGE_SIZE); 1045 1046 Py_INCREF(&pyrf_evlist__type); 1047 PyModule_AddObject(module, "evlist", (PyObject*)&pyrf_evlist__type); 1048 1049 Py_INCREF(&pyrf_evsel__type); 1050 PyModule_AddObject(module, "evsel", (PyObject*)&pyrf_evsel__type); 1051 1052 Py_INCREF(&pyrf_thread_map__type); 1053 PyModule_AddObject(module, "thread_map", (PyObject*)&pyrf_thread_map__type); 1054 1055 Py_INCREF(&pyrf_cpu_map__type); 1056 PyModule_AddObject(module, "cpu_map", (PyObject*)&pyrf_cpu_map__type); 1057 1058 dict = PyModule_GetDict(module); 1059 if (dict == NULL) 1060 goto error; 1061 1062 for (i = 0; perf__constants[i].name != NULL; i++) { 1063 obj = PyInt_FromLong(perf__constants[i].value); 1064 if (obj == NULL) 1065 goto error; 1066 PyDict_SetItemString(dict, perf__constants[i].name, obj); 1067 Py_DECREF(obj); 1068 } 1069 1070 error: 1071 if (PyErr_Occurred()) 1072 PyErr_SetString(PyExc_ImportError, "perf: Init failed!"); 1073 } 1074 1075 /* 1076 * Dummy, to avoid dragging all the test_attr infrastructure in the python 1077 * binding. 1078 */ 1079 void test_attr__open(struct perf_event_attr *attr, pid_t pid, int cpu, 1080 int fd, int group_fd, unsigned long flags) 1081 { 1082 } 1083