src/bin/lttng/commands/create.c

   1 /*
   2  * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License, version 2 only,
   6  * as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  16  */
  17
  18 #define _LGPL_SOURCE
  19 #include <assert.h>
  20 #include <ctype.h>
  21 #include <popt.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <sys/stat.h>
  26 #include <sys/types.h>
  27 #include <time.h>
  28 #include <unistd.h>
  29 #include <signal.h>
  30 #include <sys/wait.h>
  31
  32 #include <common/mi-lttng.h>
  33
  34 #include "../command.h"
  35 #include "../utils.h"
  36
  37 #include <common/defaults.h>
  38 #include <common/sessiond-comm/sessiond-comm.h>
  39 #include <common/uri.h>
  40 #include <common/utils.h>
  41 #include <lttng/snapshot.h>
  42
  43 static char *opt_output_path;
  44 static char *opt_session_name;
  45 static char *opt_url;
  46 static char *opt_ctrl_url;
  47 static char *opt_data_url;
  48 static char *opt_shm_path;
  49 static int opt_no_consumer;
  50 static int opt_no_output;
  51 static int opt_snapshot;
  52 static unsigned int opt_live_timer;
  53
  54 enum {
  55         OPT_HELP = 1,
  56         OPT_LIST_OPTIONS,
  57         OPT_LIVE_TIMER,
  58 };
  59
  60 enum {
  61         OUTPUT_UNKNOWN = -1,
  62         OUTPUT_NONE,
  63         OUTPUT_LOCAL,
  64         OUTPUT_NET,
  65 };
  66 enum {
  67         SESSION_UNKNOWN = -1,
  68         SESSION_NORMAL,
  69         SESSION_LIVE,
  70         SESSION_SNAPSHOT,
  71 };
  72
  73
  74 static struct mi_writer *writer;
  75
  76 static struct poptOption long_options[] = {
  77         /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
  78         {"help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL},
  79         {"output", 'o', POPT_ARG_STRING, &opt_output_path, 0, NULL, NULL},
  80         {"list-options", 0, POPT_ARG_NONE, NULL, OPT_LIST_OPTIONS, NULL, NULL},
  81         {"set-url",        'U', POPT_ARG_STRING, &opt_url, 0, 0, 0},
  82         {"ctrl-url",       'C', POPT_ARG_STRING, &opt_ctrl_url, 0, 0, 0},
  83         {"data-url",       'D', POPT_ARG_STRING, &opt_data_url, 0, 0, 0},
  84         {"no-output",       0, POPT_ARG_VAL, &opt_no_output, 1, 0, 0},
  85         {"no-consumer",     0, POPT_ARG_VAL, &opt_no_consumer, 1, 0, 0},
  86         {"snapshot",        0, POPT_ARG_VAL, &opt_snapshot, 1, 0, 0},
  87         {"live",            0, POPT_ARG_INT | POPT_ARGFLAG_OPTIONAL, 0, OPT_LIVE_TIMER, 0, 0},
  88         {"shm-path",        0, POPT_ARG_STRING, &opt_shm_path, 0, 0, 0},
  89         {0, 0, 0, 0, 0, 0, 0}
  90 };
  91
  92 /*
  93  * Please have a look at src/lib/lttng-ctl/lttng-ctl.c for more information on
  94  * why this declaration exists and used ONLY in for this command.
  95  */
  96 extern int _lttng_create_session_ext(const char *name, const char *url,
  97                 const char *datetime);
  98
  99 /*
 100  * Retrieve the created session and mi output it based on provided argument
 101  * This is currently a summary of what was pretty printed and is subject to
 102  * enhancements.
 103  */
 104 static int mi_created_session(const char *session_name)
 105 {
 106         int ret, i, count, found;
 107         struct lttng_session *sessions;
 108
 109         /* session_name should not be null */
 110         assert(session_name);
 111         assert(writer);
 112
 113         count = lttng_list_sessions(&sessions);
 114         if (count < 0) {
 115                 ret = count;
 116                 ERR("%s", lttng_strerror(ret));
 117                 goto error;
 118         }
 119
 120         if (count == 0) {
 121                 ERR("Error session creation failed: session %s not found", session_name);
 122                 ret = -LTTNG_ERR_SESS_NOT_FOUND;
 123                 goto end;
 124         }
 125
 126         found = 0;
 127         for (i = 0; i < count; i++) {
 128                 if (strncmp(sessions[i].name, session_name, NAME_MAX) == 0) {
 129                         found = 1;
 130                         ret = mi_lttng_session(writer, &sessions[i], 0);
 131                         if (ret) {
 132                                 goto error;
 133                         }
 134                         break;
 135                 }
 136         }
 137
 138         if (!found) {
 139                 ret = -LTTNG_ERR_SESS_NOT_FOUND;
 140         } else {
 141                 ret = CMD_SUCCESS;
 142         }
 143
 144 error:
 145         free(sessions);
 146 end:
 147         return ret;
 148 }
 149
 150 /*
 151  * For a session name, set the consumer URLs.
 152  */
 153 static int set_consumer_url(const char *session_name, const char *ctrl_url,
 154                 const char *data_url)
 155 {
 156         int ret;
 157         struct lttng_handle *handle;
 158
 159         assert(session_name);
 160
 161         /*
 162          * Set handle with the session_name, but no domain. This implies that
 163          * the actions taken with this handle apply on the tracing session
 164          * rather then the domain-specific session.
 165          */
 166         handle = lttng_create_handle(session_name, NULL);
 167         if (handle == NULL) {
 168                 ret = CMD_FATAL;
 169                 goto error;
 170         }
 171
 172         ret = lttng_set_consumer_url(handle, ctrl_url, data_url);
 173         if (ret < 0) {
 174                 goto error;
 175         }
 176
 177 error:
 178         lttng_destroy_handle(handle);
 179         return ret;
 180 }
 181
 182 static int add_snapshot_output(const char *session_name, const char *ctrl_url,
 183                 const char *data_url)
 184 {
 185         int ret;
 186         struct lttng_snapshot_output *output = NULL;
 187
 188         assert(session_name);
 189
 190         output = lttng_snapshot_output_create();
 191         if (!output) {
 192                 ret = CMD_FATAL;
 193                 goto error_create;
 194         }
 195
 196         if (ctrl_url) {
 197                 ret = lttng_snapshot_output_set_ctrl_url(ctrl_url, output);
 198                 if (ret < 0) {
 199                         goto error;
 200                 }
 201         }
 202
 203         if (data_url) {
 204                 ret = lttng_snapshot_output_set_data_url(data_url, output);
 205                 if (ret < 0) {
 206                         goto error;
 207                 }
 208         }
 209
 210         /* This call, if successful, populates the id of the output object. */
 211         ret = lttng_snapshot_add_output(session_name, output);
 212         if (ret < 0) {
 213                 goto error;
 214         }
 215
 216 error:
 217         lttng_snapshot_output_destroy(output);
 218 error_create:
 219         return ret;
 220 }
 221
 222 /*
 223  * Validate the combinations of passed options
 224  *
 225  * CMD_ERROR on error
 226  * CMD_SUCCESS on success
 227  */
 228 static int validate_command_options(void)
 229 {
 230         int ret = CMD_SUCCESS;
 231
 232         if (opt_snapshot && opt_live_timer) {
 233                 ERR("Snapshot and live modes are mutually exclusive.");
 234                 ret = CMD_ERROR;
 235                 goto error;
 236         }
 237
 238         if ((!opt_ctrl_url && opt_data_url) || (opt_ctrl_url && !opt_data_url)) {
 239                 ERR("Control and data URLs must both be set.");
 240                 ret = CMD_ERROR;
 241                 goto error;
 242         }
 243
 244 error:
 245         return ret;
 246 }
 247
 248 /*
 249  * Create a session via direct calls to liblttng-ctl.
 250  *
 251  * Return CMD_SUCCESS on success, negative value on internal lttng errors and positive
 252  * value on command errors.
 253  */
 254 static int create_session_basic (const char *session_name,
 255                 int session_type,
 256                 int live_timer,
 257                 int output_type,
 258                 const char* url,
 259                 const char* ctrl_url,
 260                 const char* data_url,
 261                 const char* shm_path,
 262                 const char* datetime)
 263 {
 264         /* Create session based on session creation */
 265         int ret = CMD_SUCCESS;
 266         const char *pathname;
 267
 268         assert(datetime);
 269
 270         if (opt_relayd_path) {
 271                 pathname = opt_relayd_path;
 272         } else {
 273                 pathname = INSTALL_BIN_PATH "/lttng-relayd";
 274         }
 275
 276         switch (session_type) {
 277         case SESSION_NORMAL:
 278                 ret = _lttng_create_session_ext(session_name, url, datetime);
 279                 break;
 280         case SESSION_SNAPSHOT:
 281                 if (output_type == OUTPUT_NONE) {
 282                         ERR("--no-output on a snapshot session is invalid");
 283                         ret = CMD_UNSUPPORTED;
 284                         goto error;
 285                 }
 286                 ret = lttng_create_session_snapshot(session_name, url);
 287                 break;
 288         case SESSION_LIVE:
 289                 if (output_type == OUTPUT_NONE) {
 290                         ERR("--no-output on a live session is invalid");
 291                         ret = CMD_UNSUPPORTED;
 292                         goto error;
 293                 }
 294
 295                 if (output_type == OUTPUT_LOCAL) {
 296                         ERR("Local file output on a live session is invalid");
 297                         ret = CMD_UNSUPPORTED;
 298                         goto error;
 299                 }
 300                 if (output_type != OUTPUT_NET && !check_relayd() &&
 301                                 spawn_relayd(pathname, 0) < 0) {
 302                         ret = CMD_FATAL;
 303                         goto error;
 304                 }
 305                 ret = lttng_create_session_live(session_name, url, live_timer);
 306                 break;
 307         default:
 308                 ERR("Unknown session type");
 309                 ret = CMD_UNDEFINED;
 310                 goto error;
 311         }
 312
 313         if (ret < 0) {
 314                 /* Don't set ret so the sessiond error is propagated. */
 315                 switch (-ret) {
 316                 case LTTNG_ERR_EXIST_SESS:
 317                         WARN("Session %s already exists", session_name);
 318                         break;
 319                 default:
 320                         break;
 321                 }
 322                 goto error;
 323         }
 324
 325         /* Configure the session based on the output type */
 326         switch (output_type) {
 327         case OUTPUT_LOCAL:
 328                 break;
 329         case OUTPUT_NET:
 330                 if (!ctrl_url || !data_url) {
 331                         break;
 332                 }
 333
 334                 if (session_type == SESSION_SNAPSHOT) {
 335                         ret = add_snapshot_output(session_name, ctrl_url,
 336                                         data_url);
 337                 } else {
 338                         /*
 339                          * Normal sessions and live sessions behave the same way
 340                          * regarding consumer url.
 341                          */
 342                         ret = set_consumer_url(session_name, ctrl_url, data_url);
 343                 }
 344                 if (ret < 0) {
 345                         /* Destroy created session on errors */
 346                         lttng_destroy_session(session_name);
 347                         goto error;
 348                 }
 349                 break;
 350         case OUTPUT_NONE:
 351                 break;
 352         default:
 353                 ERR("Unknown output type");
 354                 ret = CMD_UNDEFINED;
 355                 goto error;
 356         }
 357
 358         /*
 359          * Set the session shared memory path
 360          */
 361         if (shm_path) {
 362                 ret = lttng_set_session_shm_path(session_name, shm_path);
 363                 if (ret < 0) {
 364                         lttng_destroy_session(session_name);
 365                         goto error;
 366                 }
 367         }
 368 error:
 369         return ret;
 370 }
 371
 372 static int generate_output(const char *session_name,
 373                 int session_type,
 374                 int live_timer,
 375                 int output_type,
 376                 const char* url,
 377                 const char* ctrl_url,
 378                 const char* data_url,
 379                 const char* shm_path)
 380 {
 381         int ret = CMD_SUCCESS;
 382
 383         /*
 384          * TODO move this to after session name
 385          * for now we only emulate previous behaviour.
 386          */
 387         if (session_type != SESSION_SNAPSHOT) {
 388                 if (ctrl_url) {
 389                         MSG("Control URL %s set for session %s", ctrl_url, session_name);
 390                 }
 391
 392                 if (data_url) {
 393                         MSG("Data URL %s set for session %s", data_url, session_name);
 394                 }
 395         }
 396
 397         if (url && output_type == OUTPUT_LOCAL) {
 398                 /* Remove the file:// */
 399                 if (strlen(url) > strlen("file://")){
 400                         url = url + strlen("file://");
 401                 }
 402         }
 403
 404         MSG("Session %s created.", session_name);
 405         if (url && session_type != SESSION_SNAPSHOT) {
 406                 MSG("Traces will be written in %s", url);
 407
 408                 if (live_timer) {
 409                         MSG("Live timer set to %u usec", live_timer);
 410                 }
 411         } else if (session_type == SESSION_SNAPSHOT) {
 412                 if (url) {
 413                         MSG("Default snapshot output set to: %s", url);
 414                 }
 415                 MSG("Snapshot mode set. Every channel enabled for that session will "
 416                                 "be set to mmap output, and default to overwrite mode.");
 417         }
 418
 419         if (shm_path) {
 420                 MSG("Session %s set to shm_path: %s.", session_name,
 421                                 shm_path);
 422         }
 423
 424         /* Mi output */
 425         if (lttng_opt_mi) {
 426                 ret = mi_created_session(session_name);
 427                 if (ret) {
 428                         ret = CMD_ERROR;
 429                         goto error;
 430                 }
 431         }
 432 error:
 433         return ret;
 434 }
 435
 436 /*
 437  *  Create a tracing session.
 438  *  If no name is specified, a default name is generated.
 439  *
 440  *  Returns one of the CMD_* result constants.
 441  */
 442 static int create_session(void)
 443 {
 444         int ret;
 445
 446         /* Base data */
 447         int base_session_type = SESSION_UNKNOWN;
 448         int base_output_type = OUTPUT_UNKNOWN;
 449         char *base_session_name = NULL;
 450         char *base_url = NULL;
 451         char *base_ctrl_url = NULL;
 452         char *base_data_url = NULL;
 453         char *base_shm_path = NULL;
 454         int base_live_timer = 0;
 455
 456         /* Time data */
 457         char datetime[16];
 458         time_t rawtime;
 459         struct tm *timeinfo = NULL;
 460
 461         /* Temporary variables */
 462         char *traces_path = NULL;
 463         char *temp_url = NULL;
 464         char *session_name_date = NULL;
 465         char *tmp_url = NULL;
 466         char *tmp_home_path = NULL;
 467         struct lttng_uri *uris = NULL;
 468         ssize_t uri_array_size = 0;
 469
 470         /* Option validation */
 471         if (validate_command_options() != CMD_SUCCESS) {
 472                 ret = CMD_ERROR;
 473                 goto error;
 474         }
 475
 476         /* Get date and time for automatic session name/path */
 477         time(&rawtime);
 478         timeinfo = localtime(&rawtime);
 479         strftime(datetime, sizeof(datetime), "%Y%m%d-%H%M%S", timeinfo);
 480
 481         /* Find the session type based on options */
 482         if(base_session_type == SESSION_UNKNOWN) {
 483                 if (opt_snapshot) {
 484                         base_session_type = SESSION_SNAPSHOT;
 485                 } else if (opt_live_timer) {
 486                         base_session_type = SESSION_LIVE;
 487                 } else {
 488                         base_session_type = SESSION_NORMAL;
 489                 }
 490         }
 491
 492         /*
 493          * Session name handling
 494          */
 495         if (opt_session_name) {
 496                 /* Override the session name */
 497                 if (strlen(opt_session_name) > NAME_MAX) {
 498                         ERR("Session name too long. Length must be lower or equal to %d",
 499                                         NAME_MAX);
 500                         ret = LTTNG_ERR_SESSION_FAIL;
 501                         free(session_name_date);
 502                         goto error;
 503                 }
 504                 /*
 505                  * Check if the session name begins with "auto-" or is exactly "auto".
 506                  * Both are reserved for the default session name. See bug #449 to
 507                  * understand why we need to check both here.
 508                  */
 509                 if ((strncmp(opt_session_name, DEFAULT_SESSION_NAME "-",
 510                                 strlen(DEFAULT_SESSION_NAME) + 1) == 0) ||
 511                         (strncmp(opt_session_name, DEFAULT_SESSION_NAME,
 512                                 strlen(DEFAULT_SESSION_NAME)) == 0 &&
 513                         strlen(opt_session_name) == strlen(DEFAULT_SESSION_NAME))) {
 514                         ERR("%s is a reserved keyword for default session(s)",
 515                                         DEFAULT_SESSION_NAME);
 516
 517                         ret = CMD_ERROR;
 518                         goto error;
 519                 }
 520
 521                 base_session_name = strndup(opt_session_name, NAME_MAX);
 522                 if (!base_session_name) {
 523                         PERROR("Strdup session name");
 524                         ret = CMD_ERROR;
 525                         goto error;
 526                 }
 527
 528                 ret = asprintf(&session_name_date, "%s-%s", base_session_name, datetime);
 529                 if (ret < 0) {
 530                         PERROR("Asprintf session name");
 531                         goto error;
 532                 }
 533                 DBG("Session name from command option set to %s", base_session_name);
 534         } else if (base_session_name) {
 535                 ret = asprintf(&session_name_date, "%s-%s", base_session_name, datetime);
 536                 if (ret < 0) {
 537                         PERROR("Asprintf session name");
 538                         goto error;
 539                 }
 540         } else {
 541                 /* Generate a name */
 542                 ret = asprintf(&base_session_name, DEFAULT_SESSION_NAME "-%s", datetime);
 543                 if (ret < 0) {
 544                         PERROR("Asprintf session name");
 545                         goto error;
 546                 }
 547                 session_name_date = strdup(base_session_name);
 548                 DBG("Auto session name set to %s", base_session_name);
 549         }
 550
 551
 552         /*
 553          * Output handling
 554          */
 555
 556         /*
 557          * If any of those options are present clear all output related data.
 558          */
 559         if (opt_output_path || opt_url || (opt_ctrl_url && opt_data_url) || opt_no_output) {
 560                 /* Overwrite output */
 561                 free(base_url);
 562                 free(base_ctrl_url);
 563                 free(base_data_url);
 564                 base_url = NULL;
 565                 base_ctrl_url = NULL;
 566                 base_data_url = NULL;
 567         }
 568
 569         if (opt_output_path) {
 570
 571                 traces_path = utils_expand_path(opt_output_path);
 572                 if (!traces_path) {
 573                         ret = CMD_ERROR;
 574                         goto error;
 575                 }
 576
 577                 /* Create URL string from the local file system path */
 578                 ret = asprintf(&temp_url, "file://%s", traces_path);
 579                 if (ret < 0) {
 580                         PERROR("asprintf url path");
 581                         ret = CMD_FATAL;
 582                         goto error;
 583                 }
 584
 585                 base_url = temp_url;
 586         } else if (opt_url) { /* Handling URL (-U opt) */
 587                 base_url = strdup(opt_url);
 588         } else if (opt_data_url && opt_ctrl_url) {
 589                 /*
 590                  * With both control and data, we'll be setting the consumer URL
 591                  * after session creation thus use no URL.
 592                  */
 593                 base_ctrl_url = strdup(opt_ctrl_url);
 594                 base_data_url = strdup(opt_data_url);
 595         } else if (!(opt_no_output || base_output_type == OUTPUT_NONE ||
 596                                 base_url || base_ctrl_url || base_data_url)) {
 597                 /* Generate default output depending on the session type */
 598                 switch (base_session_type) {
 599                 case SESSION_NORMAL:
 600                         /* fallthrough */
 601                 case SESSION_SNAPSHOT:
 602                         /* Default to a local path */
 603                         tmp_home_path = utils_get_home_dir();
 604                         if (tmp_home_path == NULL) {
 605                                 ERR("HOME path not found.\n \
 606                                                 Please specify an output path using -o, --output PATH");
 607                                 ret = CMD_FATAL;
 608                                 goto error;
 609                         }
 610
 611                         ret = asprintf(&tmp_url,
 612                                         "file://%s/" DEFAULT_TRACE_DIR_NAME "/%s",
 613                                         tmp_home_path, session_name_date);
 614
 615                         if (ret < 0) {
 616                                 PERROR("asprintf trace dir name");
 617                                 ret = CMD_FATAL;
 618                                 goto error;
 619                         }
 620
 621                         base_url = tmp_url ;
 622                         break;
 623                 case SESSION_LIVE:
 624                         /* Default to a net output */
 625                         ret = asprintf(&tmp_url, "net://127.0.0.1");
 626                         if (ret < 0) {
 627                                 PERROR("asprintf default live URL");
 628                                 ret = CMD_FATAL;
 629                                 goto error;
 630                         }
 631                         base_url = tmp_url ;
 632                         break;
 633                 default:
 634                         ERR("Unknown session type");
 635                         ret = CMD_FATAL;
 636                         goto error;
 637                 }
 638         }
 639
 640          /*
 641           * Shared memory path handling
 642           */
 643         if (opt_shm_path) {
 644                 ret = asprintf(&base_shm_path, "%s/%s", opt_shm_path, session_name_date);
 645                 if (ret < 0) {
 646                         PERROR("asprintf shm_path");
 647                         goto error;
 648                 }
 649         }
 650
 651          /*
 652           * Live timer handling
 653           */
 654         if (opt_live_timer) {
 655                 base_live_timer = opt_live_timer;
 656         }
 657
 658         /* Get output type from urls */
 659         if (base_url) {
 660                 /* Get lttng uris from single url */
 661                 uri_array_size = uri_parse_str_urls(base_url, NULL, &uris);
 662                 if (uri_array_size < 0) {
 663                         ret = CMD_ERROR;
 664                         goto error;
 665                 }
 666         } else if (base_ctrl_url && base_data_url) {
 667                 uri_array_size = uri_parse_str_urls(base_ctrl_url, base_data_url, &uris);
 668                 if (uri_array_size < 0) {
 669                         ret = CMD_ERROR;
 670                         goto error;
 671                 }
 672         } else {
 673                 /* --no-output */
 674                 uri_array_size = 0;
 675         }
 676
 677         switch (uri_array_size) {
 678         case 0:
 679                 base_output_type = OUTPUT_NONE;
 680                 break;
 681         case 1:
 682                 base_output_type = OUTPUT_LOCAL;
 683                 break;
 684         case 2:
 685                 base_output_type = OUTPUT_NET;
 686                 break;
 687         default:
 688                 ret = CMD_ERROR;
 689                 goto error;
 690         }
 691
 692         ret = create_session_basic (base_session_name,
 693                         base_session_type,
 694                         base_live_timer,
 695                         base_output_type,
 696                         base_url,
 697                         base_ctrl_url,
 698                         base_data_url,
 699                         base_shm_path,
 700                         datetime);
 701         if (ret) {
 702                 goto error;
 703         }
 704
 705         ret = generate_output (base_session_name,
 706                         base_session_type,
 707                         base_live_timer,
 708                         base_output_type,
 709                         base_url,
 710                         base_ctrl_url,
 711                         base_data_url,
 712                         base_shm_path);
 713         if (ret) {
 714                 goto error;
 715         }
 716
 717         /* Init lttng session config */
 718         ret = config_init(base_session_name);
 719         if (ret < 0) {
 720                 ret = CMD_ERROR;
 721                 goto error;
 722         }
 723
 724         ret = CMD_SUCCESS;
 725
 726 error:
 727         /* Session temp stuff */
 728         free(session_name_date);
 729         free(uris);
 730
 731         if (ret < 0) {
 732                 ERR("%s", lttng_strerror(ret));
 733         }
 734
 735         free(base_session_name);
 736         free(base_url);
 737         free(base_ctrl_url);
 738         free(base_data_url);
 739         free(base_shm_path);
 740         return ret;
 741 }
 742
 743 /*
 744  *  spawn_sessiond
 745  *
 746  *  Spawn a session daemon by forking and execv.
 747  */
 748 static int spawn_sessiond(char *pathname)
 749 {
 750         int ret = 0;
 751         pid_t pid;
 752
 753         MSG("Spawning a session daemon");
 754         pid = fork();
 755         if (pid == 0) {
 756                 /*
 757                  * Spawn session daemon in daemon mode.
 758                  */
 759                 execlp(pathname, "lttng-sessiond",
 760                                 "--daemonize", NULL);
 761                 /* execlp only returns if error happened */
 762                 if (errno == ENOENT) {
 763                         ERR("No session daemon found. Use --sessiond-path.");
 764                 } else {
 765                         PERROR("execlp");
 766                 }
 767                 kill(getppid(), SIGTERM);       /* wake parent */
 768                 exit(EXIT_FAILURE);
 769         } else if (pid > 0) {
 770                 /*
 771                  * In daemon mode (--daemonize), sessiond only exits when
 772                  * it's ready to accept commands.
 773                  */
 774                 for (;;) {
 775                         int status;
 776                         pid_t wait_pid_ret = waitpid(pid, &status, 0);
 777
 778                         if (wait_pid_ret < 0) {
 779                                 if (errno == EINTR) {
 780                                         continue;
 781                                 }
 782                                 PERROR("waitpid");
 783                                 ret = -errno;
 784                                 goto end;
 785                         }
 786
 787                         if (WIFSIGNALED(status)) {
 788                                 ERR("Session daemon was killed by signal %d",
 789                                                 WTERMSIG(status));
 790                                 ret = -1;
 791                                 goto end;
 792                         } else if (WIFEXITED(status)) {
 793                                 DBG("Session daemon terminated normally (exit status: %d)",
 794                                                 WEXITSTATUS(status));
 795
 796                                 if (WEXITSTATUS(status) != 0) {
 797                                         ERR("Session daemon terminated with an error (exit status: %d)",
 798                                                         WEXITSTATUS(status));
 799                                         ret = -1;
 800                                         goto end;
 801                                 }
 802                                 break;
 803                         }
 804                 }
 805
 806                 goto end;
 807         } else {
 808                 PERROR("fork");
 809                 ret = -1;
 810                 goto end;
 811         }
 812
 813 end:
 814         return ret;
 815 }
 816
 817 /*
 818  *  launch_sessiond
 819  *
 820  *  Check if the session daemon is available using
 821  *  the liblttngctl API for the check. If not, try to
 822  *  spawn a daemon.
 823  */
 824 static int launch_sessiond(void)
 825 {
 826         int ret;
 827         char *pathname = NULL;
 828
 829         ret = lttng_session_daemon_alive();
 830         if (ret) {
 831                 /* Sessiond is alive, not an error */
 832                 ret = 0;
 833                 goto end;
 834         }
 835
 836         /* Try command line option path */
 837         pathname = opt_sessiond_path;
 838
 839         /* Try LTTNG_SESSIOND_PATH env variable */
 840         if (pathname == NULL) {
 841                 pathname = getenv(DEFAULT_SESSIOND_PATH_ENV);
 842         }
 843
 844         /* Try with configured path */
 845         if (pathname == NULL) {
 846                 if (CONFIG_SESSIOND_BIN[0] != '\0') {
 847                         pathname = CONFIG_SESSIOND_BIN;
 848                 }
 849         }
 850
 851         /* Try the default path */
 852         if (pathname == NULL) {
 853                 pathname = INSTALL_BIN_PATH "/lttng-sessiond";
 854         }
 855
 856         DBG("Session daemon binary path: %s", pathname);
 857
 858         /* Check existence and permissions */
 859         ret = access(pathname, F_OK | X_OK);
 860         if (ret < 0) {
 861                 ERR("No such file or access denied: %s", pathname);
 862                 goto end;
 863         }
 864
 865         ret = spawn_sessiond(pathname);
 866 end:
 867         if (ret) {
 868                 ERR("Problem occurred while launching session daemon (%s)",
 869                                 pathname);
 870         }
 871         return ret;
 872 }
 873
 874 /*
 875  *  The 'create <options>' first level command
 876  *
 877  *  Returns one of the CMD_* result constants.
 878  */
 879 int cmd_create(int argc, const char **argv)
 880 {
 881         int opt, ret = CMD_SUCCESS, command_ret = CMD_SUCCESS, success = 1;
 882         char *opt_arg = NULL;
 883         static poptContext pc;
 884
 885         pc = poptGetContext(NULL, argc, argv, long_options, 0);
 886         poptReadDefaultConfig(pc, 0);
 887
 888         while ((opt = poptGetNextOpt(pc)) != -1) {
 889                 switch (opt) {
 890                 case OPT_HELP:
 891                         SHOW_HELP();
 892                         goto end;
 893                 case OPT_LIST_OPTIONS:
 894                         list_cmd_options(stdout, long_options);
 895                         goto end;
 896                 case OPT_LIVE_TIMER:
 897                 {
 898                         unsigned long v;
 899
 900                         errno = 0;
 901                         opt_arg = poptGetOptArg(pc);
 902                         if (!opt_arg) {
 903                                 /* Set up default values. */
 904                                 opt_live_timer = (uint32_t) DEFAULT_LTTNG_LIVE_TIMER;
 905                                 DBG("Session live timer interval set to default value %d",
 906                                                 opt_live_timer);
 907                                 break;
 908                         }
 909
 910                         v = strtoul(opt_arg, NULL, 0);
 911                         if (errno != 0 || !isdigit(opt_arg[0])) {
 912                                 ERR("Wrong value in --live parameter: %s", opt_arg);
 913                                 ret = CMD_ERROR;
 914                                 goto end;
 915                         }
 916                         if (v != (uint32_t) v) {
 917                                 ERR("32-bit overflow in --live parameter: %s", opt_arg);
 918                                 ret = CMD_ERROR;
 919                                 goto end;
 920                         }
 921                         if (v == 0) {
 922                                 ERR("Live timer interval must be greater than zero");
 923                                 ret = CMD_ERROR;
 924                                 goto end;
 925                         }
 926                         opt_live_timer = (uint32_t) v;
 927                         DBG("Session live timer interval set to %d", opt_live_timer);
 928                         break;
 929                 }
 930                 default:
 931                         ret = CMD_UNDEFINED;
 932                         goto end;
 933                 }
 934         }
 935
 936         if (opt_no_consumer) {
 937                 MSG("The option --no-consumer is obsolete. Use --no-output now.");
 938                 ret = CMD_WARNING;
 939                 goto end;
 940         }
 941
 942         /* Spawn a session daemon if needed */
 943         if (!opt_no_sessiond) {
 944                 ret = launch_sessiond();
 945                 if (ret) {
 946                         ret = CMD_ERROR;
 947                         goto end;
 948                 }
 949         }
 950
 951         /* MI initialization */
 952         if (lttng_opt_mi) {
 953                 writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi);
 954                 if (!writer) {
 955                         ret = -LTTNG_ERR_NOMEM;
 956                         goto end;
 957                 }
 958
 959                 /* Open command element */
 960                 ret = mi_lttng_writer_command_open(writer,
 961                                 mi_lttng_element_command_create);
 962                 if (ret) {
 963                         ret = CMD_ERROR;
 964                         goto end;
 965                 }
 966
 967                 /* Open output element */
 968                 ret = mi_lttng_writer_open_element(writer,
 969                                 mi_lttng_element_command_output);
 970                 if (ret) {
 971                         ret = CMD_ERROR;
 972                         goto end;
 973                 }
 974         }
 975         opt_session_name = (char*) poptGetArg(pc);
 976
 977         command_ret = create_session();
 978
 979         if (command_ret) {
 980                 success = 0;
 981         }
 982
 983         if (lttng_opt_mi) {
 984                 /* Close  output element */
 985                 ret = mi_lttng_writer_close_element(writer);
 986                 if (ret) {
 987                         ret = CMD_ERROR;
 988                         goto end;
 989                 }
 990
 991                 /* Success ? */
 992                 ret = mi_lttng_writer_write_element_bool(writer,
 993                                 mi_lttng_element_command_success, success);
 994                 if (ret) {
 995                         ret = CMD_ERROR;
 996                         goto end;
 997                 }
 998
 999                 /* Command element close */
1000                 ret = mi_lttng_writer_command_close(writer);
1001                 if (ret) {
1002                         ret = CMD_ERROR;
1003                         goto end;
1004                 }
1005         }
1006
1007 end:
1008         /* Mi clean-up */
1009         if (writer && mi_lttng_writer_destroy(writer)) {
1010                 /* Preserve original error code */
1011                 ret = ret ? ret : -LTTNG_ERR_MI_IO_FAIL;
1012         }
1013
1014         /* Overwrite ret if an error occurred in create_session() */
1015         ret = command_ret ? command_ret : ret;
1016
1017         poptFreeContext(pc);
1018         return ret;
1019 }