#include "../command.hpp"
#include <common/exception.hpp>
+#include <common/make-unique-wrapper.hpp>
#include <common/mi-lttng.hpp>
+#include <common/scope-exit.hpp>
#include <common/sessiond-comm/sessiond-comm.hpp>
#include <common/utils.hpp>
* Unregister the provided session to the session daemon. On success, removes
* the default configuration.
*/
-int destroy_session(const struct lttng_session& session)
+cmd_error_code destroy_session(const lttng_session& session)
{
int ret;
- char *session_name = nullptr;
- bool session_was_already_stopped;
- enum lttng_error_code ret_code;
- struct lttng_destruction_handle *handle = nullptr;
- enum lttng_destruction_handle_status status;
bool newline_needed = false, printed_destroy_msg = false;
- enum lttng_rotation_state rotation_state;
- char *stats_str = nullptr;
+
+ const auto print_trailing_new_line = lttng::make_scope_exit([&newline_needed]() noexcept {
+ if (newline_needed) {
+ MSG("");
+ }
+ });
ret = lttng_stop_tracing_no_wait(session.name);
if (ret < 0 && ret != -LTTNG_ERR_TRACE_ALREADY_STOPPED) {
- ERR("%s", lttng_strerror(ret));
+ LTTNG_THROW_CTL(fmt::format("Failed to stop session `{}`", session.name),
+ static_cast<lttng_error_code>(-ret));
}
- session_was_already_stopped = ret == -LTTNG_ERR_TRACE_ALREADY_STOPPED;
+ const auto session_was_already_stopped = ret == -LTTNG_ERR_TRACE_ALREADY_STOPPED;
if (!opt_no_wait) {
do {
ret = lttng_data_pending(session.name);
if (ret < 0) {
/* Return the data available call error. */
- goto error;
+ ERR_FMT("Failed to check pending data for session `{}` ({})",
+ session.name,
+ lttng_strerror(ret));
+ return CMD_ERROR;
}
/*
*/
if (ret) {
if (!printed_destroy_msg) {
- _MSG("Destroying session %s", session.name);
+ _MSG("Destroying session `%s`", session.name);
newline_needed = true;
printed_destroy_msg = true;
fflush(stdout);
} while (ret != 0);
}
+ std::unique_ptr<char, lttng::details::create_unique_class<char, lttng::free>>
+ stats_str;
if (!session_was_already_stopped) {
+ char *raw_stats_str = nullptr;
+
/*
* Don't print the event and packet loss warnings since the user
* already saw them when stopping the trace.
*/
- ret = get_session_stats_str(session.name, &stats_str);
+ ret = get_session_stats_str(session.name, &raw_stats_str);
if (ret < 0) {
- goto error;
+ return CMD_ERROR;
}
- }
- ret_code = lttng_destroy_session_ext(session.name, &handle);
- if (ret_code != LTTNG_OK) {
- ret = -ret_code;
- goto error;
+ /* May still be null if there are no stats to print. */
+ stats_str.reset(raw_stats_str);
}
- if (opt_no_wait) {
- goto skip_wait_rotation;
- }
+ const auto destruction_handle = [&session]() {
+ struct lttng_destruction_handle *raw_destruction_handle = nullptr;
+
+ auto ctl_ret_code =
+ lttng_destroy_session_ext(session.name, &raw_destruction_handle);
+ if (ctl_ret_code != LTTNG_OK) {
+ LTTNG_THROW_CTL(fmt::format("Failed to destroy session `{}`", session.name),
+ ctl_ret_code);
+ }
- do {
- status = lttng_destruction_handle_wait_for_completion(
- handle, DEFAULT_DATA_AVAILABILITY_WAIT_TIME_US / USEC_PER_MSEC);
- switch (status) {
- case LTTNG_DESTRUCTION_HANDLE_STATUS_TIMEOUT:
- if (!printed_destroy_msg) {
- _MSG("Destroying session %s", session.name);
- newline_needed = true;
- printed_destroy_msg = true;
+ return lttng::make_unique_wrapper<lttng_destruction_handle,
+ lttng_destruction_handle_destroy>(
+ raw_destruction_handle);
+ }();
+
+ if (!opt_no_wait) {
+ enum lttng_destruction_handle_status status;
+
+ do {
+ status = lttng_destruction_handle_wait_for_completion(
+ destruction_handle.get(),
+ DEFAULT_DATA_AVAILABILITY_WAIT_TIME_US / USEC_PER_MSEC);
+ switch (status) {
+ case LTTNG_DESTRUCTION_HANDLE_STATUS_TIMEOUT:
+ if (!printed_destroy_msg) {
+ _MSG("Destroying session `%s`", session.name);
+ newline_needed = true;
+ printed_destroy_msg = true;
+ }
+ _MSG(".");
+ fflush(stdout);
+ break;
+ case LTTNG_DESTRUCTION_HANDLE_STATUS_COMPLETED:
+ break;
+ default:
+ ERR_FMT("{}An error occurred during the destruction of session `{}`",
+ newline_needed ? "\n" : "",
+ session.name);
+ newline_needed = false;
+ return CMD_ERROR;
}
- _MSG(".");
- fflush(stdout);
- break;
- case LTTNG_DESTRUCTION_HANDLE_STATUS_COMPLETED:
- break;
- default:
- ERR("%sFailed to wait for the completion of the destruction of session \"%s\"",
- newline_needed ? "\n" : "",
- session.name);
+ } while (status == LTTNG_DESTRUCTION_HANDLE_STATUS_TIMEOUT);
+
+ enum lttng_error_code ctl_ret_code;
+ status = lttng_destruction_handle_get_result(destruction_handle.get(),
+ &ctl_ret_code);
+ if (status != LTTNG_DESTRUCTION_HANDLE_STATUS_OK) {
+ ERR_FMT("{}Failed to query the result of the destruction of session `{}`",
+ newline_needed ? "\n" : "",
+ session.name);
+
newline_needed = false;
- ret = -1;
- goto error;
+ return CMD_ERROR;
}
- } while (status == LTTNG_DESTRUCTION_HANDLE_STATUS_TIMEOUT);
-
- status = lttng_destruction_handle_get_result(handle, &ret_code);
- if (status != LTTNG_DESTRUCTION_HANDLE_STATUS_OK) {
- ERR("%sFailed to get the result of session destruction",
- newline_needed ? "\n" : "");
- ret = -1;
- newline_needed = false;
- goto error;
- }
- if (ret_code != LTTNG_OK) {
- ret = -ret_code;
- goto error;
- }
- status = lttng_destruction_handle_get_rotation_state(handle, &rotation_state);
- if (status != LTTNG_DESTRUCTION_HANDLE_STATUS_OK) {
- ERR("%sFailed to get rotation state from destruction handle",
- newline_needed ? "\n" : "");
- newline_needed = false;
- goto skip_wait_rotation;
- }
-
- switch (rotation_state) {
- case LTTNG_ROTATION_STATE_NO_ROTATION:
- break;
- case LTTNG_ROTATION_STATE_COMPLETED:
- {
- const struct lttng_trace_archive_location *location;
+ if (ctl_ret_code != LTTNG_OK) {
+ LTTNG_THROW_CTL(fmt::format("Failed to destroy session `{}`", session.name),
+ ctl_ret_code);
+ }
- status = lttng_destruction_handle_get_archive_location(handle, &location);
- if (status == LTTNG_DESTRUCTION_HANDLE_STATUS_OK) {
- ret = print_trace_archive_location(location, session.name);
- if (ret) {
- ERR("%sFailed to print the location of trace archive",
- newline_needed ? "\n" : "");
+ enum lttng_rotation_state rotation_state;
+ status = lttng_destruction_handle_get_rotation_state(destruction_handle.get(),
+ &rotation_state);
+ if (status != LTTNG_DESTRUCTION_HANDLE_STATUS_OK) {
+ ERR_FMT("{}Failed to query the rotation state from the destruction handle of session `{}`",
+ newline_needed ? "\n" : "",
+ session.name);
+ newline_needed = false;
+ } else {
+ switch (rotation_state) {
+ case LTTNG_ROTATION_STATE_NO_ROTATION:
+ break;
+ case LTTNG_ROTATION_STATE_COMPLETED:
+ {
+ const struct lttng_trace_archive_location *location;
+
+ status = lttng_destruction_handle_get_archive_location(
+ destruction_handle.get(), &location);
+ if (status == LTTNG_DESTRUCTION_HANDLE_STATUS_OK) {
+ ret = print_trace_archive_location(location, session.name);
+ if (ret) {
+ ERR_FMT("{}Failed to print the location of the latest trace archive of session `{}`",
+ newline_needed ? "\n" : "",
+ session.name);
+ newline_needed = false;
+ }
+
+ break;
+ }
+ }
+ /* fall-through. */
+ default:
+ ERR_FMT("{}Failed to get the location of the rotation performed during the destruction of `{}`",
+ newline_needed ? "\n" : "",
+ session.name);
newline_needed = false;
- goto skip_wait_rotation;
+ break;
}
- break;
}
}
- /* fall-through. */
- default:
- ERR("%sFailed to get the location of the rotation performed during the session's destruction",
- newline_needed ? "\n" : "");
- newline_needed = false;
- goto skip_wait_rotation;
- }
-skip_wait_rotation:
- MSG("%sSession %s destroyed", newline_needed ? "\n" : "", session.name);
+
+ MSG("%sSession `%s` destroyed", newline_needed ? "\n" : "", session.name);
newline_needed = false;
if (stats_str) {
- MSG("%s", stats_str);
+ MSG("%s", stats_str.get());
}
- session_name = get_session_name_quiet();
- if (session_name && !strncmp(session.name, session_name, NAME_MAX)) {
+ /*
+ * If the session being destroy is the "default" session as defined in the .lttngrc file,
+ * destroy the file.
+ */
+ const auto session_name =
+ lttng::make_unique_wrapper<char, lttng::free>(get_session_name_quiet());
+ if (session_name && !strncmp(session.name, session_name.get(), NAME_MAX)) {
config_destroy_default();
}
if (lttng_opt_mi) {
ret = mi_lttng_session(writer, &session, 0);
if (ret) {
- ret = CMD_ERROR;
- goto error;
+ return CMD_ERROR;
}
}
- ret = CMD_SUCCESS;
-error:
- if (newline_needed) {
- MSG("");
- }
- lttng_destruction_handle_destroy(handle);
- free(session_name);
- free(stats_str);
- return ret;
+ return CMD_SUCCESS;
}
-cmd_error_code destroy_sessions(const struct session_spec& spec)
+cmd_error_code destroy_sessions(const session_spec& spec)
{
- //bool had_warning = false;
- //bool had_error = false;
+ bool had_warning = false;
+ bool had_error = false;
bool listing_failed = false;
const auto sessions = [&listing_failed, &spec]() -> session_list {
}
}();
- if (sessions.size() == 0) {
- switch (spec.type) {
- case session_spec::ALL:
- /* fall-through. */
- case session_spec::GLOB_PATTERN:
- MSG("No session found, nothing to do.");
- break;
- case session_spec::NAME:
- ERR("Session name %s not found", spec.value);
- return CMD_ERROR;
- }
+ if (!listing_failed && sessions.size() == 0 && spec.type == session_spec::type::NAME) {
+ ERR_FMT("Session `{}` not found", spec.value);
+ return CMD_ERROR;
+ }
+
+ if (listing_failed) {
+ return CMD_FATAL;
}
for (const auto& session : sessions) {
- int const sub_ret = destroy_session(session);
+ cmd_error_code sub_ret;
- if (sub_ret != CMD_SUCCESS) {
- ERR("%s during the destruction of session \"%s\"",
- lttng_strerror(sub_ret),
- session.name);
- return CMD_ERROR;
+ try {
+ sub_ret = destroy_session(session);
+ } catch (const lttng::ctl::error& ctl_exception) {
+ switch (ctl_exception.code()) {
+ case LTTNG_ERR_NO_SESSION:
+ if (spec.type != 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 destroy 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;
}
- return CMD_SUCCESS;
+ if (had_error) {
+ return CMD_ERROR;
+ } else if (had_warning) {
+ return CMD_WARNING;
+ } else {
+ return CMD_SUCCESS;
+ }
}
} /* namespace */
if (lttng_opt_mi) {
/* Close sessions and output element element */
if (mi_lttng_close_multi_element(writer, 2)) {
- command_ret = CMD_ERROR;
+ command_ret = CMD_ERROR;
goto end;
}
/* Success ? */
if (mi_lttng_writer_write_element_bool(
- writer, mi_lttng_element_command_success, success)) {
- command_ret = CMD_ERROR;
+ writer, mi_lttng_element_command_success, success)) {
+ command_ret = CMD_ERROR;
goto end;
}
/* Command element close */
if (mi_lttng_writer_command_close(writer)) {
- command_ret = CMD_ERROR;
+ command_ret = CMD_ERROR;
goto end;
}
}
projects / lttng-tools.git / commitdiff
