extras/bindings/swig/python/lttng.i.in

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