[lttng-tools.git] / src / lib / lttng-ctl / clear.cpp

/*
 * Copyright (C) 2019 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 * Copyright (C) 2019 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 */

#define _LGPL_SOURCE
#include <algorithm>
#include <string.h>

#include <lttng/lttng-error.h>
#include <lttng/clear.h>
#include <lttng/clear-handle.h>
#include <common/sessiond-comm/sessiond-comm.h>
#include <common/macros.h>
#include <common/compat/poll.h>
#include <common/dynamic-buffer.h>
#include <common/buffer-view.h>
#include <common/optional.h>

#include "lttng-ctl-helper.h"

enum communication_state {
	COMMUNICATION_STATE_RECEIVE_LTTNG_MSG,
	COMMUNICATION_STATE_RECEIVE_COMMAND_HEADER,
	COMMUNICATION_STATE_END,
	COMMUNICATION_STATE_ERROR,
};

struct lttng_clear_handle {
	LTTNG_OPTIONAL(enum lttng_error_code) clear_return_code;
	struct {
		int socket;
		struct lttng_poll_event events;
		size_t bytes_left_to_receive;
		enum communication_state state;
		struct lttng_dynamic_buffer buffer;
		LTTNG_OPTIONAL(size_t) data_size;
	} communication;
};

void lttng_clear_handle_destroy(struct lttng_clear_handle *handle)
{
	int ret;

	if (!handle) {
		return;
	}

	if (handle->communication.socket >= 0) {
		ret = close(handle->communication.socket);
		if (ret) {
			PERROR("Failed to close lttng-sessiond command socket");
		}
	}
	lttng_poll_clean(&handle->communication.events);
	lttng_dynamic_buffer_reset(&handle->communication.buffer);
	free(handle);
}

static
struct lttng_clear_handle *lttng_clear_handle_create(int sessiond_socket)
{
	int ret;
	struct lttng_clear_handle *handle = (lttng_clear_handle *) zmalloc(sizeof(*handle));

	if (!handle) {
		goto end;
	}
	lttng_dynamic_buffer_init(&handle->communication.buffer);
	handle->communication.socket = sessiond_socket;
	ret = lttng_poll_create(&handle->communication.events, 1, 0);
	if (ret) {
		goto error;
	}

	ret = lttng_poll_add(&handle->communication.events, sessiond_socket,
			LPOLLIN | LPOLLHUP | LPOLLRDHUP | LPOLLERR);
	if (ret) {
		goto error;
	}

	handle->communication.bytes_left_to_receive =
			sizeof(struct lttcomm_lttng_msg);
	handle->communication.state = COMMUNICATION_STATE_RECEIVE_LTTNG_MSG;
end:
	return handle;
error:
	lttng_clear_handle_destroy(handle);
	return NULL;
}

static
int handle_state_transition(struct lttng_clear_handle *handle)
{
	int ret = 0;

	LTTNG_ASSERT(handle->communication.bytes_left_to_receive == 0);

	switch (handle->communication.state) {
	case COMMUNICATION_STATE_RECEIVE_LTTNG_MSG:
	{
		const struct lttcomm_lttng_msg *msg =
				(typeof(msg)) handle->communication.buffer.data;

		LTTNG_OPTIONAL_SET(&handle->clear_return_code,
				(enum lttng_error_code) msg->ret_code);
		if (handle->clear_return_code.value != LTTNG_OK) {
			handle->communication.state = COMMUNICATION_STATE_END;
			break;
		} else if (msg->cmd_header_size != 0 || msg->data_size != 0) {
			handle->communication.state = COMMUNICATION_STATE_ERROR;
			ret = -1;
			break;
		}

		handle->communication.state = COMMUNICATION_STATE_END;
		handle->communication.bytes_left_to_receive = 0;
		LTTNG_OPTIONAL_SET(&handle->communication.data_size, 0);
		ret = lttng_dynamic_buffer_set_size(
				&handle->communication.buffer, 0);
		LTTNG_ASSERT(!ret);
		break;
	}
	default:
		abort();
	}

	/* Clear reception buffer on state transition. */
	if (lttng_dynamic_buffer_set_size(&handle->communication.buffer, 0)) {
		abort();
	}
	return ret;
}

static
int handle_incoming_data(struct lttng_clear_handle *handle)
{
	int ret;
	ssize_t comm_ret;
	const size_t original_buffer_size = handle->communication.buffer.size;

	/* Reserve space for reception. */
	ret = lttng_dynamic_buffer_set_size(&handle->communication.buffer,
			original_buffer_size + handle->communication.bytes_left_to_receive);
	if (ret) {
		goto end;
	}

	comm_ret = lttcomm_recv_unix_sock(handle->communication.socket,
			handle->communication.buffer.data + original_buffer_size,
			handle->communication.bytes_left_to_receive);
	if (comm_ret <= 0) {
		ret = -1;
		goto end;
	}

	handle->communication.bytes_left_to_receive -= comm_ret;
	if (handle->communication.bytes_left_to_receive == 0) {
		ret = handle_state_transition(handle);
	} else {
		ret = lttng_dynamic_buffer_set_size(
				&handle->communication.buffer,
				original_buffer_size + comm_ret);
	}
end:
	return ret;
}

extern enum lttng_clear_handle_status
	lttng_clear_handle_wait_for_completion(
		struct lttng_clear_handle *handle, int timeout_ms)
{
	enum lttng_clear_handle_status status;
	unsigned long time_left_ms = 0;
	const bool has_timeout = timeout_ms > 0;
	struct timespec initial_time;

	if (handle->communication.state == COMMUNICATION_STATE_ERROR) {
		status = LTTNG_CLEAR_HANDLE_STATUS_ERROR;
		goto end;
	} else if (handle->communication.state == COMMUNICATION_STATE_END) {
		status = LTTNG_CLEAR_HANDLE_STATUS_COMPLETED;
		goto end;
	}
	if (has_timeout) {
		int ret = lttng_clock_gettime(CLOCK_MONOTONIC, &initial_time);
		if (ret) {
			status = LTTNG_CLEAR_HANDLE_STATUS_ERROR;
			goto end;
		}
		time_left_ms = (unsigned long) timeout_ms;
	}

	while (handle->communication.state != COMMUNICATION_STATE_END &&
			(time_left_ms || !has_timeout)) {
		int ret;
		uint32_t revents;
		struct timespec current_time, diff;
		unsigned long diff_ms;

		ret = lttng_poll_wait(&handle->communication.events,
				has_timeout ? time_left_ms : -1);
		if (ret == 0) {
			/* timeout */
			break;
		} else if (ret < 0) {
			status = LTTNG_CLEAR_HANDLE_STATUS_ERROR;
			goto end;
		}

		/* The sessiond connection socket is the only monitored fd. */
		revents = LTTNG_POLL_GETEV(&handle->communication.events, 0);
		if (revents & LPOLLIN) {
			ret = handle_incoming_data(handle);
			if (ret) {
				handle->communication.state =
						COMMUNICATION_STATE_ERROR;
				status = LTTNG_CLEAR_HANDLE_STATUS_ERROR;
				goto end;
			}
		} else {
			handle->communication.state = COMMUNICATION_STATE_ERROR;
			status = LTTNG_CLEAR_HANDLE_STATUS_ERROR;
			goto end;
		}
		if (!has_timeout) {
			continue;
		}

		ret = lttng_clock_gettime(CLOCK_MONOTONIC, &current_time);
		if (ret) {
			status = LTTNG_CLEAR_HANDLE_STATUS_ERROR;
			goto end;
		}
		diff = timespec_abs_diff(initial_time, current_time);
		ret = timespec_to_ms(diff, &diff_ms);
		if (ret) {
			ERR("Failed to compute elapsed time while waiting for completion");
			status = LTTNG_CLEAR_HANDLE_STATUS_ERROR;
			goto end;
		}
		DBG("%lums elapsed while waiting for session clear completion",
				diff_ms);
		diff_ms = std::max(diff_ms, 1UL);
		diff_ms = std::min(diff_ms, time_left_ms);
		time_left_ms -= diff_ms;
	}

	status = handle->communication.state == COMMUNICATION_STATE_END ?
			LTTNG_CLEAR_HANDLE_STATUS_COMPLETED :
			LTTNG_CLEAR_HANDLE_STATUS_TIMEOUT;
end:
	return status;
}

extern enum lttng_clear_handle_status
	lttng_clear_handle_get_result(
		const struct lttng_clear_handle *handle,
		enum lttng_error_code *result)
{
	enum lttng_clear_handle_status status =
			LTTNG_CLEAR_HANDLE_STATUS_OK;

	if (!handle->clear_return_code.is_set) {
		status = LTTNG_CLEAR_HANDLE_STATUS_INVALID;
		goto end;
	}
	*result = handle->clear_return_code.value;
end:
	return status;
}

/*
 * Clear the session
 */
enum lttng_error_code lttng_clear_session(const char *session_name,
		struct lttng_clear_handle **_handle)
{
	enum lttng_error_code ret_code = LTTNG_OK;
	struct lttng_clear_handle *handle = NULL;
	struct lttcomm_session_msg lsm = {
		.cmd_type = LTTNG_CLEAR_SESSION,
	};
	int sessiond_socket = -1;
	ssize_t comm_ret;
	int ret;

	if (session_name == NULL) {
		ret_code = LTTNG_ERR_INVALID;
		goto error;
	}
	ret = lttng_strncpy(lsm.session.name, session_name,
			sizeof(lsm.session.name));
	if (ret) {
		ret_code = LTTNG_ERR_INVALID;
		goto error;
	}
	ret = connect_sessiond();
	if (ret < 0) {
		ret_code = LTTNG_ERR_NO_SESSIOND;
		goto error;
	} else {
		sessiond_socket = ret;
	}
	handle = lttng_clear_handle_create(sessiond_socket);
	if (!handle) {
		ret_code = LTTNG_ERR_NOMEM;
		goto error;
	}
	comm_ret = lttcomm_send_creds_unix_sock(sessiond_socket, &lsm, sizeof(lsm));
	if (comm_ret < 0) {
		ret_code = LTTNG_ERR_FATAL;
		goto error;
	}
	sessiond_socket = -1;

error:
	/* Transfer the handle to the caller. */
	if (_handle) {
		*_handle = handle;
		handle = NULL;
	}
	if (sessiond_socket >= 0) {
		ret = close(sessiond_socket);
		if (ret < 0) {
			PERROR("Failed to close the LTTng session daemon connection socket");
		}
	}
	if (handle) {
		lttng_clear_handle_destroy(handle);
	}
	return ret_code;
}
Commit	Line	Data
f2c1f0d4	1	/*
ab5be9fa MJ	2	* Copyright (C) 2019 Jérémie Galarneau <jeremie.galarneau@efficios.com>
ab5be9fa MJ	3	* Copyright (C) 2019 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
f2c1f0d4	4	*
ab5be9fa	5	* SPDX-License-Identifier: LGPL-2.1-only
f2c1f0d4	6	*
f2c1f0d4 MD	7	*/
	8
	9	#define _LGPL_SOURCE
4bd69c5f	10	#include <algorithm>
f2c1f0d4 MD	11	#include <string.h>
	12
	13	#include <lttng/lttng-error.h>
	14	#include <lttng/clear.h>
	15	#include <lttng/clear-handle.h>
	16	#include <common/sessiond-comm/sessiond-comm.h>
	17	#include <common/macros.h>
	18	#include <common/compat/poll.h>
	19	#include <common/dynamic-buffer.h>
	20	#include <common/buffer-view.h>
	21	#include <common/optional.h>
	22
	23	#include "lttng-ctl-helper.h"
	24
	25	enum communication_state {
	26	COMMUNICATION_STATE_RECEIVE_LTTNG_MSG,
	27	COMMUNICATION_STATE_RECEIVE_COMMAND_HEADER,
	28	COMMUNICATION_STATE_END,
	29	COMMUNICATION_STATE_ERROR,
	30	};
	31
	32	struct lttng_clear_handle {
	33	LTTNG_OPTIONAL(enum lttng_error_code) clear_return_code;
	34	struct {
	35	int socket;
	36	struct lttng_poll_event events;
	37	size_t bytes_left_to_receive;
	38	enum communication_state state;
	39	struct lttng_dynamic_buffer buffer;
	40	LTTNG_OPTIONAL(size_t) data_size;
	41	} communication;
	42	};
	43
	44	void lttng_clear_handle_destroy(struct lttng_clear_handle *handle)
	45	{
	46	int ret;
	47
	48	if (!handle) {
	49	return;
	50	}
	51
	52	if (handle->communication.socket >= 0) {
	53	ret = close(handle->communication.socket);
	54	if (ret) {
	55	PERROR("Failed to close lttng-sessiond command socket");
	56	}
e429da85 JG	57	}
e429da85 JG	58	lttng_poll_clean(&handle->communication.events);
f2c1f0d4 MD	59	lttng_dynamic_buffer_reset(&handle->communication.buffer);
	60	free(handle);
	61	}
	62
	63	static
	64	struct lttng_clear_handle *lttng_clear_handle_create(int sessiond_socket)
	65	{
	66	int ret;
4bd69c5f	67	struct lttng_clear_handle handle = (lttng_clear_handle ) zmalloc(sizeof(*handle));
f2c1f0d4 MD	68
	69	if (!handle) {
	70	goto end;
	71	}
	72	lttng_dynamic_buffer_init(&handle->communication.buffer);
	73	handle->communication.socket = sessiond_socket;
	74	ret = lttng_poll_create(&handle->communication.events, 1, 0);
	75	if (ret) {
	76	goto error;
	77	}
	78
	79	ret = lttng_poll_add(&handle->communication.events, sessiond_socket,
	80	LPOLLIN \| LPOLLHUP \| LPOLLRDHUP \| LPOLLERR);
e429da85	81	if (ret) {
f2c1f0d4	82	goto error;
e429da85	83	}
f2c1f0d4 MD	84
	85	handle->communication.bytes_left_to_receive =
	86	sizeof(struct lttcomm_lttng_msg);
	87	handle->communication.state = COMMUNICATION_STATE_RECEIVE_LTTNG_MSG;
	88	end:
	89	return handle;
	90	error:
	91	lttng_clear_handle_destroy(handle);
	92	return NULL;
	93	}
	94
	95	static
	96	int handle_state_transition(struct lttng_clear_handle *handle)
	97	{
	98	int ret = 0;
	99
a0377dfe	100	LTTNG_ASSERT(handle->communication.bytes_left_to_receive == 0);
f2c1f0d4 MD	101
	102	switch (handle->communication.state) {
	103	case COMMUNICATION_STATE_RECEIVE_LTTNG_MSG:
	104	{
	105	const struct lttcomm_lttng_msg *msg =
	106	(typeof(msg)) handle->communication.buffer.data;
	107
	108	LTTNG_OPTIONAL_SET(&handle->clear_return_code,
	109	(enum lttng_error_code) msg->ret_code);
	110	if (handle->clear_return_code.value != LTTNG_OK) {
	111	handle->communication.state = COMMUNICATION_STATE_END;
	112	break;
	113	} else if (msg->cmd_header_size != 0 \|\| msg->data_size != 0) {
	114	handle->communication.state = COMMUNICATION_STATE_ERROR;
	115	ret = -1;
	116	break;
	117	}
	118
	119	handle->communication.state = COMMUNICATION_STATE_END;
	120	handle->communication.bytes_left_to_receive = 0;
	121	LTTNG_OPTIONAL_SET(&handle->communication.data_size, 0);
	122	ret = lttng_dynamic_buffer_set_size(
	123	&handle->communication.buffer, 0);
a0377dfe	124	LTTNG_ASSERT(!ret);
f2c1f0d4 MD	125	break;
	126	}
	127	default:
	128	abort();
	129	}
	130
	131	/* Clear reception buffer on state transition. */
	132	if (lttng_dynamic_buffer_set_size(&handle->communication.buffer, 0)) {
	133	abort();
	134	}
	135	return ret;
	136	}
	137
	138	static
	139	int handle_incoming_data(struct lttng_clear_handle *handle)
	140	{
	141	int ret;
	142	ssize_t comm_ret;
	143	const size_t original_buffer_size = handle->communication.buffer.size;
	144
	145	/* Reserve space for reception. */
	146	ret = lttng_dynamic_buffer_set_size(&handle->communication.buffer,
	147	original_buffer_size + handle->communication.bytes_left_to_receive);
	148	if (ret) {
	149	goto end;
	150	}
	151
	152	comm_ret = lttcomm_recv_unix_sock(handle->communication.socket,
	153	handle->communication.buffer.data + original_buffer_size,
	154	handle->communication.bytes_left_to_receive);
	155	if (comm_ret <= 0) {
	156	ret = -1;
	157	goto end;
	158	}
	159
	160	handle->communication.bytes_left_to_receive -= comm_ret;
	161	if (handle->communication.bytes_left_to_receive == 0) {
	162	ret = handle_state_transition(handle);
	163	} else {
	164	ret = lttng_dynamic_buffer_set_size(
	165	&handle->communication.buffer,
	166	original_buffer_size + comm_ret);
	167	}
	168	end:
	169	return ret;
	170	}
	171
	172	extern enum lttng_clear_handle_status
	173	lttng_clear_handle_wait_for_completion(
	174	struct lttng_clear_handle *handle, int timeout_ms)
	175	{
f2c1f0d4 MD	176	enum lttng_clear_handle_status status;
	177	unsigned long time_left_ms = 0;
	178	const bool has_timeout = timeout_ms > 0;
	179	struct timespec initial_time;
	180
e429da85	181	if (handle->communication.state == COMMUNICATION_STATE_ERROR) {
f2c1f0d4 MD	182	status = LTTNG_CLEAR_HANDLE_STATUS_ERROR;
	183	goto end;
	184	} else if (handle->communication.state == COMMUNICATION_STATE_END) {
	185	status = LTTNG_CLEAR_HANDLE_STATUS_COMPLETED;
	186	goto end;
	187	}
e429da85	188	if (has_timeout) {
bf3683d0	189	int ret = lttng_clock_gettime(CLOCK_MONOTONIC, &initial_time);
f2c1f0d4 MD	190	if (ret) {
	191	status = LTTNG_CLEAR_HANDLE_STATUS_ERROR;
	192	goto end;
	193	}
	194	time_left_ms = (unsigned long) timeout_ms;
e429da85	195	}
f2c1f0d4	196
e429da85	197	while (handle->communication.state != COMMUNICATION_STATE_END &&
f2c1f0d4 MD	198	(time_left_ms \|\| !has_timeout)) {
	199	int ret;
	200	uint32_t revents;
e429da85	201	struct timespec current_time, diff;
f2c1f0d4 MD	202	unsigned long diff_ms;
f2c1f0d4 MD	203
e429da85	204	ret = lttng_poll_wait(&handle->communication.events,
f2c1f0d4	205	has_timeout ? time_left_ms : -1);
e429da85	206	if (ret == 0) {
f2c1f0d4 MD	207	/* timeout */
	208	break;
	209	} else if (ret < 0) {
	210	status = LTTNG_CLEAR_HANDLE_STATUS_ERROR;
	211	goto end;
	212	}
	213
	214	/* The sessiond connection socket is the only monitored fd. */
	215	revents = LTTNG_POLL_GETEV(&handle->communication.events, 0);
	216	if (revents & LPOLLIN) {
	217	ret = handle_incoming_data(handle);
	218	if (ret) {
	219	handle->communication.state =
	220	COMMUNICATION_STATE_ERROR;
	221	status = LTTNG_CLEAR_HANDLE_STATUS_ERROR;
	222	goto end;
	223	}
	224	} else {
	225	handle->communication.state = COMMUNICATION_STATE_ERROR;
	226	status = LTTNG_CLEAR_HANDLE_STATUS_ERROR;
	227	goto end;
	228	}
	229	if (!has_timeout) {
	230	continue;
	231	}
	232
	233	ret = lttng_clock_gettime(CLOCK_MONOTONIC, &current_time);
	234	if (ret) {
	235	status = LTTNG_CLEAR_HANDLE_STATUS_ERROR;
	236	goto end;
	237	}
	238	diff = timespec_abs_diff(initial_time, current_time);
	239	ret = timespec_to_ms(diff, &diff_ms);
	240	if (ret) {
	241	ERR("Failed to compute elapsed time while waiting for completion");
	242	status = LTTNG_CLEAR_HANDLE_STATUS_ERROR;
	243	goto end;
	244	}
	245	DBG("%lums elapsed while waiting for session clear completion",
	246	diff_ms);
4bd69c5f SM	247	diff_ms = std::max(diff_ms, 1UL);
4bd69c5f SM	248	diff_ms = std::min(diff_ms, time_left_ms);
f2c1f0d4 MD	249	time_left_ms -= diff_ms;
	250	}
	251
	252	status = handle->communication.state == COMMUNICATION_STATE_END ?
	253	LTTNG_CLEAR_HANDLE_STATUS_COMPLETED :
	254	LTTNG_CLEAR_HANDLE_STATUS_TIMEOUT;
	255	end:
	256	return status;
	257	}
	258
	259	extern enum lttng_clear_handle_status
	260	lttng_clear_handle_get_result(
	261	const struct lttng_clear_handle *handle,
	262	enum lttng_error_code *result)
	263	{
	264	enum lttng_clear_handle_status status =
	265	LTTNG_CLEAR_HANDLE_STATUS_OK;
	266
	267	if (!handle->clear_return_code.is_set) {
	268	status = LTTNG_CLEAR_HANDLE_STATUS_INVALID;
	269	goto end;
	270	}
	271	*result = handle->clear_return_code.value;
	272	end:
	273	return status;
	274	}
	275
	276	/*
	277	* Clear the session
	278	*/
	279	enum lttng_error_code lttng_clear_session(const char *session_name,
	280	struct lttng_clear_handle **_handle)
	281	{
	282	enum lttng_error_code ret_code = LTTNG_OK;
	283	struct lttng_clear_handle *handle = NULL;
	284	struct lttcomm_session_msg lsm = {
	285	.cmd_type = LTTNG_CLEAR_SESSION,
	286	};
	287	int sessiond_socket = -1;
	288	ssize_t comm_ret;
	289	int ret;
	290
	291	if (session_name == NULL) {
	292	ret_code = LTTNG_ERR_INVALID;
	293	goto error;
	294	}
	295	ret = lttng_strncpy(lsm.session.name, session_name,
	296	sizeof(lsm.session.name));
	297	if (ret) {
	298	ret_code = LTTNG_ERR_INVALID;
	299	goto error;
	300	}
	301	ret = connect_sessiond();
	302	if (ret < 0) {
	303	ret_code = LTTNG_ERR_NO_SESSIOND;
	304	goto error;
	305	} else {
	306	sessiond_socket = ret;
	307	}
	308	handle = lttng_clear_handle_create(sessiond_socket);
	309	if (!handle) {
	310	ret_code = LTTNG_ERR_NOMEM;
	311	goto error;
	312	}
313	comm_ret = lttcomm_send_creds_unix_sock(sessiond_socket, &lsm, sizeof(lsm));
314	if (comm_ret < 0) {
315	ret_code = LTTNG_ERR_FATAL;
316	goto error;
317	}
318	sessiond_socket = -1;
319
320	error:
321	/* Transfer the handle to the caller. */
322	if (_handle) {
323	*_handle = handle;
324	handle = NULL;
325	}
326	if (sessiond_socket >= 0) {
327	ret = close(sessiond_socket);
328	if (ret < 0) {
329	PERROR("Failed to close the LTTng session daemon connection socket");
330	}
331	}
332	if (handle) {
333	lttng_clear_handle_destroy(handle);
334	}
335	return ret_code;
336	}