| .. | .. |
|---|
| 4 | 4 | #include <inttypes.h> |
|---|
| 5 | 5 | #include <poll.h> |
|---|
| 6 | 6 | #include <linux/err.h> |
|---|
| 7 | +#include <perf/cpumap.h> |
|---|
| 8 | +#include <traceevent/event-parse.h> |
|---|
| 9 | +#include <perf/mmap.h> |
|---|
| 7 | 10 | #include "evlist.h" |
|---|
| 8 | 11 | #include "callchain.h" |
|---|
| 9 | 12 | #include "evsel.h" |
|---|
| 10 | 13 | #include "event.h" |
|---|
| 11 | | -#include "cpumap.h" |
|---|
| 12 | 14 | #include "print_binary.h" |
|---|
| 13 | 15 | #include "thread_map.h" |
|---|
| 16 | +#include "trace-event.h" |
|---|
| 14 | 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" |
|---|
| 15 | 23 | |
|---|
| 16 | 24 | #if PY_MAJOR_VERSION < 3 |
|---|
| 17 | 25 | #define _PyUnicode_FromString(arg) \ |
|---|
| .. | .. |
|---|
| 50 | 58 | } |
|---|
| 51 | 59 | |
|---|
| 52 | 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 | +/* |
|---|
| 53 | 83 | * Support debug printing even though util/debug.c is not linked. That means |
|---|
| 54 | 84 | * implementing 'verbose' and 'eprintf'. |
|---|
| 55 | 85 | */ |
|---|
| 56 | 86 | int verbose; |
|---|
| 87 | +int debug_peo_args; |
|---|
| 88 | + |
|---|
| 89 | +int eprintf(int level, int var, const char *fmt, ...); |
|---|
| 57 | 90 | |
|---|
| 58 | 91 | int eprintf(int level, int var, const char *fmt, ...) |
|---|
| 59 | 92 | { |
|---|
| .. | .. |
|---|
| 92 | 125 | |
|---|
| 93 | 126 | struct pyrf_event { |
|---|
| 94 | 127 | PyObject_HEAD |
|---|
| 95 | | - struct perf_evsel *evsel; |
|---|
| 128 | + struct evsel *evsel; |
|---|
| 96 | 129 | struct perf_sample sample; |
|---|
| 97 | 130 | union perf_event event; |
|---|
| 98 | 131 | }; |
|---|
| .. | .. |
|---|
| 114 | 147 | sample_members |
|---|
| 115 | 148 | member_def(perf_event_header, type, T_UINT, "event type"), |
|---|
| 116 | 149 | member_def(perf_event_header, misc, T_UINT, "event misc"), |
|---|
| 117 | | - member_def(mmap_event, pid, T_UINT, "event pid"), |
|---|
| 118 | | - member_def(mmap_event, tid, T_UINT, "event tid"), |
|---|
| 119 | | - member_def(mmap_event, start, T_ULONGLONG, "start of the map"), |
|---|
| 120 | | - member_def(mmap_event, len, T_ULONGLONG, "map length"), |
|---|
| 121 | | - member_def(mmap_event, pgoff, T_ULONGLONG, "page offset"), |
|---|
| 122 | | - member_def(mmap_event, filename, T_STRING_INPLACE, "backing store"), |
|---|
| 150 | + member_def(perf_record_mmap, pid, T_UINT, "event pid"), |
|---|
| 151 | + member_def(perf_record_mmap, tid, T_UINT, "event tid"), |
|---|
| 152 | + member_def(perf_record_mmap, start, T_ULONGLONG, "start of the map"), |
|---|
| 153 | + member_def(perf_record_mmap, len, T_ULONGLONG, "map length"), |
|---|
| 154 | + member_def(perf_record_mmap, pgoff, T_ULONGLONG, "page offset"), |
|---|
| 155 | + member_def(perf_record_mmap, filename, T_STRING_INPLACE, "backing store"), |
|---|
| 123 | 156 | { .name = NULL, }, |
|---|
| 124 | 157 | }; |
|---|
| 125 | 158 | |
|---|
| .. | .. |
|---|
| 128 | 161 | PyObject *ret; |
|---|
| 129 | 162 | char *s; |
|---|
| 130 | 163 | |
|---|
| 131 | | - if (asprintf(&s, "{ type: mmap, pid: %u, tid: %u, start: %#" PRIx64 ", " |
|---|
| 132 | | - "length: %#" PRIx64 ", offset: %#" PRIx64 ", " |
|---|
| 164 | + if (asprintf(&s, "{ type: mmap, pid: %u, tid: %u, start: %#" PRI_lx64 ", " |
|---|
| 165 | + "length: %#" PRI_lx64 ", offset: %#" PRI_lx64 ", " |
|---|
| 133 | 166 | "filename: %s }", |
|---|
| 134 | 167 | pevent->event.mmap.pid, pevent->event.mmap.tid, |
|---|
| 135 | 168 | pevent->event.mmap.start, pevent->event.mmap.len, |
|---|
| .. | .. |
|---|
| 157 | 190 | static PyMemberDef pyrf_task_event__members[] = { |
|---|
| 158 | 191 | sample_members |
|---|
| 159 | 192 | member_def(perf_event_header, type, T_UINT, "event type"), |
|---|
| 160 | | - member_def(fork_event, pid, T_UINT, "event pid"), |
|---|
| 161 | | - member_def(fork_event, ppid, T_UINT, "event ppid"), |
|---|
| 162 | | - member_def(fork_event, tid, T_UINT, "event tid"), |
|---|
| 163 | | - member_def(fork_event, ptid, T_UINT, "event ptid"), |
|---|
| 164 | | - member_def(fork_event, time, T_ULONGLONG, "timestamp"), |
|---|
| 193 | + member_def(perf_record_fork, pid, T_UINT, "event pid"), |
|---|
| 194 | + member_def(perf_record_fork, ppid, T_UINT, "event ppid"), |
|---|
| 195 | + member_def(perf_record_fork, tid, T_UINT, "event tid"), |
|---|
| 196 | + member_def(perf_record_fork, ptid, T_UINT, "event ptid"), |
|---|
| 197 | + member_def(perf_record_fork, time, T_ULONGLONG, "timestamp"), |
|---|
| 165 | 198 | { .name = NULL, }, |
|---|
| 166 | 199 | }; |
|---|
| 167 | 200 | |
|---|
| 168 | 201 | static PyObject *pyrf_task_event__repr(struct pyrf_event *pevent) |
|---|
| 169 | 202 | { |
|---|
| 170 | 203 | return _PyUnicode_FromFormat("{ type: %s, pid: %u, ppid: %u, tid: %u, " |
|---|
| 171 | | - "ptid: %u, time: %" PRIu64 "}", |
|---|
| 204 | + "ptid: %u, time: %" PRI_lu64 "}", |
|---|
| 172 | 205 | pevent->event.header.type == PERF_RECORD_FORK ? "fork" : "exit", |
|---|
| 173 | 206 | pevent->event.fork.pid, |
|---|
| 174 | 207 | pevent->event.fork.ppid, |
|---|
| .. | .. |
|---|
| 192 | 225 | static PyMemberDef pyrf_comm_event__members[] = { |
|---|
| 193 | 226 | sample_members |
|---|
| 194 | 227 | member_def(perf_event_header, type, T_UINT, "event type"), |
|---|
| 195 | | - member_def(comm_event, pid, T_UINT, "event pid"), |
|---|
| 196 | | - member_def(comm_event, tid, T_UINT, "event tid"), |
|---|
| 197 | | - member_def(comm_event, comm, T_STRING_INPLACE, "process name"), |
|---|
| 228 | + member_def(perf_record_comm, pid, T_UINT, "event pid"), |
|---|
| 229 | + member_def(perf_record_comm, tid, T_UINT, "event tid"), |
|---|
| 230 | + member_def(perf_record_comm, comm, T_STRING_INPLACE, "process name"), |
|---|
| 198 | 231 | { .name = NULL, }, |
|---|
| 199 | 232 | }; |
|---|
| 200 | 233 | |
|---|
| .. | .. |
|---|
| 221 | 254 | static PyMemberDef pyrf_throttle_event__members[] = { |
|---|
| 222 | 255 | sample_members |
|---|
| 223 | 256 | member_def(perf_event_header, type, T_UINT, "event type"), |
|---|
| 224 | | - member_def(throttle_event, time, T_ULONGLONG, "timestamp"), |
|---|
| 225 | | - member_def(throttle_event, id, T_ULONGLONG, "event id"), |
|---|
| 226 | | - member_def(throttle_event, stream_id, T_ULONGLONG, "event stream id"), |
|---|
| 257 | + member_def(perf_record_throttle, time, T_ULONGLONG, "timestamp"), |
|---|
| 258 | + member_def(perf_record_throttle, id, T_ULONGLONG, "event id"), |
|---|
| 259 | + member_def(perf_record_throttle, stream_id, T_ULONGLONG, "event stream id"), |
|---|
| 227 | 260 | { .name = NULL, }, |
|---|
| 228 | 261 | }; |
|---|
| 229 | 262 | |
|---|
| 230 | 263 | static PyObject *pyrf_throttle_event__repr(struct pyrf_event *pevent) |
|---|
| 231 | 264 | { |
|---|
| 232 | | - struct throttle_event *te = (struct throttle_event *)(&pevent->event.header + 1); |
|---|
| 265 | + struct perf_record_throttle *te = (struct perf_record_throttle *)(&pevent->event.header + 1); |
|---|
| 233 | 266 | |
|---|
| 234 | | - return _PyUnicode_FromFormat("{ type: %sthrottle, time: %" PRIu64 ", id: %" PRIu64 |
|---|
| 235 | | - ", stream_id: %" PRIu64 " }", |
|---|
| 267 | + return _PyUnicode_FromFormat("{ type: %sthrottle, time: %" PRI_lu64 ", id: %" PRI_lu64 |
|---|
| 268 | + ", stream_id: %" PRI_lu64 " }", |
|---|
| 236 | 269 | pevent->event.header.type == PERF_RECORD_THROTTLE ? "" : "un", |
|---|
| 237 | 270 | te->time, te->id, te->stream_id); |
|---|
| 238 | 271 | } |
|---|
| .. | .. |
|---|
| 251 | 284 | |
|---|
| 252 | 285 | static PyMemberDef pyrf_lost_event__members[] = { |
|---|
| 253 | 286 | sample_members |
|---|
| 254 | | - member_def(lost_event, id, T_ULONGLONG, "event id"), |
|---|
| 255 | | - member_def(lost_event, lost, T_ULONGLONG, "number of lost events"), |
|---|
| 287 | + member_def(perf_record_lost, id, T_ULONGLONG, "event id"), |
|---|
| 288 | + member_def(perf_record_lost, lost, T_ULONGLONG, "number of lost events"), |
|---|
| 256 | 289 | { .name = NULL, }, |
|---|
| 257 | 290 | }; |
|---|
| 258 | 291 | |
|---|
| .. | .. |
|---|
| 261 | 294 | PyObject *ret; |
|---|
| 262 | 295 | char *s; |
|---|
| 263 | 296 | |
|---|
| 264 | | - if (asprintf(&s, "{ type: lost, id: %#" PRIx64 ", " |
|---|
| 265 | | - "lost: %#" PRIx64 " }", |
|---|
| 297 | + if (asprintf(&s, "{ type: lost, id: %#" PRI_lx64 ", " |
|---|
| 298 | + "lost: %#" PRI_lx64 " }", |
|---|
| 266 | 299 | pevent->event.lost.id, pevent->event.lost.lost) < 0) { |
|---|
| 267 | 300 | ret = PyErr_NoMemory(); |
|---|
| 268 | 301 | } else { |
|---|
| .. | .. |
|---|
| 286 | 319 | |
|---|
| 287 | 320 | static PyMemberDef pyrf_read_event__members[] = { |
|---|
| 288 | 321 | sample_members |
|---|
| 289 | | - member_def(read_event, pid, T_UINT, "event pid"), |
|---|
| 290 | | - member_def(read_event, tid, T_UINT, "event tid"), |
|---|
| 322 | + member_def(perf_record_read, pid, T_UINT, "event pid"), |
|---|
| 323 | + member_def(perf_record_read, tid, T_UINT, "event tid"), |
|---|
| 291 | 324 | { .name = NULL, }, |
|---|
| 292 | 325 | }; |
|---|
| 293 | 326 | |
|---|
| .. | .. |
|---|
| 336 | 369 | |
|---|
| 337 | 370 | static bool is_tracepoint(struct pyrf_event *pevent) |
|---|
| 338 | 371 | { |
|---|
| 339 | | - return pevent->evsel->attr.type == PERF_TYPE_TRACEPOINT; |
|---|
| 372 | + return pevent->evsel->core.attr.type == PERF_TYPE_TRACEPOINT; |
|---|
| 340 | 373 | } |
|---|
| 341 | 374 | |
|---|
| 342 | 375 | static PyObject* |
|---|
| 343 | | -tracepoint_field(struct pyrf_event *pe, struct format_field *field) |
|---|
| 376 | +tracepoint_field(struct pyrf_event *pe, struct tep_format_field *field) |
|---|
| 344 | 377 | { |
|---|
| 345 | | - struct tep_handle *pevent = field->event->pevent; |
|---|
| 378 | + struct tep_handle *pevent = field->event->tep; |
|---|
| 346 | 379 | void *data = pe->sample.raw_data; |
|---|
| 347 | 380 | PyObject *ret = NULL; |
|---|
| 348 | 381 | unsigned long long val; |
|---|
| 349 | 382 | unsigned int offset, len; |
|---|
| 350 | 383 | |
|---|
| 351 | | - if (field->flags & FIELD_IS_ARRAY) { |
|---|
| 384 | + if (field->flags & TEP_FIELD_IS_ARRAY) { |
|---|
| 352 | 385 | offset = field->offset; |
|---|
| 353 | 386 | len = field->size; |
|---|
| 354 | | - if (field->flags & FIELD_IS_DYNAMIC) { |
|---|
| 387 | + if (field->flags & TEP_FIELD_IS_DYNAMIC) { |
|---|
| 355 | 388 | val = tep_read_number(pevent, data + offset, len); |
|---|
| 356 | 389 | offset = val; |
|---|
| 357 | 390 | len = offset >> 16; |
|---|
| 358 | 391 | offset &= 0xffff; |
|---|
| 359 | 392 | } |
|---|
| 360 | | - if (field->flags & FIELD_IS_STRING && |
|---|
| 393 | + if (field->flags & TEP_FIELD_IS_STRING && |
|---|
| 361 | 394 | is_printable_array(data + offset, len)) { |
|---|
| 362 | 395 | ret = _PyUnicode_FromString((char *)data + offset); |
|---|
| 363 | 396 | } else { |
|---|
| 364 | 397 | ret = PyByteArray_FromStringAndSize((const char *) data + offset, len); |
|---|
| 365 | | - field->flags &= ~FIELD_IS_STRING; |
|---|
| 398 | + field->flags &= ~TEP_FIELD_IS_STRING; |
|---|
| 366 | 399 | } |
|---|
| 367 | 400 | } else { |
|---|
| 368 | 401 | val = tep_read_number(pevent, data + field->offset, |
|---|
| 369 | 402 | field->size); |
|---|
| 370 | | - if (field->flags & FIELD_IS_POINTER) |
|---|
| 403 | + if (field->flags & TEP_FIELD_IS_POINTER) |
|---|
| 371 | 404 | ret = PyLong_FromUnsignedLong((unsigned long) val); |
|---|
| 372 | | - else if (field->flags & FIELD_IS_SIGNED) |
|---|
| 405 | + else if (field->flags & TEP_FIELD_IS_SIGNED) |
|---|
| 373 | 406 | ret = PyLong_FromLong((long) val); |
|---|
| 374 | 407 | else |
|---|
| 375 | 408 | ret = PyLong_FromUnsignedLong((unsigned long) val); |
|---|
| .. | .. |
|---|
| 382 | 415 | get_tracepoint_field(struct pyrf_event *pevent, PyObject *attr_name) |
|---|
| 383 | 416 | { |
|---|
| 384 | 417 | const char *str = _PyUnicode_AsString(PyObject_Str(attr_name)); |
|---|
| 385 | | - struct perf_evsel *evsel = pevent->evsel; |
|---|
| 386 | | - struct format_field *field; |
|---|
| 418 | + struct evsel *evsel = pevent->evsel; |
|---|
| 419 | + struct tep_format_field *field; |
|---|
| 387 | 420 | |
|---|
| 388 | 421 | if (!evsel->tp_format) { |
|---|
| 389 | | - struct event_format *tp_format; |
|---|
| 422 | + struct tep_event *tp_format; |
|---|
| 390 | 423 | |
|---|
| 391 | | - tp_format = trace_event__tp_format_id(evsel->attr.config); |
|---|
| 424 | + tp_format = trace_event__tp_format_id(evsel->core.attr.config); |
|---|
| 392 | 425 | if (!tp_format) |
|---|
| 393 | 426 | return NULL; |
|---|
| 394 | 427 | |
|---|
| .. | .. |
|---|
| 429 | 462 | static PyMemberDef pyrf_context_switch_event__members[] = { |
|---|
| 430 | 463 | sample_members |
|---|
| 431 | 464 | member_def(perf_event_header, type, T_UINT, "event type"), |
|---|
| 432 | | - member_def(context_switch_event, next_prev_pid, T_UINT, "next/prev pid"), |
|---|
| 433 | | - member_def(context_switch_event, next_prev_tid, T_UINT, "next/prev tid"), |
|---|
| 465 | + member_def(perf_record_switch, next_prev_pid, T_UINT, "next/prev pid"), |
|---|
| 466 | + member_def(perf_record_switch, next_prev_tid, T_UINT, "next/prev tid"), |
|---|
| 434 | 467 | { .name = NULL, }, |
|---|
| 435 | 468 | }; |
|---|
| 436 | 469 | |
|---|
| .. | .. |
|---|
| 535 | 568 | struct pyrf_cpu_map { |
|---|
| 536 | 569 | PyObject_HEAD |
|---|
| 537 | 570 | |
|---|
| 538 | | - struct cpu_map *cpus; |
|---|
| 571 | + struct perf_cpu_map *cpus; |
|---|
| 539 | 572 | }; |
|---|
| 540 | 573 | |
|---|
| 541 | 574 | static int pyrf_cpu_map__init(struct pyrf_cpu_map *pcpus, |
|---|
| .. | .. |
|---|
| 548 | 581 | kwlist, &cpustr)) |
|---|
| 549 | 582 | return -1; |
|---|
| 550 | 583 | |
|---|
| 551 | | - pcpus->cpus = cpu_map__new(cpustr); |
|---|
| 584 | + pcpus->cpus = perf_cpu_map__new(cpustr); |
|---|
| 552 | 585 | if (pcpus->cpus == NULL) |
|---|
| 553 | 586 | return -1; |
|---|
| 554 | 587 | return 0; |
|---|
| .. | .. |
|---|
| 556 | 589 | |
|---|
| 557 | 590 | static void pyrf_cpu_map__delete(struct pyrf_cpu_map *pcpus) |
|---|
| 558 | 591 | { |
|---|
| 559 | | - cpu_map__put(pcpus->cpus); |
|---|
| 592 | + perf_cpu_map__put(pcpus->cpus); |
|---|
| 560 | 593 | Py_TYPE(pcpus)->tp_free((PyObject*)pcpus); |
|---|
| 561 | 594 | } |
|---|
| 562 | 595 | |
|---|
| .. | .. |
|---|
| 604 | 637 | struct pyrf_thread_map { |
|---|
| 605 | 638 | PyObject_HEAD |
|---|
| 606 | 639 | |
|---|
| 607 | | - struct thread_map *threads; |
|---|
| 640 | + struct perf_thread_map *threads; |
|---|
| 608 | 641 | }; |
|---|
| 609 | 642 | |
|---|
| 610 | 643 | static int pyrf_thread_map__init(struct pyrf_thread_map *pthreads, |
|---|
| .. | .. |
|---|
| 625 | 658 | |
|---|
| 626 | 659 | static void pyrf_thread_map__delete(struct pyrf_thread_map *pthreads) |
|---|
| 627 | 660 | { |
|---|
| 628 | | - thread_map__put(pthreads->threads); |
|---|
| 661 | + perf_thread_map__put(pthreads->threads); |
|---|
| 629 | 662 | Py_TYPE(pthreads)->tp_free((PyObject*)pthreads); |
|---|
| 630 | 663 | } |
|---|
| 631 | 664 | |
|---|
| .. | .. |
|---|
| 673 | 706 | struct pyrf_evsel { |
|---|
| 674 | 707 | PyObject_HEAD |
|---|
| 675 | 708 | |
|---|
| 676 | | - struct perf_evsel evsel; |
|---|
| 709 | + struct evsel evsel; |
|---|
| 677 | 710 | }; |
|---|
| 678 | 711 | |
|---|
| 679 | 712 | static int pyrf_evsel__init(struct pyrf_evsel *pevsel, |
|---|
| .. | .. |
|---|
| 781 | 814 | attr.sample_id_all = sample_id_all; |
|---|
| 782 | 815 | attr.size = sizeof(attr); |
|---|
| 783 | 816 | |
|---|
| 784 | | - perf_evsel__init(&pevsel->evsel, &attr, idx); |
|---|
| 817 | + evsel__init(&pevsel->evsel, &attr, idx); |
|---|
| 785 | 818 | return 0; |
|---|
| 786 | 819 | } |
|---|
| 787 | 820 | |
|---|
| 788 | 821 | static void pyrf_evsel__delete(struct pyrf_evsel *pevsel) |
|---|
| 789 | 822 | { |
|---|
| 790 | | - perf_evsel__exit(&pevsel->evsel); |
|---|
| 823 | + evsel__exit(&pevsel->evsel); |
|---|
| 791 | 824 | Py_TYPE(pevsel)->tp_free((PyObject*)pevsel); |
|---|
| 792 | 825 | } |
|---|
| 793 | 826 | |
|---|
| 794 | 827 | static PyObject *pyrf_evsel__open(struct pyrf_evsel *pevsel, |
|---|
| 795 | 828 | PyObject *args, PyObject *kwargs) |
|---|
| 796 | 829 | { |
|---|
| 797 | | - struct perf_evsel *evsel = &pevsel->evsel; |
|---|
| 798 | | - struct cpu_map *cpus = NULL; |
|---|
| 799 | | - struct thread_map *threads = NULL; |
|---|
| 830 | + struct evsel *evsel = &pevsel->evsel; |
|---|
| 831 | + struct perf_cpu_map *cpus = NULL; |
|---|
| 832 | + struct perf_thread_map *threads = NULL; |
|---|
| 800 | 833 | PyObject *pcpus = NULL, *pthreads = NULL; |
|---|
| 801 | 834 | int group = 0, inherit = 0; |
|---|
| 802 | 835 | static char *kwlist[] = { "cpus", "threads", "group", "inherit", NULL }; |
|---|
| .. | .. |
|---|
| 811 | 844 | if (pcpus != NULL) |
|---|
| 812 | 845 | cpus = ((struct pyrf_cpu_map *)pcpus)->cpus; |
|---|
| 813 | 846 | |
|---|
| 814 | | - evsel->attr.inherit = inherit; |
|---|
| 847 | + evsel->core.attr.inherit = inherit; |
|---|
| 815 | 848 | /* |
|---|
| 816 | 849 | * This will group just the fds for this single evsel, to group |
|---|
| 817 | 850 | * multiple events, use evlist.open(). |
|---|
| 818 | 851 | */ |
|---|
| 819 | | - if (perf_evsel__open(evsel, cpus, threads) < 0) { |
|---|
| 852 | + if (evsel__open(evsel, cpus, threads) < 0) { |
|---|
| 820 | 853 | PyErr_SetFromErrno(PyExc_OSError); |
|---|
| 821 | 854 | return NULL; |
|---|
| 822 | 855 | } |
|---|
| .. | .. |
|---|
| 857 | 890 | struct pyrf_evlist { |
|---|
| 858 | 891 | PyObject_HEAD |
|---|
| 859 | 892 | |
|---|
| 860 | | - struct perf_evlist evlist; |
|---|
| 893 | + struct evlist evlist; |
|---|
| 861 | 894 | }; |
|---|
| 862 | 895 | |
|---|
| 863 | 896 | static int pyrf_evlist__init(struct pyrf_evlist *pevlist, |
|---|
| 864 | 897 | PyObject *args, PyObject *kwargs __maybe_unused) |
|---|
| 865 | 898 | { |
|---|
| 866 | 899 | PyObject *pcpus = NULL, *pthreads = NULL; |
|---|
| 867 | | - struct cpu_map *cpus; |
|---|
| 868 | | - struct thread_map *threads; |
|---|
| 900 | + struct perf_cpu_map *cpus; |
|---|
| 901 | + struct perf_thread_map *threads; |
|---|
| 869 | 902 | |
|---|
| 870 | 903 | if (!PyArg_ParseTuple(args, "OO", &pcpus, &pthreads)) |
|---|
| 871 | 904 | return -1; |
|---|
| 872 | 905 | |
|---|
| 873 | 906 | threads = ((struct pyrf_thread_map *)pthreads)->threads; |
|---|
| 874 | 907 | cpus = ((struct pyrf_cpu_map *)pcpus)->cpus; |
|---|
| 875 | | - perf_evlist__init(&pevlist->evlist, cpus, threads); |
|---|
| 908 | + evlist__init(&pevlist->evlist, cpus, threads); |
|---|
| 876 | 909 | return 0; |
|---|
| 877 | 910 | } |
|---|
| 878 | 911 | |
|---|
| 879 | 912 | static void pyrf_evlist__delete(struct pyrf_evlist *pevlist) |
|---|
| 880 | 913 | { |
|---|
| 881 | | - perf_evlist__exit(&pevlist->evlist); |
|---|
| 914 | + evlist__exit(&pevlist->evlist); |
|---|
| 882 | 915 | Py_TYPE(pevlist)->tp_free((PyObject*)pevlist); |
|---|
| 883 | 916 | } |
|---|
| 884 | 917 | |
|---|
| 885 | 918 | static PyObject *pyrf_evlist__mmap(struct pyrf_evlist *pevlist, |
|---|
| 886 | 919 | PyObject *args, PyObject *kwargs) |
|---|
| 887 | 920 | { |
|---|
| 888 | | - struct perf_evlist *evlist = &pevlist->evlist; |
|---|
| 921 | + struct evlist *evlist = &pevlist->evlist; |
|---|
| 889 | 922 | static char *kwlist[] = { "pages", "overwrite", NULL }; |
|---|
| 890 | 923 | int pages = 128, overwrite = false; |
|---|
| 891 | 924 | |
|---|
| .. | .. |
|---|
| 893 | 926 | &pages, &overwrite)) |
|---|
| 894 | 927 | return NULL; |
|---|
| 895 | 928 | |
|---|
| 896 | | - if (perf_evlist__mmap(evlist, pages) < 0) { |
|---|
| 929 | + if (evlist__mmap(evlist, pages) < 0) { |
|---|
| 897 | 930 | PyErr_SetFromErrno(PyExc_OSError); |
|---|
| 898 | 931 | return NULL; |
|---|
| 899 | 932 | } |
|---|
| .. | .. |
|---|
| 905 | 938 | static PyObject *pyrf_evlist__poll(struct pyrf_evlist *pevlist, |
|---|
| 906 | 939 | PyObject *args, PyObject *kwargs) |
|---|
| 907 | 940 | { |
|---|
| 908 | | - struct perf_evlist *evlist = &pevlist->evlist; |
|---|
| 941 | + struct evlist *evlist = &pevlist->evlist; |
|---|
| 909 | 942 | static char *kwlist[] = { "timeout", NULL }; |
|---|
| 910 | 943 | int timeout = -1, n; |
|---|
| 911 | 944 | |
|---|
| 912 | 945 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i", kwlist, &timeout)) |
|---|
| 913 | 946 | return NULL; |
|---|
| 914 | 947 | |
|---|
| 915 | | - n = perf_evlist__poll(evlist, timeout); |
|---|
| 948 | + n = evlist__poll(evlist, timeout); |
|---|
| 916 | 949 | if (n < 0) { |
|---|
| 917 | 950 | PyErr_SetFromErrno(PyExc_OSError); |
|---|
| 918 | 951 | return NULL; |
|---|
| .. | .. |
|---|
| 925 | 958 | PyObject *args __maybe_unused, |
|---|
| 926 | 959 | PyObject *kwargs __maybe_unused) |
|---|
| 927 | 960 | { |
|---|
| 928 | | - struct perf_evlist *evlist = &pevlist->evlist; |
|---|
| 961 | + struct evlist *evlist = &pevlist->evlist; |
|---|
| 929 | 962 | PyObject *list = PyList_New(0); |
|---|
| 930 | 963 | int i; |
|---|
| 931 | 964 | |
|---|
| 932 | | - for (i = 0; i < evlist->pollfd.nr; ++i) { |
|---|
| 965 | + for (i = 0; i < evlist->core.pollfd.nr; ++i) { |
|---|
| 933 | 966 | PyObject *file; |
|---|
| 934 | 967 | #if PY_MAJOR_VERSION < 3 |
|---|
| 935 | | - FILE *fp = fdopen(evlist->pollfd.entries[i].fd, "r"); |
|---|
| 968 | + FILE *fp = fdopen(evlist->core.pollfd.entries[i].fd, "r"); |
|---|
| 936 | 969 | |
|---|
| 937 | 970 | if (fp == NULL) |
|---|
| 938 | 971 | goto free_list; |
|---|
| 939 | 972 | |
|---|
| 940 | 973 | file = PyFile_FromFile(fp, "perf", "r", NULL); |
|---|
| 941 | 974 | #else |
|---|
| 942 | | - file = PyFile_FromFd(evlist->pollfd.entries[i].fd, "perf", "r", -1, |
|---|
| 975 | + file = PyFile_FromFd(evlist->core.pollfd.entries[i].fd, "perf", "r", -1, |
|---|
| 943 | 976 | NULL, NULL, NULL, 0); |
|---|
| 944 | 977 | #endif |
|---|
| 945 | 978 | if (file == NULL) |
|---|
| .. | .. |
|---|
| 963 | 996 | PyObject *args, |
|---|
| 964 | 997 | PyObject *kwargs __maybe_unused) |
|---|
| 965 | 998 | { |
|---|
| 966 | | - struct perf_evlist *evlist = &pevlist->evlist; |
|---|
| 999 | + struct evlist *evlist = &pevlist->evlist; |
|---|
| 967 | 1000 | PyObject *pevsel; |
|---|
| 968 | | - struct perf_evsel *evsel; |
|---|
| 1001 | + struct evsel *evsel; |
|---|
| 969 | 1002 | |
|---|
| 970 | 1003 | if (!PyArg_ParseTuple(args, "O", &pevsel)) |
|---|
| 971 | 1004 | return NULL; |
|---|
| 972 | 1005 | |
|---|
| 973 | 1006 | Py_INCREF(pevsel); |
|---|
| 974 | 1007 | evsel = &((struct pyrf_evsel *)pevsel)->evsel; |
|---|
| 975 | | - evsel->idx = evlist->nr_entries; |
|---|
| 976 | | - perf_evlist__add(evlist, evsel); |
|---|
| 1008 | + evsel->idx = evlist->core.nr_entries; |
|---|
| 1009 | + evlist__add(evlist, evsel); |
|---|
| 977 | 1010 | |
|---|
| 978 | | - return Py_BuildValue("i", evlist->nr_entries); |
|---|
| 1011 | + return Py_BuildValue("i", evlist->core.nr_entries); |
|---|
| 979 | 1012 | } |
|---|
| 980 | 1013 | |
|---|
| 981 | | -static struct perf_mmap *get_md(struct perf_evlist *evlist, int cpu) |
|---|
| 1014 | +static struct mmap *get_md(struct evlist *evlist, int cpu) |
|---|
| 982 | 1015 | { |
|---|
| 983 | 1016 | int i; |
|---|
| 984 | 1017 | |
|---|
| 985 | | - for (i = 0; i < evlist->nr_mmaps; i++) { |
|---|
| 986 | | - struct perf_mmap *md = &evlist->mmap[i]; |
|---|
| 1018 | + for (i = 0; i < evlist->core.nr_mmaps; i++) { |
|---|
| 1019 | + struct mmap *md = &evlist->mmap[i]; |
|---|
| 987 | 1020 | |
|---|
| 988 | | - if (md->cpu == cpu) |
|---|
| 1021 | + if (md->core.cpu == cpu) |
|---|
| 989 | 1022 | return md; |
|---|
| 990 | 1023 | } |
|---|
| 991 | 1024 | |
|---|
| .. | .. |
|---|
| 995 | 1028 | static PyObject *pyrf_evlist__read_on_cpu(struct pyrf_evlist *pevlist, |
|---|
| 996 | 1029 | PyObject *args, PyObject *kwargs) |
|---|
| 997 | 1030 | { |
|---|
| 998 | | - struct perf_evlist *evlist = &pevlist->evlist; |
|---|
| 1031 | + struct evlist *evlist = &pevlist->evlist; |
|---|
| 999 | 1032 | union perf_event *event; |
|---|
| 1000 | 1033 | int sample_id_all = 1, cpu; |
|---|
| 1001 | 1034 | static char *kwlist[] = { "cpu", "sample_id_all", NULL }; |
|---|
| 1002 | | - struct perf_mmap *md; |
|---|
| 1035 | + struct mmap *md; |
|---|
| 1003 | 1036 | int err; |
|---|
| 1004 | 1037 | |
|---|
| 1005 | 1038 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|i", kwlist, |
|---|
| .. | .. |
|---|
| 1010 | 1043 | if (!md) |
|---|
| 1011 | 1044 | return NULL; |
|---|
| 1012 | 1045 | |
|---|
| 1013 | | - if (perf_mmap__read_init(md) < 0) |
|---|
| 1046 | + if (perf_mmap__read_init(&md->core) < 0) |
|---|
| 1014 | 1047 | goto end; |
|---|
| 1015 | 1048 | |
|---|
| 1016 | | - event = perf_mmap__read_event(md); |
|---|
| 1049 | + event = perf_mmap__read_event(&md->core); |
|---|
| 1017 | 1050 | if (event != NULL) { |
|---|
| 1018 | 1051 | PyObject *pyevent = pyrf_event__new(event); |
|---|
| 1019 | 1052 | struct pyrf_event *pevent = (struct pyrf_event *)pyevent; |
|---|
| 1020 | | - struct perf_evsel *evsel; |
|---|
| 1053 | + struct evsel *evsel; |
|---|
| 1021 | 1054 | |
|---|
| 1022 | 1055 | if (pyevent == NULL) |
|---|
| 1023 | 1056 | return PyErr_NoMemory(); |
|---|
| .. | .. |
|---|
| 1030 | 1063 | |
|---|
| 1031 | 1064 | pevent->evsel = evsel; |
|---|
| 1032 | 1065 | |
|---|
| 1033 | | - err = perf_evsel__parse_sample(evsel, event, &pevent->sample); |
|---|
| 1066 | + err = evsel__parse_sample(evsel, event, &pevent->sample); |
|---|
| 1034 | 1067 | |
|---|
| 1035 | 1068 | /* Consume the even only after we parsed it out. */ |
|---|
| 1036 | | - perf_mmap__consume(md); |
|---|
| 1069 | + perf_mmap__consume(&md->core); |
|---|
| 1037 | 1070 | |
|---|
| 1038 | 1071 | if (err) |
|---|
| 1039 | 1072 | return PyErr_Format(PyExc_OSError, |
|---|
| .. | .. |
|---|
| 1048 | 1081 | static PyObject *pyrf_evlist__open(struct pyrf_evlist *pevlist, |
|---|
| 1049 | 1082 | PyObject *args, PyObject *kwargs) |
|---|
| 1050 | 1083 | { |
|---|
| 1051 | | - struct perf_evlist *evlist = &pevlist->evlist; |
|---|
| 1084 | + struct evlist *evlist = &pevlist->evlist; |
|---|
| 1052 | 1085 | int group = 0; |
|---|
| 1053 | 1086 | static char *kwlist[] = { "group", NULL }; |
|---|
| 1054 | 1087 | |
|---|
| .. | .. |
|---|
| 1058 | 1091 | if (group) |
|---|
| 1059 | 1092 | perf_evlist__set_leader(evlist); |
|---|
| 1060 | 1093 | |
|---|
| 1061 | | - if (perf_evlist__open(evlist) < 0) { |
|---|
| 1094 | + if (evlist__open(evlist) < 0) { |
|---|
| 1062 | 1095 | PyErr_SetFromErrno(PyExc_OSError); |
|---|
| 1063 | 1096 | return NULL; |
|---|
| 1064 | 1097 | } |
|---|
| .. | .. |
|---|
| 1111 | 1144 | { |
|---|
| 1112 | 1145 | struct pyrf_evlist *pevlist = (void *)obj; |
|---|
| 1113 | 1146 | |
|---|
| 1114 | | - return pevlist->evlist.nr_entries; |
|---|
| 1147 | + return pevlist->evlist.core.nr_entries; |
|---|
| 1115 | 1148 | } |
|---|
| 1116 | 1149 | |
|---|
| 1117 | 1150 | static PyObject *pyrf_evlist__item(PyObject *obj, Py_ssize_t i) |
|---|
| 1118 | 1151 | { |
|---|
| 1119 | 1152 | struct pyrf_evlist *pevlist = (void *)obj; |
|---|
| 1120 | | - struct perf_evsel *pos; |
|---|
| 1153 | + struct evsel *pos; |
|---|
| 1121 | 1154 | |
|---|
| 1122 | | - if (i >= pevlist->evlist.nr_entries) |
|---|
| 1155 | + if (i >= pevlist->evlist.core.nr_entries) |
|---|
| 1123 | 1156 | return NULL; |
|---|
| 1124 | 1157 | |
|---|
| 1125 | 1158 | evlist__for_each_entry(&pevlist->evlist, pos) { |
|---|
| .. | .. |
|---|
| 1241 | 1274 | static PyObject *pyrf__tracepoint(struct pyrf_evsel *pevsel, |
|---|
| 1242 | 1275 | PyObject *args, PyObject *kwargs) |
|---|
| 1243 | 1276 | { |
|---|
| 1244 | | - struct event_format *tp_format; |
|---|
| 1277 | + struct tep_event *tp_format; |
|---|
| 1245 | 1278 | static char *kwlist[] = { "sys", "name", NULL }; |
|---|
| 1246 | 1279 | char *sys = NULL; |
|---|
| 1247 | 1280 | char *name = NULL; |
|---|