The command line and API interface to the lttng rotate command.
Signed-off-by: Julien Desfossez <jdesfossez@efficios.com>
Signed-off-by: Jérémie Galarneau <jeremie.galarneau@efficios.com>
LTTNG_ERR_ROTATION_SIZE_IS_SET = 132, /* Rotate size already setup for this session. */
LTTNG_ERR_ROTATION_MULTIPLE_AFTER_STOP = 133, /* Already rotated once after a stop. */
LTTNG_ERR_ROTATION_WRONG_VERSION = 134, /* Rotate not supported by this kernel tracer version */
+ LTTNG_ERR_NO_SESSION_OUTPUT = 135, /* Session has no output configured. */
/* MUST be last element */
LTTNG_ERR_NR, /* Last element */
#include <limits.h>
#include <stdint.h>
+#include <stdbool.h>
#include <lttng/constant.h>
#include <lttng/rotation.h>
#include <common/macros.h>
+/*
+ * Object used as input parameter to the rotate session API for immediate
+ * rotations.
+ * This is opaque to the public library.
+ */
+struct lttng_rotation_immediate_attr {
+ /* Session name to rotate. */
+ char session_name[LTTNG_NAME_MAX];
+ /* For the rotate pending request. */
+ uint64_t rotate_id;
+};
+
+/*
+ * Object returned by the rotate session API.
+ * This is opaque to the public library.
+ */
+struct lttng_rotation_handle {
+ char session_name[LTTNG_NAME_MAX];
+ /*
+ * ID of the rotate command.
+ * This matches the session->rotate_count, so the handle is valid until
+ * the next rotate command. After that, the rotation_get_state command
+ * returns the "expired" state.
+ */
+ uint64_t rotation_id;
+ /*
+ * Where the rotated (readable) trace has been stored when the
+ * rotation is completed.
+ */
+ struct {
+ bool is_set;
+ char path[LTTNG_PATH_MAX];
+ } archive_location;
+};
+
/*
* Internal objects between lttng-ctl and the session daemon, the values
- * are then copied to the user's lttng_rotate_session_handle object.
+ * are then copied to the user's lttng_rotation_handle object.
*/
+
/* For the LTTNG_ROTATE_SESSION command. */
struct lttng_rotate_session_return {
- uint64_t rotate_id;
- /* Represents values defined in enum lttng_rotation_status. */
+ uint64_t rotation_id;
+} LTTNG_PACKED;
+
+/* For the LTTNG_ROTATION_GET_INFO command. */
+struct lttng_rotation_get_info_return {
+ /* Represents values defined in enum lttng_rotation_state. */
int32_t status;
+ char path[LTTNG_PATH_MAX];
+} LTTNG_PACKED;
+
+/* For the LTTNG_SESSION_GET_CURRENT_OUTPUT command. */
+struct lttng_session_get_current_output_return {
+ char path[LTTNG_PATH_MAX];
} LTTNG_PACKED;
#endif /* LTTNG_ROTATE_INTERNAL_ABI_H */
/*
* Copyright (C) 2017 - Julien Desfossez <jdesfossez@efficios.com>
+ * Copyright (C) 2018 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License, version 2.1 only,
#endif
/*
- * Return codes for lttng_rotate_session_get_output_path.
+ * Return codes for lttng_rotation_handle_get_state()
*/
-enum lttng_rotation_status {
- /*
- * After starting a rotation.
- */
- LTTNG_ROTATION_STATUS_STARTED = 0,
+enum lttng_rotation_state {
/*
- * When the rotation is complete.
+ * Rotation is ongoing, but has not been completed yet.
*/
- LTTNG_ROTATION_STATUS_COMPLETED = 1,
+ LTTNG_ROTATION_STATE_ONGOING = 0,
/*
- * If the handle does not match the last rotate command, we cannot
- * retrieve the path for the chunk.
+ * Rotation has been completed and the resulting chunk
+ * can now safely be read.
*/
- LTTNG_ROTATION_STATUS_EXPIRED = 2,
+ LTTNG_ROTATION_STATE_COMPLETED = 1,
/*
- * On error.
+ * The rotation has expired.
+ *
+ * The information associated with a given rotation is eventually
+ * purged by the session daemon. In such a case, the attributes of
+ * the rotation, such as its path, may no longer be available.
+ *
+ * Note that this state does not guarantee the the rotation was
+ * completed successfully.
*/
- LTTNG_ROTATION_STATUS_ERROR = 3,
+ LTTNG_ROTATION_STATE_EXPIRED = 2,
/*
- * If no rotation occured during this session.
+ * The rotation could not be completed due to an error.
*/
- LTTNG_ROTATION_STATUS_NO_ROTATION = 4,
+ LTTNG_ROTATION_STATE_ERROR = 3,
+};
+
+enum lttng_rotation_status {
+ LTTNG_ROTATION_STATUS_OK = 0,
+ /* Information not available. */
+ LTTNG_ROTATION_STATUS_UNAVAILABLE = 1,
+ /* Generic error. */
+ LTTNG_ROTATION_STATUS_ERROR = -1,
+ /* Invalid parameters provided. */
+ LTTNG_ROTATION_STATUS_INVALID = -2,
};
+/*
+ * Input parameter to the lttng_rotate_session command.
+ *
+ * An immediate rotation is performed as soon as possible by the tracers.
+ *
+ * The lttng_rotation_immediate_attr object is opaque to the user. Use the
+ * helper functions below to access it.
+ */
+struct lttng_rotation_immediate_attr;
+
+/*
+ * Handle used to represent a specific rotation.
+ *
+ * This object is opaque to the user. Use the helper functions below to access
+ * it.
+ */
+struct lttng_rotation_handle;
+
+/*
+ * Return a newly allocated immediate session rotation descriptor object or NULL
+ * on error.
+ */
+extern struct lttng_rotation_immediate_attr *
+lttng_rotation_immediate_attr_create(void);
+
+/*
+ * Destroy a given immediate session rotation descriptor object.
+ */
+extern void lttng_rotation_immediate_attr_destroy(
+ struct lttng_rotation_immediate_attr *attr);
+
+/*
+ * Set the name of the session to rotate immediately.
+ *
+ * The session_name parameter is copied to the immediate session rotation
+ * attributes.
+ */
+extern enum lttng_rotation_status lttng_rotation_immediate_attr_set_session_name(
+ struct lttng_rotation_immediate_attr *attr,
+ const char *session_name);
+
+/*
+ * Get the current state of the rotation referenced by the handle.
+ *
+ * This will issue a request to the session daemon on every call. Hence,
+ * the result of this call may change over time.
+ */
+extern enum lttng_rotation_status lttng_rotation_handle_get_state(
+ struct lttng_rotation_handle *rotation_handle,
+ enum lttng_rotation_state *rotation_state);
+
+/*
+ * Get the location of the rotation's resulting archive.
+ *
+ * The rotation must be completed in order for this call to succeed.
+ * The path returned is owned by the rotation handle.
+ *
+ * Note that path will not be set in case of error, or if the session
+ * rotation has expired.
+ *
+ * FIXME: Return an lttng_location object instead of a path.
+ */
+extern enum lttng_rotation_status lttng_rotation_handle_get_completed_archive_location(
+ struct lttng_rotation_handle *rotation_handle,
+ const char **path);
+
+/*
+ * Destroy an lttng_rotate_session handle.
+ */
+extern void lttng_rotation_handle_destroy(
+ struct lttng_rotation_handle *rotation_handle);
+
+/*
+ * Rotate the output folder of the session
+ *
+ * On success, handle is allocated and can be used to monitor the progress
+ * of the rotation with lttng_rotation_get_state(). The handle must be freed
+ * by the caller with lttng_rotation_handle_destroy().
+ *
+ * Return 0 if the rotate action was successfully launched or a negative
+ * LTTng error code on error.
+ */
+extern int lttng_rotate_session(struct lttng_rotation_immediate_attr *attr,
+ struct lttng_rotation_handle **rotation_handle);
+
#ifdef __cplusplus
}
#endif
extern int lttng_list_tracker_pids(struct lttng_handle *handle,
int *enabled, int32_t **pids, size_t *nr_pids);
+/*
+ * Ask the session daemon where the data for this session is currently being
+ * written to. If rotations occured during a session, this call is useful to
+ * know the location of the last chunk.
+ *
+ * Return 0 and allocate chunk_path if rotations occured for this session, the
+ * caller needs to free chunk_path.
+ * Return 1 if no rotation occured during the session, chunk_path is left
+ * unallocated.
+ *
+ * Return a negative LTTng error code on error (readable with lttng_strerror).
+ *
+ * FIXME: Return an lttng_location object rather than a path.
+ */
+extern int lttng_session_get_current_archive_location(const char *session_name,
+ char **chunk_path);
+
#ifdef __cplusplus
}
#endif
if (!session->has_been_started) {
ret = -LTTNG_ERR_START_SESSION_ONCE;
- goto error;
+ goto end;
}
if (session->live_timer || session->snapshot_mode ||
!session->output_traces) {
ret = -LTTNG_ERR_ROTATION_NOT_AVAILABLE;
- goto error;
+ goto end;
}
/*
(session->consumer->relay_major_version == 2 &&
session->consumer->relay_minor_version < 11)) {
ret = -LTTNG_ERR_ROTATION_NOT_AVAILABLE;
- goto error;
+ goto end;
}
if (session->rotate_pending || session->rotate_pending_relay) {
ret = -LTTNG_ERR_ROTATION_PENDING;
DBG("Rotate already in progress");
- goto error;
+ goto end;
}
/*
DBG("Session \"%s\" was already rotated after stop, refusing rotation",
session->name);
ret = -LTTNG_ERR_ROTATION_MULTIPLE_AFTER_STOP;
- goto error;
+ goto end;
}
/* Special case for the first rotation. */
if (ret) {
ERR("Failed to copy session base path to current rotation chunk path");
ret = -LTTNG_ERR_UNK;
- goto error;
+ goto end;
}
} else {
/*
if (ret) {
ERR("Failed to copy the active tracing path to the current rotate path");
ret = -LTTNG_ERR_UNK;
- goto error;
+ goto end;
}
}
DBG("Current rotate path %s", session->rotation_chunk.current_rotate_path);
session->rotate_count++;
session->rotate_pending = true;
- session->rotation_status = LTTNG_ROTATION_STATUS_STARTED;
+ session->rotation_state = LTTNG_ROTATION_STATE_ONGOING;
/*
* Create the path name for the next chunk.
now = time(NULL);
if (now == (time_t) -1) {
ret = -LTTNG_ERR_ROTATION_NOT_AVAILABLE;
- goto error;
+ goto end;
}
session->last_chunk_start_ts = session->current_chunk_start_ts;
session->current_chunk_start_ts = now;
if (!timeinfo) {
PERROR("Failed to sample local time in rotate session command");
ret = -LTTNG_ERR_UNK;
- goto error;
+ goto end;
}
strf_ret = strftime(datetime, sizeof(datetime), "%Y%m%d-%H%M%S",
timeinfo);
if (!strf_ret) {
ERR("Failed to format local time timestamp in rotate session command");
ret = -LTTNG_ERR_UNK;
- goto error;
+ goto end;
}
if (session->kernel_session) {
/*
if (ret < 0 || ret == sizeof(session->rotation_chunk.active_tracing_path)) {
ERR("Failed to format active kernel tracing path in rotate session command");
ret = -LTTNG_ERR_UNK;
- goto error;
+ goto end;
}
/*
* The sub-directory for the consumer
if (ret < 0 || ret == sizeof(session->kernel_session->consumer->chunk_path)) {
ERR("Failed to format the kernel consumer's sub-directory in rotate session command");
ret = -LTTNG_ERR_UNK;
- goto error;
+ goto end;
}
/*
* Create the new chunk folder, before the rotation begins so we don't
session->kernel_session->gid);
if (ret) {
ERR("Failed to create kernel session tracing path at %s",
- session->kernel_session->chunk_path);
- goto error;
+ session->kernel_session->consumer->chunk_path);
+ ret = -LTTNG_ERR_CREATE_DIR_FAIL;
+ goto end;
}
ret = kernel_rotate_session(session);
if (ret != LTTNG_OK) {
- goto error;
+ ret = -ret;
+ goto end;
}
}
if (session->ust_session) {
if (ret < 0) {
ERR("Failed to format active UST tracing path in rotate session command");
ret = -LTTNG_ERR_UNK;
- goto error;
+ goto end;
}
ret = snprintf(session->ust_session->consumer->chunk_path,
PATH_MAX, "/%s-%" PRIu64, datetime,
if (ret < 0) {
ERR("Failed to format the UST consumer's sub-directory in rotate session command");
ret = -LTTNG_ERR_UNK;
- goto error;
+ goto end;
}
/*
* Create the new chunk folder, before the rotation begins so we don't
session->ust_session->gid);
ret = ust_app_rotate_session(session, &ust_active);
if (ret != LTTNG_OK) {
- goto error;
+ ret = -LTTNG_ERR_CREATE_DIR_FAIL;
+ goto end;
}
/*
* Handle the case where we did not start a rotation on any channel.
goto end;
}
session->rotate_pending = false;
- session->rotation_status = LTTNG_ROTATION_STATUS_COMPLETED;
+ session->rotation_state = LTTNG_ROTATION_STATE_COMPLETED;
}
}
}
if (rotate_return) {
- (*rotate_return)->rotate_id = session->rotate_count;
- (*rotate_return)->status = LTTNG_ROTATION_STATUS_STARTED;
+ rotate_return->rotation_id = session->rotate_count;
}
-
DBG("Cmd rotate session %s, rotate_id %" PRIu64 " completed", session->name,
session->rotate_count);
ret = LTTNG_OK;
- goto end;
-
-error:
- if (rotate_return) {
- (*rotate_return)->status = LTTNG_ROTATION_STATUS_ERROR;
- }
end:
return ret;
}
/*
- * Command LTTNG_ROTATE_PENDING from the lttng-ctl library.
+ * Command LTTNG_ROTATION_GET_INFO from the lttng-ctl library.
*
* Check if the session has finished its rotation.
*
* Return 0 on success or else a LTTNG_ERR code.
*/
-int cmd_rotate_pending(struct ltt_session *session,
- struct lttng_rotate_pending_return **pending_return,
- uint64_t rotate_id)
+int cmd_rotate_get_info(struct ltt_session *session,
+ struct lttng_rotation_get_info_return *info_return,
+ uint64_t rotation_id)
{
int ret;
assert(session);
- DBG("Cmd rotate pending session %s, rotate_id %" PRIu64, session->name,
+ DBG("Cmd rotate_get_info session %s, rotation id %" PRIu64, session->name,
session->rotate_count);
- *pending_return = zmalloc(sizeof(struct lttng_rotate_pending_return));
- if (!*pending_return) {
- ret = -ENOMEM;
- goto end;
- }
-
- if (session->rotate_count != rotate_id) {
- (*pending_return)->status = LTTNG_ROTATION_STATUS_EXPIRED;
+ if (session->rotate_count != rotation_id) {
+ info_return->status = (int32_t) LTTNG_ROTATION_STATE_EXPIRED;
ret = LTTNG_OK;
goto end;
}
- if (session->rotation_status == LTTNG_ROTATION_STATUS_ERROR) {
- DBG("An error occurred during rotation");
- (*pending_return)->status = LTTNG_ROTATION_STATUS_ERROR;
- /* Rotate with a relay */
- } else if (session->rotate_pending_relay) {
- DBG("Session %s, rotate_id %" PRIu64 " still pending",
- session->name, session->rotate_count);
- (*pending_return)->status = LTTNG_ROTATION_STATUS_STARTED;
- } else if (session->rotate_pending) {
- DBG("Session %s, rotate_id %" PRIu64 " still pending",
- session->name, session->rotate_count);
- (*pending_return)->status = LTTNG_ROTATION_STATUS_STARTED;
- } else {
- DBG("Session %s, rotate_id %" PRIu64 " finished",
- session->name, session->rotate_count);
- (*pending_return)->status = LTTNG_ROTATION_STATUS_COMPLETED;
- ret = lttng_strncpy((*pending_return)->output_path,
+ switch (session->rotation_state) {
+ case LTTNG_ROTATION_STATE_ONGOING:
+ DBG("Reporting that rotation id %" PRIu64 " of session %s is still pending",
+ rotation_id, session->name);
+ break;
+ case LTTNG_ROTATION_STATE_COMPLETED:
+ ret = lttng_strncpy(info_return->path,
session->rotation_chunk.current_rotate_path,
- sizeof((*pending_return)->output_path));
+ sizeof(info_return->path));
if (ret) {
- ERR("Failed to copy active tracing path to rotate pending command reply");
- (*pending_return)->status = LTTNG_ROTATION_STATUS_ERROR;
- ret = -1;
+ ERR("Failed to copy active tracing path to rotate_get_info reply");
+ info_return->status = LTTNG_ROTATION_STATUS_ERROR;
+ ret = -LTTNG_ERR_UNK;
goto end;
}
+ break;
+ case LTTNG_ROTATION_STATE_ERROR:
+ DBG("Reporting that an error occurred during rotation %" PRIu64 " of session %s",
+ rotation_id, session->name);
+ break;
+ default:
+ abort();
}
+ info_return->status = (int32_t) session->rotation_state;
ret = LTTNG_OK;
-
- goto end;
-
end:
return ret;
}
*
* Return LTTNG_OK on success or else a LTTNG_ERR code.
*/
-int cmd_rotate_get_current_path(struct ltt_session *session,
- struct lttng_rotate_get_current_path **get_return)
+int cmd_session_get_current_output(struct ltt_session *session,
+ struct lttng_session_get_current_output_return *output_return)
{
int ret;
+ const char *path;
- *get_return = zmalloc(sizeof(struct lttng_rotate_get_current_path));
- if (!*get_return) {
- ret = -ENOMEM;
- goto end;
+ if (!session->snapshot_mode) {
+ if (session->rotate_count == 0) {
+ if (session->kernel_session) {
+ path = session_get_base_path(session);
+ } else if (session->ust_session) {
+ path = session_get_base_path(session);
+ } else {
+ abort();
+ }
+ assert(path);
+ } else {
+ path = session->rotation_chunk.active_tracing_path;
+ }
+ } else {
+ /*
+ * A snapshot session does not have a "current" trace archive
+ * location.
+ */
+ path = "";
}
- if (session->rotate_count == 0) {
- (*get_return)->status = LTTNG_ROTATION_STATUS_NO_ROTATION;
- } else {
- (*get_return)->status = session->rotation_status;
- ret = lttng_strncpy((*get_return)->output_path,
- session->rotation_chunk.current_rotate_path,
- sizeof((*get_return)->output_path));
- if (ret) {
- ERR("Failed to copy trace output path to rotate get current path command reply");
- ret = -1;
- goto end;
- }
+ DBG("Cmd get current output for session %s, returning %s",
+ session->name, path);
+
+ ret = lttng_strncpy(output_return->path,
+ path,
+ sizeof(output_return->path));
+ if (ret) {
+ ERR("Failed to copy trace output path to session get current output command reply");
+ ret = -LTTNG_ERR_UNK;
+ goto end;
}
ret = LTTNG_OK;
-
end:
return ret;
}
int cmd_rotate_session(struct ltt_session *session,
struct lttng_rotate_session_return *rotate_return);
+int cmd_rotate_get_info(struct ltt_session *session,
+ struct lttng_rotation_get_info_return *info_return,
+ uint64_t rotate_id);
+int cmd_session_get_current_output(struct ltt_session *session,
+ struct lttng_session_get_current_output_return *output_return);
#endif /* CMD_H */
assert(socket);
- DBG("Consumer rotate pending on relay for session %" PRIu64 ", chunk id % " PRIu64,
+ DBG("Consumer rotate pending on relay for session %" PRIu64 ", chunk id %" PRIu64,
session_id, chunk_id);
assert(output->type == CONSUMER_DST_NET);
case LTTNG_REGISTER_TRIGGER:
case LTTNG_UNREGISTER_TRIGGER:
case LTTNG_ROTATE_SESSION:
- case LTTNG_ROTATE_PENDING:
- case LTTNG_ROTATE_GET_CURRENT_PATH:
+ case LTTNG_ROTATION_GET_INFO:
+ case LTTNG_SESSION_GET_CURRENT_OUTPUT:
need_domain = 0;
break;
default:
case LTTNG_LIST_TRACKER_PIDS:
case LTTNG_DATA_PENDING:
case LTTNG_ROTATE_SESSION:
- case LTTNG_ROTATE_PENDING:
+ case LTTNG_ROTATION_GET_INFO:
break;
default:
/* Setup lttng message with no payload */
DBG("Client rotate session \"%s\"", cmd_ctx->session->name);
+ memset(&rotate_return, 0, sizeof(rotate_return));
if (cmd_ctx->session->kernel_session && !check_rotate_compatible()) {
DBG("Kernel tracer version is not compatible with the rotation feature");
ret = LTTNG_ERR_ROTATION_WRONG_VERSION;
ret = LTTNG_OK;
break;
}
- case LTTNG_ROTATE_PENDING:
+ case LTTNG_ROTATION_GET_INFO:
{
- struct lttng_rotate_pending_return *pending_return = NULL;
+ struct lttng_rotation_get_info_return get_info_return;
- ret = cmd_rotate_pending(cmd_ctx->session, &pending_return,
- cmd_ctx->lsm->u.rotate_pending.rotate_id);
+ memset(&get_info_return, 0, sizeof(get_info_return));
+ ret = cmd_rotate_get_info(cmd_ctx->session, &get_info_return,
+ cmd_ctx->lsm->u.get_rotation_info.rotation_id);
if (ret < 0) {
ret = -ret;
goto error;
}
- ret = setup_lttng_msg_no_cmd_header(cmd_ctx, pending_return,
- sizeof(struct lttng_rotate_session_handle));
- free(pending_return);
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &get_info_return,
+ sizeof(get_info_return));
if (ret < 0) {
ret = -ret;
goto error;
ret = LTTNG_OK;
break;
}
- case LTTNG_ROTATE_GET_CURRENT_PATH:
+ case LTTNG_SESSION_GET_CURRENT_OUTPUT:
{
- struct lttng_rotate_get_current_path *get_return = NULL;
+ struct lttng_session_get_current_output_return output_return;
- ret = cmd_rotate_get_current_path(cmd_ctx->session, &get_return);
+ memset(&output_return, 0, sizeof(output_return));
+ ret = cmd_session_get_current_output(cmd_ctx->session,
+ &output_return);
if (ret < 0) {
ret = -ret;
goto error;
}
- ret = setup_lttng_msg_no_cmd_header(cmd_ctx, get_return,
- sizeof(struct lttng_rotate_get_current_path));
- free(get_return);
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &output_return,
+ sizeof(output_return));
if (ret < 0) {
ret = -ret;
goto error;
goto end;
error:
- session->rotation_status = LTTNG_ROTATION_STATUS_ERROR;
+ session->rotation_state = LTTNG_ROTATION_STATE_ERROR;
end:
return ret;
}
time_t now = time(NULL);
if (now == (time_t) -1) {
- session->rotation_status = LTTNG_ROTATION_STATUS_ERROR;
+ session->rotation_state = LTTNG_ROTATION_STATE_ERROR;
ret = LTTNG_ERR_UNK;
goto end_unlock_session;
}
goto end_unlock_session;
}
session->rotate_pending = false;
- session->rotation_status = LTTNG_ROTATION_STATUS_COMPLETED;
+ session->rotation_state = LTTNG_ROTATION_STATE_COMPLETED;
session->last_chunk_start_ts = session->current_chunk_start_ts;
if (session->rotate_pending_relay) {
ret = sessiond_timer_rotate_pending_start(
* True until the relay has finished the rotation of all the streams.
*/
bool rotate_pending_relay;
- /* Current status of a rotation. */
- enum lttng_rotation_status rotation_status;
+ /* Current state of a rotation. */
+ enum lttng_rotation_state rotation_state;
/*
* Number of channels waiting for a rotation.
* When this number reaches 0, we can handle the rename of the chunk
commands/metadata.c \
commands/regenerate.c \
commands/help.c \
+ commands/rotate.c \
utils.c utils.h lttng.c
lttng_LDADD = $(top_builddir)/src/lib/lttng-ctl/liblttng-ctl.la \
DECL_COMMAND(untrack);
DECL_COMMAND(metadata);
DECL_COMMAND(regenerate);
+DECL_COMMAND(rotate);
extern int cmd_help(int argc, const char **argv,
const struct cmd_struct commands[]);
--- /dev/null
+/*
+ * Copyright (C) 2017 - Julien Desfossez <jdesfossez@efficios.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2 only,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#define _LGPL_SOURCE
+#include <popt.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <inttypes.h>
+#include <ctype.h>
+#include <assert.h>
+
+#include <common/sessiond-comm/sessiond-comm.h>
+#include <common/mi-lttng.h>
+
+#include "../command.h"
+#include <lttng/rotation.h>
+
+static char *opt_session_name;
+static int opt_no_wait;
+static struct mi_writer *writer;
+
+enum {
+ OPT_HELP = 1,
+ OPT_LIST_OPTIONS,
+};
+
+static 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}
+};
+
+static int mi_output_rotate(const char *status, const char *path,
+ const char *session_name)
+{
+ int ret;
+
+ if (!lttng_opt_mi) {
+ ret = 0;
+ goto end;
+ }
+
+ ret = mi_lttng_writer_open_element(writer,
+ mi_lttng_element_rotation);
+ if (ret) {
+ goto end;
+ }
+
+ ret = mi_lttng_writer_write_element_string(writer,
+ mi_lttng_element_session_name, session_name);
+ if (ret) {
+ goto end;
+ }
+
+ ret = mi_lttng_writer_write_element_string(writer,
+ mi_lttng_element_rotate_status, status);
+ if (ret) {
+ goto end;
+ }
+ if (path) {
+ ret = mi_lttng_writer_write_element_string(writer,
+ config_element_path, path);
+ if (ret) {
+ goto end;
+ }
+ }
+ /* Close rotation element */
+ ret = mi_lttng_writer_close_element(writer);
+ if (ret) {
+ goto end;
+ }
+
+end:
+ return ret;
+}
+
+static int rotate_tracing(char *session_name)
+{
+ int ret;
+ struct lttng_rotation_immediate_attr *attr = NULL;
+ struct lttng_rotation_handle *handle = NULL;
+ enum lttng_rotation_status rotation_status;
+ enum lttng_rotation_state rotation_state = LTTNG_ROTATION_STATE_ONGOING;
+
+ DBG("Rotating the output files of session %s", session_name);
+
+ attr = lttng_rotation_immediate_attr_create();
+ if (!attr) {
+ goto error;
+ }
+
+ ret = lttng_rotation_immediate_attr_set_session_name(attr, session_name);
+ if (ret < 0) {
+ ERR("Session name exceeds the maximal allowed length");
+ goto error;
+ }
+
+ ret = lttng_rotate_session(attr, &handle);
+ if (ret < 0) {
+ switch (-ret) {
+ case LTTNG_ERR_SESSION_NOT_STARTED:
+ WARN("Tracing session %s not started yet", session_name);
+ break;
+ default:
+ ERR("%s", lttng_strerror(ret));
+ break;
+ }
+ goto error;
+ }
+
+ if (!opt_no_wait) {
+ _MSG("Waiting for rotation to complete");
+ ret = fflush(stdout);
+ if (ret) {
+ PERROR("fflush");
+ goto error;
+ }
+
+ do {
+ rotation_status = lttng_rotation_handle_get_state(handle,
+ &rotation_state);
+ if (rotation_status != LTTNG_ROTATION_STATUS_OK) {
+ ERR("Failed to query the state of the rotation");
+ goto error;
+ }
+
+ /*
+ * Data sleep time before retrying (in usec). Don't
+ * sleep if the call returned value indicates
+ * availability.
+ */
+ if (rotation_state == LTTNG_ROTATION_STATE_ONGOING) {
+ ret = usleep(DEFAULT_DATA_AVAILABILITY_WAIT_TIME);
+ if (ret) {
+ PERROR("usleep");
+ goto error;
+ }
+ _MSG(".");
+
+ ret = fflush(stdout);
+ if (ret) {
+ PERROR("fflush");
+ goto error;
+ }
+ }
+ } while (rotation_state == LTTNG_ROTATION_STATE_ONGOING);
+ MSG("");
+ }
+
+ switch (rotation_state) {
+ case LTTNG_ROTATION_STATE_COMPLETED:
+ {
+ const char *path;
+
+ rotation_status = lttng_rotation_handle_get_completed_archive_location(
+ handle, &path);
+ if (rotation_status != LTTNG_ROTATION_STATUS_OK) {
+ ERR("Failed to retrieve the rotation's completed chunk archive location");
+ goto error;
+ }
+ MSG("Trace chunk archive for session %s is now readable at %s",
+ session_name, path);
+ ret = mi_output_rotate("completed", path, session_name);
+ if (ret) {
+ goto error;
+ }
+ ret = CMD_SUCCESS;
+ goto end;
+ }
+ case LTTNG_ROTATION_STATE_EXPIRED:
+ MSG("Session %s rotated, but handle expired", session_name);
+ ret = mi_output_rotate("expired", NULL, session_name);
+ if (ret) {
+ goto error;
+ }
+ ret = CMD_SUCCESS;
+ goto end;
+ default:
+ ERR("Unexpected rotation state received, aborting...");
+ goto error;
+ }
+
+error:
+ ret = CMD_ERROR;
+end:
+ lttng_rotation_handle_destroy(handle);
+ lttng_rotation_immediate_attr_destroy(attr);
+ return ret;
+}
+
+/*
+ * cmd_rotate
+ *
+ * The 'rotate <options>' first level command
+ */
+int cmd_rotate(int argc, const char **argv)
+{
+ int opt, ret = CMD_SUCCESS, command_ret = CMD_SUCCESS, success = 1;
+ int popt_ret;
+ static poptContext pc;
+ char *session_name = NULL;
+ bool free_session_name = false;
+
+ pc = poptGetContext(NULL, argc, argv, long_options, 0);
+ popt_ret = poptReadDefaultConfig(pc, 0);
+ if (popt_ret) {
+ ret = CMD_ERROR;
+ ERR("poptReadDefaultConfig");
+ goto end;
+ }
+
+ while ((opt = poptGetNextOpt(pc)) != -1) {
+ switch (opt) {
+ case OPT_HELP:
+ SHOW_HELP();
+ goto end;
+ case OPT_LIST_OPTIONS:
+ list_cmd_options(stdout, long_options);
+ goto end;
+ default:
+ ret = CMD_UNDEFINED;
+ goto end;
+ }
+ }
+
+ opt_session_name = (char*) poptGetArg(pc);
+
+ if (!opt_session_name) {
+ session_name = get_session_name();
+ if (!session_name) {
+ goto end;
+ }
+ free_session_name = true;
+ } else {
+ session_name = opt_session_name;
+ }
+
+ /* Mi check */
+ if (lttng_opt_mi) {
+ writer = mi_lttng_writer_create(fileno(stdout), lttng_opt_mi);
+ if (!writer) {
+ ret = -LTTNG_ERR_NOMEM;
+ goto end;
+ }
+
+ /* Open rotate command */
+ ret = mi_lttng_writer_command_open(writer,
+ mi_lttng_element_command_rotate);
+ if (ret) {
+ ret = CMD_ERROR;
+ goto end;
+ }
+
+ /* Open output element */
+ ret = mi_lttng_writer_open_element(writer,
+ mi_lttng_element_command_output);
+ if (ret) {
+ goto end;
+ }
+
+ /* Open rotations element */
+ ret = mi_lttng_writer_open_element(writer,
+ mi_lttng_element_rotations);
+ if (ret) {
+ goto end;
+ }
+
+ }
+
+ command_ret = rotate_tracing(session_name);
+ if (command_ret) {
+ success = 0;
+ }
+
+ /* Mi closing */
+ if (lttng_opt_mi) {
+ /* Close rotations element */
+ ret = mi_lttng_writer_close_element(writer);
+ if (ret) {
+ goto end;
+ }
+ /* Close output element */
+ ret = mi_lttng_writer_close_element(writer);
+ if (ret) {
+ 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;
+ }
+
+ /* Overwrite ret if an error occurred with start_tracing */
+ ret = command_ret ? command_ret : ret;
+ poptFreeContext(pc);
+ if (free_session_name) {
+ free(session_name);
+ }
+ return ret;
+}
{ "load", cmd_load},
{ "metadata", cmd_metadata},
{ "regenerate", cmd_regenerate},
+ { "rotate", cmd_rotate},
{ "save", cmd_save},
{ "set-session", cmd_set_session},
{ "snapshot", cmd_snapshot},
[ ERROR_INDEX(LTTNG_ERR_ROTATION_SIZE_IS_SET) ] = "Automatic rotation schedule with a size threshold condition already set for this session",
[ ERROR_INDEX(LTTNG_ERR_ROTATION_MULTIPLE_AFTER_STOP) ] = "Session was already rotated once since it became inactive",
[ ERROR_INDEX(LTTNG_ERR_ROTATION_WRONG_VERSION) ] = "Rotation feature is not supported by this kernel tracer version",
+ [ ERROR_INDEX(LTTNG_ERR_NO_SESSION_OUTPUT) ] = "Session has no output",
/* Last element */
[ ERROR_INDEX(LTTNG_ERR_NR) ] = "Unknown error code"
<xs:element name="targets" type="tns:targets_type" minOccurs="0" />
<xs:element name="metadata_action" type="tns:metadata_cmd_type" minOccurs="0" />
<xs:element name="regenerate_action" type="tns:regenerate_cmd_type" minOccurs="0" />
+ <xs:element name="rotations" type="tns:rotations_type" minOccurs="0" />
</xs:choice>
</xs:complexType>
<xs:enumeration value="untrack" />
<xs:enumeration value="metadata" />
<xs:enumeration value="regenerate" />
+ <xs:enumeration value="rotate" />
</xs:restriction>
</xs:simpleType>
const char * const mi_lttng_element_command_track = "track";
const char * const mi_lttng_element_command_untrack = "untrack";
const char * const mi_lttng_element_command_version = "version";
+const char * const mi_lttng_element_command_rotate = "rotate";
/* Strings related to version command */
const char * const mi_lttng_element_version = "version";
/* String related to track/untrack command */
const char * const mi_lttng_element_track_untrack_all_wildcard = "*";
+LTTNG_HIDDEN const char * const mi_lttng_element_session_name = "session_name";
+
+/* String related to rotate command */
+LTTNG_HIDDEN const char * const mi_lttng_element_rotation = "rotation";
+LTTNG_HIDDEN const char * const mi_lttng_element_rotations = "rotations";
+LTTNG_HIDDEN const char * const mi_lttng_element_rotate_status = "status";
+
/* Deprecated symbols preserved for ABI compatibility. */
const char * const mi_lttng_context_type_perf_counter;
const char * const mi_lttng_context_type_perf_cpu_counter;
extern const char * const mi_lttng_element_command_track;
extern const char * const mi_lttng_element_command_untrack;
extern const char * const mi_lttng_element_command_version;
+extern const char * const mi_lttng_element_command_rotate;
/* Strings related to version command */
extern const char * const mi_lttng_element_version;
/* String related to track/untrack command */
const char * const mi_lttng_element_track_untrack_all_wildcard;
+LTTNG_HIDDEN const char * const mi_lttng_element_session_name;
+
+/* String related to rotate command */
+LTTNG_HIDDEN const char * const mi_lttng_element_rotation;
+LTTNG_HIDDEN const char * const mi_lttng_element_rotations;
+LTTNG_HIDDEN const char * const mi_lttng_element_rotate_status;
+
/* Utility string function */
const char *mi_lttng_loglevel_string(int value, enum lttng_domain_type domain);
const char *mi_lttng_logleveltype_string(enum lttng_loglevel_type value);
LTTNG_REGISTER_TRIGGER = 43,
LTTNG_UNREGISTER_TRIGGER = 44,
LTTNG_ROTATE_SESSION = 45,
- LTTNG_ROTATE_PENDING = 46,
+ LTTNG_ROTATION_GET_INFO = 46,
+ LTTNG_SESSION_GET_CURRENT_OUTPUT = 48,
};
enum lttcomm_relayd_command {
uint32_t length;
} LTTNG_PACKED trigger;
struct {
- uint64_t rotate_id;
- } LTTNG_PACKED rotate_pending;
+ uint64_t rotation_id;
+ } LTTNG_PACKED get_rotation_info;
} u;
} LTTNG_PACKED;
liblttng_ctl_la_SOURCES = lttng-ctl.c snapshot.c lttng-ctl-helper.h \
lttng-ctl-health.c save.c load.c deprecated-symbols.c \
- channel.c
+ channel.c rotate.c
liblttng_ctl_la_LDFLAGS = \
$(LT_NO_UNDEFINED)
return ret;
}
+int lttng_session_get_current_archive_location(const char *session_name,
+ char **chunk_path)
+{
+ struct lttcomm_session_msg lsm;
+ struct lttng_session_get_current_output_return *output_return = NULL;
+ int ret;
+ size_t path_len;
+
+ memset(&lsm, 0, sizeof(lsm));
+ lsm.cmd_type = LTTNG_SESSION_GET_CURRENT_OUTPUT;
+ ret = lttng_strncpy(lsm.session.name, session_name,
+ sizeof(lsm.session.name));
+ if (ret) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
+
+ ret = lttng_ctl_ask_sessiond(&lsm, (void **) &output_return);
+ if (ret < 0) {
+ ret = -1;
+ goto end;
+ }
+
+ path_len = lttng_strnlen(output_return->path,
+ sizeof(output_return->path));
+ if (path_len == 0 || path_len == sizeof(output_return->path)) {
+ ret = -LTTNG_ERR_NO_SESSION_OUTPUT;
+ goto end;
+ }
+
+ *chunk_path = zmalloc(path_len + 1);
+ if (!*chunk_path) {
+ ret = -1;
+ goto end;
+ }
+ memcpy(*chunk_path, output_return->path, path_len);
+
+ ret = 0;
+
+end:
+ free(output_return);
+ return ret;
+}
+
/*
* lib constructor.
*/
--- /dev/null
+/*
+ * Copyright (C) 2017 - Julien Desfossez <jdesfossez@efficios.com>
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License, version 2.1 only,
+ * as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#define _LGPL_SOURCE
+#include <assert.h>
+#include <string.h>
+
+#include <lttng/lttng-error.h>
+#include <lttng/rotation.h>
+#include <lttng/rotate-internal.h>
+#include <common/sessiond-comm/sessiond-comm.h>
+#include <common/macros.h>
+
+#include "lttng-ctl-helper.h"
+
+struct lttng_rotation_immediate_attr *lttng_rotation_immediate_attr_create(void)
+{
+ return zmalloc(sizeof(struct lttng_rotation_immediate_attr));
+}
+
+void lttng_rotation_immediate_attr_destroy(
+ struct lttng_rotation_immediate_attr *attr)
+{
+ free(attr);
+}
+
+enum lttng_rotation_status lttng_rotation_immediate_attr_set_session_name(
+ struct lttng_rotation_immediate_attr *attr,
+ const char *session_name)
+{
+ enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
+ int ret;
+
+ if (!attr || !session_name) {
+ status = LTTNG_ROTATION_STATUS_INVALID;
+ goto error;
+ }
+
+ ret = lttng_strncpy(attr->session_name, session_name,
+ sizeof(attr->session_name));
+ if (ret) {
+ status = LTTNG_ROTATION_STATUS_INVALID;
+ goto error;
+ }
+
+error:
+ return status;
+}
+
+static
+enum lttng_rotation_status ask_rotation_info(
+ struct lttng_rotation_handle *rotation_handle,
+ struct lttng_rotation_get_info_return **info)
+{
+ /* lsm.get_rotation_state.rotation_id */
+ struct lttcomm_session_msg lsm;
+ enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
+ int ret;
+
+ if (!rotation_handle || !info) {
+ status = LTTNG_ROTATION_STATUS_INVALID;
+ goto end;
+ }
+
+ memset(&lsm, 0, sizeof(lsm));
+ lsm.cmd_type = LTTNG_ROTATION_GET_INFO;
+ lsm.u.get_rotation_info.rotation_id = rotation_handle->rotation_id;
+
+ ret = lttng_strncpy(lsm.session.name, rotation_handle->session_name,
+ sizeof(lsm.session.name));
+ if (ret) {
+ status = LTTNG_ROTATION_STATUS_INVALID;
+ goto end;
+ }
+
+ ret = lttng_ctl_ask_sessiond(&lsm, (void **) info);
+ if (ret < 0) {
+ status = LTTNG_ROTATION_STATUS_ERROR;
+ goto end;
+ }
+end:
+ return status;
+
+}
+
+enum lttng_rotation_status lttng_rotation_handle_get_state(
+ struct lttng_rotation_handle *rotation_handle,
+ enum lttng_rotation_state *state)
+{
+ enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
+ struct lttng_rotation_get_info_return *info = NULL;
+ int ret;
+
+ if (!rotation_handle || !state) {
+ status = LTTNG_ROTATION_STATUS_INVALID;
+ goto end;
+ }
+
+ status = ask_rotation_info(rotation_handle, &info);
+ if (status != LTTNG_ROTATION_STATUS_OK) {
+ goto end;
+ }
+
+ *state = (enum lttng_rotation_state) info->status;
+ if (rotation_handle->archive_location.is_set ||
+ *state != LTTNG_ROTATION_STATE_COMPLETED) {
+ /*
+ * The path is only provided by the sessiond once
+ * the session rotation is completed, but not expired.
+ */
+ goto end;
+ }
+
+ /*
+ * Cache the location since the rotation may expire before the user
+ * has a chance to query it.
+ */
+ ret = lttng_strncpy(rotation_handle->archive_location.path,
+ info->path,
+ sizeof(rotation_handle->archive_location.path));
+ if (ret) {
+ status = LTTNG_ROTATION_STATUS_ERROR;
+ goto end;
+ }
+ rotation_handle->archive_location.is_set = true;
+end:
+ free(info);
+ return status;
+}
+
+enum lttng_rotation_status lttng_rotation_handle_get_completed_archive_location(
+ struct lttng_rotation_handle *rotation_handle,
+ const char **path)
+{
+ int ret;
+ enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
+ struct lttng_rotation_get_info_return *info = NULL;
+
+ if (!rotation_handle || !path) {
+ status = LTTNG_ROTATION_STATUS_INVALID;
+ goto end;
+ }
+
+ /* Use the cached location we got from a previous query. */
+ if (rotation_handle->archive_location.is_set) {
+ *path = rotation_handle->archive_location.path;
+ goto end;
+ }
+
+ status = ask_rotation_info(rotation_handle, &info);
+ if (status != LTTNG_ROTATION_STATUS_OK) {
+ goto end;
+ }
+
+ if ((enum lttng_rotation_state) info->status !=
+ LTTNG_ROTATION_STATE_COMPLETED) {
+ status = LTTNG_ROTATION_STATUS_UNAVAILABLE;
+ goto end;
+ }
+
+ ret = lttng_strncpy(rotation_handle->archive_location.path,
+ info->path,
+ sizeof(rotation_handle->archive_location.path));
+ if (ret) {
+ status = LTTNG_ROTATION_STATUS_ERROR;
+ goto end;
+ }
+ rotation_handle->archive_location.is_set = true;
+end:
+ free(info);
+ return status;
+}
+
+void lttng_rotation_handle_destroy(
+ struct lttng_rotation_handle *rotation_handle)
+{
+ free(rotation_handle);
+}
+
+static
+int init_rotation_handle(struct lttng_rotation_handle *rotation_handle,
+ struct lttng_rotate_session_return *rotate_return,
+ struct lttng_rotation_immediate_attr *attr)
+{
+ int ret;
+
+ ret = lttng_strncpy(rotation_handle->session_name, attr->session_name,
+ sizeof(rotation_handle->session_name));
+ if (ret) {
+ goto end;
+ }
+
+ rotation_handle->rotation_id = rotate_return->rotation_id;
+end:
+ return ret;
+}
+
+/*
+ * Rotate the output folder of the session.
+ *
+ * Return 0 on success else a negative LTTng error code.
+ */
+int lttng_rotate_session(struct lttng_rotation_immediate_attr *attr,
+ struct lttng_rotation_handle **rotation_handle)
+{
+ struct lttcomm_session_msg lsm;
+ struct lttng_rotate_session_return *rotate_return = NULL;
+ int ret;
+
+ if (!attr) {
+ ret = -LTTNG_ERR_INVALID;
+ goto end;
+ }
+
+ memset(&lsm, 0, sizeof(lsm));
+ lsm.cmd_type = LTTNG_ROTATE_SESSION;
+ lttng_ctl_copy_string(lsm.session.name, attr->session_name,
+ sizeof(lsm.session.name));
+
+ ret = lttng_ctl_ask_sessiond(&lsm, (void **) &rotate_return);
+ if (ret < 0) {
+ *rotation_handle = NULL;
+ goto end;
+ }
+
+ *rotation_handle = zmalloc(sizeof(struct lttng_rotation_handle));
+ if (!*rotation_handle) {
+ ret = -LTTNG_ERR_NOMEM;
+ goto end;
+ }
+
+ init_rotation_handle(*rotation_handle, rotate_return, attr);
+
+ ret = 0;
+
+end:
+ free(rotate_return);
+ return ret;
+}
projects / lttng-tools.git / commitdiff
