src/bin/lttng/commands/snapshot.c

   1 /*
   2  * Copyright (C) 2013 - David Goulet <dgoulet@efficios.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License, version 2 only, as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with
  14  * this program; if not, write to the Free Software Foundation, Inc., 51
  15  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  16  */
  17
  18 #define _GNU_SOURCE
  19 #include <assert.h>
  20 #include <inttypes.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 <unistd.h>
  28
  29 #include <common/utils.h>
  30 #include <lttng/snapshot.h>
  31
  32 #include "../command.h"
  33
  34 static const char *opt_session_name;
  35 static const char *opt_output_name;
  36 static const char *opt_data_url;
  37 static const char *opt_ctrl_url;
  38 static const char *current_session_name;
  39 static uint64_t opt_max_size;
  40
  41 /* Stub for the cmd struct actions. */
  42 static int cmd_add_output(int argc, const char **argv);
  43 static int cmd_del_output(int argc, const char **argv);
  44 static int cmd_list_output(int argc, const char **argv);
  45 static int cmd_record(int argc, const char **argv);
  46
  47 static const char *indent4 = "    ";
  48
  49 enum {
  50         OPT_HELP = 1,
  51         OPT_LIST_OPTIONS,
  52         OPT_MAX_SIZE,
  53         OPT_LIST_COMMANDS,
  54 };
  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  * usage
  79  */
  80 static void usage(FILE *ofp)
  81 {
  82         fprintf(ofp, "usage: lttng snapshot [OPTION] ACTION\n");
  83         fprintf(ofp, "\n");
  84         fprintf(ofp, "Actions:\n");
  85         fprintf(ofp, "   add-output [-m <SIZE>] [-s <NAME>] [-n <NAME>] <URL> | -C <URL> -D <URL>\n");
  86         fprintf(ofp, "      Setup and add an snapshot output for a session.\n");
  87         fprintf(ofp, "\n");
  88         fprintf(ofp, "   del-output ID | NAME [-s <NAME>]\n");
  89         fprintf(ofp, "      Delete an output for a session using the ID.\n");
  90         fprintf(ofp, "\n");
  91         fprintf(ofp, "   list-output [-s <NAME>]\n");
  92         fprintf(ofp, "      List the output of a session.\n");
  93         fprintf(ofp, "\n");
  94         fprintf(ofp, "   record [-m <SIZE>] [-s <NAME>] [-n <NAME>] [<URL> | -C <URL> -D <URL>]\n");
  95         fprintf(ofp, "      Snapshot a session's buffer(s) for all domains. If an URL is\n");
  96         fprintf(ofp, "      specified, it is used instead of a previously added output.\n");
  97         fprintf(ofp, "      Specifying only a name or/a size will override the current output value.\n");
  98         fprintf(ofp, "      For instance, you can record a snapshot with a custom maximum size\n");
  99         fprintf(ofp, "      or with a different name.\n");
 100         fprintf(ofp, "\n");
 101         fprintf(ofp, "Options:\n");
 102         fprintf(ofp, "  -h, --help           Show this help\n");
 103         fprintf(ofp, "      --list-options   Simple listing of options\n");
 104         fprintf(ofp, "  -s, --session NAME   Apply to session name\n");
 105         fprintf(ofp, "  -n, --name NAME      Name of the output or snapshot\n");
 106         fprintf(ofp, "  -m, --max-size SIZE  Maximum bytes size of the snapshot {+k,+M,+G}\n");
 107         fprintf(ofp, "  -C, --ctrl-url URL   Set control path URL. (Must use -D also)\n");
 108         fprintf(ofp, "  -D, --data-url URL   Set data path URL. (Must use -C also)\n");
 109         fprintf(ofp, "\n");
 110 }
 111
 112 /*
 113  * Count and return the number of arguments in argv.
 114  */
 115 static int count_arguments(const char **argv)
 116 {
 117         int i = 0;
 118
 119         assert(argv);
 120
 121         while (argv[i] != NULL) {
 122                 i++;
 123         }
 124
 125         return i;
 126 }
 127
 128 /*
 129  * Create a snapshot output object from arguments using the given URL.
 130  *
 131  * Return a newly allocated object or NULL on error.
 132  */
 133 static struct lttng_snapshot_output *create_output_from_args(const char *url)
 134 {
 135         int ret = 0;
 136         struct lttng_snapshot_output *output = NULL;
 137
 138         output = lttng_snapshot_output_create();
 139         if (!output) {
 140                 goto error_create;
 141         }
 142
 143         if (url) {
 144                 ret = lttng_snapshot_output_set_ctrl_url(url, output);
 145                 if (ret < 0) {
 146                         goto error;
 147                 }
 148         } else if (opt_ctrl_url) {
 149                 ret = lttng_snapshot_output_set_ctrl_url(opt_ctrl_url, output);
 150                 if (ret < 0) {
 151                         goto error;
 152                 }
 153         }
 154
 155         if (opt_data_url) {
 156                 ret = lttng_snapshot_output_set_data_url(opt_data_url, output);
 157                 if (ret < 0) {
 158                         goto error;
 159                 }
 160         }
 161
 162         if (opt_max_size) {
 163                 ret = lttng_snapshot_output_set_size(opt_max_size, output);
 164                 if (ret < 0) {
 165                         goto error;
 166                 }
 167         }
 168
 169         if (opt_output_name) {
 170                 ret = lttng_snapshot_output_set_name(opt_output_name, output);
 171                 if (ret < 0) {
 172                         goto error;
 173                 }
 174         }
 175
 176         return output;
 177
 178 error:
 179         lttng_snapshot_output_destroy(output);
 180 error_create:
 181         return NULL;
 182 }
 183
 184 static int list_output(void)
 185 {
 186         int ret, output_seen = 0;
 187         struct lttng_snapshot_output *s_iter;
 188         struct lttng_snapshot_output_list *list;
 189
 190         ret = lttng_snapshot_list_output(current_session_name, &list);
 191         if (ret < 0) {
 192                 goto error;
 193         }
 194
 195         MSG("Snapshot output list for session %s", current_session_name);
 196
 197         while ((s_iter = lttng_snapshot_output_list_get_next(list)) != NULL) {
 198                 MSG("%s[%" PRIu32 "] %s: %s (max-size: %" PRId64 ")", indent4,
 199                                 lttng_snapshot_output_get_id(s_iter),
 200                                 lttng_snapshot_output_get_name(s_iter),
 201                                 lttng_snapshot_output_get_ctrl_url(s_iter),
 202                                 lttng_snapshot_output_get_maxsize(s_iter));
 203                 output_seen = 1;
 204         }
 205
 206         lttng_snapshot_output_list_destroy(list);
 207
 208         if (!output_seen) {
 209                 MSG("%sNone", indent4);
 210         }
 211
 212 error:
 213         return ret;
 214 }
 215
 216 /*
 217  * Delete output by ID.
 218  */
 219 static int del_output(uint32_t id, const char *name)
 220 {
 221         int ret;
 222         struct lttng_snapshot_output *output = NULL;
 223
 224         output = lttng_snapshot_output_create();
 225         if (!output) {
 226                 ret = CMD_FATAL;
 227                 goto error;
 228         }
 229
 230         if (name) {
 231                 ret = lttng_snapshot_output_set_name(name, output);
 232         } else if (id != UINT32_MAX) {
 233                 ret = lttng_snapshot_output_set_id(id, output);
 234         } else {
 235                 ret = CMD_ERROR;
 236                 goto error;
 237         }
 238         if (ret < 0) {
 239                 ret = CMD_FATAL;
 240                 goto error;
 241         }
 242
 243         ret = lttng_snapshot_del_output(current_session_name, output);
 244         if (ret < 0) {
 245                 goto error;
 246         }
 247
 248         if (id != UINT32_MAX) {
 249                 MSG("Snapshot output id %" PRIu32 " successfully deleted for session %s",
 250                                 id, current_session_name);
 251         } else {
 252                 MSG("Snapshot output %s successfully deleted for session %s",
 253                                 name, current_session_name);
 254         }
 255
 256 error:
 257         lttng_snapshot_output_destroy(output);
 258         return ret;
 259 }
 260
 261 /*
 262  * Add output from the user URL.
 263  */
 264 static int add_output(const char *url)
 265 {
 266         int ret;
 267         struct lttng_snapshot_output *output = NULL;
 268         char name[NAME_MAX];
 269         const char *n_ptr;
 270
 271         if (!url && (!opt_data_url || !opt_ctrl_url)) {
 272                 ret = CMD_ERROR;
 273                 goto error;
 274         }
 275
 276         output = create_output_from_args(url);
 277         if (!output) {
 278                 ret = CMD_FATAL;
 279                 goto error;
 280         }
 281
 282         /* This call, if successful, populates the id of the output object. */
 283         ret = lttng_snapshot_add_output(current_session_name, output);
 284         if (ret < 0) {
 285                 goto error;
 286         }
 287
 288         n_ptr = lttng_snapshot_output_get_name(output);
 289         if (*n_ptr == '\0') {
 290                 int pret;
 291                 pret = snprintf(name, sizeof(name), DEFAULT_SNAPSHOT_NAME "-%" PRIu32,
 292                                 lttng_snapshot_output_get_id(output));
 293                 if (pret < 0) {
 294                         PERROR("snprintf add output name");
 295                 }
 296                 n_ptr = name;
 297         }
 298
 299         MSG("Snapshot output successfully added for session %s",
 300                         current_session_name);
 301         MSG("  [%" PRIu32 "] %s: %s (max-size: %" PRId64 ")",
 302                         lttng_snapshot_output_get_id(output), n_ptr,
 303                         lttng_snapshot_output_get_ctrl_url(output),
 304                         lttng_snapshot_output_get_maxsize(output));
 305 error:
 306         lttng_snapshot_output_destroy(output);
 307         return ret;
 308 }
 309
 310 static int cmd_add_output(int argc, const char **argv)
 311 {
 312         int ret = CMD_SUCCESS;
 313
 314         if (argc < 2 && (!opt_data_url || !opt_ctrl_url)) {
 315                 usage(stderr);
 316                 ret = CMD_ERROR;
 317                 goto end;
 318         }
 319
 320         ret = add_output(argv[1]);
 321
 322 end:
 323         return ret;
 324 }
 325
 326 static int cmd_del_output(int argc, const char **argv)
 327 {
 328         int ret = CMD_SUCCESS;
 329         char *name;
 330         long id;
 331
 332         if (argc < 2) {
 333                 usage(stderr);
 334                 ret = CMD_ERROR;
 335                 goto end;
 336         }
 337
 338         errno = 0;
 339         id = strtol(argv[1], &name, 10);
 340         if (id == 0 && errno == 0) {
 341                 ret = del_output(UINT32_MAX, name);
 342         } else if (errno == 0 && *name == '\0') {
 343                 ret = del_output(id, NULL);
 344         } else {
 345                 ERR("Argument %s not recognized", argv[1]);
 346                 ret = -1;
 347                 goto end;
 348         }
 349
 350 end:
 351         return ret;
 352 }
 353
 354 static int cmd_list_output(int argc, const char **argv)
 355 {
 356         return list_output();
 357 }
 358
 359 /*
 360  * Do a snapshot record with the URL if one is given.
 361  */
 362 static int record(const char *url)
 363 {
 364         int ret;
 365         struct lttng_snapshot_output *output = NULL;
 366
 367         output = create_output_from_args(url);
 368         if (!output) {
 369                 ret = CMD_FATAL;
 370                 goto error;
 371         }
 372
 373         ret = lttng_snapshot_record(current_session_name, output, 0);
 374         if (ret < 0) {
 375                 goto error;
 376         }
 377
 378         MSG("Snapshot recorded successfully for session %s", current_session_name);
 379
 380         if (url) {
 381                 MSG("Snapshot written at: %s", url);
 382         } else if (opt_ctrl_url) {
 383                 MSG("Snapshot written to ctrl: %s, data: %s", opt_ctrl_url,
 384                                 opt_data_url);
 385         }
 386
 387 error:
 388         lttng_snapshot_output_destroy(output);
 389         return ret;
 390 }
 391
 392 static int cmd_record(int argc, const char **argv)
 393 {
 394         int ret;
 395
 396         if (argc == 2) {
 397                 /* With a given URL */
 398                 ret = record(argv[1]);
 399         } else {
 400                 ret = record(NULL);
 401         }
 402
 403         return ret;
 404 }
 405
 406 static int handle_command(const char **argv)
 407 {
 408         int ret, i = 0, argc;
 409         struct cmd_struct *cmd;
 410
 411         if (argv == NULL || (!opt_ctrl_url && opt_data_url) ||
 412                         (opt_ctrl_url && !opt_data_url)) {
 413                 usage(stderr);
 414                 ret = CMD_ERROR;
 415                 goto end;
 416         }
 417
 418         argc = count_arguments(argv);
 419
 420         cmd = &actions[i];
 421         while (cmd->func != NULL) {
 422                 /* Find command */
 423                 if (strcmp(argv[0], cmd->name) == 0) {
 424                         ret = cmd->func(argc, argv);
 425                         goto end;
 426                 }
 427                 i++;
 428                 cmd = &actions[i];
 429         }
 430
 431         /* Command not found */
 432         ret = CMD_UNDEFINED;
 433
 434 end:
 435         return ret;
 436 }
 437
 438 /*
 439  * The 'snapshot <cmd> <options>' first level command
 440  */
 441 int cmd_snapshot(int argc, const char **argv)
 442 {
 443         int opt, ret = CMD_SUCCESS;
 444         char *session_name = NULL;
 445         static poptContext pc;
 446
 447         pc = poptGetContext(NULL, argc, argv, snapshot_opts, 0);
 448         poptReadDefaultConfig(pc, 0);
 449
 450         while ((opt = poptGetNextOpt(pc)) != -1) {
 451                 switch (opt) {
 452                 case OPT_HELP:
 453                         usage(stdout);
 454                         goto end;
 455                 case OPT_LIST_OPTIONS:
 456                         list_cmd_options(stdout, snapshot_opts);
 457                         goto end;
 458                 case OPT_LIST_COMMANDS:
 459                         list_commands(actions, stdout);
 460                         goto end;
 461                 case OPT_MAX_SIZE:
 462                 {
 463                         uint64_t val;
 464                         const char *opt = poptGetOptArg(pc);
 465
 466                         if (utils_parse_size_suffix((char *) opt, &val) < 0) {
 467                                 ERR("Unable to handle max-size value %s", opt);
 468                                 ret = CMD_ERROR;
 469                                 goto end;
 470                         }
 471
 472                         opt_max_size = val;
 473
 474                         break;
 475                 }
 476                 default:
 477                         usage(stderr);
 478                         ret = CMD_UNDEFINED;
 479                         goto end;
 480                 }
 481         }
 482
 483         if (!opt_session_name) {
 484                 session_name = get_session_name();
 485                 if (session_name == NULL) {
 486                         ret = CMD_ERROR;
 487                         goto end;
 488                 }
 489                 current_session_name = session_name;
 490         } else {
 491                 current_session_name = opt_session_name;
 492         }
 493
 494         ret = handle_command(poptGetArgs(pc));
 495         if (ret < 0) {
 496                 switch (-ret) {
 497                 case LTTNG_ERR_EPERM:
 498                         ERR("The session needs to be set in no output mode (--no-output)");
 499                         break;
 500                 case LTTNG_ERR_SNAPSHOT_NODATA:
 501                         WARN("%s", lttng_strerror(ret));
 502                         break;
 503                 default:
 504                         ERR("%s", lttng_strerror(ret));
 505                         break;
 506                 }
 507                 goto end;
 508         }
 509
 510 end:
 511         if (!opt_session_name) {
 512                 free(session_name);
 513         }
 514         poptFreeContext(pc);
 515         return ret;
 516 }