X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng%2Fcommands%2Fdestroy.c;h=be0261d11b760b67561b52d324334c35f39162e7;hp=95343c9c9a883513dd2741e5a1cb68acb2e612a3;hb=3285a971b225891df3dc7c2796176ce1f94665fe;hpb=6c1c0768320135c6936c371b09731851b508c023 diff --git a/src/bin/lttng/commands/destroy.c b/src/bin/lttng/commands/destroy.c index 95343c9c9..be0261d11 100644 --- a/src/bin/lttng/commands/destroy.c +++ b/src/bin/lttng/commands/destroy.c @@ -15,7 +15,6 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE #define _LGPL_SOURCE #include #include @@ -24,14 +23,24 @@ #include #include #include +#include +#include #include "../command.h" #include #include +#include static char *opt_session_name; static int opt_destroy_all; +static int opt_no_wait; + +#ifdef LTTNG_EMBED_HELP +static const char help_msg[] = +#include +; +#endif /* Mi writer */ static struct mi_writer *writer; @@ -46,26 +55,10 @@ static struct poptOption long_options[] = { {"help", 'h', POPT_ARG_NONE, 0, OPT_HELP, 0, 0}, {"all", 'a', POPT_ARG_VAL, &opt_destroy_all, 1, 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} }; -/* - * usage - */ -static void usage(FILE *ofp) -{ - fprintf(ofp, "usage: lttng destroy [NAME] [OPTIONS]\n"); - fprintf(ofp, "\n"); - fprintf(ofp, "Where NAME is an optional session name. If not specified, lttng will\n"); - fprintf(ofp, "get it from the configuration directory (.lttng).\n"); - fprintf(ofp, "\n"); - fprintf(ofp, "Options:\n"); - fprintf(ofp, " -h, --help Show this help\n"); - fprintf(ofp, " -a, --all Destroy all sessions\n"); - fprintf(ofp, " --list-options Simple listing of options\n"); - fprintf(ofp, "\n"); -} - /* * destroy_session * @@ -75,22 +68,140 @@ static void usage(FILE *ofp) static int destroy_session(struct lttng_session *session) { int ret; + char *session_name = NULL; + bool session_was_stopped; + enum lttng_error_code ret_code; + struct lttng_destruction_handle *handle = NULL; + enum lttng_destruction_handle_status status; + bool printed_wait_msg = false; + enum lttng_rotation_state rotation_state; + + ret = lttng_stop_tracing_no_wait(session->name); + if (ret < 0 && ret != -LTTNG_ERR_TRACE_ALREADY_STOPPED) { + ERR("%s", lttng_strerror(ret)); + } + session_was_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; + } + + /* + * Data sleep time before retrying (in usec). Don't sleep if the call + * returned value indicates availability. + */ + if (ret) { + if (!printed_wait_msg) { + _MSG("Waiting for destruction of session \"%s\"", + session->name); + printed_wait_msg = true; + fflush(stdout); + } - ret = lttng_destroy_session(session->name); - if (ret < 0) { - switch (-ret) { - case LTTNG_ERR_SESS_NOT_FOUND: - WARN("Session name %s not found", session->name); + usleep(DEFAULT_DATA_AVAILABILITY_WAIT_TIME_US); + _MSG("."); + fflush(stdout); + } + } while (ret != 0); + } + if (!session_was_stopped) { + /* + * Don't print the event and packet loss warnings since the user + * already saw them when stopping the trace. + */ + print_session_stats(session->name); + } + + ret_code = lttng_destroy_session_ext(session->name, &handle); + if (ret_code != LTTNG_OK) { + ret = -ret_code; + goto error; + } + + if (opt_no_wait) { + goto skip_wait_rotation; + } + + 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_wait_msg) { + _MSG("Waiting for destruction of session \"%s\"", + session->name); + printed_wait_msg = true; + } + _MSG("."); + fflush(stdout); break; - default: - ERR("%s", lttng_strerror(ret)); + case LTTNG_DESTRUCTION_HANDLE_STATUS_COMPLETED: break; + default: + ERR("Failed to wait for the completion of the destruction of session \"%s\"", + session->name); + ret = -1; + goto 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("Failed to get the result of session destruction"); + ret = -1; + goto error; + } + if (ret_code != LTTNG_OK) { + ret = -ret_code; goto error; } - MSG("Session %s destroyed", session->name); - config_destroy_default(); + status = lttng_destruction_handle_get_rotation_state(handle, + &rotation_state); + if (status != LTTNG_DESTRUCTION_HANDLE_STATUS_OK) { + ERR("Failed to get rotation state from destruction handle"); + 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; + + status = lttng_destruction_handle_get_archive_location(handle, + &location); + if (status == LTTNG_DESTRUCTION_HANDLE_STATUS_OK) { + if (printed_wait_msg) { + MSG(""); + printed_wait_msg = false; + } + ret = print_trace_archive_location(location, + session->name); + if (ret) { + ERR("Failed to print the location of trace archive"); + goto skip_wait_rotation; + } + break; + } + /* fall-through. */ + } + default: + ERR("Failed to get the location of the rotation performed during the session's destruction"); + goto skip_wait_rotation; + } +skip_wait_rotation: + MSG("%sSession \"%s\" destroyed", printed_wait_msg ? "\n" : "", + session->name); + printed_wait_msg = false; + + session_name = get_session_name_quiet(); + if (session_name && !strncmp(session->name, session_name, NAME_MAX)) { + config_destroy_default(); + } if (lttng_opt_mi) { ret = mi_lttng_session(writer, session, 0); @@ -102,6 +213,11 @@ static int destroy_session(struct lttng_session *session) ret = CMD_SUCCESS; error: + if (printed_wait_msg) { + MSG(""); + } + lttng_destruction_handle_destroy(handle); + free(session_name); return ret; } @@ -112,23 +228,27 @@ error: */ static int destroy_all_sessions(struct lttng_session *sessions, int count) { - int i, ret = CMD_SUCCESS; + int i; + bool error_occurred = false; + assert(count >= 0); if (count == 0) { MSG("No session found, nothing to do."); - } else if (count < 0) { - ERR("%s", lttng_strerror(ret)); - goto error; } for (i = 0; i < count; i++) { - ret = destroy_session(&sessions[i]); + int ret = destroy_session(&sessions[i]); + if (ret < 0) { - goto error; + ERR("%s during the destruction of session \"%s\"", + lttng_strerror(ret), + sessions[i].name); + /* Continue to next session. */ + error_occurred = true; } } -error: - return ret; + + return error_occurred ? CMD_ERROR : CMD_SUCCESS; } /* @@ -140,6 +260,7 @@ int cmd_destroy(int argc, const char **argv) int ret = CMD_SUCCESS , i, command_ret = CMD_SUCCESS, success = 1; static poptContext pc; char *session_name = NULL; + const char *leftover = NULL; struct lttng_session *sessions; int count; @@ -151,13 +272,12 @@ int cmd_destroy(int argc, const char **argv) while ((opt = poptGetNextOpt(pc)) != -1) { switch (opt) { case OPT_HELP: - usage(stdout); + SHOW_HELP(); break; case OPT_LIST_OPTIONS: list_cmd_options(stdout, long_options); break; default: - usage(stderr); ret = CMD_UNDEFINED; break; } @@ -199,7 +319,8 @@ int cmd_destroy(int argc, const char **argv) /* Recuperate all sessions for further operation */ count = lttng_list_sessions(&sessions); if (count < 0) { - command_ret = count; + ERR("%s", lttng_strerror(count)); + command_ret = CMD_ERROR; success = 0; goto mi_closing; } @@ -213,7 +334,7 @@ int cmd_destroy(int argc, const char **argv) } else { opt_session_name = (char *) poptGetArg(pc); - if (opt_session_name == NULL) { + if (!opt_session_name) { /* No session name specified, lookup default */ session_name = get_session_name(); if (session_name == NULL) { @@ -233,8 +354,10 @@ int cmd_destroy(int argc, const char **argv) command_ret = destroy_session(&sessions[i]); if (command_ret) { success = 0; + ERR("%s during the destruction of session \"%s\"", + lttng_strerror(command_ret), + sessions[i].name); } - } } @@ -246,6 +369,14 @@ int cmd_destroy(int argc, const char **argv) } } + leftover = poptGetArg(pc); + if (leftover) { + ERR("Unknown argument: %s", leftover); + ret = CMD_ERROR; + success = 0; + goto mi_closing; + } + mi_closing: /* Mi closing */ if (lttng_opt_mi) {