X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng%2Fcommands%2Fsnapshot.c;h=298bc6ef36cee6a1bac7cb362464c0dd22f9915c;hp=564651e09c50480c22f45952e02833627f11364e;hb=dad01b0a32248a3accec24e763b354610321d228;hpb=c7e35b037773dbbfe10178c946ba44feefb226e1 diff --git a/src/bin/lttng/commands/snapshot.c b/src/bin/lttng/commands/snapshot.c index 564651e09..298bc6ef3 100644 --- a/src/bin/lttng/commands/snapshot.c +++ b/src/bin/lttng/commands/snapshot.c @@ -15,7 +15,7 @@ * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE +#define _LGPL_SOURCE #include #include #include @@ -25,8 +25,10 @@ #include #include #include +#include #include +#include #include #include "../command.h" @@ -53,6 +55,8 @@ enum { OPT_LIST_COMMANDS, }; +static struct mi_writer *writer; + static struct poptOption snapshot_opts[] = { /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */ {"help", 'h', POPT_ARG_NONE, 0, OPT_HELP, 0, 0}, @@ -74,41 +78,6 @@ static struct cmd_struct actions[] = { { NULL, NULL } /* Array closure */ }; -/* - * usage - */ -static void usage(FILE *ofp) -{ - fprintf(ofp, "usage: lttng snapshot [OPTION] ACTION\n"); - fprintf(ofp, "\n"); - fprintf(ofp, "Actions:\n"); - fprintf(ofp, " add-output [-m ] [-s ] [-n ] | -C -D \n"); - fprintf(ofp, " Setup and add an snapshot output for a session.\n"); - fprintf(ofp, "\n"); - fprintf(ofp, " del-output ID | NAME [-s ]\n"); - fprintf(ofp, " Delete an output for a session using the ID.\n"); - fprintf(ofp, "\n"); - fprintf(ofp, " list-output [-s ]\n"); - fprintf(ofp, " List the output of a session.\n"); - fprintf(ofp, "\n"); - fprintf(ofp, " record [-m ] [-s ] [-n ] [ | -C -D ]\n"); - fprintf(ofp, " Snapshot a session's buffer(s) for all domains. If an URL is\n"); - fprintf(ofp, " specified, it is used instead of a previously added output.\n"); - fprintf(ofp, " Specifying only a name or/a size will override the current output value.\n"); - fprintf(ofp, " For instance, you can record a snapshot with a custom maximum size\n"); - fprintf(ofp, " or with a different name.\n"); - fprintf(ofp, "\n"); - fprintf(ofp, "Options:\n"); - fprintf(ofp, " -h, --help Show this help\n"); - fprintf(ofp, " --list-options Simple listing of options\n"); - fprintf(ofp, " -s, --session NAME Apply to session name\n"); - fprintf(ofp, " -n, --name NAME Name of the output or snapshot\n"); - fprintf(ofp, " -m, --max-size SIZE Maximum bytes size of the snapshot {+k,+M,+G}\n"); - fprintf(ofp, " -C, --ctrl-url URL Set control path URL. (Must use -D also)\n"); - fprintf(ofp, " -D, --data-url URL Set data path URL. (Must use -C also)\n"); - fprintf(ofp, "\n"); -} - /* * Count and return the number of arguments in argv. */ @@ -181,6 +150,52 @@ error_create: return NULL; } +static int mi_list_output(void) +{ + int ret; + struct lttng_snapshot_output *s_iter; + struct lttng_snapshot_output_list *list; + + assert(writer); + + ret = lttng_snapshot_list_output(current_session_name, &list); + if (ret < 0) { + goto error; + } + + ret = mi_lttng_snapshot_output_session_name(writer, current_session_name); + if (ret) { + ret = CMD_ERROR; + goto end; + } + + while ((s_iter = lttng_snapshot_output_list_get_next(list)) != NULL) { + ret = mi_lttng_snapshot_list_output(writer, s_iter); + if (ret) { + ret = CMD_ERROR; + goto end; + } + } + + + /* Close snapshot snapshots element */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + ret = CMD_ERROR; + goto end; + } + + /* Close snapshot session element */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + ret = CMD_ERROR; + } +end: + lttng_snapshot_output_list_destroy(list); +error: + return ret; +} + static int list_output(void) { int ret, output_seen = 0; @@ -213,6 +228,50 @@ error: return ret; } +/* + * Delete output by ID (machine interface version). + */ +static int mi_del_output(uint32_t id, const char *name) +{ + int ret; + struct lttng_snapshot_output *output = NULL; + + assert(writer); + + output = lttng_snapshot_output_create(); + if (!output) { + ret = CMD_FATAL; + goto error; + } + + if (name) { + ret = lttng_snapshot_output_set_name(name, output); + } else if (id != UINT32_MAX) { + ret = lttng_snapshot_output_set_id(id, output); + } else { + ret = CMD_ERROR; + goto error; + } + if (ret < 0) { + ret = CMD_FATAL; + goto error; + } + + ret = lttng_snapshot_del_output(current_session_name, output); + if (ret < 0) { + goto error; + } + + ret = mi_lttng_snapshot_del_output(writer, id, name, current_session_name); + if (ret) { + ret = CMD_ERROR; + } + +error: + lttng_snapshot_output_destroy(output); + return ret; +} + /* * Delete output by ID. */ @@ -258,6 +317,55 @@ error: return ret; } +/* + * Add output from the user URL (machine interface). + */ +static int mi_add_output(const char *url) +{ + int ret; + struct lttng_snapshot_output *output = NULL; + char name[NAME_MAX]; + const char *n_ptr; + + if (!url && (!opt_data_url || !opt_ctrl_url)) { + ret = CMD_ERROR; + goto error; + } + + output = create_output_from_args(url); + if (!output) { + ret = CMD_FATAL; + goto error; + } + + /* This call, if successful, populates the id of the output object. */ + ret = lttng_snapshot_add_output(current_session_name, output); + if (ret < 0) { + goto error; + } + + n_ptr = lttng_snapshot_output_get_name(output); + if (*n_ptr == '\0') { + int pret; + pret = snprintf(name, sizeof(name), DEFAULT_SNAPSHOT_NAME "-%" PRIu32, + lttng_snapshot_output_get_id(output)); + if (pret < 0) { + PERROR("snprintf add output name"); + } + n_ptr = name; + } + + ret = mi_lttng_snapshot_add_output(writer, current_session_name, n_ptr, + output); + if (ret) { + ret = CMD_ERROR; + } + +error: + lttng_snapshot_output_destroy(output); + return ret; +} + /* * Add output from the user URL. */ @@ -309,15 +417,18 @@ error: static int cmd_add_output(int argc, const char **argv) { - int ret = CMD_SUCCESS; + int ret; if (argc < 2 && (!opt_data_url || !opt_ctrl_url)) { - usage(stderr); ret = CMD_ERROR; goto end; } - ret = add_output(argv[1]); + if (lttng_opt_mi) { + ret = mi_add_output(argv[1]); + } else { + ret = add_output(argv[1]); + } end: return ret; @@ -325,12 +436,11 @@ end: static int cmd_del_output(int argc, const char **argv) { - int ret = CMD_SUCCESS; + int ret; char *name; long id; if (argc < 2) { - usage(stderr); ret = CMD_ERROR; goto end; } @@ -338,9 +448,17 @@ static int cmd_del_output(int argc, const char **argv) errno = 0; id = strtol(argv[1], &name, 10); if (id == 0 && errno == 0) { - ret = del_output(UINT32_MAX, name); + if (lttng_opt_mi) { + ret = mi_del_output(UINT32_MAX, name); + } else { + ret = del_output(UINT32_MAX, name); + } } else if (errno == 0 && *name == '\0') { - ret = del_output(id, NULL); + if (lttng_opt_mi) { + ret = mi_del_output(id, NULL); + } else { + ret = del_output(id, NULL); + } } else { ERR("Argument %s not recognized", argv[1]); ret = -1; @@ -353,7 +471,46 @@ end: static int cmd_list_output(int argc, const char **argv) { - return list_output(); + int ret; + + if (lttng_opt_mi) { + ret = mi_list_output(); + } else { + ret = list_output(); + } + + return ret; +} + +/* + * Do a snapshot record with the URL if one is given (machine interface). + */ +static int mi_record(const char *url) +{ + int ret; + struct lttng_snapshot_output *output = NULL; + + output = create_output_from_args(url); + if (!output) { + ret = CMD_FATAL; + goto error; + } + + ret = lttng_snapshot_record(current_session_name, output, 0); + if (ret < 0) { + ret = CMD_ERROR; + goto error; + } + + ret = mi_lttng_snapshot_record(writer, current_session_name, url, + opt_ctrl_url, opt_data_url); + if (ret) { + ret = CMD_ERROR; + } + +error: + lttng_snapshot_output_destroy(output); + return ret; } /* @@ -373,9 +530,7 @@ static int record(const char *url) ret = lttng_snapshot_record(current_session_name, output, 0); if (ret < 0) { if (ret == -LTTNG_ERR_MAX_SIZE_INVALID) { - ERR("The minimum size of a snapshot is computed by multiplying " - "the total amount of streams with the largest subbuffer " - "in the session."); + ERR("Invalid snapshot size. Cannot fit at least one packet per stream."); } goto error; } @@ -400,9 +555,17 @@ static int cmd_record(int argc, const char **argv) if (argc == 2) { /* With a given URL */ - ret = record(argv[1]); + if (lttng_opt_mi) { + ret = mi_record(argv[1]); + } else { + ret = record(argv[1]); + } } else { - ret = record(NULL); + if (lttng_opt_mi) { + ret = mi_record(NULL); + } else { + ret = record(NULL); + } } return ret; @@ -410,13 +573,12 @@ static int cmd_record(int argc, const char **argv) static int handle_command(const char **argv) { - int ret, i = 0, argc; + int ret = CMD_SUCCESS, i = 0, argc, command_ret = CMD_SUCCESS; struct cmd_struct *cmd; if (argv == NULL || (!opt_ctrl_url && opt_data_url) || (opt_ctrl_url && !opt_data_url)) { - usage(stderr); - ret = CMD_ERROR; + command_ret = CMD_ERROR; goto end; } @@ -426,43 +588,96 @@ static int handle_command(const char **argv) while (cmd->func != NULL) { /* Find command */ if (strcmp(argv[0], cmd->name) == 0) { - ret = cmd->func(argc, argv); + if (lttng_opt_mi) { + /* Action element */ + ret = mi_lttng_writer_open_element(writer, + mi_lttng_element_command_action); + if (ret) { + ret = CMD_ERROR; + goto end; + } + + /* Name of the action */ + ret = mi_lttng_writer_write_element_string(writer, + config_element_name, argv[0]); + if (ret) { + ret = CMD_ERROR; + goto end; + } + + /* Open output element */ + ret = mi_lttng_writer_open_element(writer, + mi_lttng_element_command_output); + if (ret) { + ret = CMD_ERROR; + goto end; + } + } + + command_ret = cmd->func(argc, argv); + + if (lttng_opt_mi) { + /* Close output and action element */ + ret = mi_lttng_close_multi_element(writer, 2); + if (ret) { + ret = CMD_ERROR; + goto end; + } + } goto end; } i++; cmd = &actions[i]; } - /* Command not found */ ret = CMD_UNDEFINED; end: + /* Overwrite ret if an error occurred in cmd->func() */ + ret = command_ret ? command_ret : ret; return ret; } - /* * The 'snapshot ' first level command */ int cmd_snapshot(int argc, const char **argv) { - int opt, ret = CMD_SUCCESS; + int opt, ret = CMD_SUCCESS, command_ret = CMD_SUCCESS, success = 1; char *session_name = NULL; static poptContext pc; pc = poptGetContext(NULL, argc, argv, snapshot_opts, 0); poptReadDefaultConfig(pc, 0); - /* TODO: mi support */ + /* Mi check */ if (lttng_opt_mi) { - ret = -LTTNG_ERR_MI_NOT_IMPLEMENTED; - ERR("mi option not supported"); - goto end; + writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi); + if (!writer) { + ret = -LTTNG_ERR_NOMEM; + goto end; + } + + /* Open command element */ + ret = mi_lttng_writer_command_open(writer, + mi_lttng_element_command_snapshot); + if (ret) { + ret = CMD_ERROR; + goto end; + } + + /* Open output element */ + ret = mi_lttng_writer_open_element(writer, + mi_lttng_element_command_output); + if (ret) { + ret = CMD_ERROR; + goto end; + } } while ((opt = poptGetNextOpt(pc)) != -1) { switch (opt) { case OPT_HELP: - usage(stdout); + SHOW_HELP(); goto end; case OPT_LIST_OPTIONS: list_cmd_options(stdout, snapshot_opts); @@ -486,7 +701,6 @@ int cmd_snapshot(int argc, const char **argv) break; } default: - usage(stderr); ret = CMD_UNDEFINED; goto end; } @@ -503,26 +717,68 @@ int cmd_snapshot(int argc, const char **argv) current_session_name = opt_session_name; } - ret = handle_command(poptGetArgs(pc)); - if (ret < 0) { - switch (-ret) { + command_ret = handle_command(poptGetArgs(pc)); + if (command_ret) { + switch (-command_ret) { case LTTNG_ERR_EPERM: ERR("The session needs to be set in no output mode (--no-output)"); break; case LTTNG_ERR_SNAPSHOT_NODATA: - WARN("%s", lttng_strerror(ret)); + WARN("%s", lttng_strerror(command_ret)); + + /* A warning is fine since the user has no control on + * whether or not applications (or the kernel) have + * produced any event between the start of the tracing + * session and the recording of the snapshot. MI wise + * the command is not a success since nothing was + * recorded. + */ + command_ret = 0; break; default: - ERR("%s", lttng_strerror(ret)); + ERR("%s", lttng_strerror(command_ret)); break; } - goto end; + success = 0; + } + + if (lttng_opt_mi) { + /* Close output element */ + ret = mi_lttng_writer_close_element(writer); + if (ret) { + ret = CMD_ERROR; + goto end; + } + + /* Success ? */ + ret = mi_lttng_writer_write_element_bool(writer, + mi_lttng_element_command_success, success); + if (ret) { + ret = CMD_ERROR; + goto end; + } + + /* Command element close */ + ret = mi_lttng_writer_command_close(writer); + if (ret) { + ret = CMD_ERROR; + goto end; + } } end: + /* Mi clean-up */ + if (writer && mi_lttng_writer_destroy(writer)) { + /* Preserve original error code */ + ret = ret ? ret : -LTTNG_ERR_MI_IO_FAIL; + } + if (!opt_session_name) { free(session_name); } + + /* Overwrite ret if an error occured during handle_command */ + ret = command_ret ? command_ret : ret; poptFreeContext(pc); return ret; }