[lttng-tools.git] / src / lib / lttng-ctl / rotate.c

/*
 * 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/location-internal.h>
#include <lttng/rotate-internal.h>
#include <common/sessiond-comm/sessiond-comm.h>
#include <common/macros.h>

#include "lttng-ctl-helper.h"

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;

}

static
struct lttng_trace_archive_location *
create_trace_archive_location_from_get_info(
		const struct lttng_rotation_get_info_return *info)
{
	struct lttng_trace_archive_location *location;

	switch (info->location_type) {
	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL:
		location = lttng_trace_archive_location_local_create(
				info->location.local.absolute_path);
		break;
	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY:
		location = lttng_trace_archive_location_relay_create(
				info->location.relay.host,
				info->location.relay.protocol,
				info->location.relay.ports.control,
				info->location.relay.ports.data,
				info->location.relay.relative_path);
		break;
	default:
		location = NULL;
		break;
	}
	return location;
}

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;

	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 ||
			*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.
	 */
	rotation_handle->archive_location =
			create_trace_archive_location_from_get_info(info);
	if (!rotation_handle->archive_location) {
		status = LTTNG_ROTATION_STATUS_ERROR;
		goto end;
	}
end:
	free(info);
	return status;
}

enum lttng_rotation_status lttng_rotation_handle_get_archive_location(
		struct lttng_rotation_handle *rotation_handle,
		const struct lttng_trace_archive_location **location)
{
	enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
	struct lttng_rotation_get_info_return *info = NULL;

	if (!rotation_handle || !location) {
		status = LTTNG_ROTATION_STATUS_INVALID;
		goto end;
	}

	/* Use the cached location we got from a previous query. */
	if (rotation_handle->archive_location) {
		*location = rotation_handle->archive_location;
		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;
	}

	rotation_handle->archive_location =
			create_trace_archive_location_from_get_info(info);
	if (!rotation_handle->archive_location) {
		status = LTTNG_ROTATION_STATUS_ERROR;
		goto end;
	}
end:
	free(info);
	return status;
}

void lttng_rotation_handle_destroy(
		struct lttng_rotation_handle *rotation_handle)
{
	if (!rotation_handle) {
		return;
	}
	lttng_trace_archive_location_destroy(rotation_handle->archive_location);
	free(rotation_handle);
}

static
int init_rotation_handle(struct lttng_rotation_handle *rotation_handle,
		const char *session_name,
		struct lttng_rotate_session_return *rotate_return)
{
	int ret;

	ret = lttng_strncpy(rotation_handle->session_name, 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(const char *session_name,
		struct lttng_rotation_immediate_descriptor *descriptor,
		struct lttng_rotation_handle **rotation_handle)
{
	struct lttcomm_session_msg lsm;
	struct lttng_rotate_session_return *rotate_return = NULL;
	int ret;
	size_t session_name_len;

	if (!session_name) {
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	session_name_len = strlen(session_name);
	if (session_name_len >= sizeof(lsm.session.name) ||
	    session_name_len >= member_sizeof(struct lttng_rotation_handle, session_name)) {
		ret = -LTTNG_ERR_INVALID;
		goto end;
	}

	memset(&lsm, 0, sizeof(lsm));
	lsm.cmd_type = LTTNG_ROTATE_SESSION;
	lttng_ctl_copy_string(lsm.session.name, 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, session_name, rotate_return);

	ret = 0;

end:
	free(rotate_return);
	return ret;
}

/*
 * Update the automatic rotation parameters.
 * 'add' as true enables the provided schedule, false removes the shedule.
 *
 * The external API makes it appear as though arbitrary schedules can
 * be added or removed at will. However, the session daemon is
 * currently limited to one schedule per type (per session).
 *
 * The additional flexibility of the public API is offered for future
 * rotation schedules that could indicate more precise criteria than
 * size and time (e.g. a domain) where it could make sense to add
 * multiple schedules of a given type to a session.
 *
 * Hence, the exact schedule that the user wishes to remove (and not
 * just its type) must be passed so that the session daemon can
 * validate that is exists before clearing it.
 */
static
enum lttng_rotation_status lttng_rotation_update_schedule(
		const char *session_name,
		const struct lttng_rotation_schedule *schedule,
		bool add)
{
	struct lttcomm_session_msg lsm;
	enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
	int ret;

	if (!session_name || !schedule) {
		status = LTTNG_ROTATION_STATUS_INVALID;
		goto end;
	}

	if (strlen(session_name) >= sizeof(lsm.session.name)) {
		status = LTTNG_ROTATION_STATUS_INVALID;
		goto end;
	}

	memset(&lsm, 0, sizeof(lsm));
	lsm.cmd_type = LTTNG_ROTATION_SET_SCHEDULE;
	lttng_ctl_copy_string(lsm.session.name, session_name,
			sizeof(lsm.session.name));

	lsm.u.rotation_set_schedule.type = (uint32_t) schedule->type;
	switch (schedule->type) {
	case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD:
	{
		uint64_t threshold;

		status = lttng_rotation_schedule_size_threshold_get_threshold(
				schedule, &threshold);
		if (status != LTTNG_ROTATION_STATUS_OK) {
			if (status == LTTNG_ROTATION_STATUS_UNAVAILABLE) {
				status = LTTNG_ROTATION_STATUS_INVALID;
			}
			goto end;
		}
		lsm.u.rotation_set_schedule.value = threshold;
		lsm.u.rotation_set_schedule.set = !!add;
		break;
	}
	case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC:
	{
		uint64_t period;

		status = lttng_rotation_schedule_periodic_get_period(
				schedule, &period);
		if (status != LTTNG_ROTATION_STATUS_OK) {
			if (status == LTTNG_ROTATION_STATUS_UNAVAILABLE) {
				status = LTTNG_ROTATION_STATUS_INVALID;
			}
			goto end;
		}
		lsm.u.rotation_set_schedule.value = period;
		lsm.u.rotation_set_schedule.set = !!add;
		break;
	}
	default:
		status = LTTNG_ROTATION_STATUS_INVALID;
		goto end;
	}

	ret = lttng_ctl_ask_sessiond(&lsm, NULL);
	if (ret >= 0) {
		goto end;
	}

	switch (-ret) {
	case LTTNG_ERR_ROTATION_SCHEDULE_SET:
		status = LTTNG_ROTATION_STATUS_SCHEDULE_ALREADY_SET;
		break;
	case LTTNG_ERR_ROTATION_SCHEDULE_NOT_SET:
		status = LTTNG_ROTATION_STATUS_INVALID;
		break;
	default:
		status = LTTNG_ROTATION_STATUS_ERROR;
	}
end:
	return status;
}

static
struct lttng_rotation_schedules *lttng_rotation_schedules_create(void)
{
	return zmalloc(sizeof(struct lttng_rotation_schedules));
}

static
void lttng_schedules_add(struct lttng_rotation_schedules *schedules,
		struct lttng_rotation_schedule *schedule)
{
	schedules->schedules[schedules->count++] = schedule;
}

static
int get_schedules(const char *session_name,
		struct lttng_rotation_schedules **_schedules)
{
	int ret;
	struct lttcomm_session_msg lsm;
	struct lttng_session_list_schedules_return *schedules_comm;
	struct lttng_rotation_schedules *schedules = NULL;
	struct lttng_rotation_schedule *periodic = NULL, *size = NULL;

	memset(&lsm, 0, sizeof(lsm));
	lsm.cmd_type = LTTNG_SESSION_LIST_ROTATION_SCHEDULES;
	lttng_ctl_copy_string(lsm.session.name, session_name,
			sizeof(lsm.session.name));

	ret = lttng_ctl_ask_sessiond(&lsm, (void **) &schedules_comm);
	if (ret < 0) {
		goto end;
	}

	schedules = lttng_rotation_schedules_create();
	if (!schedules) {
		ret = -LTTNG_ERR_NOMEM;
		goto end;
	}

	if (schedules_comm->periodic.set == 1) {
		enum lttng_rotation_status status;

		periodic = lttng_rotation_schedule_periodic_create();
		if (!periodic) {
			ret = -LTTNG_ERR_NOMEM;
			goto end;
		}

		status = lttng_rotation_schedule_periodic_set_period(
				periodic, schedules_comm->periodic.value);
		if (status != LTTNG_ROTATION_STATUS_OK) {
			/*
			 * This would imply that the session daemon returned
			 * an invalid periodic rotation schedule value.
			 */
			ret = -LTTNG_ERR_UNK;
			goto end;
		}

		lttng_schedules_add(schedules, periodic);
		periodic = NULL;
	}

	if (schedules_comm->size.set == 1) {
		enum lttng_rotation_status status;

		size = lttng_rotation_schedule_size_threshold_create();
		if (!size) {
			ret = -LTTNG_ERR_NOMEM;
			goto end;
		}

		status = lttng_rotation_schedule_size_threshold_set_threshold(
				size, schedules_comm->size.value);
		if (status != LTTNG_ROTATION_STATUS_OK) {
			/*
			 * This would imply that the session daemon returned
			 * an invalid size threshold schedule value.
			 */
			ret = -LTTNG_ERR_UNK;
			goto end;
		}

		lttng_schedules_add(schedules, size);
		size = NULL;
	}

	ret = LTTNG_OK;
end:
	free(schedules_comm);
	free(periodic);
	free(size);
	*_schedules = schedules;
	return ret;
}

enum lttng_rotation_schedule_type lttng_rotation_schedule_get_type(
		const struct lttng_rotation_schedule *schedule)
{
	return schedule ? schedule->type : LTTNG_ROTATION_SCHEDULE_TYPE_UNKNOWN;
}

struct lttng_rotation_schedule *
lttng_rotation_schedule_size_threshold_create(void)
{
	struct lttng_rotation_schedule_size_threshold *schedule;

	schedule = zmalloc(sizeof(*schedule));
	if (!schedule) {
		goto end;
	}

	schedule->parent.type = LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD;
end:
	return &schedule->parent;
}

enum lttng_rotation_status
lttng_rotation_schedule_size_threshold_get_threshold(
		const struct lttng_rotation_schedule *schedule,
		uint64_t *size_threshold_bytes)
{
	enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
	struct lttng_rotation_schedule_size_threshold *size_schedule;

	if (!schedule || !size_threshold_bytes ||
			schedule->type != LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD) {
		status = LTTNG_ROTATION_STATUS_INVALID;
		goto end;
	}

	size_schedule = container_of(schedule,
			struct lttng_rotation_schedule_size_threshold,
			parent);
	if (size_schedule->size.set) {
		*size_threshold_bytes = size_schedule->size.bytes;
	} else {
		status = LTTNG_ROTATION_STATUS_UNAVAILABLE;
		goto end;
	}
end:
	return status;
}

enum lttng_rotation_status
lttng_rotation_schedule_size_threshold_set_threshold(
		struct lttng_rotation_schedule *schedule,
		uint64_t size_threshold_bytes)
{
	enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
	struct lttng_rotation_schedule_size_threshold *size_schedule;

	if (!schedule || size_threshold_bytes == 0 ||
			size_threshold_bytes == -1ULL ||
			schedule->type != LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD) {
		status = LTTNG_ROTATION_STATUS_INVALID;
		goto end;
	}

	size_schedule = container_of(schedule,
			struct lttng_rotation_schedule_size_threshold,
			parent);
	size_schedule->size.bytes = size_threshold_bytes;
	size_schedule->size.set = true;
end:
	return status;
}

struct lttng_rotation_schedule *
lttng_rotation_schedule_periodic_create(void)
{
	struct lttng_rotation_schedule_periodic *schedule;

	schedule = zmalloc(sizeof(*schedule));
	if (!schedule) {
		goto end;
	}

	schedule->parent.type = LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC;
end:
	return &schedule->parent;
}

enum lttng_rotation_status
lttng_rotation_schedule_periodic_get_period(
		const struct lttng_rotation_schedule *schedule,
		uint64_t *period_us)
{
	enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
	struct lttng_rotation_schedule_periodic *periodic_schedule;

	if (!schedule || !period_us ||
			schedule->type != LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC) {
		status = LTTNG_ROTATION_STATUS_INVALID;
		goto end;
	}

	periodic_schedule = container_of(schedule,
			struct lttng_rotation_schedule_periodic,
			parent);
	if (periodic_schedule->period.set) {
		*period_us = periodic_schedule->period.us;
	} else {
		status = LTTNG_ROTATION_STATUS_UNAVAILABLE;
		goto end;
	}
end:
	return status;
}

enum lttng_rotation_status
lttng_rotation_schedule_periodic_set_period(
		struct lttng_rotation_schedule *schedule,
		uint64_t period_us)
{
	enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
	struct lttng_rotation_schedule_periodic *periodic_schedule;

	if (!schedule || period_us == 0 || period_us == -1ULL ||
			schedule->type != LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC) {
		status = LTTNG_ROTATION_STATUS_INVALID;
		goto end;
	}

	periodic_schedule = container_of(schedule,
			struct lttng_rotation_schedule_periodic,
			parent);
	periodic_schedule->period.us = period_us;
	periodic_schedule->period.set = true;
end:
	return status;
}

void lttng_rotation_schedule_destroy(struct lttng_rotation_schedule *schedule)
{
	if (!schedule) {
		return;
	}
	free(schedule);
}

void lttng_rotation_schedules_destroy(
		struct lttng_rotation_schedules *schedules)
{
	unsigned int i;

	if (!schedules) {
		return;
	}

	for (i = 0; i < schedules->count; i++) {
		lttng_rotation_schedule_destroy(schedules->schedules[i]);
	}
	free(schedules);
}


enum lttng_rotation_status lttng_rotation_schedules_get_count(
		const struct lttng_rotation_schedules *schedules,
		unsigned int *count)
{
	enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;

	if (!schedules || !count) {
		status = LTTNG_ROTATION_STATUS_INVALID;
		goto end;
	}

	*count = schedules->count;
end:
	return status;
}

const struct lttng_rotation_schedule *lttng_rotation_schedules_get_at_index(
		const struct lttng_rotation_schedules *schedules,
		unsigned int index)
{
	const struct lttng_rotation_schedule *schedule = NULL;

	if (!schedules || index >= schedules->count) {
		goto end;
	}

	schedule = schedules->schedules[index];
end:
	return schedule;
}

enum lttng_rotation_status lttng_session_add_rotation_schedule(
		const char *session_name,
		const struct lttng_rotation_schedule *schedule)
{
	return lttng_rotation_update_schedule(session_name, schedule, true);
}

enum lttng_rotation_status lttng_session_remove_rotation_schedule(
		const char *session_name,
		const struct lttng_rotation_schedule *schedule)
{
	return lttng_rotation_update_schedule(session_name, schedule, false);
}

int lttng_session_list_rotation_schedules(
		const char *session_name,
		struct lttng_rotation_schedules **schedules)
{
	return get_schedules(session_name, schedules);
}
Commit	Line	Data
d68c9a04 JD	1	/*
	2	* Copyright (C) 2017 - Julien Desfossez <jdesfossez@efficios.com>
	3	*
	4	* This library is free software; you can redistribute it and/or modify it
	5	* under the terms of the GNU Lesser General Public License, version 2.1 only,
	6	* as published by the Free Software Foundation.
	7	*
	8	* This library is distributed in the hope that it will be useful, but WITHOUT
	9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	10	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
	11	* for more details.
	12	*
	13	* You should have received a copy of the GNU Lesser General Public License
	14	* along with this library; if not, write to the Free Software Foundation,
	15	* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	16	*/
	17
	18	#define _LGPL_SOURCE
	19	#include <assert.h>
	20	#include <string.h>
	21
	22	#include <lttng/lttng-error.h>
	23	#include <lttng/rotation.h>
dd73d57b	24	#include <lttng/location-internal.h>
d68c9a04 JD	25	#include <lttng/rotate-internal.h>
	26	#include <common/sessiond-comm/sessiond-comm.h>
	27	#include <common/macros.h>
	28
	29	#include "lttng-ctl-helper.h"
	30
d68c9a04 JD	31	static
	32	enum lttng_rotation_status ask_rotation_info(
	33	struct lttng_rotation_handle *rotation_handle,
	34	struct lttng_rotation_get_info_return **info)
	35	{
	36	/* lsm.get_rotation_state.rotation_id */
	37	struct lttcomm_session_msg lsm;
	38	enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
	39	int ret;
	40
	41	if (!rotation_handle \|\| !info) {
	42	status = LTTNG_ROTATION_STATUS_INVALID;
	43	goto end;
	44	}
	45
	46	memset(&lsm, 0, sizeof(lsm));
	47	lsm.cmd_type = LTTNG_ROTATION_GET_INFO;
	48	lsm.u.get_rotation_info.rotation_id = rotation_handle->rotation_id;
	49
	50	ret = lttng_strncpy(lsm.session.name, rotation_handle->session_name,
	51	sizeof(lsm.session.name));
	52	if (ret) {
	53	status = LTTNG_ROTATION_STATUS_INVALID;
	54	goto end;
	55	}
	56
	57	ret = lttng_ctl_ask_sessiond(&lsm, (void **) info);
	58	if (ret < 0) {
	59	status = LTTNG_ROTATION_STATUS_ERROR;
	60	goto end;
	61	}
	62	end:
	63	return status;
	64
	65	}
	66
dd73d57b JG	67	static
	68	struct lttng_trace_archive_location *
	69	create_trace_archive_location_from_get_info(
	70	const struct lttng_rotation_get_info_return *info)
	71	{
	72	struct lttng_trace_archive_location *location;
	73
	74	switch (info->location_type) {
	75	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_LOCAL:
	76	location = lttng_trace_archive_location_local_create(
	77	info->location.local.absolute_path);
	78	break;
	79	case LTTNG_TRACE_ARCHIVE_LOCATION_TYPE_RELAY:
	80	location = lttng_trace_archive_location_relay_create(
	81	info->location.relay.host,
	82	info->location.relay.protocol,
	83	info->location.relay.ports.control,
	84	info->location.relay.ports.data,
	85	info->location.relay.relative_path);
	86	break;
	87	default:
	88	location = NULL;
	89	break;
	90	}
	91	return location;
	92	}
	93
d68c9a04 JD	94	enum lttng_rotation_status lttng_rotation_handle_get_state(
	95	struct lttng_rotation_handle *rotation_handle,
	96	enum lttng_rotation_state *state)
	97	{
	98	enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
	99	struct lttng_rotation_get_info_return *info = NULL;
d68c9a04 JD	100
	101	if (!rotation_handle \|\| !state) {
	102	status = LTTNG_ROTATION_STATUS_INVALID;
	103	goto end;
	104	}
	105
	106	status = ask_rotation_info(rotation_handle, &info);
	107	if (status != LTTNG_ROTATION_STATUS_OK) {
	108	goto end;
	109	}
	110
	111	*state = (enum lttng_rotation_state) info->status;
dd73d57b	112	if (rotation_handle->archive_location \|\|
d68c9a04 JD	113	*state != LTTNG_ROTATION_STATE_COMPLETED) {
	114	/*
	115	* The path is only provided by the sessiond once
	116	* the session rotation is completed, but not expired.
	117	*/
	118	goto end;
	119	}
	120
	121	/*
	122	* Cache the location since the rotation may expire before the user
	123	* has a chance to query it.
	124	*/
dd73d57b JG	125	rotation_handle->archive_location =
	126	create_trace_archive_location_from_get_info(info);
	127	if (!rotation_handle->archive_location) {
d68c9a04 JD	128	status = LTTNG_ROTATION_STATUS_ERROR;
	129	goto end;
	130	}
d68c9a04 JD	131	end:
	132	free(info);
	133	return status;
	134	}
	135
dd73d57b	136	enum lttng_rotation_status lttng_rotation_handle_get_archive_location(
d68c9a04	137	struct lttng_rotation_handle *rotation_handle,
dd73d57b	138	const struct lttng_trace_archive_location **location)
d68c9a04	139	{
d68c9a04 JD	140	enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
	141	struct lttng_rotation_get_info_return *info = NULL;
	142
dd73d57b	143	if (!rotation_handle \|\| !location) {
d68c9a04 JD	144	status = LTTNG_ROTATION_STATUS_INVALID;
	145	goto end;
	146	}
	147
	148	/* Use the cached location we got from a previous query. */
dd73d57b JG	149	if (rotation_handle->archive_location) {
dd73d57b JG	150	*location = rotation_handle->archive_location;
d68c9a04 JD	151	goto end;
	152	}
	153
	154	status = ask_rotation_info(rotation_handle, &info);
	155	if (status != LTTNG_ROTATION_STATUS_OK) {
	156	goto end;
	157	}
	158
	159	if ((enum lttng_rotation_state) info->status !=
	160	LTTNG_ROTATION_STATE_COMPLETED) {
	161	status = LTTNG_ROTATION_STATUS_UNAVAILABLE;
	162	goto end;
	163	}
	164
dd73d57b JG	165	rotation_handle->archive_location =
	166	create_trace_archive_location_from_get_info(info);
	167	if (!rotation_handle->archive_location) {
d68c9a04 JD	168	status = LTTNG_ROTATION_STATUS_ERROR;
	169	goto end;
	170	}
d68c9a04 JD	171	end:
	172	free(info);
	173	return status;
	174	}
	175
	176	void lttng_rotation_handle_destroy(
	177	struct lttng_rotation_handle *rotation_handle)
	178	{
06b180a1 JR	179	if (!rotation_handle) {
	180	return;
	181	}
dd73d57b	182	lttng_trace_archive_location_destroy(rotation_handle->archive_location);
d68c9a04 JD	183	free(rotation_handle);
	184	}
	185
	186	static
	187	int init_rotation_handle(struct lttng_rotation_handle *rotation_handle,
dbd512ea	188	const char *session_name,
66ea93b1	189	struct lttng_rotate_session_return *rotate_return)
d68c9a04 JD	190	{
	191	int ret;
	192
dbd512ea	193	ret = lttng_strncpy(rotation_handle->session_name, session_name,
d68c9a04 JD	194	sizeof(rotation_handle->session_name));
	195	if (ret) {
	196	goto end;
	197	}
	198
	199	rotation_handle->rotation_id = rotate_return->rotation_id;
	200	end:
	201	return ret;
	202	}
	203
	204	/*
	205	* Rotate the output folder of the session.
	206	*
	207	* Return 0 on success else a negative LTTng error code.
	208	*/
dbd512ea	209	int lttng_rotate_session(const char *session_name,
66ea93b1	210	struct lttng_rotation_immediate_descriptor *descriptor,
d68c9a04 JD	211	struct lttng_rotation_handle **rotation_handle)
	212	{
	213	struct lttcomm_session_msg lsm;
	214	struct lttng_rotate_session_return *rotate_return = NULL;
	215	int ret;
dbd512ea	216	size_t session_name_len;
d68c9a04	217
dbd512ea JG	218	if (!session_name) {
	219	ret = -LTTNG_ERR_INVALID;
	220	goto end;
	221	}
	222
	223	session_name_len = strlen(session_name);
	224	if (session_name_len >= sizeof(lsm.session.name) \|\|
	225	session_name_len >= member_sizeof(struct lttng_rotation_handle, session_name)) {
d68c9a04 JD	226	ret = -LTTNG_ERR_INVALID;
	227	goto end;
	228	}
	229
	230	memset(&lsm, 0, sizeof(lsm));
	231	lsm.cmd_type = LTTNG_ROTATE_SESSION;
dbd512ea	232	lttng_ctl_copy_string(lsm.session.name, session_name,
d68c9a04 JD	233	sizeof(lsm.session.name));
	234
	235	ret = lttng_ctl_ask_sessiond(&lsm, (void **) &rotate_return);
1320cab1	236	if (ret <= 0) {
d68c9a04 JD	237	*rotation_handle = NULL;
	238	goto end;
	239	}
	240
	241	*rotation_handle = zmalloc(sizeof(struct lttng_rotation_handle));
	242	if (!*rotation_handle) {
	243	ret = -LTTNG_ERR_NOMEM;
	244	goto end;
	245	}
	246
66ea93b1	247	init_rotation_handle(*rotation_handle, session_name, rotate_return);
d68c9a04 JD	248
	249	ret = 0;
	250
	251	end:
	252	free(rotate_return);
	253	return ret;
	254	}
259c2674 JD	255
259c2674 JD	256	/*
66ea93b1 JG	257	* Update the automatic rotation parameters.
	258	* 'add' as true enables the provided schedule, false removes the shedule.
	259	*
	260	* The external API makes it appear as though arbitrary schedules can
	261	* be added or removed at will. However, the session daemon is
	262	* currently limited to one schedule per type (per session).
	263	*
	264	* The additional flexibility of the public API is offered for future
	265	* rotation schedules that could indicate more precise criteria than
	266	* size and time (e.g. a domain) where it could make sense to add
	267	* multiple schedules of a given type to a session.
	268	*
	269	* Hence, the exact schedule that the user wishes to remove (and not
	270	* just its type) must be passed so that the session daemon can
	271	* validate that is exists before clearing it.
259c2674	272	*/
66ea93b1 JG	273	static
	274	enum lttng_rotation_status lttng_rotation_update_schedule(
	275	const char *session_name,
	276	const struct lttng_rotation_schedule *schedule,
	277	bool add)
259c2674 JD	278	{
259c2674 JD	279	struct lttcomm_session_msg lsm;
66ea93b1	280	enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
259c2674 JD	281	int ret;
259c2674 JD	282
66ea93b1 JG	283	if (!session_name \|\| !schedule) {
66ea93b1 JG	284	status = LTTNG_ROTATION_STATUS_INVALID;
dbd512ea JG	285	goto end;
	286	}
	287
	288	if (strlen(session_name) >= sizeof(lsm.session.name)) {
66ea93b1	289	status = LTTNG_ROTATION_STATUS_INVALID;
259c2674 JD	290	goto end;
	291	}
	292
	293	memset(&lsm, 0, sizeof(lsm));
	294	lsm.cmd_type = LTTNG_ROTATION_SET_SCHEDULE;
dbd512ea	295	lttng_ctl_copy_string(lsm.session.name, session_name,
259c2674	296	sizeof(lsm.session.name));
66ea93b1 JG	297
	298	lsm.u.rotation_set_schedule.type = (uint32_t) schedule->type;
	299	switch (schedule->type) {
	300	case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD:
	301	{
7370c955 JG	302	uint64_t threshold;
7370c955 JG	303
66ea93b1	304	status = lttng_rotation_schedule_size_threshold_get_threshold(
7370c955	305	schedule, &threshold);
66ea93b1	306	if (status != LTTNG_ROTATION_STATUS_OK) {
ed9f1fb2 JG	307	if (status == LTTNG_ROTATION_STATUS_UNAVAILABLE) {
	308	status = LTTNG_ROTATION_STATUS_INVALID;
	309	}
66ea93b1 JG	310	goto end;
66ea93b1 JG	311	}
7370c955	312	lsm.u.rotation_set_schedule.value = threshold;
66ea93b1 JG	313	lsm.u.rotation_set_schedule.set = !!add;
	314	break;
	315	}
	316	case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC:
	317	{
7370c955 JG	318	uint64_t period;
7370c955 JG	319
66ea93b1	320	status = lttng_rotation_schedule_periodic_get_period(
7370c955	321	schedule, &period);
66ea93b1	322	if (status != LTTNG_ROTATION_STATUS_OK) {
ed9f1fb2 JG	323	if (status == LTTNG_ROTATION_STATUS_UNAVAILABLE) {
	324	status = LTTNG_ROTATION_STATUS_INVALID;
	325	}
66ea93b1 JG	326	goto end;
66ea93b1 JG	327	}
7370c955	328	lsm.u.rotation_set_schedule.value = period;
66ea93b1 JG	329	lsm.u.rotation_set_schedule.set = !!add;
	330	break;
	331	}
	332	default:
	333	status = LTTNG_ROTATION_STATUS_INVALID;
	334	goto end;
	335	}
259c2674 JD	336
259c2674 JD	337	ret = lttng_ctl_ask_sessiond(&lsm, NULL);
66ea93b1 JG	338	if (ret >= 0) {
	339	goto end;
	340	}
	341
	342	switch (-ret) {
	343	case LTTNG_ERR_ROTATION_SCHEDULE_SET:
	344	status = LTTNG_ROTATION_STATUS_SCHEDULE_ALREADY_SET;
	345	break;
	346	case LTTNG_ERR_ROTATION_SCHEDULE_NOT_SET:
	347	status = LTTNG_ROTATION_STATUS_INVALID;
	348	break;
	349	default:
	350	status = LTTNG_ROTATION_STATUS_ERROR;
	351	}
259c2674	352	end:
66ea93b1 JG	353	return status;
	354	}
	355
	356	static
	357	struct lttng_rotation_schedules *lttng_rotation_schedules_create(void)
	358	{
	359	return zmalloc(sizeof(struct lttng_rotation_schedules));
259c2674	360	}
329f3443	361
66ea93b1 JG	362	static
	363	void lttng_schedules_add(struct lttng_rotation_schedules *schedules,
	364	struct lttng_rotation_schedule *schedule)
	365	{
	366	schedules->schedules[schedules->count++] = schedule;
	367	}
	368
	369	static
	370	int get_schedules(const char *session_name,
	371	struct lttng_rotation_schedules **_schedules)
329f3443	372	{
329f3443	373	int ret;
66ea93b1 JG	374	struct lttcomm_session_msg lsm;
	375	struct lttng_session_list_schedules_return *schedules_comm;
	376	struct lttng_rotation_schedules *schedules = NULL;
	377	struct lttng_rotation_schedule periodic = NULL, size = NULL;
329f3443 JD	378
329f3443 JD	379	memset(&lsm, 0, sizeof(lsm));
66ea93b1	380	lsm.cmd_type = LTTNG_SESSION_LIST_ROTATION_SCHEDULES;
329f3443 JD	381	lttng_ctl_copy_string(lsm.session.name, session_name,
	382	sizeof(lsm.session.name));
	383
66ea93b1	384	ret = lttng_ctl_ask_sessiond(&lsm, (void **) &schedules_comm);
329f3443	385	if (ret < 0) {
329f3443 JD	386	goto end;
	387	}
	388
66ea93b1 JG	389	schedules = lttng_rotation_schedules_create();
	390	if (!schedules) {
	391	ret = -LTTNG_ERR_NOMEM;
	392	goto end;
	393	}
	394
	395	if (schedules_comm->periodic.set == 1) {
	396	enum lttng_rotation_status status;
	397
	398	periodic = lttng_rotation_schedule_periodic_create();
	399	if (!periodic) {
	400	ret = -LTTNG_ERR_NOMEM;
	401	goto end;
	402	}
	403
	404	status = lttng_rotation_schedule_periodic_set_period(
	405	periodic, schedules_comm->periodic.value);
	406	if (status != LTTNG_ROTATION_STATUS_OK) {
	407	/*
	408	* This would imply that the session daemon returned
	409	* an invalid periodic rotation schedule value.
	410	*/
	411	ret = -LTTNG_ERR_UNK;
	412	goto end;
	413	}
	414
	415	lttng_schedules_add(schedules, periodic);
	416	periodic = NULL;
	417	}
	418
	419	if (schedules_comm->size.set == 1) {
	420	enum lttng_rotation_status status;
	421
	422	size = lttng_rotation_schedule_size_threshold_create();
	423	if (!size) {
	424	ret = -LTTNG_ERR_NOMEM;
	425	goto end;
	426	}
	427
	428	status = lttng_rotation_schedule_size_threshold_set_threshold(
	429	size, schedules_comm->size.value);
	430	if (status != LTTNG_ROTATION_STATUS_OK) {
	431	/*
	432	* This would imply that the session daemon returned
	433	* an invalid size threshold schedule value.
	434	*/
	435	ret = -LTTNG_ERR_UNK;
	436	goto end;
	437	}
	438
	439	lttng_schedules_add(schedules, size);
	440	size = NULL;
	441	}
	442
	443	ret = LTTNG_OK;
329f3443	444	end:
66ea93b1 JG	445	free(schedules_comm);
	446	free(periodic);
	447	free(size);
	448	*_schedules = schedules;
329f3443 JD	449	return ret;
	450	}
	451
66ea93b1 JG	452	enum lttng_rotation_schedule_type lttng_rotation_schedule_get_type(
66ea93b1 JG	453	const struct lttng_rotation_schedule *schedule)
329f3443	454	{
66ea93b1 JG	455	return schedule ? schedule->type : LTTNG_ROTATION_SCHEDULE_TYPE_UNKNOWN;
66ea93b1 JG	456	}
329f3443	457
66ea93b1 JG	458	struct lttng_rotation_schedule *
	459	lttng_rotation_schedule_size_threshold_create(void)
	460	{
	461	struct lttng_rotation_schedule_size_threshold *schedule;
329f3443	462
66ea93b1 JG	463	schedule = zmalloc(sizeof(*schedule));
66ea93b1 JG	464	if (!schedule) {
329f3443 JD	465	goto end;
	466	}
	467
66ea93b1 JG	468	schedule->parent.type = LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD;
	469	end:
	470	return &schedule->parent;
	471	}
	472
	473	enum lttng_rotation_status
	474	lttng_rotation_schedule_size_threshold_get_threshold(
	475	const struct lttng_rotation_schedule *schedule,
	476	uint64_t *size_threshold_bytes)
	477	{
	478	enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
	479	struct lttng_rotation_schedule_size_threshold *size_schedule;
329f3443	480
ed9f1fb2 JG	481	if (!schedule \|\| !size_threshold_bytes \|\|
ed9f1fb2 JG	482	schedule->type != LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD) {
66ea93b1 JG	483	status = LTTNG_ROTATION_STATUS_INVALID;
	484	goto end;
	485	}
	486
	487	size_schedule = container_of(schedule,
	488	struct lttng_rotation_schedule_size_threshold,
	489	parent);
	490	if (size_schedule->size.set) {
	491	*size_threshold_bytes = size_schedule->size.bytes;
	492	} else {
	493	status = LTTNG_ROTATION_STATUS_UNAVAILABLE;
	494	goto end;
	495	}
	496	end:
	497	return status;
	498	}
	499
	500	enum lttng_rotation_status
	501	lttng_rotation_schedule_size_threshold_set_threshold(
	502	struct lttng_rotation_schedule *schedule,
	503	uint64_t size_threshold_bytes)
	504	{
	505	enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
	506	struct lttng_rotation_schedule_size_threshold *size_schedule;
	507
	508	if (!schedule \|\| size_threshold_bytes == 0 \|\|
ed9f1fb2 JG	509	size_threshold_bytes == -1ULL \|\|
ed9f1fb2 JG	510	schedule->type != LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD) {
66ea93b1 JG	511	status = LTTNG_ROTATION_STATUS_INVALID;
	512	goto end;
	513	}
329f3443	514
66ea93b1 JG	515	size_schedule = container_of(schedule,
	516	struct lttng_rotation_schedule_size_threshold,
	517	parent);
	518	size_schedule->size.bytes = size_threshold_bytes;
	519	size_schedule->size.set = true;
329f3443	520	end:
66ea93b1 JG	521	return status;
	522	}
	523
	524	struct lttng_rotation_schedule *
	525	lttng_rotation_schedule_periodic_create(void)
	526	{
	527	struct lttng_rotation_schedule_periodic *schedule;
	528
	529	schedule = zmalloc(sizeof(*schedule));
	530	if (!schedule) {
	531	goto end;
	532	}
	533
	534	schedule->parent.type = LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC;
	535	end:
	536	return &schedule->parent;
	537	}
	538
	539	enum lttng_rotation_status
	540	lttng_rotation_schedule_periodic_get_period(
	541	const struct lttng_rotation_schedule *schedule,
	542	uint64_t *period_us)
	543	{
	544	enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
	545	struct lttng_rotation_schedule_periodic *periodic_schedule;
	546
ed9f1fb2 JG	547	if (!schedule \|\| !period_us \|\|
ed9f1fb2 JG	548	schedule->type != LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC) {
66ea93b1 JG	549	status = LTTNG_ROTATION_STATUS_INVALID;
	550	goto end;
	551	}
	552
	553	periodic_schedule = container_of(schedule,
	554	struct lttng_rotation_schedule_periodic,
	555	parent);
	556	if (periodic_schedule->period.set) {
	557	*period_us = periodic_schedule->period.us;
	558	} else {
	559	status = LTTNG_ROTATION_STATUS_UNAVAILABLE;
	560	goto end;
	561	}
	562	end:
	563	return status;
	564	}
	565
	566	enum lttng_rotation_status
	567	lttng_rotation_schedule_periodic_set_period(
	568	struct lttng_rotation_schedule *schedule,
	569	uint64_t period_us)
	570	{
	571	enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
	572	struct lttng_rotation_schedule_periodic *periodic_schedule;
	573
ed9f1fb2 JG	574	if (!schedule \|\| period_us == 0 \|\| period_us == -1ULL \|\|
ed9f1fb2 JG	575	schedule->type != LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC) {
66ea93b1 JG	576	status = LTTNG_ROTATION_STATUS_INVALID;
	577	goto end;
	578	}
	579
	580	periodic_schedule = container_of(schedule,
	581	struct lttng_rotation_schedule_periodic,
	582	parent);
	583	periodic_schedule->period.us = period_us;
	584	periodic_schedule->period.set = true;
	585	end:
	586	return status;
	587	}
	588
	589	void lttng_rotation_schedule_destroy(struct lttng_rotation_schedule *schedule)
	590	{
	591	if (!schedule) {
	592	return;
	593	}
	594	free(schedule);
	595	}
	596
	597	void lttng_rotation_schedules_destroy(
	598	struct lttng_rotation_schedules *schedules)
	599	{
	600	unsigned int i;
	601
	602	if (!schedules) {
	603	return;
	604	}
	605
	606	for (i = 0; i < schedules->count; i++) {
	607	lttng_rotation_schedule_destroy(schedules->schedules[i]);
	608	}
	609	free(schedules);
	610	}
	611
	612
	613	enum lttng_rotation_status lttng_rotation_schedules_get_count(
	614	const struct lttng_rotation_schedules *schedules,
	615	unsigned int *count)
	616	{
	617	enum lttng_rotation_status status = LTTNG_ROTATION_STATUS_OK;
	618
	619	if (!schedules \|\| !count) {
	620	status = LTTNG_ROTATION_STATUS_INVALID;
	621	goto end;
	622	}
	623
	624	*count = schedules->count;
	625	end:
	626	return status;
	627	}
	628
	629	const struct lttng_rotation_schedule *lttng_rotation_schedules_get_at_index(
	630	const struct lttng_rotation_schedules *schedules,
	631	unsigned int index)
	632	{
	633	const struct lttng_rotation_schedule *schedule = NULL;
	634
	635	if (!schedules \|\| index >= schedules->count) {
	636	goto end;
	637	}
	638
	639	schedule = schedules->schedules[index];
640	end:
641	return schedule;
642	}
643
644	enum lttng_rotation_status lttng_session_add_rotation_schedule(
645	const char *session_name,
646	const struct lttng_rotation_schedule *schedule)
647	{
648	return lttng_rotation_update_schedule(session_name, schedule, true);
649	}
650
651	enum lttng_rotation_status lttng_session_remove_rotation_schedule(
652	const char *session_name,
653	const struct lttng_rotation_schedule *schedule)
654	{
655	return lttng_rotation_update_schedule(session_name, schedule, false);
656	}
657
658	int lttng_session_list_rotation_schedules(
659	const char *session_name,
660	struct lttng_rotation_schedules **schedules)
661	{
662	return get_schedules(session_name, schedules);
329f3443	663	}