Clean-up: lttng: check status returned when checking rotation state

[lttng-tools.git] / src / bin / lttng / commands / destroy.c

diff --git a/src/bin/lttng/commands/destroy.c b/src/bin/lttng/commands/destroy.c
index aad4bdd23f07db2ac8a9b53eaab6044a0abdf54e..cac1e96fd8d1f9655f67adf084833880673027a8 100644 (file)
--- a/src/bin/lttng/commands/destroy.c
+++ b/src/bin/lttng/commands/destroy.c
@@ -24,6 +24,7 @@
 #include <sys/types.h>
 #include <unistd.h>
 #include <stdbool.h>
+#include <lttng/lttng.h>
 
 #include "../command.h"
 
@@ -35,6 +36,12 @@ 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 <lttng-destroy.1.h>
+;
+#endif
+
 /* Mi writer */
 static struct mi_writer *writer;
 
@@ -63,6 +70,11 @@ 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) {
@@ -70,8 +82,6 @@ static int destroy_session(struct lttng_session *session)
        }
        session_was_stopped = ret == -LTTNG_ERR_TRACE_ALREADY_STOPPED;
        if (!opt_no_wait) {
-               _MSG("Waiting for data availability");
-               fflush(stdout);
                do {
                        ret = lttng_data_pending(session->name);
                        if (ret < 0) {
@@ -84,12 +94,18 @@ static int destroy_session(struct lttng_session *session)
                         * returned value indicates availability.
                         */
                        if (ret) {
-                               usleep(DEFAULT_DATA_AVAILABILITY_WAIT_TIME);
+                               if (!printed_wait_msg) {
+                                       _MSG("Waiting for destruction of session \"%s\"",
+                                                       session->name);
+                                       printed_wait_msg = true;
+                                       fflush(stdout);
+                               }
+
+                               usleep(DEFAULT_DATA_AVAILABILITY_WAIT_TIME_US);
                                _MSG(".");
                                fflush(stdout);
                        }
                } while (ret != 0);
-               MSG("");
        }
        if (!session_was_stopped) {
                /*
@@ -99,12 +115,88 @@ static int destroy_session(struct lttng_session *session)
                print_session_stats(session->name);
        }
 
-       ret = lttng_destroy_session_no_wait(session->name);
-       if (ret < 0) {
+       ret_code = lttng_destroy_session_ext(session->name, &handle);
+       if (ret_code != LTTNG_OK) {
+               ret = -ret_code;
                goto error;
        }
 
-       MSG("Session %s destroyed", session->name);
+       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;
+               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 = -LTTNG_OK;
+               goto error;
+       }
+
+       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)) {
@@ -121,6 +213,10 @@ 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;
 }
@@ -160,6 +256,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;
@@ -218,7 +315,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;
        }
@@ -265,6 +363,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) {