liblttng-ust/lttng-ust-abi.c

   1 /*
   2  * lttng-ust-abi.c
   3  *
   4  * LTTng UST ABI
   5  *
   6  * Copyright (C) 2010-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; only
  11  * version 2.1 of the License.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  *
  22  *
  23  * Mimic system calls for:
  24  * - session creation, returns an object descriptor or failure.
  25  *   - channel creation, returns an object descriptor or failure.
  26  *     - Operates on a session object descriptor
  27  *     - Takes all channel options as parameters.
  28  *   - stream get, returns an object descriptor or failure.
  29  *     - Operates on a channel object descriptor.
  30  *   - stream notifier get, returns an object descriptor or failure.
  31  *     - Operates on a channel object descriptor.
  32  *   - event creation, returns an object descriptor or failure.
  33  *     - Operates on a channel object descriptor
  34  *     - Takes an event name as parameter
  35  *     - Takes an instrumentation source as parameter
  36  *       - e.g. tracepoints, dynamic_probes...
  37  *     - Takes instrumentation source specific arguments.
  38  */
  39
  40 #define _LGPL_SOURCE
  41 #include <stdint.h>
  42 #include <unistd.h>
  43
  44 #include <urcu/compiler.h>
  45 #include <urcu/list.h>
  46
  47 #include <helper.h>
  48 #include <lttng/tracepoint.h>
  49 #include <lttng/ust-abi.h>
  50 #include <lttng/ust-error.h>
  51 #include <lttng/ust-events.h>
  52 #include <lttng/ust-version.h>
  53 #include <ust-fd.h>
  54 #include <usterr-signal-safe.h>
  55
  56 #include "../libringbuffer/frontend_types.h"
  57 #include "../libringbuffer/shm.h"
  58 #include "lttng-tracer.h"
  59 #include "string-utils.h"
  60 #include "ust-events-internal.h"
  61
  62 #define OBJ_NAME_LEN    16
  63
  64 static int lttng_ust_abi_close_in_progress;
  65
  66 static
  67 int lttng_abi_tracepoint_list(void *owner);
  68 static
  69 int lttng_abi_tracepoint_field_list(void *owner);
  70
  71 /*
  72  * Object descriptor table. Should be protected from concurrent access
  73  * by the caller.
  74  */
  75
  76 struct lttng_ust_obj {
  77         union {
  78                 struct {
  79                         void *private_data;
  80                         const struct lttng_ust_objd_ops *ops;
  81                         int f_count;
  82                         int owner_ref;  /* has ref from owner */
  83                         void *owner;
  84                         char name[OBJ_NAME_LEN];
  85                 } s;
  86                 int freelist_next;      /* offset freelist. end is -1. */
  87         } u;
  88 };
  89
  90 struct lttng_ust_objd_table {
  91         struct lttng_ust_obj *array;
  92         unsigned int len, allocated_len;
  93         int freelist_head;              /* offset freelist head. end is -1 */
  94 };
  95
  96 static struct lttng_ust_objd_table objd_table = {
  97         .freelist_head = -1,
  98 };
  99
 100 static
 101 int objd_alloc(void *private_data, const struct lttng_ust_objd_ops *ops,
 102                 void *owner, const char *name)
 103 {
 104         struct lttng_ust_obj *obj;
 105
 106         if (objd_table.freelist_head != -1) {
 107                 obj = &objd_table.array[objd_table.freelist_head];
 108                 objd_table.freelist_head = obj->u.freelist_next;
 109                 goto end;
 110         }
 111
 112         if (objd_table.len >= objd_table.allocated_len) {
 113                 unsigned int new_allocated_len, old_allocated_len;
 114                 struct lttng_ust_obj *new_table, *old_table;
 115
 116                 old_allocated_len = objd_table.allocated_len;
 117                 old_table = objd_table.array;
 118                 if (!old_allocated_len)
 119                         new_allocated_len = 1;
 120                 else
 121                         new_allocated_len = old_allocated_len << 1;
 122                 new_table = zmalloc(sizeof(struct lttng_ust_obj) * new_allocated_len);
 123                 if (!new_table)
 124                         return -ENOMEM;
 125                 memcpy(new_table, old_table,
 126                        sizeof(struct lttng_ust_obj) * old_allocated_len);
 127                 free(old_table);
 128                 objd_table.array = new_table;
 129                 objd_table.allocated_len = new_allocated_len;
 130         }
 131         obj = &objd_table.array[objd_table.len];
 132         objd_table.len++;
 133 end:
 134         obj->u.s.private_data = private_data;
 135         obj->u.s.ops = ops;
 136         obj->u.s.f_count = 2;   /* count == 1 : object is allocated */
 137                                 /* count == 2 : allocated + hold ref */
 138         obj->u.s.owner_ref = 1; /* One owner reference */
 139         obj->u.s.owner = owner;
 140         strncpy(obj->u.s.name, name, OBJ_NAME_LEN);
 141         obj->u.s.name[OBJ_NAME_LEN - 1] = '\0';
 142         return obj - objd_table.array;
 143 }
 144
 145 static
 146 struct lttng_ust_obj *_objd_get(int id)
 147 {
 148         if (id >= objd_table.len)
 149                 return NULL;
 150         if (!objd_table.array[id].u.s.f_count)
 151                 return NULL;
 152         return &objd_table.array[id];
 153 }
 154
 155 static
 156 void *objd_private(int id)
 157 {
 158         struct lttng_ust_obj *obj = _objd_get(id);
 159         assert(obj);
 160         return obj->u.s.private_data;
 161 }
 162
 163 static
 164 void objd_set_private(int id, void *private_data)
 165 {
 166         struct lttng_ust_obj *obj = _objd_get(id);
 167         assert(obj);
 168         obj->u.s.private_data = private_data;
 169 }
 170
 171 const struct lttng_ust_objd_ops *objd_ops(int id)
 172 {
 173         struct lttng_ust_obj *obj = _objd_get(id);
 174
 175         if (!obj)
 176                 return NULL;
 177         return obj->u.s.ops;
 178 }
 179
 180 static
 181 void objd_free(int id)
 182 {
 183         struct lttng_ust_obj *obj = _objd_get(id);
 184
 185         assert(obj);
 186         obj->u.freelist_next = objd_table.freelist_head;
 187         objd_table.freelist_head = obj - objd_table.array;
 188         assert(obj->u.s.f_count == 1);
 189         obj->u.s.f_count = 0;   /* deallocated */
 190 }
 191
 192 static
 193 void objd_ref(int id)
 194 {
 195         struct lttng_ust_obj *obj = _objd_get(id);
 196         assert(obj != NULL);
 197         obj->u.s.f_count++;
 198 }
 199
 200 int lttng_ust_objd_unref(int id, int is_owner)
 201 {
 202         struct lttng_ust_obj *obj = _objd_get(id);
 203
 204         if (!obj)
 205                 return -EINVAL;
 206         if (obj->u.s.f_count == 1) {
 207                 ERR("Reference counting error\n");
 208                 return -EINVAL;
 209         }
 210         if (is_owner) {
 211                 if (!obj->u.s.owner_ref) {
 212                         ERR("Error decrementing owner reference");
 213                         return -EINVAL;
 214                 }
 215                 obj->u.s.owner_ref--;
 216         }
 217         if ((--obj->u.s.f_count) == 1) {
 218                 const struct lttng_ust_objd_ops *ops = objd_ops(id);
 219
 220                 if (ops->release)
 221                         ops->release(id);
 222                 objd_free(id);
 223         }
 224         return 0;
 225 }
 226
 227 static
 228 void objd_table_destroy(void)
 229 {
 230         int i;
 231
 232         for (i = 0; i < objd_table.allocated_len; i++) {
 233                 struct lttng_ust_obj *obj;
 234
 235                 obj = _objd_get(i);
 236                 if (!obj)
 237                         continue;
 238                 if (!obj->u.s.owner_ref)
 239                         continue;       /* only unref owner ref. */
 240                 (void) lttng_ust_objd_unref(i, 1);
 241         }
 242         free(objd_table.array);
 243         objd_table.array = NULL;
 244         objd_table.len = 0;
 245         objd_table.allocated_len = 0;
 246         objd_table.freelist_head = -1;
 247 }
 248
 249 const char *lttng_ust_obj_get_name(int id)
 250 {
 251         struct lttng_ust_obj *obj = _objd_get(id);
 252
 253         if (!obj)
 254                 return NULL;
 255         return obj->u.s.name;
 256 }
 257
 258 void lttng_ust_objd_table_owner_cleanup(void *owner)
 259 {
 260         int i;
 261
 262         for (i = 0; i < objd_table.allocated_len; i++) {
 263                 struct lttng_ust_obj *obj;
 264
 265                 obj = _objd_get(i);
 266                 if (!obj)
 267                         continue;
 268                 if (!obj->u.s.owner)
 269                         continue;       /* skip root handles */
 270                 if (!obj->u.s.owner_ref)
 271                         continue;       /* only unref owner ref. */
 272                 if (obj->u.s.owner == owner)
 273                         (void) lttng_ust_objd_unref(i, 1);
 274         }
 275 }
 276
 277 /*
 278  * This is LTTng's own personal way to create an ABI for sessiond.
 279  * We send commands over a socket.
 280  */
 281
 282 static const struct lttng_ust_objd_ops lttng_ops;
 283 static const struct lttng_ust_objd_ops lttng_session_ops;
 284 static const struct lttng_ust_objd_ops lttng_channel_ops;
 285 static const struct lttng_ust_objd_ops lttng_event_enabler_ops;
 286 static const struct lttng_ust_objd_ops lttng_tracepoint_list_ops;
 287 static const struct lttng_ust_objd_ops lttng_tracepoint_field_list_ops;
 288
 289 int lttng_abi_create_root_handle(void)
 290 {
 291         int root_handle;
 292
 293         /* root handles have NULL owners */
 294         root_handle = objd_alloc(NULL, &lttng_ops, NULL, "root");
 295         return root_handle;
 296 }
 297
 298 static
 299 int lttng_is_channel_ready(struct lttng_channel *lttng_chan)
 300 {
 301         struct channel *chan;
 302         unsigned int nr_streams, exp_streams;
 303
 304         chan = lttng_chan->chan;
 305         nr_streams = channel_handle_get_nr_streams(lttng_chan->handle);
 306         exp_streams = chan->nr_streams;
 307         return nr_streams == exp_streams;
 308 }
 309
 310 static
 311 int lttng_abi_create_session(void *owner)
 312 {
 313         struct lttng_session *session;
 314         int session_objd, ret;
 315
 316         session = lttng_session_create();
 317         if (!session)
 318                 return -ENOMEM;
 319         session_objd = objd_alloc(session, &lttng_session_ops, owner, "session");
 320         if (session_objd < 0) {
 321                 ret = session_objd;
 322                 goto objd_error;
 323         }
 324         session->objd = session_objd;
 325         session->owner = owner;
 326         return session_objd;
 327
 328 objd_error:
 329         lttng_session_destroy(session);
 330         return ret;
 331 }
 332
 333 static
 334 long lttng_abi_tracer_version(int objd,
 335         struct lttng_ust_tracer_version *v)
 336 {
 337         v->major = LTTNG_UST_MAJOR_VERSION;
 338         v->minor = LTTNG_UST_MINOR_VERSION;
 339         v->patchlevel = LTTNG_UST_PATCHLEVEL_VERSION;
 340         return 0;
 341 }
 342
 343 static
 344 long lttng_abi_add_context(int objd,
 345         struct lttng_ust_context *context_param,
 346         union ust_args *uargs,
 347         struct lttng_ctx **ctx, struct lttng_session *session)
 348 {
 349         return lttng_attach_context(context_param, uargs, ctx, session);
 350 }
 351
 352 /**
 353  *      lttng_cmd - lttng control through socket commands
 354  *
 355  *      @objd: the object descriptor
 356  *      @cmd: the command
 357  *      @arg: command arg
 358  *      @uargs: UST arguments (internal)
 359  *      @owner: objd owner
 360  *
 361  *      This descriptor implements lttng commands:
 362  *      LTTNG_UST_SESSION
 363  *              Returns a LTTng trace session object descriptor
 364  *      LTTNG_UST_TRACER_VERSION
 365  *              Returns the LTTng kernel tracer version
 366  *      LTTNG_UST_TRACEPOINT_LIST
 367  *              Returns a file descriptor listing available tracepoints
 368  *      LTTNG_UST_TRACEPOINT_FIELD_LIST
 369  *              Returns a file descriptor listing available tracepoint fields
 370  *      LTTNG_UST_WAIT_QUIESCENT
 371  *              Returns after all previously running probes have completed
 372  *
 373  * The returned session will be deleted when its file descriptor is closed.
 374  */
 375 static
 376 long lttng_cmd(int objd, unsigned int cmd, unsigned long arg,
 377         union ust_args *uargs, void *owner)
 378 {
 379         switch (cmd) {
 380         case LTTNG_UST_SESSION:
 381                 return lttng_abi_create_session(owner);
 382         case LTTNG_UST_TRACER_VERSION:
 383                 return lttng_abi_tracer_version(objd,
 384                                 (struct lttng_ust_tracer_version *) arg);
 385         case LTTNG_UST_TRACEPOINT_LIST:
 386                 return lttng_abi_tracepoint_list(owner);
 387         case LTTNG_UST_TRACEPOINT_FIELD_LIST:
 388                 return lttng_abi_tracepoint_field_list(owner);
 389         case LTTNG_UST_WAIT_QUIESCENT:
 390                 synchronize_trace();
 391                 return 0;
 392         default:
 393                 return -EINVAL;
 394         }
 395 }
 396
 397 static const struct lttng_ust_objd_ops lttng_ops = {
 398         .cmd = lttng_cmd,
 399 };
 400
 401 int lttng_abi_map_channel(int session_objd,
 402                 struct lttng_ust_channel *ust_chan,
 403                 union ust_args *uargs,
 404                 void *owner)
 405 {
 406         struct lttng_session *session = objd_private(session_objd);
 407         const char *transport_name;
 408         const struct lttng_transport *transport;
 409         const char *chan_name;
 410         int chan_objd;
 411         struct lttng_ust_shm_handle *channel_handle;
 412         struct lttng_channel *lttng_chan;
 413         struct channel *chan;
 414         struct lttng_ust_lib_ring_buffer_config *config;
 415         void *chan_data;
 416         int wakeup_fd;
 417         uint64_t len;
 418         int ret;
 419         enum lttng_ust_chan_type type;
 420
 421         chan_data = uargs->channel.chan_data;
 422         wakeup_fd = uargs->channel.wakeup_fd;
 423         len = ust_chan->len;
 424         type = ust_chan->type;
 425
 426         switch (type) {
 427         case LTTNG_UST_CHAN_PER_CPU:
 428                 break;
 429         default:
 430                 ret = -EINVAL;
 431                 goto invalid;
 432         }
 433
 434         if (session->been_active) {
 435                 ret = -EBUSY;
 436                 goto active;    /* Refuse to add channel to active session */
 437         }
 438
 439         channel_handle = channel_handle_create(chan_data, len, wakeup_fd);
 440         if (!channel_handle) {
 441                 ret = -EINVAL;
 442                 goto handle_error;
 443         }
 444
 445         chan = shmp(channel_handle, channel_handle->chan);
 446         assert(chan);
 447         chan->handle = channel_handle;
 448         config = &chan->backend.config;
 449         lttng_chan = channel_get_private(chan);
 450         if (!lttng_chan) {
 451                 ret = -EINVAL;
 452                 goto alloc_error;
 453         }
 454
 455         /* Lookup transport name */
 456         switch (type) {
 457         case LTTNG_UST_CHAN_PER_CPU:
 458                 if (config->output == RING_BUFFER_MMAP) {
 459                         if (config->mode == RING_BUFFER_OVERWRITE) {
 460                                 if (config->wakeup == RING_BUFFER_WAKEUP_BY_WRITER) {
 461                                         transport_name = "relay-overwrite-mmap";
 462                                 } else {
 463                                         transport_name = "relay-overwrite-rt-mmap";
 464                                 }
 465                         } else {
 466                                 if (config->wakeup == RING_BUFFER_WAKEUP_BY_WRITER) {
 467                                         transport_name = "relay-discard-mmap";
 468                                 } else {
 469                                         transport_name = "relay-discard-rt-mmap";
 470                                 }
 471                         }
 472                 } else {
 473                         ret = -EINVAL;
 474                         goto notransport;
 475                 }
 476                 chan_name = "channel";
 477                 break;
 478         default:
 479                 ret = -EINVAL;
 480                 goto notransport;
 481         }
 482         transport = lttng_transport_find(transport_name);
 483         if (!transport) {
 484                 DBG("LTTng transport %s not found\n",
 485                        transport_name);
 486                 ret = -EINVAL;
 487                 goto notransport;
 488         }
 489
 490         chan_objd = objd_alloc(NULL, &lttng_channel_ops, owner, chan_name);
 491         if (chan_objd < 0) {
 492                 ret = chan_objd;
 493                 goto objd_error;
 494         }
 495
 496         /* Initialize our lttng chan */
 497         lttng_chan->chan = chan;
 498         lttng_chan->tstate = 1;
 499         lttng_chan->enabled = 1;
 500         lttng_chan->ctx = NULL;
 501         lttng_chan->session = session;
 502         lttng_chan->ops = &transport->ops;
 503         memcpy(&lttng_chan->chan->backend.config,
 504                 transport->client_config,
 505                 sizeof(lttng_chan->chan->backend.config));
 506         cds_list_add(&lttng_chan->node, &session->chan_head);
 507         lttng_chan->header_type = 0;
 508         lttng_chan->handle = channel_handle;
 509         lttng_chan->type = type;
 510
 511         /*
 512          * We tolerate no failure path after channel creation. It will stay
 513          * invariant for the rest of the session.
 514          */
 515         objd_set_private(chan_objd, lttng_chan);
 516         lttng_chan->objd = chan_objd;
 517         /* The channel created holds a reference on the session */
 518         objd_ref(session_objd);
 519         return chan_objd;
 520
 521         /* error path after channel was created */
 522 objd_error:
 523 notransport:
 524 alloc_error:
 525         channel_destroy(chan, channel_handle, 0);
 526         return ret;
 527
 528         /*
 529          * error path before channel creation (owning chan_data and
 530          * wakeup_fd).
 531          */
 532 handle_error:
 533 active:
 534 invalid:
 535         {
 536                 int close_ret;
 537
 538                 lttng_ust_lock_fd_tracker();
 539                 close_ret = close(wakeup_fd);
 540                 lttng_ust_unlock_fd_tracker();
 541                 if (close_ret) {
 542                         PERROR("close");
 543                 }
 544         }
 545         free(chan_data);
 546         return ret;
 547 }
 548
 549 /**
 550  *      lttng_session_cmd - lttng session object command
 551  *
 552  *      @obj: the object
 553  *      @cmd: the command
 554  *      @arg: command arg
 555  *      @uargs: UST arguments (internal)
 556  *      @owner: objd owner
 557  *
 558  *      This descriptor implements lttng commands:
 559  *      LTTNG_UST_CHANNEL
 560  *              Returns a LTTng channel object descriptor
 561  *      LTTNG_UST_ENABLE
 562  *              Enables tracing for a session (weak enable)
 563  *      LTTNG_UST_DISABLE
 564  *              Disables tracing for a session (strong disable)
 565  *
 566  * The returned channel will be deleted when its file descriptor is closed.
 567  */
 568 static
 569 long lttng_session_cmd(int objd, unsigned int cmd, unsigned long arg,
 570         union ust_args *uargs, void *owner)
 571 {
 572         struct lttng_session *session = objd_private(objd);
 573
 574         switch (cmd) {
 575         case LTTNG_UST_CHANNEL:
 576                 return lttng_abi_map_channel(objd,
 577                                 (struct lttng_ust_channel *) arg,
 578                                 uargs, owner);
 579         case LTTNG_UST_SESSION_START:
 580         case LTTNG_UST_ENABLE:
 581                 return lttng_session_enable(session);
 582         case LTTNG_UST_SESSION_STOP:
 583         case LTTNG_UST_DISABLE:
 584                 return lttng_session_disable(session);
 585         case LTTNG_UST_SESSION_STATEDUMP:
 586                 return lttng_session_statedump(session);
 587         default:
 588                 return -EINVAL;
 589         }
 590 }
 591
 592 /*
 593  * Called when the last file reference is dropped.
 594  *
 595  * Big fat note: channels and events are invariant for the whole session after
 596  * their creation. So this session destruction also destroys all channel and
 597  * event structures specific to this session (they are not destroyed when their
 598  * individual file is released).
 599  */
 600 static
 601 int lttng_release_session(int objd)
 602 {
 603         struct lttng_session *session = objd_private(objd);
 604
 605         if (session) {
 606                 lttng_session_destroy(session);
 607                 return 0;
 608         } else {
 609                 return -EINVAL;
 610         }
 611 }
 612
 613 static const struct lttng_ust_objd_ops lttng_session_ops = {
 614         .release = lttng_release_session,
 615         .cmd = lttng_session_cmd,
 616 };
 617
 618 static
 619 long lttng_tracepoint_list_cmd(int objd, unsigned int cmd, unsigned long arg,
 620         union ust_args *uargs, void *owner)
 621 {
 622         struct lttng_ust_tracepoint_list *list = objd_private(objd);
 623         struct lttng_ust_tracepoint_iter *tp =
 624                 (struct lttng_ust_tracepoint_iter *) arg;
 625         struct lttng_ust_tracepoint_iter *iter;
 626
 627         switch (cmd) {
 628         case LTTNG_UST_TRACEPOINT_LIST_GET:
 629         {
 630                 iter = lttng_ust_tracepoint_list_get_iter_next(list);
 631                 if (!iter)
 632                         return -LTTNG_UST_ERR_NOENT;
 633                 memcpy(tp, iter, sizeof(*tp));
 634                 return 0;
 635         }
 636         default:
 637                 return -EINVAL;
 638         }
 639 }
 640
 641 static
 642 int lttng_abi_tracepoint_list(void *owner)
 643 {
 644         int list_objd, ret;
 645         struct lttng_ust_tracepoint_list *list;
 646
 647         list_objd = objd_alloc(NULL, &lttng_tracepoint_list_ops, owner, "tp_list");
 648         if (list_objd < 0) {
 649                 ret = list_objd;
 650                 goto objd_error;
 651         }
 652         list = zmalloc(sizeof(*list));
 653         if (!list) {
 654                 ret = -ENOMEM;
 655                 goto alloc_error;
 656         }
 657         objd_set_private(list_objd, list);
 658
 659         /* populate list by walking on all registered probes. */
 660         ret = lttng_probes_get_event_list(list);
 661         if (ret) {
 662                 goto list_error;
 663         }
 664         return list_objd;
 665
 666 list_error:
 667         free(list);
 668 alloc_error:
 669         {
 670                 int err;
 671
 672                 err = lttng_ust_objd_unref(list_objd, 1);
 673                 assert(!err);
 674         }
 675 objd_error:
 676         return ret;
 677 }
 678
 679 static
 680 int lttng_release_tracepoint_list(int objd)
 681 {
 682         struct lttng_ust_tracepoint_list *list = objd_private(objd);
 683
 684         if (list) {
 685                 lttng_probes_prune_event_list(list);
 686                 free(list);
 687                 return 0;
 688         } else {
 689                 return -EINVAL;
 690         }
 691 }
 692
 693 static const struct lttng_ust_objd_ops lttng_tracepoint_list_ops = {
 694         .release = lttng_release_tracepoint_list,
 695         .cmd = lttng_tracepoint_list_cmd,
 696 };
 697
 698 static
 699 long lttng_tracepoint_field_list_cmd(int objd, unsigned int cmd,
 700         unsigned long arg, union ust_args *uargs, void *owner)
 701 {
 702         struct lttng_ust_field_list *list = objd_private(objd);
 703         struct lttng_ust_field_iter *tp = &uargs->field_list.entry;
 704         struct lttng_ust_field_iter *iter;
 705
 706         switch (cmd) {
 707         case LTTNG_UST_TRACEPOINT_FIELD_LIST_GET:
 708         {
 709                 iter = lttng_ust_field_list_get_iter_next(list);
 710                 if (!iter)
 711                         return -LTTNG_UST_ERR_NOENT;
 712                 memcpy(tp, iter, sizeof(*tp));
 713                 return 0;
 714         }
 715         default:
 716                 return -EINVAL;
 717         }
 718 }
 719
 720 static
 721 int lttng_abi_tracepoint_field_list(void *owner)
 722 {
 723         int list_objd, ret;
 724         struct lttng_ust_field_list *list;
 725
 726         list_objd = objd_alloc(NULL, &lttng_tracepoint_field_list_ops, owner,
 727                         "tp_field_list");
 728         if (list_objd < 0) {
 729                 ret = list_objd;
 730                 goto objd_error;
 731         }
 732         list = zmalloc(sizeof(*list));
 733         if (!list) {
 734                 ret = -ENOMEM;
 735                 goto alloc_error;
 736         }
 737         objd_set_private(list_objd, list);
 738
 739         /* populate list by walking on all registered probes. */
 740         ret = lttng_probes_get_field_list(list);
 741         if (ret) {
 742                 goto list_error;
 743         }
 744         return list_objd;
 745
 746 list_error:
 747         free(list);
 748 alloc_error:
 749         {
 750                 int err;
 751
 752                 err = lttng_ust_objd_unref(list_objd, 1);
 753                 assert(!err);
 754         }
 755 objd_error:
 756         return ret;
 757 }
 758
 759 static
 760 int lttng_release_tracepoint_field_list(int objd)
 761 {
 762         struct lttng_ust_field_list *list = objd_private(objd);
 763
 764         if (list) {
 765                 lttng_probes_prune_field_list(list);
 766                 free(list);
 767                 return 0;
 768         } else {
 769                 return -EINVAL;
 770         }
 771 }
 772
 773 static const struct lttng_ust_objd_ops lttng_tracepoint_field_list_ops = {
 774         .release = lttng_release_tracepoint_field_list,
 775         .cmd = lttng_tracepoint_field_list_cmd,
 776 };
 777
 778 static
 779 int lttng_abi_map_stream(int channel_objd, struct lttng_ust_stream *info,
 780                 union ust_args *uargs, void *owner)
 781 {
 782         struct lttng_channel *channel = objd_private(channel_objd);
 783         int ret;
 784
 785         ret = channel_handle_add_stream(channel->handle,
 786                 uargs->stream.shm_fd, uargs->stream.wakeup_fd,
 787                 info->stream_nr, info->len);
 788         if (ret)
 789                 goto error_add_stream;
 790
 791         return 0;
 792
 793 error_add_stream:
 794         return ret;
 795 }
 796
 797 static
 798 int lttng_abi_create_event_enabler(int channel_objd,
 799                            struct lttng_ust_event *event_param,
 800                            void *owner,
 801                            enum lttng_enabler_format_type format_type)
 802 {
 803         struct lttng_channel *channel = objd_private(channel_objd);
 804         struct lttng_event_enabler *enabler;
 805         int event_objd, ret;
 806
 807         event_param->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
 808         event_objd = objd_alloc(NULL, &lttng_event_enabler_ops, owner,
 809                 "event enabler");
 810         if (event_objd < 0) {
 811                 ret = event_objd;
 812                 goto objd_error;
 813         }
 814         /*
 815          * We tolerate no failure path after event creation. It will stay
 816          * invariant for the rest of the session.
 817          */
 818         enabler = lttng_event_enabler_create(format_type, event_param, channel);
 819         if (!enabler) {
 820                 ret = -ENOMEM;
 821                 goto event_error;
 822         }
 823         objd_set_private(event_objd, enabler);
 824         /* The event holds a reference on the channel */
 825         objd_ref(channel_objd);
 826         return event_objd;
 827
 828 event_error:
 829         {
 830                 int err;
 831
 832                 err = lttng_ust_objd_unref(event_objd, 1);
 833                 assert(!err);
 834         }
 835 objd_error:
 836         return ret;
 837 }
 838
 839 /**
 840  *      lttng_channel_cmd - lttng control through object descriptors
 841  *
 842  *      @objd: the object descriptor
 843  *      @cmd: the command
 844  *      @arg: command arg
 845  *      @uargs: UST arguments (internal)
 846  *      @owner: objd owner
 847  *
 848  *      This object descriptor implements lttng commands:
 849  *      LTTNG_UST_STREAM
 850  *              Returns an event stream object descriptor or failure.
 851  *              (typically, one event stream records events from one CPU)
 852  *      LTTNG_UST_EVENT
 853  *              Returns an event object descriptor or failure.
 854  *      LTTNG_UST_CONTEXT
 855  *              Prepend a context field to each event in the channel
 856  *      LTTNG_UST_ENABLE
 857  *              Enable recording for events in this channel (weak enable)
 858  *      LTTNG_UST_DISABLE
 859  *              Disable recording for events in this channel (strong disable)
 860  *
 861  * Channel and event file descriptors also hold a reference on the session.
 862  */
 863 static
 864 long lttng_channel_cmd(int objd, unsigned int cmd, unsigned long arg,
 865         union ust_args *uargs, void *owner)
 866 {
 867         struct lttng_channel *channel = objd_private(objd);
 868
 869         if (cmd != LTTNG_UST_STREAM) {
 870                 /*
 871                  * Check if channel received all streams.
 872                  */
 873                 if (!lttng_is_channel_ready(channel))
 874                         return -EPERM;
 875         }
 876
 877         switch (cmd) {
 878         case LTTNG_UST_STREAM:
 879         {
 880                 struct lttng_ust_stream *stream;
 881
 882                 stream = (struct lttng_ust_stream *) arg;
 883                 /* stream used as output */
 884                 return lttng_abi_map_stream(objd, stream, uargs, owner);
 885         }
 886         case LTTNG_UST_EVENT:
 887         {
 888                 struct lttng_ust_event *event_param =
 889                         (struct lttng_ust_event *) arg;
 890
 891                 if (strutils_is_star_glob_pattern(event_param->name)) {
 892                         /*
 893                          * If the event name is a star globbing pattern,
 894                          * we create the special star globbing enabler.
 895                          */
 896                         return lttng_abi_create_event_enabler(objd, event_param,
 897                                         owner, LTTNG_ENABLER_FORMAT_STAR_GLOB);
 898                 } else {
 899                         return lttng_abi_create_event_enabler(objd, event_param,
 900                                         owner, LTTNG_ENABLER_FORMAT_EVENT);
 901                 }
 902         }
 903         case LTTNG_UST_CONTEXT:
 904                 return lttng_abi_add_context(objd,
 905                                 (struct lttng_ust_context *) arg, uargs,
 906                                 &channel->ctx, channel->session);
 907         case LTTNG_UST_ENABLE:
 908                 return lttng_channel_enable(channel);
 909         case LTTNG_UST_DISABLE:
 910                 return lttng_channel_disable(channel);
 911         case LTTNG_UST_FLUSH_BUFFER:
 912                 return channel->ops->flush_buffer(channel->chan, channel->handle);
 913         default:
 914                 return -EINVAL;
 915         }
 916 }
 917
 918 static
 919 int lttng_channel_release(int objd)
 920 {
 921         struct lttng_channel *channel = objd_private(objd);
 922
 923         if (channel)
 924                 return lttng_ust_objd_unref(channel->session->objd, 0);
 925         return 0;
 926 }
 927
 928 static const struct lttng_ust_objd_ops lttng_channel_ops = {
 929         .release = lttng_channel_release,
 930         .cmd = lttng_channel_cmd,
 931 };
 932
 933 /**
 934  *      lttng_enabler_cmd - lttng control through object descriptors
 935  *
 936  *      @objd: the object descriptor
 937  *      @cmd: the command
 938  *      @arg: command arg
 939  *      @uargs: UST arguments (internal)
 940  *      @owner: objd owner
 941  *
 942  *      This object descriptor implements lttng commands:
 943  *      LTTNG_UST_CONTEXT
 944  *              Prepend a context field to each record of events of this
 945  *              enabler.
 946  *      LTTNG_UST_ENABLE
 947  *              Enable recording for this enabler
 948  *      LTTNG_UST_DISABLE
 949  *              Disable recording for this enabler
 950  *      LTTNG_UST_FILTER
 951  *              Attach a filter to an enabler.
 952  *      LTTNG_UST_EXCLUSION
 953  *              Attach exclusions to an enabler.
 954  */
 955 static
 956 long lttng_event_enabler_cmd(int objd, unsigned int cmd, unsigned long arg,
 957         union ust_args *uargs, void *owner)
 958 {
 959         struct lttng_event_enabler *enabler = objd_private(objd);
 960
 961         switch (cmd) {
 962         case LTTNG_UST_CONTEXT:
 963                 return lttng_event_enabler_attach_context(enabler,
 964                                 (struct lttng_ust_context *) arg);
 965         case LTTNG_UST_ENABLE:
 966                 return lttng_event_enabler_enable(enabler);
 967         case LTTNG_UST_DISABLE:
 968                 return lttng_event_enabler_disable(enabler);
 969         case LTTNG_UST_FILTER:
 970         {
 971                 int ret;
 972
 973                 ret = lttng_event_enabler_attach_bytecode(enabler,
 974                                 (struct lttng_ust_filter_bytecode_node *) arg);
 975                 if (ret)
 976                         return ret;
 977                 return 0;
 978         }
 979         case LTTNG_UST_EXCLUSION:
 980         {
 981                 return lttng_event_enabler_attach_exclusion(enabler,
 982                                 (struct lttng_ust_excluder_node *) arg);
 983         }
 984         default:
 985                 return -EINVAL;
 986         }
 987 }
 988
 989 static
 990 int lttng_event_enabler_release(int objd)
 991 {
 992         struct lttng_event_enabler *event_enabler = objd_private(objd);
 993
 994         if (event_enabler)
 995                 return lttng_ust_objd_unref(event_enabler->chan->objd, 0);
 996
 997         return 0;
 998 }
 999
1000 static const struct lttng_ust_objd_ops lttng_event_enabler_ops = {
1001         .release = lttng_event_enabler_release,
1002         .cmd = lttng_event_enabler_cmd,
1003 };
1004
1005 void lttng_ust_abi_exit(void)
1006 {
1007         lttng_ust_abi_close_in_progress = 1;
1008         ust_lock_nocheck();
1009         objd_table_destroy();
1010         ust_unlock();
1011         lttng_ust_abi_close_in_progress = 0;
1012 }