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
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; only version 2
   8  * of the License.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18  */
  19
  20 #define _GNU_SOURCE
  21 #include <fcntl.h>
  22 #include <getopt.h>
  23 #include <grp.h>
  24 #include <limits.h>
  25 #include <pthread.h>
  26 #include <signal.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <sys/ipc.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
  42 #include <lttng-consumerd.h>
  43 #include <lttng-kernel-ctl.h>
  44 #include <lttng-sessiond-comm.h>
  45 #include <lttng/lttng-kconsumer.h>
  46 #include <lttng/lttng-ustconsumer.h>
  47 #include <lttngerr.h>
  48
  49 /* TODO : support UST (all direct kernctl accesses). */
  50
  51 /* the two threads (receive fd and poll) */
  52 static pthread_t threads[2];
  53
  54 /* to count the number of time the user pressed ctrl+c */
  55 static int sigintcount = 0;
  56
  57 /* Argument variables */
  58 int opt_quiet;
  59 int opt_verbose;
  60 static int opt_daemon;
  61 static const char *progname;
  62 static char command_sock_path[PATH_MAX]; /* Global command socket path */
  63 static char error_sock_path[PATH_MAX]; /* Global error path */
  64 static enum lttng_consumer_type opt_type = LTTNG_CONSUMER_KERNEL;
  65
  66 /* the liblttngkconsumerd context */
  67 static struct lttng_consumer_local_data *ctx;
  68
  69 /*
  70  * Signal handler for the daemon
  71  */
  72 static void sighandler(int sig)
  73 {
  74         if (sig == SIGINT && sigintcount++ == 0) {
  75                 DBG("ignoring first SIGINT");
  76                 return;
  77         }
  78
  79         lttng_consumer_should_exit(ctx);
  80 }
  81
  82 /*
  83  * Setup signal handler for :
  84  *      SIGINT, SIGTERM, SIGPIPE
  85  */
  86 static int set_signal_handler(void)
  87 {
  88         int ret = 0;
  89         struct sigaction sa;
  90         sigset_t sigset;
  91
  92         if ((ret = sigemptyset(&sigset)) < 0) {
  93                 perror("sigemptyset");
  94                 return ret;
  95         }
  96
  97         sa.sa_handler = sighandler;
  98         sa.sa_mask = sigset;
  99         sa.sa_flags = 0;
 100         if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
 101                 perror("sigaction");
 102                 return ret;
 103         }
 104
 105         if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) {
 106                 perror("sigaction");
 107                 return ret;
 108         }
 109
 110         if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) {
 111                 perror("sigaction");
 112                 return ret;
 113         }
 114
 115         return ret;
 116 }
 117
 118 /*
 119  * usage function on stderr
 120  */
 121 static void usage(void)
 122 {
 123         fprintf(stderr, "Usage: %s OPTIONS\n\nOptions:\n", progname);
 124         fprintf(stderr, "  -h, --help                         "
 125                         "Display this usage.\n");
 126         fprintf(stderr, "  -c, --kconsumerd-cmd-sock PATH     "
 127                         "Specify path for the command socket\n");
 128         fprintf(stderr, "  -e, --kconsumerd-err-sock PATH     "
 129                         "Specify path for the error socket\n");
 130         fprintf(stderr, "  -d, --daemonize                    "
 131                         "Start as a daemon.\n");
 132         fprintf(stderr, "  -q, --quiet                        "
 133                         "No output at all.\n");
 134         fprintf(stderr, "  -v, --verbose                      "
 135                         "Verbose mode. Activate DBG() macro.\n");
 136         fprintf(stderr, "  -V, --version                      "
 137                         "Show version number.\n");
 138         fprintf(stderr, "  -k, --kernel                       "
 139                         "Consumer kernel buffers (default).\n");
 140         fprintf(stderr, "  -u, --ust                          "
 141                         "Consumer UST buffers.%s\n",
 142 #ifdef HAVE_LIBLTTNG_UST_CTL
 143                         ""
 144 #else
 145                         " (support not compiled in)"
 146 #endif
 147                         );
 148 }
 149
 150 /*
 151  * daemon argument parsing
 152  */
 153 static void parse_args(int argc, char **argv)
 154 {
 155         int c;
 156
 157         static struct option long_options[] = {
 158                 { "kconsumerd-cmd-sock", 1, 0, 'c' },
 159                 { "kconsumerd-err-sock", 1, 0, 'e' },
 160                 { "daemonize", 0, 0, 'd' },
 161                 { "help", 0, 0, 'h' },
 162                 { "quiet", 0, 0, 'q' },
 163                 { "verbose", 0, 0, 'v' },
 164                 { "version", 0, 0, 'V' },
 165                 { "kernel", 0, 0, 'k' },
 166 #ifdef HAVE_LIBLTTNG_UST_CTL
 167                 { "ust", 0, 0, 'u' },
 168 #endif
 169                 { NULL, 0, 0, 0 }
 170         };
 171
 172         while (1) {
 173                 int option_index = 0;
 174                 c = getopt_long(argc, argv, "dhqvVku" "c:e:", long_options, &option_index);
 175                 if (c == -1) {
 176                         break;
 177                 }
 178
 179                 switch (c) {
 180                 case 0:
 181                         fprintf(stderr, "option %s", long_options[option_index].name);
 182                         if (optarg) {
 183                                 fprintf(stderr, " with arg %s\n", optarg);
 184                         }
 185                         break;
 186                 case 'c':
 187                         snprintf(command_sock_path, PATH_MAX, "%s", optarg);
 188                         break;
 189                 case 'e':
 190                         snprintf(error_sock_path, PATH_MAX, "%s", optarg);
 191                         break;
 192                 case 'd':
 193                         opt_daemon = 1;
 194                         break;
 195                 case 'h':
 196                         usage();
 197                         exit(EXIT_FAILURE);
 198                 case 'q':
 199                         opt_quiet = 1;
 200                         break;
 201                 case 'v':
 202                         opt_verbose = 1;
 203                         break;
 204                 case 'V':
 205                         fprintf(stdout, "%s\n", VERSION);
 206                         exit(EXIT_SUCCESS);
 207                 case 'k':
 208                         opt_type = LTTNG_CONSUMER_KERNEL;
 209                         break;
 210 #ifdef HAVE_LIBLTTNG_UST_CTL
 211                 case 'u':
 212                         opt_type = LTTNG_CONSUMER_UST;
 213                         break;
 214 #endif
 215                 default:
 216                         usage();
 217                         exit(EXIT_FAILURE);
 218                 }
 219         }
 220 }
 221
 222 /*
 223  * Consume data on a file descriptor and write it on a trace file.
 224  */
 225 static int read_subbuffer(struct lttng_consumer_stream *stream)
 226 {
 227         unsigned long len;
 228         int err;
 229         long ret = 0;
 230         int infd = stream->wait_fd;
 231
 232         DBG("In read_subbuffer (infd : %d)", infd);
 233         /* Get the next subbuffer */
 234         err = kernctl_get_next_subbuf(infd);
 235         if (err != 0) {
 236                 ret = errno;
 237                 /*
 238                  * This is a debug message even for single-threaded consumer,
 239                  * because poll() have more relaxed criterions than get subbuf,
 240                  * so get_subbuf may fail for short race windows where poll()
 241                  * would issue wakeups.
 242                  */
 243                 DBG("Reserving sub buffer failed (everything is normal, "
 244                                 "it is due to concurrency)");
 245                 goto end;
 246         }
 247
 248         switch (stream->output) {
 249                 case LTTNG_EVENT_SPLICE:
 250                         /* read the whole subbuffer */
 251                         err = kernctl_get_padded_subbuf_size(infd, &len);
 252                         if (err != 0) {
 253                                 ret = errno;
 254                                 perror("Getting sub-buffer len failed.");
 255                                 goto end;
 256                         }
 257
 258                         /* splice the subbuffer to the tracefile */
 259                         ret = lttng_consumer_on_read_subbuffer_splice(ctx, stream, len);
 260                         if (ret < 0) {
 261                                 /*
 262                                  * display the error but continue processing to try
 263                                  * to release the subbuffer
 264                                  */
 265                                 ERR("Error splicing to tracefile");
 266                         }
 267                         break;
 268                 case LTTNG_EVENT_MMAP:
 269                         /* read the used subbuffer size */
 270                         err = kernctl_get_padded_subbuf_size(infd, &len);
 271                         if (err != 0) {
 272                                 ret = errno;
 273                                 perror("Getting sub-buffer len failed.");
 274                                 goto end;
 275                         }
 276                         /* write the subbuffer to the tracefile */
 277                         ret = lttng_consumer_on_read_subbuffer_mmap(ctx, stream, len);
 278                         if (ret < 0) {
 279                                 /*
 280                                  * display the error but continue processing to try
 281                                  * to release the subbuffer
 282                                  */
 283                                 ERR("Error writing to tracefile");
 284                         }
 285                         break;
 286                 default:
 287                         ERR("Unknown output method");
 288                         ret = -1;
 289         }
 290
 291         err = kernctl_put_next_subbuf(infd);
 292         if (err != 0) {
 293                 ret = errno;
 294                 if (errno == EFAULT) {
 295                         perror("Error in unreserving sub buffer\n");
 296                 } else if (errno == EIO) {
 297                         /* Should never happen with newer LTTng versions */
 298                         perror("Reader has been pushed by the writer, last sub-buffer corrupted.");
 299                 }
 300                 goto end;
 301         }
 302
 303 end:
 304         return ret;
 305 }
 306
 307 static int on_recv_stream(struct lttng_consumer_stream *stream)
 308 {
 309         int ret;
 310
 311         /* Opening the tracefile in write mode */
 312         if (stream->path_name != NULL) {
 313                 ret = open(stream->path_name,
 314                                 O_WRONLY|O_CREAT|O_TRUNC, S_IRWXU|S_IRWXG|S_IRWXO);
 315                 if (ret < 0) {
 316                         ERR("Opening %s", stream->path_name);
 317                         perror("open");
 318                         goto error;
 319                 }
 320                 stream->out_fd = ret;
 321         }
 322
 323         if (stream->output == LTTNG_EVENT_MMAP) {
 324                 /* get the len of the mmap region */
 325                 unsigned long mmap_len;
 326
 327                 ret = kernctl_get_mmap_len(stream->wait_fd, &mmap_len);
 328                 if (ret != 0) {
 329                         ret = errno;
 330                         perror("kernctl_get_mmap_len");
 331                         goto error_close_fd;
 332                 }
 333                 stream->mmap_len = (size_t) mmap_len;
 334
 335                 stream->mmap_base = mmap(NULL, stream->mmap_len,
 336                                 PROT_READ, MAP_PRIVATE, stream->wait_fd, 0);
 337                 if (stream->mmap_base == MAP_FAILED) {
 338                         perror("Error mmaping");
 339                         ret = -1;
 340                         goto error_close_fd;
 341                 }
 342         }
 343
 344         /* we return 0 to let the library handle the FD internally */
 345         return 0;
 346
 347 error_close_fd:
 348         {
 349                 int err;
 350
 351                 err = close(stream->out_fd);
 352                 assert(!err);
 353         }
 354 error:
 355         return ret;
 356 }
 357
 358 /*
 359  * main
 360  */
 361 int main(int argc, char **argv)
 362 {
 363         int i;
 364         int ret = 0;
 365         void *status;
 366
 367         /* Parse arguments */
 368         progname = argv[0];
 369         parse_args(argc, argv);
 370
 371         /* Daemonize */
 372         if (opt_daemon) {
 373                 ret = daemon(0, 0);
 374                 if (ret < 0) {
 375                         perror("daemon");
 376                         goto error;
 377                 }
 378         }
 379
 380         if (strlen(command_sock_path) == 0) {
 381                 snprintf(command_sock_path, PATH_MAX,
 382                         opt_type == LTTNG_CONSUMER_KERNEL ?
 383                                 KCONSUMERD_CMD_SOCK_PATH :
 384                                 USTCONSUMERD_CMD_SOCK_PATH);
 385         }
 386         /* create the consumer instance with and assign the callbacks */
 387         ctx = lttng_consumer_create(opt_type, read_subbuffer, NULL, on_recv_stream, NULL);
 388         if (ctx == NULL) {
 389                 goto error;
 390         }
 391
 392         lttng_consumer_set_command_sock_path(ctx, command_sock_path);
 393         if (strlen(error_sock_path) == 0) {
 394                 snprintf(error_sock_path, PATH_MAX,
 395                         opt_type == LTTNG_CONSUMER_KERNEL ?
 396                                 KCONSUMERD_ERR_SOCK_PATH :
 397                                 USTCONSUMERD_ERR_SOCK_PATH);
 398         }
 399
 400         if (set_signal_handler() < 0) {
 401                 goto error;
 402         }
 403
 404         /* Connect to the socket created by lttng-sessiond to report errors */
 405         DBG("Connecting to error socket %s", error_sock_path);
 406         ret = lttcomm_connect_unix_sock(error_sock_path);
 407         /* not a fatal error, but all communication with lttng-sessiond will fail */
 408         if (ret < 0) {
 409                 WARN("Cannot connect to error socket, is lttng-sessiond started ?");
 410         }
 411         lttng_consumer_set_error_sock(ctx, ret);
 412
 413         /* Create the thread to manage the receive of fd */
 414         ret = pthread_create(&threads[0], NULL, lttng_consumer_thread_receive_fds,
 415                         (void *) ctx);
 416         if (ret != 0) {
 417                 perror("pthread_create");
 418                 goto error;
 419         }
 420
 421         /* Create thread to manage the polling/writing of traces */
 422         ret = pthread_create(&threads[1], NULL, lttng_consumer_thread_poll_fds,
 423                         (void *) ctx);
 424         if (ret != 0) {
 425                 perror("pthread_create");
 426                 goto error;
 427         }
 428
 429         for (i = 0; i < 2; i++) {
 430                 ret = pthread_join(threads[i], &status);
 431                 if (ret != 0) {
 432                         perror("pthread_join");
 433                         goto error;
 434                 }
 435         }
 436         ret = EXIT_SUCCESS;
 437         lttng_consumer_send_error(ctx, CONSUMERD_EXIT_SUCCESS);
 438         goto end;
 439
 440 error:
 441         ret = EXIT_FAILURE;
 442         lttng_consumer_send_error(ctx, CONSUMERD_EXIT_FAILURE);
 443
 444 end:
 445         lttng_consumer_destroy(ctx);
 446         lttng_consumer_cleanup();
 447
 448         return ret;
 449 }