X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng%2Fcommands%2Fstop.cpp;h=9d5533a2175c361be78f159a56628517afed9c13;hb=e8c353ad12851366573d9bfe45d333a9e9ff742d;hp=d69da40abe677b63c6ba5860416667ff97b6917c;hpb=48a4000561343808724f7cb5fa8c131877489ccd;p=lttng-tools.git diff --git a/src/bin/lttng/commands/stop.cpp b/src/bin/lttng/commands/stop.cpp index d69da40ab..9d5533a21 100644 --- a/src/bin/lttng/commands/stop.cpp +++ b/src/bin/lttng/commands/stop.cpp @@ -1,11 +1,19 @@ /* - * Copyright (C) 2011 David Goulet + * Copyright (C) 2011 EfficiOS Inc. * * SPDX-License-Identifier: GPL-2.0-only * */ #define _LGPL_SOURCE +#include "../command.hpp" +#include "../exception.hpp" +#include "../utils.hpp" + +#include +#include +#include + #include #include #include @@ -14,38 +22,37 @@ #include #include -#include -#include - -#include "../command.h" +enum { + OPT_HELP = 1, + OPT_LIST_OPTIONS, + OPT_ENABLE_GLOB, + OPT_ALL, +}; -static char *opt_session_name; -static int opt_no_wait; -static struct mi_writer *writer; +namespace { +int opt_no_wait; +struct mi_writer *writer; #ifdef LTTNG_EMBED_HELP -static const char help_msg[] = +const char help_msg[] = #include -; + ; #endif -enum { - OPT_HELP = 1, - OPT_LIST_OPTIONS, -}; - -static struct poptOption long_options[] = { +struct poptOption long_options[] = { /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */ - {"help", 'h', POPT_ARG_NONE, 0, OPT_HELP, 0, 0}, - {"list-options", 0, POPT_ARG_NONE, NULL, OPT_LIST_OPTIONS, NULL, NULL}, - {"no-wait", 'n', POPT_ARG_VAL, &opt_no_wait, 1, 0, 0}, - {0, 0, 0, 0, 0, 0, 0} + { "help", 'h', POPT_ARG_NONE, nullptr, OPT_HELP, nullptr, nullptr }, + { "list-options", 0, POPT_ARG_NONE, nullptr, OPT_LIST_OPTIONS, nullptr, nullptr }, + { "no-wait", 'n', POPT_ARG_VAL, &opt_no_wait, 1, nullptr, nullptr }, + { "glob", 'g', POPT_ARG_NONE, nullptr, OPT_ENABLE_GLOB, nullptr, nullptr }, + { "all", 'a', POPT_ARG_NONE, nullptr, OPT_ALL, nullptr, nullptr }, + { nullptr, 0, 0, nullptr, 0, nullptr, nullptr } }; /* * Mi print of partial session */ -static int mi_print_session(char *session_name, int enabled) +int mi_print_session(const char *session_name, int enabled) { int ret; LTTNG_ASSERT(writer); @@ -58,15 +65,13 @@ static int mi_print_session(char *session_name, int enabled) } /* Print session name element */ - ret = mi_lttng_writer_write_element_string(writer, config_element_name, - session_name); + ret = mi_lttng_writer_write_element_string(writer, config_element_name, session_name); if (ret) { goto end; } /* Is enabled ? */ - ret = mi_lttng_writer_write_element_bool(writer, config_element_enabled, - enabled); + ret = mi_lttng_writer_write_element_bool(writer, config_element_enabled, enabled); if (ret) { goto end; } @@ -81,32 +86,14 @@ end: /* * Start tracing for all trace of the session. */ -static int stop_tracing(void) +cmd_error_code stop_tracing(const char *session_name) { int ret; - char *session_name; - - if (opt_session_name == NULL) { - session_name = get_session_name(); - if (session_name == NULL) { - ret = CMD_ERROR; - goto error; - } - } else { - session_name = opt_session_name; - } ret = lttng_stop_tracing_no_wait(session_name); if (ret < 0) { - switch (-ret) { - case LTTNG_ERR_TRACE_ALREADY_STOPPED: - WARN("Tracing already stopped for session %s", session_name); - break; - default: - ERR("%s", lttng_strerror(ret)); - break; - } - goto free_name; + LTTNG_THROW_CTL(lttng::format("Failed to start session `{}`", session_name), + static_cast(-ret)); } if (!opt_no_wait) { @@ -116,7 +103,10 @@ static int stop_tracing(void) ret = lttng_data_pending(session_name); if (ret < 0) { /* Return the data available call error. */ - goto free_name; + ERR_FMT("Failed to check pending data for session `{}` ({})", + session_name, + lttng_strerror(ret)); + return CMD_ERROR; } /* @@ -132,25 +122,99 @@ static int stop_tracing(void) MSG(""); } - ret = CMD_SUCCESS; - print_session_stats(session_name); - MSG("Tracing stopped for session %s", session_name); + MSG("Tracing stopped for session `%s`", session_name); if (lttng_opt_mi) { - ret = mi_print_session(session_name, 0); - if (ret) { - goto free_name; + if (mi_print_session(session_name, 0)) { + return CMD_ERROR; + } + } + + return CMD_SUCCESS; +} + +cmd_error_code stop_tracing(const lttng::cli::session_spec& spec) +{ + bool had_warning = false; + bool had_error = false; + bool listing_failed = false; + + const auto sessions = [&listing_failed, &spec]() -> lttng::cli::session_list { + try { + return list_sessions(spec); + } catch (const lttng::ctl::error& ctl_exception) { + ERR_FMT("Failed to list sessions ({})", + lttng_strerror(-ctl_exception.code())); + listing_failed = true; + return {}; + } catch (const lttng::cli::no_default_session_error& cli_exception) { + /* + * The retrieval of the default session name already logs + * an error when it fails. There is no value in printing + * anything about this exception. + */ + listing_failed = true; + return {}; } + }(); + + if (!listing_failed && sessions.size() == 0 && + spec.type_ == lttng::cli::session_spec::type::NAME) { + ERR_FMT("Session `{}` not found", spec.value); + return CMD_ERROR; } -free_name: - if (opt_session_name == NULL) { - free(session_name); + if (listing_failed) { + return CMD_FATAL; } -error: - return ret; + for (const auto& session : sessions) { + cmd_error_code sub_ret; + + try { + sub_ret = stop_tracing(session.name); + } catch (const lttng::ctl::error& ctl_exception) { + switch (ctl_exception.code()) { + case LTTNG_ERR_TRACE_ALREADY_STOPPED: + WARN_FMT("Tracing already stopped for session `{}`", session.name); + sub_ret = CMD_SUCCESS; + break; + case LTTNG_ERR_NO_SESSION: + if (spec.type_ != lttng::cli::session_spec::type::NAME) { + /* Session destroyed during command, ignore and carry-on. */ + sub_ret = CMD_SUCCESS; + break; + } else { + sub_ret = CMD_ERROR; + break; + } + case LTTNG_ERR_NO_SESSIOND: + /* Don't keep going on a fatal error. */ + return CMD_FATAL; + default: + /* Generic error. */ + sub_ret = CMD_ERROR; + ERR_FMT("Failed to stop session `{}` ({})", + session.name, + lttng_strerror(-ctl_exception.code())); + break; + } + } + + /* Keep going, but report the most serious state. */ + had_warning |= sub_ret == CMD_WARNING; + had_error |= sub_ret == CMD_ERROR; + } + + if (had_error) { + return CMD_ERROR; + } else if (had_warning) { + return CMD_WARNING; + } else { + return CMD_SUCCESS; + } } +} /* namespace */ /* * cmd_stop @@ -159,23 +223,37 @@ error: */ int cmd_stop(int argc, const char **argv) { - int opt, ret = CMD_SUCCESS, command_ret = CMD_SUCCESS, success = 1; + int opt; + cmd_error_code command_ret = CMD_SUCCESS; + bool success = true; static poptContext pc; - const char *leftover = NULL; + const char *leftover = nullptr; + lttng::cli::session_spec session_spec(lttng::cli::session_spec::type::NAME); - pc = poptGetContext(NULL, argc, argv, long_options, 0); + pc = poptGetContext(nullptr, argc, argv, long_options, 0); poptReadDefaultConfig(pc, 0); while ((opt = poptGetNextOpt(pc)) != -1) { switch (opt) { case OPT_HELP: + { + int ret; + SHOW_HELP(); + command_ret = static_cast(ret); goto end; + } case OPT_LIST_OPTIONS: list_cmd_options(stdout, long_options); goto end; + case OPT_ENABLE_GLOB: + session_spec.type_ = lttng::cli::session_spec::type::GLOB_PATTERN; + break; + case OPT_ALL: + session_spec.type_ = lttng::cli::session_spec::type::ALL; + break; default: - ret = CMD_UNDEFINED; + command_ret = CMD_UNDEFINED; goto end; } } @@ -184,23 +262,19 @@ int cmd_stop(int argc, const char **argv) if (lttng_opt_mi) { writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi); if (!writer) { - ret = -LTTNG_ERR_NOMEM; + command_ret = CMD_ERROR; goto end; } /* Open command element */ - ret = mi_lttng_writer_command_open(writer, - mi_lttng_element_command_stop); - if (ret) { - ret = CMD_ERROR; + if (mi_lttng_writer_command_open(writer, mi_lttng_element_command_stop)) { + command_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; + if (mi_lttng_writer_open_element(writer, mi_lttng_element_command_output)) { + command_ret = CMD_ERROR; goto end; } @@ -208,49 +282,44 @@ int cmd_stop(int argc, const char **argv) * Open sessions element * For validation */ - ret = mi_lttng_writer_open_element(writer, - config_element_sessions); - if (ret) { - ret = CMD_ERROR; + if (mi_lttng_writer_open_element(writer, config_element_sessions)) { + command_ret = CMD_ERROR; goto end; } } - opt_session_name = (char*) poptGetArg(pc); + session_spec.value = poptGetArg(pc); leftover = poptGetArg(pc); if (leftover) { ERR("Unknown argument: %s", leftover); - ret = CMD_ERROR; + command_ret = CMD_ERROR; goto end; } - command_ret = stop_tracing(); + command_ret = stop_tracing(session_spec); if (command_ret) { - success = 0; + success = false; } /* Mi closing */ if (lttng_opt_mi) { /* Close sessions and output element */ - ret = mi_lttng_close_multi_element(writer, 2); - if (ret) { - ret = CMD_ERROR; + if (mi_lttng_close_multi_element(writer, 2)) { + command_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; + if (mi_lttng_writer_write_element_bool( + writer, mi_lttng_element_command_success, success)) { + command_ret = CMD_ERROR; goto end; } /* Command element close */ - ret = mi_lttng_writer_command_close(writer); - if (ret) { - ret = CMD_ERROR; + if (mi_lttng_writer_command_close(writer)) { + command_ret = CMD_ERROR; goto end; } } @@ -258,13 +327,9 @@ int cmd_stop(int argc, const char **argv) end: /* Mi clean-up */ if (writer && mi_lttng_writer_destroy(writer)) { - /* Preserve original error code */ - ret = ret ? ret : -LTTNG_ERR_MI_IO_FAIL; + command_ret = CMD_ERROR; } - /* Overwrite ret if an error occurred in stop_tracing() */ - ret = command_ret ? command_ret : ret; - poptFreeContext(pc); - return ret; + return command_ret; }