~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/util/python.c

Version: ~ [ linux-5.17-rc1 ] ~ [ linux-5.16.2 ] ~ [ linux-5.15.16 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.93 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.173 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.225 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.262 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.297 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.299 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp