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