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