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