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