ltt-sessiond/main.c

   1 /*
   2    DBG("Creating kernel event %s for channel %s.",
   3    cmd_ctx->lsm->u.enable.event.name, cmd_ctx->lsm->u.enable.channel_name);
   4
   5  * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20  */
  21
  22 #define _GNU_SOURCE
  23 #include <fcntl.h>
  24 #include <getopt.h>
  25 #include <grp.h>
  26 #include <limits.h>
  27 #include <pthread.h>
  28 #include <semaphore.h>
  29 #include <signal.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <sys/ipc.h>
  34 #include <sys/shm.h>
  35 #include <sys/socket.h>
  36 #include <sys/stat.h>
  37 #include <sys/types.h>
  38 #include <sys/time.h>
  39 #include <sys/resource.h>
  40 #include <unistd.h>
  41
  42 #include <urcu/list.h>          /* URCU list library (-lurcu) */
  43 #include <lttng/lttng.h>
  44
  45 #include "liblttsessiondcomm.h"
  46 #include "ltt-sessiond.h"
  47 #include "lttngerr.h"
  48 #include "kernel-ctl.h"
  49 #include "ust-ctl.h"
  50 #include "session.h"
  51 #include "traceable-app.h"
  52 #include "lttng-kconsumerd.h"
  53 #include "libustctl.h"
  54
  55 /*
  56  * TODO:
  57  * teardown: signal SIGTERM handler -> write into pipe. Threads waits
  58  * with epoll on pipe and on other pipes/sockets for commands.  Main
  59  * simply waits on pthread join.
  60  */
  61
  62 /* Const values */
  63 const char default_home_dir[] = DEFAULT_HOME_DIR;
  64 const char default_tracing_group[] = LTTNG_DEFAULT_TRACING_GROUP;
  65 const char default_ust_sock_dir[] = DEFAULT_UST_SOCK_DIR;
  66 const char default_global_apps_pipe[] = DEFAULT_GLOBAL_APPS_PIPE;
  67
  68 /* Variables */
  69 int opt_verbose;    /* Not static for lttngerr.h */
  70 int opt_quiet;      /* Not static for lttngerr.h */
  71 const char *progname;
  72 const char *opt_tracing_group;
  73 static int opt_sig_parent;
  74 static int opt_daemon;
  75 static int is_root;                     /* Set to 1 if the daemon is running as root */
  76 static pid_t ppid;          /* Parent PID for --sig-parent option */
  77 static pid_t kconsumerd_pid;
  78
  79 static char apps_unix_sock_path[PATH_MAX];                              /* Global application Unix socket path */
  80 static char client_unix_sock_path[PATH_MAX];                    /* Global client Unix socket path */
  81 static char kconsumerd_err_unix_sock_path[PATH_MAX];    /* kconsumerd error Unix socket path */
  82 static char kconsumerd_cmd_unix_sock_path[PATH_MAX];    /* kconsumerd command Unix socket path */
  83
  84 /* Sockets and FDs */
  85 static int client_sock;
  86 static int apps_sock;
  87 static int kconsumerd_err_sock;
  88 static int kconsumerd_cmd_sock;
  89 static int kernel_tracer_fd;
  90
  91 /* Pthread, Mutexes and Semaphores */
  92 static pthread_t kconsumerd_thread;
  93 static pthread_t apps_thread;
  94 static pthread_t client_thread;
  95 static sem_t kconsumerd_sem;
  96
  97 static pthread_mutex_t kconsumerd_pid_mutex;    /* Mutex to control kconsumerd pid assignation */
  98
  99 /*
 100  *  teardown_kernel_session
 101  *
 102  *  Complete teardown of a kernel session. This free all data structure
 103  *  related to a kernel session and update counter.
 104  */
 105 static void teardown_kernel_session(struct ltt_session *session)
 106 {
 107         if (session->kernel_session != NULL) {
 108                 DBG("Tearing down kernel session");
 109                 trace_destroy_kernel_session(session->kernel_session);
 110                 /* Extra precaution */
 111                 session->kernel_session = NULL;
 112                 /* Decrement session count */
 113                 session->kern_session_count--;
 114         }
 115 }
 116
 117 /*
 118  *  cleanup
 119  *
 120  *  Cleanup the daemon on exit
 121  */
 122 static void cleanup()
 123 {
 124         int ret;
 125         char *cmd;
 126         struct ltt_session *sess;
 127
 128         DBG("Cleaning up");
 129
 130         /* <fun> */
 131         MSG("\n%c[%d;%dm*** assert failed *** ==> %c[%dm", 27,1,31,27,0);
 132         MSG("%c[%d;%dmMatthew, BEET driven development works!%c[%dm",27,1,33,27,0);
 133         /* </fun> */
 134
 135         /* Stopping all threads */
 136         DBG("Terminating all threads");
 137         pthread_cancel(client_thread);
 138         pthread_cancel(apps_thread);
 139         if (kconsumerd_pid != 0) {
 140                 pthread_cancel(kconsumerd_thread);
 141         }
 142
 143         DBG("Unlinking all unix socket");
 144         unlink(client_unix_sock_path);
 145         unlink(apps_unix_sock_path);
 146         unlink(kconsumerd_err_unix_sock_path);
 147
 148         DBG("Removing %s directory", LTTNG_RUNDIR);
 149         ret = asprintf(&cmd, "rm -rf " LTTNG_RUNDIR);
 150         if (ret < 0) {
 151                 ERR("asprintf failed. Something is really wrong!");
 152         }
 153
 154         /* Remove lttng run directory */
 155         ret = system(cmd);
 156         if (ret < 0) {
 157                 ERR("Unable to clean " LTTNG_RUNDIR);
 158         }
 159
 160         DBG("Cleaning up all session");
 161         /* Cleanup ALL session */
 162         cds_list_for_each_entry(sess, &ltt_session_list.head, list) {
 163                 teardown_kernel_session(sess);
 164                 // TODO complete session cleanup (including UST)
 165         }
 166
 167         DBG("Closing kernel fd");
 168         close(kernel_tracer_fd);
 169 }
 170
 171 /*
 172  *  send_unix_sock
 173  *
 174  *  Send data on a unix socket using the liblttsessiondcomm API.
 175  *
 176  *  Return lttcomm error code.
 177  */
 178 static int send_unix_sock(int sock, void *buf, size_t len)
 179 {
 180         /* Check valid length */
 181         if (len <= 0) {
 182                 return -1;
 183         }
 184
 185         return lttcomm_send_unix_sock(sock, buf, len);
 186 }
 187
 188 /*
 189  *  clean_command_ctx
 190  *
 191  *  Free memory of a command context structure.
 192  */
 193 static void clean_command_ctx(struct command_ctx *cmd_ctx)
 194 {
 195         DBG("Clean command context structure %p", cmd_ctx);
 196         if (cmd_ctx) {
 197                 if (cmd_ctx->llm) {
 198                         free(cmd_ctx->llm);
 199                 }
 200                 if (cmd_ctx->lsm) {
 201                         free(cmd_ctx->lsm);
 202                 }
 203                 free(cmd_ctx);
 204                 cmd_ctx = NULL;
 205         }
 206 }
 207
 208 /*
 209  *  send_kconsumerd_fds
 210  *
 211  *  Send all stream fds of the kernel session to the consumer.
 212  */
 213 static int send_kconsumerd_fds(int sock, struct ltt_kernel_session *session)
 214 {
 215         int ret;
 216         size_t nb_fd;
 217         struct ltt_kernel_stream *stream;
 218         struct ltt_kernel_channel *chan;
 219         struct lttcomm_kconsumerd_header lkh;
 220         struct lttcomm_kconsumerd_msg lkm;
 221
 222         nb_fd = session->stream_count_global;
 223
 224         /* Setup header */
 225         lkh.payload_size = (nb_fd + 1) * sizeof(struct lttcomm_kconsumerd_msg);
 226         lkh.cmd_type = ADD_STREAM;
 227
 228         DBG("Sending kconsumerd header");
 229
 230         ret = lttcomm_send_unix_sock(sock, &lkh, sizeof(struct lttcomm_kconsumerd_header));
 231         if (ret < 0) {
 232                 perror("send kconsumerd header");
 233                 goto error;
 234         }
 235
 236         DBG("Sending metadata stream fd");
 237
 238         /* Send metadata stream fd first */
 239         lkm.fd = session->metadata_stream_fd;
 240         lkm.state = ACTIVE_FD;
 241         lkm.max_sb_size = session->metadata->conf->attr.subbuf_size;
 242         strncpy(lkm.path_name, session->metadata->pathname, PATH_MAX);
 243
 244         ret = lttcomm_send_fds_unix_sock(sock, &lkm, &lkm.fd, 1, sizeof(lkm));
 245         if (ret < 0) {
 246                 perror("send kconsumerd fd");
 247                 goto error;
 248         }
 249
 250         cds_list_for_each_entry(chan, &session->channel_list.head, list) {
 251                 cds_list_for_each_entry(stream, &chan->stream_list.head, list) {
 252                         lkm.fd = stream->fd;
 253                         lkm.state = stream->state;
 254                         lkm.max_sb_size = chan->channel->attr.subbuf_size;
 255                         strncpy(lkm.path_name, stream->pathname, PATH_MAX);
 256
 257                         DBG("Sending fd %d to kconsumerd", lkm.fd);
 258
 259                         ret = lttcomm_send_fds_unix_sock(sock, &lkm, &lkm.fd, 1, sizeof(lkm));
 260                         if (ret < 0) {
 261                                 perror("send kconsumerd fd");
 262                                 goto error;
 263                         }
 264                 }
 265         }
 266
 267         DBG("Kconsumerd fds sent");
 268
 269         return 0;
 270
 271 error:
 272         return ret;
 273 }
 274
 275 /*
 276  *  create_trace_dir
 277  *
 278  *  Create the trace output directory.
 279  */
 280 static int create_trace_dir(struct ltt_kernel_session *session)
 281 {
 282         int ret;
 283         struct ltt_kernel_channel *chan;
 284
 285         /* Create all channel directories */
 286         cds_list_for_each_entry(chan, &session->channel_list.head, list) {
 287                 DBG("Creating trace directory at %s", chan->pathname);
 288                 // TODO: recursive create dir
 289                 ret = mkdir(chan->pathname, S_IRWXU | S_IRWXG );
 290                 if (ret < 0) {
 291                         if (ret != EEXIST) {
 292                                 perror("mkdir trace path");
 293                                 ret = -errno;
 294                                 goto error;
 295                         }
 296                 }
 297         }
 298
 299         return 0;
 300
 301 error:
 302         return ret;
 303 }
 304
 305 /*
 306  *      ust_connect_app
 307  *
 308  *      Return a socket connected to the libust communication socket
 309  *      of the application identified by the pid.
 310  *
 311  *      If the pid is not found in the traceable list,
 312  *      return -1 to indicate error.
 313  */
 314 static int ust_connect_app(pid_t pid)
 315 {
 316         int sock;
 317         struct ltt_traceable_app *lta;
 318
 319         DBG("Connect to application pid %d", pid);
 320
 321         lta = find_app_by_pid(pid);
 322         if (lta == NULL) {
 323                 /* App not found */
 324                 DBG("Application pid %d not found", pid);
 325                 return -1;
 326         }
 327
 328         sock = ustctl_connect_pid(lta->pid);
 329         if (sock < 0) {
 330                 ERR("Fail connecting to the PID %d", pid);
 331         }
 332
 333         return sock;
 334 }
 335
 336 /*
 337  *      notify_apps
 338  *
 339  *  Notify apps by writing 42 to a named pipe using name.
 340  *      Every applications waiting for a ltt-sessiond will be notified
 341  *      and re-register automatically to the session daemon.
 342  *
 343  *      Return open or write error value.
 344  */
 345 static int notify_apps(const char *name)
 346 {
 347         int fd;
 348         int ret = -1;
 349
 350         DBG("Notify the global application pipe");
 351
 352         /* Try opening the global pipe */
 353         fd = open(name, O_WRONLY);
 354         if (fd < 0) {
 355                 goto error;
 356         }
 357
 358         /* Notify by writing on the pipe */
 359         ret = write(fd, "42", 2);
 360         if (ret < 0) {
 361                 perror("write");
 362         }
 363
 364 error:
 365         return ret;
 366 }
 367
 368 /*
 369  *  setup_lttng_msg
 370  *
 371  *  Setup the outgoing data buffer for the response (llm) by allocating the
 372  *  right amount of memory and copying the original information from the lsm
 373  *  structure.
 374  *
 375  *  Return total size of the buffer pointed by buf.
 376  */
 377 static int setup_lttng_msg(struct command_ctx *cmd_ctx, size_t size)
 378 {
 379         int ret, buf_size;
 380
 381         buf_size = size;
 382
 383         cmd_ctx->llm = malloc(sizeof(struct lttcomm_lttng_msg) + buf_size);
 384         if (cmd_ctx->llm == NULL) {
 385                 perror("malloc");
 386                 ret = -ENOMEM;
 387                 goto error;
 388         }
 389
 390         /* Copy common data */
 391         cmd_ctx->llm->cmd_type = cmd_ctx->lsm->cmd_type;
 392         cmd_ctx->llm->pid = cmd_ctx->lsm->pid;
 393
 394         cmd_ctx->llm->data_size = size;
 395         cmd_ctx->lttng_msg_size = sizeof(struct lttcomm_lttng_msg) + buf_size;
 396
 397         return buf_size;
 398
 399 error:
 400         return ret;
 401 }
 402
 403 /*
 404  *  thread_manage_kconsumerd
 405  *
 406  *  This thread manage the kconsumerd error sent
 407  *  back to the session daemon.
 408  */
 409 static void *thread_manage_kconsumerd(void *data)
 410 {
 411         int sock, ret;
 412         enum lttcomm_return_code code;
 413
 414         DBG("[thread] Manage kconsumerd started");
 415
 416         ret = lttcomm_listen_unix_sock(kconsumerd_err_sock);
 417         if (ret < 0) {
 418                 goto error;
 419         }
 420
 421         sock = lttcomm_accept_unix_sock(kconsumerd_err_sock);
 422         if (sock < 0) {
 423                 goto error;
 424         }
 425
 426         /* Getting status code from kconsumerd */
 427         ret = lttcomm_recv_unix_sock(sock, &code, sizeof(enum lttcomm_return_code));
 428         if (ret <= 0) {
 429                 goto error;
 430         }
 431
 432         if (code == KCONSUMERD_COMMAND_SOCK_READY) {
 433                 kconsumerd_cmd_sock = lttcomm_connect_unix_sock(kconsumerd_cmd_unix_sock_path);
 434                 if (kconsumerd_cmd_sock < 0) {
 435                         sem_post(&kconsumerd_sem);
 436                         perror("kconsumerd connect");
 437                         goto error;
 438                 }
 439                 /* Signal condition to tell that the kconsumerd is ready */
 440                 sem_post(&kconsumerd_sem);
 441                 DBG("Kconsumerd command socket ready");
 442         } else {
 443                 DBG("Kconsumerd error when waiting for SOCK_READY : %s",
 444                                 lttcomm_get_readable_code(-code));
 445                 goto error;
 446         }
 447
 448         /* Wait for any kconsumerd error */
 449         ret = lttcomm_recv_unix_sock(sock, &code, sizeof(enum lttcomm_return_code));
 450         if (ret <= 0) {
 451                 ERR("Kconsumerd closed the command socket");
 452                 goto error;
 453         }
 454
 455         ERR("Kconsumerd return code : %s", lttcomm_get_readable_code(-code));
 456
 457 error:
 458         kconsumerd_pid = 0;
 459         DBG("Kconsumerd thread dying");
 460         return NULL;
 461 }
 462
 463 /*
 464  *      thread_manage_apps
 465  *
 466  *      This thread manage the application socket communication
 467  */
 468 static void *thread_manage_apps(void *data)
 469 {
 470         int sock, ret;
 471
 472         /* TODO: Something more elegant is needed but fine for now */
 473         /* FIXME: change all types to either uint8_t, uint32_t, uint64_t
 474          * for 32-bit vs 64-bit compat processes. */
 475         /* replicate in ust with version number */
 476         struct {
 477                 int reg;        /* 1:register, 0:unregister */
 478                 pid_t pid;
 479                 uid_t uid;
 480         } reg_msg;
 481
 482         DBG("[thread] Manage apps started");
 483
 484         ret = lttcomm_listen_unix_sock(apps_sock);
 485         if (ret < 0) {
 486                 goto error;
 487         }
 488
 489         /* Notify all applications to register */
 490         notify_apps(default_global_apps_pipe);
 491
 492         while (1) {
 493                 DBG("Accepting application registration");
 494                 /* Blocking call, waiting for transmission */
 495                 sock = lttcomm_accept_unix_sock(apps_sock);
 496                 if (sock < 0) {
 497                         goto error;
 498                 }
 499
 500                 /* Basic recv here to handle the very simple data
 501                  * that the libust send to register (reg_msg).
 502                  */
 503                 ret = recv(sock, &reg_msg, sizeof(reg_msg), 0);
 504                 if (ret < 0) {
 505                         perror("recv");
 506                         continue;
 507                 }
 508
 509                 /* Add application to the global traceable list */
 510                 if (reg_msg.reg == 1) {
 511                         /* Registering */
 512                         ret = register_traceable_app(reg_msg.pid, reg_msg.uid);
 513                         if (ret < 0) {
 514                                 /* register_traceable_app only return an error with
 515                                  * ENOMEM. At this point, we better stop everything.
 516                                  */
 517                                 goto error;
 518                         }
 519                 } else {
 520                         /* Unregistering */
 521                         unregister_traceable_app(reg_msg.pid);
 522                 }
 523         }
 524
 525 error:
 526
 527         return NULL;
 528 }
 529
 530 /*
 531  *  spawn_kconsumerd_thread
 532  *
 533  *  Start the thread_manage_kconsumerd. This must be done after a kconsumerd
 534  *  exec or it will fails.
 535  */
 536 static int spawn_kconsumerd_thread(void)
 537 {
 538         int ret;
 539
 540         /* Setup semaphore */
 541         sem_init(&kconsumerd_sem, 0, 0);
 542
 543         ret = pthread_create(&kconsumerd_thread, NULL, thread_manage_kconsumerd, (void *) NULL);
 544         if (ret != 0) {
 545                 perror("pthread_create kconsumerd");
 546                 goto error;
 547         }
 548
 549         /* Wait for the kconsumerd thread to be ready */
 550         sem_wait(&kconsumerd_sem);
 551
 552         if (kconsumerd_pid == 0) {
 553                 ERR("Kconsumerd did not start");
 554                 goto error;
 555         }
 556
 557         return 0;
 558
 559 error:
 560         ret = LTTCOMM_KERN_CONSUMER_FAIL;
 561         return ret;
 562 }
 563
 564 /*
 565  *  spawn_kconsumerd
 566  *
 567  *  Fork and exec a kernel consumer daemon (kconsumerd).
 568  *
 569  *  NOTE: It is very important to fork a kconsumerd BEFORE opening any kernel
 570  *  file descriptor using the libkernelctl or kernel-ctl functions. So, a
 571  *  kernel consumer MUST only be spawned before creating a kernel session.
 572  *
 573  *  Return pid if successful else -1.
 574  */
 575 static pid_t spawn_kconsumerd(void)
 576 {
 577         int ret;
 578         pid_t pid;
 579
 580         DBG("Spawning kconsumerd");
 581
 582         pid = fork();
 583         if (pid == 0) {
 584                 /*
 585                  * Exec kconsumerd.
 586                  */
 587                 execlp("kconsumerd", "kconsumerd", "--verbose", NULL);
 588                 if (errno != 0) {
 589                         perror("kernel start consumer exec");
 590                 }
 591                 exit(EXIT_FAILURE);
 592         } else if (pid > 0) {
 593                 ret = pid;
 594                 goto error;
 595         } else {
 596                 perror("kernel start consumer fork");
 597                 ret = -errno;
 598                 goto error;
 599         }
 600
 601 error:
 602         return ret;
 603 }
 604
 605 /*
 606  *  start_kconsumerd
 607  *
 608  *  Spawn the kconsumerd daemon and session daemon thread.
 609  */
 610 static int start_kconsumerd(void)
 611 {
 612         int ret;
 613
 614         pthread_mutex_lock(&kconsumerd_pid_mutex);
 615         if (kconsumerd_pid != 0) {
 616                 goto end;
 617         }
 618
 619         ret = spawn_kconsumerd();
 620         if (ret < 0) {
 621                 ERR("Spawning kconsumerd failed");
 622                 ret = LTTCOMM_KERN_CONSUMER_FAIL;
 623                 pthread_mutex_unlock(&kconsumerd_pid_mutex);
 624                 goto error;
 625         }
 626
 627         /* Setting up the global kconsumerd_pid */
 628         kconsumerd_pid = ret;
 629         pthread_mutex_unlock(&kconsumerd_pid_mutex);
 630
 631         DBG("Kconsumerd pid %d", ret);
 632
 633         DBG("Spawning kconsumerd thread");
 634         ret = spawn_kconsumerd_thread();
 635         if (ret < 0) {
 636                 ERR("Fatal error spawning kconsumerd thread");
 637                 goto error;
 638         }
 639
 640 end:
 641         pthread_mutex_unlock(&kconsumerd_pid_mutex);
 642         return 0;
 643
 644 error:
 645         return ret;
 646 }
 647
 648 /*
 649  *  init_kernel_tracer
 650  *
 651  *  Setup necessary data for kernel tracer action.
 652  */
 653 static void init_kernel_tracer(void)
 654 {
 655         /* Set the global kernel tracer fd */
 656         kernel_tracer_fd = open(DEFAULT_KERNEL_TRACER_PATH, O_RDWR);
 657         if (kernel_tracer_fd < 0) {
 658                 WARN("No kernel tracer available");
 659                 kernel_tracer_fd = 0;
 660         }
 661
 662         DBG("Kernel tracer fd %d", kernel_tracer_fd);
 663 }
 664
 665 /*
 666  *  start_kernel_trace
 667  *
 668  *  Start tracing by creating trace directory and sending FDs to the kernel
 669  *  consumer.
 670  */
 671 static int start_kernel_trace(struct ltt_kernel_session *session)
 672 {
 673         int ret;
 674
 675         /* Create trace directory */
 676         ret = create_trace_dir(session);
 677         if (ret < 0) {
 678                 if (ret == -EEXIST) {
 679                         ret = LTTCOMM_KERN_DIR_EXIST;
 680                 } else {
 681                         ret = LTTCOMM_KERN_DIR_FAIL;
 682                         goto error;
 683                 }
 684         }
 685
 686         if (session->kconsumer_fds_sent == 0) {
 687                 ret = send_kconsumerd_fds(kconsumerd_cmd_sock, session);
 688                 if (ret < 0) {
 689                         ERR("Send kconsumerd fds failed");
 690                         ret = LTTCOMM_KERN_CONSUMER_FAIL;
 691                         goto error;
 692                 }
 693
 694                 session->kconsumer_fds_sent = 1;
 695         }
 696
 697 error:
 698         return ret;
 699 }
 700
 701 /*
 702  *  init_default_channel
 703  *
 704  *  Allocate a channel structure and fill it.
 705  */
 706 static struct lttng_channel *init_default_channel(void)
 707 {
 708         struct lttng_channel *chan;
 709
 710         chan = malloc(sizeof(struct lttng_channel));
 711         if (chan == NULL) {
 712                 perror("init channel malloc");
 713                 goto error;
 714         }
 715
 716         if (snprintf(chan->name, NAME_MAX, DEFAULT_CHANNEL_NAME) < 0) {
 717                 perror("snprintf defautl channel name");
 718                 return NULL;
 719         }
 720
 721         chan->attr.overwrite = DEFAULT_CHANNEL_OVERWRITE;
 722         chan->attr.subbuf_size = DEFAULT_CHANNEL_SUBBUF_SIZE;
 723         chan->attr.num_subbuf = DEFAULT_CHANNEL_SUBBUF_NUM;
 724         chan->attr.switch_timer_interval = DEFAULT_CHANNEL_SWITCH_TIMER;
 725         chan->attr.read_timer_interval = DEFAULT_CHANNEL_READ_TIMER;
 726
 727 error:
 728         return chan;
 729 }
 730
 731 /*
 732  *  create_kernel_session
 733  *
 734  *  Create a kernel tracer session then create the default channel.
 735  */
 736 static int create_kernel_session(struct ltt_session *session)
 737 {
 738         int ret;
 739         struct lttng_channel *chan;
 740
 741         DBG("Creating kernel session");
 742
 743         ret = kernel_create_session(session, kernel_tracer_fd);
 744         if (ret < 0) {
 745                 ret = LTTCOMM_KERN_SESS_FAIL;
 746                 goto error;
 747         }
 748
 749         chan = init_default_channel();
 750         if (chan == NULL) {
 751                 ret = LTTCOMM_FATAL;
 752                 goto error;
 753         }
 754
 755         DBG("Creating default kernel channel %s", DEFAULT_CHANNEL_NAME);
 756
 757         ret = kernel_create_channel(session->kernel_session, chan);
 758         if (ret < 0) {
 759                 ret = LTTCOMM_KERN_CHAN_FAIL;
 760                 goto error;
 761         }
 762
 763 error:
 764         return ret;
 765 }
 766
 767 /*
 768  *      process_client_msg
 769  *
 770  *  Process the command requested by the lttng client within the command
 771  *  context structure.  This function make sure that the return structure (llm)
 772  *  is set and ready for transmission before returning.
 773  *
 774  *      Return any error encountered or 0 for success.
 775  */
 776 static int process_client_msg(struct command_ctx *cmd_ctx)
 777 {
 778         int ret;
 779
 780         DBG("Processing client command %d", cmd_ctx->lsm->cmd_type);
 781
 782         /* Listing commands don't need a session */
 783         switch (cmd_ctx->lsm->cmd_type) {
 784         case LTTNG_CREATE_SESSION:
 785         case LTTNG_LIST_SESSIONS:
 786         case LTTNG_LIST_EVENTS:
 787         case LTTNG_KERNEL_LIST_EVENTS:
 788         case LTTNG_LIST_TRACEABLE_APPS:
 789                 break;
 790         default:
 791                 DBG("Getting session %s by name", cmd_ctx->lsm->session_name);
 792                 cmd_ctx->session = find_session_by_name(cmd_ctx->lsm->session_name);
 793                 if (cmd_ctx->session == NULL) {
 794                         /* If session name not found */
 795                         if (cmd_ctx->lsm->session_name != NULL) {
 796                                 ret = LTTCOMM_SESS_NOT_FOUND;
 797                         } else {        /* If no session name specified */
 798                                 ret = LTTCOMM_SELECT_SESS;
 799                         }
 800                         goto error;
 801                 }
 802                 break;
 803         }
 804
 805         /*
 806          * Check kernel command for kernel session.
 807          */
 808         switch (cmd_ctx->lsm->cmd_type) {
 809         case LTTNG_KERNEL_CREATE_CHANNEL:
 810         case LTTNG_KERNEL_DISABLE_ALL_EVENT:
 811         case LTTNG_KERNEL_DISABLE_CHANNEL:
 812         case LTTNG_KERNEL_DISABLE_EVENT:
 813         case LTTNG_KERNEL_ENABLE_ALL_EVENT:
 814         case LTTNG_KERNEL_ENABLE_CHANNEL:
 815         case LTTNG_KERNEL_ENABLE_EVENT:
 816         case LTTNG_KERNEL_LIST_EVENTS:
 817                 /* Kernel tracer check */
 818                 if (kernel_tracer_fd == 0) {
 819                         init_kernel_tracer();
 820                         if (kernel_tracer_fd == 0) {
 821                                 ret = LTTCOMM_KERN_NA;
 822                                 goto error;
 823                         }
 824                 }
 825
 826                 /* Need a session for kernel command */
 827                 if (cmd_ctx->lsm->cmd_type != LTTNG_KERNEL_LIST_EVENTS &&
 828                                 cmd_ctx->session->kernel_session == NULL) {
 829
 830                         ret = create_kernel_session(cmd_ctx->session);
 831                         if (ret < 0) {
 832                                 ret = LTTCOMM_KERN_SESS_FAIL;
 833                                 goto error;
 834                         }
 835
 836                         /* Start the kernel consumer daemon */
 837                         if (kconsumerd_pid == 0) {
 838                                 ret = start_kconsumerd();
 839                                 if (ret < 0) {
 840                                         goto error;
 841                                 }
 842                         }
 843                 }
 844         }
 845
 846         /* Connect to ust apps if available pid */
 847         if (cmd_ctx->lsm->pid > 0) {
 848                 /* Connect to app using ustctl API */
 849                 cmd_ctx->ust_sock = ust_connect_app(cmd_ctx->lsm->pid);
 850                 if (cmd_ctx->ust_sock < 0) {
 851                         ret = LTTCOMM_NO_TRACEABLE;
 852                         goto error;
 853                 }
 854         }
 855
 856         /* Process by command type */
 857         switch (cmd_ctx->lsm->cmd_type) {
 858         case LTTNG_KERNEL_CREATE_CHANNEL:
 859         {
 860                 /* Setup lttng message with no payload */
 861                 ret = setup_lttng_msg(cmd_ctx, 0);
 862                 if (ret < 0) {
 863                         goto setup_error;
 864                 }
 865
 866                 /* Kernel tracer */
 867                 DBG("Creating kernel channel");
 868
 869                 ret = kernel_create_channel(cmd_ctx->session->kernel_session,
 870                                 &cmd_ctx->lsm->u.channel.chan);
 871                 if (ret < 0) {
 872                         ret = LTTCOMM_KERN_CHAN_FAIL;
 873                         goto error;
 874                 }
 875
 876                 ret = LTTCOMM_OK;
 877                 break;
 878         }
 879         case LTTNG_KERNEL_DISABLE_EVENT:
 880         {
 881                 int found = 0;
 882                 struct ltt_kernel_channel *chan;
 883
 884                 /* Setup lttng message with no payload */
 885                 ret = setup_lttng_msg(cmd_ctx, 0);
 886                 if (ret < 0) {
 887                         goto setup_error;
 888                 }
 889
 890                 /* Get channel by name and create event for that channel */
 891                 cds_list_for_each_entry(chan, &cmd_ctx->session->kernel_session->channel_list.head, list) {
 892                         if (strcmp(cmd_ctx->lsm->u.disable.channel_name, chan->channel->name) == 0) {
 893                                 DBG("Disabling kernel event %s for channel %s.",
 894                                                 cmd_ctx->lsm->u.disable.name, cmd_ctx->lsm->u.disable.channel_name);
 895
 896                                 ret = kernel_disable_event(cmd_ctx->lsm->u.disable.name, chan);
 897                                 if (ret < 0) {
 898                                         ret = LTTCOMM_KERN_DISABLE_FAIL;
 899                                         goto error;
 900                                 }
 901                                 found = 1;
 902                                 break;
 903                         }
 904                 }
 905
 906                 if (!found) {
 907                         ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
 908                 } else {
 909                         kernel_wait_quiescent(kernel_tracer_fd);
 910                         ret = LTTCOMM_OK;
 911                 }
 912                 break;
 913         }
 914         case LTTNG_KERNEL_ENABLE_EVENT:
 915         {
 916                 int found = 0;
 917                 struct ltt_kernel_channel *chan;
 918
 919                 /* Setup lttng message with no payload */
 920                 ret = setup_lttng_msg(cmd_ctx, 0);
 921                 if (ret < 0) {
 922                         goto setup_error;
 923                 }
 924
 925                 /* Get channel by name and create event for that channel */
 926                 cds_list_for_each_entry(chan, &cmd_ctx->session->kernel_session->channel_list.head, list) {
 927                         if (strcmp(cmd_ctx->lsm->u.enable.channel_name, chan->channel->name) == 0) {
 928                                 DBG("Creating kernel event %s for channel %s.",
 929                                                 cmd_ctx->lsm->u.enable.event.name, cmd_ctx->lsm->u.enable.channel_name);
 930
 931                                 ret = kernel_create_event(chan, &cmd_ctx->lsm->u.enable.event);
 932                                 if (ret < 0) {
 933                                         ret = LTTCOMM_KERN_ENABLE_FAIL;
 934                                         goto error;
 935                                 }
 936                                 found = 1;
 937                                 break;
 938                         }
 939                 }
 940
 941                 if (!found) {
 942                         ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
 943                 } else {
 944                         kernel_wait_quiescent(kernel_tracer_fd);
 945                         ret = LTTCOMM_OK;
 946                 }
 947                 break;
 948         }
 949         case LTTNG_KERNEL_ENABLE_ALL_EVENT:
 950         {
 951                 int pos, size, found;
 952                 char *event_list, *event, *ptr;
 953                 struct ltt_kernel_channel *chan;
 954                 struct lttng_event ev;
 955
 956                 /* Setup lttng message with no payload */
 957                 ret = setup_lttng_msg(cmd_ctx, 0);
 958                 if (ret < 0) {
 959                         goto setup_error;
 960                 }
 961
 962                 DBG("Enabling all kernel event");
 963
 964                 size = kernel_list_events(kernel_tracer_fd, &event_list);
 965                 if (size < 0) {
 966                         ret = LTTCOMM_KERN_LIST_FAIL;
 967                         goto error;
 968                 }
 969
 970                 /* Get channel by name and create event for that channel */
 971                 cds_list_for_each_entry(chan, &cmd_ctx->session->kernel_session->channel_list.head, list) {
 972                         if (strcmp(cmd_ctx->lsm->u.enable.channel_name, chan->channel->name) == 0) {
 973                                 found = 1;
 974                                 break;
 975                         }
 976                 }
 977
 978                 if (!found) {
 979                         ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
 980                         goto error;
 981                 }
 982
 983                 ptr = event_list;
 984                 while ((size = sscanf(ptr, "event { name = %m[^;]; };%n\n", &event, &pos)) == 1) {
 985                         strncpy(ev.name, event, LTTNG_SYM_NAME_LEN);
 986                         /* Default event type for enable all */
 987                         ev.type = LTTNG_EVENT_TRACEPOINTS;
 988                         /* Enable each single tracepoint event */
 989                         ret = kernel_create_event(chan, &ev);
 990                         if (ret < 0) {
 991                                 ret = LTTCOMM_KERN_ENABLE_FAIL;
 992                                 goto error;
 993                         }
 994                         /* Move pointer to the next line */
 995                         ptr += pos + 1;
 996                         free(event);
 997                 }
 998
 999                 free(event_list);
1000
1001                 /* Quiescent wait after event enable */
1002                 kernel_wait_quiescent(kernel_tracer_fd);
1003                 ret = LTTCOMM_OK;
1004                 break;
1005         }
1006         case LTTNG_KERNEL_LIST_EVENTS:
1007         {
1008                 char *event_list;
1009                 ssize_t size = 0;
1010
1011                 DBG("Listing kernel events");
1012
1013                 size = kernel_list_events(kernel_tracer_fd, &event_list);
1014                 if (size < 0) {
1015                         ret = LTTCOMM_KERN_LIST_FAIL;
1016                         goto error;
1017                 }
1018
1019                 /*
1020                  * Setup lttng message with payload size set to the event list size in
1021                  * bytes and then copy list into the llm payload.
1022                  */
1023                 ret = setup_lttng_msg(cmd_ctx, size);
1024                 if (ret < 0) {
1025                         goto setup_error;
1026                 }
1027
1028                 /* Copy event list into message payload */
1029                 memcpy(cmd_ctx->llm->payload, event_list, size);
1030
1031                 free(event_list);
1032
1033                 ret = LTTCOMM_OK;
1034                 break;
1035         }
1036         case LTTNG_START_TRACE:
1037         {
1038                 struct ltt_kernel_channel *chan;
1039
1040                 /* Setup lttng message with no payload */
1041                 ret = setup_lttng_msg(cmd_ctx, 0);
1042                 if (ret < 0) {
1043                         goto setup_error;
1044                 }
1045
1046                 /* Kernel tracing */
1047                 if (cmd_ctx->session->kernel_session != NULL) {
1048                         if (cmd_ctx->session->kernel_session->metadata == NULL) {
1049                                 DBG("Open kernel metadata");
1050                                 ret = kernel_open_metadata(cmd_ctx->session->kernel_session);
1051                                 if (ret < 0) {
1052                                         ret = LTTCOMM_KERN_META_FAIL;
1053                                         goto error;
1054                                 }
1055                         }
1056
1057                         if (cmd_ctx->session->kernel_session->metadata_stream_fd == 0) {
1058                                 DBG("Opening kernel metadata stream");
1059                                 if (cmd_ctx->session->kernel_session->metadata_stream_fd == 0) {
1060                                         ret = kernel_open_metadata_stream(cmd_ctx->session->kernel_session);
1061                                         if (ret < 0) {
1062                                                 ERR("Kernel create metadata stream failed");
1063                                                 ret = LTTCOMM_KERN_STREAM_FAIL;
1064                                                 goto error;
1065                                         }
1066                                 }
1067                         }
1068
1069                         /* For each channel */
1070                         cds_list_for_each_entry(chan, &cmd_ctx->session->kernel_session->channel_list.head, list) {
1071                                 if (chan->stream_count == 0) {
1072                                         ret = kernel_open_channel_stream(chan);
1073                                         if (ret < 0) {
1074                                                 ERR("Kernel create channel stream failed");
1075                                                 ret = LTTCOMM_KERN_STREAM_FAIL;
1076                                                 goto error;
1077                                         }
1078                                         /* Update the stream global counter */
1079                                         cmd_ctx->session->kernel_session->stream_count_global += ret;
1080                                 }
1081                         }
1082
1083                         DBG("Start kernel tracing");
1084                         ret = kernel_start_session(cmd_ctx->session->kernel_session);
1085                         if (ret < 0) {
1086                                 ERR("Kernel start session failed");
1087                                 ret = LTTCOMM_KERN_START_FAIL;
1088                                 goto error;
1089                         }
1090
1091                         ret = start_kernel_trace(cmd_ctx->session->kernel_session);
1092                         if (ret < 0) {
1093                                 ret = LTTCOMM_KERN_START_FAIL;
1094                                 goto error;
1095                         }
1096
1097                         /* Quiescent wait after starting trace */
1098                         kernel_wait_quiescent(kernel_tracer_fd);
1099                 }
1100
1101                 /* TODO: Start all UST traces */
1102
1103                 ret = LTTCOMM_OK;
1104                 break;
1105         }
1106         case LTTNG_STOP_TRACE:
1107         {
1108                 struct ltt_kernel_channel *chan;
1109                 /* Setup lttng message with no payload */
1110                 ret = setup_lttng_msg(cmd_ctx, 0);
1111                 if (ret < 0) {
1112                         goto setup_error;
1113                 }
1114
1115                 /* Kernel tracer */
1116                 if (cmd_ctx->session->kernel_session != NULL) {
1117                         DBG("Stop kernel tracing");
1118
1119                         ret = kernel_metadata_flush_buffer(cmd_ctx->session->kernel_session->metadata_stream_fd);
1120                         if (ret < 0) {
1121                                 ERR("Kernel metadata flush failed");
1122                         }
1123
1124                         cds_list_for_each_entry(chan, &cmd_ctx->session->kernel_session->channel_list.head, list) {
1125                                 ret = kernel_flush_buffer(chan);
1126                                 if (ret < 0) {
1127                                         ERR("Kernel flush buffer error");
1128                                 }
1129                         }
1130
1131                         ret = kernel_stop_session(cmd_ctx->session->kernel_session);
1132                         if (ret < 0) {
1133                                 ERR("Kernel stop session failed");
1134                                 ret = LTTCOMM_KERN_STOP_FAIL;
1135                                 goto error;
1136                         }
1137
1138                         /* Quiescent wait after stopping trace */
1139                         kernel_wait_quiescent(kernel_tracer_fd);
1140                 }
1141
1142                 /* TODO : User-space tracer */
1143
1144                 ret = LTTCOMM_OK;
1145                 break;
1146         }
1147         case LTTNG_CREATE_SESSION:
1148         {
1149                 /* Setup lttng message with no payload */
1150                 ret = setup_lttng_msg(cmd_ctx, 0);
1151                 if (ret < 0) {
1152                         goto setup_error;
1153                 }
1154
1155                 ret = create_session(cmd_ctx->lsm->session_name, cmd_ctx->lsm->path);
1156                 if (ret < 0) {
1157                         if (ret == -EEXIST) {
1158                                 ret = LTTCOMM_EXIST_SESS;
1159                         } else {
1160                                 ret = LTTCOMM_FATAL;
1161                         }
1162                         goto error;
1163                 }
1164
1165                 ret = LTTCOMM_OK;
1166                 break;
1167         }
1168         case LTTNG_DESTROY_SESSION:
1169         {
1170                 /* Setup lttng message with no payload */
1171                 ret = setup_lttng_msg(cmd_ctx, 0);
1172                 if (ret < 0) {
1173                         goto setup_error;
1174                 }
1175
1176                 /* Clean kernel session teardown */
1177                 teardown_kernel_session(cmd_ctx->session);
1178
1179                 ret = destroy_session(cmd_ctx->lsm->session_name);
1180                 if (ret < 0) {
1181                         ret = LTTCOMM_FATAL;
1182                         goto error;
1183                 }
1184
1185                 ret = LTTCOMM_OK;
1186                 break;
1187         }
1188         /*
1189         case LTTNG_LIST_TRACES:
1190         {
1191                 unsigned int trace_count;
1192
1193                 trace_count = get_trace_count_per_session(cmd_ctx->session);
1194                 if (trace_count == 0) {
1195                         ret = LTTCOMM_NO_TRACE;
1196                         goto error;
1197                 }
1198
1199                 ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_trace) * trace_count);
1200                 if (ret < 0) {
1201                         goto setup_error;
1202                 }
1203
1204                 get_traces_per_session(cmd_ctx->session,
1205                                 (struct lttng_trace *)(cmd_ctx->llm->payload));
1206
1207                 ret = LTTCOMM_OK;
1208                 break;
1209         }
1210         */
1211         /*
1212         case UST_CREATE_TRACE:
1213         {
1214                 ret = setup_lttng_msg(cmd_ctx, 0);
1215                 if (ret < 0) {
1216                         goto setup_error;
1217                 }
1218
1219                 ret = ust_create_trace(cmd_ctx);
1220                 if (ret < 0) {
1221                         goto error;
1222                 }
1223                 break;
1224         }
1225         */
1226         case LTTNG_LIST_TRACEABLE_APPS:
1227         {
1228                 unsigned int app_count;
1229
1230                 app_count = get_app_count();
1231                 DBG("Traceable application count : %d", app_count);
1232                 if (app_count == 0) {
1233                         ret = LTTCOMM_NO_APPS;
1234                         goto error;
1235                 }
1236
1237                 ret = setup_lttng_msg(cmd_ctx, sizeof(pid_t) * app_count);
1238                 if (ret < 0) {
1239                         goto setup_error;
1240                 }
1241
1242                 get_app_list_pids((pid_t *)(cmd_ctx->llm->payload));
1243
1244                 ret = LTTCOMM_OK;
1245                 break;
1246         }
1247         /*
1248         case UST_START_TRACE:
1249         {
1250                 ret = setup_lttng_msg(cmd_ctx, 0);
1251                 if (ret < 0) {
1252                         goto setup_error;
1253                 }
1254
1255                 ret = ust_start_trace(cmd_ctx);
1256                 if (ret < 0) {
1257                         goto setup_error;
1258                 }
1259                 break;
1260         }
1261         case UST_STOP_TRACE:
1262         {
1263                 ret = setup_lttng_msg(cmd_ctx, 0);
1264                 if (ret < 0) {
1265                         goto setup_error;
1266                 }
1267
1268                 ret = ust_stop_trace(cmd_ctx);
1269                 if (ret < 0) {
1270                         goto setup_error;
1271                 }
1272                 break;
1273         }
1274         */
1275         case LTTNG_LIST_SESSIONS:
1276         {
1277                 unsigned int session_count;
1278
1279                 session_count = get_session_count();
1280                 if (session_count == 0) {
1281                         ret = LTTCOMM_NO_SESSION;
1282                         goto error;
1283                 }
1284
1285                 ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_session) * session_count);
1286                 if (ret < 0) {
1287                         goto setup_error;
1288                 }
1289
1290                 get_lttng_session((struct lttng_session *)(cmd_ctx->llm->payload));
1291
1292                 ret = LTTCOMM_OK;
1293                 break;
1294         }
1295         default:
1296                 /* Undefined command */
1297                 ret = setup_lttng_msg(cmd_ctx, 0);
1298                 if (ret < 0) {
1299                         goto setup_error;
1300                 }
1301
1302                 ret = LTTCOMM_UND;
1303                 break;
1304         }
1305
1306         /* Set return code */
1307         cmd_ctx->llm->ret_code = ret;
1308
1309         return ret;
1310
1311 error:
1312         if (cmd_ctx->llm == NULL) {
1313                 DBG("Missing llm structure. Allocating one.");
1314                 if (setup_lttng_msg(cmd_ctx, 0) < 0) {
1315                         goto setup_error;
1316                 }
1317         }
1318         /* Notify client of error */
1319         cmd_ctx->llm->ret_code = ret;
1320
1321 setup_error:
1322         return ret;
1323 }
1324
1325 /*
1326  *      thread_manage_clients
1327  *
1328  *      This thread manage all clients request using the unix
1329  *      client socket for communication.
1330  */
1331 static void *thread_manage_clients(void *data)
1332 {
1333         int sock, ret;
1334         struct command_ctx *cmd_ctx;
1335
1336         DBG("[thread] Manage client started");
1337
1338         ret = lttcomm_listen_unix_sock(client_sock);
1339         if (ret < 0) {
1340                 goto error;
1341         }
1342
1343         /* Notify parent pid that we are ready
1344          * to accept command for client side.
1345          */
1346         if (opt_sig_parent) {
1347                 kill(ppid, SIGCHLD);
1348         }
1349
1350         while (1) {
1351                 /* Blocking call, waiting for transmission */
1352                 DBG("Accepting client command ...");
1353                 sock = lttcomm_accept_unix_sock(client_sock);
1354                 if (sock < 0) {
1355                         goto error;
1356                 }
1357
1358                 /* Allocate context command to process the client request */
1359                 cmd_ctx = malloc(sizeof(struct command_ctx));
1360
1361                 /* Allocate data buffer for reception */
1362                 cmd_ctx->lsm = malloc(sizeof(struct lttcomm_session_msg));
1363                 cmd_ctx->llm = NULL;
1364                 cmd_ctx->session = NULL;
1365
1366                 /*
1367                  * Data is received from the lttng client. The struct
1368                  * lttcomm_session_msg (lsm) contains the command and data request of
1369                  * the client.
1370                  */
1371                 DBG("Receiving data from client ...");
1372                 ret = lttcomm_recv_unix_sock(sock, cmd_ctx->lsm, sizeof(struct lttcomm_session_msg));
1373                 if (ret <= 0) {
1374                         continue;
1375                 }
1376
1377                 // TODO: Validate cmd_ctx including sanity check for security purpose.
1378
1379                 /*
1380                  * This function dispatch the work to the kernel or userspace tracer
1381                  * libs and fill the lttcomm_lttng_msg data structure of all the needed
1382                  * informations for the client. The command context struct contains
1383                  * everything this function may needs.
1384                  */
1385                 ret = process_client_msg(cmd_ctx);
1386                 if (ret < 0) {
1387                         /* TODO: Inform client somehow of the fatal error. At this point,
1388                          * ret < 0 means that a malloc failed (ENOMEM). */
1389                         /* Error detected but still accept command */
1390                         clean_command_ctx(cmd_ctx);
1391                         continue;
1392                 }
1393
1394                 DBG("Sending response (size: %d, retcode: %d)",
1395                                 cmd_ctx->lttng_msg_size, cmd_ctx->llm->ret_code);
1396                 ret = send_unix_sock(sock, cmd_ctx->llm, cmd_ctx->lttng_msg_size);
1397                 if (ret < 0) {
1398                         ERR("Failed to send data back to client");
1399                 }
1400
1401                 clean_command_ctx(cmd_ctx);
1402
1403                 /* End of transmission */
1404                 close(sock);
1405         }
1406
1407 error:
1408         return NULL;
1409 }
1410
1411
1412 /*
1413  * usage function on stderr
1414  */
1415 static void usage(void)
1416 {
1417         fprintf(stderr, "Usage: %s OPTIONS\n\nOptions:\n", progname);
1418         fprintf(stderr, "  -h, --help                         Display this usage.\n");
1419         fprintf(stderr, "  -c, --client-sock PATH             Specify path for the client unix socket\n");
1420         fprintf(stderr, "  -a, --apps-sock PATH               Specify path for apps unix socket\n");
1421         fprintf(stderr, "      --kconsumerd-err-sock PATH     Specify path for the kernel consumer error socket\n");
1422         fprintf(stderr, "      --kconsumerd-cmd-sock PATH     Specify path for the kernel consumer command socket\n");
1423         fprintf(stderr, "  -d, --daemonize                    Start as a daemon.\n");
1424         fprintf(stderr, "  -g, --group NAME                   Specify the tracing group name. (default: tracing)\n");
1425         fprintf(stderr, "  -V, --version                      Show version number.\n");
1426         fprintf(stderr, "  -S, --sig-parent                   Send SIGCHLD to parent pid to notify readiness.\n");
1427         fprintf(stderr, "  -q, --quiet                        No output at all.\n");
1428         fprintf(stderr, "  -v, --verbose                      Verbose mode. Activate DBG() macro.\n");
1429 }
1430
1431 /*
1432  * daemon argument parsing
1433  */
1434 static int parse_args(int argc, char **argv)
1435 {
1436         int c;
1437
1438         static struct option long_options[] = {
1439                 { "client-sock", 1, 0, 'c' },
1440                 { "apps-sock", 1, 0, 'a' },
1441                 { "kconsumerd-cmd-sock", 1, 0, 0 },
1442                 { "kconsumerd-err-sock", 1, 0, 0 },
1443                 { "daemonize", 0, 0, 'd' },
1444                 { "sig-parent", 0, 0, 'S' },
1445                 { "help", 0, 0, 'h' },
1446                 { "group", 1, 0, 'g' },
1447                 { "version", 0, 0, 'V' },
1448                 { "quiet", 0, 0, 'q' },
1449                 { "verbose", 0, 0, 'v' },
1450                 { NULL, 0, 0, 0 }
1451         };
1452
1453         while (1) {
1454                 int option_index = 0;
1455                 c = getopt_long(argc, argv, "dhqvVS" "a:c:g:s:E:C:", long_options, &option_index);
1456                 if (c == -1) {
1457                         break;
1458                 }
1459
1460                 switch (c) {
1461                 case 0:
1462                         fprintf(stderr, "option %s", long_options[option_index].name);
1463                         if (optarg) {
1464                                 fprintf(stderr, " with arg %s\n", optarg);
1465                         }
1466                         break;
1467                 case 'c':
1468                         snprintf(client_unix_sock_path, PATH_MAX, "%s", optarg);
1469                         break;
1470                 case 'a':
1471                         snprintf(apps_unix_sock_path, PATH_MAX, "%s", optarg);
1472                         break;
1473                 case 'd':
1474                         opt_daemon = 1;
1475                         break;
1476                 case 'g':
1477                         opt_tracing_group = strdup(optarg);
1478                         break;
1479                 case 'h':
1480                         usage();
1481                         exit(EXIT_FAILURE);
1482                 case 'V':
1483                         fprintf(stdout, "%s\n", VERSION);
1484                         exit(EXIT_SUCCESS);
1485                 case 'S':
1486                         opt_sig_parent = 1;
1487                         break;
1488                 case 'E':
1489                         snprintf(kconsumerd_err_unix_sock_path, PATH_MAX, "%s", optarg);
1490                         break;
1491                 case 'C':
1492                         snprintf(kconsumerd_cmd_unix_sock_path, PATH_MAX, "%s", optarg);
1493                         break;
1494                 case 'q':
1495                         opt_quiet = 1;
1496                         break;
1497                 case 'v':
1498                         opt_verbose = 1;
1499                         break;
1500                 default:
1501                         /* Unknown option or other error.
1502                          * Error is printed by getopt, just return */
1503                         return -1;
1504                 }
1505         }
1506
1507         return 0;
1508 }
1509
1510 /*
1511  *      init_daemon_socket
1512  *
1513  *      Creates the two needed socket by the daemon.
1514  *          apps_sock - The communication socket for all UST apps.
1515  *          client_sock - The communication of the cli tool (lttng).
1516  */
1517 static int init_daemon_socket()
1518 {
1519         int ret = 0;
1520         mode_t old_umask;
1521
1522         old_umask = umask(0);
1523
1524         /* Create client tool unix socket */
1525         client_sock = lttcomm_create_unix_sock(client_unix_sock_path);
1526         if (client_sock < 0) {
1527                 ERR("Create unix sock failed: %s", client_unix_sock_path);
1528                 ret = -1;
1529                 goto end;
1530         }
1531
1532         /* File permission MUST be 660 */
1533         ret = chmod(client_unix_sock_path, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
1534         if (ret < 0) {
1535                 ERR("Set file permissions failed: %s", client_unix_sock_path);
1536                 perror("chmod");
1537                 goto end;
1538         }
1539
1540         /* Create the application unix socket */
1541         apps_sock = lttcomm_create_unix_sock(apps_unix_sock_path);
1542         if (apps_sock < 0) {
1543                 ERR("Create unix sock failed: %s", apps_unix_sock_path);
1544                 ret = -1;
1545                 goto end;
1546         }
1547
1548         /* File permission MUST be 666 */
1549         ret = chmod(apps_unix_sock_path, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
1550         if (ret < 0) {
1551                 ERR("Set file permissions failed: %s", apps_unix_sock_path);
1552                 perror("chmod");
1553                 goto end;
1554         }
1555
1556 end:
1557         umask(old_umask);
1558         return ret;
1559 }
1560
1561 /*
1562  *      check_existing_daemon
1563  *
1564  *      Check if the global socket is available.
1565  *  If yes, error is returned.
1566  */
1567 static int check_existing_daemon()
1568 {
1569         int ret;
1570
1571         ret = access(client_unix_sock_path, F_OK);
1572         if (ret == 0) {
1573                 ret = access(apps_unix_sock_path, F_OK);
1574         }
1575
1576         return ret;
1577 }
1578
1579 /*
1580  *  get_home_dir
1581  *
1582  *  Return pointer to home directory path using
1583  *  the env variable HOME.
1584  *
1585  *  Default : /tmp
1586  */
1587 static const char *get_home_dir(void)
1588 {
1589         const char *home_path;
1590
1591         if ((home_path = (const char *) getenv("HOME")) == NULL) {
1592                 home_path = default_home_dir;
1593         }
1594
1595         return home_path;
1596 }
1597
1598 /*
1599  *  set_permissions
1600  *
1601  *  Set the tracing group gid onto the client socket.
1602  *
1603  *  Race window between mkdir and chown is OK because we are going from
1604  *  less permissive (root.root) to more permissive (root.tracing).
1605  */
1606 static int set_permissions(void)
1607 {
1608         int ret;
1609         struct group *grp;
1610
1611         /* Decide which group name to use */
1612         (opt_tracing_group != NULL) ?
1613                 (grp = getgrnam(opt_tracing_group)) :
1614                 (grp = getgrnam(default_tracing_group));
1615
1616         if (grp == NULL) {
1617                 ERR("Missing tracing group. Aborting execution.\n");
1618                 ret = -1;
1619                 goto end;
1620         }
1621
1622         /* Set lttng run dir */
1623         ret = chown(LTTNG_RUNDIR, 0, grp->gr_gid);
1624         if (ret < 0) {
1625                 ERR("Unable to set group on " LTTNG_RUNDIR);
1626                 perror("chown");
1627         }
1628
1629         /* lttng client socket path */
1630         ret = chown(client_unix_sock_path, 0, grp->gr_gid);
1631         if (ret < 0) {
1632                 ERR("Unable to set group on %s", client_unix_sock_path);
1633                 perror("chown");
1634         }
1635
1636         /* kconsumerd error socket path */
1637         ret = chown(kconsumerd_err_unix_sock_path, 0, grp->gr_gid);
1638         if (ret < 0) {
1639                 ERR("Unable to set group on %s", kconsumerd_err_unix_sock_path);
1640                 perror("chown");
1641         }
1642
1643         DBG("All permissions are set");
1644
1645 end:
1646         return ret;
1647 }
1648
1649 /*
1650  *  create_lttng_rundir
1651  *
1652  *  Create the lttng run directory needed for all
1653  *  global sockets and pipe.
1654  */
1655 static int create_lttng_rundir(void)
1656 {
1657         int ret;
1658
1659         ret = mkdir(LTTNG_RUNDIR, S_IRWXU | S_IRWXG );
1660         if (ret < 0) {
1661                 if (errno != EEXIST) {
1662                         ERR("Unable to create " LTTNG_RUNDIR);
1663                         goto error;
1664                 } else {
1665                         ret = 0;
1666                 }
1667         }
1668
1669 error:
1670         return ret;
1671 }
1672
1673 /*
1674  *  set_kconsumerd_sockets
1675  *
1676  *  Setup sockets and directory needed by the kconsumerd
1677  *  communication with the session daemon.
1678  */
1679 static int set_kconsumerd_sockets(void)
1680 {
1681         int ret;
1682
1683         if (strlen(kconsumerd_err_unix_sock_path) == 0) {
1684                 snprintf(kconsumerd_err_unix_sock_path, PATH_MAX, KCONSUMERD_ERR_SOCK_PATH);
1685         }
1686
1687         if (strlen(kconsumerd_cmd_unix_sock_path) == 0) {
1688                 snprintf(kconsumerd_cmd_unix_sock_path, PATH_MAX, KCONSUMERD_CMD_SOCK_PATH);
1689         }
1690
1691         ret = mkdir(KCONSUMERD_PATH, S_IRWXU | S_IRWXG);
1692         if (ret < 0) {
1693                 if (errno != EEXIST) {
1694                         ERR("Failed to create " KCONSUMERD_PATH);
1695                         goto error;
1696                 }
1697                 ret = 0;
1698         }
1699
1700         /* Create the kconsumerd error unix socket */
1701         kconsumerd_err_sock = lttcomm_create_unix_sock(kconsumerd_err_unix_sock_path);
1702         if (kconsumerd_err_sock < 0) {
1703                 ERR("Create unix sock failed: %s", kconsumerd_err_unix_sock_path);
1704                 ret = -1;
1705                 goto error;
1706         }
1707
1708         /* File permission MUST be 660 */
1709         ret = chmod(kconsumerd_err_unix_sock_path, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
1710         if (ret < 0) {
1711                 ERR("Set file permissions failed: %s", kconsumerd_err_unix_sock_path);
1712                 perror("chmod");
1713                 goto error;
1714         }
1715
1716 error:
1717         return ret;
1718 }
1719
1720 /*
1721  *  sighandler
1722  *
1723  *  Signal handler for the daemon
1724  */
1725 static void sighandler(int sig)
1726 {
1727         switch (sig) {
1728                 case SIGPIPE:
1729                         DBG("SIGPIPE catched");
1730                         return;
1731                 case SIGINT:
1732                         DBG("SIGINT catched");
1733                         cleanup();
1734                         break;
1735                 case SIGTERM:
1736                         DBG("SIGTERM catched");
1737                         cleanup();
1738                         break;
1739                 default:
1740                         break;
1741         }
1742
1743         exit(EXIT_SUCCESS);
1744 }
1745
1746 /*
1747  *  set_signal_handler
1748  *
1749  *  Setup signal handler for :
1750  *              SIGINT, SIGTERM, SIGPIPE
1751  */
1752 static int set_signal_handler(void)
1753 {
1754         int ret = 0;
1755         struct sigaction sa;
1756         sigset_t sigset;
1757
1758         if ((ret = sigemptyset(&sigset)) < 0) {
1759                 perror("sigemptyset");
1760                 return ret;
1761         }
1762
1763         sa.sa_handler = sighandler;
1764         sa.sa_mask = sigset;
1765         sa.sa_flags = 0;
1766         if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
1767                 perror("sigaction");
1768                 return ret;
1769         }
1770
1771         if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) {
1772                 perror("sigaction");
1773                 return ret;
1774         }
1775
1776         if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) {
1777                 perror("sigaction");
1778                 return ret;
1779         }
1780
1781         DBG("Signal handler set for SIGTERM, SIGPIPE and SIGINT");
1782
1783         return ret;
1784 }
1785
1786 /*
1787  *  set_ulimit
1788  *
1789  *  Set open files limit to unlimited. This daemon can open a large number of
1790  *  file descriptors in order to consumer multiple kernel traces.
1791  */
1792 static void set_ulimit(void)
1793 {
1794         int ret;
1795         struct rlimit lim;
1796
1797         lim.rlim_cur = 65535;
1798         lim.rlim_max = 65535;
1799
1800         ret = setrlimit(RLIMIT_NOFILE, &lim);
1801         if (ret < 0) {
1802                 perror("failed to set open files limit");
1803         }
1804 }
1805
1806 /*
1807  * main
1808  */
1809 int main(int argc, char **argv)
1810 {
1811         int ret = 0;
1812         void *status;
1813
1814         /* Parse arguments */
1815         progname = argv[0];
1816         if ((ret = parse_args(argc, argv) < 0)) {
1817                 goto error;
1818         }
1819
1820         /* Daemonize */
1821         if (opt_daemon) {
1822                 ret = daemon(0, 0);
1823                 if (ret < 0) {
1824                         perror("daemon");
1825                         goto error;
1826                 }
1827         }
1828
1829         /* Check if daemon is UID = 0 */
1830         is_root = !getuid();
1831
1832         /* Set all sockets path */
1833         if (is_root) {
1834                 ret = create_lttng_rundir();
1835                 if (ret < 0) {
1836                         goto error;
1837                 }
1838
1839                 if (strlen(apps_unix_sock_path) == 0) {
1840                         snprintf(apps_unix_sock_path, PATH_MAX,
1841                                         DEFAULT_GLOBAL_APPS_UNIX_SOCK);
1842                 }
1843
1844                 if (strlen(client_unix_sock_path) == 0) {
1845                         snprintf(client_unix_sock_path, PATH_MAX,
1846                                         DEFAULT_GLOBAL_CLIENT_UNIX_SOCK);
1847                 }
1848
1849                 ret = set_kconsumerd_sockets();
1850                 if (ret < 0) {
1851                         goto error;
1852                 }
1853
1854                 /* Setup kernel tracer */
1855                 init_kernel_tracer();
1856
1857                 /* Set ulimit for open files */
1858                 set_ulimit();
1859         } else {
1860                 if (strlen(apps_unix_sock_path) == 0) {
1861                         snprintf(apps_unix_sock_path, PATH_MAX,
1862                                         DEFAULT_HOME_APPS_UNIX_SOCK, get_home_dir());
1863                 }
1864
1865                 /* Set the cli tool unix socket path */
1866                 if (strlen(client_unix_sock_path) == 0) {
1867                         snprintf(client_unix_sock_path, PATH_MAX,
1868                                         DEFAULT_HOME_CLIENT_UNIX_SOCK, get_home_dir());
1869                 }
1870         }
1871
1872         DBG("Client socket path %s", client_unix_sock_path);
1873         DBG("Application socket path %s", apps_unix_sock_path);
1874
1875         /* See if daemon already exist. If any of the two
1876          * socket needed by the daemon are present, this test fails
1877          */
1878         if ((ret = check_existing_daemon()) == 0) {
1879                 ERR("Already running daemon.\n");
1880                 /* We do not goto error because we must not
1881                  * cleanup() because a daemon is already running.
1882                  */
1883                 exit(EXIT_FAILURE);
1884         }
1885
1886         if (set_signal_handler() < 0) {
1887                 goto error;
1888         }
1889
1890         /* Setup the needed unix socket */
1891         if (init_daemon_socket() < 0) {
1892                 goto error;
1893         }
1894
1895         /* Set credentials to socket */
1896         if (is_root && (set_permissions() < 0)) {
1897                 goto error;
1898         }
1899
1900         /* Get parent pid if -S, --sig-parent is specified. */
1901         if (opt_sig_parent) {
1902                 ppid = getppid();
1903         }
1904
1905         while (1) {
1906                 /* Create thread to manage the client socket */
1907                 ret = pthread_create(&client_thread, NULL, thread_manage_clients, (void *) NULL);
1908                 if (ret != 0) {
1909                         perror("pthread_create");
1910                         goto error;
1911                 }
1912
1913                 /* Create thread to manage application socket */
1914                 ret = pthread_create(&apps_thread, NULL, thread_manage_apps, (void *) NULL);
1915                 if (ret != 0) {
1916                         perror("pthread_create");
1917                         goto error;
1918                 }
1919
1920                 ret = pthread_join(client_thread, &status);
1921                 if (ret != 0) {
1922                         perror("pthread_join");
1923                         goto error;
1924                 }
1925         }
1926
1927         cleanup();
1928         exit(EXIT_SUCCESS);
1929
1930 error:
1931         cleanup();
1932         exit(EXIT_FAILURE);
1933 }