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