libust/lttng-ust-abi.c

   1 /*
   2  * lttng-ust-abi.c
   3  *
   4  * Copyright 2010-2011 (c) - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   5  *
   6  * LTTng UST ABI
   7  *
   8  * Mimic system calls for:
   9  * - session creation, returns an object descriptor or failure.
  10  *   - channel creation, returns an object descriptor or failure.
  11  *     - Operates on a session object descriptor
  12  *     - Takes all channel options as parameters.
  13  *   - stream get, returns an object descriptor or failure.
  14  *     - Operates on a channel object descriptor.
  15  *   - stream notifier get, returns an object descriptor or failure.
  16  *     - Operates on a channel object descriptor.
  17  *   - event creation, returns an object descriptor or failure.
  18  *     - Operates on a channel object descriptor
  19  *     - Takes an event name as parameter
  20  *     - Takes an instrumentation source as parameter
  21  *       - e.g. tracepoints, dynamic_probes...
  22  *     - Takes instrumentation source specific arguments.
  23  *
  24  * Dual LGPL v2.1/GPL v2 license.
  25  */
  26
  27 #include <ust/lttng-ust-abi.h>
  28 #include <urcu/compiler.h>
  29 #include <urcu/list.h>
  30 #include <ust/lttng-events.h>
  31 #include <ust/usterr-signal-safe.h>
  32 #include "ust/core.h"
  33 #include "ltt-tracer.h"
  34
  35 /*
  36  * Object descriptor table. Should be protected from concurrent access
  37  * by the caller.
  38  */
  39
  40 struct obj {
  41         union {
  42                 struct {
  43                         void *private_data;
  44                         const struct objd_ops *ops;
  45                         int f_count;
  46                 } s;
  47                 int freelist_next;      /* offset freelist. end is -1. */
  48         } u;
  49 };
  50
  51 struct objd_table {
  52         struct obj *array;
  53         unsigned int len, allocated_len;
  54         int freelist_head;              /* offset freelist head. end is -1 */
  55 };
  56
  57 static struct objd_table objd_table = {
  58         .freelist_head = -1,
  59 };
  60
  61 static
  62 int objd_alloc(void *private_data, const struct objd_ops *ops)
  63 {
  64         struct obj *obj;
  65
  66         if (objd_table.freelist_head != -1) {
  67                 obj = &objd_table.array[objd_table.freelist_head];
  68                 objd_table.freelist_head = obj->u.freelist_next;
  69                 goto end;
  70         }
  71
  72         if (objd_table.len >= objd_table.allocated_len) {
  73                 unsigned int new_allocated_len, old_allocated_len;
  74                 struct obj *new_table, *old_table;
  75
  76                 old_allocated_len = objd_table.allocated_len;
  77                 old_table = objd_table.array;
  78                 if (!old_allocated_len)
  79                         new_allocated_len = 1;
  80                 else
  81                         new_allocated_len = old_allocated_len << 1;
  82                 new_table = zmalloc(sizeof(struct obj) * new_allocated_len);
  83                 if (!new_table)
  84                         return -ENOMEM;
  85                 memcpy(new_table, old_table,
  86                        sizeof(struct obj) * old_allocated_len);
  87                 free(old_table);
  88                 objd_table.array = new_table;
  89                 objd_table.allocated_len = new_allocated_len;
  90         }
  91         obj = &objd_table.array[objd_table.len];
  92         objd_table.len++;
  93 end:
  94         obj->u.s.private_data = private_data;
  95         obj->u.s.ops = ops;
  96         obj->u.s.f_count = 2;   /* count == 1 : object is allocated */
  97                                 /* count == 2 : allocated + hold ref */
  98         return obj - objd_table.array;
  99 }
 100
 101 static
 102 struct obj *_objd_get(int id)
 103 {
 104         if (id >= objd_table.len)
 105                 return NULL;
 106         if (!objd_table.array[id].u.s.f_count)
 107                 return NULL;
 108         return &objd_table.array[id];
 109 }
 110
 111 static
 112 void *objd_private(int id)
 113 {
 114         struct obj *obj = _objd_get(id);
 115         assert(obj);
 116         return obj->u.s.private_data;
 117 }
 118
 119 static
 120 void objd_set_private(int id, void *private_data)
 121 {
 122         struct obj *obj = _objd_get(id);
 123         assert(obj);
 124         obj->u.s.private_data = private_data;
 125 }
 126
 127 const struct objd_ops *objd_ops(int id)
 128 {
 129         struct obj *obj = _objd_get(id);
 130
 131         if (!obj)
 132                 return NULL;
 133         return obj->u.s.ops;
 134 }
 135
 136 static
 137 void objd_free(int id)
 138 {
 139         struct obj *obj = _objd_get(id);
 140
 141         assert(obj);
 142         obj->u.freelist_next = objd_table.freelist_head;
 143         objd_table.freelist_head = obj - objd_table.array;
 144         assert(obj->u.s.f_count == 1);
 145         obj->u.s.f_count = 0;   /* deallocated */
 146 }
 147
 148 static
 149 void objd_ref(int id)
 150 {
 151         struct obj *obj = _objd_get(id);
 152         obj->u.s.f_count++;
 153 }
 154
 155 int objd_unref(int id)
 156 {
 157         struct obj *obj = _objd_get(id);
 158
 159         if (!obj)
 160                 return -EINVAL;
 161         if (obj->u.s.f_count == 1) {
 162                 ERR("Reference counting error\n");
 163                 return -EINVAL;
 164         }
 165         if ((--obj->u.s.f_count) == 1) {
 166                 const struct objd_ops *ops = objd_ops(id);
 167
 168                 if (ops->release)
 169                         ops->release(id);
 170                 objd_free(id);
 171         }
 172         return 0;
 173 }
 174
 175 static
 176 void objd_table_destroy(void)
 177 {
 178         int i;
 179
 180         for (i = 0; i < objd_table.allocated_len; i++) {
 181                 struct obj *obj = _objd_get(i);
 182                 const struct objd_ops *ops;
 183
 184                 if (!obj)
 185                         continue;
 186                 ops = obj->u.s.ops;
 187                 if (ops->release)
 188                         ops->release(i);
 189         }
 190         free(objd_table.array);
 191         objd_table.array = NULL;
 192         objd_table.len = 0;
 193         objd_table.allocated_len = 0;
 194         objd_table.freelist_head = -1;
 195 }
 196
 197 /*
 198  * This is LTTng's own personal way to create an ABI for sessiond.
 199  * We send commands over a socket.
 200  */
 201
 202 static const struct objd_ops lttng_ops;
 203 static const struct objd_ops lttng_session_ops;
 204 static const struct objd_ops lttng_channel_ops;
 205 static const struct objd_ops lttng_metadata_ops;
 206 static const struct objd_ops lttng_event_ops;
 207 static const struct objd_ops lib_ring_buffer_objd_ops;
 208
 209 enum channel_type {
 210         PER_CPU_CHANNEL,
 211         METADATA_CHANNEL,
 212 };
 213
 214 int lttng_abi_create_root_handle(void)
 215 {
 216         int root_handle;
 217
 218         root_handle = objd_alloc(NULL, &lttng_ops);
 219         assert(root_handle == 0);
 220         return root_handle;
 221 }
 222
 223 static
 224 int lttng_abi_create_session(void)
 225 {
 226         struct ltt_session *session;
 227         int session_objd, ret;
 228
 229         session = ltt_session_create();
 230         if (!session)
 231                 return -ENOMEM;
 232         session_objd = objd_alloc(session, &lttng_session_ops);
 233         if (session_objd < 0) {
 234                 ret = session_objd;
 235                 goto objd_error;
 236         }
 237         session->objd = session_objd;
 238         return session_objd;
 239
 240 objd_error:
 241         ltt_session_destroy(session);
 242         return ret;
 243 }
 244
 245 #if 0
 246 static
 247 int lttng_abi_tracepoint_list(void)
 248 {
 249         int list_objd, ret;
 250
 251         /* TODO: Create list private data */
 252         list_objd = objd_alloc(NULL, &lttng_tracepoint_list_ops);
 253         if (list_objd < 0) {
 254                 ret = list_objd;
 255                 goto objd_error;
 256         }
 257
 258         return list_objd;
 259
 260 objd_error:
 261         return ret;
 262 }
 263 #endif //0
 264
 265 static
 266 long lttng_abi_tracer_version(int objd,
 267         struct lttng_ust_tracer_version *v)
 268 {
 269         v->version = LTTNG_UST_VERSION;
 270         v->patchlevel = LTTNG_UST_PATCHLEVEL;
 271         v->sublevel = LTTNG_UST_SUBLEVEL;
 272         return 0;
 273 }
 274
 275 static
 276 long lttng_abi_add_context(int objd,
 277         struct lttng_ust_context *context_param,
 278         struct lttng_ctx **ctx, struct ltt_session *session)
 279 {
 280         if (session->been_active)
 281                 return -EPERM;
 282
 283         switch (context_param->ctx) {
 284         case LTTNG_UST_CONTEXT_VTID:
 285                 //TODO return lttng_add_vtid_to_ctx(ctx);
 286         default:
 287                 return -EINVAL;
 288         }
 289 }
 290
 291 /**
 292  *      lttng_cmd - lttng control through socket commands
 293  *
 294  *      @objd: the object descriptor
 295  *      @cmd: the command
 296  *      @arg: command arg
 297  *
 298  *      This descriptor implements lttng commands:
 299  *      LTTNG_UST_SESSION
 300  *              Returns a LTTng trace session object descriptor
 301  *      LTTNG_UST_TRACER_VERSION
 302  *              Returns the LTTng kernel tracer version
 303  *      LTTNG_UST_TRACEPOINT_LIST
 304  *              Returns a file descriptor listing available tracepoints
 305  *      LTTNG_UST_WAIT_QUIESCENT
 306  *              Returns after all previously running probes have completed
 307  *
 308  * The returned session will be deleted when its file descriptor is closed.
 309  */
 310 static
 311 long lttng_cmd(int objd, unsigned int cmd, unsigned long arg)
 312 {
 313         switch (cmd) {
 314         case LTTNG_UST_SESSION:
 315                 return lttng_abi_create_session();
 316         case LTTNG_UST_TRACER_VERSION:
 317                 return lttng_abi_tracer_version(objd,
 318                                 (struct lttng_ust_tracer_version *) arg);
 319         case LTTNG_UST_TRACEPOINT_LIST:
 320                 return -ENOSYS; //TODO
 321                 //return lttng_abi_tracepoint_list();
 322         case LTTNG_UST_WAIT_QUIESCENT:
 323                 synchronize_trace();
 324                 return 0;
 325         default:
 326                 return -EINVAL;
 327         }
 328 }
 329
 330 static const struct objd_ops lttng_ops = {
 331         .cmd = lttng_cmd,
 332 };
 333
 334 /*
 335  * We tolerate no failure in this function (if one happens, we print a dmesg
 336  * error, but cannot return any error, because the channel information is
 337  * invariant.
 338  */
 339 static
 340 void lttng_metadata_create_events(int channel_objd)
 341 {
 342         struct ltt_channel *channel = objd_private(channel_objd);
 343         static struct lttng_ust_event metadata_params = {
 344                 .instrumentation = LTTNG_UST_TRACEPOINT,
 345                 .name = "lttng_metadata",
 346         };
 347         struct ltt_event *event;
 348         int ret;
 349
 350         /*
 351          * We tolerate no failure path after event creation. It will stay
 352          * invariant for the rest of the session.
 353          */
 354         event = ltt_event_create(channel, &metadata_params, NULL);
 355         if (!event) {
 356                 ret = -EINVAL;
 357                 goto create_error;
 358         }
 359         return;
 360
 361 create_error:
 362         WARN_ON(1);
 363         return;         /* not allowed to return error */
 364 }
 365
 366 int lttng_abi_create_channel(int session_objd,
 367                              struct lttng_ust_channel *chan_param,
 368                              enum channel_type channel_type)
 369 {
 370         struct ltt_session *session = objd_private(session_objd);
 371         const struct objd_ops *ops;
 372         const char *transport_name;
 373         struct ltt_channel *chan;
 374         int chan_objd;
 375         int ret = 0;
 376
 377         chan_objd = objd_alloc(NULL, &lttng_channel_ops);
 378         if (chan_objd < 0) {
 379                 ret = chan_objd;
 380                 goto objd_error;
 381         }
 382         switch (channel_type) {
 383         case PER_CPU_CHANNEL:
 384                 if (chan_param->output == LTTNG_UST_MMAP) {
 385                         transport_name = chan_param->overwrite ?
 386                                 "relay-overwrite-mmap" : "relay-discard-mmap";
 387                 } else {
 388                         return -EINVAL;
 389                 }
 390                 ops = &lttng_channel_ops;
 391                 break;
 392         case METADATA_CHANNEL:
 393                 if (chan_param->output == LTTNG_UST_MMAP)
 394                         transport_name = "relay-metadata-mmap";
 395                 else
 396                         return -EINVAL;
 397                 ops = &lttng_metadata_ops;
 398                 break;
 399         default:
 400                 transport_name = "<unknown>";
 401                 break;
 402         }
 403         /*
 404          * We tolerate no failure path after channel creation. It will stay
 405          * invariant for the rest of the session.
 406          */
 407         chan = ltt_channel_create(session, transport_name, NULL,
 408                                   chan_param->subbuf_size,
 409                                   chan_param->num_subbuf,
 410                                   chan_param->switch_timer_interval,
 411                                   chan_param->read_timer_interval);
 412         if (!chan) {
 413                 ret = -EINVAL;
 414                 goto chan_error;
 415         }
 416         objd_set_private(chan_objd, chan);
 417         chan->objd = chan_objd;
 418         if (channel_type == METADATA_CHANNEL) {
 419                 session->metadata = chan;
 420                 lttng_metadata_create_events(chan_objd);
 421         }
 422
 423         /* The channel created holds a reference on the session */
 424         objd_ref(session_objd);
 425
 426         return chan_objd;
 427
 428 chan_error:
 429         {
 430                 int err;
 431
 432                 err = objd_unref(chan_objd);
 433                 assert(!err);
 434         }
 435 objd_error:
 436         return ret;
 437 }
 438
 439 /**
 440  *      lttng_session_cmd - lttng session object command
 441  *
 442  *      @obj: the object
 443  *      @cmd: the command
 444  *      @arg: command arg
 445  *
 446  *      This descriptor implements lttng commands:
 447  *      LTTNG_UST_CHANNEL
 448  *              Returns a LTTng channel object descriptor
 449  *      LTTNG_UST_ENABLE
 450  *              Enables tracing for a session (weak enable)
 451  *      LTTNG_UST_DISABLE
 452  *              Disables tracing for a session (strong disable)
 453  *      LTTNG_UST_METADATA
 454  *              Returns a LTTng metadata object descriptor
 455  *
 456  * The returned channel will be deleted when its file descriptor is closed.
 457  */
 458 static
 459 long lttng_session_cmd(int objd, unsigned int cmd, unsigned long arg)
 460 {
 461         struct ltt_session *session = objd_private(objd);
 462
 463         switch (cmd) {
 464         case LTTNG_UST_CHANNEL:
 465                 return lttng_abi_create_channel(objd,
 466                                 (struct lttng_ust_channel *) arg,
 467                                 PER_CPU_CHANNEL);
 468         case LTTNG_UST_SESSION_START:
 469         case LTTNG_UST_ENABLE:
 470                 return ltt_session_enable(session);
 471         case LTTNG_UST_SESSION_STOP:
 472         case LTTNG_UST_DISABLE:
 473                 return ltt_session_disable(session);
 474         case LTTNG_UST_METADATA:
 475                 return lttng_abi_create_channel(objd,
 476                                 (struct lttng_ust_channel *) arg,
 477                                 METADATA_CHANNEL);
 478         default:
 479                 return -EINVAL;
 480         }
 481 }
 482
 483 /*
 484  * Called when the last file reference is dropped.
 485  *
 486  * Big fat note: channels and events are invariant for the whole session after
 487  * their creation. So this session destruction also destroys all channel and
 488  * event structures specific to this session (they are not destroyed when their
 489  * individual file is released).
 490  */
 491 static
 492 int lttng_release_session(int objd)
 493 {
 494         struct ltt_session *session = objd_private(objd);
 495
 496         if (session) {
 497                 ltt_session_destroy(session);
 498                 return 0;
 499         } else {
 500                 return -EINVAL;
 501         }
 502 }
 503
 504 static const struct objd_ops lttng_session_ops = {
 505         .release = lttng_release_session,
 506         .cmd = lttng_session_cmd,
 507 };
 508
 509 struct stream_priv_data {
 510         struct lib_ring_buffer *buf;
 511         struct ltt_channel *ltt_chan;
 512 };
 513
 514 static
 515 int lttng_abi_open_stream(int channel_objd, struct lttng_ust_stream *info)
 516 {
 517         struct ltt_channel *channel = objd_private(channel_objd);
 518         struct lib_ring_buffer *buf;
 519         struct stream_priv_data *priv;
 520         int stream_objd, ret;
 521
 522         buf = channel->ops->buffer_read_open(channel->chan, channel->handle,
 523                         &info->shm_fd, &info->wait_fd, &info->memory_map_size);
 524         if (!buf)
 525                 return -ENOENT;
 526
 527         priv = zmalloc(sizeof(*priv));
 528         if (!priv) {
 529                 ret = -ENOMEM;
 530                 goto alloc_error;
 531         }
 532         priv->buf = buf;
 533         priv->ltt_chan = channel;
 534         stream_objd = objd_alloc(priv, &lib_ring_buffer_objd_ops);
 535         if (stream_objd < 0) {
 536                 ret = stream_objd;
 537                 goto objd_error;
 538         }
 539         /* Hold a reference on the channel object descriptor */
 540         objd_ref(channel_objd);
 541         return stream_objd;
 542
 543 objd_error:
 544         free(priv);
 545 alloc_error:
 546         channel->ops->buffer_read_close(buf, channel->handle);
 547         return ret;
 548 }
 549
 550 static
 551 int lttng_abi_create_event(int channel_objd,
 552                            struct lttng_ust_event *event_param)
 553 {
 554         struct ltt_channel *channel = objd_private(channel_objd);
 555         struct ltt_event *event;
 556         int event_objd, ret;
 557
 558         event_param->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
 559         event_objd = objd_alloc(NULL, &lttng_event_ops);
 560         if (event_objd < 0) {
 561                 ret = event_objd;
 562                 goto objd_error;
 563         }
 564         /*
 565          * We tolerate no failure path after event creation. It will stay
 566          * invariant for the rest of the session.
 567          */
 568         event = ltt_event_create(channel, event_param, NULL);
 569         if (!event) {
 570                 ret = -EINVAL;
 571                 goto event_error;
 572         }
 573         objd_set_private(event_objd, event);
 574         /* The event holds a reference on the channel */
 575         objd_ref(channel_objd);
 576         return event_objd;
 577
 578 event_error:
 579         {
 580                 int err;
 581
 582                 err = objd_unref(event_objd);
 583                 assert(!err);
 584         }
 585 objd_error:
 586         return ret;
 587 }
 588
 589 /**
 590  *      lttng_channel_cmd - lttng control through object descriptors
 591  *
 592  *      @objd: the object descriptor
 593  *      @cmd: the command
 594  *      @arg: command arg
 595  *
 596  *      This object descriptor implements lttng commands:
 597  *      LTTNG_UST_STREAM
 598  *              Returns an event stream object descriptor or failure.
 599  *              (typically, one event stream records events from one CPU)
 600  *      LTTNG_UST_EVENT
 601  *              Returns an event object descriptor or failure.
 602  *      LTTNG_UST_CONTEXT
 603  *              Prepend a context field to each event in the channel
 604  *      LTTNG_UST_ENABLE
 605  *              Enable recording for events in this channel (weak enable)
 606  *      LTTNG_UST_DISABLE
 607  *              Disable recording for events in this channel (strong disable)
 608  *
 609  * Channel and event file descriptors also hold a reference on the session.
 610  */
 611 static
 612 long lttng_channel_cmd(int objd, unsigned int cmd, unsigned long arg)
 613 {
 614         struct ltt_channel *channel = objd_private(objd);
 615
 616         switch (cmd) {
 617         case LTTNG_UST_STREAM:
 618         {
 619                 struct lttng_ust_stream *stream;
 620
 621                 stream = (struct lttng_ust_stream *) arg;
 622                 /* stream used as output */
 623                 return lttng_abi_open_stream(objd, stream);
 624         }
 625         case LTTNG_UST_EVENT:
 626                 return lttng_abi_create_event(objd, (struct lttng_ust_event *) arg);
 627         case LTTNG_UST_CONTEXT:
 628                 return lttng_abi_add_context(objd,
 629                                 (struct lttng_ust_context *) arg,
 630                                 &channel->ctx, channel->session);
 631         case LTTNG_UST_ENABLE:
 632                 return ltt_channel_enable(channel);
 633         case LTTNG_UST_DISABLE:
 634                 return ltt_channel_disable(channel);
 635         default:
 636                 return -EINVAL;
 637         }
 638 }
 639
 640 /**
 641  *      lttng_metadata_cmd - lttng control through object descriptors
 642  *
 643  *      @objd: the object descriptor
 644  *      @cmd: the command
 645  *      @arg: command arg
 646  *
 647  *      This object descriptor implements lttng commands:
 648  *      LTTNG_UST_STREAM
 649  *              Returns an event stream file descriptor or failure.
 650  *
 651  * Channel and event file descriptors also hold a reference on the session.
 652  */
 653 static
 654 long lttng_metadata_cmd(int objd, unsigned int cmd, unsigned long arg)
 655 {
 656         switch (cmd) {
 657         case LTTNG_UST_STREAM:
 658         {
 659                 struct lttng_ust_stream *stream;
 660
 661                 stream = (struct lttng_ust_stream *) arg;
 662                 /* stream used as output */
 663                 return lttng_abi_open_stream(objd, stream);
 664         }
 665         default:
 666                 return -EINVAL;
 667         }
 668 }
 669
 670 #if 0
 671 /**
 672  *      lttng_channel_poll - lttng stream addition/removal monitoring
 673  *
 674  *      @file: the file
 675  *      @wait: poll table
 676  */
 677 unsigned int lttng_channel_poll(struct file *file, poll_table *wait)
 678 {
 679         struct ltt_channel *channel = file->private_data;
 680         unsigned int mask = 0;
 681
 682         if (file->f_mode & FMODE_READ) {
 683                 poll_wait_set_exclusive(wait);
 684                 poll_wait(file, channel->ops->get_hp_wait_queue(channel->chan),
 685                           wait);
 686
 687                 if (channel->ops->is_disabled(channel->chan))
 688                         return POLLERR;
 689                 if (channel->ops->is_finalized(channel->chan))
 690                         return POLLHUP;
 691                 if (channel->ops->buffer_has_read_closed_stream(channel->chan))
 692                         return POLLIN | POLLRDNORM;
 693                 return 0;
 694         }
 695         return mask;
 696
 697 }
 698 #endif //0
 699
 700 static
 701 int lttng_channel_release(int objd)
 702 {
 703         struct ltt_channel *channel = objd_private(objd);
 704
 705         if (channel)
 706                 return objd_unref(channel->session->objd);
 707         return 0;
 708 }
 709
 710 static const struct objd_ops lttng_channel_ops = {
 711         .release = lttng_channel_release,
 712         //.poll = lttng_channel_poll,
 713         .cmd = lttng_channel_cmd,
 714 };
 715
 716 static const struct objd_ops lttng_metadata_ops = {
 717         .release = lttng_channel_release,
 718         .cmd = lttng_metadata_cmd,
 719 };
 720
 721 /**
 722  *      lttng_rb_cmd - lttng ring buffer control through object descriptors
 723  *
 724  *      @objd: the object descriptor
 725  *      @cmd: the command
 726  *      @arg: command arg
 727  *
 728  *      This object descriptor implements lttng commands:
 729  *              (None for now. Access is done directly though shm.)
 730  *              TODO: Add buffer flush.
 731  */
 732 static
 733 long lttng_rb_cmd(int objd, unsigned int cmd, unsigned long arg)
 734 {
 735         struct stream_priv_data *priv = objd_private(objd);
 736
 737         switch (cmd) {
 738         default:
 739                 return -EINVAL;
 740         }
 741 }
 742
 743 static
 744 int lttng_rb_release(int objd)
 745 {
 746         struct stream_priv_data *priv = objd_private(objd);
 747         struct lib_ring_buffer *buf;
 748         struct ltt_channel *channel;
 749
 750         if (priv) {
 751                 buf = priv->buf;
 752                 channel = priv->ltt_chan;
 753                 free(priv);
 754
 755                 return objd_unref(channel->objd);
 756         }
 757         return 0;
 758 }
 759
 760 static const struct objd_ops lib_ring_buffer_objd_ops = {
 761         .release = lttng_rb_release,
 762         .cmd = lttng_rb_cmd,
 763 };
 764
 765 /**
 766  *      lttng_event_cmd - lttng control through object descriptors
 767  *
 768  *      @objd: the object descriptor
 769  *      @cmd: the command
 770  *      @arg: command arg
 771  *
 772  *      This object descriptor implements lttng commands:
 773  *      LTTNG_UST_CONTEXT
 774  *              Prepend a context field to each record of this event
 775  *      LTTNG_UST_ENABLE
 776  *              Enable recording for this event (weak enable)
 777  *      LTTNG_UST_DISABLE
 778  *              Disable recording for this event (strong disable)
 779  */
 780 static
 781 long lttng_event_cmd(int objd, unsigned int cmd, unsigned long arg)
 782 {
 783         struct ltt_event *event = objd_private(objd);
 784
 785         switch (cmd) {
 786         case LTTNG_UST_CONTEXT:
 787                 return lttng_abi_add_context(objd,
 788                                 (struct lttng_ust_context *) arg,
 789                                 &event->ctx, event->chan->session);
 790         case LTTNG_UST_ENABLE:
 791                 return ltt_event_enable(event);
 792         case LTTNG_UST_DISABLE:
 793                 return ltt_event_disable(event);
 794         default:
 795                 return -EINVAL;
 796         }
 797 }
 798
 799 static
 800 int lttng_event_release(int objd)
 801 {
 802         struct ltt_event *event = objd_private(objd);
 803
 804         if (event)
 805                 return objd_unref(event->chan->objd);
 806         return 0;
 807 }
 808
 809 /* TODO: filter control ioctl */
 810 static const struct objd_ops lttng_event_ops = {
 811         .release = lttng_event_release,
 812         .cmd = lttng_event_cmd,
 813 };
 814
 815 void lttng_ust_abi_exit(void)
 816 {
 817         objd_table_destroy();
 818 }