Fix warning when building Python bindings
[lttng-tools.git] / extras / bindings / swig / python / lttng.i.in
1 %define DOCSTRING
2 "LTTNG_VERSION_STR
3
4 The LTTng project aims at providing highly efficient tracing tools for Linux.
5 It's tracers help tracking down performance issues and debugging problems involving
6 multiple concurrent processes and threads. Tracing across multiple systems is also possible."
7 %enddef
8
9 %module(docstring=DOCSTRING) lttng
10
11 %include "typemaps.i"
12 %include "stdint.i"
13 %include "pyabc.i"
14 %{
15 #define SWIG_FILE_WITH_INIT
16 #include <lttng/lttng.h>
17 %}
18
19 %{
20 #if PY_MAJOR_VERSION >= 3
21 // The PyInt and PyLong types were unified as of Python 3
22 // This makes the typemap code useable with both Python 2 and 3.
23 #define PyInt_AsSsize_t PyLong_AsSsize_t
24 #endif
25 %}
26
27 typedef unsigned int uint32_t;
28 typedef int int32_t;
29 typedef unsigned long long uint64_t;
30 typedef long pid_t;
31
32
33 // =============================================
34 // ENUMS
35 // These are directly taken from lttng.h.
36 // Any change to these enums must also be
37 // made here.
38 // =============================================
39
40 %rename("DOMAIN_KERNEL") LTTNG_DOMAIN_KERNEL;
41 %rename("DOMAIN_UST") LTTNG_DOMAIN_UST;
42 enum lttng_domain_type {
43 LTTNG_DOMAIN_KERNEL = 1,
44 LTTNG_DOMAIN_UST = 2,
45 };
46
47 %rename("EVENT_ALL") LTTNG_EVENT_ALL;
48 %rename("EVENT_TRACEPOINT") LTTNG_EVENT_TRACEPOINT;
49 %rename("EVENT_PROBE") LTTNG_EVENT_PROBE;
50 %rename("EVENT_FUNCTION")LTTNG_EVENT_FUNCTION;
51 %rename("EVENT_FUNCTION_ENTRY") LTTNG_EVENT_FUNCTION_ENTRY;
52 %rename("EVENT_NOOP") LTTNG_EVENT_NOOP;
53 %rename("EVENT_SYSCALL") LTTNG_EVENT_SYSCALL;
54 enum lttng_event_type {
55 LTTNG_EVENT_ALL = -1,
56 LTTNG_EVENT_TRACEPOINT = 0,
57 LTTNG_EVENT_PROBE = 1,
58 LTTNG_EVENT_FUNCTION = 2,
59 LTTNG_EVENT_FUNCTION_ENTRY = 3,
60 LTTNG_EVENT_NOOP = 4,
61 LTTNG_EVENT_SYSCALL = 5,
62 };
63
64 %rename("EVENT_LOGLEVEL_ALL") LTTNG_EVENT_LOGLEVEL_ALL;
65 %rename("EVENT_LOGLEVEL_RANGE") LTTNG_EVENT_LOGLEVEL_RANGE;
66 %rename("EVENT_LOGLEVEL_SINGLE") LTTNG_EVENT_LOGLEVEL_SINGLE;
67 enum lttng_loglevel_type {
68 LTTNG_EVENT_LOGLEVEL_ALL = 0,
69 LTTNG_EVENT_LOGLEVEL_RANGE = 1,
70 LTTNG_EVENT_LOGLEVEL_SINGLE = 2,
71 };
72
73 %rename("LOGLEVEL_EMERG") LTTNG_LOGLEVEL_EMERG;
74 %rename("LOGLEVEL_ALERT") LTTNG_LOGLEVEL_ALERT;
75 %rename("LOGLEVEL_CRIT") LTTNG_LOGLEVEL_CRIT;
76 %rename("LOGLEVEL_ERR") LTTNG_LOGLEVEL_ERR;
77 %rename("LOGLEVEL_WARNING") LTTNG_LOGLEVEL_WARNING;
78 %rename("LOGLEVEL_NOTICE") LTTNG_LOGLEVEL_NOTICE;
79 %rename("LOGLEVEL_INFO") LTTNG_LOGLEVEL_INFO;
80 %rename("LOGLEVEL_DEBUG_SYSTEM") LTTNG_LOGLEVEL_DEBUG_SYSTEM;
81 %rename("LOGLEVEL_DEBUG_PROGRAM") LTTNG_LOGLEVEL_DEBUG_PROGRAM;
82 %rename("LOGLEVEL_DEBUG_PROCESS") LTTNG_LOGLEVEL_DEBUG_PROCESS;
83 %rename("LOGLEVEL_DEBUG_MODULE") LTTNG_LOGLEVEL_DEBUG_MODULE;
84 %rename("LOGLEVEL_DEBUG_UNIT") LTTNG_LOGLEVEL_DEBUG_UNIT;
85 %rename("LOGLEVEL_DEBUG_FUNCTION") LTTNG_LOGLEVEL_DEBUG_FUNCTION;
86 %rename("LOGLEVEL_DEBUG_LINE") LTTNG_LOGLEVEL_DEBUG_LINE;
87 %rename("LOGLEVEL_DEBUG") LTTNG_LOGLEVEL_DEBUG;
88 enum lttng_loglevel {
89 LTTNG_LOGLEVEL_EMERG = 0,
90 LTTNG_LOGLEVEL_ALERT = 1,
91 LTTNG_LOGLEVEL_CRIT = 2,
92 LTTNG_LOGLEVEL_ERR = 3,
93 LTTNG_LOGLEVEL_WARNING = 4,
94 LTTNG_LOGLEVEL_NOTICE = 5,
95 LTTNG_LOGLEVEL_INFO = 6,
96 LTTNG_LOGLEVEL_DEBUG_SYSTEM = 7,
97 LTTNG_LOGLEVEL_DEBUG_PROGRAM = 8,
98 LTTNG_LOGLEVEL_DEBUG_PROCESS = 9,
99 LTTNG_LOGLEVEL_DEBUG_MODULE = 10,
100 LTTNG_LOGLEVEL_DEBUG_UNIT = 11,
101 LTTNG_LOGLEVEL_DEBUG_FUNCTION = 12,
102 LTTNG_LOGLEVEL_DEBUG_LINE = 13,
103 LTTNG_LOGLEVEL_DEBUG = 14,
104 };
105
106 %rename("EVENT_SPLICE") LTTNG_EVENT_SPLICE;
107 %rename("EVENT_MMAP") LTTNG_EVENT_MMAP;
108 enum lttng_event_output {
109 LTTNG_EVENT_SPLICE = 0,
110 LTTNG_EVENT_MMAP = 1,
111 };
112
113 %rename("EVENT_CONTEXT_PID") LTTNG_EVENT_CONTEXT_PID;
114 %rename("EVENT_CONTEXT_PERF_COUNTER") LTTNG_EVENT_CONTEXT_PERF_COUNTER;
115 %rename("EVENT_CONTEXT_PROCNAME") LTTNG_EVENT_CONTEXT_PROCNAME;
116 %rename("EVENT_CONTEXT_PRIO") LTTNG_EVENT_CONTEXT_PRIO;
117 %rename("EVENT_CONTEXT_NICE") LTTNG_EVENT_CONTEXT_NICE;
118 %rename("EVENT_CONTEXT_VPID") LTTNG_EVENT_CONTEXT_VPID;
119 %rename("EVENT_CONTEXT_TID") LTTNG_EVENT_CONTEXT_TID;
120 %rename("EVENT_CONTEXT_VTID") LTTNG_EVENT_CONTEXT_VTID;
121 %rename("EVENT_CONTEXT_PPID") LTTNG_EVENT_CONTEXT_PPID;
122 %rename("EVENT_CONTEXT_VPPID") LTTNG_EVENT_CONTEXT_VPPID;
123 %rename("EVENT_CONTEXT_PTHREAD_ID") LTTNG_EVENT_CONTEXT_PTHREAD_ID;
124 enum lttng_event_context_type {
125 LTTNG_EVENT_CONTEXT_PID = 0,
126 LTTNG_EVENT_CONTEXT_PERF_COUNTER = 1,
127 LTTNG_EVENT_CONTEXT_PROCNAME = 2,
128 LTTNG_EVENT_CONTEXT_PRIO = 3,
129 LTTNG_EVENT_CONTEXT_NICE = 4,
130 LTTNG_EVENT_CONTEXT_VPID = 5,
131 LTTNG_EVENT_CONTEXT_TID = 6,
132 LTTNG_EVENT_CONTEXT_VTID = 7,
133 LTTNG_EVENT_CONTEXT_PPID = 8,
134 LTTNG_EVENT_CONTEXT_VPPID = 9,
135 LTTNG_EVENT_CONTEXT_PTHREAD_ID = 10,
136 };
137
138 %rename("CALIBRATE_FUNCTION") LTTNG_CALIBRATE_FUNCTION;
139 enum lttng_calibrate_type {
140 LTTNG_CALIBRATE_FUNCTION = 0,
141 };
142
143
144
145 // =============================================
146 // TYPEMAPS
147 // =============================================
148
149 //list_sessions
150 %typemap(argout) struct lttng_session **sessions{
151
152 int l = PyInt_AsSsize_t($result);
153 if (l >= 0)
154 {
155 PyObject *sessions = PyList_New(0);
156 int i;
157 for(i=0; i<l; i++)
158 {
159 PyObject *tmp = PyTuple_New(4);
160 PyObject *name = PyString_FromString((*$1)[i].name);
161 PyObject *path = PyString_FromString((*$1)[i].path);
162 PyObject *enabled = PyInt_FromSize_t((*$1)[i].enabled);
163 PyObject *padding = PyString_FromString((*$1)[i].padding);
164
165 PyTuple_SetItem(tmp, 0, name);
166 PyTuple_SetItem(tmp, 1, path);
167 PyTuple_SetItem(tmp, 2, enabled);
168 PyTuple_SetItem(tmp, 3, padding);
169 PyList_Append(sessions, tmp);
170 }
171 $result = sessions;
172 }
173 }
174 %typemap(in,numinputs=0) struct lttng_session **sessions (struct lttng_session *temp){
175 $1=&temp;
176 }
177
178 //list_domains
179 %typemap(argout) struct lttng_domain **domains{
180
181 int l = PyInt_AsSsize_t($result);
182 if (l >= 0)
183 {
184 PyObject *dom = PyList_New(0);
185 int i;
186 for(i=0; i<l; i++)
187 {
188 PyObject *tmp = PyTuple_New(5);
189 PyObject *type = PyInt_FromSize_t((*$1)[i].type);
190 PyObject *execname = PyString_FromString((*$1)[i].attr.exec_name);
191 PyObject *pid = PyInt_FromSize_t((*$1)[i].attr.pid);
192 PyObject *padding = PyString_FromString((*$1)[i].padding);
193 PyObject *attrpadding = PyString_FromString((*$1)[i].attr.padding);
194
195 PyTuple_SetItem(tmp, 0, type);
196 PyTuple_SetItem(tmp, 1, padding);
197 PyTuple_SetItem(tmp, 2, pid);
198 PyTuple_SetItem(tmp, 3, execname);
199 PyTuple_SetItem(tmp, 4, attrpadding);
200 PyList_Append(dom, tmp);
201 }
202 $result = dom;
203 }
204 }
205 %typemap(in,numinputs=0) struct lttng_domain **domains (struct lttng_domain *temp){
206 $1=&temp;
207 }
208
209 //list_channels
210 %typemap(argout) struct lttng_channel **channels{
211
212 int l = PyInt_AsSsize_t($result);
213 if (l >= 0)
214 {
215 PyObject *chan = PyList_New(0);
216 int i;
217 for(i=0; i<l; i++)
218 {
219 PyObject *tmp = PyTuple_New(4);
220 PyObject *name = PyString_FromString((*$1)[i].name);
221 PyObject *enabled = PyInt_FromSize_t((*$1)[i].enabled);
222 PyObject *padding = PyString_FromString((*$1)[i].padding);
223
224 PyObject *attrtmp = PyTuple_New(7);
225 PyObject *overwrite = PyInt_FromLong((*$1)[i].attr.overwrite);
226 PyObject *subbuf = PyInt_FromSize_t((*$1)[i].attr.subbuf_size);
227 PyObject *num = PyInt_FromSize_t((*$1)[i].attr.num_subbuf);
228 PyObject *switchtimer = PyInt_FromSize_t((*$1)[i].attr.switch_timer_interval);
229 PyObject *readtimer = PyInt_FromSize_t((*$1)[i].attr.read_timer_interval);
230 PyObject *output = PyInt_FromSize_t((*$1)[i].attr.output);
231 PyObject *attrpad = PyString_FromString((*$1)[i].attr.padding);
232
233 PyTuple_SetItem(attrtmp, 0, overwrite);
234 PyTuple_SetItem(attrtmp, 1, subbuf);
235 PyTuple_SetItem(attrtmp, 2, num);
236 PyTuple_SetItem(attrtmp, 3, switchtimer);
237 PyTuple_SetItem(attrtmp, 4, readtimer);
238 PyTuple_SetItem(attrtmp, 5, output);
239 PyTuple_SetItem(attrtmp, 6, attrpad);
240
241 PyTuple_SetItem(tmp, 0, name);
242 PyTuple_SetItem(tmp, 1, enabled);
243 PyTuple_SetItem(tmp, 2, padding);
244 PyTuple_SetItem(tmp, 3, attrtmp);
245 PyList_Append(chan, tmp);
246 }
247 $result = chan;
248 }
249 }
250 %typemap(in,numinputs=0) struct lttng_channel **channels (struct lttng_channel *temp){
251 $1=&temp;
252 }
253
254 //list_events & list_tracepoints
255 %typemap(argout) struct lttng_event **events{
256
257 int l = PyInt_AsSsize_t($result);
258 if (l >= 0)
259 {
260 PyObject *events = PyList_New(0);
261 int i;
262 for(i=0; i<l; i++)
263 {
264 PyObject *tmp = PyTuple_New(10);
265 PyObject *name = PyString_FromString((*$1)[i].name);
266 PyObject *type = PyInt_FromSize_t((*$1)[i].type);
267 PyObject *logleveltype = PyInt_FromSize_t((*$1)[i].loglevel_type);
268 PyObject *loglevel = PyInt_FromLong((*$1)[i].loglevel);
269 PyObject *enabled = PyInt_FromLong((*$1)[i].enabled);
270 PyObject *pid = PyInt_FromSize_t((*$1)[i].pid);
271 PyObject *padding = PyString_FromString((*$1)[i].padding);
272 PyObject *attrpadding = PyString_FromString((*$1)[i].attr.padding);
273
274 PyObject *probe = PyTuple_New(4);
275 PyObject *addr = PyInt_FromSize_t((*$1)[i].attr.probe.addr);
276 PyObject *offset = PyInt_FromSize_t((*$1)[i].attr.probe.offset);
277 PyObject *symbolname = PyString_FromString((*$1)[i].attr.probe.symbol_name);
278 PyObject *probepad = PyString_FromString((*$1)[i].attr.probe.padding);
279
280 PyObject *function = PyTuple_New(2);
281 PyObject *f_symbolname = PyString_FromString((*$1)[i].attr.ftrace.symbol_name);
282 PyObject *f_pad = PyString_FromString((*$1)[i].attr.ftrace.padding);
283
284 PyTuple_SetItem(function, 0, f_symbolname);
285 PyTuple_SetItem(function, 1, f_pad);
286
287 PyTuple_SetItem(probe, 0, addr);
288 PyTuple_SetItem(probe, 1, offset);
289 PyTuple_SetItem(probe, 2, symbolname);
290 PyTuple_SetItem(probe, 3, probepad);
291
292 PyTuple_SetItem(tmp, 0, name);
293 PyTuple_SetItem(tmp, 1, type);
294 PyTuple_SetItem(tmp, 2, logleveltype);
295 PyTuple_SetItem(tmp, 3, loglevel);
296 PyTuple_SetItem(tmp, 4, enabled);
297 PyTuple_SetItem(tmp, 5, pid);
298 PyTuple_SetItem(tmp, 6, padding);
299 PyTuple_SetItem(tmp, 7, probe);
300 PyTuple_SetItem(tmp, 8, function);
301 PyTuple_SetItem(tmp, 9, attrpadding);
302 PyList_Append(events, tmp);
303 }
304 $result = events;
305 }
306 }
307 %typemap(in,numinputs=0) struct lttng_event **events (struct lttng_event *temp){
308 $1=&temp;
309 }
310
311
312
313 // =============================================
314 // FUNCTIONS
315 // =============================================
316
317 %rename("create") lttng_create_session(const char *name, const char *path);
318 %rename("create_snapshot") lttng_create_session_snapshot(const char *name, const char *snapshot_url);
319 %rename("destroy") lttng_destroy_session(const char *name);
320 %rename("_lttng_create_handle") lttng_create_handle(const char *session_name, struct lttng_domain *domain);
321 %rename("_lttng_destroy_handle") lttng_destroy_handle(struct lttng_handle *handle);
322 %rename("_lttng_list_sessions") lttng_list_sessions(struct lttng_session **sessions);
323 %rename("_lttng_list_domains") lttng_list_domains(const char *session_name, struct lttng_domain **domains);
324 %rename("_lttng_list_channels") lttng_list_channels(struct lttng_handle *handle,struct lttng_channel **channels);
325 %rename("_lttng_list_events") lttng_list_events(struct lttng_handle *handle, const char *channel_name, struct lttng_event **events);
326 %rename("_lttng_list_tracepoints") lttng_list_tracepoints(struct lttng_handle *handle, struct lttng_event **events);
327 %rename("session_daemon_alive") lttng_session_daemon_alive(void);
328 %rename("set_tracing_group") lttng_set_tracing_group(const char *name);
329 %rename("strerror") lttng_strerror(int code);
330 %rename("_lttng_register_consumer") lttng_register_consumer(struct lttng_handle *handle, const char *socket_path);
331 %rename("start") lttng_start_tracing(const char *session_name);
332 %rename("stop") lttng_stop_tracing(const char *session_name);
333 %rename("_lttng_add_context") lttng_add_context(struct lttng_handle *handle, struct lttng_event_context *ctx, const char *event_name, const char *channel_name);
334 %rename("_lttng_enable_event") lttng_enable_event(struct lttng_handle *handle, struct lttng_event *ev, const char *channel_name);
335 %rename("_lttng_enable_channel") lttng_enable_channel(struct lttng_handle *handle, struct lttng_channel *chan);
336 %rename("_lttng_disable_event") lttng_disable_event(struct lttng_handle *handle, const char *name, const char *channel_name);
337 %rename("_lttng_disable_channel") lttng_disable_channel(struct lttng_handle *handle, const char *name);
338 %rename("_lttng_calibrate") lttng_calibrate(struct lttng_handle *handle, struct lttng_calibrate *calibrate);
339 %rename("channel_set_default_attr") lttng_channel_set_default_attr(struct lttng_domain *domain, struct lttng_channel_attr *attr);
340
341 //Redefined functions
342 struct lttng_handle *lttng_create_handle(const char *session_name,
343 struct lttng_domain *domain);
344 void lttng_destroy_handle(struct lttng_handle *handle);
345 int lttng_list_channels(struct lttng_handle *handle,struct lttng_channel **channels);
346 int lttng_list_events(struct lttng_handle *handle,
347 const char *channel_name, struct lttng_event **events);
348 int lttng_list_tracepoints(struct lttng_handle *handle, struct lttng_event **events);
349 int lttng_add_context(struct lttng_handle *handle, struct lttng_event_context *ctx,
350 const char *event_name, const char *channel_name);
351 int lttng_enable_event(struct lttng_handle *handle,
352 struct lttng_event *ev, const char *channel_name);
353 int lttng_enable_channel(struct lttng_handle *handle, struct lttng_channel *chan);
354 int lttng_disable_event(struct lttng_handle *handle,
355 const char *name, const char *channel_name);
356 int lttng_disable_channel(struct lttng_handle *handle, const char *name);
357 int lttng_calibrate(struct lttng_handle *handle, struct lttng_calibrate *calibrate);
358 int lttng_register_consumer(struct lttng_handle *handle, const char *socket_path);
359 int lttng_list_sessions(struct lttng_session **sessions);
360 int lttng_list_domains(const char *session_name, struct lttng_domain **domains);
361
362 //Functions not needing redefinition
363 %feature("docstring")"create(str name, str path) -> int
364
365 Create a new tracing session using name and path.
366 Returns 0 on success or a negative error code."
367 int lttng_create_session(const char *name, const char *path);
368
369 %feature("docstring")"create_snapshot(str name, str snapshot_url) -> int
370
371 Create a new tracing session using name and snapshot_url in snapshot
372 mode (flight recorder).
373 Returns 0 on success or a negative error code."
374 int lttng_create_session_snapshot(const char *name, const char *path);
375
376 %feature("docstring")"destroy(str name) -> int
377
378 Tear down tracing session using name.
379 Returns 0 on success or a negative error code."
380 int lttng_destroy_session(const char *name);
381
382
383 %feature("docstring")"session_daemon_alive() -> int
384
385 Check if session daemon is alive.
386 Return 1 if alive or 0 if not.
387 On error returns a negative value."
388 int lttng_session_daemon_alive(void);
389
390
391 %feature("docstring")"set_tracing_group(str name) -> int
392
393 Sets the tracing_group variable with name.
394 This function allocates memory pointed to by tracing_group.
395 On success, returns 0, on error, returns -1 (null name) or -ENOMEM."
396 int lttng_set_tracing_group(const char *name);
397
398
399 %feature("docstring")"strerror(int code) -> char
400
401 Returns a human readable string describing
402 the error code (a negative value)."
403 const char *lttng_strerror(int code);
404
405
406 %feature("docstring")"start(str session_name) -> int
407
408 Start tracing for all traces of the session.
409 Returns size of returned session payload data or a negative error code."
410 int lttng_start_tracing(const char *session_name);
411
412
413 %feature("docstring")"stop(str session_name) -> int
414
415 Stop tracing for all traces of the session.
416 Returns size of returned session payload data or a negative error code."
417 int lttng_stop_tracing(const char *session_name);
418
419
420 %feature("docstring")"channel_set_default_attr(Domain domain, ChannelAttr attr)
421
422 Set default channel attributes.
423 If either or both of the arguments are null, attr content is zeroe'd."
424 void lttng_channel_set_default_attr(struct lttng_domain *domain, struct lttng_channel_attr *attr);
425
426
427 // =============================================
428 // Python redefinition of some functions
429 // (List and Handle-related)
430 // =============================================
431
432 %feature("docstring")""
433 %pythoncode %{
434
435 def list_sessions():
436 """
437 list_sessions() -> dict
438
439 Ask the session daemon for all available sessions.
440 Returns a dict of Session instances, the key is the name;
441 on error, returns a negative value.
442 """
443
444 ses_list = _lttng_list_sessions()
445 if type(ses_list) is int:
446 return ses_list
447
448 sessions = {}
449
450 for ses_elements in ses_list:
451 ses = Session()
452 ses.name = ses_elements[0]
453 ses.path = ses_elements[1]
454 ses.enabled = ses_elements[2]
455 ses.padding = ses_elements[3]
456
457 sessions[ses.name] = ses
458
459 return sessions
460
461
462 def list_domains(session_name):
463 """
464 list_domains(str session_name) -> list
465
466 Ask the session daemon for all available domains of a session.
467 Returns a list of Domain instances;
468 on error, returns a negative value.
469 """
470
471 dom_list = _lttng_list_domains(session_name)
472 if type(dom_list) is int:
473 return dom_list
474
475 domains = []
476
477 for dom_elements in dom_list:
478 dom = Domain()
479 dom.type = dom_elements[0]
480 dom.paddinf = dom_elements[1]
481 dom.attr.pid = dom_elements[2]
482 dom.attr.exec_name = dom_elements[3]
483 dom.attr.padding = dom_elements[4]
484
485 domains.append(dom)
486
487 return domains
488
489
490 def list_channels(handle):
491 """
492 list_channels(Handle handle) -> dict
493
494 Ask the session daemon for all available channels of a session.
495 Returns a dict of Channel instances, the key is the name;
496 on error, returns a negative value.
497 """
498
499 try:
500 chan_list = _lttng_list_channels(handle._h)
501 except AttributeError:
502 raise TypeError("in method 'list_channels', argument 1 must be a Handle instance")
503
504 if type(chan_list) is int:
505 return chan_list
506
507 channels = {}
508
509 for channel_elements in chan_list:
510 chan = Channel()
511 chan.name = channel_elements[0]
512 chan.enabled = channel_elements[1]
513 chan.padding = channel_elements[2]
514 chan.attr.overwrite = channel_elements[3][0]
515 chan.attr.subbuf_size = channel_elements[3][1]
516 chan.attr.num_subbuf = channel_elements[3][2]
517 chan.attr.switch_timer_interval = channel_elements[3][3]
518 chan.attr.read_timer_interval = channel_elements[3][4]
519 chan.attr.output = channel_elements[3][5]
520 chan.attr.padding = channel_elements[3][6]
521
522 channels[chan.name] = chan
523
524 return channels
525
526
527 def list_events(handle, channel_name):
528 """
529 list_events(Handle handle, str channel_name) -> dict
530
531 Ask the session daemon for all available events of a session channel.
532 Returns a dict of Event instances, the key is the name;
533 on error, returns a negative value.
534 """
535
536 try:
537 ev_list = _lttng_list_events(handle._h, channel_name)
538 except AttributeError:
539 raise TypeError("in method 'list_events', argument 1 must be a Handle instance")
540
541 if type(ev_list) is int:
542 return ev_list
543
544 events = {}
545
546 for ev_elements in ev_list:
547 ev = Event()
548 ev.name = ev_elements[0]
549 ev.type = ev_elements[1]
550 ev.loglevel_type = ev_elements[2]
551 ev.loglevel = ev_elements[3]
552 ev.enabled = ev_elements[4]
553 ev.pid = ev_elements[5]
554 ev.attr.padding = ev_elements[6]
555 ev.attr.probe.addr = ev_elements[7][0]
556 ev.attr.probe.offset = ev_elements[7][1]
557 ev.attr.probe.symbol_name = ev_elements[7][2]
558 ev.attr.probe.padding = ev_elements[7][3]
559 ev.attr.ftrace.symbol_name = ev_elements[8][0]
560 ev.attr.ftrace.padding = ev_elements[8][1]
561 ev.attr.padding = ev_elements[9]
562
563 events[ev.name] = ev
564
565 return events
566
567
568 def list_tracepoints(handle):
569 """
570 list_tracepoints(Handle handle) -> dict
571
572 Returns a dict of Event instances, the key is the name;
573 on error, returns a negative value.
574 """
575
576 try:
577 ev_list = _lttng_list_tracepoints(handle._h)
578 except AttributeError:
579 raise TypeError("in method 'list_tracepoints', argument 1 must be a Handle instance")
580
581 if type(ev_list) is int:
582 return ev_list
583
584 events = {}
585
586 for ev_elements in ev_list:
587 ev = Event()
588 ev.name = ev_elements[0]
589 ev.type = ev_elements[1]
590 ev.loglevel_type = ev_elements[2]
591 ev.loglevel = ev_elements[3]
592 ev.enabled = ev_elements[4]
593 ev.pid = ev_elements[5]
594 ev.attr.padding = ev_elements[6]
595 ev.attr.probe.addr = ev_elements[7][0]
596 ev.attr.probe.offset = ev_elements[7][1]
597 ev.attr.probe.symbol_name = ev_elements[7][2]
598 ev.attr.probe.padding = ev_elements[7][3]
599 ev.attr.ftrace.symbol_name = ev_elements[8][0]
600 ev.attr.ftrace.padding = ev_elements[8][1]
601 ev.attr.padding = ev_elements[9]
602
603 events[ev.name] = ev
604
605 return events
606
607
608 def register_consumer(handle, socket_path):
609 """
610 register_consumer(Handle handle, str socket_path) -> int
611
612 Register an outside consumer.
613 Returns size of returned session payload data or a negative error code.
614 """
615
616 try:
617 return _lttng_register_consumer(handle._h, socket_path)
618 except AttributeError:
619 raise TypeError("in method 'register_consumer', argument 1 must be a Handle instance")
620
621
622 def add_context(handle, event_context, event_name, channel_name):
623 """
624 add_context(Handle handle, EventContext ctx,
625 str event_name, str channel_name) -> int
626
627 Add context to event and/or channel.
628 If event_name is None, the context is applied to all events of the channel.
629 If channel_name is None, a lookup of the event's channel is done.
630 If both are None, the context is applied to all events of all channels.
631 Returns the size of the returned payload data or a negative error code.
632 """
633
634 try:
635 return _lttng_add_context(handle._h, event_context, event_name, channel_name)
636 except AttributeError:
637 raise TypeError("in method 'add_context', argument 1 must be a Handle instance")
638
639
640 def enable_event(handle, event, channel_name):
641 """
642 enable_event(Handle handle, Event event,
643 str channel_name) -> int
644
645 Enable event(s) for a channel.
646 If no event name is specified, all events are enabled.
647 If no channel name is specified, the default 'channel0' is used.
648 Returns size of returned session payload data or a negative error code.
649 """
650
651 try:
652 return _lttng_enable_event(handle._h, event, channel_name)
653 except AttributeError:
654 raise TypeError("in method 'enable_event', argument 1 must be a Handle instance")
655
656
657 def enable_channel(handle, channel):
658 """
659 enable_channel(Handle handle, Channel channel -> int
660
661 Enable channel per domain
662 Returns size of returned session payload data or a negative error code.
663 """
664
665 try:
666 return _lttng_enable_channel(handle._h, channel)
667 except AttributeError:
668 raise TypeError("in method 'enable_channel', argument 1 must be a Handle instance")
669
670
671 def disable_event(handle, name, channel_name):
672 """
673 disable_event(Handle handle, str name, str channel_name) -> int
674
675 Disable event(s) of a channel and domain.
676 If no event name is specified, all events are disabled.
677 If no channel name is specified, the default 'channel0' is used.
678 Returns size of returned session payload data or a negative error code
679 """
680
681 try:
682 return _lttng_disable_event(handle._h, name, channel_name)
683 except AttributeError:
684 raise TypeError("in method 'disable_event', argument 1 must be a Handle instance")
685
686
687 def disable_channel(handle, name):
688 """
689 disable_channel(Handle handle, str name) -> int
690
691 All tracing will be stopped for registered events of the channel.
692 Returns size of returned session payload data or a negative error code.
693 """
694
695 try:
696 return _lttng_disable_channel(handle._h, name)
697 except AttributeError:
698 raise TypeError("in method 'disable_channel', argument 1 must be a Handle instance")
699
700
701 def calibrate(handle, calibrate):
702 """
703 calibrate(Handle handle, Calibrate calibrate) -> int
704
705 Quantify LTTng overhead.
706 Returns size of returned session payload data or a negative error code.
707 """
708
709 try:
710 return _lttng_calibrate(handle._h, calibrate)
711 except AttributeError:
712 raise TypeError("in method 'calibrate', argument 1 must be a Handle instance")
713 %}
714
715
716 // =============================================
717 // Handle class
718 // Used to prevent freeing unallocated memory
719 // =============================================
720
721 %feature("docstring")""
722 %feature("autodoc", "1");
723
724 %pythoncode %{
725 class Handle:
726 """
727 Manages a handle.
728 Takes two arguments: (str session_name, Domain domain)
729 """
730
731 __frozen = False
732
733 def __init__(self, session_name, domain):
734 if type(session_name) is not str:
735 raise TypeError("in method '__init__', argument 2 of type 'str'")
736 if type(domain) is not Domain and domain is not None:
737 raise TypeError("in method '__init__', argument 3 of type 'lttng.Domain'")
738
739 self._sname = session_name
740 if domain is None:
741 self._domtype = None
742 else:
743 self._domtype = domain.type
744 self._h = _lttng_create_handle(session_name, domain)
745 self.__frozen = True
746
747 def __del__(self):
748 _lttng_destroy_handle(self._h)
749
750 def __repr__(self):
751 if self._domtype == 1:
752 domstr = "DOMAIN_KERNEL"
753 elif self._domtype == 2:
754 domstr = "DOMAIN_UST"
755 else:
756 domstr = self._domtype
757
758 return "lttng.Handle; session('{}'), domain.type({})".format(
759 self._sname, domstr)
760
761 def __setattr__(self, attr, val):
762 if self.__frozen:
763 raise NotImplementedError("cannot modify attributes")
764 else:
765 self.__dict__[attr] = val
766 %}
767
768
769 // =============================================
770 // STRUCTURES
771 // These are directly taken from lttng.h.
772 // Any change to these structures must also be
773 // made here.
774 // =============================================
775
776 %rename("Domain") lttng_domain;
777 %rename("EventContext") lttng_event_context;
778 %rename("Event") lttng_event;
779 %rename("Calibrate") lttng_calibrate;
780 %rename("ChannelAttr") lttng_channel_attr;
781 %rename("Channel") lttng_channel;
782 %rename("Session") lttng_session;
783
784 struct lttng_domain{
785 enum lttng_domain_type type;
786 char padding[LTTNG_DOMAIN_PADDING1];
787
788 union {
789 pid_t pid;
790 char exec_name[NAME_MAX];
791 char padding[LTTNG_DOMAIN_PADDING2];
792 } attr;
793
794 %extend {
795 char *__repr__() {
796 static char temp[256];
797 switch ( $self->type ) {
798 case 1:
799 sprintf(temp, "lttng.Domain; type(DOMAIN_KERNEL)");
800 break;
801 case 2:
802 sprintf(temp, "lttng.Domain; type(DOMAIN_UST)");
803 break;
804 default:
805 sprintf(temp, "lttng.Domain; type(%i)", $self->type);
806 break;
807 }
808 return &temp[0];
809 }
810 }
811 };
812
813 struct lttng_event_context {
814 enum lttng_event_context_type ctx;
815 char padding[LTTNG_EVENT_CONTEXT_PADDING1];
816
817 union {
818 struct lttng_event_perf_counter_ctx perf_counter;
819 char padding[LTTNG_EVENT_CONTEXT_PADDING2];
820 } u;
821
822 %extend {
823 char *__repr__() {
824 static char temp[256];
825 switch ( $self->ctx ) {
826 case 0:
827 sprintf(temp, "lttng.EventContext; ctx(EVENT_CONTEXT_PID)");
828 break;
829 case 1:
830 sprintf(temp, "lttng.EventContext; ctx(EVENT_CONTEXT_PERF_COUNTER)");
831 break;
832 case 2:
833 sprintf(temp, "lttng.EventContext; ctx(EVENT_CONTEXT_PROCNAME)");
834 break;
835 case 3:
836 sprintf(temp, "lttng.EventContext; ctx(EVENT_CONTEXT_PRIO)");
837 break;
838 case 4:
839 sprintf(temp, "lttng.EventContext; ctx(EVENT_CONTEXT_NICE)");
840 break;
841 case 5:
842 sprintf(temp, "lttng.EventContext; ctx(EVENT_CONTEXT_VPID)");
843 break;
844 case 6:
845 sprintf(temp, "lttng.EventContext; ctx(EVENT_CONTEXT_TID)");
846 break;
847 case 7:
848 sprintf(temp, "lttng.EventContext; ctx(EVENT_CONTEXT_VTID)");
849 break;
850 case 8:
851 sprintf(temp, "lttng.EventContext; ctx(EVENT_CONTEXT_PPID)");
852 break;
853 case 9:
854 sprintf(temp, "lttng.EventContext; ctx(EVENT_CONTEXT_VPPID)");
855 break;
856 case 10:
857 sprintf(temp, "lttng.EventContext; ctx(EVENT_CONTEXT_PTHREAD_ID)");
858 break;
859 default:
860 sprintf(temp, "lttng.EventContext; type(%i)", $self->ctx);
861 break;
862 }
863 return &temp[0];
864 }
865 }
866 };
867
868 struct lttng_event_probe_attr {
869 uint64_t addr;
870 uint64_t offset;
871 char symbol_name[LTTNG_SYMBOL_NAME_LEN];
872 char padding[LTTNG_EVENT_PROBE_PADDING1];
873 };
874
875 struct lttng_event_function_attr {
876 char symbol_name[LTTNG_SYMBOL_NAME_LEN];
877 char padding[LTTNG_EVENT_FUNCTION_PADDING1];
878 };
879
880 struct lttng_event {
881 enum lttng_event_type type;
882 char name[LTTNG_SYMBOL_NAME_LEN];
883
884 enum lttng_loglevel_type loglevel_type;
885 int loglevel;
886
887 int32_t enabled;
888 pid_t pid;
889
890 char padding[LTTNG_EVENT_PADDING1];
891
892 union {
893 struct lttng_event_probe_attr probe;
894 struct lttng_event_function_attr ftrace;
895
896 char padding[LTTNG_EVENT_PADDING2];
897 } attr;
898
899 %extend {
900 char *__repr__() {
901 static char temp[512];
902 char evtype[50];
903 char logtype[50];
904
905 switch ( $self->type ) {
906 case -1:
907 sprintf(evtype, "EVENT_ALL");
908 break;
909 case 0:
910 sprintf(evtype, "EVENT_TRACEPOINT");
911 break;
912 case 1:
913 sprintf(evtype, "EVENT_PROBE");
914 break;
915 case 2:
916 sprintf(evtype, "EVENT_FUNCTION");
917 break;
918 case 3:
919 sprintf(evtype, "EVENT_FUNCTION_ENTRY");
920 break;
921 case 4:
922 sprintf(evtype, "EVENT_NOOP");
923 break;
924 case 5:
925 sprintf(evtype, "EVENT_SYSCALL");
926 break;
927 default:
928 sprintf(evtype, "%i", $self->type);
929 break;
930 }
931
932 switch ( $self->loglevel_type ) {
933 case 0:
934 sprintf(logtype, "EVENT_LOGLEVEL_ALL");
935 break;
936 case 1:
937 sprintf(logtype, "EVENT_LOGLEVEL_RANGE");
938 break;
939 case 2:
940 sprintf(logtype, "EVENT_LOGLEVEL_SINGLE");
941 break;
942 default:
943 sprintf(logtype, "%i", $self->loglevel_type);
944 break;
945 }
946
947 sprintf(temp, "lttng.Event; name('%s'), type(%s), "
948 "loglevel_type(%s), loglevel(%i), "
949 "enabled(%s), pid(%i)",
950 $self->name, evtype, logtype, $self->loglevel,
951 $self->enabled ? "True" : "False", $self->pid);
952 return &temp[0];
953 }
954 }
955 };
956
957 struct lttng_calibrate {
958 enum lttng_calibrate_type type;
959 char padding[LTTNG_CALIBRATE_PADDING1];
960
961 %extend {
962 char *__repr__() {
963 static char temp[256];
964 switch ( $self->type ) {
965 case 0:
966 sprintf(temp, "lttng.Calibrate; type(CALIBRATE_FUNCTION)");
967 break;
968 default:
969 sprintf(temp, "lttng.Calibrate; type(%i)", $self->type);
970 break;
971 }
972 return &temp[0];
973 }
974 }
975 };
976
977 struct lttng_channel_attr {
978 int overwrite;
979 uint64_t subbuf_size;
980 uint64_t num_subbuf;
981 unsigned int switch_timer_interval;
982 unsigned int read_timer_interval;
983 enum lttng_event_output output;
984
985 char padding[LTTNG_CHANNEL_ATTR_PADDING1];
986
987 %extend {
988 char *__repr__() {
989 static char temp[256];
990 char evout[25];
991
992 switch ( $self->output ) {
993 case 0:
994 sprintf(evout, "EVENT_SPLICE");
995 break;
996 case 1:
997 sprintf(evout, "EVENT_MMAP");
998 break;
999 default:
1000 sprintf(evout, "%i", $self->output);
1001 break;
1002 }
1003 sprintf(temp, "lttng.ChannelAttr; overwrite(%i), subbuf_size(%"PRIu64"), "
1004 "num_subbuf(%"PRIu64"), switch_timer_interval(%u), "
1005 "read_timer_interval(%u), output(%s)",
1006 $self->overwrite, $self->subbuf_size, $self->num_subbuf,
1007 $self->switch_timer_interval, $self->read_timer_interval,
1008 evout);
1009 return &temp[0];
1010 }
1011 }
1012 };
1013
1014 struct lttng_channel {
1015 char name[LTTNG_SYMBOL_NAME_LEN];
1016 uint32_t enabled;
1017 struct lttng_channel_attr attr;
1018 char padding[LTTNG_CHANNEL_PADDING1];
1019
1020 %extend {
1021 char *__repr__() {
1022 static char temp[512];
1023 sprintf(temp, "lttng.Channel; name('%s'), enabled(%s)",
1024 $self->name, $self->enabled ? "True" : "False");
1025 return &temp[0];
1026 }
1027 }
1028 };
1029
1030 struct lttng_session {
1031 char name[NAME_MAX];
1032 char path[PATH_MAX];
1033 uint32_t enabled;
1034 char padding[LTTNG_SESSION_PADDING1];
1035
1036 %extend {
1037 char *__repr__() {
1038 static char temp[512];
1039 sprintf(temp, "lttng.Session; name('%s'), path('%s'), enabled(%s)",
1040 $self->name, $self->path,
1041 $self->enabled ? "True" : "False");
1042 return &temp[0];
1043 }
1044 }
1045 };
This page took 0.081251 seconds and 4 git commands to generate.