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