src/bin/lttng-sessiond/event.c

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