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

/*
 * Copyright (C) 2017 - Julien Desfossez <jdesfossez@efficios.com>
 * Copyright (C) 2018 - Jérémie Galarneau <jeremie.galarneau@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 <assert.h>
#include <inttypes.h>
#include <signal.h>

#include "timer.h"
#include "health-sessiond.h"
#include "rotation-thread.h"
#include "thread.h"

#define LTTNG_SESSIOND_SIG_QS				SIGRTMIN + 10
#define LTTNG_SESSIOND_SIG_EXIT				SIGRTMIN + 11
#define LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK	SIGRTMIN + 12
#define LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION		SIGRTMIN + 13

#define UINT_TO_PTR(value)				\
	({						\
		assert(value <= UINTPTR_MAX);		\
		(void *) (uintptr_t) value;		\
	})
#define PTR_TO_UINT(ptr) ((uintptr_t) ptr)

/*
 * Handle timer teardown race wrt memory free of private data by sessiond
 * signals are handled by a single thread, which permits a synchronization
 * point between handling of each signal. Internal lock ensures mutual
 * exclusion.
 */
static
struct timer_signal_data {
	/* Thread managing signals. */
	pthread_t tid;
	int qs_done;
	pthread_mutex_t lock;
} timer_signal = {
	.tid = 0,
	.qs_done = 0,
	.lock = PTHREAD_MUTEX_INITIALIZER,
};

/*
 * Set custom signal mask to current thread.
 */
static
void setmask(sigset_t *mask)
{
	int ret;

	ret = sigemptyset(mask);
	if (ret) {
		PERROR("sigemptyset");
	}
	ret = sigaddset(mask, LTTNG_SESSIOND_SIG_QS);
	if (ret) {
		PERROR("sigaddset teardown");
	}
	ret = sigaddset(mask, LTTNG_SESSIOND_SIG_EXIT);
	if (ret) {
		PERROR("sigaddset exit");
	}
	ret = sigaddset(mask, LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK);
	if (ret) {
		PERROR("sigaddset pending rotation check");
	}
	ret = sigaddset(mask, LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION);
	if (ret) {
		PERROR("sigaddset scheduled rotation");
	}
}

/*
 * This is the same function as timer_signal_thread_qs, when it
 * returns, it means that no timer signr is currently pending or being handled
 * by the timer thread. This cannot be called from the timer thread.
 */
static
void timer_signal_thread_qs(unsigned int signr)
{
	sigset_t pending_set;
	int ret;

	/*
	 * We need to be the only thread interacting with the thread
	 * that manages signals for teardown synchronization.
	 */
	pthread_mutex_lock(&timer_signal.lock);

	/* Ensure we don't have any signal queued for this session. */
	for (;;) {
		ret = sigemptyset(&pending_set);
		if (ret == -1) {
			PERROR("sigemptyset");
		}
		ret = sigpending(&pending_set);
		if (ret == -1) {
			PERROR("sigpending");
		}
		if (!sigismember(&pending_set, signr)) {
			break;
		}
		caa_cpu_relax();
	}

	/*
	 * From this point, no new signal handler will be fired that would try to
	 * access "session". However, we still need to wait for any currently
	 * executing handler to complete.
	 */
	cmm_smp_mb();
	CMM_STORE_SHARED(timer_signal.qs_done, 0);
	cmm_smp_mb();

	/*
	 * Kill with LTTNG_SESSIOND_SIG_QS, so signal management thread
	 * wakes up.
	 */
	kill(getpid(), LTTNG_SESSIOND_SIG_QS);

	while (!CMM_LOAD_SHARED(timer_signal.qs_done)) {
		caa_cpu_relax();
	}
	cmm_smp_mb();

	pthread_mutex_unlock(&timer_signal.lock);
}

/*
 * Start a timer on a session that will fire at a given interval
 * (timer_interval_us) and fire a given signal (signal).
 *
 * Returns a negative value on error, 0 if a timer was created, and
 * a positive value if no timer was created (not an error).
 */
static
int timer_start(timer_t *timer_id, struct ltt_session *session,
		unsigned int timer_interval_us, int signal, bool one_shot)
{
	int ret = 0, delete_ret;
	struct sigevent sev;
	struct itimerspec its;

	sev.sigev_notify = SIGEV_SIGNAL;
	sev.sigev_signo = signal;
	sev.sigev_value.sival_ptr = session;
	ret = timer_create(CLOCK_MONOTONIC, &sev, timer_id);
	if (ret == -1) {
		PERROR("timer_create");
		goto end;
	}

	its.it_value.tv_sec = timer_interval_us / 1000000;
	its.it_value.tv_nsec = (timer_interval_us % 1000000) * 1000;
	if (one_shot) {
		its.it_interval.tv_sec = 0;
		its.it_interval.tv_nsec = 0;
	} else {
		its.it_interval.tv_sec = its.it_value.tv_sec;
		its.it_interval.tv_nsec = its.it_value.tv_nsec;
	}

	ret = timer_settime(*timer_id, 0, &its, NULL);
	if (ret == -1) {
		PERROR("timer_settime");
		goto error_destroy_timer;
	}
	goto end;

error_destroy_timer:
	delete_ret = timer_delete(*timer_id);
	if (delete_ret == -1) {
		PERROR("timer_delete");
	}

end:
	return ret;
}

static
int timer_stop(timer_t *timer_id, int signal)
{
	int ret = 0;

	ret = timer_delete(*timer_id);
	if (ret == -1) {
		PERROR("timer_delete");
		goto end;
	}

	timer_signal_thread_qs(signal);
	*timer_id = 0;
end:
	return ret;
}

int timer_session_rotation_pending_check_start(struct ltt_session *session,
		unsigned int interval_us)
{
	int ret;

	if (!session_get(session)) {
		ret = -1;
		goto end;
	}
	DBG("Enabling session rotation pending check timer on session %" PRIu64,
			session->id);
	/*
	 * We arm this timer in a one-shot mode so we don't have to disable it
	 * explicitly (which could deadlock if the timer thread is blocked
	 * writing in the rotation_timer_pipe).
	 *
	 * Instead, we re-arm it if needed after the rotation_pending check as
	 * returned. Also, this timer is usually only needed once, so there is
	 * no need to go through the whole signal teardown scheme everytime.
	 */
	ret = timer_start(&session->rotation_pending_check_timer,
			session, interval_us,
			LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK,
			/* one-shot */ true);
	if (ret == 0) {
		session->rotation_pending_check_timer_enabled = true;
	}
end:
	return ret;
}

/*
 * Call with session and session_list locks held.
 */
int timer_session_rotation_pending_check_stop(struct ltt_session *session)
{
	int ret;

	assert(session);
	assert(session->rotation_pending_check_timer_enabled);

	DBG("Disabling session rotation pending check timer on session %" PRIu64,
			session->id);
	ret = timer_stop(&session->rotation_pending_check_timer,
			LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK);
	if (ret == -1) {
		ERR("Failed to stop rotate_pending_check timer");
	} else {
		session->rotation_pending_check_timer_enabled = false;
		/*
		 * The timer's reference to the session can be released safely.
		 */
		session_put(session);
	}
	return ret;
}

/*
 * Call with session and session_list locks held.
 */
int timer_session_rotation_schedule_timer_start(struct ltt_session *session,
		unsigned int interval_us)
{
	int ret;

	if (!session_get(session)) {
		ret = -1;
		goto end;
	}
	DBG("Enabling scheduled rotation timer on session \"%s\" (%ui µs)", session->name,
			interval_us);
	ret = timer_start(&session->rotation_schedule_timer, session,
			interval_us, LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION,
			/* one-shot */ false);
	if (ret < 0) {
		goto end;
	}
	session->rotation_schedule_timer_enabled = true;
end:
	return ret;
}

/*
 * Call with session and session_list locks held.
 */
int timer_session_rotation_schedule_timer_stop(struct ltt_session *session)
{
	int ret = 0;

	assert(session);

	if (!session->rotation_schedule_timer_enabled) {
		goto end;
	}

	DBG("Disabling scheduled rotation timer on session %s", session->name);
	ret = timer_stop(&session->rotation_schedule_timer,
			LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION);
	if (ret < 0) {
		ERR("Failed to stop scheduled rotation timer of session \"%s\"",
				session->name);
		goto end;
	}

	session->rotation_schedule_timer_enabled = false;
	/* The timer's reference to the session can be released safely. */
	session_put(session);
	ret = 0;
end:
	return ret;
}

/*
 * Block the RT signals for the entire process. It must be called from the
 * sessiond main before creating the threads
 */
int timer_signal_init(void)
{
	int ret;
	sigset_t mask;

	/* Block signal for entire process, so only our thread processes it. */
	setmask(&mask);
	ret = pthread_sigmask(SIG_BLOCK, &mask, NULL);
	if (ret) {
		errno = ret;
		PERROR("pthread_sigmask");
		return -1;
	}
	return 0;
}

/*
 * This thread is the sighandler for the timer signals.
 */
static
void *thread_timer(void *data)
{
	int signr;
	sigset_t mask;
	siginfo_t info;
	struct timer_thread_parameters *ctx = data;

	rcu_register_thread();
	rcu_thread_online();

	health_register(health_sessiond, HEALTH_SESSIOND_TYPE_TIMER);
	health_code_update();

	/* Only self thread will receive signal mask. */
	setmask(&mask);
	CMM_STORE_SHARED(timer_signal.tid, pthread_self());

	while (1) {
		health_code_update();

		health_poll_entry();
		signr = sigwaitinfo(&mask, &info);
		health_poll_exit();

		/*
		 * NOTE: cascading conditions are used instead of a switch case
		 * since the use of SIGRTMIN in the definition of the signals'
		 * values prevents the reduction to an integer constant.
		 */
		if (signr == -1) {
			if (errno != EINTR) {
				PERROR("sigwaitinfo");
			}
			continue;
		} else if (signr == LTTNG_SESSIOND_SIG_QS) {
			cmm_smp_mb();
			CMM_STORE_SHARED(timer_signal.qs_done, 1);
			cmm_smp_mb();
		} else if (signr == LTTNG_SESSIOND_SIG_EXIT) {
			goto end;
		} else if (signr == LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK) {
			struct ltt_session *session =
					(struct ltt_session *) info.si_value.sival_ptr;

			rotation_thread_enqueue_job(ctx->rotation_thread_job_queue,
					ROTATION_THREAD_JOB_TYPE_CHECK_PENDING_ROTATION,
					session);
		} else if (signr == LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION) {
			rotation_thread_enqueue_job(ctx->rotation_thread_job_queue,
					ROTATION_THREAD_JOB_TYPE_SCHEDULED_ROTATION,
					(struct ltt_session *) info.si_value.sival_ptr);
			/*
			 * The scheduled periodic rotation timer is not in
			 * "one-shot" mode. The reference to the session is not
			 * released since the timer is still enabled and can
			 * still fire.
			 */
		} else {
			ERR("Unexpected signal %d\n", info.si_signo);
		}
	}

end:
	DBG("[timer-thread] Exit");
	health_unregister(health_sessiond);
	rcu_thread_offline();
	rcu_unregister_thread();
	return NULL;
}

static
bool shutdown_timer_thread(void *data)
{
	return kill(getpid(), LTTNG_SESSIOND_SIG_EXIT) == 0;
}

bool launch_timer_thread(
		struct timer_thread_parameters *timer_thread_parameters)
{
	struct lttng_thread *thread;

	thread = lttng_thread_create("Timer",
			thread_timer,
			shutdown_timer_thread,
			NULL,
			timer_thread_parameters);
	if (!thread) {
		goto error;
	}
	lttng_thread_put(thread);
	return true;
error:
	return false;
}
Commit	Line	Data
	1	/*
	2	* Copyright (C) 2017 - Julien Desfossez <jdesfossez@efficios.com>
	3	* Copyright (C) 2018 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License, version 2 only, as
	7	* published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	* more details.
	13	*
	14	* You should have received a copy of the GNU General Public License along with
	15	* this program; if not, write to the Free Software Foundation, Inc., 51
	16	* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	17	*/
	18
	19	#define _LGPL_SOURCE
	20	#include <assert.h>
	21	#include <inttypes.h>
	22	#include <signal.h>
	23
	24	#include "timer.h"
	25	#include "health-sessiond.h"
	26	#include "rotation-thread.h"
	27	#include "thread.h"
	28
	29	#define LTTNG_SESSIOND_SIG_QS SIGRTMIN + 10
	30	#define LTTNG_SESSIOND_SIG_EXIT SIGRTMIN + 11
	31	#define LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK SIGRTMIN + 12
	32	#define LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION SIGRTMIN + 13
	33
	34	#define UINT_TO_PTR(value) \
	35	({ \
	36	assert(value <= UINTPTR_MAX); \
	37	(void *) (uintptr_t) value; \
	38	})
	39	#define PTR_TO_UINT(ptr) ((uintptr_t) ptr)
	40
	41	/*
	42	* Handle timer teardown race wrt memory free of private data by sessiond
	43	* signals are handled by a single thread, which permits a synchronization
	44	* point between handling of each signal. Internal lock ensures mutual
	45	* exclusion.
	46	*/
	47	static
	48	struct timer_signal_data {
	49	/* Thread managing signals. */
	50	pthread_t tid;
	51	int qs_done;
	52	pthread_mutex_t lock;
	53	} timer_signal = {
	54	.tid = 0,
	55	.qs_done = 0,
	56	.lock = PTHREAD_MUTEX_INITIALIZER,
	57	};
	58
	59	/*
	60	* Set custom signal mask to current thread.
	61	*/
	62	static
	63	void setmask(sigset_t *mask)
	64	{
	65	int ret;
	66
	67	ret = sigemptyset(mask);
	68	if (ret) {
	69	PERROR("sigemptyset");
	70	}
	71	ret = sigaddset(mask, LTTNG_SESSIOND_SIG_QS);
	72	if (ret) {
	73	PERROR("sigaddset teardown");
	74	}
	75	ret = sigaddset(mask, LTTNG_SESSIOND_SIG_EXIT);
	76	if (ret) {
	77	PERROR("sigaddset exit");
	78	}
	79	ret = sigaddset(mask, LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK);
	80	if (ret) {
	81	PERROR("sigaddset pending rotation check");
	82	}
	83	ret = sigaddset(mask, LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION);
	84	if (ret) {
	85	PERROR("sigaddset scheduled rotation");
	86	}
	87	}
	88
	89	/*
	90	* This is the same function as timer_signal_thread_qs, when it
	91	* returns, it means that no timer signr is currently pending or being handled
	92	* by the timer thread. This cannot be called from the timer thread.
	93	*/
	94	static
	95	void timer_signal_thread_qs(unsigned int signr)
	96	{
	97	sigset_t pending_set;
	98	int ret;
	99
	100	/*
	101	* We need to be the only thread interacting with the thread
	102	* that manages signals for teardown synchronization.
	103	*/
	104	pthread_mutex_lock(&timer_signal.lock);
	105
	106	/* Ensure we don't have any signal queued for this session. */
	107	for (;;) {
	108	ret = sigemptyset(&pending_set);
	109	if (ret == -1) {
	110	PERROR("sigemptyset");
	111	}
	112	ret = sigpending(&pending_set);
	113	if (ret == -1) {
	114	PERROR("sigpending");
	115	}
	116	if (!sigismember(&pending_set, signr)) {
	117	break;
	118	}
	119	caa_cpu_relax();
	120	}
	121
	122	/*
	123	* From this point, no new signal handler will be fired that would try to
	124	* access "session". However, we still need to wait for any currently
	125	* executing handler to complete.
	126	*/
	127	cmm_smp_mb();
	128	CMM_STORE_SHARED(timer_signal.qs_done, 0);
	129	cmm_smp_mb();
	130
	131	/*
	132	* Kill with LTTNG_SESSIOND_SIG_QS, so signal management thread
	133	* wakes up.
	134	*/
	135	kill(getpid(), LTTNG_SESSIOND_SIG_QS);
	136
	137	while (!CMM_LOAD_SHARED(timer_signal.qs_done)) {
	138	caa_cpu_relax();
	139	}
	140	cmm_smp_mb();
	141
	142	pthread_mutex_unlock(&timer_signal.lock);
	143	}
	144
	145	/*
	146	* Start a timer on a session that will fire at a given interval
	147	* (timer_interval_us) and fire a given signal (signal).
	148	*
	149	* Returns a negative value on error, 0 if a timer was created, and
	150	* a positive value if no timer was created (not an error).
	151	*/
	152	static
	153	int timer_start(timer_t timer_id, struct ltt_session session,
	154	unsigned int timer_interval_us, int signal, bool one_shot)
	155	{
	156	int ret = 0, delete_ret;
	157	struct sigevent sev;
	158	struct itimerspec its;
	159
	160	sev.sigev_notify = SIGEV_SIGNAL;
	161	sev.sigev_signo = signal;
	162	sev.sigev_value.sival_ptr = session;
	163	ret = timer_create(CLOCK_MONOTONIC, &sev, timer_id);
	164	if (ret == -1) {
	165	PERROR("timer_create");
	166	goto end;
	167	}
	168
	169	its.it_value.tv_sec = timer_interval_us / 1000000;
	170	its.it_value.tv_nsec = (timer_interval_us % 1000000) * 1000;
	171	if (one_shot) {
	172	its.it_interval.tv_sec = 0;
	173	its.it_interval.tv_nsec = 0;
	174	} else {
	175	its.it_interval.tv_sec = its.it_value.tv_sec;
	176	its.it_interval.tv_nsec = its.it_value.tv_nsec;
	177	}
	178
	179	ret = timer_settime(*timer_id, 0, &its, NULL);
	180	if (ret == -1) {
	181	PERROR("timer_settime");
	182	goto error_destroy_timer;
	183	}
	184	goto end;
	185
	186	error_destroy_timer:
	187	delete_ret = timer_delete(*timer_id);
	188	if (delete_ret == -1) {
	189	PERROR("timer_delete");
	190	}
	191
	192	end:
	193	return ret;
	194	}
	195
	196	static
	197	int timer_stop(timer_t *timer_id, int signal)
	198	{
	199	int ret = 0;
	200
	201	ret = timer_delete(*timer_id);
	202	if (ret == -1) {
	203	PERROR("timer_delete");
	204	goto end;
	205	}
	206
	207	timer_signal_thread_qs(signal);
	208	*timer_id = 0;
	209	end:
	210	return ret;
	211	}
	212
	213	int timer_session_rotation_pending_check_start(struct ltt_session *session,
	214	unsigned int interval_us)
	215	{
	216	int ret;
	217
	218	if (!session_get(session)) {
	219	ret = -1;
	220	goto end;
	221	}
	222	DBG("Enabling session rotation pending check timer on session %" PRIu64,
	223	session->id);
	224	/*
	225	* We arm this timer in a one-shot mode so we don't have to disable it
	226	* explicitly (which could deadlock if the timer thread is blocked
	227	* writing in the rotation_timer_pipe).
	228	*
	229	* Instead, we re-arm it if needed after the rotation_pending check as
	230	* returned. Also, this timer is usually only needed once, so there is
	231	* no need to go through the whole signal teardown scheme everytime.
	232	*/
	233	ret = timer_start(&session->rotation_pending_check_timer,
	234	session, interval_us,
	235	LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK,
	236	/* one-shot */ true);
	237	if (ret == 0) {
	238	session->rotation_pending_check_timer_enabled = true;
	239	}
	240	end:
	241	return ret;
	242	}
	243
	244	/*
	245	* Call with session and session_list locks held.
	246	*/
	247	int timer_session_rotation_pending_check_stop(struct ltt_session *session)
	248	{
	249	int ret;
	250
	251	assert(session);
	252	assert(session->rotation_pending_check_timer_enabled);
	253
	254	DBG("Disabling session rotation pending check timer on session %" PRIu64,
	255	session->id);
	256	ret = timer_stop(&session->rotation_pending_check_timer,
	257	LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK);
	258	if (ret == -1) {
	259	ERR("Failed to stop rotate_pending_check timer");
	260	} else {
	261	session->rotation_pending_check_timer_enabled = false;
	262	/*
	263	* The timer's reference to the session can be released safely.
	264	*/
	265	session_put(session);
	266	}
	267	return ret;
	268	}
	269
	270	/*
	271	* Call with session and session_list locks held.
	272	*/
	273	int timer_session_rotation_schedule_timer_start(struct ltt_session *session,
	274	unsigned int interval_us)
	275	{
	276	int ret;
	277
	278	if (!session_get(session)) {
	279	ret = -1;
	280	goto end;
	281	}
	282	DBG("Enabling scheduled rotation timer on session \"%s\" (%ui µs)", session->name,
	283	interval_us);
	284	ret = timer_start(&session->rotation_schedule_timer, session,
	285	interval_us, LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION,
	286	/* one-shot */ false);
	287	if (ret < 0) {
	288	goto end;
	289	}
	290	session->rotation_schedule_timer_enabled = true;
	291	end:
	292	return ret;
	293	}
	294
	295	/*
	296	* Call with session and session_list locks held.
	297	*/
	298	int timer_session_rotation_schedule_timer_stop(struct ltt_session *session)
	299	{
	300	int ret = 0;
	301
	302	assert(session);
	303
	304	if (!session->rotation_schedule_timer_enabled) {
	305	goto end;
	306	}
	307
	308	DBG("Disabling scheduled rotation timer on session %s", session->name);
	309	ret = timer_stop(&session->rotation_schedule_timer,
	310	LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION);
	311	if (ret < 0) {
	312	ERR("Failed to stop scheduled rotation timer of session \"%s\"",
	313	session->name);
	314	goto end;
	315	}
	316
	317	session->rotation_schedule_timer_enabled = false;
	318	/* The timer's reference to the session can be released safely. */
	319	session_put(session);
	320	ret = 0;
	321	end:
	322	return ret;
	323	}
	324
	325	/*
	326	* Block the RT signals for the entire process. It must be called from the
	327	* sessiond main before creating the threads
	328	*/
	329	int timer_signal_init(void)
	330	{
	331	int ret;
	332	sigset_t mask;
	333
	334	/* Block signal for entire process, so only our thread processes it. */
	335	setmask(&mask);
	336	ret = pthread_sigmask(SIG_BLOCK, &mask, NULL);
	337	if (ret) {
	338	errno = ret;
	339	PERROR("pthread_sigmask");
	340	return -1;
	341	}
	342	return 0;
	343	}
	344
	345	/*
	346	* This thread is the sighandler for the timer signals.
	347	*/
	348	static
	349	void thread_timer(void data)
	350	{
	351	int signr;
	352	sigset_t mask;
	353	siginfo_t info;
	354	struct timer_thread_parameters *ctx = data;
	355
	356	rcu_register_thread();
	357	rcu_thread_online();
	358
	359	health_register(health_sessiond, HEALTH_SESSIOND_TYPE_TIMER);
	360	health_code_update();
	361
	362	/* Only self thread will receive signal mask. */
	363	setmask(&mask);
	364	CMM_STORE_SHARED(timer_signal.tid, pthread_self());
	365
	366	while (1) {
	367	health_code_update();
	368
	369	health_poll_entry();
	370	signr = sigwaitinfo(&mask, &info);
	371	health_poll_exit();
	372
	373	/*
	374	* NOTE: cascading conditions are used instead of a switch case
	375	* since the use of SIGRTMIN in the definition of the signals'
	376	* values prevents the reduction to an integer constant.
	377	*/
	378	if (signr == -1) {
	379	if (errno != EINTR) {
	380	PERROR("sigwaitinfo");
	381	}
	382	continue;
	383	} else if (signr == LTTNG_SESSIOND_SIG_QS) {
	384	cmm_smp_mb();
	385	CMM_STORE_SHARED(timer_signal.qs_done, 1);
	386	cmm_smp_mb();
	387	} else if (signr == LTTNG_SESSIOND_SIG_EXIT) {
	388	goto end;
	389	} else if (signr == LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK) {
	390	struct ltt_session *session =
	391	(struct ltt_session *) info.si_value.sival_ptr;
	392
	393	rotation_thread_enqueue_job(ctx->rotation_thread_job_queue,
	394	ROTATION_THREAD_JOB_TYPE_CHECK_PENDING_ROTATION,
	395	session);
	396	} else if (signr == LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION) {
	397	rotation_thread_enqueue_job(ctx->rotation_thread_job_queue,
	398	ROTATION_THREAD_JOB_TYPE_SCHEDULED_ROTATION,
	399	(struct ltt_session *) info.si_value.sival_ptr);
	400	/*
	401	* The scheduled periodic rotation timer is not in
	402	* "one-shot" mode. The reference to the session is not
	403	* released since the timer is still enabled and can
	404	* still fire.
	405	*/
	406	} else {
	407	ERR("Unexpected signal %d\n", info.si_signo);
	408	}
	409	}
	410
	411	end:
	412	DBG("[timer-thread] Exit");
	413	health_unregister(health_sessiond);
	414	rcu_thread_offline();
	415	rcu_unregister_thread();
	416	return NULL;
	417	}
	418
	419	static
	420	bool shutdown_timer_thread(void *data)
	421	{
	422	return kill(getpid(), LTTNG_SESSIOND_SIG_EXIT) == 0;
	423	}
	424
	425	bool launch_timer_thread(
	426	struct timer_thread_parameters *timer_thread_parameters)
	427	{
	428	struct lttng_thread *thread;
	429
	430	thread = lttng_thread_create("Timer",
	431	thread_timer,
	432	shutdown_timer_thread,
	433	NULL,
	434	timer_thread_parameters);
	435	if (!thread) {
	436	goto error;
	437	}
	438	lttng_thread_put(thread);
	439	return true;
	440	error:
	441	return false;
	442	}