[lttng-tools.git] / src / bin / lttng-sessiond / manage-kernel.c

/*
 * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
 * Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 * Copyright (C) 2013 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 */

#include <common/pipe.h>
#include <common/utils.h>

#include "manage-kernel.h"
#include "testpoint.h"
#include "health-sessiond.h"
#include "utils.h"
#include "thread.h"
#include "kernel.h"
#include "kernel-consumer.h"

struct thread_notifiers {
	struct lttng_pipe *quit_pipe;
	int kernel_poll_pipe_read_fd;
};

/*
 * Update the kernel poll set of all channel fd available over all tracing
 * session. Add the wakeup pipe at the end of the set.
 */
static int update_kernel_poll(struct lttng_poll_event *events)
{
	int ret;
	struct ltt_kernel_channel *channel;
	struct ltt_session *session;
	const struct ltt_session_list *session_list = session_get_list();

	DBG("Updating kernel poll set");

	session_lock_list();
	cds_list_for_each_entry(session, &session_list->head, list) {
		if (!session_get(session)) {
			continue;
		}
		session_lock(session);
		if (session->kernel_session == NULL) {
			session_unlock(session);
			session_put(session);
			continue;
		}

		cds_list_for_each_entry(channel,
				&session->kernel_session->channel_list.head, list) {
			/* Add channel fd to the kernel poll set */
			ret = lttng_poll_add(events, channel->fd, LPOLLIN | LPOLLRDNORM);
			if (ret < 0) {
				session_unlock(session);
				session_put(session);
				goto error;
			}
			DBG("Channel fd %d added to kernel set", channel->fd);
		}
		session_unlock(session);
		session_put(session);
	}
	session_unlock_list();

	return 0;

error:
	session_unlock_list();
	return -1;
}

/*
 * Find the channel fd from 'fd' over all tracing session. When found, check
 * for new channel stream and send those stream fds to the kernel consumer.
 *
 * Useful for CPU hotplug feature.
 */
static int update_kernel_stream(int fd)
{
	int ret = 0;
	struct ltt_session *session;
	struct ltt_kernel_session *ksess;
	struct ltt_kernel_channel *channel;
	const struct ltt_session_list *session_list = session_get_list();

	DBG("Updating kernel streams for channel fd %d", fd);

	session_lock_list();
	cds_list_for_each_entry(session, &session_list->head, list) {
		if (!session_get(session)) {
			continue;
		}
		session_lock(session);
		if (session->kernel_session == NULL) {
			session_unlock(session);
			session_put(session);
			continue;
		}
		ksess = session->kernel_session;

		cds_list_for_each_entry(channel,
				&ksess->channel_list.head, list) {
			struct lttng_ht_iter iter;
			struct consumer_socket *socket;

			if (channel->fd != fd) {
				continue;
			}
			DBG("Channel found, updating kernel streams");
			ret = kernel_open_channel_stream(channel);
			if (ret < 0) {
				goto error;
			}
			/* Update the stream global counter */
			ksess->stream_count_global += ret;

			/*
			 * Have we already sent fds to the consumer? If yes, it
			 * means that tracing is started so it is safe to send
			 * our updated stream fds.
			 */
			if (ksess->consumer_fds_sent != 1
					|| ksess->consumer == NULL) {
				ret = -1;
				goto error;
			}

			rcu_read_lock();
			cds_lfht_for_each_entry(ksess->consumer->socks->ht,
					&iter.iter, socket, node.node) {
				pthread_mutex_lock(socket->lock);
				ret = kernel_consumer_send_channel_streams(socket,
						channel, ksess,
						session->output_traces ? 1 : 0);
				pthread_mutex_unlock(socket->lock);
				if (ret < 0) {
					rcu_read_unlock();
					goto error;
				}
			}
			rcu_read_unlock();
		}
		session_unlock(session);
		session_put(session);
	}
	session_unlock_list();
	return ret;

error:
	session_unlock(session);
	session_put(session);
	session_unlock_list();
	return ret;
}

/*
 * This thread manage event coming from the kernel.
 *
 * Features supported in this thread:
 *    -) CPU Hotplug
 */
static void *thread_kernel_management(void *data)
{
	int ret, i, pollfd, update_poll_flag = 1, err = -1;
	uint32_t revents, nb_fd;
	char tmp;
	struct lttng_poll_event events;
	struct thread_notifiers *notifiers = data;
	const int quit_pipe_read_fd = lttng_pipe_get_readfd(notifiers->quit_pipe);

	DBG("[thread] Thread manage kernel started");

	health_register(health_sessiond, HEALTH_SESSIOND_TYPE_KERNEL);

	/*
	 * This first step of the while is to clean this structure which could free
	 * non NULL pointers so initialize it before the loop.
	 */
	lttng_poll_init(&events);

	if (testpoint(sessiond_thread_manage_kernel)) {
		goto error_testpoint;
	}

	health_code_update();

	if (testpoint(sessiond_thread_manage_kernel_before_loop)) {
		goto error_testpoint;
	}

	while (1) {
		health_code_update();

		if (update_poll_flag == 1) {
			/* Clean events object. We are about to populate it again. */
			lttng_poll_clean(&events);

			ret = lttng_poll_create(&events, 2, LTTNG_CLOEXEC);
			if (ret < 0) {
				goto error_poll_create;
			}

			ret = lttng_poll_add(&events,
					notifiers->kernel_poll_pipe_read_fd,
					LPOLLIN);
			if (ret < 0) {
				goto error;
			}

			ret = lttng_poll_add(&events,
					quit_pipe_read_fd,
					LPOLLIN);
			if (ret < 0) {
				goto error;
			}

			/* This will add the available kernel channel if any. */
			ret = update_kernel_poll(&events);
			if (ret < 0) {
				goto error;
			}
			update_poll_flag = 0;
		}

		DBG("Thread kernel polling");

		/* Poll infinite value of time */
	restart:
		health_poll_entry();
		ret = lttng_poll_wait(&events, -1);
		DBG("Thread kernel return from poll on %d fds",
				LTTNG_POLL_GETNB(&events));
		health_poll_exit();
		if (ret < 0) {
			/*
			 * Restart interrupted system call.
			 */
			if (errno == EINTR) {
				goto restart;
			}
			goto error;
		} else if (ret == 0) {
			/* Should not happen since timeout is infinite */
			ERR("Return value of poll is 0 with an infinite timeout.\n"
				"This should not have happened! Continuing...");
			continue;
		}

		nb_fd = ret;

		for (i = 0; i < nb_fd; i++) {
			/* Fetch once the poll data */
			revents = LTTNG_POLL_GETEV(&events, i);
			pollfd = LTTNG_POLL_GETFD(&events, i);

			health_code_update();

			if (pollfd == quit_pipe_read_fd) {
				err = 0;
				goto exit;
			}

			/* Check for data on kernel pipe */
			if (revents & LPOLLIN) {
				if (pollfd == notifiers->kernel_poll_pipe_read_fd) {
					(void) lttng_read(notifiers->kernel_poll_pipe_read_fd,
						&tmp, 1);
					/*
					 * Ret value is useless here, if this pipe gets any actions an
					 * update is required anyway.
					 */
					update_poll_flag = 1;
					continue;
				} else {
					/*
					 * New CPU detected by the kernel. Adding kernel stream to
					 * kernel session and updating the kernel consumer
					 */
					ret = update_kernel_stream(pollfd);
					if (ret < 0) {
						continue;
					}
					break;
				}
			} else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
				update_poll_flag = 1;
				continue;
			} else {
				ERR("Unexpected poll events %u for sock %d", revents, pollfd);
				goto error;
			}
		}
	}

exit:
error:
	lttng_poll_clean(&events);
error_poll_create:
error_testpoint:
	if (err) {
		health_error();
		ERR("Health error occurred in %s", __func__);
		WARN("Kernel thread died unexpectedly. "
				"Kernel tracing can continue but CPU hotplug is disabled.");
	}
	health_unregister(health_sessiond);
	DBG("Kernel thread dying");
	return NULL;
}

static bool shutdown_kernel_management_thread(void *data)
{
	struct thread_notifiers *notifiers = data;
	const int write_fd = lttng_pipe_get_writefd(notifiers->quit_pipe);

	return notify_thread_pipe(write_fd) == 1;
}

static void cleanup_kernel_management_thread(void *data)
{
	struct thread_notifiers *notifiers = data;

	lttng_pipe_destroy(notifiers->quit_pipe);
	free(notifiers);
}

bool launch_kernel_management_thread(int kernel_poll_pipe_read_fd)
{
	struct lttng_pipe *quit_pipe;
	struct thread_notifiers *notifiers = NULL;
	struct lttng_thread *thread;

	notifiers = zmalloc(sizeof(*notifiers));
	if (!notifiers) {
		goto error_alloc;
	}
	quit_pipe = lttng_pipe_open(FD_CLOEXEC);
	if (!quit_pipe) {
		goto error;
	}
	notifiers->quit_pipe = quit_pipe;
	notifiers->kernel_poll_pipe_read_fd = kernel_poll_pipe_read_fd;

	thread = lttng_thread_create("Kernel management",
			thread_kernel_management,
			shutdown_kernel_management_thread,
			cleanup_kernel_management_thread,
			notifiers);
	if (!thread) {
		goto error;
	}
	lttng_thread_put(thread);
	return true;
error:
	cleanup_kernel_management_thread(notifiers);
error_alloc:
	return false;
}
Commit	Line	Data
5b093681	1	/*
ab5be9fa MJ	2	* Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
	3	* Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	4	* Copyright (C) 2013 Jérémie Galarneau <jeremie.galarneau@efficios.com>
5b093681	5	*
ab5be9fa	6	* SPDX-License-Identifier: GPL-2.0-only
5b093681	7	*
5b093681 JG	8	*/
	9
	10	#include <common/pipe.h>
	11	#include <common/utils.h>
	12
	13	#include "manage-kernel.h"
	14	#include "testpoint.h"
	15	#include "health-sessiond.h"
	16	#include "utils.h"
	17	#include "thread.h"
	18	#include "kernel.h"
	19	#include "kernel-consumer.h"
	20
	21	struct thread_notifiers {
	22	struct lttng_pipe *quit_pipe;
	23	int kernel_poll_pipe_read_fd;
	24	};
	25
	26	/*
	27	* Update the kernel poll set of all channel fd available over all tracing
	28	* session. Add the wakeup pipe at the end of the set.
	29	*/
	30	static int update_kernel_poll(struct lttng_poll_event *events)
	31	{
	32	int ret;
	33	struct ltt_kernel_channel *channel;
	34	struct ltt_session *session;
	35	const struct ltt_session_list *session_list = session_get_list();
	36
	37	DBG("Updating kernel poll set");
	38
	39	session_lock_list();
	40	cds_list_for_each_entry(session, &session_list->head, list) {
	41	if (!session_get(session)) {
	42	continue;
	43	}
	44	session_lock(session);
	45	if (session->kernel_session == NULL) {
	46	session_unlock(session);
	47	session_put(session);
	48	continue;
	49	}
	50
	51	cds_list_for_each_entry(channel,
	52	&session->kernel_session->channel_list.head, list) {
	53	/* Add channel fd to the kernel poll set */
	54	ret = lttng_poll_add(events, channel->fd, LPOLLIN \| LPOLLRDNORM);
	55	if (ret < 0) {
	56	session_unlock(session);
	57	session_put(session);
	58	goto error;
	59	}
	60	DBG("Channel fd %d added to kernel set", channel->fd);
	61	}
	62	session_unlock(session);
0318876b	63	session_put(session);
5b093681 JG	64	}
	65	session_unlock_list();
	66
	67	return 0;
	68
	69	error:
	70	session_unlock_list();
	71	return -1;
	72	}
	73
	74	/*
	75	* Find the channel fd from 'fd' over all tracing session. When found, check
	76	* for new channel stream and send those stream fds to the kernel consumer.
	77	*
	78	* Useful for CPU hotplug feature.
	79	*/
	80	static int update_kernel_stream(int fd)
	81	{
	82	int ret = 0;
	83	struct ltt_session *session;
	84	struct ltt_kernel_session *ksess;
	85	struct ltt_kernel_channel *channel;
	86	const struct ltt_session_list *session_list = session_get_list();
	87
	88	DBG("Updating kernel streams for channel fd %d", fd);
	89
	90	session_lock_list();
	91	cds_list_for_each_entry(session, &session_list->head, list) {
	92	if (!session_get(session)) {
	93	continue;
	94	}
	95	session_lock(session);
	96	if (session->kernel_session == NULL) {
	97	session_unlock(session);
	98	session_put(session);
	99	continue;
	100	}
	101	ksess = session->kernel_session;
	102
	103	cds_list_for_each_entry(channel,
	104	&ksess->channel_list.head, list) {
	105	struct lttng_ht_iter iter;
	106	struct consumer_socket *socket;
	107
	108	if (channel->fd != fd) {
	109	continue;
	110	}
	111	DBG("Channel found, updating kernel streams");
	112	ret = kernel_open_channel_stream(channel);
	113	if (ret < 0) {
	114	goto error;
	115	}
	116	/* Update the stream global counter */
	117	ksess->stream_count_global += ret;
	118
	119	/*
	120	* Have we already sent fds to the consumer? If yes, it
	121	* means that tracing is started so it is safe to send
	122	* our updated stream fds.
	123	*/
	124	if (ksess->consumer_fds_sent != 1
	125	\|\| ksess->consumer == NULL) {
	126	ret = -1;
	127	goto error;
128	}
129
130	rcu_read_lock();
131	cds_lfht_for_each_entry(ksess->consumer->socks->ht,
132	&iter.iter, socket, node.node) {
133	pthread_mutex_lock(socket->lock);
134	ret = kernel_consumer_send_channel_streams(socket,
135	channel, ksess,
136	session->output_traces ? 1 : 0);
137	pthread_mutex_unlock(socket->lock);
138	if (ret < 0) {
139	rcu_read_unlock();
140	goto error;
141	}
142	}
143	rcu_read_unlock();
144	}
145	session_unlock(session);
146	session_put(session);
147	}
148	session_unlock_list();
149	return ret;
150
151	error:
152	session_unlock(session);
153	session_put(session);
154	session_unlock_list();
155	return ret;
156	}
157
158	/*
159	* This thread manage event coming from the kernel.
160	*
161	* Features supported in this thread:
162	* -) CPU Hotplug
163	*/
164	static void thread_kernel_management(void data)
165	{
166	int ret, i, pollfd, update_poll_flag = 1, err = -1;
167	uint32_t revents, nb_fd;
168	char tmp;
169	struct lttng_poll_event events;
170	struct thread_notifiers *notifiers = data;
171	const int quit_pipe_read_fd = lttng_pipe_get_readfd(notifiers->quit_pipe);
172
173	DBG("[thread] Thread manage kernel started");
174
175	health_register(health_sessiond, HEALTH_SESSIOND_TYPE_KERNEL);
176
177	/*
178	* This first step of the while is to clean this structure which could free
179	* non NULL pointers so initialize it before the loop.
180	*/
181	lttng_poll_init(&events);
182
183	if (testpoint(sessiond_thread_manage_kernel)) {
184	goto error_testpoint;
185	}
186
187	health_code_update();
188
189	if (testpoint(sessiond_thread_manage_kernel_before_loop)) {
190	goto error_testpoint;
191	}
192
193	while (1) {
194	health_code_update();
195
196	if (update_poll_flag == 1) {
197	/* Clean events object. We are about to populate it again. */
198	lttng_poll_clean(&events);
199
200	ret = lttng_poll_create(&events, 2, LTTNG_CLOEXEC);
201	if (ret < 0) {
202	goto error_poll_create;
203	}
204
205	ret = lttng_poll_add(&events,
206	notifiers->kernel_poll_pipe_read_fd,
207	LPOLLIN);
208	if (ret < 0) {
209	goto error;
210	}
211
212	ret = lttng_poll_add(&events,
213	quit_pipe_read_fd,
214	LPOLLIN);
215	if (ret < 0) {
216	goto error;
217	}
218
219	/* This will add the available kernel channel if any. */
220	ret = update_kernel_poll(&events);
221	if (ret < 0) {
222	goto error;
223	}
224	update_poll_flag = 0;
225	}
226
227	DBG("Thread kernel polling");
228
229	/* Poll infinite value of time */
230	restart:
231	health_poll_entry();
232	ret = lttng_poll_wait(&events, -1);
233	DBG("Thread kernel return from poll on %d fds",
234	LTTNG_POLL_GETNB(&events));
235	health_poll_exit();
236	if (ret < 0) {
237	/*
238	* Restart interrupted system call.
239	*/
240	if (errno == EINTR) {
241	goto restart;
242	}
243	goto error;
244	} else if (ret == 0) {
245	/* Should not happen since timeout is infinite */
246	ERR("Return value of poll is 0 with an infinite timeout.\n"
247	"This should not have happened! Continuing...");
248	continue;
249	}
250
251	nb_fd = ret;
252
253	for (i = 0; i < nb_fd; i++) {
254	/* Fetch once the poll data */
255	revents = LTTNG_POLL_GETEV(&events, i);
256	pollfd = LTTNG_POLL_GETFD(&events, i);
257
258	health_code_update();
259
5b093681 JG	260	if (pollfd == quit_pipe_read_fd) {
	261	err = 0;
	262	goto exit;
	263	}
	264
	265	/* Check for data on kernel pipe */
	266	if (revents & LPOLLIN) {
	267	if (pollfd == notifiers->kernel_poll_pipe_read_fd) {
	268	(void) lttng_read(notifiers->kernel_poll_pipe_read_fd,
	269	&tmp, 1);
	270	/*
	271	* Ret value is useless here, if this pipe gets any actions an
	272	* update is required anyway.
	273	*/
	274	update_poll_flag = 1;
	275	continue;
	276	} else {
	277	/*
	278	* New CPU detected by the kernel. Adding kernel stream to
	279	* kernel session and updating the kernel consumer
	280	*/
	281	ret = update_kernel_stream(pollfd);
	282	if (ret < 0) {
	283	continue;
	284	}
	285	break;
	286	}
	287	} else if (revents & (LPOLLERR \| LPOLLHUP \| LPOLLRDHUP)) {
	288	update_poll_flag = 1;
	289	continue;
	290	} else {
	291	ERR("Unexpected poll events %u for sock %d", revents, pollfd);
	292	goto error;
	293	}
	294	}
	295	}
	296
	297	exit:
	298	error:
	299	lttng_poll_clean(&events);
	300	error_poll_create:
	301	error_testpoint:
	302	if (err) {
	303	health_error();
	304	ERR("Health error occurred in %s", __func__);
	305	WARN("Kernel thread died unexpectedly. "
	306	"Kernel tracing can continue but CPU hotplug is disabled.");
	307	}
	308	health_unregister(health_sessiond);
	309	DBG("Kernel thread dying");
	310	return NULL;
	311	}
	312
	313	static bool shutdown_kernel_management_thread(void *data)
	314	{
	315	struct thread_notifiers *notifiers = data;
	316	const int write_fd = lttng_pipe_get_writefd(notifiers->quit_pipe);
	317
	318	return notify_thread_pipe(write_fd) == 1;
	319	}
	320
	321	static void cleanup_kernel_management_thread(void *data)
	322	{
	323	struct thread_notifiers *notifiers = data;
324
325	lttng_pipe_destroy(notifiers->quit_pipe);
326	free(notifiers);
327	}
328
329	bool launch_kernel_management_thread(int kernel_poll_pipe_read_fd)
330	{
331	struct lttng_pipe *quit_pipe;
332	struct thread_notifiers *notifiers = NULL;
333	struct lttng_thread *thread;
334
5b093681 JG	335	notifiers = zmalloc(sizeof(*notifiers));
5b093681 JG	336	if (!notifiers) {
21fa020e JG	337	goto error_alloc;
	338	}
	339	quit_pipe = lttng_pipe_open(FD_CLOEXEC);
	340	if (!quit_pipe) {
5b093681 JG	341	goto error;
	342	}
	343	notifiers->quit_pipe = quit_pipe;
	344	notifiers->kernel_poll_pipe_read_fd = kernel_poll_pipe_read_fd;
	345
	346	thread = lttng_thread_create("Kernel management",
	347	thread_kernel_management,
	348	shutdown_kernel_management_thread,
	349	cleanup_kernel_management_thread,
	350	notifiers);
	351	if (!thread) {
	352	goto error;
	353	}
	354	lttng_thread_put(thread);
	355	return true;
	356	error:
	357	cleanup_kernel_management_thread(notifiers);
21fa020e	358	error_alloc:
5b093681 JG	359	return false;
5b093681 JG	360	}