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