liblttng-ust/lttng-events.c

   1 /*
   2  * lttng-events.c
   3  *
   4  * Holds LTTng per-session event registry.
   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 #define _LGPL_SOURCE
  24 #include <stdio.h>
  25 #include <assert.h>
  26 #include <errno.h>
  27 #include <limits.h>
  28 #include <pthread.h>
  29 #include <sys/shm.h>
  30 #include <sys/ipc.h>
  31 #include <stdint.h>
  32 #include <stddef.h>
  33 #include <inttypes.h>
  34 #include <time.h>
  35 #include <stdbool.h>
  36 #include <unistd.h>
  37 #include <lttng/ust-endian.h>
  38
  39 #include <urcu-bp.h>
  40 #include <urcu/arch.h>
  41 #include <urcu/compiler.h>
  42 #include <urcu/hlist.h>
  43 #include <urcu/list.h>
  44 #include <urcu/uatomic.h>
  45
  46 #include <lttng/tracepoint.h>
  47 #include <lttng/ust-events.h>
  48
  49 #include <usterr-signal-safe.h>
  50 #include <helper.h>
  51 #include <lttng/ust-ctl.h>
  52 #include <ust-comm.h>
  53 #include <ust-fd.h>
  54 #include <lttng/ust-dynamic-type.h>
  55 #include <lttng/ust-context-provider.h>
  56 #include "error.h"
  57 #include "compat.h"
  58 #include "lttng-ust-uuid.h"
  59
  60 #include "tracepoint-internal.h"
  61 #include "string-utils.h"
  62 #include "lttng-bytecode.h"
  63 #include "lttng-tracer.h"
  64 #include "lttng-tracer-core.h"
  65 #include "lttng-ust-statedump.h"
  66 #include "context-internal.h"
  67 #include "ust-events-internal.h"
  68 #include "wait.h"
  69 #include "../libringbuffer/shm.h"
  70 #include "jhash.h"
  71 #include <lttng/ust-abi.h>
  72
  73 /*
  74  * All operations within this file are called by the communication
  75  * thread, under ust_lock protection.
  76  */
  77
  78 static CDS_LIST_HEAD(sessions);
  79 static CDS_LIST_HEAD(event_notifier_groups);
  80
  81 struct cds_list_head *_lttng_get_sessions(void)
  82 {
  83         return &sessions;
  84 }
  85
  86 static void _lttng_event_destroy(struct lttng_event *event);
  87 static void _lttng_event_notifier_destroy(
  88                 struct lttng_event_notifier *event_notifier);
  89 static void _lttng_enum_destroy(struct lttng_enum *_enum);
  90
  91 static
  92 void lttng_session_lazy_sync_event_enablers(struct lttng_session *session);
  93 static
  94 void lttng_session_sync_event_enablers(struct lttng_session *session);
  95 static
  96 void lttng_event_notifier_group_sync_enablers(
  97                 struct lttng_event_notifier_group *event_notifier_group);
  98 static
  99 void lttng_enabler_destroy(struct lttng_enabler *enabler);
 100
 101 /*
 102  * Called with ust lock held.
 103  */
 104 int lttng_session_active(void)
 105 {
 106         struct lttng_session *iter;
 107
 108         cds_list_for_each_entry(iter, &sessions, node) {
 109                 if (iter->active)
 110                         return 1;
 111         }
 112         return 0;
 113 }
 114
 115 static
 116 int lttng_loglevel_match(int loglevel,
 117                 unsigned int has_loglevel,
 118                 enum lttng_ust_loglevel_type req_type,
 119                 int req_loglevel)
 120 {
 121         if (!has_loglevel)
 122                 loglevel = TRACE_DEFAULT;
 123         switch (req_type) {
 124         case LTTNG_UST_LOGLEVEL_RANGE:
 125                 if (loglevel <= req_loglevel
 126                                 || (req_loglevel == -1 && loglevel <= TRACE_DEBUG))
 127                         return 1;
 128                 else
 129                         return 0;
 130         case LTTNG_UST_LOGLEVEL_SINGLE:
 131                 if (loglevel == req_loglevel
 132                                 || (req_loglevel == -1 && loglevel <= TRACE_DEBUG))
 133                         return 1;
 134                 else
 135                         return 0;
 136         case LTTNG_UST_LOGLEVEL_ALL:
 137         default:
 138                 if (loglevel <= TRACE_DEBUG)
 139                         return 1;
 140                 else
 141                         return 0;
 142         }
 143 }
 144
 145 void synchronize_trace(void)
 146 {
 147         synchronize_rcu();
 148 }
 149
 150 struct lttng_session *lttng_session_create(void)
 151 {
 152         struct lttng_session *session;
 153         int i;
 154
 155         session = zmalloc(sizeof(struct lttng_session));
 156         if (!session)
 157                 return NULL;
 158         if (lttng_context_init_all(&session->ctx)) {
 159                 free(session);
 160                 return NULL;
 161         }
 162         CDS_INIT_LIST_HEAD(&session->chan_head);
 163         CDS_INIT_LIST_HEAD(&session->events_head);
 164         CDS_INIT_LIST_HEAD(&session->enums_head);
 165         CDS_INIT_LIST_HEAD(&session->enablers_head);
 166         for (i = 0; i < LTTNG_UST_EVENT_HT_SIZE; i++)
 167                 CDS_INIT_HLIST_HEAD(&session->events_ht.table[i]);
 168         for (i = 0; i < LTTNG_UST_ENUM_HT_SIZE; i++)
 169                 CDS_INIT_HLIST_HEAD(&session->enums_ht.table[i]);
 170         cds_list_add(&session->node, &sessions);
 171         return session;
 172 }
 173
 174 struct lttng_event_notifier_group *lttng_event_notifier_group_create(void)
 175 {
 176         struct lttng_event_notifier_group *event_notifier_group;
 177         int i;
 178
 179         event_notifier_group = zmalloc(sizeof(struct lttng_event_notifier_group));
 180         if (!event_notifier_group)
 181                 return NULL;
 182
 183         /* Add all contexts. */
 184         if (lttng_context_init_all(&event_notifier_group->ctx)) {
 185                 free(event_notifier_group);
 186                 return NULL;
 187         }
 188
 189         CDS_INIT_LIST_HEAD(&event_notifier_group->enablers_head);
 190         CDS_INIT_LIST_HEAD(&event_notifier_group->event_notifiers_head);
 191         for (i = 0; i < LTTNG_UST_EVENT_NOTIFIER_HT_SIZE; i++)
 192                 CDS_INIT_HLIST_HEAD(&event_notifier_group->event_notifiers_ht.table[i]);
 193
 194         cds_list_add(&event_notifier_group->node, &event_notifier_groups);
 195
 196         return event_notifier_group;
 197 }
 198
 199 /*
 200  * Only used internally at session destruction.
 201  */
 202 static
 203 void _lttng_channel_unmap(struct lttng_channel *lttng_chan)
 204 {
 205         struct channel *chan;
 206         struct lttng_ust_shm_handle *handle;
 207
 208         cds_list_del(&lttng_chan->node);
 209         lttng_destroy_context(lttng_chan->ctx);
 210         chan = lttng_chan->chan;
 211         handle = lttng_chan->handle;
 212         /*
 213          * note: lttng_chan is private data contained within handle. It
 214          * will be freed along with the handle.
 215          */
 216         channel_destroy(chan, handle, 0);
 217 }
 218
 219 static
 220 void register_event(struct lttng_event *event)
 221 {
 222         int ret;
 223         const struct lttng_event_desc *desc;
 224
 225         assert(event->registered == 0);
 226         desc = event->desc;
 227         ret = __tracepoint_probe_register_queue_release(desc->name,
 228                         desc->probe_callback,
 229                         event, desc->signature);
 230         WARN_ON_ONCE(ret);
 231         if (!ret)
 232                 event->registered = 1;
 233 }
 234
 235 static
 236 void register_event_notifier(struct lttng_event_notifier *event_notifier)
 237 {
 238         int ret;
 239         const struct lttng_event_desc *desc;
 240
 241         assert(event_notifier->registered == 0);
 242         desc = event_notifier->desc;
 243         ret = __tracepoint_probe_register_queue_release(desc->name,
 244                 desc->u.ext.event_notifier_callback, event_notifier, desc->signature);
 245         WARN_ON_ONCE(ret);
 246         if (!ret)
 247                 event_notifier->registered = 1;
 248 }
 249
 250 static
 251 void unregister_event(struct lttng_event *event)
 252 {
 253         int ret;
 254         const struct lttng_event_desc *desc;
 255
 256         assert(event->registered == 1);
 257         desc = event->desc;
 258         ret = __tracepoint_probe_unregister_queue_release(desc->name,
 259                         desc->probe_callback,
 260                         event);
 261         WARN_ON_ONCE(ret);
 262         if (!ret)
 263                 event->registered = 0;
 264 }
 265
 266 static
 267 void unregister_event_notifier(struct lttng_event_notifier *event_notifier)
 268 {
 269         int ret;
 270         const struct lttng_event_desc *desc;
 271
 272         assert(event_notifier->registered == 1);
 273         desc = event_notifier->desc;
 274         ret = __tracepoint_probe_unregister_queue_release(desc->name,
 275                 desc->u.ext.event_notifier_callback, event_notifier);
 276         WARN_ON_ONCE(ret);
 277         if (!ret)
 278                 event_notifier->registered = 0;
 279 }
 280
 281 /*
 282  * Only used internally at session destruction.
 283  */
 284 static
 285 void _lttng_event_unregister(struct lttng_event *event)
 286 {
 287         if (event->registered)
 288                 unregister_event(event);
 289 }
 290
 291 /*
 292  * Only used internally at session destruction.
 293  */
 294 static
 295 void _lttng_event_notifier_unregister(struct lttng_event_notifier *event_notifier)
 296 {
 297         if (event_notifier->registered)
 298                 unregister_event_notifier(event_notifier);
 299 }
 300
 301 void lttng_session_destroy(struct lttng_session *session)
 302 {
 303         struct lttng_channel *chan, *tmpchan;
 304         struct lttng_event *event, *tmpevent;
 305         struct lttng_enum *_enum, *tmp_enum;
 306         struct lttng_event_enabler *event_enabler, *event_tmpenabler;
 307
 308         CMM_ACCESS_ONCE(session->active) = 0;
 309         cds_list_for_each_entry(event, &session->events_head, node) {
 310                 _lttng_event_unregister(event);
 311         }
 312         synchronize_trace();    /* Wait for in-flight events to complete */
 313         __tracepoint_probe_prune_release_queue();
 314         cds_list_for_each_entry_safe(event_enabler, event_tmpenabler,
 315                         &session->enablers_head, node)
 316                 lttng_event_enabler_destroy(event_enabler);
 317         cds_list_for_each_entry_safe(event, tmpevent,
 318                         &session->events_head, node)
 319                 _lttng_event_destroy(event);
 320         cds_list_for_each_entry_safe(_enum, tmp_enum,
 321                         &session->enums_head, node)
 322                 _lttng_enum_destroy(_enum);
 323         cds_list_for_each_entry_safe(chan, tmpchan, &session->chan_head, node)
 324                 _lttng_channel_unmap(chan);
 325         cds_list_del(&session->node);
 326         lttng_destroy_context(session->ctx);
 327         free(session);
 328 }
 329
 330 void lttng_event_notifier_group_destroy(
 331                 struct lttng_event_notifier_group *event_notifier_group)
 332 {
 333         int close_ret;
 334         struct lttng_event_notifier_enabler *notifier_enabler, *tmpnotifier_enabler;
 335         struct lttng_event_notifier *notifier, *tmpnotifier;
 336
 337         if (!event_notifier_group) {
 338                 return;
 339         }
 340
 341         cds_list_for_each_entry(notifier,
 342                         &event_notifier_group->event_notifiers_head, node)
 343                 _lttng_event_notifier_unregister(notifier);
 344
 345         synchronize_trace();
 346
 347         cds_list_for_each_entry_safe(notifier_enabler, tmpnotifier_enabler,
 348                         &event_notifier_group->enablers_head, node)
 349                 lttng_event_notifier_enabler_destroy(notifier_enabler);
 350
 351         cds_list_for_each_entry_safe(notifier, tmpnotifier,
 352                         &event_notifier_group->event_notifiers_head, node)
 353                 _lttng_event_notifier_destroy(notifier);
 354
 355         /* Close the notification fd to the listener of event notifiers. */
 356
 357         lttng_ust_lock_fd_tracker();
 358         close_ret = close(event_notifier_group->notification_fd);
 359         if (!close_ret) {
 360                 lttng_ust_delete_fd_from_tracker(
 361                                 event_notifier_group->notification_fd);
 362         } else {
 363                 PERROR("close");
 364                 abort();
 365         }
 366         lttng_ust_unlock_fd_tracker();
 367
 368         cds_list_del(&event_notifier_group->node);
 369
 370         free(event_notifier_group);
 371 }
 372
 373 static
 374 void lttng_enabler_destroy(struct lttng_enabler *enabler)
 375 {
 376         struct lttng_ust_bytecode_node *filter_node, *tmp_filter_node;
 377         struct lttng_ust_excluder_node *excluder_node, *tmp_excluder_node;
 378
 379         if (!enabler) {
 380                 return;
 381         }
 382
 383         /* Destroy filter bytecode */
 384         cds_list_for_each_entry_safe(filter_node, tmp_filter_node,
 385                         &enabler->filter_bytecode_head, node) {
 386                 free(filter_node);
 387         }
 388
 389         /* Destroy excluders */
 390         cds_list_for_each_entry_safe(excluder_node, tmp_excluder_node,
 391                         &enabler->excluder_head, node) {
 392                 free(excluder_node);
 393         }
 394 }
 395
 396  void lttng_event_notifier_enabler_destroy(struct lttng_event_notifier_enabler *event_notifier_enabler)
 397 {
 398         if (!event_notifier_enabler) {
 399                 return;
 400         }
 401
 402         cds_list_del(&event_notifier_enabler->node);
 403
 404         lttng_enabler_destroy(lttng_event_notifier_enabler_as_enabler(event_notifier_enabler));
 405
 406         free(event_notifier_enabler);
 407 }
 408
 409 static
 410 int lttng_enum_create(const struct lttng_enum_desc *desc,
 411                 struct lttng_session *session)
 412 {
 413         const char *enum_name = desc->name;
 414         struct lttng_enum *_enum;
 415         struct cds_hlist_head *head;
 416         int ret = 0;
 417         size_t name_len = strlen(enum_name);
 418         uint32_t hash;
 419         int notify_socket;
 420
 421         /* Check if this enum is already registered for this session. */
 422         hash = jhash(enum_name, name_len, 0);
 423         head = &session->enums_ht.table[hash & (LTTNG_UST_ENUM_HT_SIZE - 1)];
 424
 425         _enum = lttng_ust_enum_get_from_desc(session, desc);
 426         if (_enum) {
 427                 ret = -EEXIST;
 428                 goto exist;
 429         }
 430
 431         notify_socket = lttng_get_notify_socket(session->owner);
 432         if (notify_socket < 0) {
 433                 ret = notify_socket;
 434                 goto socket_error;
 435         }
 436
 437         _enum = zmalloc(sizeof(*_enum));
 438         if (!_enum) {
 439                 ret = -ENOMEM;
 440                 goto cache_error;
 441         }
 442         _enum->session = session;
 443         _enum->desc = desc;
 444
 445         ret = ustcomm_register_enum(notify_socket,
 446                 session->objd,
 447                 enum_name,
 448                 desc->nr_entries,
 449                 desc->entries,
 450                 &_enum->id);
 451         if (ret < 0) {
 452                 DBG("Error (%d) registering enumeration to sessiond", ret);
 453                 goto sessiond_register_error;
 454         }
 455         cds_list_add(&_enum->node, &session->enums_head);
 456         cds_hlist_add_head(&_enum->hlist, head);
 457         return 0;
 458
 459 sessiond_register_error:
 460         free(_enum);
 461 cache_error:
 462 socket_error:
 463 exist:
 464         return ret;
 465 }
 466
 467 static
 468 int lttng_create_enum_check(const struct lttng_type *type,
 469                 struct lttng_session *session)
 470 {
 471         switch (type->atype) {
 472         case atype_enum:
 473         {
 474                 const struct lttng_enum_desc *enum_desc;
 475                 int ret;
 476
 477                 enum_desc = type->u.legacy.basic.enumeration.desc;
 478                 ret = lttng_enum_create(enum_desc, session);
 479                 if (ret && ret != -EEXIST) {
 480                         DBG("Unable to create enum error: (%d)", ret);
 481                         return ret;
 482                 }
 483                 break;
 484         }
 485         case atype_enum_nestable:
 486         {
 487                 const struct lttng_enum_desc *enum_desc;
 488                 int ret;
 489
 490                 enum_desc = type->u.enum_nestable.desc;
 491                 ret = lttng_enum_create(enum_desc, session);
 492                 if (ret && ret != -EEXIST) {
 493                         DBG("Unable to create enum error: (%d)", ret);
 494                         return ret;
 495                 }
 496                 break;
 497         }
 498         case atype_dynamic:
 499         {
 500                 const struct lttng_event_field *tag_field_generic;
 501                 const struct lttng_enum_desc *enum_desc;
 502                 int ret;
 503
 504                 tag_field_generic = lttng_ust_dynamic_type_tag_field();
 505                 enum_desc = tag_field_generic->type.u.enum_nestable.desc;
 506                 ret = lttng_enum_create(enum_desc, session);
 507                 if (ret && ret != -EEXIST) {
 508                         DBG("Unable to create enum error: (%d)", ret);
 509                         return ret;
 510                 }
 511                 break;
 512         }
 513         default:
 514                 /* TODO: nested types when they become supported. */
 515                 break;
 516         }
 517         return 0;
 518 }
 519
 520 static
 521 int lttng_create_all_event_enums(size_t nr_fields,
 522                 const struct lttng_event_field *event_fields,
 523                 struct lttng_session *session)
 524 {
 525         size_t i;
 526         int ret;
 527
 528         /* For each field, ensure enum is part of the session. */
 529         for (i = 0; i < nr_fields; i++) {
 530                 const struct lttng_type *type = &event_fields[i].type;
 531
 532                 ret = lttng_create_enum_check(type, session);
 533                 if (ret)
 534                         return ret;
 535         }
 536         return 0;
 537 }
 538
 539 static
 540 int lttng_create_all_ctx_enums(size_t nr_fields,
 541                 const struct lttng_ctx_field *ctx_fields,
 542                 struct lttng_session *session)
 543 {
 544         size_t i;
 545         int ret;
 546
 547         /* For each field, ensure enum is part of the session. */
 548         for (i = 0; i < nr_fields; i++) {
 549                 const struct lttng_type *type = &ctx_fields[i].event_field.type;
 550
 551                 ret = lttng_create_enum_check(type, session);
 552                 if (ret)
 553                         return ret;
 554         }
 555         return 0;
 556 }
 557
 558 /*
 559  * Ensure that a state-dump will be performed for this session at the end
 560  * of the current handle_message().
 561  */
 562 int lttng_session_statedump(struct lttng_session *session)
 563 {
 564         session->statedump_pending = 1;
 565         lttng_ust_sockinfo_session_enabled(session->owner);
 566         return 0;
 567 }
 568
 569 int lttng_session_enable(struct lttng_session *session)
 570 {
 571         int ret = 0;
 572         struct lttng_channel *chan;
 573         int notify_socket;
 574
 575         if (session->active) {
 576                 ret = -EBUSY;
 577                 goto end;
 578         }
 579
 580         notify_socket = lttng_get_notify_socket(session->owner);
 581         if (notify_socket < 0)
 582                 return notify_socket;
 583
 584         /* Set transient enabler state to "enabled" */
 585         session->tstate = 1;
 586
 587         /* We need to sync enablers with session before activation. */
 588         lttng_session_sync_event_enablers(session);
 589
 590         /*
 591          * Snapshot the number of events per channel to know the type of header
 592          * we need to use.
 593          */
 594         cds_list_for_each_entry(chan, &session->chan_head, node) {
 595                 const struct lttng_ctx *ctx;
 596                 const struct lttng_ctx_field *fields = NULL;
 597                 size_t nr_fields = 0;
 598                 uint32_t chan_id;
 599
 600                 /* don't change it if session stop/restart */
 601                 if (chan->header_type)
 602                         continue;
 603                 ctx = chan->ctx;
 604                 if (ctx) {
 605                         nr_fields = ctx->nr_fields;
 606                         fields = ctx->fields;
 607                         ret = lttng_create_all_ctx_enums(nr_fields, fields,
 608                                 session);
 609                         if (ret < 0) {
 610                                 DBG("Error (%d) adding enum to session", ret);
 611                                 return ret;
 612                         }
 613                 }
 614                 ret = ustcomm_register_channel(notify_socket,
 615                         session,
 616                         session->objd,
 617                         chan->objd,
 618                         nr_fields,
 619                         fields,
 620                         &chan_id,
 621                         &chan->header_type);
 622                 if (ret) {
 623                         DBG("Error (%d) registering channel to sessiond", ret);
 624                         return ret;
 625                 }
 626                 if (chan_id != chan->id) {
 627                         DBG("Error: channel registration id (%u) does not match id assigned at creation (%u)",
 628                                 chan_id, chan->id);
 629                         return -EINVAL;
 630                 }
 631         }
 632
 633         /* Set atomically the state to "active" */
 634         CMM_ACCESS_ONCE(session->active) = 1;
 635         CMM_ACCESS_ONCE(session->been_active) = 1;
 636
 637         ret = lttng_session_statedump(session);
 638         if (ret)
 639                 return ret;
 640 end:
 641         return ret;
 642 }
 643
 644 int lttng_session_disable(struct lttng_session *session)
 645 {
 646         int ret = 0;
 647
 648         if (!session->active) {
 649                 ret = -EBUSY;
 650                 goto end;
 651         }
 652         /* Set atomically the state to "inactive" */
 653         CMM_ACCESS_ONCE(session->active) = 0;
 654
 655         /* Set transient enabler state to "disabled" */
 656         session->tstate = 0;
 657         lttng_session_sync_event_enablers(session);
 658 end:
 659         return ret;
 660 }
 661
 662 int lttng_channel_enable(struct lttng_channel *channel)
 663 {
 664         int ret = 0;
 665
 666         if (channel->enabled) {
 667                 ret = -EBUSY;
 668                 goto end;
 669         }
 670         /* Set transient enabler state to "enabled" */
 671         channel->tstate = 1;
 672         lttng_session_sync_event_enablers(channel->session);
 673         /* Set atomically the state to "enabled" */
 674         CMM_ACCESS_ONCE(channel->enabled) = 1;
 675 end:
 676         return ret;
 677 }
 678
 679 int lttng_channel_disable(struct lttng_channel *channel)
 680 {
 681         int ret = 0;
 682
 683         if (!channel->enabled) {
 684                 ret = -EBUSY;
 685                 goto end;
 686         }
 687         /* Set atomically the state to "disabled" */
 688         CMM_ACCESS_ONCE(channel->enabled) = 0;
 689         /* Set transient enabler state to "enabled" */
 690         channel->tstate = 0;
 691         lttng_session_sync_event_enablers(channel->session);
 692 end:
 693         return ret;
 694 }
 695
 696 static inline
 697 struct cds_hlist_head *borrow_hash_table_bucket(
 698                 struct cds_hlist_head *hash_table,
 699                 unsigned int hash_table_size,
 700                 const struct lttng_event_desc *desc)
 701 {
 702         const char *event_name;
 703         size_t name_len;
 704         uint32_t hash;
 705
 706         event_name = desc->name;
 707         name_len = strlen(event_name);
 708
 709         hash = jhash(event_name, name_len, 0);
 710         return &hash_table[hash & (hash_table_size - 1)];
 711 }
 712
 713 /*
 714  * Supports event creation while tracing session is active.
 715  */
 716 static
 717 int lttng_event_create(const struct lttng_event_desc *desc,
 718                 struct lttng_channel *chan)
 719 {
 720         struct lttng_event *event;
 721         struct lttng_session *session = chan->session;
 722         struct cds_hlist_head *head;
 723         int ret = 0;
 724         int notify_socket, loglevel;
 725         const char *uri;
 726
 727         head = borrow_hash_table_bucket(chan->session->events_ht.table,
 728                 LTTNG_UST_EVENT_HT_SIZE, desc);
 729
 730         notify_socket = lttng_get_notify_socket(session->owner);
 731         if (notify_socket < 0) {
 732                 ret = notify_socket;
 733                 goto socket_error;
 734         }
 735
 736         ret = lttng_create_all_event_enums(desc->nr_fields, desc->fields,
 737                         session);
 738         if (ret < 0) {
 739                 DBG("Error (%d) adding enum to session", ret);
 740                 goto create_enum_error;
 741         }
 742
 743         /*
 744          * Check if loglevel match. Refuse to connect event if not.
 745          */
 746         event = zmalloc(sizeof(struct lttng_event));
 747         if (!event) {
 748                 ret = -ENOMEM;
 749                 goto cache_error;
 750         }
 751         event->chan = chan;
 752
 753         /* Event will be enabled by enabler sync. */
 754         event->enabled = 0;
 755         event->registered = 0;
 756         CDS_INIT_LIST_HEAD(&event->filter_bytecode_runtime_head);
 757         CDS_INIT_LIST_HEAD(&event->enablers_ref_head);
 758         event->desc = desc;
 759
 760         if (desc->loglevel)
 761                 loglevel = *(*event->desc->loglevel);
 762         else
 763                 loglevel = TRACE_DEFAULT;
 764         if (desc->u.ext.model_emf_uri)
 765                 uri = *(desc->u.ext.model_emf_uri);
 766         else
 767                 uri = NULL;
 768
 769         /* Fetch event ID from sessiond */
 770         ret = ustcomm_register_event(notify_socket,
 771                 session,
 772                 session->objd,
 773                 chan->objd,
 774                 desc->name,
 775                 loglevel,
 776                 desc->signature,
 777                 desc->nr_fields,
 778                 desc->fields,
 779                 uri,
 780                 &event->id);
 781         if (ret < 0) {
 782                 DBG("Error (%d) registering event to sessiond", ret);
 783                 goto sessiond_register_error;
 784         }
 785
 786         cds_list_add(&event->node, &chan->session->events_head);
 787         cds_hlist_add_head(&event->hlist, head);
 788         return 0;
 789
 790 sessiond_register_error:
 791         free(event);
 792 cache_error:
 793 create_enum_error:
 794 socket_error:
 795         return ret;
 796 }
 797
 798 static
 799 int lttng_event_notifier_create(const struct lttng_event_desc *desc,
 800                 uint64_t token,
 801                 struct lttng_event_notifier_group *event_notifier_group)
 802 {
 803         struct lttng_event_notifier *event_notifier;
 804         struct cds_hlist_head *head;
 805         int ret = 0;
 806
 807         /*
 808          * Get the hashtable bucket the created lttng_event_notifier object
 809          * should be inserted.
 810          */
 811         head = borrow_hash_table_bucket(
 812                 event_notifier_group->event_notifiers_ht.table,
 813                 LTTNG_UST_EVENT_NOTIFIER_HT_SIZE, desc);
 814
 815         event_notifier = zmalloc(sizeof(struct lttng_event_notifier));
 816         if (!event_notifier) {
 817                 ret = -ENOMEM;
 818                 goto error;
 819         }
 820
 821         event_notifier->group = event_notifier_group;
 822         event_notifier->user_token = token;
 823
 824         /* Event notifier will be enabled by enabler sync. */
 825         event_notifier->enabled = 0;
 826         event_notifier->registered = 0;
 827
 828         CDS_INIT_LIST_HEAD(&event_notifier->filter_bytecode_runtime_head);
 829         CDS_INIT_LIST_HEAD(&event_notifier->enablers_ref_head);
 830         event_notifier->desc = desc;
 831
 832         cds_list_add(&event_notifier->node,
 833                         &event_notifier_group->event_notifiers_head);
 834         cds_hlist_add_head(&event_notifier->hlist, head);
 835
 836         return 0;
 837
 838 error:
 839         return ret;
 840 }
 841
 842 static
 843 void _lttng_event_notifier_destroy(struct lttng_event_notifier *event_notifier)
 844 {
 845         struct lttng_enabler_ref *enabler_ref, *tmp_enabler_ref;
 846
 847         /* Remove from event_notifier list. */
 848         cds_list_del(&event_notifier->node);
 849         /* Remove from event_notifier hash table. */
 850         cds_hlist_del(&event_notifier->hlist);
 851
 852         lttng_free_event_notifier_filter_runtime(event_notifier);
 853
 854         /* Free event_notifier enabler refs */
 855         cds_list_for_each_entry_safe(enabler_ref, tmp_enabler_ref,
 856                         &event_notifier->enablers_ref_head, node)
 857                 free(enabler_ref);
 858         free(event_notifier);
 859 }
 860
 861 static
 862 int lttng_desc_match_star_glob_enabler(const struct lttng_event_desc *desc,
 863                 struct lttng_enabler *enabler)
 864 {
 865         int loglevel = 0;
 866         unsigned int has_loglevel = 0;
 867
 868         assert(enabler->format_type == LTTNG_ENABLER_FORMAT_STAR_GLOB);
 869         if (!strutils_star_glob_match(enabler->event_param.name, SIZE_MAX,
 870                         desc->name, SIZE_MAX))
 871                 return 0;
 872         if (desc->loglevel) {
 873                 loglevel = *(*desc->loglevel);
 874                 has_loglevel = 1;
 875         }
 876         if (!lttng_loglevel_match(loglevel,
 877                         has_loglevel,
 878                         enabler->event_param.loglevel_type,
 879                         enabler->event_param.loglevel))
 880                 return 0;
 881         return 1;
 882 }
 883
 884 static
 885 int lttng_desc_match_event_enabler(const struct lttng_event_desc *desc,
 886                 struct lttng_enabler *enabler)
 887 {
 888         int loglevel = 0;
 889         unsigned int has_loglevel = 0;
 890
 891         assert(enabler->format_type == LTTNG_ENABLER_FORMAT_EVENT);
 892         if (strcmp(desc->name, enabler->event_param.name))
 893                 return 0;
 894         if (desc->loglevel) {
 895                 loglevel = *(*desc->loglevel);
 896                 has_loglevel = 1;
 897         }
 898         if (!lttng_loglevel_match(loglevel,
 899                         has_loglevel,
 900                         enabler->event_param.loglevel_type,
 901                         enabler->event_param.loglevel))
 902                 return 0;
 903         return 1;
 904 }
 905
 906 static
 907 int lttng_desc_match_enabler(const struct lttng_event_desc *desc,
 908                 struct lttng_enabler *enabler)
 909 {
 910         switch (enabler->format_type) {
 911         case LTTNG_ENABLER_FORMAT_STAR_GLOB:
 912         {
 913                 struct lttng_ust_excluder_node *excluder;
 914
 915                 if (!lttng_desc_match_star_glob_enabler(desc, enabler)) {
 916                         return 0;
 917                 }
 918
 919                 /*
 920                  * If the matching event matches with an excluder,
 921                  * return 'does not match'
 922                  */
 923                 cds_list_for_each_entry(excluder, &enabler->excluder_head, node) {
 924                         int count;
 925
 926                         for (count = 0; count < excluder->excluder.count; count++) {
 927                                 int len;
 928                                 char *excluder_name;
 929
 930                                 excluder_name = (char *) (excluder->excluder.names)
 931                                                 + count * LTTNG_UST_SYM_NAME_LEN;
 932                                 len = strnlen(excluder_name, LTTNG_UST_SYM_NAME_LEN);
 933                                 if (len > 0 && strutils_star_glob_match(excluder_name, len, desc->name, SIZE_MAX))
 934                                         return 0;
 935                         }
 936                 }
 937                 return 1;
 938         }
 939         case LTTNG_ENABLER_FORMAT_EVENT:
 940                 return lttng_desc_match_event_enabler(desc, enabler);
 941         default:
 942                 return -EINVAL;
 943         }
 944 }
 945
 946 static
 947 int lttng_event_enabler_match_event(struct lttng_event_enabler *event_enabler,
 948                 struct lttng_event *event)
 949 {
 950         if (lttng_desc_match_enabler(event->desc,
 951                         lttng_event_enabler_as_enabler(event_enabler))
 952                         && event->chan == event_enabler->chan)
 953                 return 1;
 954         else
 955                 return 0;
 956 }
 957
 958 static
 959 int lttng_event_notifier_enabler_match_event_notifier(
 960                 struct lttng_event_notifier_enabler *event_notifier_enabler,
 961                 struct lttng_event_notifier *event_notifier)
 962 {
 963         int desc_matches = lttng_desc_match_enabler(event_notifier->desc,
 964                 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler));
 965
 966         if (desc_matches && event_notifier->group == event_notifier_enabler->group &&
 967                         event_notifier->user_token == event_notifier_enabler->user_token)
 968                 return 1;
 969         else
 970                 return 0;
 971 }
 972
 973 static
 974 struct lttng_enabler_ref *lttng_enabler_ref(
 975                 struct cds_list_head *enabler_ref_list,
 976                 struct lttng_enabler *enabler)
 977 {
 978         struct lttng_enabler_ref *enabler_ref;
 979
 980         cds_list_for_each_entry(enabler_ref, enabler_ref_list, node) {
 981                 if (enabler_ref->ref == enabler)
 982                         return enabler_ref;
 983         }
 984         return NULL;
 985 }
 986
 987 /*
 988  * Create struct lttng_event if it is missing and present in the list of
 989  * tracepoint probes.
 990  */
 991 static
 992 void lttng_create_event_if_missing(struct lttng_event_enabler *event_enabler)
 993 {
 994         struct lttng_session *session = event_enabler->chan->session;
 995         struct lttng_probe_desc *probe_desc;
 996         const struct lttng_event_desc *desc;
 997         struct lttng_event *event;
 998         int i;
 999         struct cds_list_head *probe_list;
1000
1001         probe_list = lttng_get_probe_list_head();
1002         /*
1003          * For each probe event, if we find that a probe event matches
1004          * our enabler, create an associated lttng_event if not
1005          * already present.
1006          */
1007         cds_list_for_each_entry(probe_desc, probe_list, head) {
1008                 for (i = 0; i < probe_desc->nr_events; i++) {
1009                         int ret;
1010                         bool found = false;
1011                         struct cds_hlist_head *head;
1012                         struct cds_hlist_node *node;
1013
1014                         desc = probe_desc->event_desc[i];
1015                         if (!lttng_desc_match_enabler(desc,
1016                                         lttng_event_enabler_as_enabler(event_enabler)))
1017                                 continue;
1018
1019                         head = borrow_hash_table_bucket(
1020                                 session->events_ht.table,
1021                                 LTTNG_UST_EVENT_HT_SIZE, desc);
1022
1023                         cds_hlist_for_each_entry(event, node, head, hlist) {
1024                                 if (event->desc == desc
1025                                                 && event->chan == event_enabler->chan) {
1026                                         found = true;
1027                                         break;
1028                                 }
1029                         }
1030                         if (found)
1031                                 continue;
1032
1033                         /*
1034                          * We need to create an event for this
1035                          * event probe.
1036                          */
1037                         ret = lttng_event_create(probe_desc->event_desc[i],
1038                                         event_enabler->chan);
1039                         if (ret) {
1040                                 DBG("Unable to create event %s, error %d\n",
1041                                         probe_desc->event_desc[i]->name, ret);
1042                         }
1043                 }
1044         }
1045 }
1046
1047 static
1048 void probe_provider_event_for_each(struct lttng_probe_desc *provider_desc,
1049                 void (*event_func)(struct lttng_session *session,
1050                         struct lttng_event *event),
1051                 void (*event_notifier_func)(struct lttng_event_notifier *event_notifier))
1052 {
1053         struct cds_hlist_node *node, *tmp_node;
1054         struct cds_list_head *sessionsp;
1055         unsigned int i;
1056
1057         /* Get handle on list of sessions. */
1058         sessionsp = _lttng_get_sessions();
1059
1060         /*
1061          * Iterate over all events in the probe provider descriptions and
1062          * sessions to queue the unregistration of the events.
1063          */
1064         for (i = 0; i < provider_desc->nr_events; i++) {
1065                 const struct lttng_event_desc *event_desc;
1066                 struct lttng_event_notifier_group *event_notifier_group;
1067                 struct lttng_event_notifier *event_notifier;
1068                 struct lttng_session *session;
1069                 struct cds_hlist_head *head;
1070                 struct lttng_event *event;
1071
1072                 event_desc = provider_desc->event_desc[i];
1073
1074                 /*
1075                  * Iterate over all session to find the current event
1076                  * description.
1077                  */
1078                 cds_list_for_each_entry(session, sessionsp, node) {
1079                         /*
1080                          * Get the list of events in the hashtable bucket and
1081                          * iterate to find the event matching this descriptor.
1082                          */
1083                         head = borrow_hash_table_bucket(
1084                                 session->events_ht.table,
1085                                 LTTNG_UST_EVENT_HT_SIZE, event_desc);
1086
1087                         cds_hlist_for_each_entry_safe(event, node, tmp_node, head, hlist) {
1088                                 if (event_desc == event->desc) {
1089                                         event_func(session, event);
1090                                         break;
1091                                 }
1092                         }
1093                 }
1094
1095                 /*
1096                  * Iterate over all event_notifier groups to find the current event
1097                  * description.
1098                  */
1099                 cds_list_for_each_entry(event_notifier_group, &event_notifier_groups, node) {
1100                         /*
1101                          * Get the list of event_notifiers in the hashtable bucket and
1102                          * iterate to find the event_notifier matching this
1103                          * descriptor.
1104                          */
1105                         head = borrow_hash_table_bucket(
1106                                 event_notifier_group->event_notifiers_ht.table,
1107                                 LTTNG_UST_EVENT_NOTIFIER_HT_SIZE, event_desc);
1108
1109                         cds_hlist_for_each_entry_safe(event_notifier, node, tmp_node, head, hlist) {
1110                                 if (event_desc == event_notifier->desc) {
1111                                         event_notifier_func(event_notifier);
1112                                         break;
1113                                 }
1114                         }
1115                 }
1116         }
1117 }
1118
1119 static
1120 void _unregister_event(struct lttng_session *session,
1121                 struct lttng_event *event)
1122 {
1123         _lttng_event_unregister(event);
1124 }
1125
1126 static
1127 void _event_enum_destroy(struct lttng_session *session,
1128                 struct lttng_event *event)
1129 {
1130         unsigned int i;
1131
1132         /* Destroy enums of the current event. */
1133         for (i = 0; i < event->desc->nr_fields; i++) {
1134                 const struct lttng_enum_desc *enum_desc;
1135                 const struct lttng_event_field *field;
1136                 struct lttng_enum *curr_enum;
1137
1138                 field = &(event->desc->fields[i]);
1139                 switch (field->type.atype) {
1140                 case atype_enum:
1141                         enum_desc = field->type.u.legacy.basic.enumeration.desc;
1142                         break;
1143                 case atype_enum_nestable:
1144                         enum_desc = field->type.u.enum_nestable.desc;
1145                         break;
1146                 default:
1147                         continue;
1148                 }
1149
1150                 curr_enum = lttng_ust_enum_get_from_desc(session, enum_desc);
1151                 if (curr_enum) {
1152                         _lttng_enum_destroy(curr_enum);
1153                 }
1154         }
1155
1156         /* Destroy event. */
1157         _lttng_event_destroy(event);
1158 }
1159
1160 /*
1161  * Iterate over all the UST sessions to unregister and destroy all probes from
1162  * the probe provider descriptor received as argument. Must me called with the
1163  * ust_lock held.
1164  */
1165 void lttng_probe_provider_unregister_events(
1166                 struct lttng_probe_desc *provider_desc)
1167 {
1168         /*
1169          * Iterate over all events in the probe provider descriptions and sessions
1170          * to queue the unregistration of the events.
1171          */
1172         probe_provider_event_for_each(provider_desc, _unregister_event,
1173                 _lttng_event_notifier_unregister);
1174
1175         /* Wait for grace period. */
1176         synchronize_trace();
1177         /* Prune the unregistration queue. */
1178         __tracepoint_probe_prune_release_queue();
1179
1180         /*
1181          * It is now safe to destroy the events and remove them from the event list
1182          * and hashtables.
1183          */
1184         probe_provider_event_for_each(provider_desc, _event_enum_destroy,
1185                 _lttng_event_notifier_destroy);
1186 }
1187
1188 /*
1189  * Create events associated with an event enabler (if not already present),
1190  * and add backward reference from the event to the enabler.
1191  */
1192 static
1193 int lttng_event_enabler_ref_events(struct lttng_event_enabler *event_enabler)
1194 {
1195         struct lttng_session *session = event_enabler->chan->session;
1196         struct lttng_event *event;
1197
1198         if (!lttng_event_enabler_as_enabler(event_enabler)->enabled)
1199                 goto end;
1200
1201         /* First ensure that probe events are created for this enabler. */
1202         lttng_create_event_if_missing(event_enabler);
1203
1204         /* For each event matching enabler in session event list. */
1205         cds_list_for_each_entry(event, &session->events_head, node) {
1206                 struct lttng_enabler_ref *enabler_ref;
1207
1208                 if (!lttng_event_enabler_match_event(event_enabler, event))
1209                         continue;
1210
1211                 enabler_ref = lttng_enabler_ref(&event->enablers_ref_head,
1212                         lttng_event_enabler_as_enabler(event_enabler));
1213                 if (!enabler_ref) {
1214                         /*
1215                          * If no backward ref, create it.
1216                          * Add backward ref from event to enabler.
1217                          */
1218                         enabler_ref = zmalloc(sizeof(*enabler_ref));
1219                         if (!enabler_ref)
1220                                 return -ENOMEM;
1221                         enabler_ref->ref = lttng_event_enabler_as_enabler(
1222                                 event_enabler);
1223                         cds_list_add(&enabler_ref->node,
1224                                 &event->enablers_ref_head);
1225                 }
1226
1227                 /*
1228                  * Link filter bytecodes if not linked yet.
1229                  */
1230                 lttng_enabler_link_bytecode(event->desc,
1231                         &session->ctx,
1232                         &event->filter_bytecode_runtime_head,
1233                         &lttng_event_enabler_as_enabler(event_enabler)->filter_bytecode_head);
1234
1235                 /* TODO: merge event context. */
1236         }
1237 end:
1238         return 0;
1239 }
1240
1241 /*
1242  * Called at library load: connect the probe on all enablers matching
1243  * this event.
1244  * Called with session mutex held.
1245  */
1246 int lttng_fix_pending_events(void)
1247 {
1248         struct lttng_session *session;
1249
1250         cds_list_for_each_entry(session, &sessions, node) {
1251                 lttng_session_lazy_sync_event_enablers(session);
1252         }
1253         return 0;
1254 }
1255
1256 int lttng_fix_pending_event_notifiers(void)
1257 {
1258         struct lttng_event_notifier_group *event_notifier_group;
1259
1260         cds_list_for_each_entry(event_notifier_group, &event_notifier_groups, node) {
1261                 lttng_event_notifier_group_sync_enablers(event_notifier_group);
1262         }
1263         return 0;
1264 }
1265
1266 /*
1267  * For each session of the owner thread, execute pending statedump.
1268  * Only dump state for the sessions owned by the caller thread, because
1269  * we don't keep ust_lock across the entire iteration.
1270  */
1271 void lttng_handle_pending_statedump(void *owner)
1272 {
1273         struct lttng_session *session;
1274
1275         /* Execute state dump */
1276         do_lttng_ust_statedump(owner);
1277
1278         /* Clear pending state dump */
1279         if (ust_lock()) {
1280                 goto end;
1281         }
1282         cds_list_for_each_entry(session, &sessions, node) {
1283                 if (session->owner != owner)
1284                         continue;
1285                 if (!session->statedump_pending)
1286                         continue;
1287                 session->statedump_pending = 0;
1288         }
1289 end:
1290         ust_unlock();
1291         return;
1292 }
1293
1294 /*
1295  * Only used internally at session destruction.
1296  */
1297 static
1298 void _lttng_event_destroy(struct lttng_event *event)
1299 {
1300         struct lttng_enabler_ref *enabler_ref, *tmp_enabler_ref;
1301
1302         /* Remove from event list. */
1303         cds_list_del(&event->node);
1304         /* Remove from event hash table. */
1305         cds_hlist_del(&event->hlist);
1306
1307         lttng_destroy_context(event->ctx);
1308         lttng_free_event_filter_runtime(event);
1309         /* Free event enabler refs */
1310         cds_list_for_each_entry_safe(enabler_ref, tmp_enabler_ref,
1311                         &event->enablers_ref_head, node)
1312                 free(enabler_ref);
1313         free(event);
1314 }
1315
1316 static
1317 void _lttng_enum_destroy(struct lttng_enum *_enum)
1318 {
1319         cds_list_del(&_enum->node);
1320         cds_hlist_del(&_enum->hlist);
1321         free(_enum);
1322 }
1323
1324 void lttng_ust_events_exit(void)
1325 {
1326         struct lttng_session *session, *tmpsession;
1327
1328         cds_list_for_each_entry_safe(session, tmpsession, &sessions, node)
1329                 lttng_session_destroy(session);
1330 }
1331
1332 /*
1333  * Enabler management.
1334  */
1335 struct lttng_event_enabler *lttng_event_enabler_create(
1336                 enum lttng_enabler_format_type format_type,
1337                 struct lttng_ust_event *event_param,
1338                 struct lttng_channel *chan)
1339 {
1340         struct lttng_event_enabler *event_enabler;
1341
1342         event_enabler = zmalloc(sizeof(*event_enabler));
1343         if (!event_enabler)
1344                 return NULL;
1345         event_enabler->base.format_type = format_type;
1346         CDS_INIT_LIST_HEAD(&event_enabler->base.filter_bytecode_head);
1347         CDS_INIT_LIST_HEAD(&event_enabler->base.excluder_head);
1348         memcpy(&event_enabler->base.event_param, event_param,
1349                 sizeof(event_enabler->base.event_param));
1350         event_enabler->chan = chan;
1351         /* ctx left NULL */
1352         event_enabler->base.enabled = 0;
1353         cds_list_add(&event_enabler->node, &event_enabler->chan->session->enablers_head);
1354         lttng_session_lazy_sync_event_enablers(event_enabler->chan->session);
1355
1356         return event_enabler;
1357 }
1358
1359 struct lttng_event_notifier_enabler *lttng_event_notifier_enabler_create(
1360                 struct lttng_event_notifier_group *event_notifier_group,
1361                 enum lttng_enabler_format_type format_type,
1362                 struct lttng_ust_event_notifier *event_notifier_param)
1363 {
1364         struct lttng_event_notifier_enabler *event_notifier_enabler;
1365
1366         event_notifier_enabler = zmalloc(sizeof(*event_notifier_enabler));
1367         if (!event_notifier_enabler)
1368                 return NULL;
1369         event_notifier_enabler->base.format_type = format_type;
1370         CDS_INIT_LIST_HEAD(&event_notifier_enabler->base.filter_bytecode_head);
1371         CDS_INIT_LIST_HEAD(&event_notifier_enabler->base.excluder_head);
1372
1373         event_notifier_enabler->user_token = event_notifier_param->event.token;
1374
1375         memcpy(&event_notifier_enabler->base.event_param.name,
1376                 event_notifier_param->event.name,
1377                 sizeof(event_notifier_enabler->base.event_param.name));
1378         event_notifier_enabler->base.event_param.instrumentation =
1379                 event_notifier_param->event.instrumentation;
1380         event_notifier_enabler->base.event_param.loglevel =
1381                 event_notifier_param->event.loglevel;
1382         event_notifier_enabler->base.event_param.loglevel_type =
1383                 event_notifier_param->event.loglevel_type;
1384
1385         event_notifier_enabler->base.enabled = 0;
1386         event_notifier_enabler->group = event_notifier_group;
1387
1388         cds_list_add(&event_notifier_enabler->node,
1389                         &event_notifier_group->enablers_head);
1390
1391         lttng_event_notifier_group_sync_enablers(event_notifier_group);
1392
1393         return event_notifier_enabler;
1394 }
1395
1396 int lttng_event_enabler_enable(struct lttng_event_enabler *event_enabler)
1397 {
1398         lttng_event_enabler_as_enabler(event_enabler)->enabled = 1;
1399         lttng_session_lazy_sync_event_enablers(event_enabler->chan->session);
1400
1401         return 0;
1402 }
1403
1404 int lttng_event_enabler_disable(struct lttng_event_enabler *event_enabler)
1405 {
1406         lttng_event_enabler_as_enabler(event_enabler)->enabled = 0;
1407         lttng_session_lazy_sync_event_enablers(event_enabler->chan->session);
1408
1409         return 0;
1410 }
1411
1412 static
1413 void _lttng_enabler_attach_filter_bytecode(struct lttng_enabler *enabler,
1414                 struct lttng_ust_bytecode_node *bytecode)
1415 {
1416         bytecode->enabler = enabler;
1417         cds_list_add_tail(&bytecode->node, &enabler->filter_bytecode_head);
1418 }
1419
1420 int lttng_event_enabler_attach_filter_bytecode(struct lttng_event_enabler *event_enabler,
1421                 struct lttng_ust_bytecode_node *bytecode)
1422 {
1423         _lttng_enabler_attach_filter_bytecode(
1424                 lttng_event_enabler_as_enabler(event_enabler), bytecode);
1425
1426         lttng_session_lazy_sync_event_enablers(event_enabler->chan->session);
1427         return 0;
1428 }
1429
1430 static
1431 void _lttng_enabler_attach_exclusion(struct lttng_enabler *enabler,
1432                 struct lttng_ust_excluder_node *excluder)
1433 {
1434         excluder->enabler = enabler;
1435         cds_list_add_tail(&excluder->node, &enabler->excluder_head);
1436 }
1437
1438 int lttng_event_enabler_attach_exclusion(struct lttng_event_enabler *event_enabler,
1439                 struct lttng_ust_excluder_node *excluder)
1440 {
1441         _lttng_enabler_attach_exclusion(
1442                 lttng_event_enabler_as_enabler(event_enabler), excluder);
1443
1444         lttng_session_lazy_sync_event_enablers(event_enabler->chan->session);
1445         return 0;
1446 }
1447
1448 int lttng_event_notifier_enabler_enable(
1449                 struct lttng_event_notifier_enabler *event_notifier_enabler)
1450 {
1451         lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->enabled = 1;
1452         lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group);
1453
1454         return 0;
1455 }
1456
1457 int lttng_event_notifier_enabler_disable(
1458                 struct lttng_event_notifier_enabler *event_notifier_enabler)
1459 {
1460         lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->enabled = 0;
1461         lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group);
1462
1463         return 0;
1464 }
1465
1466 int lttng_event_notifier_enabler_attach_filter_bytecode(
1467                 struct lttng_event_notifier_enabler *event_notifier_enabler,
1468                 struct lttng_ust_bytecode_node *bytecode)
1469 {
1470         _lttng_enabler_attach_filter_bytecode(
1471                 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler),
1472                 bytecode);
1473
1474         lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group);
1475         return 0;
1476 }
1477
1478 int lttng_event_notifier_enabler_attach_exclusion(
1479                 struct lttng_event_notifier_enabler *event_notifier_enabler,
1480                 struct lttng_ust_excluder_node *excluder)
1481 {
1482         _lttng_enabler_attach_exclusion(
1483                 lttng_event_notifier_enabler_as_enabler(event_notifier_enabler),
1484                 excluder);
1485
1486         lttng_event_notifier_group_sync_enablers(event_notifier_enabler->group);
1487         return 0;
1488 }
1489
1490 int lttng_attach_context(struct lttng_ust_context *context_param,
1491                 union ust_args *uargs,
1492                 struct lttng_ctx **ctx, struct lttng_session *session)
1493 {
1494         /*
1495          * We cannot attach a context after trace has been started for a
1496          * session because the metadata does not allow expressing this
1497          * information outside of the original channel scope.
1498          */
1499         if (session->been_active)
1500                 return -EPERM;
1501
1502         switch (context_param->ctx) {
1503         case LTTNG_UST_CONTEXT_PTHREAD_ID:
1504                 return lttng_add_pthread_id_to_ctx(ctx);
1505         case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER:
1506         {
1507                 struct lttng_ust_perf_counter_ctx *perf_ctx_param;
1508
1509                 perf_ctx_param = &context_param->u.perf_counter;
1510                 return lttng_add_perf_counter_to_ctx(
1511                         perf_ctx_param->type,
1512                         perf_ctx_param->config,
1513                         perf_ctx_param->name,
1514                         ctx);
1515         }
1516         case LTTNG_UST_CONTEXT_VTID:
1517                 return lttng_add_vtid_to_ctx(ctx);
1518         case LTTNG_UST_CONTEXT_VPID:
1519                 return lttng_add_vpid_to_ctx(ctx);
1520         case LTTNG_UST_CONTEXT_PROCNAME:
1521                 return lttng_add_procname_to_ctx(ctx);
1522         case LTTNG_UST_CONTEXT_IP:
1523                 return lttng_add_ip_to_ctx(ctx);
1524         case LTTNG_UST_CONTEXT_CPU_ID:
1525                 return lttng_add_cpu_id_to_ctx(ctx);
1526         case LTTNG_UST_CONTEXT_APP_CONTEXT:
1527                 return lttng_ust_add_app_context_to_ctx_rcu(uargs->app_context.ctxname,
1528                         ctx);
1529         case LTTNG_UST_CONTEXT_CGROUP_NS:
1530                 return lttng_add_cgroup_ns_to_ctx(ctx);
1531         case LTTNG_UST_CONTEXT_IPC_NS:
1532                 return lttng_add_ipc_ns_to_ctx(ctx);
1533         case LTTNG_UST_CONTEXT_MNT_NS:
1534                 return lttng_add_mnt_ns_to_ctx(ctx);
1535         case LTTNG_UST_CONTEXT_NET_NS:
1536                 return lttng_add_net_ns_to_ctx(ctx);
1537         case LTTNG_UST_CONTEXT_PID_NS:
1538                 return lttng_add_pid_ns_to_ctx(ctx);
1539         case LTTNG_UST_CONTEXT_TIME_NS:
1540                 return lttng_add_time_ns_to_ctx(ctx);
1541         case LTTNG_UST_CONTEXT_USER_NS:
1542                 return lttng_add_user_ns_to_ctx(ctx);
1543         case LTTNG_UST_CONTEXT_UTS_NS:
1544                 return lttng_add_uts_ns_to_ctx(ctx);
1545         case LTTNG_UST_CONTEXT_VUID:
1546                 return lttng_add_vuid_to_ctx(ctx);
1547         case LTTNG_UST_CONTEXT_VEUID:
1548                 return lttng_add_veuid_to_ctx(ctx);
1549         case LTTNG_UST_CONTEXT_VSUID:
1550                 return lttng_add_vsuid_to_ctx(ctx);
1551         case LTTNG_UST_CONTEXT_VGID:
1552                 return lttng_add_vgid_to_ctx(ctx);
1553         case LTTNG_UST_CONTEXT_VEGID:
1554                 return lttng_add_vegid_to_ctx(ctx);
1555         case LTTNG_UST_CONTEXT_VSGID:
1556                 return lttng_add_vsgid_to_ctx(ctx);
1557         default:
1558                 return -EINVAL;
1559         }
1560 }
1561
1562 int lttng_event_enabler_attach_context(struct lttng_event_enabler *enabler,
1563                 struct lttng_ust_context *context_param)
1564 {
1565         return -ENOSYS;
1566 }
1567
1568 void lttng_event_enabler_destroy(struct lttng_event_enabler *event_enabler)
1569 {
1570         if (!event_enabler) {
1571                 return;
1572         }
1573         cds_list_del(&event_enabler->node);
1574
1575         lttng_enabler_destroy(lttng_event_enabler_as_enabler(event_enabler));
1576
1577         lttng_destroy_context(event_enabler->ctx);
1578         free(event_enabler);
1579 }
1580
1581 /*
1582  * lttng_session_sync_event_enablers should be called just before starting a
1583  * session.
1584  */
1585 static
1586 void lttng_session_sync_event_enablers(struct lttng_session *session)
1587 {
1588         struct lttng_event_enabler *event_enabler;
1589         struct lttng_event *event;
1590
1591         cds_list_for_each_entry(event_enabler, &session->enablers_head, node)
1592                 lttng_event_enabler_ref_events(event_enabler);
1593         /*
1594          * For each event, if at least one of its enablers is enabled,
1595          * and its channel and session transient states are enabled, we
1596          * enable the event, else we disable it.
1597          */
1598         cds_list_for_each_entry(event, &session->events_head, node) {
1599                 struct lttng_enabler_ref *enabler_ref;
1600                 struct lttng_bytecode_runtime *runtime;
1601                 int enabled = 0, has_enablers_without_bytecode = 0;
1602
1603                 /* Enable events */
1604                 cds_list_for_each_entry(enabler_ref,
1605                                 &event->enablers_ref_head, node) {
1606                         if (enabler_ref->ref->enabled) {
1607                                 enabled = 1;
1608                                 break;
1609                         }
1610                 }
1611                 /*
1612                  * Enabled state is based on union of enablers, with
1613                  * intesection of session and channel transient enable
1614                  * states.
1615                  */
1616                 enabled = enabled && session->tstate && event->chan->tstate;
1617
1618                 CMM_STORE_SHARED(event->enabled, enabled);
1619                 /*
1620                  * Sync tracepoint registration with event enabled
1621                  * state.
1622                  */
1623                 if (enabled) {
1624                         if (!event->registered)
1625                                 register_event(event);
1626                 } else {
1627                         if (event->registered)
1628                                 unregister_event(event);
1629                 }
1630
1631                 /* Check if has enablers without bytecode enabled */
1632                 cds_list_for_each_entry(enabler_ref,
1633                                 &event->enablers_ref_head, node) {
1634                         if (enabler_ref->ref->enabled
1635                                         && cds_list_empty(&enabler_ref->ref->filter_bytecode_head)) {
1636                                 has_enablers_without_bytecode = 1;
1637                                 break;
1638                         }
1639                 }
1640                 event->has_enablers_without_bytecode =
1641                         has_enablers_without_bytecode;
1642
1643                 /* Enable filters */
1644                 cds_list_for_each_entry(runtime,
1645                                 &event->filter_bytecode_runtime_head, node) {
1646                         lttng_bytecode_filter_sync_state(runtime);
1647                 }
1648         }
1649         __tracepoint_probe_prune_release_queue();
1650 }
1651
1652 static
1653 void lttng_create_event_notifier_if_missing(
1654                 struct lttng_event_notifier_enabler *event_notifier_enabler)
1655 {
1656         struct lttng_event_notifier_group *event_notifier_group = event_notifier_enabler->group;
1657         struct lttng_probe_desc *probe_desc;
1658         struct cds_list_head *probe_list;
1659         int i;
1660
1661         probe_list = lttng_get_probe_list_head();
1662
1663         cds_list_for_each_entry(probe_desc, probe_list, head) {
1664                 for (i = 0; i < probe_desc->nr_events; i++) {
1665                         int ret;
1666                         bool found = false;
1667                         const struct lttng_event_desc *desc;
1668                         struct lttng_event_notifier *event_notifier;
1669                         struct cds_hlist_head *head;
1670                         struct cds_hlist_node *node;
1671
1672                         desc = probe_desc->event_desc[i];
1673                         if (!lttng_desc_match_enabler(desc,
1674                                         lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)))
1675                                 continue;
1676
1677                         /*
1678                          * Given the current event_notifier group, get the bucket that
1679                          * the target event_notifier would be if it was already
1680                          * created.
1681                          */
1682                         head = borrow_hash_table_bucket(
1683                                 event_notifier_group->event_notifiers_ht.table,
1684                                 LTTNG_UST_EVENT_NOTIFIER_HT_SIZE, desc);
1685
1686                         cds_hlist_for_each_entry(event_notifier, node, head, hlist) {
1687                                 /*
1688                                  * Check if event_notifier already exists by checking
1689                                  * if the event_notifier and enabler share the same
1690                                  * description and id.
1691                                  */
1692                                 if (event_notifier->desc == desc &&
1693                                                 event_notifier->user_token == event_notifier_enabler->user_token) {
1694                                         found = true;
1695                                         break;
1696                                 }
1697                         }
1698
1699                         if (found)
1700                                 continue;
1701
1702                         /*
1703                          * We need to create a event_notifier for this event probe.
1704                          */
1705                         ret = lttng_event_notifier_create(desc,
1706                                 event_notifier_enabler->user_token,
1707                                 event_notifier_group);
1708                         if (ret) {
1709                                 DBG("Unable to create event_notifier %s, error %d\n",
1710                                         probe_desc->event_desc[i]->name, ret);
1711                         }
1712                 }
1713         }
1714 }
1715
1716 /*
1717  * Create event_notifiers associated with a event_notifier enabler (if not already present).
1718  */
1719 static
1720 int lttng_event_notifier_enabler_ref_event_notifiers(
1721                 struct lttng_event_notifier_enabler *event_notifier_enabler)
1722 {
1723         struct lttng_event_notifier_group *event_notifier_group = event_notifier_enabler->group;
1724         struct lttng_event_notifier *event_notifier;
1725
1726          /*
1727           * Only try to create event_notifiers for enablers that are enabled, the user
1728           * might still be attaching filter or exclusion to the
1729           * event_notifier_enabler.
1730           */
1731         if (!lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->enabled)
1732                 goto end;
1733
1734         /* First, ensure that probe event_notifiers are created for this enabler. */
1735         lttng_create_event_notifier_if_missing(event_notifier_enabler);
1736
1737         /* Link the created event_notifier with its associated enabler. */
1738         cds_list_for_each_entry(event_notifier, &event_notifier_group->event_notifiers_head, node) {
1739                 struct lttng_enabler_ref *enabler_ref;
1740
1741                 if (!lttng_event_notifier_enabler_match_event_notifier(event_notifier_enabler, event_notifier))
1742                         continue;
1743
1744                 enabler_ref = lttng_enabler_ref(&event_notifier->enablers_ref_head,
1745                         lttng_event_notifier_enabler_as_enabler(event_notifier_enabler));
1746                 if (!enabler_ref) {
1747                         /*
1748                          * If no backward ref, create it.
1749                          * Add backward ref from event_notifier to enabler.
1750                          */
1751                         enabler_ref = zmalloc(sizeof(*enabler_ref));
1752                         if (!enabler_ref)
1753                                 return -ENOMEM;
1754
1755                         enabler_ref->ref = lttng_event_notifier_enabler_as_enabler(
1756                                 event_notifier_enabler);
1757                         cds_list_add(&enabler_ref->node,
1758                                 &event_notifier->enablers_ref_head);
1759                 }
1760
1761                 /*
1762                  * Link filter bytecodes if not linked yet.
1763                  */
1764                 lttng_enabler_link_bytecode(event_notifier->desc,
1765                         &event_notifier_group->ctx,
1766                         &event_notifier->filter_bytecode_runtime_head,
1767                         &lttng_event_notifier_enabler_as_enabler(event_notifier_enabler)->filter_bytecode_head);
1768         }
1769 end:
1770         return 0;
1771 }
1772
1773 static
1774 void lttng_event_notifier_group_sync_enablers(struct lttng_event_notifier_group *event_notifier_group)
1775 {
1776         struct lttng_event_notifier_enabler *event_notifier_enabler;
1777         struct lttng_event_notifier *event_notifier;
1778
1779         cds_list_for_each_entry(event_notifier_enabler, &event_notifier_group->enablers_head, node)
1780                 lttng_event_notifier_enabler_ref_event_notifiers(event_notifier_enabler);
1781
1782         /*
1783          * For each event_notifier, if at least one of its enablers is enabled,
1784          * we enable the event_notifier, else we disable it.
1785          */
1786         cds_list_for_each_entry(event_notifier, &event_notifier_group->event_notifiers_head, node) {
1787                 struct lttng_enabler_ref *enabler_ref;
1788                 struct lttng_bytecode_runtime *runtime;
1789                 int enabled = 0, has_enablers_without_bytecode = 0;
1790
1791                 /* Enable event_notifiers */
1792                 cds_list_for_each_entry(enabler_ref,
1793                                 &event_notifier->enablers_ref_head, node) {
1794                         if (enabler_ref->ref->enabled) {
1795                                 enabled = 1;
1796                                 break;
1797                         }
1798                 }
1799
1800                 CMM_STORE_SHARED(event_notifier->enabled, enabled);
1801                 /*
1802                  * Sync tracepoint registration with event_notifier enabled
1803                  * state.
1804                  */
1805                 if (enabled) {
1806                         if (!event_notifier->registered)
1807                                 register_event_notifier(event_notifier);
1808                 } else {
1809                         if (event_notifier->registered)
1810                                 unregister_event_notifier(event_notifier);
1811                 }
1812
1813                 /* Check if has enablers without bytecode enabled */
1814                 cds_list_for_each_entry(enabler_ref,
1815                                 &event_notifier->enablers_ref_head, node) {
1816                         if (enabler_ref->ref->enabled
1817                                         && cds_list_empty(&enabler_ref->ref->filter_bytecode_head)) {
1818                                 has_enablers_without_bytecode = 1;
1819                                 break;
1820                         }
1821                 }
1822                 event_notifier->has_enablers_without_bytecode =
1823                         has_enablers_without_bytecode;
1824
1825                 /* Enable filters */
1826                 cds_list_for_each_entry(runtime,
1827                                 &event_notifier->filter_bytecode_runtime_head, node) {
1828                         lttng_bytecode_filter_sync_state(runtime);
1829                 }
1830         }
1831         __tracepoint_probe_prune_release_queue();
1832 }
1833
1834 /*
1835  * Apply enablers to session events, adding events to session if need
1836  * be. It is required after each modification applied to an active
1837  * session, and right before session "start".
1838  * "lazy" sync means we only sync if required.
1839  */
1840 static
1841 void lttng_session_lazy_sync_event_enablers(struct lttng_session *session)
1842 {
1843         /* We can skip if session is not active */
1844         if (!session->active)
1845                 return;
1846         lttng_session_sync_event_enablers(session);
1847 }
1848
1849 /*
1850  * Update all sessions with the given app context.
1851  * Called with ust lock held.
1852  * This is invoked when an application context gets loaded/unloaded. It
1853  * ensures the context callbacks are in sync with the application
1854  * context (either app context callbacks, or dummy callbacks).
1855  */
1856 void lttng_ust_context_set_session_provider(const char *name,
1857                 size_t (*get_size)(struct lttng_ctx_field *field, size_t offset),
1858                 void (*record)(struct lttng_ctx_field *field,
1859                         struct lttng_ust_lib_ring_buffer_ctx *ctx,
1860                         struct lttng_channel *chan),
1861                 void (*get_value)(struct lttng_ctx_field *field,
1862                         struct lttng_ctx_value *value))
1863 {
1864         struct lttng_session *session;
1865
1866         cds_list_for_each_entry(session, &sessions, node) {
1867                 struct lttng_channel *chan;
1868                 struct lttng_event *event;
1869                 int ret;
1870
1871                 ret = lttng_ust_context_set_provider_rcu(&session->ctx,
1872                                 name, get_size, record, get_value);
1873                 if (ret)
1874                         abort();
1875                 cds_list_for_each_entry(chan, &session->chan_head, node) {
1876                         ret = lttng_ust_context_set_provider_rcu(&chan->ctx,
1877                                         name, get_size, record, get_value);
1878                         if (ret)
1879                                 abort();
1880                 }
1881                 cds_list_for_each_entry(event, &session->events_head, node) {
1882                         ret = lttng_ust_context_set_provider_rcu(&event->ctx,
1883                                         name, get_size, record, get_value);
1884                         if (ret)
1885                                 abort();
1886                 }
1887         }
1888 }
1889
1890 /*
1891  * Update all event_notifier groups with the given app context.
1892  * Called with ust lock held.
1893  * This is invoked when an application context gets loaded/unloaded. It
1894  * ensures the context callbacks are in sync with the application
1895  * context (either app context callbacks, or dummy callbacks).
1896  */
1897 void lttng_ust_context_set_event_notifier_group_provider(const char *name,
1898                 size_t (*get_size)(struct lttng_ctx_field *field, size_t offset),
1899                 void (*record)(struct lttng_ctx_field *field,
1900                         struct lttng_ust_lib_ring_buffer_ctx *ctx,
1901                         struct lttng_channel *chan),
1902                 void (*get_value)(struct lttng_ctx_field *field,
1903                         struct lttng_ctx_value *value))
1904 {
1905         struct lttng_event_notifier_group *event_notifier_group;
1906
1907         cds_list_for_each_entry(event_notifier_group, &event_notifier_groups, node) {
1908                 int ret;
1909
1910                 ret = lttng_ust_context_set_provider_rcu(
1911                                 &event_notifier_group->ctx,
1912                                 name, get_size, record, get_value);
1913                 if (ret)
1914                         abort();
1915         }
1916 }