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