src/bin/lttng/commands/snapshot.c

   1 /*
   2  * Copyright (C) 2013 David Goulet <dgoulet@efficios.com>
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #define _LGPL_SOURCE
   9 #include <assert.h>
  10 #include <inttypes.h>
  11 #include <popt.h>
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <sys/stat.h>
  16 #include <sys/types.h>
  17 #include <unistd.h>
  18 #include <assert.h>
  19
  20 #include <common/utils.h>
  21 #include <common/mi-lttng.h>
  22 #include <lttng/snapshot.h>
  23
  24 #include "../command.h"
  25
  26 static const char *opt_session_name;
  27 static const char *opt_output_name;
  28 static const char *opt_data_url;
  29 static const char *opt_ctrl_url;
  30 static const char *current_session_name;
  31 static uint64_t opt_max_size;
  32
  33 /* Stub for the cmd struct actions. */
  34 static int cmd_add_output(int argc, const char **argv);
  35 static int cmd_del_output(int argc, const char **argv);
  36 static int cmd_list_output(int argc, const char **argv);
  37 static int cmd_record(int argc, const char **argv);
  38
  39 static const char *indent4 = "    ";
  40
  41 #ifdef LTTNG_EMBED_HELP
  42 static const char help_msg[] =
  43 #include <lttng-snapshot.1.h>
  44 ;
  45 #endif
  46
  47 enum {
  48         OPT_HELP = 1,
  49         OPT_LIST_OPTIONS,
  50         OPT_MAX_SIZE,
  51         OPT_LIST_COMMANDS,
  52 };
  53
  54 static struct mi_writer *writer;
  55
  56 static struct poptOption snapshot_opts[] = {
  57         /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
  58         {"help",      'h', POPT_ARG_NONE, 0, OPT_HELP, 0, 0},
  59         {"session",      's', POPT_ARG_STRING, &opt_session_name, 0, 0, 0},
  60         {"ctrl-url",     'C', POPT_ARG_STRING, &opt_ctrl_url, 0, 0, 0},
  61         {"data-url",     'D', POPT_ARG_STRING, &opt_data_url, 0, 0, 0},
  62         {"name",         'n', POPT_ARG_STRING, &opt_output_name, 0, 0, 0},
  63         {"max-size",     'm', POPT_ARG_STRING, 0, OPT_MAX_SIZE, 0, 0},
  64         {"list-options",   0, POPT_ARG_NONE, NULL, OPT_LIST_OPTIONS, NULL, NULL},
  65         {"list-commands",  0, POPT_ARG_NONE, NULL, OPT_LIST_COMMANDS},
  66         {0, 0, 0, 0, 0, 0, 0}
  67 };
  68
  69 static struct cmd_struct actions[] = {
  70         { "add-output", cmd_add_output },
  71         { "del-output", cmd_del_output },
  72         { "list-output", cmd_list_output },
  73         { "record", cmd_record },
  74         { NULL, NULL }  /* Array closure */
  75 };
  76
  77 /*
  78  * Count and return the number of arguments in argv.
  79  */
  80 static int count_arguments(const char **argv)
  81 {
  82         int i = 0;
  83
  84         assert(argv);
  85
  86         while (argv[i] != NULL) {
  87                 i++;
  88         }
  89
  90         return i;
  91 }
  92
  93 /*
  94  * Create a snapshot output object from arguments using the given URL.
  95  *
  96  * Return a newly allocated object or NULL on error.
  97  */
  98 static struct lttng_snapshot_output *create_output_from_args(const char *url)
  99 {
 100         int ret = 0;
 101         struct lttng_snapshot_output *output = NULL;
 102
 103         output = lttng_snapshot_output_create();
 104         if (!output) {
 105                 goto error_create;
 106         }
 107
 108         if (url) {
 109                 ret = lttng_snapshot_output_set_ctrl_url(url, output);
 110                 if (ret < 0) {
 111                         goto error;
 112                 }
 113         } else if (opt_ctrl_url) {
 114                 ret = lttng_snapshot_output_set_ctrl_url(opt_ctrl_url, output);
 115                 if (ret < 0) {
 116                         goto error;
 117                 }
 118         }
 119
 120         if (opt_data_url) {
 121                 ret = lttng_snapshot_output_set_data_url(opt_data_url, output);
 122                 if (ret < 0) {
 123                         goto error;
 124                 }
 125         }
 126
 127         if (opt_max_size) {
 128                 ret = lttng_snapshot_output_set_size(opt_max_size, output);
 129                 if (ret < 0) {
 130                         goto error;
 131                 }
 132         }
 133
 134         if (opt_output_name) {
 135                 ret = lttng_snapshot_output_set_name(opt_output_name, output);
 136                 if (ret < 0) {
 137                         goto error;
 138                 }
 139         }
 140
 141         return output;
 142
 143 error:
 144         lttng_snapshot_output_destroy(output);
 145 error_create:
 146         return NULL;
 147 }
 148
 149 static int list_output(void)
 150 {
 151         int ret, output_seen = 0;
 152         struct lttng_snapshot_output *s_iter;
 153         struct lttng_snapshot_output_list *list;
 154
 155         ret = lttng_snapshot_list_output(current_session_name, &list);
 156         if (ret < 0) {
 157                 goto error;
 158         }
 159
 160         MSG("Snapshot output list for session %s", current_session_name);
 161
 162         if (lttng_opt_mi) {
 163                 ret = mi_lttng_snapshot_output_session_name(writer,
 164                                 current_session_name);
 165                 if (ret) {
 166                         ret = CMD_ERROR;
 167                         goto end;
 168                 }
 169         }
 170
 171         while ((s_iter = lttng_snapshot_output_list_get_next(list)) != NULL) {
 172                 if (lttng_snapshot_output_get_maxsize(s_iter)) {
 173                         MSG("%s[%" PRIu32 "] %s: %s (max size: %" PRIu64 " bytes)", indent4,
 174                                         lttng_snapshot_output_get_id(s_iter),
 175                                         lttng_snapshot_output_get_name(s_iter),
 176                                         lttng_snapshot_output_get_ctrl_url(s_iter),
 177                                         lttng_snapshot_output_get_maxsize(s_iter));
 178                 } else {
 179                         MSG("%s[%" PRIu32 "] %s: %s", indent4,
 180                                         lttng_snapshot_output_get_id(s_iter),
 181                                         lttng_snapshot_output_get_name(s_iter),
 182                                         lttng_snapshot_output_get_ctrl_url(s_iter));
 183                 }
 184                 output_seen = 1;
 185                 if (lttng_opt_mi) {
 186                         ret = mi_lttng_snapshot_list_output(writer, s_iter);
 187                         if (ret) {
 188                                 ret = CMD_ERROR;
 189                                 goto end;
 190                         }
 191                 }
 192         }
 193
 194         if (lttng_opt_mi) {
 195                 /* Close snapshot snapshots element */
 196                 ret = mi_lttng_writer_close_element(writer);
 197                 if (ret) {
 198                         ret = CMD_ERROR;
 199                         goto end;
 200                 }
 201
 202                 /* Close snapshot session element */
 203                 ret = mi_lttng_writer_close_element(writer);
 204                 if (ret) {
 205                         ret = CMD_ERROR;
 206                 }
 207         }
 208 end:
 209         lttng_snapshot_output_list_destroy(list);
 210
 211         if (!output_seen) {
 212                 MSG("%sNone", indent4);
 213         }
 214
 215 error:
 216         return ret;
 217 }
 218
 219 /*
 220  * Delete output by ID.
 221  */
 222 static int del_output(uint32_t id, const char *name)
 223 {
 224         int ret;
 225         struct lttng_snapshot_output *output = NULL;
 226
 227         output = lttng_snapshot_output_create();
 228         if (!output) {
 229                 ret = CMD_FATAL;
 230                 goto error;
 231         }
 232
 233         if (name) {
 234                 ret = lttng_snapshot_output_set_name(name, output);
 235         } else if (id != UINT32_MAX) {
 236                 ret = lttng_snapshot_output_set_id(id, output);
 237         } else {
 238                 ret = CMD_ERROR;
 239                 goto error;
 240         }
 241         if (ret < 0) {
 242                 ret = CMD_FATAL;
 243                 goto error;
 244         }
 245
 246         ret = lttng_snapshot_del_output(current_session_name, output);
 247         if (ret < 0) {
 248                 goto error;
 249         }
 250
 251         if (id != UINT32_MAX) {
 252                 MSG("Snapshot output id %" PRIu32 " successfully deleted for session %s",
 253                                 id, current_session_name);
 254         } else {
 255                 MSG("Snapshot output %s successfully deleted for session %s",
 256                                 name, current_session_name);
 257         }
 258
 259         if (lttng_opt_mi) {
 260                 ret = mi_lttng_snapshot_del_output(writer, id, name,
 261                                 current_session_name);
 262                 if (ret) {
 263                         ret = CMD_ERROR;
 264                 }
 265         }
 266
 267 error:
 268         lttng_snapshot_output_destroy(output);
 269         return ret;
 270 }
 271
 272 /*
 273  * Add output from the user URL.
 274  */
 275 static int add_output(const char *url)
 276 {
 277         int ret;
 278         struct lttng_snapshot_output *output = NULL;
 279         char name[NAME_MAX];
 280         const char *n_ptr;
 281
 282         if (!url && (!opt_data_url || !opt_ctrl_url)) {
 283                 ret = CMD_ERROR;
 284                 goto error;
 285         }
 286
 287         output = create_output_from_args(url);
 288         if (!output) {
 289                 ret = CMD_FATAL;
 290                 goto error;
 291         }
 292
 293         /* This call, if successful, populates the id of the output object. */
 294         ret = lttng_snapshot_add_output(current_session_name, output);
 295         if (ret < 0) {
 296                 goto error;
 297         }
 298
 299         n_ptr = lttng_snapshot_output_get_name(output);
 300         if (*n_ptr == '\0') {
 301                 int pret;
 302                 pret = snprintf(name, sizeof(name), DEFAULT_SNAPSHOT_NAME "-%" PRIu32,
 303                                 lttng_snapshot_output_get_id(output));
 304                 if (pret < 0) {
 305                         PERROR("snprintf add output name");
 306                 }
 307                 n_ptr = name;
 308         }
 309
 310         MSG("Snapshot output successfully added for session %s",
 311                         current_session_name);
 312         if (opt_max_size) {
 313                 MSG("  [%" PRIu32 "] %s: %s (max size: %" PRIu64 " bytes)",
 314                                 lttng_snapshot_output_get_id(output), n_ptr,
 315                                 lttng_snapshot_output_get_ctrl_url(output),
 316                                 lttng_snapshot_output_get_maxsize(output));
 317         } else {
 318                 MSG("  [%" PRIu32 "] %s: %s",
 319                                 lttng_snapshot_output_get_id(output), n_ptr,
 320                                 lttng_snapshot_output_get_ctrl_url(output));
 321         }
 322         if (lttng_opt_mi) {
 323                 ret = mi_lttng_snapshot_add_output(writer, current_session_name,
 324                                 n_ptr, output);
 325                 if (ret) {
 326                         ret = CMD_ERROR;
 327                 }
 328         }
 329 error:
 330         lttng_snapshot_output_destroy(output);
 331         return ret;
 332 }
 333
 334 static int cmd_add_output(int argc, const char **argv)
 335 {
 336         int ret;
 337
 338         if (argc < 2 && (!opt_data_url || !opt_ctrl_url)) {
 339                 ERR("An output destination must be specified to add a snapshot output.");
 340                 ret = CMD_ERROR;
 341                 goto end;
 342         }
 343
 344         ret = add_output(argv[1]);
 345         if (ret < 0) {
 346                 switch (-ret) {
 347                 case LTTNG_ERR_SNAPSHOT_UNSUPPORTED:
 348                         ERR("Session \"%s\" contains a channel that is incompatible with the snapshot functionality.\nMake sure all channels are configured in 'mmap' output mode.",
 349                                         current_session_name);
 350                         ret = CMD_ERROR;
 351                         break;
 352                 default:
 353                         break;
 354                 }
 355         }
 356
 357 end:
 358         return ret;
 359 }
 360
 361 static int cmd_del_output(int argc, const char **argv)
 362 {
 363         int ret;
 364         char *name;
 365         long id;
 366
 367         if (argc < 2) {
 368                 ERR("A snapshot output name or id must be provided to delete a snapshot output.");
 369                 ret = CMD_ERROR;
 370                 goto end;
 371         }
 372
 373         errno = 0;
 374         id = strtol(argv[1], &name, 10);
 375         if (id == 0 && (errno == 0 || errno == EINVAL)) {
 376                 ret = del_output(UINT32_MAX, name);
 377         } else if (errno == 0 && *name == '\0') {
 378                 ret = del_output(id, NULL);
 379         } else {
 380                 ERR("Argument %s not recognized", argv[1]);
 381                 ret = -1;
 382                 goto end;
 383         }
 384
 385 end:
 386         return ret;
 387 }
 388
 389 static int cmd_list_output(int argc, const char **argv)
 390 {
 391         int ret;
 392
 393         ret = list_output();
 394
 395         return ret;
 396 }
 397
 398 /*
 399  * Do a snapshot record with the URL if one is given.
 400  */
 401 static int record(const char *url)
 402 {
 403         int ret;
 404         struct lttng_snapshot_output *output = NULL;
 405
 406         output = create_output_from_args(url);
 407         if (!output) {
 408                 ret = CMD_FATAL;
 409                 goto error;
 410         }
 411
 412         ret = lttng_snapshot_record(current_session_name, output, 0);
 413         if (ret < 0) {
 414                 if (ret == -LTTNG_ERR_MAX_SIZE_INVALID) {
 415                         ERR("Invalid snapshot size. Cannot fit at least one packet per stream.");
 416                 }
 417                 goto error;
 418         }
 419
 420         MSG("Snapshot recorded successfully for session %s", current_session_name);
 421
 422         if (url) {
 423                 MSG("Snapshot written at: %s", url);
 424         } else if (opt_ctrl_url) {
 425                 MSG("Snapshot written to ctrl: %s, data: %s", opt_ctrl_url,
 426                                 opt_data_url);
 427         }
 428
 429         if (lttng_opt_mi) {
 430                 ret = mi_lttng_snapshot_record(writer, current_session_name, url,
 431                                 opt_ctrl_url, opt_data_url);
 432                 if (ret) {
 433                         ret = CMD_ERROR;
 434                 }
 435         }
 436
 437 error:
 438         lttng_snapshot_output_destroy(output);
 439         return ret;
 440 }
 441
 442 static int cmd_record(int argc, const char **argv)
 443 {
 444         int ret;
 445
 446         if (argc == 2) {
 447                 ret = record(argv[1]);
 448         } else {
 449                 ret = record(NULL);
 450         }
 451
 452         return ret;
 453 }
 454
 455 static enum cmd_error_code handle_command(const char **argv)
 456 {
 457         int mi_ret, i = 0, argc;
 458         enum cmd_error_code cmd_ret;
 459         struct cmd_struct *cmd;
 460
 461         if (!argv) {
 462                 ERR("No action specified for snapshot command.");
 463                 cmd_ret = CMD_ERROR;
 464                 goto end;
 465         }
 466
 467         if ((!opt_ctrl_url && opt_data_url) ||
 468                         (opt_ctrl_url && !opt_data_url)) {
 469                 ERR("URLs must be specified for both data and control");
 470                 cmd_ret = CMD_ERROR;
 471                 goto end;
 472         }
 473
 474         argc = count_arguments(argv);
 475         /* popt should have passed NULL if no arguments are present. */
 476         assert(argc > 0);
 477
 478         cmd = &actions[i];
 479         while (cmd->func != NULL) {
 480                 /* Find command */
 481                 if (strcmp(argv[0], cmd->name) == 0) {
 482                         int result;
 483
 484                         if (lttng_opt_mi) {
 485                                 /* Action element */
 486                                 mi_ret = mi_lttng_writer_open_element(writer,
 487                                                 mi_lttng_element_command_action);
 488                                 if (mi_ret) {
 489                                         cmd_ret = CMD_ERROR;
 490                                         goto end;
 491                                 }
 492
 493                                 /* Name of the action */
 494                                 mi_ret = mi_lttng_writer_write_element_string(writer,
 495                                                 config_element_name, argv[0]);
 496                                 if (mi_ret) {
 497                                         cmd_ret = CMD_ERROR;
 498                                         goto end;
 499                                 }
 500
 501                                 /* Open output element */
 502                                 mi_ret = mi_lttng_writer_open_element(writer,
 503                                                 mi_lttng_element_command_output);
 504                                 if (mi_ret) {
 505                                         cmd_ret = CMD_ERROR;
 506                                         goto end;
 507                                 }
 508                         }
 509
 510                         result = cmd->func(argc, argv);
 511                         if (result) {
 512                                 switch (result) {
 513                                 case CMD_ERROR:
 514                                 case CMD_UNDEFINED:
 515                                 case CMD_FATAL:
 516                                 case CMD_WARNING:
 517                                 case CMD_UNSUPPORTED:
 518                                         /*
 519                                          * Sub-commands mix lttng_error_codes
 520                                          * and cmd_error_codes. This should be
 521                                          * cleaned-up, but in the meantime this
 522                                          * hack works since the values of the
 523                                          * two enums do not intersect.
 524                                          */
 525                                         cmd_ret = result;
 526                                         break;
 527                                 case -LTTNG_ERR_SNAPSHOT_NODATA:
 528                                         WARN("%s", lttng_strerror(result));
 529
 530                                         /*  A warning is fine since the user has no control on
 531                                          *  whether or not applications (or the kernel) have
 532                                          *  produced any event between the start of the tracing
 533                                          *  session and the recording of the snapshot. MI wise
 534                                          *  the command is not a success since nothing was
 535                                          *  recorded.
 536                                          */
 537                                         cmd_ret = CMD_SUCCESS;
 538                                         break;
 539                                 default:
 540                                         ERR("%s", lttng_strerror(result));
 541                                         cmd_ret = CMD_ERROR;
 542                                         break;
 543                                 }
 544                         } else {
 545                                 cmd_ret = CMD_SUCCESS;
 546                         }
 547
 548
 549                         if (lttng_opt_mi) {
 550                                 /* Close output and action element */
 551                                 mi_ret = mi_lttng_close_multi_element(writer, 2);
 552                                 if (mi_ret) {
 553                                         cmd_ret = CMD_ERROR;
 554                                         goto end;
 555                                 }
 556                         }
 557                         goto end;
 558                 }
 559                 i++;
 560                 cmd = &actions[i];
 561         }
 562
 563         cmd_ret = CMD_UNDEFINED;
 564
 565 end:
 566         return cmd_ret;
 567 }
 568 /*
 569  * The 'snapshot <cmd> <options>' first level command
 570  */
 571 int cmd_snapshot(int argc, const char **argv)
 572 {
 573         int opt;
 574         int mi_ret;
 575         enum cmd_error_code cmd_ret = CMD_SUCCESS;
 576         char *session_name = NULL;
 577         static poptContext pc;
 578
 579         pc = poptGetContext(NULL, argc, argv, snapshot_opts, 0);
 580         poptReadDefaultConfig(pc, 0);
 581
 582         /* Mi check */
 583         if (lttng_opt_mi) {
 584                 writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi);
 585                 if (!writer) {
 586                         cmd_ret = CMD_ERROR;
 587                         goto end;
 588                 }
 589
 590                 /* Open command element */
 591                 mi_ret = mi_lttng_writer_command_open(writer,
 592                                 mi_lttng_element_command_snapshot);
 593                 if (mi_ret) {
 594                         cmd_ret = CMD_ERROR;
 595                         goto end;
 596                 }
 597
 598                 /* Open output element */
 599                 mi_ret = mi_lttng_writer_open_element(writer,
 600                                 mi_lttng_element_command_output);
 601                 if (mi_ret) {
 602                         cmd_ret = CMD_ERROR;
 603                         goto end;
 604                 }
 605         }
 606
 607         while ((opt = poptGetNextOpt(pc)) != -1) {
 608                 switch (opt) {
 609                 case OPT_HELP:
 610                 {
 611                         int ret;
 612
 613                         /* SHOW_HELP assigns to ret. */
 614                         SHOW_HELP();
 615                         cmd_ret = ret;
 616                         goto end;
 617                 }
 618                 case OPT_LIST_OPTIONS:
 619                         list_cmd_options(stdout, snapshot_opts);
 620                         goto end;
 621                 case OPT_LIST_COMMANDS:
 622                         list_commands(actions, stdout);
 623                         goto end;
 624                 case OPT_MAX_SIZE:
 625                 {
 626                         uint64_t val;
 627                         const char *opt = poptGetOptArg(pc);
 628
 629                         if (utils_parse_size_suffix((char *) opt, &val) < 0) {
 630                                 ERR("Unable to handle max-size value %s", opt);
 631                                 cmd_ret = CMD_ERROR;
 632                                 goto end;
 633                         }
 634
 635                         opt_max_size = val;
 636
 637                         break;
 638                 }
 639                 default:
 640                         cmd_ret = CMD_UNDEFINED;
 641                         goto end;
 642                 }
 643         }
 644
 645         if (!opt_session_name) {
 646                 session_name = get_session_name();
 647                 if (session_name == NULL) {
 648                         cmd_ret = CMD_ERROR;
 649                         goto end;
 650                 }
 651                 current_session_name = session_name;
 652         } else {
 653                 current_session_name = opt_session_name;
 654         }
 655
 656         cmd_ret = handle_command(poptGetArgs(pc));
 657
 658         if (lttng_opt_mi) {
 659                 /* Close output element */
 660                 mi_ret = mi_lttng_writer_close_element(writer);
 661                 if (mi_ret) {
 662                         cmd_ret = CMD_ERROR;
 663                         goto end;
 664                 }
 665
 666                 /* Success ? */
 667                 mi_ret = mi_lttng_writer_write_element_bool(writer,
 668                                 mi_lttng_element_command_success,
 669                                 cmd_ret == CMD_SUCCESS);
 670                 if (mi_ret) {
 671                         cmd_ret = CMD_ERROR;
 672                         goto end;
 673                 }
 674
 675                 /* Command element close */
 676                 mi_ret = mi_lttng_writer_command_close(writer);
 677                 if (mi_ret) {
 678                         cmd_ret = CMD_ERROR;
 679                         goto end;
 680                 }
 681         }
 682
 683 end:
 684         /* Mi clean-up */
 685         if (writer && mi_lttng_writer_destroy(writer)) {
 686                 cmd_ret = CMD_ERROR;
 687         }
 688
 689         if (!opt_session_name) {
 690                 free(session_name);
 691         }
 692
 693         poptFreeContext(pc);
 694         return cmd_ret;
 695 }