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", 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                 output_seen = 1;
 203         }
 204
 205         lttng_snapshot_output_list_destroy(list);
 206
 207         if (!output_seen) {
 208                 MSG("%sNone", indent4);
 209         }
 210
 211 error:
 212         return ret;
 213 }
 214
 215 /*
 216  * Delete output by ID.
 217  */
 218 static int del_output(uint32_t id, const char *name)
 219 {
 220         int ret;
 221         struct lttng_snapshot_output *output = NULL;
 222
 223         output = lttng_snapshot_output_create();
 224         if (!output) {
 225                 ret = CMD_FATAL;
 226                 goto error;
 227         }
 228
 229         if (name) {
 230                 ret = lttng_snapshot_output_set_name(name, output);
 231         } else if (id != UINT32_MAX) {
 232                 ret = lttng_snapshot_output_set_id(id, output);
 233         } else {
 234                 ret = CMD_ERROR;
 235                 goto error;
 236         }
 237         if (ret < 0) {
 238                 ret = CMD_FATAL;
 239                 goto error;
 240         }
 241
 242         ret = lttng_snapshot_del_output(current_session_name, output);
 243         if (ret < 0) {
 244                 goto error;
 245         }
 246
 247         if (id != UINT32_MAX) {
 248                 MSG("Snapshot output id %" PRIu32 " successfully deleted for session %s",
 249                                 id, current_session_name);
 250         } else {
 251                 MSG("Snapshot output %s successfully deleted for session %s",
 252                                 name, current_session_name);
 253         }
 254
 255 error:
 256         lttng_snapshot_output_destroy(output);
 257         return ret;
 258 }
 259
 260 /*
 261  * Add output from the user URL.
 262  */
 263 static int add_output(const char *url)
 264 {
 265         int ret;
 266         struct lttng_snapshot_output *output = NULL;
 267         char name[NAME_MAX];
 268         const char *n_ptr;
 269
 270         if (!url && (!opt_data_url || !opt_ctrl_url)) {
 271                 ret = CMD_ERROR;
 272                 goto error;
 273         }
 274
 275         output = create_output_from_args(url);
 276         if (!output) {
 277                 ret = CMD_FATAL;
 278                 goto error;
 279         }
 280
 281         /* This call, if successful, populates the id of the output object. */
 282         ret = lttng_snapshot_add_output(current_session_name, output);
 283         if (ret < 0) {
 284                 goto error;
 285         }
 286
 287         n_ptr = lttng_snapshot_output_get_name(output);
 288         if (*n_ptr == '\0') {
 289                 int pret;
 290                 pret = snprintf(name, sizeof(name), DEFAULT_SNAPSHOT_NAME "-%" PRIu32,
 291                                 lttng_snapshot_output_get_id(output));
 292                 if (pret < 0) {
 293                         PERROR("snprintf add output name");
 294                 }
 295                 n_ptr = name;
 296         }
 297
 298         MSG("Snapshot output successfully added for session %s",
 299                         current_session_name);
 300         MSG("  [%" PRIu32 "] %s: %s (max-size: %" PRId64 ")",
 301                         lttng_snapshot_output_get_id(output), n_ptr,
 302                         lttng_snapshot_output_get_ctrl_url(output),
 303                         lttng_snapshot_output_get_maxsize(output));
 304 error:
 305         lttng_snapshot_output_destroy(output);
 306         return ret;
 307 }
 308
 309 static int cmd_add_output(int argc, const char **argv)
 310 {
 311         int ret = CMD_SUCCESS;
 312
 313         if (argc < 2 && (!opt_data_url || !opt_ctrl_url)) {
 314                 usage(stderr);
 315                 ret = CMD_ERROR;
 316                 goto end;
 317         }
 318
 319         ret = add_output(argv[1]);
 320
 321 end:
 322         return ret;
 323 }
 324
 325 static int cmd_del_output(int argc, const char **argv)
 326 {
 327         int ret = CMD_SUCCESS;
 328         char *name;
 329         long id;
 330
 331         if (argc < 2) {
 332                 usage(stderr);
 333                 ret = CMD_ERROR;
 334                 goto end;
 335         }
 336
 337         errno = 0;
 338         id = strtol(argv[1], &name, 10);
 339         if (id == 0 && errno == 0) {
 340                 ret = del_output(UINT32_MAX, name);
 341         } else if (errno == 0 && *name == '\0') {
 342                 ret = del_output(id, NULL);
 343         } else {
 344                 ERR("Argument %s not recognized", argv[1]);
 345                 ret = -1;
 346                 goto end;
 347         }
 348
 349 end:
 350         return ret;
 351 }
 352
 353 static int cmd_list_output(int argc, const char **argv)
 354 {
 355         return list_output();
 356 }
 357
 358 /*
 359  * Do a snapshot record with the URL if one is given.
 360  */
 361 static int record(const char *url)
 362 {
 363         int ret;
 364         struct lttng_snapshot_output *output = NULL;
 365
 366         output = create_output_from_args(url);
 367         if (!output) {
 368                 ret = CMD_FATAL;
 369                 goto error;
 370         }
 371
 372         ret = lttng_snapshot_record(current_session_name, output, 0);
 373         if (ret < 0) {
 374                 goto error;
 375         }
 376
 377         MSG("Snapshot recorded successfully for session %s", current_session_name);
 378
 379         if (url) {
 380                 MSG("Snapshot written at: %s", url);
 381         } else if (opt_ctrl_url) {
 382                 MSG("Snapshot written to ctrl: %s, data: %s", opt_ctrl_url,
 383                                 opt_data_url);
 384         }
 385
 386 error:
 387         lttng_snapshot_output_destroy(output);
 388         return ret;
 389 }
 390
 391 static int cmd_record(int argc, const char **argv)
 392 {
 393         int ret;
 394
 395         if (argc == 2) {
 396                 /* With a given URL */
 397                 ret = record(argv[1]);
 398         } else {
 399                 ret = record(NULL);
 400         }
 401
 402         return ret;
 403 }
 404
 405 static int handle_command(const char **argv)
 406 {
 407         int ret, i = 0, argc;
 408         struct cmd_struct *cmd;
 409
 410         if (argv == NULL || (!opt_ctrl_url && opt_data_url) ||
 411                         (opt_ctrl_url && !opt_data_url)) {
 412                 usage(stderr);
 413                 ret = CMD_ERROR;
 414                 goto end;
 415         }
 416
 417         argc = count_arguments(argv);
 418
 419         cmd = &actions[i];
 420         while (cmd->func != NULL) {
 421                 /* Find command */
 422                 if (strcmp(argv[0], cmd->name) == 0) {
 423                         ret = cmd->func(argc, argv);
 424                         goto end;
 425                 }
 426                 i++;
 427                 cmd = &actions[i];
 428         }
 429
 430         /* Command not found */
 431         ret = CMD_UNDEFINED;
 432
 433 end:
 434         return ret;
 435 }
 436
 437 /*
 438  * The 'snapshot <cmd> <options>' first level command
 439  */
 440 int cmd_snapshot(int argc, const char **argv)
 441 {
 442         int opt, ret = CMD_SUCCESS;
 443         char *session_name = NULL;
 444         static poptContext pc;
 445
 446         pc = poptGetContext(NULL, argc, argv, snapshot_opts, 0);
 447         poptReadDefaultConfig(pc, 0);
 448
 449         while ((opt = poptGetNextOpt(pc)) != -1) {
 450                 switch (opt) {
 451                 case OPT_HELP:
 452                         usage(stdout);
 453                         goto end;
 454                 case OPT_LIST_OPTIONS:
 455                         list_cmd_options(stdout, snapshot_opts);
 456                         goto end;
 457                 case OPT_LIST_COMMANDS:
 458                         list_commands(actions, stdout);
 459                         goto end;
 460                 case OPT_MAX_SIZE:
 461                 {
 462                         uint64_t val;
 463                         const char *opt = poptGetOptArg(pc);
 464
 465                         if (utils_parse_size_suffix((char *) opt, &val) < 0) {
 466                                 ERR("Unable to handle max-size value %s", opt);
 467                                 ret = CMD_ERROR;
 468                                 goto end;
 469                         }
 470
 471                         opt_max_size = val;
 472
 473                         break;
 474                 }
 475                 default:
 476                         usage(stderr);
 477                         ret = CMD_UNDEFINED;
 478                         goto end;
 479                 }
 480         }
 481
 482         if (!opt_session_name) {
 483                 session_name = get_session_name();
 484                 if (session_name == NULL) {
 485                         ret = CMD_ERROR;
 486                         goto end;
 487                 }
 488                 current_session_name = session_name;
 489         } else {
 490                 current_session_name = opt_session_name;
 491         }
 492
 493         ret = handle_command(poptGetArgs(pc));
 494         if (ret < 0) {
 495                 switch (-ret) {
 496                 case LTTNG_ERR_EPERM:
 497                         ERR("The session needs to be set in no output mode (--no-output)");
 498                         break;
 499                 case LTTNG_ERR_SNAPSHOT_NODATA:
 500                         WARN("%s", lttng_strerror(ret));
 501                         break;
 502                 default:
 503                         ERR("%s", lttng_strerror(ret));
 504                         break;
 505                 }
 506                 goto end;
 507         }
 508
 509 end:
 510         if (!opt_session_name) {
 511                 free(session_name);
 512         }
 513         poptFreeContext(pc);
 514         return ret;
 515 }