2 #include <structmember.h>
9 #include "thread_map.h"
12 * Support debug printing even though util/debug.c is not linked. That means
13 * implementing 'verbose' and 'eprintf'.
17 int eprintf(int level
, int var
, const char *fmt
, ...)
24 ret
= vfprintf(stderr
, fmt
, args
);
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,
36 PyMODINIT_FUNC
initperf(void);
38 #define member_def(type, member, ptype, help) \
40 offsetof(struct pyrf_event, event) + offsetof(struct type, member), \
43 #define sample_member_def(name, member, ptype, help) \
45 offsetof(struct pyrf_event, sample) + offsetof(struct perf_sample, member), \
50 struct perf_sample sample
;
51 union perf_event event
;
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"),
65 static char pyrf_mmap_event__doc
[] = PyDoc_STR("perf mmap event object.");
67 static PyMemberDef pyrf_mmap_event__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"),
79 static PyObject
*pyrf_mmap_event__repr(struct pyrf_event
*pevent
)
84 if (asprintf(&s
, "{ type: mmap, pid: %u, tid: %u, start: %#" PRIx64
", "
85 "length: %#" PRIx64
", offset: %#" PRIx64
", "
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();
92 ret
= PyString_FromString(s
);
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
,
108 static char pyrf_task_event__doc
[] = PyDoc_STR("perf task (fork/exit) event object.");
110 static PyMemberDef pyrf_task_event__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"),
121 static PyObject
*pyrf_task_event__repr(struct pyrf_event
*pevent
)
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
);
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
,
143 static char pyrf_comm_event__doc
[] = PyDoc_STR("perf comm event object.");
145 static PyMemberDef pyrf_comm_event__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"),
154 static PyObject
*pyrf_comm_event__repr(struct pyrf_event
*pevent
)
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
);
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
,
172 static char pyrf_throttle_event__doc
[] = PyDoc_STR("perf throttle event object.");
174 static PyMemberDef pyrf_throttle_event__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"),
183 static PyObject
*pyrf_throttle_event__repr(struct pyrf_event
*pevent
)
185 struct throttle_event
*te
= (struct throttle_event
*)(&pevent
->event
.header
+ 1);
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
);
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
,
203 static char pyrf_lost_event__doc
[] = PyDoc_STR("perf lost event object.");
205 static PyMemberDef pyrf_lost_event__members
[] = {
207 member_def(lost_event
, id
, T_ULONGLONG
, "event id"),
208 member_def(lost_event
, lost
, T_ULONGLONG
, "number of lost events"),
212 static PyObject
*pyrf_lost_event__repr(struct pyrf_event
*pevent
)
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();
222 ret
= PyString_FromString(s
);
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
,
238 static char pyrf_read_event__doc
[] = PyDoc_STR("perf read event object.");
240 static PyMemberDef pyrf_read_event__members
[] = {
242 member_def(read_event
, pid
, T_UINT
, "event pid"),
243 member_def(read_event
, tid
, T_UINT
, "event tid"),
247 static PyObject
*pyrf_read_event__repr(struct pyrf_event
*pevent
)
249 return PyString_FromFormat("{ type: read, pid: %u, tid: %u }",
250 pevent
->event
.read
.pid
,
251 pevent
->event
.read
.tid
);
253 * FIXME: return the array of read values,
254 * making this method useful ;-)
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
,
268 static char pyrf_sample_event__doc
[] = PyDoc_STR("perf sample event object.");
270 static PyMemberDef pyrf_sample_event__members
[] = {
272 member_def(perf_event_header
, type
, T_UINT
, "event type"),
276 static PyObject
*pyrf_sample_event__repr(struct pyrf_event
*pevent
)
281 if (asprintf(&s
, "{ type: sample }") < 0) {
282 ret
= PyErr_NoMemory();
284 ret
= PyString_FromString(s
);
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
,
300 static int pyrf_event__setup_types(void)
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
);
313 err
= PyType_Ready(&pyrf_lost_event__type
);
316 err
= PyType_Ready(&pyrf_task_event__type
);
319 err
= PyType_Ready(&pyrf_comm_event__type
);
322 err
= PyType_Ready(&pyrf_throttle_event__type
);
325 err
= PyType_Ready(&pyrf_read_event__type
);
328 err
= PyType_Ready(&pyrf_sample_event__type
);
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
,
347 static PyObject
*pyrf_event__new(union perf_event
*event
)
349 struct pyrf_event
*pevent
;
352 if (event
->header
.type
< PERF_RECORD_MMAP
||
353 event
->header
.type
> PERF_RECORD_SAMPLE
)
356 ptype
= pyrf_event__type
[event
->header
.type
];
357 pevent
= PyObject_New(struct pyrf_event
, ptype
);
359 memcpy(&pevent
->event
, event
, event
->header
.size
);
360 return (PyObject
*)pevent
;
363 struct pyrf_cpu_map
{
366 struct cpu_map
*cpus
;
369 static int pyrf_cpu_map__init(struct pyrf_cpu_map
*pcpus
,
370 PyObject
*args
, PyObject
*kwargs
)
372 static char *kwlist
[] = { "cpustr", NULL
};
375 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "|s",
379 pcpus
->cpus
= cpu_map__new(cpustr
);
380 if (pcpus
->cpus
== NULL
)
385 static void pyrf_cpu_map__delete(struct pyrf_cpu_map
*pcpus
)
387 cpu_map__put(pcpus
->cpus
);
388 pcpus
->ob_type
->tp_free((PyObject
*)pcpus
);
391 static Py_ssize_t
pyrf_cpu_map__length(PyObject
*obj
)
393 struct pyrf_cpu_map
*pcpus
= (void *)obj
;
395 return pcpus
->cpus
->nr
;
398 static PyObject
*pyrf_cpu_map__item(PyObject
*obj
, Py_ssize_t i
)
400 struct pyrf_cpu_map
*pcpus
= (void *)obj
;
402 if (i
>= pcpus
->cpus
->nr
)
405 return Py_BuildValue("i", pcpus
->cpus
->map
[i
]);
408 static PySequenceMethods pyrf_cpu_map__sequence_methods
= {
409 .sq_length
= pyrf_cpu_map__length
,
410 .sq_item
= pyrf_cpu_map__item
,
413 static char pyrf_cpu_map__doc
[] = PyDoc_STR("cpu map object.");
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
,
426 static int pyrf_cpu_map__setup_types(void)
428 pyrf_cpu_map__type
.tp_new
= PyType_GenericNew
;
429 return PyType_Ready(&pyrf_cpu_map__type
);
432 struct pyrf_thread_map
{
435 struct thread_map
*threads
;
438 static int pyrf_thread_map__init(struct pyrf_thread_map
*pthreads
,
439 PyObject
*args
, PyObject
*kwargs
)
441 static char *kwlist
[] = { "pid", "tid", "uid", NULL
};
442 int pid
= -1, tid
= -1, uid
= UINT_MAX
;
444 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "|iii",
445 kwlist
, &pid
, &tid
, &uid
))
448 pthreads
->threads
= thread_map__new(pid
, tid
, uid
);
449 if (pthreads
->threads
== NULL
)
454 static void pyrf_thread_map__delete(struct pyrf_thread_map
*pthreads
)
456 thread_map__put(pthreads
->threads
);
457 pthreads
->ob_type
->tp_free((PyObject
*)pthreads
);
460 static Py_ssize_t
pyrf_thread_map__length(PyObject
*obj
)
462 struct pyrf_thread_map
*pthreads
= (void *)obj
;
464 return pthreads
->threads
->nr
;
467 static PyObject
*pyrf_thread_map__item(PyObject
*obj
, Py_ssize_t i
)
469 struct pyrf_thread_map
*pthreads
= (void *)obj
;
471 if (i
>= pthreads
->threads
->nr
)
474 return Py_BuildValue("i", pthreads
->threads
->map
[i
]);
477 static PySequenceMethods pyrf_thread_map__sequence_methods
= {
478 .sq_length
= pyrf_thread_map__length
,
479 .sq_item
= pyrf_thread_map__item
,
482 static char pyrf_thread_map__doc
[] = PyDoc_STR("thread map object.");
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
,
495 static int pyrf_thread_map__setup_types(void)
497 pyrf_thread_map__type
.tp_new
= PyType_GenericNew
;
498 return PyType_Ready(&pyrf_thread_map__type
);
504 struct perf_evsel evsel
;
507 static int pyrf_evsel__init(struct pyrf_evsel
*pevsel
,
508 PyObject
*args
, PyObject
*kwargs
)
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
,
515 static char *kwlist
[] = {
546 u64 sample_period
= 0;
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
))
582 if (sample_period
!= 0) {
583 if (attr
.sample_freq
!= 0)
584 return -1; /* FIXME: throw right exception */
585 attr
.sample_period
= sample_period
;
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
;
600 attr
.inherit_stat
= inherit_stat
;
601 attr
.enable_on_exec
= enable_on_exec
;
603 attr
.watermark
= watermark
;
604 attr
.precise_ip
= precise_ip
;
605 attr
.mmap_data
= mmap_data
;
606 attr
.sample_id_all
= sample_id_all
;
608 perf_evsel__init(&pevsel
->evsel
, &attr
, idx
);
612 static void pyrf_evsel__delete(struct pyrf_evsel
*pevsel
)
614 perf_evsel__exit(&pevsel
->evsel
);
615 pevsel
->ob_type
->tp_free((PyObject
*)pevsel
);
618 static PyObject
*pyrf_evsel__open(struct pyrf_evsel
*pevsel
,
619 PyObject
*args
, PyObject
*kwargs
)
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
};
628 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "|OOii", kwlist
,
629 &pcpus
, &pthreads
, &group
, &inherit
))
632 if (pthreads
!= NULL
)
633 threads
= ((struct pyrf_thread_map
*)pthreads
)->threads
;
636 cpus
= ((struct pyrf_cpu_map
*)pcpus
)->cpus
;
638 evsel
->attr
.inherit
= inherit
;
640 * This will group just the fds for this single evsel, to group
641 * multiple events, use evlist.open().
643 if (perf_evsel__open(evsel
, cpus
, threads
) < 0) {
644 PyErr_SetFromErrno(PyExc_OSError
);
652 static PyMethodDef pyrf_evsel__methods
[] = {
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.")
662 static char pyrf_evsel__doc
[] = PyDoc_STR("perf event selector list object.");
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
,
675 static int pyrf_evsel__setup_types(void)
677 pyrf_evsel__type
.tp_new
= PyType_GenericNew
;
678 return PyType_Ready(&pyrf_evsel__type
);
684 struct perf_evlist evlist
;
687 static int pyrf_evlist__init(struct pyrf_evlist
*pevlist
,
688 PyObject
*args
, PyObject
*kwargs __maybe_unused
)
690 PyObject
*pcpus
= NULL
, *pthreads
= NULL
;
691 struct cpu_map
*cpus
;
692 struct thread_map
*threads
;
694 if (!PyArg_ParseTuple(args
, "OO", &pcpus
, &pthreads
))
697 threads
= ((struct pyrf_thread_map
*)pthreads
)->threads
;
698 cpus
= ((struct pyrf_cpu_map
*)pcpus
)->cpus
;
699 perf_evlist__init(&pevlist
->evlist
, cpus
, threads
);
703 static void pyrf_evlist__delete(struct pyrf_evlist
*pevlist
)
705 perf_evlist__exit(&pevlist
->evlist
);
706 pevlist
->ob_type
->tp_free((PyObject
*)pevlist
);
709 static PyObject
*pyrf_evlist__mmap(struct pyrf_evlist
*pevlist
,
710 PyObject
*args
, PyObject
*kwargs
)
712 struct perf_evlist
*evlist
= &pevlist
->evlist
;
713 static char *kwlist
[] = { "pages", "overwrite", NULL
};
714 int pages
= 128, overwrite
= false;
716 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "|ii", kwlist
,
720 if (perf_evlist__mmap(evlist
, pages
, overwrite
) < 0) {
721 PyErr_SetFromErrno(PyExc_OSError
);
729 static PyObject
*pyrf_evlist__poll(struct pyrf_evlist
*pevlist
,
730 PyObject
*args
, PyObject
*kwargs
)
732 struct perf_evlist
*evlist
= &pevlist
->evlist
;
733 static char *kwlist
[] = { "timeout", NULL
};
736 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "|i", kwlist
, &timeout
))
739 n
= perf_evlist__poll(evlist
, timeout
);
741 PyErr_SetFromErrno(PyExc_OSError
);
745 return Py_BuildValue("i", n
);
748 static PyObject
*pyrf_evlist__get_pollfd(struct pyrf_evlist
*pevlist
,
749 PyObject
*args __maybe_unused
,
750 PyObject
*kwargs __maybe_unused
)
752 struct perf_evlist
*evlist
= &pevlist
->evlist
;
753 PyObject
*list
= PyList_New(0);
756 for (i
= 0; i
< evlist
->pollfd
.nr
; ++i
) {
758 FILE *fp
= fdopen(evlist
->pollfd
.entries
[i
].fd
, "r");
763 file
= PyFile_FromFile(fp
, "perf", "r", NULL
);
767 if (PyList_Append(list
, file
) != 0) {
777 return PyErr_NoMemory();
781 static PyObject
*pyrf_evlist__add(struct pyrf_evlist
*pevlist
,
783 PyObject
*kwargs __maybe_unused
)
785 struct perf_evlist
*evlist
= &pevlist
->evlist
;
787 struct perf_evsel
*evsel
;
789 if (!PyArg_ParseTuple(args
, "O", &pevsel
))
793 evsel
= &((struct pyrf_evsel
*)pevsel
)->evsel
;
794 evsel
->idx
= evlist
->nr_entries
;
795 perf_evlist__add(evlist
, evsel
);
797 return Py_BuildValue("i", evlist
->nr_entries
);
800 static PyObject
*pyrf_evlist__read_on_cpu(struct pyrf_evlist
*pevlist
,
801 PyObject
*args
, PyObject
*kwargs
)
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
};
809 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "i|i", kwlist
,
810 &cpu
, &sample_id_all
))
813 event
= perf_evlist__mmap_read(evlist
, cpu
);
815 PyObject
*pyevent
= pyrf_event__new(event
);
816 struct pyrf_event
*pevent
= (struct pyrf_event
*)pyevent
;
818 perf_evlist__mmap_consume(evlist
, cpu
);
821 return PyErr_NoMemory();
823 err
= perf_evlist__parse_sample(evlist
, event
, &pevent
->sample
);
825 return PyErr_Format(PyExc_OSError
,
826 "perf: can't parse sample, err=%d", err
);
834 static PyObject
*pyrf_evlist__open(struct pyrf_evlist
*pevlist
,
835 PyObject
*args
, PyObject
*kwargs
)
837 struct perf_evlist
*evlist
= &pevlist
->evlist
;
839 static char *kwlist
[] = { "group", NULL
};
841 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "|OOii", kwlist
, &group
))
845 perf_evlist__set_leader(evlist
);
847 if (perf_evlist__open(evlist
) < 0) {
848 PyErr_SetFromErrno(PyExc_OSError
);
856 static PyMethodDef pyrf_evlist__methods
[] = {
859 .ml_meth
= (PyCFunction
)pyrf_evlist__mmap
,
860 .ml_flags
= METH_VARARGS
| METH_KEYWORDS
,
861 .ml_doc
= PyDoc_STR("mmap the file descriptor table.")
865 .ml_meth
= (PyCFunction
)pyrf_evlist__open
,
866 .ml_flags
= METH_VARARGS
| METH_KEYWORDS
,
867 .ml_doc
= PyDoc_STR("open the file descriptors.")
871 .ml_meth
= (PyCFunction
)pyrf_evlist__poll
,
872 .ml_flags
= METH_VARARGS
| METH_KEYWORDS
,
873 .ml_doc
= PyDoc_STR("poll the file descriptor table.")
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.")
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.")
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.")
896 static Py_ssize_t
pyrf_evlist__length(PyObject
*obj
)
898 struct pyrf_evlist
*pevlist
= (void *)obj
;
900 return pevlist
->evlist
.nr_entries
;
903 static PyObject
*pyrf_evlist__item(PyObject
*obj
, Py_ssize_t i
)
905 struct pyrf_evlist
*pevlist
= (void *)obj
;
906 struct perf_evsel
*pos
;
908 if (i
>= pevlist
->evlist
.nr_entries
)
911 evlist__for_each(&pevlist
->evlist
, pos
) {
916 return Py_BuildValue("O", container_of(pos
, struct pyrf_evsel
, evsel
));
919 static PySequenceMethods pyrf_evlist__sequence_methods
= {
920 .sq_length
= pyrf_evlist__length
,
921 .sq_item
= pyrf_evlist__item
,
924 static char pyrf_evlist__doc
[] = PyDoc_STR("perf event selector list object.");
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
,
938 static int pyrf_evlist__setup_types(void)
940 pyrf_evlist__type
.tp_new
= PyType_GenericNew
;
941 return PyType_Ready(&pyrf_evlist__type
);
944 #define PERF_CONST(name) { #name, PERF_##name }
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
),
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
),
976 PERF_CONST(COUNT_HW_STALLED_CYCLES_FRONTEND
),
977 PERF_CONST(COUNT_HW_STALLED_CYCLES_BACKEND
),
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
),
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
),
1002 PERF_CONST(FORMAT_TOTAL_TIME_ENABLED
),
1003 PERF_CONST(FORMAT_TOTAL_TIME_RUNNING
),
1004 PERF_CONST(FORMAT_ID
),
1005 PERF_CONST(FORMAT_GROUP
),
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
),
1025 static PyMethodDef perf__methods
[] = {
1026 { .ml_name
= NULL
, }
1029 PyMODINIT_FUNC
initperf(void)
1033 PyObject
*dict
, *module
= Py_InitModule("perf", perf__methods
);
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)
1043 /* The page_size is placed in util object. */
1044 page_size
= sysconf(_SC_PAGE_SIZE
);
1046 Py_INCREF(&pyrf_evlist__type
);
1047 PyModule_AddObject(module
, "evlist", (PyObject
*)&pyrf_evlist__type
);
1049 Py_INCREF(&pyrf_evsel__type
);
1050 PyModule_AddObject(module
, "evsel", (PyObject
*)&pyrf_evsel__type
);
1052 Py_INCREF(&pyrf_thread_map__type
);
1053 PyModule_AddObject(module
, "thread_map", (PyObject
*)&pyrf_thread_map__type
);
1055 Py_INCREF(&pyrf_cpu_map__type
);
1056 PyModule_AddObject(module
, "cpu_map", (PyObject
*)&pyrf_cpu_map__type
);
1058 dict
= PyModule_GetDict(module
);
1062 for (i
= 0; perf__constants
[i
].name
!= NULL
; i
++) {
1063 obj
= PyInt_FromLong(perf__constants
[i
].value
);
1066 PyDict_SetItemString(dict
, perf__constants
[i
].name
, obj
);
1071 if (PyErr_Occurred())
1072 PyErr_SetString(PyExc_ImportError
, "perf: Init failed!");
1076 * Dummy, to avoid dragging all the test_attr infrastructure in the python
1079 void test_attr__open(struct perf_event_attr
*attr
, pid_t pid
, int cpu
,
1080 int fd
, int group_fd
, unsigned long flags
)