src/bin/lttng/commands/create.c

   1 /*
   2  * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
   3  * Copyright (C) 2019 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License, version 2 only,
   7  * as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #define _LGPL_SOURCE
  20 #include <assert.h>
  21 #include <ctype.h>
  22 #include <popt.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <sys/stat.h>
  27 #include <sys/types.h>
  28 #include <common/compat/time.h>
  29 #include <unistd.h>
  30 #include <signal.h>
  31 #include <sys/wait.h>
  32
  33 #include <common/mi-lttng.h>
  34
  35 #include "../command.h"
  36 #include "../utils.h"
  37
  38 #include <common/defaults.h>
  39 #include <common/sessiond-comm/sessiond-comm.h>
  40 #include <common/uri.h>
  41 #include <common/utils.h>
  42 #include <lttng/snapshot.h>
  43 #include <lttng/session-descriptor.h>
  44
  45 static char *opt_output_path;
  46 static char *opt_session_name;
  47 static char *opt_url;
  48 static char *opt_ctrl_url;
  49 static char *opt_data_url;
  50 static char *opt_shm_path;
  51 static int opt_no_consumer;
  52 static int opt_no_output;
  53 static int opt_snapshot;
  54 static uint32_t opt_live_timer;
  55
  56 #ifdef LTTNG_EMBED_HELP
  57 static const char help_msg[] =
  58 #include <lttng-create.1.h>
  59 ;
  60 #endif
  61
  62 enum {
  63         OPT_HELP = 1,
  64         OPT_LIST_OPTIONS,
  65         OPT_LIVE_TIMER,
  66 };
  67
  68 enum output_type {
  69         OUTPUT_NONE,
  70         OUTPUT_LOCAL,
  71         OUTPUT_NETWORK,
  72         OUTPUT_UNSPECIFIED,
  73 };
  74
  75 static struct mi_writer *writer;
  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  * Retrieve the created session and mi output it based on provided argument
  94  * This is currently a summary of what was pretty printed and is subject to
  95  * enhancements.
  96  */
  97 static int mi_created_session(const char *session_name)
  98 {
  99         int ret, i, count, found;
 100         struct lttng_session *sessions;
 101
 102         /* session_name should not be null */
 103         assert(session_name);
 104         assert(writer);
 105
 106         count = lttng_list_sessions(&sessions);
 107         if (count < 0) {
 108                 ret = count;
 109                 ERR("%s", lttng_strerror(ret));
 110                 goto error;
 111         }
 112
 113         if (count == 0) {
 114                 ERR("Error session creation failed: session %s not found", session_name);
 115                 ret = -LTTNG_ERR_SESS_NOT_FOUND;
 116                 goto end;
 117         }
 118
 119         found = 0;
 120         for (i = 0; i < count; i++) {
 121                 if (strncmp(sessions[i].name, session_name, NAME_MAX) == 0) {
 122                         found = 1;
 123                         ret = mi_lttng_session(writer, &sessions[i], 0);
 124                         if (ret) {
 125                                 goto error;
 126                         }
 127                         break;
 128                 }
 129         }
 130
 131         if (!found) {
 132                 ret = -LTTNG_ERR_SESS_NOT_FOUND;
 133         } else {
 134                 ret = CMD_SUCCESS;
 135         }
 136
 137 error:
 138         free(sessions);
 139 end:
 140         return ret;
 141 }
 142
 143 static
 144 struct lttng_session_descriptor *create_session_descriptor(void)
 145 {
 146         int ret;
 147         ssize_t uri_count;
 148         enum output_type output_type;
 149         struct lttng_uri *uris = NULL;
 150         struct lttng_session_descriptor *descriptor = NULL;
 151         const char *uri_str1 = NULL, *uri_str2 = NULL;
 152         char local_output_path[LTTNG_PATH_MAX] = {};
 153
 154         if (opt_no_output) {
 155                 output_type = OUTPUT_NONE;
 156         } else if (opt_output_path) {
 157                 char *expanded_output_path;
 158
 159                 output_type = OUTPUT_LOCAL;
 160                 expanded_output_path = utils_expand_path(opt_output_path);
 161                 if (!expanded_output_path) {
 162                         ERR("Failed to expand output path.");
 163                         goto end;
 164                 }
 165                 ret = lttng_strncpy(local_output_path, expanded_output_path,
 166                                 sizeof(local_output_path));
 167                 free(expanded_output_path);
 168                 if (ret) {
 169                         ERR("Output path exceeds the maximal supported length (%zu bytes)",
 170                                         sizeof(local_output_path));
 171                         goto end;
 172                 }
 173         } else if (opt_url || opt_ctrl_url) {
 174                 uri_str1 = opt_ctrl_url ? opt_ctrl_url : opt_url;
 175                 uri_str2 = opt_data_url;
 176
 177                 uri_count = uri_parse_str_urls(uri_str1, uri_str2, &uris);
 178                 if (uri_count != 1 && uri_count != 2) {
 179                         ERR("Unrecognized URL format.");
 180                         goto end;
 181                 }
 182
 183                 switch (uri_count) {
 184                 case 1:
 185                         output_type = OUTPUT_LOCAL;
 186                         if (uris[0].dtype != LTTNG_DST_PATH) {
 187                                 ERR("Unrecognized URL format.");
 188                                 goto end;
 189                         }
 190                         ret = lttng_strncpy(local_output_path, uris[0].dst.path,
 191                                         sizeof(local_output_path));
 192                         if (ret) {
 193                                 ERR("Output path exceeds the maximal supported length (%zu bytes)",
 194                                                 sizeof(local_output_path));
 195                         }
 196                         break;
 197                 case 2:
 198                         output_type = OUTPUT_NETWORK;
 199                         break;
 200                 default:
 201                         /* Already checked. */
 202                         abort();
 203                 }
 204         } else {
 205                 output_type = OUTPUT_UNSPECIFIED;
 206         }
 207
 208         if (opt_snapshot) {
 209                 /* Snapshot session. */
 210                 switch (output_type) {
 211                 case OUTPUT_UNSPECIFIED:
 212                 case OUTPUT_LOCAL:
 213                         descriptor = lttng_session_descriptor_snapshot_local_create(
 214                                         opt_session_name,
 215                                         output_type == OUTPUT_LOCAL ?
 216                                                 local_output_path : NULL);
 217                         break;
 218                 case OUTPUT_NONE:
 219                         descriptor = lttng_session_descriptor_snapshot_create(
 220                                         opt_session_name);
 221                         break;
 222                 case OUTPUT_NETWORK:
 223                         descriptor = lttng_session_descriptor_snapshot_network_create(
 224                                         opt_session_name, uri_str1, uri_str2);
 225                         break;
 226                 default:
 227                         abort();
 228                 }
 229         } else if (opt_live_timer) {
 230                 /* Live session. */
 231                 if (output_type != OUTPUT_UNSPECIFIED &&
 232                                 output_type != OUTPUT_NETWORK) {
 233                         ERR("Unsupported output type specified for live session.");
 234                         goto end;
 235                 }
 236                 descriptor = lttng_session_descriptor_live_network_create(
 237                                 opt_session_name, uri_str1, uri_str2,
 238                                 opt_live_timer);
 239
 240         } else {
 241                 /* Regular session. */
 242                 switch (output_type) {
 243                 case OUTPUT_UNSPECIFIED:
 244                 case OUTPUT_LOCAL:
 245                         descriptor = lttng_session_descriptor_local_create(
 246                                         opt_session_name,
 247                                         output_type == OUTPUT_LOCAL ?
 248                                                 local_output_path : NULL);
 249                         break;
 250                 case OUTPUT_NONE:
 251                         descriptor = lttng_session_descriptor_create(
 252                                         opt_session_name);
 253                         break;
 254                 case OUTPUT_NETWORK:
 255                         descriptor = lttng_session_descriptor_network_create(
 256                                         opt_session_name, uri_str1, uri_str2);
 257                         break;
 258                 default:
 259                         abort();
 260                 }
 261         }
 262         if (!descriptor) {
 263                 ERR("Failed to initialize session creation command.");
 264         }
 265 end:
 266         free(uris);
 267         return descriptor;
 268 }
 269
 270 /*
 271  *  Create a tracing session.
 272  *  If no name is specified, a default name is generated.
 273  *
 274  *  Returns one of the CMD_* result constants.
 275  */
 276 static int create_session(void)
 277 {
 278         int ret, i;
 279         char shm_path[LTTNG_PATH_MAX] = {};
 280         struct lttng_session_descriptor *session_descriptor = NULL;
 281         enum lttng_session_descriptor_status descriptor_status;
 282         enum lttng_error_code ret_code;
 283         struct lttng_session *sessions = NULL;
 284         const struct lttng_session *created_session = NULL;
 285         const char *created_session_name;
 286
 287         /* Validate options. */
 288         if (opt_session_name) {
 289                 if (strlen(opt_session_name) > NAME_MAX) {
 290                         ERR("Session name too long. Length must be lower or equal to %d",
 291                                         NAME_MAX);
 292                         ret = CMD_ERROR;
 293                         goto error;
 294                 }
 295                 /*
 296                  * Check if the session name begins with "auto-" or is exactly "auto".
 297                  * Both are reserved for the default session name. See bug #449 to
 298                  * understand why we need to check both here.
 299                  */
 300                 if ((strncmp(opt_session_name, DEFAULT_SESSION_NAME "-",
 301                                         strlen(DEFAULT_SESSION_NAME) + 1) == 0) ||
 302                                 (strncmp(opt_session_name, DEFAULT_SESSION_NAME,
 303                                         strlen(DEFAULT_SESSION_NAME)) == 0 &&
 304                                 strlen(opt_session_name) == strlen(DEFAULT_SESSION_NAME))) {
 305                         ERR("%s is a reserved keyword for default session(s)",
 306                                         DEFAULT_SESSION_NAME);
 307                         ret = CMD_ERROR;
 308                         goto error;
 309                 }
 310         }
 311
 312         if (opt_snapshot && opt_live_timer) {
 313                 ERR("Snapshot and live modes are mutually exclusive.");
 314                 ret = CMD_ERROR;
 315                 goto error;
 316         }
 317
 318         if ((!opt_ctrl_url && opt_data_url) || (opt_ctrl_url && !opt_data_url)) {
 319                 ERR("Both control and data URLs must be specified.");
 320                 ret = CMD_ERROR;
 321                 goto error;
 322         }
 323
 324         session_descriptor = create_session_descriptor();
 325         if (!session_descriptor) {
 326                 ret = CMD_ERROR;
 327                 goto error;
 328         }
 329         ret_code = lttng_create_session_ext(session_descriptor);
 330         if (ret_code != LTTNG_OK) {
 331                 ERR("%s", lttng_strerror(-ret_code));
 332                 ret = CMD_ERROR;
 333                 goto error;
 334         }
 335
 336         descriptor_status = lttng_session_descriptor_get_session_name(
 337                 session_descriptor, &created_session_name);
 338         if (descriptor_status != LTTNG_SESSION_DESCRIPTOR_STATUS_OK) {
 339                 ERR("Failed to obtain created session name");
 340                 ret = CMD_ERROR;
 341                 goto error;
 342         }
 343
 344         ret = lttng_list_sessions(&sessions);
 345         if (ret < 0) {
 346                 ERR("Failed to fetch properties of created session: %s",
 347                                 lttng_strerror(ret));
 348                 ret = CMD_ERROR;
 349                 goto error;
 350         }
 351         for (i = 0; i < ret; i++) {
 352                 if (!strcmp(created_session_name, sessions[i].name)) {
 353                         created_session = &sessions[i];
 354                         break;
 355                 }
 356         }
 357         if (!created_session) {
 358                 ERR("Failed to fetch properties of created session");
 359                 ret = CMD_ERROR;
 360                 goto error;
 361         }
 362
 363         if (opt_shm_path) {
 364                 char datetime_suffix[17] = {};
 365
 366                 /*
 367                  * An auto-generated session name already includes the creation
 368                  * timestamp.
 369                  */
 370                 if (opt_session_name) {
 371                         uint64_t creation_time;
 372                         struct tm *timeinfo;
 373                         time_t creation_time_t;
 374                         size_t strftime_ret;
 375
 376                         ret_code = lttng_session_get_creation_time(
 377                                         created_session,
 378                                         &creation_time);
 379                         if (ret_code != LTTNG_OK) {
 380                                 ERR("%s", lttng_strerror(-ret_code));
 381                                 ret = CMD_ERROR;
 382                                 goto error;
 383                         }
 384                         creation_time_t = (time_t) creation_time;
 385                         timeinfo = localtime(&creation_time_t);
 386                         if (!timeinfo) {
 387                                 PERROR("Failed to interpret session creation time");
 388                                 ret = CMD_ERROR;
 389                                 goto error;
 390                         }
 391                         strftime_ret = strftime(datetime_suffix,
 392                                         sizeof(datetime_suffix),
 393                                         "-%Y%m%d-%H%M%S", timeinfo);
 394                         if (strftime_ret == 0) {
 395                                 ERR("Failed to format session creation time.");
 396                                 ret = CMD_ERROR;
 397                                 goto error;
 398                         }
 399                 }
 400
 401                 ret = snprintf(shm_path, sizeof(shm_path),
 402                                 "%s/%s%s", opt_shm_path, created_session_name,
 403                                 datetime_suffix);
 404                 if (ret < 0 || ret >= sizeof(shm_path)) {
 405                         ERR("Failed to format the shared memory path.");
 406                         ret = CMD_ERROR;
 407                         goto error;
 408                 }
 409                 ret = lttng_set_session_shm_path(created_session_name,
 410                                 shm_path);
 411                 if (ret < 0) {
 412                         lttng_destroy_session(created_session_name);
 413                         ret = CMD_ERROR;
 414                         goto error;
 415                 }
 416         }
 417
 418         if (opt_snapshot) {
 419                 MSG("Snapshot session %s created.", created_session_name);
 420         } else if (opt_live_timer) {
 421                 MSG("Live session %s created.", created_session_name);
 422         } else {
 423                 MSG("Session %s created.", created_session_name);
 424         }
 425
 426         if (*created_session->path && !opt_snapshot) {
 427                 MSG("Traces will be output to %s", created_session->path);
 428
 429                 if (opt_live_timer) {
 430                         MSG("Live timer interval set to %u %s", opt_live_timer,
 431                                         USEC_UNIT);
 432                 }
 433         } else if (opt_snapshot) {
 434                 struct lttng_snapshot_output_list *list;
 435                 struct lttng_snapshot_output *iter;
 436                 char snapshot_url[LTTNG_PATH_MAX] = {};
 437
 438                 ret = lttng_snapshot_list_output(created_session_name, &list);
 439                 if (ret < 0) {
 440                         ERR("Failed to list snapshot outputs.");
 441                         ret = CMD_ERROR;
 442                         goto error;
 443                 }
 444
 445                 while ((iter = lttng_snapshot_output_list_get_next(list))) {
 446                         const char *url = NULL;
 447
 448                         url = lttng_snapshot_output_get_ctrl_url(
 449                                         iter);
 450                         ret = lttng_strncpy(snapshot_url, url,
 451                                         sizeof(snapshot_url));
 452                         if (ret) {
 453                                 snapshot_url[0] = '\0';
 454                                 ERR("Failed to retrieve snapshot output destination");
 455                         }
 456                         break;
 457                 }
 458                 lttng_snapshot_output_list_destroy(list);
 459
 460                 if (*snapshot_url) {
 461                         MSG("Default snapshot output set to %s",
 462                                         snapshot_url);
 463                 }
 464                 MSG("Every channel enabled for this session will be set to mmap output and default to overwrite mode.");
 465         }
 466         if (opt_shm_path) {
 467                 MSG("Shared memory path set to %s", shm_path);
 468         }
 469
 470         /* Mi output */
 471         if (lttng_opt_mi) {
 472                 ret = mi_created_session(created_session_name);
 473                 if (ret) {
 474                         ret = CMD_ERROR;
 475                         goto error;
 476                 }
 477         }
 478
 479         /* Init lttng session config */
 480         ret = config_init(created_session_name);
 481         if (ret < 0) {
 482                 ret = CMD_ERROR;
 483                 goto error;
 484         }
 485
 486         ret = CMD_SUCCESS;
 487 error:
 488         lttng_session_descriptor_destroy(session_descriptor);
 489         free(sessions);
 490         return ret;
 491 }
 492
 493 /*
 494  *  spawn_sessiond
 495  *
 496  *  Spawn a session daemon by forking and execv.
 497  */
 498 static int spawn_sessiond(char *pathname)
 499 {
 500         int ret = 0;
 501         pid_t pid;
 502
 503         MSG("Spawning a session daemon");
 504         pid = fork();
 505         if (pid == 0) {
 506                 /*
 507                  * Spawn session daemon in daemon mode.
 508                  */
 509                 execlp(pathname, "lttng-sessiond",
 510                                 "--daemonize", NULL);
 511                 /* execlp only returns if error happened */
 512                 if (errno == ENOENT) {
 513                         ERR("No session daemon found. Use --sessiond-path.");
 514                 } else {
 515                         PERROR("execlp");
 516                 }
 517                 kill(getppid(), SIGTERM);       /* wake parent */
 518                 exit(EXIT_FAILURE);
 519         } else if (pid > 0) {
 520                 /*
 521                  * In daemon mode (--daemonize), sessiond only exits when
 522                  * it's ready to accept commands.
 523                  */
 524                 for (;;) {
 525                         int status;
 526                         pid_t wait_pid_ret = waitpid(pid, &status, 0);
 527
 528                         if (wait_pid_ret < 0) {
 529                                 if (errno == EINTR) {
 530                                         continue;
 531                                 }
 532                                 PERROR("waitpid");
 533                                 ret = -errno;
 534                                 goto end;
 535                         }
 536
 537                         if (WIFSIGNALED(status)) {
 538                                 ERR("Session daemon was killed by signal %d",
 539                                                 WTERMSIG(status));
 540                                 ret = -1;
 541                                 goto end;
 542                         } else if (WIFEXITED(status)) {
 543                                 DBG("Session daemon terminated normally (exit status: %d)",
 544                                                 WEXITSTATUS(status));
 545
 546                                 if (WEXITSTATUS(status) != 0) {
 547                                         ERR("Session daemon terminated with an error (exit status: %d)",
 548                                                         WEXITSTATUS(status));
 549                                         ret = -1;
 550                                         goto end;
 551                                 }
 552                                 break;
 553                         }
 554                 }
 555
 556                 goto end;
 557         } else {
 558                 PERROR("fork");
 559                 ret = -1;
 560                 goto end;
 561         }
 562
 563 end:
 564         return ret;
 565 }
 566
 567 /*
 568  *  launch_sessiond
 569  *
 570  *  Check if the session daemon is available using
 571  *  the liblttngctl API for the check. If not, try to
 572  *  spawn a daemon.
 573  */
 574 static int launch_sessiond(void)
 575 {
 576         int ret;
 577         char *pathname = NULL;
 578
 579         ret = lttng_session_daemon_alive();
 580         if (ret) {
 581                 /* Sessiond is alive, not an error */
 582                 ret = 0;
 583                 goto end;
 584         }
 585
 586         /* Try command line option path */
 587         pathname = opt_sessiond_path;
 588
 589         /* Try LTTNG_SESSIOND_PATH env variable */
 590         if (pathname == NULL) {
 591                 pathname = getenv(DEFAULT_SESSIOND_PATH_ENV);
 592         }
 593
 594         /* Try with configured path */
 595         if (pathname == NULL) {
 596                 if (CONFIG_SESSIOND_BIN[0] != '\0') {
 597                         pathname = CONFIG_SESSIOND_BIN;
 598                 }
 599         }
 600
 601         /* Try the default path */
 602         if (pathname == NULL) {
 603                 pathname = INSTALL_BIN_PATH "/lttng-sessiond";
 604         }
 605
 606         DBG("Session daemon binary path: %s", pathname);
 607
 608         /* Check existence and permissions */
 609         ret = access(pathname, F_OK | X_OK);
 610         if (ret < 0) {
 611                 ERR("No such file or access denied: %s", pathname);
 612                 goto end;
 613         }
 614
 615         ret = spawn_sessiond(pathname);
 616 end:
 617         if (ret) {
 618                 ERR("Problem occurred while launching session daemon (%s)",
 619                                 pathname);
 620         }
 621         return ret;
 622 }
 623
 624 int validate_url_option_combination(void)
 625 {
 626         int ret = 0;
 627         int used_count = 0;
 628
 629         used_count += !!opt_url;
 630         used_count += !!opt_output_path;
 631         used_count += (opt_data_url || opt_ctrl_url);
 632         if (used_count > 1) {
 633                 ERR("Only one of the --set-url, --ctrl-url/data-url, or --output options may be used at once.");
 634                 ret = -1;
 635         }
 636
 637         return ret;
 638 }
 639
 640 /*
 641  *  The 'create <options>' first level command
 642  *
 643  *  Returns one of the CMD_* result constants.
 644  */
 645 int cmd_create(int argc, const char **argv)
 646 {
 647         int opt, ret = CMD_SUCCESS, command_ret = CMD_SUCCESS, success = 1;
 648         char *opt_arg = NULL;
 649         const char *leftover = NULL;
 650         static poptContext pc;
 651
 652         pc = poptGetContext(NULL, argc, argv, long_options, 0);
 653         poptReadDefaultConfig(pc, 0);
 654
 655         while ((opt = poptGetNextOpt(pc)) != -1) {
 656                 switch (opt) {
 657                 case OPT_HELP:
 658                         SHOW_HELP();
 659                         goto end;
 660                 case OPT_LIST_OPTIONS:
 661                         list_cmd_options(stdout, long_options);
 662                         goto end;
 663                 case OPT_LIVE_TIMER:
 664                 {
 665                         uint64_t v;
 666
 667                         errno = 0;
 668                         opt_arg = poptGetOptArg(pc);
 669                         if (!opt_arg) {
 670                                 /* Set up default values. */
 671                                 opt_live_timer = (uint32_t) DEFAULT_LTTNG_LIVE_TIMER;
 672                                 DBG("Session live timer interval set to default value %d",
 673                                                 opt_live_timer);
 674                                 break;
 675                         }
 676
 677                         if (utils_parse_time_suffix(opt_arg, &v) < 0) {
 678                                 ERR("Wrong value for --live parameter: %s", opt_arg);
 679                                 ret = CMD_ERROR;
 680                                 goto end;
 681                         }
 682
 683                         if (v != (uint32_t) v) {
 684                                 ERR("32-bit overflow in --live parameter: %s", opt_arg);
 685                                 ret = CMD_ERROR;
 686                                 goto end;
 687                         }
 688
 689                         if (v == 0) {
 690                                 ERR("Live timer interval must be greater than zero");
 691                                 ret = CMD_ERROR;
 692                                 goto end;
 693                         }
 694
 695                         opt_live_timer = (uint32_t) v;
 696                         DBG("Session live timer interval set to %d", opt_live_timer);
 697                         break;
 698                 }
 699                 default:
 700                         ret = CMD_UNDEFINED;
 701                         goto end;
 702                 }
 703         }
 704
 705         if (opt_no_consumer) {
 706                 MSG("The option --no-consumer is obsolete. Use --no-output now.");
 707                 ret = CMD_WARNING;
 708                 goto end;
 709         }
 710
 711         ret = validate_url_option_combination();
 712         if (ret) {
 713                 ret = CMD_ERROR;
 714                 goto end;
 715         }
 716
 717         /* Spawn a session daemon if needed */
 718         if (!opt_no_sessiond) {
 719                 ret = launch_sessiond();
 720                 if (ret) {
 721                         ret = CMD_ERROR;
 722                         goto end;
 723                 }
 724         }
 725
 726         /* MI initialization */
 727         if (lttng_opt_mi) {
 728                 writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi);
 729                 if (!writer) {
 730                         ret = -LTTNG_ERR_NOMEM;
 731                         goto end;
 732                 }
 733
 734                 /* Open command element */
 735                 ret = mi_lttng_writer_command_open(writer,
 736                                 mi_lttng_element_command_create);
 737                 if (ret) {
 738                         ret = CMD_ERROR;
 739                         goto end;
 740                 }
 741
 742                 /* Open output element */
 743                 ret = mi_lttng_writer_open_element(writer,
 744                                 mi_lttng_element_command_output);
 745                 if (ret) {
 746                         ret = CMD_ERROR;
 747                         goto end;
 748                 }
 749         }
 750         opt_session_name = (char*) poptGetArg(pc);
 751
 752         leftover = poptGetArg(pc);
 753         if (leftover) {
 754                 ERR("Unknown argument: %s", leftover);
 755                 ret = CMD_ERROR;
 756                 goto end;
 757         }
 758
 759         command_ret = create_session();
 760         if (command_ret) {
 761                 success = 0;
 762         }
 763
 764         if (lttng_opt_mi) {
 765                 /* Close  output element */
 766                 ret = mi_lttng_writer_close_element(writer);
 767                 if (ret) {
 768                         ret = CMD_ERROR;
 769                         goto end;
 770                 }
 771
 772                 /* Success ? */
 773                 ret = mi_lttng_writer_write_element_bool(writer,
 774                                 mi_lttng_element_command_success, success);
 775                 if (ret) {
 776                         ret = CMD_ERROR;
 777                         goto end;
 778                 }
 779
 780                 /* Command element close */
 781                 ret = mi_lttng_writer_command_close(writer);
 782                 if (ret) {
 783                         ret = CMD_ERROR;
 784                         goto end;
 785                 }
 786         }
 787
 788 end:
 789         /* Mi clean-up */
 790         if (writer && mi_lttng_writer_destroy(writer)) {
 791                 /* Preserve original error code */
 792                 ret = ret ? ret : -LTTNG_ERR_MI_IO_FAIL;
 793         }
 794
 795         /* Overwrite ret if an error occurred in create_session() */
 796         ret = command_ret ? command_ret : ret;
 797
 798         poptFreeContext(pc);
 799         return ret;
 800 }