src/bin/lttng-consumerd/lttng-consumerd.c

   1 /*
   2  * Copyright (C) 2011 - Julien Desfossez <julien.desfossez@polymtl.ca>
   3  *                      Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License, version 2 only,
   7  * as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #define _GNU_SOURCE
  20 #include <fcntl.h>
  21 #include <getopt.h>
  22 #include <grp.h>
  23 #include <limits.h>
  24 #include <pthread.h>
  25 #include <signal.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <sys/ipc.h>
  30 #include <sys/resource.h>
  31 #include <sys/shm.h>
  32 #include <sys/socket.h>
  33 #include <sys/stat.h>
  34 #include <sys/types.h>
  35 #include <urcu/list.h>
  36 #include <poll.h>
  37 #include <unistd.h>
  38 #include <sys/mman.h>
  39 #include <assert.h>
  40 #include <config.h>
  41 #include <urcu/compiler.h>
  42 #include <ulimit.h>
  43
  44 #include <common/defaults.h>
  45 #include <common/common.h>
  46 #include <common/consumer.h>
  47 #include <common/consumer-timer.h>
  48 #include <common/compat/poll.h>
  49 #include <common/sessiond-comm/sessiond-comm.h>
  50
  51 #include "lttng-consumerd.h"
  52
  53 /* TODO : support UST (all direct kernel-ctl accesses). */
  54
  55 /* threads (channel handling, poll, metadata, sessiond) */
  56
  57 static pthread_t channel_thread, data_thread, metadata_thread, sessiond_thread;
  58 static pthread_t metadata_timer_thread;
  59
  60 /* to count the number of times the user pressed ctrl+c */
  61 static int sigintcount = 0;
  62
  63 /* Argument variables */
  64 int lttng_opt_quiet;    /* not static in error.h */
  65 int lttng_opt_verbose;  /* not static in error.h */
  66 static int opt_daemon;
  67 static const char *progname;
  68 static char command_sock_path[PATH_MAX]; /* Global command socket path */
  69 static char error_sock_path[PATH_MAX]; /* Global error path */
  70 static enum lttng_consumer_type opt_type = LTTNG_CONSUMER_KERNEL;
  71
  72 /* the liblttngconsumerd context */
  73 static struct lttng_consumer_local_data *ctx;
  74
  75 /*
  76  * Signal handler for the daemon
  77  */
  78 static void sighandler(int sig)
  79 {
  80         if (sig == SIGINT && sigintcount++ == 0) {
  81                 DBG("ignoring first SIGINT");
  82                 return;
  83         }
  84
  85         /*
  86          * Ignore SIGPIPE because it should not stop the consumer whenever a
  87          * SIGPIPE is catched through a FD operation.
  88          */
  89         if (sig == SIGPIPE) {
  90                 return;
  91         }
  92
  93         lttng_consumer_should_exit(ctx);
  94 }
  95
  96 /*
  97  * Setup signal handler for :
  98  *      SIGINT, SIGTERM, SIGPIPE
  99  */
 100 static int set_signal_handler(void)
 101 {
 102         int ret = 0;
 103         struct sigaction sa;
 104         sigset_t sigset;
 105
 106         if ((ret = sigemptyset(&sigset)) < 0) {
 107                 perror("sigemptyset");
 108                 return ret;
 109         }
 110
 111         sa.sa_handler = sighandler;
 112         sa.sa_mask = sigset;
 113         sa.sa_flags = 0;
 114         if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
 115                 perror("sigaction");
 116                 return ret;
 117         }
 118
 119         if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) {
 120                 perror("sigaction");
 121                 return ret;
 122         }
 123
 124         if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) {
 125                 perror("sigaction");
 126                 return ret;
 127         }
 128
 129         return ret;
 130 }
 131
 132 /*
 133  * Usage function on stream file.
 134  */
 135 static void usage(FILE *fp)
 136 {
 137         fprintf(fp, "Usage: %s OPTIONS\n\nOptions:\n", progname);
 138         fprintf(fp, "  -h, --help                         "
 139                         "Display this usage.\n");
 140         fprintf(fp, "  -c, --consumerd-cmd-sock PATH     "
 141                         "Specify path for the command socket\n");
 142         fprintf(fp, "  -e, --consumerd-err-sock PATH     "
 143                         "Specify path for the error socket\n");
 144         fprintf(fp, "  -d, --daemonize                    "
 145                         "Start as a daemon.\n");
 146         fprintf(fp, "  -q, --quiet                        "
 147                         "No output at all.\n");
 148         fprintf(fp, "  -v, --verbose                      "
 149                         "Verbose mode. Activate DBG() macro.\n");
 150         fprintf(fp, "  -V, --version                      "
 151                         "Show version number.\n");
 152         fprintf(fp, "  -k, --kernel                       "
 153                         "Consumer kernel buffers (default).\n");
 154         fprintf(fp, "  -u, --ust                          "
 155                         "Consumer UST buffers.%s\n",
 156 #ifdef HAVE_LIBLTTNG_UST_CTL
 157                         ""
 158 #else
 159                         " (support not compiled in)"
 160 #endif
 161                         );
 162 }
 163
 164 /*
 165  * daemon argument parsing
 166  */
 167 static void parse_args(int argc, char **argv)
 168 {
 169         int c;
 170
 171         static struct option long_options[] = {
 172                 { "consumerd-cmd-sock", 1, 0, 'c' },
 173                 { "consumerd-err-sock", 1, 0, 'e' },
 174                 { "daemonize", 0, 0, 'd' },
 175                 { "help", 0, 0, 'h' },
 176                 { "quiet", 0, 0, 'q' },
 177                 { "verbose", 0, 0, 'v' },
 178                 { "version", 0, 0, 'V' },
 179                 { "kernel", 0, 0, 'k' },
 180 #ifdef HAVE_LIBLTTNG_UST_CTL
 181                 { "ust", 0, 0, 'u' },
 182 #endif
 183                 { NULL, 0, 0, 0 }
 184         };
 185
 186         while (1) {
 187                 int option_index = 0;
 188                 c = getopt_long(argc, argv, "dhqvVku" "c:e:", long_options, &option_index);
 189                 if (c == -1) {
 190                         break;
 191                 }
 192
 193                 switch (c) {
 194                 case 0:
 195                         fprintf(stderr, "option %s", long_options[option_index].name);
 196                         if (optarg) {
 197                                 fprintf(stderr, " with arg %s\n", optarg);
 198                         }
 199                         break;
 200                 case 'c':
 201                         snprintf(command_sock_path, PATH_MAX, "%s", optarg);
 202                         break;
 203                 case 'e':
 204                         snprintf(error_sock_path, PATH_MAX, "%s", optarg);
 205                         break;
 206                 case 'd':
 207                         opt_daemon = 1;
 208                         break;
 209                 case 'h':
 210                         usage(stdout);
 211                         exit(EXIT_SUCCESS);
 212                 case 'q':
 213                         lttng_opt_quiet = 1;
 214                         break;
 215                 case 'v':
 216                         lttng_opt_verbose = 1;
 217                         break;
 218                 case 'V':
 219                         fprintf(stdout, "%s\n", VERSION);
 220                         exit(EXIT_SUCCESS);
 221                 case 'k':
 222                         opt_type = LTTNG_CONSUMER_KERNEL;
 223                         break;
 224 #ifdef HAVE_LIBLTTNG_UST_CTL
 225                 case 'u':
 226 # if (CAA_BITS_PER_LONG == 64)
 227                         opt_type = LTTNG_CONSUMER64_UST;
 228 # elif (CAA_BITS_PER_LONG == 32)
 229                         opt_type = LTTNG_CONSUMER32_UST;
 230 # else
 231 #  error "Unknown bitness"
 232 # endif
 233                         break;
 234 #endif
 235                 default:
 236                         usage(stderr);
 237                         exit(EXIT_FAILURE);
 238                 }
 239         }
 240 }
 241
 242 /*
 243  * Set open files limit to unlimited. This daemon can open a large number of
 244  * file descriptors in order to consumer multiple kernel traces.
 245  */
 246 static void set_ulimit(void)
 247 {
 248         int ret;
 249         struct rlimit lim;
 250
 251         /* The kernel does not allowed an infinite limit for open files */
 252         lim.rlim_cur = 65535;
 253         lim.rlim_max = 65535;
 254
 255         ret = setrlimit(RLIMIT_NOFILE, &lim);
 256         if (ret < 0) {
 257                 PERROR("failed to set open files limit");
 258         }
 259 }
 260
 261 /*
 262  * main
 263  */
 264 int main(int argc, char **argv)
 265 {
 266         int ret = 0;
 267         void *status;
 268
 269         /* Parse arguments */
 270         progname = argv[0];
 271         parse_args(argc, argv);
 272
 273         /* Daemonize */
 274         if (opt_daemon) {
 275                 int i;
 276
 277                 /*
 278                  * fork
 279                  * child: setsid, close FD 0, 1, 2, chdir /
 280                  * parent: exit (if fork is successful)
 281                  */
 282                 ret = daemon(0, 0);
 283                 if (ret < 0) {
 284                         PERROR("daemon");
 285                         goto error;
 286                 }
 287                 /*
 288                  * We are in the child. Make sure all other file
 289                  * descriptors are closed, in case we are called with
 290                  * more opened file descriptors than the standard ones.
 291                  */
 292                 for (i = 3; i < sysconf(_SC_OPEN_MAX); i++) {
 293                         (void) close(i);
 294                 }
 295         }
 296
 297         /* Set up max poll set size */
 298         lttng_poll_set_max_size();
 299
 300         if (*command_sock_path == '\0') {
 301                 switch (opt_type) {
 302                 case LTTNG_CONSUMER_KERNEL:
 303                         snprintf(command_sock_path, PATH_MAX, DEFAULT_KCONSUMERD_CMD_SOCK_PATH,
 304                                         DEFAULT_LTTNG_RUNDIR);
 305                         break;
 306                 case LTTNG_CONSUMER64_UST:
 307                         snprintf(command_sock_path, PATH_MAX,
 308                                         DEFAULT_USTCONSUMERD64_CMD_SOCK_PATH, DEFAULT_LTTNG_RUNDIR);
 309                         break;
 310                 case LTTNG_CONSUMER32_UST:
 311                         snprintf(command_sock_path, PATH_MAX,
 312                                         DEFAULT_USTCONSUMERD32_CMD_SOCK_PATH, DEFAULT_LTTNG_RUNDIR);
 313                         break;
 314                 default:
 315                         WARN("Unknown consumerd type");
 316                         goto error;
 317                 }
 318         }
 319
 320         /* Init */
 321         lttng_consumer_init();
 322
 323         if (!getuid()) {
 324                 /* Set limit for open files */
 325                 set_ulimit();
 326         }
 327
 328         /* create the consumer instance with and assign the callbacks */
 329         ctx = lttng_consumer_create(opt_type, lttng_consumer_read_subbuffer,
 330                 NULL, lttng_consumer_on_recv_stream, NULL);
 331         if (ctx == NULL) {
 332                 goto error;
 333         }
 334
 335         lttng_consumer_set_command_sock_path(ctx, command_sock_path);
 336         if (*error_sock_path == '\0') {
 337                 switch (opt_type) {
 338                 case LTTNG_CONSUMER_KERNEL:
 339                         snprintf(error_sock_path, PATH_MAX, DEFAULT_KCONSUMERD_ERR_SOCK_PATH,
 340                                         DEFAULT_LTTNG_RUNDIR);
 341                         break;
 342                 case LTTNG_CONSUMER64_UST:
 343                         snprintf(error_sock_path, PATH_MAX,
 344                                         DEFAULT_USTCONSUMERD64_ERR_SOCK_PATH, DEFAULT_LTTNG_RUNDIR);
 345                         break;
 346                 case LTTNG_CONSUMER32_UST:
 347                         snprintf(error_sock_path, PATH_MAX,
 348                                         DEFAULT_USTCONSUMERD32_ERR_SOCK_PATH, DEFAULT_LTTNG_RUNDIR);
 349                         break;
 350                 default:
 351                         WARN("Unknown consumerd type");
 352                         goto error;
 353                 }
 354         }
 355
 356         if (set_signal_handler() < 0) {
 357                 goto error;
 358         }
 359
 360         /* Connect to the socket created by lttng-sessiond to report errors */
 361         DBG("Connecting to error socket %s", error_sock_path);
 362         ret = lttcomm_connect_unix_sock(error_sock_path);
 363         /* not a fatal error, but all communication with lttng-sessiond will fail */
 364         if (ret < 0) {
 365                 WARN("Cannot connect to error socket (is lttng-sessiond started?)");
 366         }
 367         lttng_consumer_set_error_sock(ctx, ret);
 368
 369         /*
 370          * For UST consumer, we block RT signals used for periodical metadata flush
 371          * in main and create a dedicated thread to handle these signals.
 372          */
 373         switch (opt_type) {
 374         case LTTNG_CONSUMER32_UST:
 375         case LTTNG_CONSUMER64_UST:
 376                 consumer_signal_init();
 377                 break;
 378         default:
 379                 break;
 380         }
 381         ctx->type = opt_type;
 382
 383         /* Create thread to manage channels */
 384         ret = pthread_create(&channel_thread, NULL, consumer_thread_channel_poll,
 385                         (void *) ctx);
 386         if (ret != 0) {
 387                 perror("pthread_create");
 388                 goto error;
 389         }
 390
 391         /* Create thread to manage the polling/writing of trace metadata */
 392         ret = pthread_create(&metadata_thread, NULL, consumer_thread_metadata_poll,
 393                         (void *) ctx);
 394         if (ret != 0) {
 395                 perror("pthread_create");
 396                 goto metadata_error;
 397         }
 398
 399         /* Create thread to manage the polling/writing of trace data */
 400         ret = pthread_create(&data_thread, NULL, consumer_thread_data_poll,
 401                         (void *) ctx);
 402         if (ret != 0) {
 403                 perror("pthread_create");
 404                 goto data_error;
 405         }
 406
 407         /* Create the thread to manage the receive of fd */
 408         ret = pthread_create(&sessiond_thread, NULL, consumer_thread_sessiond_poll,
 409                         (void *) ctx);
 410         if (ret != 0) {
 411                 perror("pthread_create");
 412                 goto sessiond_error;
 413         }
 414
 415         switch (opt_type) {
 416         case LTTNG_CONSUMER32_UST:
 417         case LTTNG_CONSUMER64_UST:
 418                 /* Create the thread to manage the metadata periodic timers */
 419                 ret = pthread_create(&metadata_timer_thread, NULL,
 420                                 consumer_timer_metadata_thread, (void *) ctx);
 421                 if (ret != 0) {
 422                         perror("pthread_create");
 423                         goto metadata_timer_error;
 424                 }
 425
 426                 ret = pthread_detach(metadata_timer_thread);
 427                 if (ret) {
 428                         errno = ret;
 429                         perror("pthread_detach");
 430                 }
 431                 break;
 432         default:
 433                 break;
 434         }
 435
 436 metadata_timer_error:
 437         ret = pthread_join(sessiond_thread, &status);
 438         if (ret != 0) {
 439                 perror("pthread_join");
 440                 goto error;
 441         }
 442
 443 sessiond_error:
 444         ret = pthread_join(data_thread, &status);
 445         if (ret != 0) {
 446                 perror("pthread_join");
 447                 goto error;
 448         }
 449
 450 data_error:
 451         ret = pthread_join(metadata_thread, &status);
 452         if (ret != 0) {
 453                 perror("pthread_join");
 454                 goto error;
 455         }
 456
 457 metadata_error:
 458         ret = pthread_join(channel_thread, &status);
 459         if (ret != 0) {
 460                 perror("pthread_join");
 461                 goto error;
 462         }
 463
 464         if (!ret) {
 465                 ret = EXIT_SUCCESS;
 466                 lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_EXIT_SUCCESS);
 467                 goto end;
 468         }
 469
 470 error:
 471         ret = EXIT_FAILURE;
 472         if (ctx) {
 473                 lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_EXIT_FAILURE);
 474         }
 475
 476 end:
 477         lttng_consumer_destroy(ctx);
 478         lttng_consumer_cleanup();
 479
 480         return ret;
 481 }