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         if (opt_snapshot && opt_live_timer) {
 232                 ERR("Snapshot and live modes are mutually exclusive.");
 233                 ret = CMD_ERROR;
 234                 goto error;
 235         }
 236
 237         if ((!opt_ctrl_url && opt_data_url) || (opt_ctrl_url && !opt_data_url)) {
 238                 ERR("You need both control and data URL.");
 239                 ret = CMD_ERROR;
 240                 goto error;
 241         }
 242
 243 error:
 244         return ret;
 245 }
 246
 247 /*
 248  * Create a session via direct calls to liblttng-ctl.
 249  *
 250  * Return CMD_SUCCESS on success, negative value on internal lttng errors and positive
 251  * value on command errors.
 252  */
 253 static int create_session_basic (const char *session_name,
 254                 int session_type,
 255                 int live_timer,
 256                 int output_type,
 257                 const char* url,
 258                 const char* ctrl_url,
 259                 const char* data_url,
 260                 const char* shm_path,
 261                 const char* datetime)
 262 {
 263         /* Create session based on session creation */
 264         int ret = CMD_SUCCESS;
 265         const char *pathname;
 266
 267         assert(datetime);
 268
 269         if (opt_relayd_path) {
 270                 pathname = opt_relayd_path;
 271         } else {
 272                 pathname = INSTALL_BIN_PATH "/lttng-relayd";
 273         }
 274
 275         switch (session_type) {
 276         case SESSION_NORMAL:
 277                 ret = _lttng_create_session_ext(session_name, url, datetime);
 278                 break;
 279         case SESSION_SNAPSHOT:
 280                 if (output_type == OUTPUT_NONE) {
 281                         ERR("--no-output on a snapshot session is invalid");
 282                         ret = CMD_UNSUPPORTED;
 283                         goto error;
 284                 }
 285                 ret = lttng_create_session_snapshot(session_name, url);
 286                 break;
 287         case SESSION_LIVE:
 288                 if (output_type == OUTPUT_NONE) {
 289                         ERR("--no-output on a live session is invalid");
 290                         ret = CMD_UNSUPPORTED;
 291                         goto error;
 292                 }
 293
 294                 if (output_type == OUTPUT_LOCAL) {
 295                         ERR("Local file output on a live session is invalid");
 296                         ret = CMD_UNSUPPORTED;
 297                         goto error;
 298                 }
 299                 if (output_type != OUTPUT_NET && !check_relayd() &&
 300                                 spawn_relayd(pathname, 0) < 0) {
 301                         ret = CMD_FATAL;
 302                         goto error;
 303                 }
 304                 ret = lttng_create_session_live(session_name, url, live_timer);
 305                 break;
 306         default:
 307                 ERR("Unknown session type");
 308                 ret = CMD_UNDEFINED;
 309                 goto error;
 310         }
 311
 312         if (ret < 0) {
 313                 /* Don't set ret so the sessiond error is propagated. */
 314                 switch (-ret) {
 315                 case LTTNG_ERR_EXIST_SESS:
 316                         WARN("Session %s already exists", session_name);
 317                         break;
 318                 default:
 319                         break;
 320                 }
 321                 goto error;
 322         }
 323
 324         /* Configure the session based on the output type */
 325         switch (output_type) {
 326         case OUTPUT_LOCAL:
 327                 break;
 328         case OUTPUT_NET:
 329                 if (!ctrl_url || !data_url) {
 330                         break;
 331                 }
 332
 333                 if (session_type == SESSION_SNAPSHOT) {
 334                         ret = add_snapshot_output(session_name, ctrl_url,
 335                                         data_url);
 336                 } else {
 337                         /*
 338                          * Normal sessions and live sessions behave the same way
 339                          * regarding consumer url.
 340                          */
 341                         ret = set_consumer_url(session_name, ctrl_url, data_url);
 342                 }
 343                 if (ret < 0) {
 344                         /* Destroy created session on errors */
 345                         lttng_destroy_session(session_name);
 346                         goto error;
 347                 }
 348                 break;
 349         case OUTPUT_NONE:
 350                 break;
 351         default:
 352                 ERR("Unknown output type");
 353                 ret = CMD_UNDEFINED;
 354                 goto error;
 355         }
 356
 357         /*
 358          * Set the session shared memory path
 359          */
 360         if (shm_path) {
 361                 ret = lttng_set_session_shm_path(session_name, shm_path);
 362                 if (ret < 0) {
 363                         lttng_destroy_session(session_name);
 364                         goto error;
 365                 }
 366         }
 367 error:
 368         return ret;
 369 }
 370
 371 static int generate_output(const char *session_name,
 372                 int session_type,
 373                 int live_timer,
 374                 int output_type,
 375                 const char* url,
 376                 const char* ctrl_url,
 377                 const char* data_url,
 378                 const char* shm_path)
 379 {
 380         int ret = CMD_SUCCESS;
 381
 382         /*
 383          * TODO move this to after session name
 384          * for now we only emulate previous behaviour.
 385          */
 386         if (session_type != SESSION_SNAPSHOT) {
 387                 if (ctrl_url) {
 388                         MSG("Control URL %s set for session %s", ctrl_url, session_name);
 389                 }
 390
 391                 if (data_url) {
 392                         MSG("Data URL %s set for session %s", data_url, session_name);
 393                 }
 394         }
 395
 396         if (url && output_type == OUTPUT_LOCAL) {
 397                 /* Remove the file:// */
 398                 if (strlen(url) > strlen("file://")){
 399                         url = url + strlen("file://");
 400                 }
 401         }
 402
 403         MSG("Session %s created.", session_name);
 404         if (url && session_type != SESSION_SNAPSHOT) {
 405                 MSG("Traces will be written in %s", url);
 406
 407                 if (live_timer) {
 408                         MSG("Live timer set to %u usec", live_timer);
 409                 }
 410         } else if (session_type == SESSION_SNAPSHOT) {
 411                 if (url) {
 412                         MSG("Default snapshot output set to: %s", url);
 413                 }
 414                 MSG("Snapshot mode set. Every channel enabled for that session will "
 415                                 "be set to mmap output, and default to overwrite mode.");
 416         }
 417
 418         if (shm_path) {
 419                 MSG("Session %s set to shm_path: %s.", session_name,
 420                                 shm_path);
 421         }
 422
 423         /* Mi output */
 424         if (lttng_opt_mi) {
 425                 ret = mi_created_session(session_name);
 426                 if (ret) {
 427                         ret = CMD_ERROR;
 428                         goto error;
 429                 }
 430         }
 431 error:
 432         return ret;
 433 }
 434
 435 /*
 436  *  Create a tracing session.
 437  *  If no name is specified, a default name is generated.
 438  *
 439  *  Returns one of the CMD_* result constants.
 440  */
 441 static int create_session(void)
 442 {
 443         int ret;
 444
 445         /* Base data */
 446         int base_session_type = SESSION_UNKNOWN;
 447         int base_output_type = OUTPUT_UNKNOWN;
 448         char *base_session_name = NULL;
 449         char *base_url = NULL;
 450         char *base_ctrl_url = NULL;
 451         char *base_data_url = NULL;
 452         char *base_shm_path = NULL;
 453         int base_live_timer = 0;
 454
 455         /* Time data */
 456         char datetime[16];
 457         time_t rawtime;
 458         struct tm *timeinfo = NULL;
 459
 460         /* Temporary variables */
 461         char *traces_path = NULL;
 462         char *temp_url = NULL;
 463         char *session_name_date = NULL;
 464         char *tmp_url = NULL;
 465         char *tmp_home_path = NULL;
 466         struct lttng_uri *uris = NULL;
 467         ssize_t uri_array_size = 0;
 468
 469         /* Option validation */
 470         if (validate_command_options() != CMD_SUCCESS) {
 471                 ret = CMD_ERROR;
 472                 goto error;
 473         }
 474
 475         /* Get date and time for automatic session name/path */
 476         time(&rawtime);
 477         timeinfo = localtime(&rawtime);
 478         strftime(datetime, sizeof(datetime), "%Y%m%d-%H%M%S", timeinfo);
 479
 480         /* Find the session type based on options */
 481         if(base_session_type == SESSION_UNKNOWN) {
 482                 if (opt_snapshot) {
 483                         base_session_type = SESSION_SNAPSHOT;
 484                 } else if (opt_live_timer) {
 485                         base_session_type = SESSION_LIVE;
 486                 } else {
 487                         base_session_type = SESSION_NORMAL;
 488                 }
 489         }
 490
 491         /*
 492          * Session name handling
 493          */
 494         if (opt_session_name) {
 495                 /* Override the session name */
 496                 if (strlen(opt_session_name) > NAME_MAX) {
 497                         ERR("Session name too long. Length must be lower or equal to %d",
 498                                         NAME_MAX);
 499                         ret = LTTNG_ERR_SESSION_FAIL;
 500                         free(session_name_date);
 501                         goto error;
 502                 }
 503                 /*
 504                  * Check if the session name begins with "auto-" or is exactly "auto".
 505                  * Both are reserved for the default session name. See bug #449 to
 506                  * understand why we need to check both here.
 507                  */
 508                 if ((strncmp(opt_session_name, DEFAULT_SESSION_NAME "-",
 509                                 strlen(DEFAULT_SESSION_NAME) + 1) == 0) ||
 510                         (strncmp(opt_session_name, DEFAULT_SESSION_NAME,
 511                                 strlen(DEFAULT_SESSION_NAME)) == 0 &&
 512                         strlen(opt_session_name) == strlen(DEFAULT_SESSION_NAME))) {
 513                         ERR("%s is a reserved keyword for default session(s)",
 514                                         DEFAULT_SESSION_NAME);
 515
 516                         ret = CMD_ERROR;
 517                         goto error;
 518                 }
 519
 520                 base_session_name = strndup(opt_session_name, NAME_MAX);
 521                 if (!base_session_name) {
 522                         PERROR("Strdup session name");
 523                         ret = CMD_ERROR;
 524                         goto error;
 525                 }
 526
 527                 ret = asprintf(&session_name_date, "%s-%s", base_session_name, datetime);
 528                 if (ret < 0) {
 529                         PERROR("Asprintf session name");
 530                         goto error;
 531                 }
 532                 DBG("Session name from command option set to %s", base_session_name);
 533         } else if (base_session_name) {
 534                 ret = asprintf(&session_name_date, "%s-%s", base_session_name, datetime);
 535                 if (ret < 0) {
 536                         PERROR("Asprintf session name");
 537                         goto error;
 538                 }
 539         } else {
 540                 /* Generate a name */
 541                 ret = asprintf(&base_session_name, DEFAULT_SESSION_NAME "-%s", datetime);
 542                 if (ret < 0) {
 543                         PERROR("Asprintf session name");
 544                         goto error;
 545                 }
 546                 session_name_date = strdup(base_session_name);
 547                 DBG("Auto session name set to %s", base_session_name);
 548         }
 549
 550
 551         /*
 552          * Output handling
 553          */
 554
 555         /*
 556          * If any of those options are present clear all output related data.
 557          */
 558         if (opt_output_path || opt_url || (opt_ctrl_url && opt_data_url) || opt_no_output) {
 559                 /* Overwrite output */
 560                 free(base_url);
 561                 free(base_ctrl_url);
 562                 free(base_data_url);
 563                 base_url = NULL;
 564                 base_ctrl_url = NULL;
 565                 base_data_url = NULL;
 566         }
 567
 568         if (opt_output_path) {
 569
 570                 traces_path = utils_expand_path(opt_output_path);
 571                 if (!traces_path) {
 572                         ret = CMD_ERROR;
 573                         goto error;
 574                 }
 575
 576                 /* Create URL string from the local file system path */
 577                 ret = asprintf(&temp_url, "file://%s", traces_path);
 578                 if (ret < 0) {
 579                         PERROR("asprintf url path");
 580                         ret = CMD_FATAL;
 581                         goto error;
 582                 }
 583
 584                 base_url = temp_url;
 585         } else if (opt_url) { /* Handling URL (-U opt) */
 586                 base_url = strdup(opt_url);
 587         } else if (opt_data_url && opt_ctrl_url) {
 588                 /*
 589                  * With both control and data, we'll be setting the consumer URL
 590                  * after session creation thus use no URL.
 591                  */
 592                 base_ctrl_url = strdup(opt_ctrl_url);
 593                 base_data_url = strdup(opt_data_url);
 594         } else if (!(opt_no_output || base_output_type == OUTPUT_NONE ||
 595                                 base_url || base_ctrl_url || base_data_url)) {
 596                 /* Generate default output depending on the session type */
 597                 switch (base_session_type) {
 598                 case SESSION_NORMAL:
 599                         /* fallthrough */
 600                 case SESSION_SNAPSHOT:
 601                         /* Default to a local path */
 602                         tmp_home_path = utils_get_home_dir();
 603                         if (tmp_home_path == NULL) {
 604                                 ERR("HOME path not found.\n \
 605                                                 Please specify an output path using -o, --output PATH");
 606                                 ret = CMD_FATAL;
 607                                 goto error;
 608                         }
 609
 610                         ret = asprintf(&tmp_url,
 611                                         "file://%s/" DEFAULT_TRACE_DIR_NAME "/%s",
 612                                         tmp_home_path, session_name_date);
 613
 614                         if (ret < 0) {
 615                                 PERROR("asprintf trace dir name");
 616                                 ret = CMD_FATAL;
 617                                 goto error;
 618                         }
 619
 620                         base_url = tmp_url ;
 621                         break;
 622                 case SESSION_LIVE:
 623                         /* Default to a net output */
 624                         ret = asprintf(&tmp_url, "net://127.0.0.1");
 625                         if (ret < 0) {
 626                                 PERROR("asprintf default live URL");
 627                                 ret = CMD_FATAL;
 628                                 goto error;
 629                         }
 630                         base_url = tmp_url ;
 631                         break;
 632                 default:
 633                         ERR("Unknown session type");
 634                         ret = CMD_FATAL;
 635                         goto error;
 636                 }
 637         }
 638
 639          /*
 640           * Shared memory path handling
 641           */
 642         if (opt_shm_path) {
 643                 ret = asprintf(&base_shm_path, "%s/%s", opt_shm_path, session_name_date);
 644                 if (ret < 0) {
 645                         PERROR("asprintf shm_path");
 646                         goto error;
 647                 }
 648         }
 649
 650          /*
 651           * Live timer handling
 652           */
 653         if (opt_live_timer) {
 654                 base_live_timer = opt_live_timer;
 655         }
 656
 657         /* Get output type from urls */
 658         if (base_url) {
 659                 /* Get lttng uris from single url */
 660                 uri_array_size = uri_parse_str_urls(base_url, NULL, &uris);
 661                 if (uri_array_size < 0) {
 662                         ret = CMD_ERROR;
 663                         goto error;
 664                 }
 665         } else if (base_ctrl_url && base_data_url) {
 666                 uri_array_size = uri_parse_str_urls(base_ctrl_url, base_data_url, &uris);
 667                 if (uri_array_size < 0) {
 668                         ret = CMD_ERROR;
 669                         goto error;
 670                 }
 671         } else {
 672                 /* --no-output */
 673                 uri_array_size = 0;
 674         }
 675
 676         switch (uri_array_size) {
 677         case 0:
 678                 base_output_type = OUTPUT_NONE;
 679                 break;
 680         case 1:
 681                 base_output_type = OUTPUT_LOCAL;
 682                 break;
 683         case 2:
 684                 base_output_type = OUTPUT_NET;
 685                 break;
 686         default:
 687                 ret = CMD_ERROR;
 688                 goto error;
 689         }
 690
 691         ret = create_session_basic (base_session_name,
 692                         base_session_type,
 693                         base_live_timer,
 694                         base_output_type,
 695                         base_url,
 696                         base_ctrl_url,
 697                         base_data_url,
 698                         base_shm_path,
 699                         datetime);
 700         if (ret) {
 701                 goto error;
 702         }
 703
 704         ret = generate_output (base_session_name,
 705                         base_session_type,
 706                         base_live_timer,
 707                         base_output_type,
 708                         base_url,
 709                         base_ctrl_url,
 710                         base_data_url,
 711                         base_shm_path);
 712         if (ret) {
 713                 goto error;
 714         }
 715
 716         /* Init lttng session config */
 717         ret = config_init(base_session_name);
 718         if (ret < 0) {
 719                 ret = CMD_ERROR;
 720                 goto error;
 721         }
 722
 723         ret = CMD_SUCCESS;
 724
 725 error:
 726         /* Session temp stuff */
 727         free(session_name_date);
 728         free(uris);
 729
 730         if (ret < 0) {
 731                 ERR("%s", lttng_strerror(ret));
 732         }
 733
 734         free(base_session_name);
 735         free(base_url);
 736         free(base_ctrl_url);
 737         free(base_data_url);
 738         free(base_shm_path);
 739         return ret;
 740 }
 741
 742 /*
 743  *  spawn_sessiond
 744  *
 745  *  Spawn a session daemon by forking and execv.
 746  */
 747 static int spawn_sessiond(char *pathname)
 748 {
 749         int ret = 0;
 750         pid_t pid;
 751
 752         MSG("Spawning a session daemon");
 753         pid = fork();
 754         if (pid == 0) {
 755                 /*
 756                  * Spawn session daemon in daemon mode.
 757                  */
 758                 execlp(pathname, "lttng-sessiond",
 759                                 "--daemonize", NULL);
 760                 /* execlp only returns if error happened */
 761                 if (errno == ENOENT) {
 762                         ERR("No session daemon found. Use --sessiond-path.");
 763                 } else {
 764                         PERROR("execlp");
 765                 }
 766                 kill(getppid(), SIGTERM);       /* wake parent */
 767                 exit(EXIT_FAILURE);
 768         } else if (pid > 0) {
 769                 /*
 770                  * In daemon mode (--daemonize), sessiond only exits when
 771                  * it's ready to accept commands.
 772                  */
 773                 for (;;) {
 774                         int status;
 775                         pid_t wait_pid_ret = waitpid(pid, &status, 0);
 776
 777                         if (wait_pid_ret < 0) {
 778                                 if (errno == EINTR) {
 779                                         continue;
 780                                 }
 781                                 PERROR("waitpid");
 782                                 ret = -errno;
 783                                 goto end;
 784                         }
 785
 786                         if (WIFSIGNALED(status)) {
 787                                 ERR("Session daemon was killed by signal %d",
 788                                                 WTERMSIG(status));
 789                                 ret = -1;
 790                                 goto end;
 791                         } else if (WIFEXITED(status)) {
 792                                 DBG("Session daemon terminated normally (exit status: %d)",
 793                                                 WEXITSTATUS(status));
 794
 795                                 if (WEXITSTATUS(status) != 0) {
 796                                         ERR("Session daemon terminated with an error (exit status: %d)",
 797                                                         WEXITSTATUS(status));
 798                                         ret = -1;
 799                                         goto end;
 800                                 }
 801                                 break;
 802                         }
 803                 }
 804
 805                 goto end;
 806         } else {
 807                 PERROR("fork");
 808                 ret = -1;
 809                 goto end;
 810         }
 811
 812 end:
 813         return ret;
 814 }
 815
 816 /*
 817  *  launch_sessiond
 818  *
 819  *  Check if the session daemon is available using
 820  *  the liblttngctl API for the check. If not, try to
 821  *  spawn a daemon.
 822  */
 823 static int launch_sessiond(void)
 824 {
 825         int ret;
 826         char *pathname = NULL;
 827
 828         ret = lttng_session_daemon_alive();
 829         if (ret) {
 830                 /* Sessiond is alive, not an error */
 831                 ret = 0;
 832                 goto end;
 833         }
 834
 835         /* Try command line option path */
 836         pathname = opt_sessiond_path;
 837
 838         /* Try LTTNG_SESSIOND_PATH env variable */
 839         if (pathname == NULL) {
 840                 pathname = getenv(DEFAULT_SESSIOND_PATH_ENV);
 841         }
 842
 843         /* Try with configured path */
 844         if (pathname == NULL) {
 845                 if (CONFIG_SESSIOND_BIN[0] != '\0') {
 846                         pathname = CONFIG_SESSIOND_BIN;
 847                 }
 848         }
 849
 850         /* Try the default path */
 851         if (pathname == NULL) {
 852                 pathname = INSTALL_BIN_PATH "/lttng-sessiond";
 853         }
 854
 855         DBG("Session daemon binary path: %s", pathname);
 856
 857         /* Check existence and permissions */
 858         ret = access(pathname, F_OK | X_OK);
 859         if (ret < 0) {
 860                 ERR("No such file or access denied: %s", pathname);
 861                 goto end;
 862         }
 863
 864         ret = spawn_sessiond(pathname);
 865 end:
 866         if (ret) {
 867                 ERR("Problem occurred while launching session daemon (%s)",
 868                                 pathname);
 869         }
 870         return ret;
 871 }
 872
 873 /*
 874  *  The 'create <options>' first level command
 875  *
 876  *  Returns one of the CMD_* result constants.
 877  */
 878 int cmd_create(int argc, const char **argv)
 879 {
 880         int opt, ret = CMD_SUCCESS, command_ret = CMD_SUCCESS, success = 1;
 881         char *opt_arg = NULL;
 882         static poptContext pc;
 883
 884         pc = poptGetContext(NULL, argc, argv, long_options, 0);
 885         poptReadDefaultConfig(pc, 0);
 886
 887         while ((opt = poptGetNextOpt(pc)) != -1) {
 888                 switch (opt) {
 889                 case OPT_HELP:
 890                         SHOW_HELP();
 891                         goto end;
 892                 case OPT_LIST_OPTIONS:
 893                         list_cmd_options(stdout, long_options);
 894                         goto end;
 895                 case OPT_LIVE_TIMER:
 896                 {
 897                         unsigned long v;
 898
 899                         errno = 0;
 900                         opt_arg = poptGetOptArg(pc);
 901                         if (!opt_arg) {
 902                                 /* Set up default values. */
 903                                 opt_live_timer = (uint32_t) DEFAULT_LTTNG_LIVE_TIMER;
 904                                 DBG("Session live timer interval set to default value %d",
 905                                                 opt_live_timer);
 906                                 break;
 907                         }
 908
 909                         v = strtoul(opt_arg, NULL, 0);
 910                         if (errno != 0 || !isdigit(opt_arg[0])) {
 911                                 ERR("Wrong value in --live parameter: %s", opt_arg);
 912                                 ret = CMD_ERROR;
 913                                 goto end;
 914                         }
 915                         if (v != (uint32_t) v) {
 916                                 ERR("32-bit overflow in --live parameter: %s", opt_arg);
 917                                 ret = CMD_ERROR;
 918                                 goto end;
 919                         }
 920                         if (v == 0) {
 921                                 ERR("Live timer interval must be greater than zero");
 922                                 ret = CMD_ERROR;
 923                                 goto end;
 924                         }
 925                         opt_live_timer = (uint32_t) v;
 926                         DBG("Session live timer interval set to %d", opt_live_timer);
 927                         break;
 928                 }
 929                 default:
 930                         ret = CMD_UNDEFINED;
 931                         goto end;
 932                 }
 933         }
 934
 935         if (opt_no_consumer) {
 936                 MSG("The option --no-consumer is obsolete. Use --no-output now.");
 937                 ret = CMD_WARNING;
 938                 goto end;
 939         }
 940
 941         /* Spawn a session daemon if needed */
 942         if (!opt_no_sessiond) {
 943                 ret = launch_sessiond();
 944                 if (ret) {
 945                         ret = CMD_ERROR;
 946                         goto end;
 947                 }
 948         }
 949
 950         /* MI initialization */
 951         if (lttng_opt_mi) {
 952                 writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi);
 953                 if (!writer) {
 954                         ret = -LTTNG_ERR_NOMEM;
 955                         goto end;
 956                 }
 957
 958                 /* Open command element */
 959                 ret = mi_lttng_writer_command_open(writer,
 960                                 mi_lttng_element_command_create);
 961                 if (ret) {
 962                         ret = CMD_ERROR;
 963                         goto end;
 964                 }
 965
 966                 /* Open output element */
 967                 ret = mi_lttng_writer_open_element(writer,
 968                                 mi_lttng_element_command_output);
 969                 if (ret) {
 970                         ret = CMD_ERROR;
 971                         goto end;
 972                 }
 973         }
 974         opt_session_name = (char*) poptGetArg(pc);
 975
 976         command_ret = create_session();
 977
 978         if (command_ret) {
 979                 success = 0;
 980         }
 981
 982         if (lttng_opt_mi) {
 983                 /* Close  output element */
 984                 ret = mi_lttng_writer_close_element(writer);
 985                 if (ret) {
 986                         ret = CMD_ERROR;
 987                         goto end;
 988                 }
 989
 990                 /* Success ? */
 991                 ret = mi_lttng_writer_write_element_bool(writer,
 992                                 mi_lttng_element_command_success, success);
 993                 if (ret) {
 994                         ret = CMD_ERROR;
 995                         goto end;
 996                 }
 997
 998                 /* Command element close */
 999                 ret = mi_lttng_writer_command_close(writer);
1000                 if (ret) {
1001                         ret = CMD_ERROR;
1002                         goto end;
1003                 }
1004         }
1005
1006 end:
1007         /* Mi clean-up */
1008         if (writer && mi_lttng_writer_destroy(writer)) {
1009                 /* Preserve original error code */
1010                 ret = ret ? ret : -LTTNG_ERR_MI_IO_FAIL;
1011         }
1012
1013         /* Overwrite ret if an error occurred in create_session() */
1014         ret = command_ret ? command_ret : ret;
1015
1016         poptFreeContext(pc);
1017         return ret;
1018 }