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