src/bin/lttng-sessiond/main.cpp

   1 /*
   2  * Copyright (C) 2011 EfficiOS Inc.
   3  * Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   4  * Copyright (C) 2013 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   5  *
   6  * SPDX-License-Identifier: GPL-2.0-only
   7  *
   8  */
   9
  10 #define _LGPL_SOURCE
  11 #include <getopt.h>
  12 #include <grp.h>
  13 #include <limits.h>
  14 #include <paths.h>
  15 #include <pthread.h>
  16 #include <signal.h>
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <inttypes.h>
  21 #include <sys/mman.h>
  22 #include <sys/mount.h>
  23 #include <sys/resource.h>
  24 #include <sys/socket.h>
  25 #include <sys/stat.h>
  26 #include <sys/types.h>
  27 #include <sys/wait.h>
  28 #include <urcu/uatomic.h>
  29 #include <unistd.h>
  30 #include <ctype.h>
  31
  32 #include <common/common.h>
  33 #include <common/compat/socket.h>
  34 #include <common/compat/getenv.h>
  35 #include <common/defaults.h>
  36 #include <common/kernel-consumer/kernel-consumer.h>
  37 #include <common/futex.h>
  38 #include <common/relayd/relayd.h>
  39 #include <common/utils.h>
  40 #include <common/path.h>
  41 #include <common/daemonize.h>
  42 #include <common/config/session-config.h>
  43 #include <common/ini-config/ini-config.h>
  44 #include <common/dynamic-buffer.h>
  45 #include <lttng/event-internal.h>
  46
  47 #include "lttng-sessiond.h"
  48 #include "buffer-registry.h"
  49 #include "channel.h"
  50 #include "cmd.h"
  51 #include "consumer.h"
  52 #include "context.h"
  53 #include "event.h"
  54 #include "event-notifier-error-accounting.h"
  55 #include "kernel.h"
  56 #include "kernel-consumer.h"
  57 #include "lttng-ust-ctl.h"
  58 #include "ust-consumer.h"
  59 #include "utils.h"
  60 #include "fd-limit.h"
  61 #include "health-sessiond.h"
  62 #include "testpoint.h"
  63 #include "notify-apps.h"
  64 #include "agent-thread.h"
  65 #include "save.h"
  66 #include "notification-thread.h"
  67 #include "notification-thread-commands.h"
  68 #include "rotation-thread.h"
  69 #include "agent.h"
  70 #include "sessiond-config.h"
  71 #include "timer.h"
  72 #include "thread.h"
  73 #include "client.h"
  74 #include "dispatch.h"
  75 #include "register.h"
  76 #include "manage-apps.h"
  77 #include "manage-kernel.h"
  78 #include "modprobe.h"
  79 #include "ust-sigbus.h"
  80
  81 static const char *help_msg =
  82 #ifdef LTTNG_EMBED_HELP
  83 #include <lttng-sessiond.8.h>
  84 #else
  85 NULL
  86 #endif
  87 ;
  88
  89 #define EVENT_NOTIFIER_ERROR_COUNTER_NUMBER_OF_BUCKET_MAX 65535
  90 #define EVENT_NOTIFIER_ERROR_BUFFER_SIZE_BASE_OPTION_STR \
  91                 "event-notifier-error-buffer-size"
  92 #define EVENT_NOTIFIER_ERROR_BUFFER_SIZE_KERNEL_OPTION_STR \
  93                 EVENT_NOTIFIER_ERROR_BUFFER_SIZE_BASE_OPTION_STR "-kernel"
  94 #define EVENT_NOTIFIER_ERROR_BUFFER_SIZE_USERSPACE_OPTION_STR \
  95                 EVENT_NOTIFIER_ERROR_BUFFER_SIZE_BASE_OPTION_STR "-userspace"
  96
  97
  98 const char *progname;
  99 static int lockfile_fd = -1;
 100 static int opt_print_version;
 101
 102 /* Set to 1 when a SIGUSR1 signal is received. */
 103 static int recv_child_signal;
 104
 105 /* Command line options */
 106 static const struct option long_options[] = {
 107         { "client-sock", required_argument, 0, 'c' },
 108         { "apps-sock", required_argument, 0, 'a' },
 109         { "kconsumerd-cmd-sock", required_argument, 0, '\0' },
 110         { "kconsumerd-err-sock", required_argument, 0, '\0' },
 111         { "ustconsumerd32-cmd-sock", required_argument, 0, '\0' },
 112         { "ustconsumerd32-err-sock", required_argument, 0, '\0' },
 113         { "ustconsumerd64-cmd-sock", required_argument, 0, '\0' },
 114         { "ustconsumerd64-err-sock", required_argument, 0, '\0' },
 115         { "consumerd32-path", required_argument, 0, '\0' },
 116         { "consumerd32-libdir", required_argument, 0, '\0' },
 117         { "consumerd64-path", required_argument, 0, '\0' },
 118         { "consumerd64-libdir", required_argument, 0, '\0' },
 119         { "daemonize", no_argument, 0, 'd' },
 120         { "background", no_argument, 0, 'b' },
 121         { "sig-parent", no_argument, 0, 'S' },
 122         { "help", no_argument, 0, 'h' },
 123         { "group", required_argument, 0, 'g' },
 124         { "version", no_argument, 0, 'V' },
 125         { "quiet", no_argument, 0, 'q' },
 126         { "verbose", no_argument, 0, 'v' },
 127         { "verbose-consumer", no_argument, 0, '\0' },
 128         { "no-kernel", no_argument, 0, '\0' },
 129         { "pidfile", required_argument, 0, 'p' },
 130         { "agent-tcp-port", required_argument, 0, '\0' },
 131         { "config", required_argument, 0, 'f' },
 132         { "load", required_argument, 0, 'l' },
 133         { "kmod-probes", required_argument, 0, '\0' },
 134         { "extra-kmod-probes", required_argument, 0, '\0' },
 135         { EVENT_NOTIFIER_ERROR_BUFFER_SIZE_KERNEL_OPTION_STR, required_argument, 0, '\0' },
 136         { EVENT_NOTIFIER_ERROR_BUFFER_SIZE_USERSPACE_OPTION_STR, required_argument, 0, '\0' },
 137         { NULL, 0, 0, 0 }
 138 };
 139
 140 /* Command line options to ignore from configuration file */
 141 static const char *config_ignore_options[] = { "help", "version", "config" };
 142
 143 /*
 144  * This pipe is used to inform the thread managing application communication
 145  * that a command is queued and ready to be processed.
 146  */
 147 static int apps_cmd_pipe[2] = { -1, -1 };
 148 static int apps_cmd_notify_pipe[2] = { -1, -1 };
 149
 150 /*
 151  * UST registration command queue. This queue is tied with a futex and uses a N
 152  * wakers / 1 waiter implemented and detailed in futex.c/.h
 153  *
 154  * The thread_registration_apps and thread_dispatch_ust_registration uses this
 155  * queue along with the wait/wake scheme. The thread_manage_apps receives down
 156  * the line new application socket and monitors it for any I/O error or clean
 157  * close that triggers an unregistration of the application.
 158  */
 159 static struct ust_cmd_queue ust_cmd_queue;
 160
 161 /*
 162  * Section name to look for in the daemon configuration file.
 163  */
 164 static const char * const config_section_name = "sessiond";
 165
 166 /* Am I root or not. Set to 1 if the daemon is running as root */
 167 static int is_root;
 168
 169 /*
 170  * Stop all threads by closing the thread quit pipe.
 171  */
 172 static void stop_threads(void)
 173 {
 174         int ret;
 175
 176         /* Stopping all threads */
 177         DBG("Terminating all threads");
 178         ret = sessiond_notify_quit_pipe();
 179         if (ret < 0) {
 180                 ERR("write error on thread quit pipe");
 181         }
 182 }
 183
 184 /*
 185  * Close every consumer sockets.
 186  */
 187 static void close_consumer_sockets(void)
 188 {
 189         int ret;
 190
 191         if (the_kconsumer_data.err_sock >= 0) {
 192                 ret = close(the_kconsumer_data.err_sock);
 193                 if (ret < 0) {
 194                         PERROR("kernel consumer err_sock close");
 195                 }
 196         }
 197         if (the_ustconsumer32_data.err_sock >= 0) {
 198                 ret = close(the_ustconsumer32_data.err_sock);
 199                 if (ret < 0) {
 200                         PERROR("UST consumerd32 err_sock close");
 201                 }
 202         }
 203         if (the_ustconsumer64_data.err_sock >= 0) {
 204                 ret = close(the_ustconsumer64_data.err_sock);
 205                 if (ret < 0) {
 206                         PERROR("UST consumerd64 err_sock close");
 207                 }
 208         }
 209         if (the_kconsumer_data.cmd_sock >= 0) {
 210                 ret = close(the_kconsumer_data.cmd_sock);
 211                 if (ret < 0) {
 212                         PERROR("kernel consumer cmd_sock close");
 213                 }
 214         }
 215         if (the_ustconsumer32_data.cmd_sock >= 0) {
 216                 ret = close(the_ustconsumer32_data.cmd_sock);
 217                 if (ret < 0) {
 218                         PERROR("UST consumerd32 cmd_sock close");
 219                 }
 220         }
 221         if (the_ustconsumer64_data.cmd_sock >= 0) {
 222                 ret = close(the_ustconsumer64_data.cmd_sock);
 223                 if (ret < 0) {
 224                         PERROR("UST consumerd64 cmd_sock close");
 225                 }
 226         }
 227         if (the_kconsumer_data.channel_monitor_pipe >= 0) {
 228                 ret = close(the_kconsumer_data.channel_monitor_pipe);
 229                 if (ret < 0) {
 230                         PERROR("kernel consumer channel monitor pipe close");
 231                 }
 232         }
 233         if (the_ustconsumer32_data.channel_monitor_pipe >= 0) {
 234                 ret = close(the_ustconsumer32_data.channel_monitor_pipe);
 235                 if (ret < 0) {
 236                         PERROR("UST consumerd32 channel monitor pipe close");
 237                 }
 238         }
 239         if (the_ustconsumer64_data.channel_monitor_pipe >= 0) {
 240                 ret = close(the_ustconsumer64_data.channel_monitor_pipe);
 241                 if (ret < 0) {
 242                         PERROR("UST consumerd64 channel monitor pipe close");
 243                 }
 244         }
 245 }
 246
 247 /*
 248  * Wait on consumer process termination.
 249  *
 250  * Need to be called with the consumer data lock held or from a context
 251  * ensuring no concurrent access to data (e.g: cleanup).
 252  */
 253 static void wait_consumer(struct consumer_data *consumer_data)
 254 {
 255         pid_t ret;
 256         int status;
 257
 258         if (consumer_data->pid <= 0) {
 259                 return;
 260         }
 261
 262         DBG("Waiting for complete teardown of consumerd (PID: %d)",
 263                         consumer_data->pid);
 264         ret = waitpid(consumer_data->pid, &status, 0);
 265         if (ret == -1) {
 266                 PERROR("consumerd waitpid pid: %d", consumer_data->pid)
 267         } else  if (!WIFEXITED(status)) {
 268                 ERR("consumerd termination with error: %d",
 269                                 WEXITSTATUS(ret));
 270         }
 271         consumer_data->pid = 0;
 272 }
 273
 274 /*
 275  * Cleanup the session daemon's data structures.
 276  */
 277 static void sessiond_cleanup(void)
 278 {
 279         int ret;
 280         struct ltt_session_list *session_list = session_get_list();
 281
 282         DBG("Cleanup sessiond");
 283
 284         /*
 285          * Close the thread quit pipe. It has already done its job,
 286          * since we are now called.
 287          */
 288         sessiond_close_quit_pipe();
 289         utils_close_pipe(apps_cmd_pipe);
 290         utils_close_pipe(apps_cmd_notify_pipe);
 291         utils_close_pipe(the_kernel_poll_pipe);
 292
 293         ret = remove(the_config.pid_file_path.value);
 294         if (ret < 0) {
 295                 PERROR("remove pidfile %s", the_config.pid_file_path.value);
 296         }
 297
 298         DBG("Removing sessiond and consumerd content of directory %s",
 299                         the_config.rundir.value);
 300
 301         /* sessiond */
 302         DBG("Removing %s", the_config.pid_file_path.value);
 303         (void) unlink(the_config.pid_file_path.value);
 304
 305         DBG("Removing %s", the_config.agent_port_file_path.value);
 306         (void) unlink(the_config.agent_port_file_path.value);
 307
 308         /* kconsumerd */
 309         DBG("Removing %s", the_kconsumer_data.err_unix_sock_path);
 310         (void) unlink(the_kconsumer_data.err_unix_sock_path);
 311
 312         DBG("Removing directory %s", the_config.kconsumerd_path.value);
 313         (void) rmdir(the_config.kconsumerd_path.value);
 314
 315         /* ust consumerd 32 */
 316         DBG("Removing %s", the_config.consumerd32_err_unix_sock_path.value);
 317         (void) unlink(the_config.consumerd32_err_unix_sock_path.value);
 318
 319         DBG("Removing directory %s", the_config.consumerd32_path.value);
 320         (void) rmdir(the_config.consumerd32_path.value);
 321
 322         /* ust consumerd 64 */
 323         DBG("Removing %s", the_config.consumerd64_err_unix_sock_path.value);
 324         (void) unlink(the_config.consumerd64_err_unix_sock_path.value);
 325
 326         DBG("Removing directory %s", the_config.consumerd64_path.value);
 327         (void) rmdir(the_config.consumerd64_path.value);
 328
 329         pthread_mutex_destroy(&session_list->lock);
 330
 331         DBG("Cleaning up all per-event notifier domain agents");
 332         agent_by_event_notifier_domain_ht_destroy();
 333
 334         DBG("Cleaning up all agent apps");
 335         agent_app_ht_clean();
 336         DBG("Closing all UST sockets");
 337         ust_app_clean_list();
 338         buffer_reg_destroy_registries();
 339
 340         close_consumer_sockets();
 341
 342         wait_consumer(&the_kconsumer_data);
 343         wait_consumer(&the_ustconsumer64_data);
 344         wait_consumer(&the_ustconsumer32_data);
 345
 346         if (is_root && !the_config.no_kernel) {
 347                 cleanup_kernel_tracer();
 348         }
 349
 350         /*
 351          * We do NOT rmdir rundir because there are other processes
 352          * using it, for instance lttng-relayd, which can start in
 353          * parallel with this teardown.
 354          */
 355 }
 356
 357 /*
 358  * Cleanup the daemon's option data structures.
 359  */
 360 static void sessiond_cleanup_options(void)
 361 {
 362         DBG("Cleaning up options");
 363
 364         sessiond_config_fini(&the_config);
 365
 366         run_as_destroy_worker();
 367 }
 368
 369 static int string_match(const char *str1, const char *str2)
 370 {
 371         return (str1 && str2) && !strcmp(str1, str2);
 372 }
 373
 374 /*
 375  * Take an option from the getopt output and set it in the right variable to be
 376  * used later.
 377  *
 378  * Return 0 on success else a negative value.
 379  */
 380 static int set_option(int opt, const char *arg, const char *optname)
 381 {
 382         int ret = 0;
 383
 384         if (string_match(optname, "client-sock") || opt == 'c') {
 385                 if (!arg || *arg == '\0') {
 386                         ret = -EINVAL;
 387                         goto end;
 388                 }
 389                 if (lttng_is_setuid_setgid()) {
 390                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 391                                 "-c, --client-sock");
 392                 } else {
 393                         config_string_set(&the_config.client_unix_sock_path,
 394                                         strdup(arg));
 395                         if (!the_config.client_unix_sock_path.value) {
 396                                 ret = -ENOMEM;
 397                                 PERROR("strdup");
 398                         }
 399                 }
 400         } else if (string_match(optname, "apps-sock") || opt == 'a') {
 401                 if (!arg || *arg == '\0') {
 402                         ret = -EINVAL;
 403                         goto end;
 404                 }
 405                 if (lttng_is_setuid_setgid()) {
 406                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 407                                 "-a, --apps-sock");
 408                 } else {
 409                         config_string_set(&the_config.apps_unix_sock_path,
 410                                         strdup(arg));
 411                         if (!the_config.apps_unix_sock_path.value) {
 412                                 ret = -ENOMEM;
 413                                 PERROR("strdup");
 414                         }
 415                 }
 416         } else if (string_match(optname, "daemonize") || opt == 'd') {
 417                 the_config.daemonize = true;
 418         } else if (string_match(optname, "background") || opt == 'b') {
 419                 the_config.background = true;
 420         } else if (string_match(optname, "group") || opt == 'g') {
 421                 if (!arg || *arg == '\0') {
 422                         ret = -EINVAL;
 423                         goto end;
 424                 }
 425                 if (lttng_is_setuid_setgid()) {
 426                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 427                                 "-g, --group");
 428                 } else {
 429                         config_string_set(&the_config.tracing_group_name,
 430                                         strdup(arg));
 431                         if (!the_config.tracing_group_name.value) {
 432                                 ret = -ENOMEM;
 433                                 PERROR("strdup");
 434                         }
 435                 }
 436         } else if (string_match(optname, "help") || opt == 'h') {
 437                 ret = utils_show_help(8, "lttng-sessiond", help_msg);
 438                 if (ret) {
 439                         ERR("Cannot show --help for `lttng-sessiond`");
 440                         perror("exec");
 441                 }
 442                 exit(ret ? EXIT_FAILURE : EXIT_SUCCESS);
 443         } else if (string_match(optname, "version") || opt == 'V') {
 444                 opt_print_version = 1;
 445         } else if (string_match(optname, "sig-parent") || opt == 'S') {
 446                 the_config.sig_parent = true;
 447         } else if (string_match(optname, "kconsumerd-err-sock")) {
 448                 if (!arg || *arg == '\0') {
 449                         ret = -EINVAL;
 450                         goto end;
 451                 }
 452                 if (lttng_is_setuid_setgid()) {
 453                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 454                                 "--kconsumerd-err-sock");
 455                 } else {
 456                         config_string_set(
 457                                         &the_config.kconsumerd_err_unix_sock_path,
 458                                         strdup(arg));
 459                         if (!the_config.kconsumerd_err_unix_sock_path.value) {
 460                                 ret = -ENOMEM;
 461                                 PERROR("strdup");
 462                         }
 463                 }
 464         } else if (string_match(optname, "kconsumerd-cmd-sock")) {
 465                 if (!arg || *arg == '\0') {
 466                         ret = -EINVAL;
 467                         goto end;
 468                 }
 469                 if (lttng_is_setuid_setgid()) {
 470                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 471                                 "--kconsumerd-cmd-sock");
 472                 } else {
 473                         config_string_set(
 474                                         &the_config.kconsumerd_cmd_unix_sock_path,
 475                                         strdup(arg));
 476                         if (!the_config.kconsumerd_cmd_unix_sock_path.value) {
 477                                 ret = -ENOMEM;
 478                                 PERROR("strdup");
 479                         }
 480                 }
 481         } else if (string_match(optname, "ustconsumerd64-err-sock")) {
 482                 if (!arg || *arg == '\0') {
 483                         ret = -EINVAL;
 484                         goto end;
 485                 }
 486                 if (lttng_is_setuid_setgid()) {
 487                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 488                                 "--ustconsumerd64-err-sock");
 489                 } else {
 490                         config_string_set(
 491                                         &the_config.consumerd64_err_unix_sock_path,
 492                                         strdup(arg));
 493                         if (!the_config.consumerd64_err_unix_sock_path.value) {
 494                                 ret = -ENOMEM;
 495                                 PERROR("strdup");
 496                         }
 497                 }
 498         } else if (string_match(optname, "ustconsumerd64-cmd-sock")) {
 499                 if (!arg || *arg == '\0') {
 500                         ret = -EINVAL;
 501                         goto end;
 502                 }
 503                 if (lttng_is_setuid_setgid()) {
 504                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 505                                 "--ustconsumerd64-cmd-sock");
 506                 } else {
 507                         config_string_set(
 508                                         &the_config.consumerd64_cmd_unix_sock_path,
 509                                         strdup(arg));
 510                         if (!the_config.consumerd64_cmd_unix_sock_path.value) {
 511                                 ret = -ENOMEM;
 512                                 PERROR("strdup");
 513                         }
 514                 }
 515         } else if (string_match(optname, "ustconsumerd32-err-sock")) {
 516                 if (!arg || *arg == '\0') {
 517                         ret = -EINVAL;
 518                         goto end;
 519                 }
 520                 if (lttng_is_setuid_setgid()) {
 521                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 522                                 "--ustconsumerd32-err-sock");
 523                 } else {
 524                         config_string_set(
 525                                         &the_config.consumerd32_err_unix_sock_path,
 526                                         strdup(arg));
 527                         if (!the_config.consumerd32_err_unix_sock_path.value) {
 528                                 ret = -ENOMEM;
 529                                 PERROR("strdup");
 530                         }
 531                 }
 532         } else if (string_match(optname, "ustconsumerd32-cmd-sock")) {
 533                 if (!arg || *arg == '\0') {
 534                         ret = -EINVAL;
 535                         goto end;
 536                 }
 537                 if (lttng_is_setuid_setgid()) {
 538                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 539                                 "--ustconsumerd32-cmd-sock");
 540                 } else {
 541                         config_string_set(
 542                                         &the_config.consumerd32_cmd_unix_sock_path,
 543                                         strdup(arg));
 544                         if (!the_config.consumerd32_cmd_unix_sock_path.value) {
 545                                 ret = -ENOMEM;
 546                                 PERROR("strdup");
 547                         }
 548                 }
 549         } else if (string_match(optname, "no-kernel")) {
 550                 the_config.no_kernel = true;
 551         } else if (string_match(optname, "quiet") || opt == 'q') {
 552                 the_config.quiet = true;
 553         } else if (string_match(optname, "verbose") || opt == 'v') {
 554                 /* Verbose level can increase using multiple -v */
 555                 if (arg) {
 556                         /* Value obtained from config file */
 557                         the_config.verbose = config_parse_value(arg);
 558                 } else {
 559                         /* -v used on command line */
 560                         the_config.verbose++;
 561                 }
 562                 /* Clamp value to [0, 3] */
 563                 the_config.verbose = the_config.verbose < 0 ?
 564                                       0 :
 565                                       (the_config.verbose <= 3 ? the_config.verbose :
 566                                                                  3);
 567         } else if (string_match(optname, "verbose-consumer")) {
 568                 if (arg) {
 569                         the_config.verbose_consumer = config_parse_value(arg);
 570                 } else {
 571                         the_config.verbose_consumer++;
 572                 }
 573         } else if (string_match(optname, "consumerd32-path")) {
 574                 if (!arg || *arg == '\0') {
 575                         ret = -EINVAL;
 576                         goto end;
 577                 }
 578                 if (lttng_is_setuid_setgid()) {
 579                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 580                                 "--consumerd32-path");
 581                 } else {
 582                         config_string_set(&the_config.consumerd32_bin_path,
 583                                         strdup(arg));
 584                         if (!the_config.consumerd32_bin_path.value) {
 585                                 PERROR("strdup");
 586                                 ret = -ENOMEM;
 587                         }
 588                 }
 589         } else if (string_match(optname, "consumerd32-libdir")) {
 590                 if (!arg || *arg == '\0') {
 591                         ret = -EINVAL;
 592                         goto end;
 593                 }
 594                 if (lttng_is_setuid_setgid()) {
 595                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 596                                 "--consumerd32-libdir");
 597                 } else {
 598                         config_string_set(&the_config.consumerd32_lib_dir,
 599                                         strdup(arg));
 600                         if (!the_config.consumerd32_lib_dir.value) {
 601                                 PERROR("strdup");
 602                                 ret = -ENOMEM;
 603                         }
 604                 }
 605         } else if (string_match(optname, "consumerd64-path")) {
 606                 if (!arg || *arg == '\0') {
 607                         ret = -EINVAL;
 608                         goto end;
 609                 }
 610                 if (lttng_is_setuid_setgid()) {
 611                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 612                                 "--consumerd64-path");
 613                 } else {
 614                         config_string_set(&the_config.consumerd64_bin_path,
 615                                         strdup(arg));
 616                         if (!the_config.consumerd64_bin_path.value) {
 617                                 PERROR("strdup");
 618                                 ret = -ENOMEM;
 619                         }
 620                 }
 621         } else if (string_match(optname, "consumerd64-libdir")) {
 622                 if (!arg || *arg == '\0') {
 623                         ret = -EINVAL;
 624                         goto end;
 625                 }
 626                 if (lttng_is_setuid_setgid()) {
 627                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 628                                 "--consumerd64-libdir");
 629                 } else {
 630                         config_string_set(&the_config.consumerd64_lib_dir,
 631                                         strdup(arg));
 632                         if (!the_config.consumerd64_lib_dir.value) {
 633                                 PERROR("strdup");
 634                                 ret = -ENOMEM;
 635                         }
 636                 }
 637         } else if (string_match(optname, "pidfile") || opt == 'p') {
 638                 if (!arg || *arg == '\0') {
 639                         ret = -EINVAL;
 640                         goto end;
 641                 }
 642                 if (lttng_is_setuid_setgid()) {
 643                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 644                                 "-p, --pidfile");
 645                 } else {
 646                         config_string_set(
 647                                         &the_config.pid_file_path, strdup(arg));
 648                         if (!the_config.pid_file_path.value) {
 649                                 PERROR("strdup");
 650                                 ret = -ENOMEM;
 651                         }
 652                 }
 653         } else if (string_match(optname, "agent-tcp-port")) {
 654                 if (!arg || *arg == '\0') {
 655                         ret = -EINVAL;
 656                         goto end;
 657                 }
 658                 if (lttng_is_setuid_setgid()) {
 659                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 660                                 "--agent-tcp-port");
 661                 } else {
 662                         unsigned long v;
 663
 664                         errno = 0;
 665                         v = strtoul(arg, NULL, 0);
 666                         if (errno != 0 || !isdigit(arg[0])) {
 667                                 ERR("Wrong value in --agent-tcp-port parameter: %s", arg);
 668                                 return -1;
 669                         }
 670                         if (v == 0 || v >= 65535) {
 671                                 ERR("Port overflow in --agent-tcp-port parameter: %s", arg);
 672                                 return -1;
 673                         }
 674                         the_config.agent_tcp_port.begin =
 675                                         the_config.agent_tcp_port.end = (int) v;
 676                         DBG3("Agent TCP port set to non default: %i", (int) v);
 677                 }
 678         } else if (string_match(optname, "load") || opt == 'l') {
 679                 if (!arg || *arg == '\0') {
 680                         ret = -EINVAL;
 681                         goto end;
 682                 }
 683                 if (lttng_is_setuid_setgid()) {
 684                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 685                                 "-l, --load");
 686                 } else {
 687                         config_string_set(&the_config.load_session_path,
 688                                         strdup(arg));
 689                         if (!the_config.load_session_path.value) {
 690                                 PERROR("strdup");
 691                                 ret = -ENOMEM;
 692                         }
 693                 }
 694         } else if (string_match(optname, "kmod-probes")) {
 695                 if (!arg || *arg == '\0') {
 696                         ret = -EINVAL;
 697                         goto end;
 698                 }
 699                 if (lttng_is_setuid_setgid()) {
 700                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 701                                 "--kmod-probes");
 702                 } else {
 703                         config_string_set(&the_config.kmod_probes_list,
 704                                         strdup(arg));
 705                         if (!the_config.kmod_probes_list.value) {
 706                                 PERROR("strdup");
 707                                 ret = -ENOMEM;
 708                         }
 709                 }
 710         } else if (string_match(optname, "extra-kmod-probes")) {
 711                 if (!arg || *arg == '\0') {
 712                         ret = -EINVAL;
 713                         goto end;
 714                 }
 715                 if (lttng_is_setuid_setgid()) {
 716                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 717                                 "--extra-kmod-probes");
 718                 } else {
 719                         config_string_set(&the_config.kmod_extra_probes_list,
 720                                         strdup(arg));
 721                         if (!the_config.kmod_extra_probes_list.value) {
 722                                 PERROR("strdup");
 723                                 ret = -ENOMEM;
 724                         }
 725                 }
 726         } else if (string_match(optname, EVENT_NOTIFIER_ERROR_BUFFER_SIZE_KERNEL_OPTION_STR)) {
 727                 unsigned long v;
 728
 729                 errno = 0;
 730                 v = strtoul(arg, NULL, 0);
 731                 if (errno != 0 || !isdigit(arg[0])) {
 732                         ERR("Wrong value in --%s parameter: %s",
 733                                         EVENT_NOTIFIER_ERROR_BUFFER_SIZE_KERNEL_OPTION_STR, arg);
 734                         return -1;
 735                 }
 736                 if (v == 0 || v >= EVENT_NOTIFIER_ERROR_COUNTER_NUMBER_OF_BUCKET_MAX) {
 737                         ERR("Value out of range for --%s parameter: %s",
 738                                         EVENT_NOTIFIER_ERROR_BUFFER_SIZE_KERNEL_OPTION_STR, arg);
 739                         return -1;
 740                 }
 741                 the_config.event_notifier_buffer_size_kernel = (int) v;
 742                 DBG3("Number of event notifier error buffer kernel size to non default: %i",
 743                                 the_config.event_notifier_buffer_size_kernel);
 744                 goto end;
 745         } else if (string_match(optname, EVENT_NOTIFIER_ERROR_BUFFER_SIZE_USERSPACE_OPTION_STR)) {
 746                 unsigned long v;
 747
 748                 errno = 0;
 749                 v = strtoul(arg, NULL, 0);
 750                 if (errno != 0 || !isdigit(arg[0])) {
 751                         ERR("Wrong value in --%s parameter: %s",
 752                                         EVENT_NOTIFIER_ERROR_BUFFER_SIZE_USERSPACE_OPTION_STR, arg);
 753                         return -1;
 754                 }
 755                 if (v == 0 || v >= EVENT_NOTIFIER_ERROR_COUNTER_NUMBER_OF_BUCKET_MAX) {
 756                         ERR("Value out of range for --%s parameter: %s",
 757                                         EVENT_NOTIFIER_ERROR_BUFFER_SIZE_USERSPACE_OPTION_STR, arg);
 758                         return -1;
 759                 }
 760                 the_config.event_notifier_buffer_size_userspace = (int) v;
 761                 DBG3("Number of event notifier error buffer userspace size to non default: %i",
 762                                 the_config.event_notifier_buffer_size_userspace);
 763                 goto end;
 764         } else if (string_match(optname, "config") || opt == 'f') {
 765                 /* This is handled in set_options() thus silent skip. */
 766                 goto end;
 767         } else {
 768                 /* Unknown option or other error.
 769                  * Error is printed by getopt, just return */
 770                 ret = -1;
 771         }
 772
 773 end:
 774         if (ret == -EINVAL) {
 775                 const char *opt_name = "unknown";
 776                 int i;
 777
 778                 for (i = 0; i < sizeof(long_options) / sizeof(struct option);
 779                         i++) {
 780                         if (opt == long_options[i].val) {
 781                                 opt_name = long_options[i].name;
 782                                 break;
 783                         }
 784                 }
 785
 786                 WARN("Invalid argument provided for option \"%s\", using default value.",
 787                         opt_name);
 788         }
 789
 790         return ret;
 791 }
 792
 793 /*
 794  * config_entry_handler_cb used to handle options read from a config file.
 795  * See config_entry_handler_cb comment in common/config/session-config.h for the
 796  * return value conventions.
 797  */
 798 static int config_entry_handler(const struct config_entry *entry,
 799                 void *unused __attribute__((unused)))
 800 {
 801         int ret = 0, i;
 802
 803         if (!entry || !entry->name || !entry->value) {
 804                 ret = -EINVAL;
 805                 goto end;
 806         }
 807
 808         /* Check if the option is to be ignored */
 809         for (i = 0; i < sizeof(config_ignore_options) / sizeof(char *); i++) {
 810                 if (!strcmp(entry->name, config_ignore_options[i])) {
 811                         goto end;
 812                 }
 813         }
 814
 815         for (i = 0; i < (sizeof(long_options) / sizeof(struct option)) - 1;
 816                 i++) {
 817
 818                 /* Ignore if not fully matched. */
 819                 if (strcmp(entry->name, long_options[i].name)) {
 820                         continue;
 821                 }
 822
 823                 /*
 824                  * If the option takes no argument on the command line, we have to
 825                  * check if the value is "true". We support non-zero numeric values,
 826                  * true, on and yes.
 827                  */
 828                 if (!long_options[i].has_arg) {
 829                         ret = config_parse_value(entry->value);
 830                         if (ret <= 0) {
 831                                 if (ret) {
 832                                         WARN("Invalid configuration value \"%s\" for option %s",
 833                                                         entry->value, entry->name);
 834                                 }
 835                                 /* False, skip boolean config option. */
 836                                 goto end;
 837                         }
 838                 }
 839
 840                 ret = set_option(long_options[i].val, entry->value, entry->name);
 841                 goto end;
 842         }
 843
 844         WARN("Unrecognized option \"%s\" in daemon configuration file.", entry->name);
 845
 846 end:
 847         return ret;
 848 }
 849
 850 static void print_version(void) {
 851         fprintf(stdout, "%s\n", VERSION);
 852 }
 853
 854 /*
 855  * daemon configuration loading and argument parsing
 856  */
 857 static int set_options(int argc, char **argv)
 858 {
 859         int ret = 0, c = 0, option_index = 0;
 860         int orig_optopt = optopt, orig_optind = optind;
 861         char *optstring;
 862         char *config_path = NULL;
 863
 864         optstring = utils_generate_optstring(long_options,
 865                         sizeof(long_options) / sizeof(struct option));
 866         if (!optstring) {
 867                 ret = -ENOMEM;
 868                 goto end;
 869         }
 870
 871         /* Check for the --config option */
 872         while ((c = getopt_long(argc, argv, optstring, long_options,
 873                                         &option_index)) != -1) {
 874                 if (c == '?') {
 875                         ret = -EINVAL;
 876                         goto end;
 877                 } else if (c != 'f') {
 878                         /* if not equal to --config option. */
 879                         continue;
 880                 }
 881
 882                 if (lttng_is_setuid_setgid()) {
 883                         WARN("Getting '%s' argument from setuid/setgid binary refused for security reasons.",
 884                                 "-f, --config");
 885                 } else {
 886                         free(config_path);
 887                         config_path = utils_expand_path(optarg);
 888                         if (!config_path) {
 889                                 ERR("Failed to resolve path: %s", optarg);
 890                         }
 891                 }
 892         }
 893
 894         ret = config_get_section_entries(config_path, config_section_name,
 895                         config_entry_handler, NULL);
 896         if (ret) {
 897                 if (ret > 0) {
 898                         ERR("Invalid configuration option at line %i", ret);
 899                         ret = -1;
 900                 }
 901                 goto end;
 902         }
 903
 904         /* Reset getopt's global state */
 905         optopt = orig_optopt;
 906         optind = orig_optind;
 907         while (1) {
 908                 option_index = -1;
 909                 /*
 910                  * getopt_long() will not set option_index if it encounters a
 911                  * short option.
 912                  */
 913                 c = getopt_long(argc, argv, optstring, long_options,
 914                                 &option_index);
 915                 if (c == -1) {
 916                         break;
 917                 }
 918
 919                 /*
 920                  * Pass NULL as the long option name if popt left the index
 921                  * unset.
 922                  */
 923                 ret = set_option(c, optarg,
 924                                 option_index < 0 ? NULL :
 925                                 long_options[option_index].name);
 926                 if (ret < 0) {
 927                         break;
 928                 }
 929         }
 930
 931 end:
 932         free(config_path);
 933         free(optstring);
 934         return ret;
 935 }
 936
 937 /*
 938  * Create lockfile using the rundir and return its fd.
 939  */
 940 static int create_lockfile(void)
 941 {
 942         return utils_create_lock_file(the_config.lock_file_path.value);
 943 }
 944
 945 /*
 946  * Check if the global socket is available, and if a daemon is answering at the
 947  * other side. If yes, error is returned.
 948  *
 949  * Also attempts to create and hold the lock file.
 950  */
 951 static int check_existing_daemon(void)
 952 {
 953         int ret = 0;
 954
 955         /* Is there anybody out there ? */
 956         if (lttng_session_daemon_alive()) {
 957                 ret = -EEXIST;
 958                 goto end;
 959         }
 960
 961         lockfile_fd = create_lockfile();
 962         if (lockfile_fd < 0) {
 963                 ret = -EEXIST;
 964                 goto end;
 965         }
 966 end:
 967         return ret;
 968 }
 969
 970 static void sessiond_cleanup_lock_file(void)
 971 {
 972         int ret;
 973
 974         /*
 975          * Cleanup lock file by deleting it and finaly closing it which will
 976          * release the file system lock.
 977          */
 978         if (lockfile_fd >= 0) {
 979                 ret = remove(the_config.lock_file_path.value);
 980                 if (ret < 0) {
 981                         PERROR("remove lock file");
 982                 }
 983                 ret = close(lockfile_fd);
 984                 if (ret < 0) {
 985                         PERROR("close lock file");
 986                 }
 987         }
 988 }
 989
 990 /*
 991  * Set the tracing group gid onto the client socket.
 992  *
 993  * Race window between mkdir and chown is OK because we are going from more
 994  * permissive (root.root) to less permissive (root.tracing).
 995  */
 996 static int set_permissions(char *rundir)
 997 {
 998         int ret;
 999         gid_t gid;
1000
1001         ret = utils_get_group_id(
1002                         the_config.tracing_group_name.value, true, &gid);
1003         if (ret) {
1004                 /* Default to root group. */
1005                 gid = 0;
1006         }
1007
1008         /* Set lttng run dir */
1009         ret = chown(rundir, 0, gid);
1010         if (ret < 0) {
1011                 ERR("Unable to set group on %s", rundir);
1012                 PERROR("chown");
1013         }
1014
1015         /*
1016          * Ensure all applications and tracing group can search the run
1017          * dir. Allow everyone to read the directory, since it does not
1018          * buy us anything to hide its content.
1019          */
1020         ret = chmod(rundir, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
1021         if (ret < 0) {
1022                 ERR("Unable to set permissions on %s", rundir);
1023                 PERROR("chmod");
1024         }
1025
1026         /* lttng client socket path */
1027         ret = chown(the_config.client_unix_sock_path.value, 0, gid);
1028         if (ret < 0) {
1029                 ERR("Unable to set group on %s",
1030                                 the_config.client_unix_sock_path.value);
1031                 PERROR("chown");
1032         }
1033
1034         /* kconsumer error socket path */
1035         ret = chown(the_kconsumer_data.err_unix_sock_path, 0, 0);
1036         if (ret < 0) {
1037                 ERR("Unable to set group on %s",
1038                                 the_kconsumer_data.err_unix_sock_path);
1039                 PERROR("chown");
1040         }
1041
1042         /* 64-bit ustconsumer error socket path */
1043         ret = chown(the_ustconsumer64_data.err_unix_sock_path, 0, 0);
1044         if (ret < 0) {
1045                 ERR("Unable to set group on %s",
1046                                 the_ustconsumer64_data.err_unix_sock_path);
1047                 PERROR("chown");
1048         }
1049
1050         /* 32-bit ustconsumer compat32 error socket path */
1051         ret = chown(the_ustconsumer32_data.err_unix_sock_path, 0, 0);
1052         if (ret < 0) {
1053                 ERR("Unable to set group on %s",
1054                                 the_ustconsumer32_data.err_unix_sock_path);
1055                 PERROR("chown");
1056         }
1057
1058         DBG("All permissions are set");
1059
1060         return ret;
1061 }
1062
1063 /*
1064  * Create the lttng run directory needed for all global sockets and pipe.
1065  */
1066 static int create_lttng_rundir(void)
1067 {
1068         int ret;
1069
1070         DBG3("Creating LTTng run directory: %s", the_config.rundir.value);
1071
1072         ret = mkdir(the_config.rundir.value, S_IRWXU);
1073         if (ret < 0) {
1074                 if (errno != EEXIST) {
1075                         ERR("Unable to create %s", the_config.rundir.value);
1076                         goto error;
1077                 } else {
1078                         ret = 0;
1079                 }
1080         }
1081
1082 error:
1083         return ret;
1084 }
1085
1086 /*
1087  * Setup sockets and directory needed by the consumerds' communication with the
1088  * session daemon.
1089  */
1090 static int set_consumer_sockets(struct consumer_data *consumer_data)
1091 {
1092         int ret;
1093         char *path = NULL;
1094
1095         switch (consumer_data->type) {
1096         case LTTNG_CONSUMER_KERNEL:
1097                 path = the_config.kconsumerd_path.value;
1098                 break;
1099         case LTTNG_CONSUMER64_UST:
1100                 path = the_config.consumerd64_path.value;
1101                 break;
1102         case LTTNG_CONSUMER32_UST:
1103                 path = the_config.consumerd32_path.value;
1104                 break;
1105         default:
1106                 ERR("Consumer type unknown");
1107                 ret = -EINVAL;
1108                 goto error;
1109         }
1110         LTTNG_ASSERT(path);
1111
1112         DBG2("Creating consumer directory: %s", path);
1113
1114         ret = mkdir(path, S_IRWXU | S_IRGRP | S_IXGRP);
1115         if (ret < 0 && errno != EEXIST) {
1116                 PERROR("mkdir");
1117                 ERR("Failed to create %s", path);
1118                 goto error;
1119         }
1120         if (is_root) {
1121                 gid_t gid;
1122
1123                 ret = utils_get_group_id(the_config.tracing_group_name.value,
1124                                 true, &gid);
1125                 if (ret) {
1126                         /* Default to root group. */
1127                         gid = 0;
1128                 }
1129
1130                 ret = chown(path, 0, gid);
1131                 if (ret < 0) {
1132                         ERR("Unable to set group on %s", path);
1133                         PERROR("chown");
1134                         goto error;
1135                 }
1136         }
1137
1138         /* Create the consumerd error unix socket */
1139         consumer_data->err_sock =
1140                 lttcomm_create_unix_sock(consumer_data->err_unix_sock_path);
1141         if (consumer_data->err_sock < 0) {
1142                 ERR("Create unix sock failed: %s", consumer_data->err_unix_sock_path);
1143                 ret = -1;
1144                 goto error;
1145         }
1146
1147         /*
1148          * Set the CLOEXEC flag. Return code is useless because either way, the
1149          * show must go on.
1150          */
1151         ret = utils_set_fd_cloexec(consumer_data->err_sock);
1152         if (ret < 0) {
1153                 PERROR("utils_set_fd_cloexec");
1154                 /* continue anyway */
1155         }
1156
1157         /* File permission MUST be 660 */
1158         ret = chmod(consumer_data->err_unix_sock_path,
1159                         S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
1160         if (ret < 0) {
1161                 ERR("Set file permissions failed: %s", consumer_data->err_unix_sock_path);
1162                 PERROR("chmod");
1163                 goto error;
1164         }
1165
1166 error:
1167         return ret;
1168 }
1169
1170 /*
1171  * Signal handler for the daemon
1172  *
1173  * Simply stop all worker threads, leaving main() return gracefully after
1174  * joining all threads and calling cleanup().
1175  */
1176 static void sighandler(int sig, siginfo_t *siginfo,
1177                 void *arg __attribute__((unused)))
1178 {
1179         switch (sig) {
1180         case SIGINT:
1181                 DBG("SIGINT caught");
1182                 stop_threads();
1183                 break;
1184         case SIGTERM:
1185                 DBG("SIGTERM caught");
1186                 stop_threads();
1187                 break;
1188         case SIGUSR1:
1189                 CMM_STORE_SHARED(recv_child_signal, 1);
1190                 break;
1191         case SIGBUS:
1192         {
1193                 int write_ret;
1194                 const char msg[] = "Received SIGBUS, aborting program.\n";
1195
1196                 lttng_ust_handle_sigbus(siginfo->si_addr);
1197                 /*
1198                  * If ustctl did not catch this signal (triggering a
1199                  * siglongjmp), abort the program. Otherwise, the execution
1200                  * will resume from the ust-ctl call which caused this error.
1201                  *
1202                  * The return value is ignored since the program aborts anyhow.
1203                  */
1204                 write_ret = write(STDERR_FILENO, msg, sizeof(msg));
1205                 (void) write_ret;
1206                 abort();
1207         }
1208         default:
1209                 break;
1210         }
1211 }
1212
1213 /*
1214  * Setup signal handler for :
1215  *              SIGINT, SIGTERM, SIGPIPE
1216  */
1217 static int set_signal_handler(void)
1218 {
1219         int ret = 0;
1220         struct sigaction sa;
1221         sigset_t sigset;
1222
1223         if ((ret = sigemptyset(&sigset)) < 0) {
1224                 PERROR("sigemptyset");
1225                 return ret;
1226         }
1227
1228         sa.sa_mask = sigset;
1229         sa.sa_flags = SA_SIGINFO;
1230
1231         sa.sa_sigaction = sighandler;
1232         if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
1233                 PERROR("sigaction");
1234                 return ret;
1235         }
1236
1237         if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) {
1238                 PERROR("sigaction");
1239                 return ret;
1240         }
1241
1242         if ((ret = sigaction(SIGUSR1, &sa, NULL)) < 0) {
1243                 PERROR("sigaction");
1244                 return ret;
1245         }
1246
1247         if ((ret = sigaction(SIGBUS, &sa, NULL)) < 0) {
1248                 PERROR("sigaction");
1249                 return ret;
1250         }
1251
1252         sa.sa_flags = 0;
1253         sa.sa_handler = SIG_IGN;
1254         if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) {
1255                 PERROR("sigaction");
1256                 return ret;
1257         }
1258
1259         DBG("Signal handler set for SIGTERM, SIGUSR1, SIGPIPE, SIGINT, and SIGBUS");
1260
1261         return ret;
1262 }
1263
1264 /*
1265  * Set open files limit to unlimited. This daemon can open a large number of
1266  * file descriptors in order to consume multiple kernel traces.
1267  */
1268 static void set_ulimit(void)
1269 {
1270         int ret;
1271         struct rlimit lim;
1272
1273         /* The kernel does not allow an infinite limit for open files */
1274         lim.rlim_cur = 65535;
1275         lim.rlim_max = 65535;
1276
1277         ret = setrlimit(RLIMIT_NOFILE, &lim);
1278         if (ret < 0) {
1279                 PERROR("failed to set open files limit");
1280         }
1281 }
1282
1283 static int write_pidfile(void)
1284 {
1285         return utils_create_pid_file(getpid(), the_config.pid_file_path.value);
1286 }
1287
1288 static int set_clock_plugin_env(void)
1289 {
1290         int ret = 0;
1291         char *env_value = NULL;
1292
1293         if (!the_config.lttng_ust_clock_plugin.value) {
1294                 goto end;
1295         }
1296
1297         ret = asprintf(&env_value, "LTTNG_UST_CLOCK_PLUGIN=%s",
1298                         the_config.lttng_ust_clock_plugin.value);
1299         if (ret < 0) {
1300                 PERROR("asprintf");
1301                 goto end;
1302         }
1303
1304         ret = putenv(env_value);
1305         if (ret) {
1306                 free(env_value);
1307                 PERROR("putenv of LTTNG_UST_CLOCK_PLUGIN");
1308                 goto end;
1309         }
1310
1311         DBG("Updated LTTNG_UST_CLOCK_PLUGIN environment variable to \"%s\"",
1312                         the_config.lttng_ust_clock_plugin.value);
1313 end:
1314         return ret;
1315 }
1316
1317 static void destroy_all_sessions_and_wait(void)
1318 {
1319         struct ltt_session *session, *tmp;
1320         struct ltt_session_list *session_list;
1321
1322         session_list = session_get_list();
1323         DBG("Initiating destruction of all sessions");
1324
1325         if (!session_list) {
1326                 return;
1327         }
1328
1329         session_lock_list();
1330         /* Initiate the destruction of all sessions. */
1331         cds_list_for_each_entry_safe(session, tmp,
1332                         &session_list->head, list) {
1333                 if (!session_get(session)) {
1334                         continue;
1335                 }
1336
1337                 session_lock(session);
1338                 if (session->destroyed) {
1339                         goto unlock_session;
1340                 }
1341                 (void) cmd_stop_trace(session);
1342                 (void) cmd_destroy_session(
1343                                 session, the_notification_thread_handle, NULL);
1344         unlock_session:
1345                 session_unlock(session);
1346                 session_put(session);
1347         }
1348         session_unlock_list();
1349
1350         /* Wait for the destruction of all sessions to complete. */
1351         DBG("Waiting for the destruction of all sessions to complete");
1352         session_list_wait_empty();
1353         DBG("Destruction of all sessions completed");
1354 }
1355
1356 static void unregister_all_triggers(void)
1357 {
1358         enum lttng_error_code ret_code;
1359         enum lttng_trigger_status trigger_status;
1360         struct lttng_triggers *triggers = NULL;
1361         unsigned int trigger_count, i;
1362         const struct lttng_credentials creds = {
1363                 .uid = LTTNG_OPTIONAL_INIT_VALUE(0),
1364         };
1365
1366         DBG("Unregistering all triggers");
1367
1368         /*
1369          * List all triggers as "root" since we wish to unregister all triggers.
1370          */
1371         ret_code = notification_thread_command_list_triggers(
1372                         the_notification_thread_handle, creds.uid.value,
1373                         &triggers);
1374         if (ret_code != LTTNG_OK) {
1375                 ERR("Failed to list triggers while unregistering all triggers");
1376                 goto end;
1377         }
1378
1379         trigger_status = lttng_triggers_get_count(triggers, &trigger_count);
1380         LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1381
1382         for (i = 0; i < trigger_count; i++) {
1383                 uid_t trigger_owner;
1384                 const char *trigger_name;
1385                 const struct lttng_trigger *trigger =
1386                                 lttng_triggers_get_at_index(triggers, i);
1387
1388                 LTTNG_ASSERT(trigger);
1389
1390                 trigger_status = lttng_trigger_get_owner_uid(
1391                                 trigger, &trigger_owner);
1392                 LTTNG_ASSERT(trigger_status == LTTNG_TRIGGER_STATUS_OK);
1393
1394                 trigger_status = lttng_trigger_get_name(trigger, &trigger_name);
1395                 trigger_name = trigger_status == LTTNG_TRIGGER_STATUS_OK ?
1396                                 trigger_name : "(anonymous)";
1397
1398                 DBG("Unregistering trigger: trigger owner uid = %d, trigger name = '%s'",
1399                                 (int) trigger_owner, trigger_name);
1400
1401                 ret_code = cmd_unregister_trigger(&creds, trigger,
1402                                 the_notification_thread_handle);
1403                 if (ret_code != LTTNG_OK) {
1404                         ERR("Failed to unregister trigger: trigger owner uid = %d, trigger name = '%s', error: '%s'",
1405                                         (int) trigger_owner, trigger_name,
1406                                         lttng_strerror(-ret_code));
1407                         /* Continue to unregister the remaining triggers. */
1408                 }
1409         }
1410 end:
1411         lttng_triggers_destroy(triggers);
1412 }
1413
1414 static int run_as_worker_post_fork_cleanup(void *data)
1415 {
1416         struct sessiond_config *sessiond_config = (struct sessiond_config *) data;
1417
1418         sessiond_config_fini(sessiond_config);
1419         return 0;
1420 }
1421
1422 static int launch_run_as_worker(const char *procname)
1423 {
1424         /*
1425          * Clean-up before forking the run-as worker. Any dynamically
1426          * allocated memory of which the worker is not aware will
1427          * be leaked as the process forks a run-as worker (and performs
1428          * no exec*()). The same would apply to any opened fd.
1429          */
1430         return run_as_create_worker(
1431                         procname, run_as_worker_post_fork_cleanup, &the_config);
1432 }
1433
1434 static void sessiond_uuid_log(void)
1435 {
1436         char uuid_str[LTTNG_UUID_STR_LEN];
1437
1438         lttng_uuid_to_str(the_sessiond_uuid, uuid_str);
1439         DBG("Starting lttng-sessiond {%s}", uuid_str);
1440 }
1441
1442 /*
1443  * main
1444  */
1445 int main(int argc, char **argv)
1446 {
1447         int ret = 0, retval = 0;
1448         const char *env_app_timeout;
1449         struct lttng_pipe *ust32_channel_monitor_pipe = NULL,
1450                         *ust64_channel_monitor_pipe = NULL,
1451                         *kernel_channel_monitor_pipe = NULL;
1452         struct timer_thread_parameters timer_thread_parameters;
1453         /* Rotation thread handle. */
1454         struct rotation_thread_handle *rotation_thread_handle = NULL;
1455         /* Queue of rotation jobs populated by the sessiond-timer. */
1456         struct rotation_thread_timer_queue *rotation_timer_queue = NULL;
1457         struct lttng_thread *client_thread = NULL;
1458         struct lttng_thread *notification_thread = NULL;
1459         struct lttng_thread *register_apps_thread = NULL;
1460         enum event_notifier_error_accounting_status event_notifier_error_accounting_status;
1461
1462         logger_set_thread_name("Main", false);
1463         init_kernel_workarounds();
1464
1465         rcu_register_thread();
1466
1467         if (set_signal_handler()) {
1468                 retval = -1;
1469                 goto exit_set_signal_handler;
1470         }
1471
1472         if (timer_signal_init()) {
1473                 retval = -1;
1474                 goto exit_set_signal_handler;
1475         }
1476
1477         the_page_size = sysconf(_SC_PAGE_SIZE);
1478         if (the_page_size < 0) {
1479                 PERROR("sysconf _SC_PAGE_SIZE");
1480                 the_page_size = LONG_MAX;
1481                 WARN("Fallback page size to %ld", the_page_size);
1482         }
1483
1484         ret = sessiond_config_init(&the_config);
1485         if (ret) {
1486                 retval = -1;
1487                 goto exit_set_signal_handler;
1488         }
1489
1490         /*
1491          * Init config from environment variables.
1492          * Command line option override env configuration per-doc. Do env first.
1493          */
1494         sessiond_config_apply_env_config(&the_config);
1495
1496         /*
1497          * Parse arguments and load the daemon configuration file.
1498          *
1499          * We have an exit_options exit path to free memory reserved by
1500          * set_options.
1501          */
1502         progname = argv[0];
1503         if (set_options(argc, argv)) {
1504                 retval = -1;
1505                 goto exit_options;
1506         }
1507
1508         /*
1509          * Resolve all paths received as arguments, configuration option, or
1510          * through environment variable as absolute paths. This is necessary
1511          * since daemonizing causes the sessiond's current working directory
1512          * to '/'.
1513          */
1514         ret = sessiond_config_resolve_paths(&the_config);
1515         if (ret) {
1516                 goto exit_options;
1517         }
1518
1519         /* Apply config. */
1520         lttng_opt_verbose = the_config.verbose;
1521         lttng_opt_quiet = the_config.quiet;
1522         the_kconsumer_data.err_unix_sock_path =
1523                         the_config.kconsumerd_err_unix_sock_path.value;
1524         the_kconsumer_data.cmd_unix_sock_path =
1525                         the_config.kconsumerd_cmd_unix_sock_path.value;
1526         the_ustconsumer32_data.err_unix_sock_path =
1527                         the_config.consumerd32_err_unix_sock_path.value;
1528         the_ustconsumer32_data.cmd_unix_sock_path =
1529                         the_config.consumerd32_cmd_unix_sock_path.value;
1530         the_ustconsumer64_data.err_unix_sock_path =
1531                         the_config.consumerd64_err_unix_sock_path.value;
1532         the_ustconsumer64_data.cmd_unix_sock_path =
1533                         the_config.consumerd64_cmd_unix_sock_path.value;
1534         set_clock_plugin_env();
1535
1536         sessiond_config_log(&the_config);
1537         sessiond_uuid_log();
1538
1539         if (opt_print_version) {
1540                 print_version();
1541                 retval = 0;
1542                 goto exit_options;
1543         }
1544
1545         if (create_lttng_rundir()) {
1546                 retval = -1;
1547                 goto exit_options;
1548         }
1549
1550         /* Abort launch if a session daemon is already running. */
1551         if (check_existing_daemon()) {
1552                 ERR("A session daemon is already running.");
1553                 retval = -1;
1554                 goto exit_options;
1555         }
1556
1557         /* Daemonize */
1558         if (the_config.daemonize || the_config.background) {
1559                 int i;
1560
1561                 ret = lttng_daemonize(&the_child_ppid, &recv_child_signal,
1562                                 !the_config.background);
1563                 if (ret < 0) {
1564                         retval = -1;
1565                         goto exit_options;
1566                 }
1567
1568                 /*
1569                  * We are in the child. Make sure all other file descriptors are
1570                  * closed, in case we are called with more opened file
1571                  * descriptors than the standard ones and the lock file.
1572                  */
1573                 for (i = 3; i < sysconf(_SC_OPEN_MAX); i++) {
1574                         if (i == lockfile_fd) {
1575                                 continue;
1576                         }
1577                         (void) close(i);
1578                 }
1579         }
1580
1581         if (launch_run_as_worker(argv[0]) < 0) {
1582                 goto exit_create_run_as_worker_cleanup;
1583         }
1584
1585         /*
1586          * Starting from here, we can create threads. This needs to be after
1587          * lttng_daemonize due to RCU.
1588          */
1589
1590         /*
1591          * Initialize the health check subsystem. This call should set the
1592          * appropriate time values.
1593          */
1594         the_health_sessiond = health_app_create(NR_HEALTH_SESSIOND_TYPES);
1595         if (!the_health_sessiond) {
1596                 PERROR("health_app_create error");
1597                 retval = -1;
1598                 goto stop_threads;
1599         }
1600
1601         /* Create thread quit pipe */
1602         if (sessiond_init_thread_quit_pipe()) {
1603                 retval = -1;
1604                 goto stop_threads;
1605         }
1606
1607         /* Check if daemon is UID = 0 */
1608         is_root = !getuid();
1609         if (is_root) {
1610                 /* Create global run dir with root access */
1611
1612                 kernel_channel_monitor_pipe = lttng_pipe_open(0);
1613                 if (!kernel_channel_monitor_pipe) {
1614                         ERR("Failed to create kernel consumer channel monitor pipe");
1615                         retval = -1;
1616                         goto stop_threads;
1617                 }
1618                 the_kconsumer_data.channel_monitor_pipe =
1619                                 lttng_pipe_release_writefd(
1620                                                 kernel_channel_monitor_pipe);
1621                 if (the_kconsumer_data.channel_monitor_pipe < 0) {
1622                         retval = -1;
1623                         goto stop_threads;
1624                 }
1625         }
1626
1627         /* Set consumer initial state */
1628         the_kernel_consumerd_state = CONSUMER_STOPPED;
1629         the_ust_consumerd_state = CONSUMER_STOPPED;
1630
1631         ust32_channel_monitor_pipe = lttng_pipe_open(0);
1632         if (!ust32_channel_monitor_pipe) {
1633                 ERR("Failed to create 32-bit user space consumer channel monitor pipe");
1634                 retval = -1;
1635                 goto stop_threads;
1636         }
1637         the_ustconsumer32_data.channel_monitor_pipe =
1638                         lttng_pipe_release_writefd(ust32_channel_monitor_pipe);
1639         if (the_ustconsumer32_data.channel_monitor_pipe < 0) {
1640                 retval = -1;
1641                 goto stop_threads;
1642         }
1643
1644         /*
1645          * The rotation_thread_timer_queue structure is shared between the
1646          * sessiond timer thread and the rotation thread. The main thread keeps
1647          * its ownership and destroys it when both threads have been joined.
1648          */
1649         rotation_timer_queue = rotation_thread_timer_queue_create();
1650         if (!rotation_timer_queue) {
1651                 retval = -1;
1652                 goto stop_threads;
1653         }
1654         timer_thread_parameters.rotation_thread_job_queue =
1655                         rotation_timer_queue;
1656
1657         ust64_channel_monitor_pipe = lttng_pipe_open(0);
1658         if (!ust64_channel_monitor_pipe) {
1659                 ERR("Failed to create 64-bit user space consumer channel monitor pipe");
1660                 retval = -1;
1661                 goto stop_threads;
1662         }
1663         the_ustconsumer64_data.channel_monitor_pipe =
1664                         lttng_pipe_release_writefd(ust64_channel_monitor_pipe);
1665         if (the_ustconsumer64_data.channel_monitor_pipe < 0) {
1666                 retval = -1;
1667                 goto stop_threads;
1668         }
1669
1670         /*
1671          * Init UST app hash table. Alloc hash table before this point since
1672          * cleanup() can get called after that point.
1673          */
1674         if (ust_app_ht_alloc()) {
1675                 ERR("Failed to allocate UST app hash table");
1676                 retval = -1;
1677                 goto stop_threads;
1678         }
1679
1680         event_notifier_error_accounting_status = event_notifier_error_accounting_init(
1681                         the_config.event_notifier_buffer_size_kernel,
1682                         the_config.event_notifier_buffer_size_userspace);
1683         if (event_notifier_error_accounting_status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) {
1684                 ERR("Failed to initialize event notifier error accounting system");
1685                 retval = -1;
1686                 goto stop_threads;
1687         }
1688
1689         /*
1690          * Initialize agent app hash table. We allocate the hash table here
1691          * since cleanup() can get called after this point.
1692          */
1693         if (agent_app_ht_alloc()) {
1694                 ERR("Failed to allocate Agent app hash table");
1695                 retval = -1;
1696                 goto stop_threads;
1697         }
1698
1699         if (agent_by_event_notifier_domain_ht_create()) {
1700                 ERR("Failed to allocate per-event notifier domain agent hash table");
1701                 retval = -1;
1702                 goto stop_threads;
1703         }
1704         /*
1705          * These actions must be executed as root. We do that *after* setting up
1706          * the sockets path because we MUST make the check for another daemon using
1707          * those paths *before* trying to set the kernel consumer sockets and init
1708          * kernel tracer.
1709          */
1710         if (is_root) {
1711                 if (set_consumer_sockets(&the_kconsumer_data)) {
1712                         retval = -1;
1713                         goto stop_threads;
1714                 }
1715
1716                 /* Setup kernel tracer */
1717                 if (!the_config.no_kernel) {
1718                         init_kernel_tracer();
1719                 }
1720
1721                 /* Set ulimit for open files */
1722                 set_ulimit();
1723         }
1724         /* init lttng_fd tracking must be done after set_ulimit. */
1725         lttng_fd_init();
1726
1727         if (set_consumer_sockets(&the_ustconsumer64_data)) {
1728                 retval = -1;
1729                 goto stop_threads;
1730         }
1731
1732         if (set_consumer_sockets(&the_ustconsumer32_data)) {
1733                 retval = -1;
1734                 goto stop_threads;
1735         }
1736
1737         /* Get parent pid if -S, --sig-parent is specified. */
1738         if (the_config.sig_parent) {
1739                 the_ppid = getppid();
1740         }
1741
1742         /* Setup the kernel pipe for waking up the kernel thread */
1743         if (is_root && !the_config.no_kernel) {
1744                 if (utils_create_pipe_cloexec(the_kernel_poll_pipe)) {
1745                         retval = -1;
1746                         goto stop_threads;
1747                 }
1748         }
1749
1750         /* Setup the thread apps communication pipe. */
1751         if (utils_create_pipe_cloexec(apps_cmd_pipe)) {
1752                 retval = -1;
1753                 goto stop_threads;
1754         }
1755
1756         /* Setup the thread apps notify communication pipe. */
1757         if (utils_create_pipe_cloexec(apps_cmd_notify_pipe)) {
1758                 retval = -1;
1759                 goto stop_threads;
1760         }
1761
1762         /* Initialize global buffer per UID and PID registry. */
1763         buffer_reg_init_uid_registry();
1764         buffer_reg_init_pid_registry();
1765
1766         /* Init UST command queue. */
1767         cds_wfcq_init(&ust_cmd_queue.head, &ust_cmd_queue.tail);
1768
1769         cmd_init();
1770
1771         /* Check for the application socket timeout env variable. */
1772         env_app_timeout = getenv(DEFAULT_APP_SOCKET_TIMEOUT_ENV);
1773         if (env_app_timeout) {
1774                 the_config.app_socket_timeout = atoi(env_app_timeout);
1775         } else {
1776                 the_config.app_socket_timeout = DEFAULT_APP_SOCKET_RW_TIMEOUT;
1777         }
1778
1779         ret = write_pidfile();
1780         if (ret) {
1781                 ERR("Error in write_pidfile");
1782                 retval = -1;
1783                 goto stop_threads;
1784         }
1785
1786         /* Initialize communication library */
1787         lttcomm_init();
1788         /* Initialize TCP timeout values */
1789         lttcomm_inet_init();
1790
1791         /* Create health-check thread. */
1792         if (!launch_health_management_thread()) {
1793                 retval = -1;
1794                 goto stop_threads;
1795         }
1796
1797         /* notification_thread_data acquires the pipes' read side. */
1798         the_notification_thread_handle = notification_thread_handle_create(
1799                         ust32_channel_monitor_pipe, ust64_channel_monitor_pipe,
1800                         kernel_channel_monitor_pipe);
1801         if (!the_notification_thread_handle) {
1802                 retval = -1;
1803                 ERR("Failed to create notification thread shared data");
1804                 goto stop_threads;
1805         }
1806
1807         /* Create notification thread. */
1808         notification_thread = launch_notification_thread(
1809                         the_notification_thread_handle);
1810         if (!notification_thread) {
1811                 retval = -1;
1812                 goto stop_threads;
1813         }
1814
1815         /* Create timer thread. */
1816         if (!launch_timer_thread(&timer_thread_parameters)) {
1817                 retval = -1;
1818                 goto stop_threads;
1819         }
1820
1821         /* rotation_thread_data acquires the pipes' read side. */
1822         rotation_thread_handle = rotation_thread_handle_create(
1823                         rotation_timer_queue, the_notification_thread_handle);
1824         if (!rotation_thread_handle) {
1825                 retval = -1;
1826                 ERR("Failed to create rotation thread shared data");
1827                 stop_threads();
1828                 goto stop_threads;
1829         }
1830
1831         /* Create rotation thread. */
1832         if (!launch_rotation_thread(rotation_thread_handle)) {
1833                 retval = -1;
1834                 goto stop_threads;
1835         }
1836
1837         /* Create thread to manage the client socket */
1838         client_thread = launch_client_thread();
1839         if (!client_thread) {
1840                 retval = -1;
1841                 goto stop_threads;
1842         }
1843
1844         /* Set credentials of the client socket and rundir */
1845         if (is_root && set_permissions(the_config.rundir.value)) {
1846                 retval = -1;
1847                 goto stop_threads;
1848         }
1849
1850         if (!launch_ust_dispatch_thread(&ust_cmd_queue, apps_cmd_pipe[1],
1851                         apps_cmd_notify_pipe[1])) {
1852                 retval = -1;
1853                 goto stop_threads;
1854         }
1855
1856         /* Create thread to manage application registration. */
1857         register_apps_thread = launch_application_registration_thread(
1858                         &ust_cmd_queue);
1859         if (!register_apps_thread) {
1860                 retval = -1;
1861                 goto stop_threads;
1862         }
1863
1864         /* Create thread to manage application socket */
1865         if (!launch_application_management_thread(apps_cmd_pipe[0])) {
1866                 retval = -1;
1867                 goto stop_threads;
1868         }
1869
1870         /* Create thread to manage application notify socket */
1871         if (!launch_application_notification_thread(apps_cmd_notify_pipe[0])) {
1872                 retval = -1;
1873                 goto stop_threads;
1874         }
1875
1876         /* Create agent management thread. */
1877         if (!launch_agent_management_thread()) {
1878                 retval = -1;
1879                 goto stop_threads;
1880         }
1881
1882         /* Don't start this thread if kernel tracing is not requested nor root */
1883         if (is_root && !the_config.no_kernel) {
1884                 /* Create kernel thread to manage kernel event */
1885                 if (!launch_kernel_management_thread(the_kernel_poll_pipe[0])) {
1886                         retval = -1;
1887                         goto stop_threads;
1888                 }
1889
1890                 if (kernel_get_notification_fd() >= 0) {
1891                         ret = notification_thread_command_add_tracer_event_source(
1892                                         the_notification_thread_handle,
1893                                         kernel_get_notification_fd(),
1894                                         LTTNG_DOMAIN_KERNEL);
1895                         if (ret != LTTNG_OK) {
1896                                 ERR("Failed to add kernel trigger event source to notification thread");
1897                                 retval = -1;
1898                                 goto stop_threads;
1899                         }
1900                 }
1901         }
1902
1903         /* Load sessions. */
1904         ret = config_load_session(
1905                         the_config.load_session_path.value, NULL, 1, 1, NULL);
1906         if (ret) {
1907                 ERR("Session load failed: %s", error_get_str(ret));
1908                 retval = -1;
1909                 goto stop_threads;
1910         }
1911
1912         /* Initialization completed. */
1913         sessiond_signal_parents();
1914
1915         /*
1916          * This is where we start awaiting program completion (e.g. through
1917          * signal that asks threads to teardown).
1918          */
1919
1920         /* Initiate teardown once activity occurs on the quit pipe. */
1921         sessiond_wait_for_quit_pipe(-1);
1922
1923 stop_threads:
1924
1925         /*
1926          * Ensure that the client thread is no longer accepting new commands,
1927          * which could cause new sessions to be created.
1928          */
1929         if (client_thread) {
1930                 lttng_thread_shutdown(client_thread);
1931                 lttng_thread_put(client_thread);
1932         }
1933
1934         destroy_all_sessions_and_wait();
1935
1936         /*
1937          * At this point no new trigger can be registered (no sessions are
1938          * running/rotating) and clients can't connect to the session daemon
1939          * anymore. Unregister all triggers.
1940          */
1941         unregister_all_triggers();
1942
1943         if (register_apps_thread) {
1944                 lttng_thread_shutdown(register_apps_thread);
1945                 lttng_thread_put(register_apps_thread);
1946         }
1947         lttng_thread_list_shutdown_orphans();
1948
1949         /*
1950          * Wait for all pending call_rcu work to complete before tearing
1951          * down data structures. call_rcu worker may be trying to
1952          * perform lookups in those structures.
1953          */
1954         rcu_barrier();
1955
1956         rcu_thread_online();
1957         sessiond_cleanup();
1958
1959         /*
1960          * Wait for all pending call_rcu work to complete before shutting down
1961          * the notification thread. This call_rcu work includes shutting down
1962          * UST apps and event notifier pipes.
1963          */
1964         rcu_barrier();
1965
1966         if (notification_thread) {
1967                 lttng_thread_shutdown(notification_thread);
1968                 lttng_thread_put(notification_thread);
1969         }
1970
1971         /*
1972          * Error accounting teardown has to be done after the teardown of all
1973          * event notifier pipes to ensure that no tracer may try to use the
1974          * error accounting facilities.
1975          */
1976         event_notifier_error_accounting_fini();
1977
1978         /*
1979          * Unloading the kernel modules needs to be done after all kernel
1980          * ressources have been released. In our case, this includes the
1981          * notification fd, the event notifier group fd, error accounting fd,
1982          * all event and event notifier fds, etc.
1983          *
1984          * In short, at this point, we need to have called close() on all fds
1985          * received from the kernel tracer.
1986          */
1987         if (is_root && !the_config.no_kernel) {
1988                 DBG("Unloading kernel modules");
1989                 modprobe_remove_lttng_all();
1990         }
1991
1992         rcu_thread_offline();
1993         rcu_unregister_thread();
1994
1995         if (rotation_thread_handle) {
1996                 rotation_thread_handle_destroy(rotation_thread_handle);
1997         }
1998
1999         /*
2000          * After the rotation and timer thread have quit, we can safely destroy
2001          * the rotation_timer_queue.
2002          */
2003         rotation_thread_timer_queue_destroy(rotation_timer_queue);
2004         /*
2005          * The teardown of the notification system is performed after the
2006          * session daemon's teardown in order to allow it to be notified
2007          * of the active session and channels at the moment of the teardown.
2008          */
2009         if (the_notification_thread_handle) {
2010                 notification_thread_handle_destroy(
2011                                 the_notification_thread_handle);
2012         }
2013         lttng_pipe_destroy(ust32_channel_monitor_pipe);
2014         lttng_pipe_destroy(ust64_channel_monitor_pipe);
2015         lttng_pipe_destroy(kernel_channel_monitor_pipe);
2016
2017         if (the_health_sessiond) {
2018                 health_app_destroy(the_health_sessiond);
2019         }
2020 exit_create_run_as_worker_cleanup:
2021 exit_options:
2022         sessiond_cleanup_lock_file();
2023         sessiond_cleanup_options();
2024
2025 exit_set_signal_handler:
2026         if (!retval) {
2027                 exit(EXIT_SUCCESS);
2028         } else {
2029                 exit(EXIT_FAILURE);
2030         }
2031 }