src/bin/lttng-sessiond/event.c

   1 /*
   2  * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
   3  * Copyright (C) 2016 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License, version 2 only,
   7  * as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #define _LGPL_SOURCE
  20 #include <errno.h>
  21 #include <urcu/list.h>
  22 #include <string.h>
  23
  24 #include <lttng/lttng.h>
  25 #include <common/error.h>
  26 #include <common/sessiond-comm/sessiond-comm.h>
  27 #include <common/filter.h>
  28 #include <common/context.h>
  29
  30 #include "channel.h"
  31 #include "event.h"
  32 #include "kernel.h"
  33 #include "lttng-sessiond.h"
  34 #include "lttng-ust-ctl.h"
  35 #include "lttng-ust-error.h"
  36 #include "ust-app.h"
  37 #include "trace-kernel.h"
  38 #include "trace-ust.h"
  39 #include "agent.h"
  40
  41 /*
  42  * Add unique UST event based on the event name, filter bytecode and loglevel.
  43  */
  44 static void add_unique_ust_event(struct lttng_ht *ht,
  45                 struct ltt_ust_event *event)
  46 {
  47         struct cds_lfht_node *node_ptr;
  48         struct ltt_ust_ht_key key;
  49
  50         assert(ht);
  51         assert(ht->ht);
  52         assert(event);
  53
  54         key.name = event->attr.name;
  55         key.filter = (struct lttng_filter_bytecode *) event->filter;
  56         key.loglevel_type = event->attr.loglevel_type;
  57         key.loglevel_value = event->attr.loglevel;
  58         key.exclusion = event->exclusion;
  59
  60         node_ptr = cds_lfht_add_unique(ht->ht,
  61                         ht->hash_fct(event->node.key, lttng_ht_seed),
  62                         trace_ust_ht_match_event, &key, &event->node.node);
  63         assert(node_ptr == &event->node.node);
  64 }
  65
  66 /*
  67  * Disable kernel tracepoint events for a channel from the kernel session of
  68  * a specified event_name and event type.
  69  * On type LTTNG_EVENT_ALL all events with event_name are disabled.
  70  * If event_name is NULL all events of the specified type are disabled.
  71  */
  72 int event_kernel_disable_event(struct ltt_kernel_channel *kchan,
  73                 char *event_name, enum lttng_event_type type)
  74 {
  75         int ret, error = 0, found = 0;
  76         struct ltt_kernel_event *kevent;
  77
  78         assert(kchan);
  79
  80         /* For each event in the kernel session */
  81         cds_list_for_each_entry(kevent, &kchan->events_list.head, list) {
  82                 if (type != LTTNG_EVENT_ALL && kevent->type != type)
  83                         continue;
  84                 if (event_name != NULL && strcmp(event_name, kevent->event->name)) {
  85                         continue;
  86                 }
  87                 found++;
  88                 ret = kernel_disable_event(kevent);
  89                 if (ret < 0) {
  90                         error = 1;
  91                         continue;
  92                 }
  93         }
  94         DBG("Disable kernel event: found %d events with name: %s and type: %d",
  95                         found, event_name ? event_name : "NULL", type);
  96
  97         if (event_name != NULL && !found) {
  98                 ret = LTTNG_ERR_NO_EVENT;
  99         } else {
 100                 ret = error ? LTTNG_ERR_KERN_DISABLE_FAIL : LTTNG_OK;
 101         }
 102
 103         return ret;
 104 }
 105
 106 /*
 107  * Enable kernel tracepoint event for a channel from the kernel session.
 108  * We own filter_expression and filter.
 109  */
 110 int event_kernel_enable_event(struct ltt_kernel_channel *kchan,
 111                 struct lttng_event *event, char *filter_expression,
 112                 struct lttng_filter_bytecode *filter)
 113 {
 114         int ret;
 115         struct ltt_kernel_event *kevent;
 116
 117         assert(kchan);
 118         assert(event);
 119
 120         kevent = trace_kernel_find_event(event->name, kchan,
 121                         event->type, filter);
 122         if (kevent == NULL) {
 123                 ret = kernel_create_event(event, kchan,
 124                         filter_expression, filter);
 125                 /* We have passed ownership */
 126                 filter_expression = NULL;
 127                 filter = NULL;
 128                 if (ret < 0) {
 129                         switch (-ret) {
 130                         case EEXIST:
 131                                 ret = LTTNG_ERR_KERN_EVENT_EXIST;
 132                                 break;
 133                         case ENOSYS:
 134                                 ret = LTTNG_ERR_KERN_EVENT_ENOSYS;
 135                                 break;
 136                         default:
 137                                 ret = LTTNG_ERR_KERN_ENABLE_FAIL;
 138                                 break;
 139                         }
 140                         goto end;
 141                 }
 142         } else if (kevent->enabled == 0) {
 143                 ret = kernel_enable_event(kevent);
 144                 if (ret < 0) {
 145                         ret = LTTNG_ERR_KERN_ENABLE_FAIL;
 146                         goto end;
 147                 }
 148         } else {
 149                 /* At this point, the event is considered enabled */
 150                 ret = LTTNG_ERR_KERN_EVENT_EXIST;
 151                 goto end;
 152         }
 153
 154         ret = LTTNG_OK;
 155 end:
 156         free(filter_expression);
 157         free(filter);
 158         return ret;
 159 }
 160
 161 /*
 162  * ============================
 163  * UST : The Ultimate Frontier!
 164  * ============================
 165  */
 166
 167 /*
 168  * Enable UST tracepoint event for a channel from a UST session.
 169  * We own filter_expression, filter, and exclusion.
 170  */
 171 int event_ust_enable_tracepoint(struct ltt_ust_session *usess,
 172                 struct ltt_ust_channel *uchan, struct lttng_event *event,
 173                 char *filter_expression,
 174                 struct lttng_filter_bytecode *filter,
 175                 struct lttng_event_exclusion *exclusion,
 176                 bool internal_event)
 177 {
 178         int ret = LTTNG_OK, to_create = 0;
 179         struct ltt_ust_event *uevent;
 180
 181         assert(usess);
 182         assert(uchan);
 183         assert(event);
 184
 185         rcu_read_lock();
 186
 187         uevent = trace_ust_find_event(uchan->events, event->name, filter,
 188                         event->loglevel_type, event->loglevel, exclusion);
 189         if (!uevent) {
 190                 uevent = trace_ust_create_event(event, filter_expression,
 191                                 filter, exclusion, internal_event);
 192                 /* We have passed ownership */
 193                 filter_expression = NULL;
 194                 filter = NULL;
 195                 exclusion = NULL;
 196                 if (uevent == NULL) {
 197                         ret = LTTNG_ERR_UST_ENABLE_FAIL;
 198                         goto error;
 199                 }
 200
 201                 /* Valid to set it after the goto error since uevent is still NULL */
 202                 to_create = 1;
 203         }
 204
 205         if (uevent->enabled) {
 206                 /* It's already enabled so everything is OK */
 207                 ret = LTTNG_ERR_UST_EVENT_ENABLED;
 208                 goto end;
 209         }
 210
 211         uevent->enabled = 1;
 212
 213         if (to_create) {
 214                 /* Create event on all UST registered apps for session */
 215                 ret = ust_app_create_event_glb(usess, uchan, uevent);
 216         } else {
 217                 /* Enable event on all UST registered apps for session */
 218                 ret = ust_app_enable_event_glb(usess, uchan, uevent);
 219         }
 220
 221         if (ret < 0) {
 222                 if (ret == -LTTNG_UST_ERR_EXIST) {
 223                         ret = LTTNG_ERR_UST_EVENT_EXIST;
 224                         goto end;
 225                 } else {
 226                         ret = LTTNG_ERR_UST_ENABLE_FAIL;
 227                         goto error;
 228                 }
 229         }
 230
 231         if (to_create) {
 232                 /* Add ltt ust event to channel */
 233                 add_unique_ust_event(uchan->events, uevent);
 234         }
 235
 236         DBG("Event UST %s %s in channel %s", uevent->attr.name,
 237                         to_create ? "created" : "enabled", uchan->name);
 238
 239         ret = LTTNG_OK;
 240
 241 end:
 242         rcu_read_unlock();
 243         free(filter_expression);
 244         free(filter);
 245         free(exclusion);
 246         return ret;
 247
 248 error:
 249         /*
 250          * Only destroy event on creation time (not enabling time) because if the
 251          * event is found in the channel (to_create == 0), it means that at some
 252          * point the enable_event worked and it's thus valid to keep it alive.
 253          * Destroying it also implies that we also destroy it's shadow copy to sync
 254          * everyone up.
 255          */
 256         if (to_create) {
 257                 /* In this code path, the uevent was not added to the hash table */
 258                 trace_ust_destroy_event(uevent);
 259         }
 260         rcu_read_unlock();
 261         free(filter_expression);
 262         free(filter);
 263         free(exclusion);
 264         return ret;
 265 }
 266
 267 /*
 268  * Disable UST tracepoint of a channel from a UST session.
 269  */
 270 int event_ust_disable_tracepoint(struct ltt_ust_session *usess,
 271                 struct ltt_ust_channel *uchan, char *event_name)
 272 {
 273         int ret;
 274         struct ltt_ust_event *uevent;
 275         struct lttng_ht_node_str *node;
 276         struct lttng_ht_iter iter;
 277         struct lttng_ht *ht;
 278
 279         assert(usess);
 280         assert(uchan);
 281         assert(event_name);
 282
 283         ht = uchan->events;
 284
 285         rcu_read_lock();
 286
 287         /*
 288          * We use a custom lookup since we need the iterator for the next_duplicate
 289          * call in the do while loop below.
 290          */
 291         cds_lfht_lookup(ht->ht, ht->hash_fct((void *) event_name, lttng_ht_seed),
 292                         trace_ust_ht_match_event_by_name, event_name, &iter.iter);
 293         node = lttng_ht_iter_get_node_str(&iter);
 294         if (node == NULL) {
 295                 DBG2("Trace UST event NOT found by name %s", event_name);
 296                 ret = LTTNG_ERR_UST_EVENT_NOT_FOUND;
 297                 goto error;
 298         }
 299
 300         do {
 301                 uevent = caa_container_of(node, struct ltt_ust_event, node);
 302                 assert(uevent);
 303
 304                 if (uevent->enabled == 0) {
 305                         /* It's already disabled so everything is OK */
 306                         goto next;
 307                 }
 308
 309                 ret = ust_app_disable_event_glb(usess, uchan, uevent);
 310                 if (ret < 0 && ret != -LTTNG_UST_ERR_EXIST) {
 311                         ret = LTTNG_ERR_UST_DISABLE_FAIL;
 312                         goto error;
 313                 }
 314                 uevent->enabled = 0;
 315
 316                 DBG2("Event UST %s disabled in channel %s", uevent->attr.name,
 317                                 uchan->name);
 318
 319 next:
 320                 /* Get next duplicate event by name. */
 321                 cds_lfht_next_duplicate(ht->ht, trace_ust_ht_match_event_by_name,
 322                                 event_name, &iter.iter);
 323                 node = lttng_ht_iter_get_node_str(&iter);
 324         } while (node);
 325
 326         ret = LTTNG_OK;
 327
 328 error:
 329         rcu_read_unlock();
 330         return ret;
 331 }
 332
 333 /*
 334  * Disable all UST tracepoints for a channel from a UST session.
 335  */
 336 int event_ust_disable_all_tracepoints(struct ltt_ust_session *usess,
 337                 struct ltt_ust_channel *uchan)
 338 {
 339         int ret, i, size, error = 0;
 340         struct lttng_ht_iter iter;
 341         struct ltt_ust_event *uevent = NULL;
 342         struct lttng_event *events = NULL;
 343
 344         assert(usess);
 345         assert(uchan);
 346
 347         rcu_read_lock();
 348
 349         /* Disabling existing events */
 350         cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent,
 351                         node.node) {
 352                 if (uevent->enabled == 1) {
 353                         ret = event_ust_disable_tracepoint(usess, uchan,
 354                                         uevent->attr.name);
 355                         if (ret < 0) {
 356                                 error = LTTNG_ERR_UST_DISABLE_FAIL;
 357                                 continue;
 358                         }
 359                 }
 360         }
 361
 362         /* Get all UST available events */
 363         size = ust_app_list_events(&events);
 364         if (size < 0) {
 365                 ret = LTTNG_ERR_UST_LIST_FAIL;
 366                 goto error;
 367         }
 368
 369         for (i = 0; i < size; i++) {
 370                 ret = event_ust_disable_tracepoint(usess, uchan,
 371                                 events[i].name);
 372                 if (ret < 0) {
 373                         /* Continue to disable the rest... */
 374                         error = LTTNG_ERR_UST_DISABLE_FAIL;
 375                         continue;
 376                 }
 377         }
 378
 379         ret = error ? error : LTTNG_OK;
 380 error:
 381         rcu_read_unlock();
 382         free(events);
 383         return ret;
 384 }
 385
 386 /*
 387  * Enable all agent event for a given UST session.
 388  *
 389  * Return LTTNG_OK on success or else a LTTNG_ERR* code.
 390  */
 391 int event_agent_enable_all(struct ltt_ust_session *usess,
 392                 struct agent *agt, struct lttng_event *event,
 393                 struct lttng_filter_bytecode *filter ,char *filter_expression)
 394 {
 395         int ret;
 396         struct agent_event *aevent;
 397         struct lttng_ht_iter iter;
 398
 399         assert(usess);
 400
 401         DBG("Event agent enabling ALL events for session %" PRIu64, usess->id);
 402
 403         /* Enable event on agent application through TCP socket. */
 404         ret = event_agent_enable(usess, agt, event, filter, filter_expression);
 405         if (ret != LTTNG_OK) {
 406                 goto error;
 407         }
 408
 409         /* Flag every event that they are now enabled. */
 410         rcu_read_lock();
 411         cds_lfht_for_each_entry(agt->events->ht, &iter.iter, aevent,
 412                         node.node) {
 413                 aevent->enabled = 1;
 414         }
 415         rcu_read_unlock();
 416
 417         ret = LTTNG_OK;
 418
 419 error:
 420         return ret;
 421 }
 422
 423 /*
 424  * Check if this event's filter requires the activation of application contexts
 425  * and enable them in the agent.
 426  */
 427 static int add_filter_app_ctx(struct lttng_filter_bytecode *bytecode,
 428                 const char *filter_expression, struct agent *agt)
 429 {
 430         int ret = LTTNG_OK;
 431         char *provider_name = NULL, *ctx_name = NULL;
 432         struct bytecode_symbol_iterator *it =
 433                         bytecode_symbol_iterator_create(bytecode);
 434
 435         if (!it) {
 436                 ret = LTTNG_ERR_NOMEM;
 437                 goto end;
 438         }
 439
 440         do {
 441                 struct lttng_event_context ctx;
 442                 const char *symbol_name =
 443                                 bytecode_symbol_iterator_get_name(it);
 444
 445                 if (parse_application_context(symbol_name, &provider_name,
 446                                 &ctx_name)) {
 447                         /* Not an application context. */
 448                         continue;
 449                 }
 450
 451                 ctx.ctx = LTTNG_EVENT_CONTEXT_APP_CONTEXT;
 452                 ctx.u.app_ctx.provider_name = provider_name;
 453                 ctx.u.app_ctx.ctx_name = ctx_name;
 454
 455                 /* Recognized an application context. */
 456                 DBG("Enabling event with filter expression \"%s\" requires enabling the %s:%s application context.",
 457                                 filter_expression, provider_name, ctx_name);
 458
 459                 ret = agent_add_context(&ctx, agt);
 460                 if (ret != LTTNG_OK) {
 461                         ERR("Failed to add application context %s:%s.",
 462                                         provider_name, ctx_name);
 463                         goto end;
 464                 }
 465
 466                 ret = agent_enable_context(&ctx, agt->domain);
 467                 if (ret != LTTNG_OK) {
 468                         ERR("Failed to enable application context %s:%s.",
 469                                         provider_name, ctx_name);
 470                         goto end;
 471                 }
 472
 473                 free(provider_name);
 474                 free(ctx_name);
 475                 provider_name = ctx_name = NULL;
 476         } while (bytecode_symbol_iterator_next(it) == 0);
 477 end:
 478         free(provider_name);
 479         free(ctx_name);
 480         bytecode_symbol_iterator_destroy(it);
 481         return ret;
 482 }
 483
 484 /*
 485  * Enable a single agent event for a given UST session.
 486  *
 487  * Return LTTNG_OK on success or else a LTTNG_ERR* code.
 488  */
 489 int event_agent_enable(struct ltt_ust_session *usess,
 490                 struct agent *agt, struct lttng_event *event,
 491                 struct lttng_filter_bytecode *filter,
 492                 char *filter_expression)
 493 {
 494         int ret, created = 0;
 495         struct agent_event *aevent;
 496
 497         assert(usess);
 498         assert(event);
 499         assert(agt);
 500
 501         DBG("Event agent enabling %s for session %" PRIu64 " with loglevel type %d "
 502                         ", loglevel %d and filter \"%s\"", event->name,
 503                         usess->id, event->loglevel_type, event->loglevel,
 504                         filter_expression ? filter_expression : "NULL");
 505
 506         aevent = agent_find_event(event->name, event->loglevel_type,
 507                         event->loglevel, filter_expression, agt);
 508         if (!aevent) {
 509                 aevent = agent_create_event(event->name, event->loglevel_type,
 510                                 event->loglevel, filter,
 511                                 filter_expression);
 512                 if (!aevent) {
 513                         ret = LTTNG_ERR_NOMEM;
 514                         goto error;
 515                 }
 516                 filter = NULL;
 517                 filter_expression = NULL;
 518                 created = 1;
 519         }
 520
 521         /* Already enabled? */
 522         if (aevent->enabled) {
 523                 ret = LTTNG_OK;
 524                 goto end;
 525         }
 526
 527         if (created && aevent->filter) {
 528                 ret = add_filter_app_ctx(
 529                                 aevent->filter, aevent->filter_expression, agt);
 530                 if (ret != LTTNG_OK) {
 531                         goto error;
 532                 }
 533         }
 534
 535         ret = agent_enable_event(aevent, agt->domain);
 536         if (ret != LTTNG_OK) {
 537                 goto error;
 538         }
 539
 540         /* If the event was created prior to the enable, add it to the domain. */
 541         if (created) {
 542                 agent_add_event(aevent, agt);
 543         }
 544
 545         ret = LTTNG_OK;
 546         goto end;
 547
 548 error:
 549         if (created) {
 550                 agent_destroy_event(aevent);
 551         }
 552 end:
 553         free(filter);
 554         free(filter_expression);
 555         return ret;
 556 }
 557
 558 /*
 559  * Return the default event name associated with the provided UST domain. Return
 560  * NULL on error.
 561  */
 562 const char *event_get_default_agent_ust_name(enum lttng_domain_type domain)
 563 {
 564         const char *default_event_name = NULL;
 565
 566         switch (domain) {
 567         case LTTNG_DOMAIN_LOG4J:
 568                 default_event_name = DEFAULT_LOG4J_EVENT_NAME;
 569                 break;
 570         case LTTNG_DOMAIN_JUL:
 571                 default_event_name = DEFAULT_JUL_EVENT_NAME;
 572                 break;
 573         case LTTNG_DOMAIN_PYTHON:
 574                 default_event_name = DEFAULT_PYTHON_EVENT_NAME;
 575                 break;
 576         default:
 577                 assert(0);
 578         }
 579
 580         return default_event_name;
 581 }
 582
 583 /*
 584  * Disable a given agent event for a given UST session.
 585  *
 586  * Must be called with the RCU read lock held.
 587  * Return LTTNG_OK on success or else a LTTNG_ERR* code.
 588  */
 589 static int event_agent_disable_one(struct ltt_ust_session *usess,
 590                 struct agent *agt, struct agent_event *aevent)
 591 {
 592         int ret;
 593         struct ltt_ust_event *uevent = NULL;
 594         struct ltt_ust_channel *uchan = NULL;
 595         const char *ust_event_name, *ust_channel_name;
 596
 597         assert(agt);
 598         assert(usess);
 599         assert(aevent);
 600
 601         DBG("Event agent disabling %s (loglevel type %d, loglevel value %d) for session %" PRIu64,
 602                 aevent->name, aevent->loglevel_type, aevent->loglevel_value,
 603                 usess->id);
 604
 605         /* Already disabled? */
 606         if (!aevent->enabled) {
 607                 goto end;
 608         }
 609
 610         if (agt->domain == LTTNG_DOMAIN_JUL) {
 611                 ust_channel_name = DEFAULT_JUL_CHANNEL_NAME;
 612         } else if (agt->domain == LTTNG_DOMAIN_LOG4J) {
 613                 ust_channel_name = DEFAULT_LOG4J_CHANNEL_NAME;
 614         } else if (agt->domain == LTTNG_DOMAIN_PYTHON) {
 615                 ust_channel_name = DEFAULT_PYTHON_CHANNEL_NAME;
 616         } else {
 617                 ret = LTTNG_ERR_INVALID;
 618                 goto error;
 619         }
 620
 621         /*
 622          * Disable it on the UST side. First get the channel reference then find
 623          * the event and finally disable it.
 624          */
 625         uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
 626                         (char *) ust_channel_name);
 627         if (!uchan) {
 628                 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
 629                 goto error;
 630         }
 631
 632         ust_event_name = event_get_default_agent_ust_name(agt->domain);
 633         if (!ust_event_name) {
 634                 ret = LTTNG_ERR_FATAL;
 635                 goto error;
 636         }
 637
 638         /*
 639          * Agent UST event has its loglevel type forced to
 640          * LTTNG_UST_LOGLEVEL_ALL. The actual loglevel type/value filtering
 641          * happens thanks to an UST filter. The following -1 is actually
 642          * ignored since the type is LTTNG_UST_LOGLEVEL_ALL.
 643          */
 644         uevent = trace_ust_find_event(uchan->events, (char *) ust_event_name,
 645                         aevent->filter, LTTNG_UST_LOGLEVEL_ALL, -1, NULL);
 646         /* If the agent event exists, it must be available on the UST side. */
 647         assert(uevent);
 648
 649         ret = ust_app_disable_event_glb(usess, uchan, uevent);
 650         if (ret < 0 && ret != -LTTNG_UST_ERR_EXIST) {
 651                 ret = LTTNG_ERR_UST_DISABLE_FAIL;
 652                 goto error;
 653         }
 654
 655         /*
 656          * Flag event that it's disabled so the shadow copy on the ust app side
 657          * will disable it if an application shows up.
 658          */
 659         uevent->enabled = 0;
 660
 661         ret = agent_disable_event(aevent, agt->domain);
 662         if (ret != LTTNG_OK) {
 663                 goto error;
 664         }
 665
 666 end:
 667         return LTTNG_OK;
 668
 669 error:
 670         return ret;
 671 }
 672
 673 /*
 674  * Disable all agent events matching a given name for a given UST session.
 675  *
 676  * Return LTTNG_OK on success or else a LTTNG_ERR* code.
 677  */
 678 int event_agent_disable(struct ltt_ust_session *usess, struct agent *agt,
 679                 char *event_name)
 680 {
 681         int ret = LTTNG_OK;
 682         struct agent_event *aevent;
 683         struct lttng_ht_iter iter;
 684         struct lttng_ht_node_str *node;
 685
 686         assert(agt);
 687         assert(usess);
 688         assert(event_name);
 689
 690         DBG("Event agent disabling %s (all loglevels) for session %" PRIu64, event_name, usess->id);
 691
 692         rcu_read_lock();
 693         agent_find_events_by_name(event_name, agt, &iter);
 694         node = lttng_ht_iter_get_node_str(&iter);
 695
 696         if (node == NULL) {
 697                 DBG2("Event agent NOT found by name %s", event_name);
 698                 ret = LTTNG_ERR_UST_EVENT_NOT_FOUND;
 699                 goto end;
 700         }
 701
 702         do {
 703                 aevent = caa_container_of(node, struct agent_event, node);
 704                 ret = event_agent_disable_one(usess, agt, aevent);
 705
 706                 if (ret != LTTNG_OK) {
 707                         goto end;
 708                 }
 709
 710                 /* Get next duplicate agent event by name. */
 711                 agent_event_next_duplicate(event_name, agt, &iter);
 712                 node = lttng_ht_iter_get_node_str(&iter);
 713         } while (node);
 714 end:
 715         rcu_read_unlock();
 716         return ret;
 717 }
 718 /*
 719  * Disable all agent event for a given UST session.
 720  *
 721  * Return LTTNG_OK on success or else a LTTNG_ERR* code.
 722  */
 723 int event_agent_disable_all(struct ltt_ust_session *usess,
 724                 struct agent *agt)
 725 {
 726         int ret;
 727         struct agent_event *aevent;
 728         struct lttng_ht_iter iter;
 729
 730         assert(agt);
 731         assert(usess);
 732
 733         /*
 734          * Disable event on agent application. Continue to disable all other events
 735          * if the * event is not found.
 736          */
 737         ret = event_agent_disable(usess, agt, "*");
 738         if (ret != LTTNG_OK && ret != LTTNG_ERR_UST_EVENT_NOT_FOUND) {
 739                 goto error;
 740         }
 741
 742         /* Disable every event. */
 743         rcu_read_lock();
 744         cds_lfht_for_each_entry(agt->events->ht, &iter.iter, aevent,
 745                         node.node) {
 746                 if (!aevent->enabled) {
 747                         continue;
 748                 }
 749
 750                 ret = event_agent_disable(usess, agt, aevent->name);
 751                 if (ret != LTTNG_OK) {
 752                         goto error_unlock;
 753                 }
 754         }
 755         ret = LTTNG_OK;
 756
 757 error_unlock:
 758         rcu_read_unlock();
 759 error:
 760         return ret;
 761 }