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

/*
 * Copyright (C) 2012 - David Goulet <dgoulet@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 _GNU_SOURCE
#include <assert.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include <common/defaults.h>
#include <common/error.h>

#include "health.h"

static const struct timespec time_delta = {
	.tv_sec = DEFAULT_HEALTH_CHECK_DELTA_S,
	.tv_nsec = DEFAULT_HEALTH_CHECK_DELTA_NS,
};

/* Define TLS health state. */
DEFINE_URCU_TLS(struct health_state, health_state);

/*
 * It ensures that TLS memory used for the node and its container structure
 * don't get reclaimed after the TLS owner thread exits until we have finished
 * using it.
 */
static pthread_mutex_t health_mutex = PTHREAD_MUTEX_INITIALIZER;

static struct health_tls_state_list health_state_list = {
	.head = CDS_LIST_HEAD_INIT(health_state_list.head),
};

/*
 * This keeps track of the error state for unregistered thread. A thread
 * reporting a health error, normally unregisters and quits. This makes the TLS
 * health state not available to the health_check_state() call so on unregister
 * we update this global error array so we can keep track of which thread was
 * on error if the TLS health state has been removed.
 */
static enum health_flags global_error_state[HEALTH_NUM_TYPE];

/*
 * Lock health state global list mutex.
 */
static void state_lock(void)
{
	pthread_mutex_lock(&health_mutex);
}

/*
 * Unlock health state global list mutex.
 */
static void state_unlock(void)
{
	pthread_mutex_unlock(&health_mutex);
}

/*
 * Set time difference in res from time_a and time_b.
 */
static void time_diff(const struct timespec *time_a,
		const struct timespec *time_b, struct timespec *res)
{
	if (time_a->tv_nsec - time_b->tv_nsec < 0) {
		res->tv_sec = time_a->tv_sec - time_b->tv_sec - 1;
		res->tv_nsec = 1000000000L + time_a->tv_sec - time_b->tv_sec;
	} else {
		res->tv_sec = time_a->tv_sec - time_b->tv_sec;
		res->tv_nsec = time_a->tv_nsec - time_b->tv_nsec;
	}
}

/*
 * Return true if time_a - time_b > diff, else false.
 */
static int time_diff_gt(const struct timespec *time_a,
		const struct timespec *time_b, const struct timespec *diff)
{
	struct timespec res;

	time_diff(time_a, time_b, &res);
	time_diff(&res, diff, &res);

	if (res.tv_sec > 0) {
		return 1;
	} else if (res.tv_sec == 0 && res.tv_nsec > 0) {
		return 1;
	}

	return 0;
}

/*
 * Health mutex MUST be held across use of the returned struct health_state to
 * provide existence guarantee.
 *
 * Return the health_state object or NULL if not found.
 */
static struct health_state *find_health_state(enum health_type type)
{
	struct health_state *state;

	/* Find the right health state in the global TLS list. */
	cds_list_for_each_entry(state, &health_state_list.head, node) {
		if (state->type == type) {
			return state;
		}
	}

	return NULL;
}

/*
 * Check health of a specific health type. Note that if a thread has not yet
 * initialize its health subsystem or has quit, it's considered in a good
 * state.
 *
 * Return 0 if health is bad or else 1.
 */
int health_check_state(enum health_type type)
{
	int retval = 1, ret;
	unsigned long current, last;
	struct timespec current_time;
	struct health_state *state;

	assert(type < HEALTH_NUM_TYPE);

	state_lock();

	state = find_health_state(type);
	if (!state) {
		/* Check the global state since the state is not visiable anymore. */
		if (global_error_state[type] & HEALTH_ERROR) {
			retval = 0;
		}
		goto not_found;
	}

	last = state->last;
	current = uatomic_read(&state->current);

	ret = clock_gettime(CLOCK_MONOTONIC, &current_time);
	if (ret < 0) {
		PERROR("Error reading time\n");
		/* error */
		retval = 0;
		goto end;
	}

	/*
	 * Thread is in bad health if flag HEALTH_ERROR is set. It is also in bad
	 * health if, after the delta delay has passed, its the progress counter
	 * has not moved and it has NOT been waiting for a poll() call.
	 */
	if (uatomic_read(&state->flags) & HEALTH_ERROR) {
		retval = 0;
		goto end;
	}

	/*
	 * Initial condition need to update the last counter and sample time, but
	 * should not check health in this initial case, because we don't know how
	 * much time has passed.
	 */
	if (state->last_time.tv_sec == 0 && state->last_time.tv_nsec == 0) {
		/* update last counter and last sample time */
		state->last = current;
		memcpy(&state->last_time, &current_time, sizeof(current_time));
	} else {
		if (time_diff_gt(&current_time, &state->last_time, &time_delta)) {
			if (current == last && !HEALTH_IS_IN_POLL(current)) {
				/* error */
				retval = 0;
			}
			/* update last counter and last sample time */
			state->last = current;
			memcpy(&state->last_time, &current_time, sizeof(current_time));
		}
	}

end:
	DBG("Health state current %lu, last %lu, ret %d",
			current, last, ret);
not_found:
	state_unlock();

	return retval;
}

/*
 * Init health state.
 */
void health_register(enum health_type type)
{
	struct health_state *state;

	assert(type < HEALTH_NUM_TYPE);

	/* Init TLS state. */
	uatomic_set(&URCU_TLS(health_state).last, 0);
	uatomic_set(&URCU_TLS(health_state).last_time.tv_sec, 0);
	uatomic_set(&URCU_TLS(health_state).last_time.tv_nsec, 0);
	uatomic_set(&URCU_TLS(health_state).current, 0);
	uatomic_set(&URCU_TLS(health_state).flags, 0);
	uatomic_set(&URCU_TLS(health_state).type, type);

	/* Add it to the global TLS state list. */
	state_lock();
	state = find_health_state(type);
	/*
	 * Duplicates are not accepted, since lookups don't handle them at the
	 * moment.
	 */
	assert(!state);

	cds_list_add(&URCU_TLS(health_state).node, &health_state_list.head);
	state_unlock();
}

/*
 * Remove node from global list.
 */
void health_unregister(void)
{
	state_lock();
	/*
	 * On error, set the global_error_state since we are about to remove
	 * the node from the global list.
	 */
	if (uatomic_read(&URCU_TLS(health_state).flags) & HEALTH_ERROR) {
		uatomic_set(&global_error_state[URCU_TLS(health_state).type],
				HEALTH_ERROR);
	}
	cds_list_del(&URCU_TLS(health_state).node);
	state_unlock();
}
Commit	Line	Data
44a5e5eb DG	1	/*
	2	* Copyright (C) 2012 - David Goulet <dgoulet@efficios.com>
	3	*
	4	* This program is free software; you can redistribute it and/or modify it
	5	* under the terms of the GNU General Public License, version 2 only, as
	6	* published by the Free Software Foundation.
	7	*
	8	* This program 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 General Public License for
	11	* more details.
	12	*
	13	* You should have received a copy of the GNU General Public License along with
	14	* this program; if not, write to the Free Software Foundation, Inc., 51
	15	* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	16	*/
	17
	18	#define _GNU_SOURCE
	19	#include <assert.h>
	20	#include <inttypes.h>
	21	#include <stdio.h>
	22	#include <stdlib.h>
8809eec0	23	#include <time.h>
44a5e5eb	24
8809eec0	25	#include <common/defaults.h>
44a5e5eb DG	26	#include <common/error.h>
	27
	28	#include "health.h"
	29
8809eec0 MD	30	static const struct timespec time_delta = {
	31	.tv_sec = DEFAULT_HEALTH_CHECK_DELTA_S,
	32	.tv_nsec = DEFAULT_HEALTH_CHECK_DELTA_NS,
	33	};
	34
927ca06a DG	35	/* Define TLS health state. */
	36	DEFINE_URCU_TLS(struct health_state, health_state);
	37
	38	/*
	39	* It ensures that TLS memory used for the node and its container structure
	40	* don't get reclaimed after the TLS owner thread exits until we have finished
	41	* using it.
	42	*/
	43	static pthread_mutex_t health_mutex = PTHREAD_MUTEX_INITIALIZER;
	44
	45	static struct health_tls_state_list health_state_list = {
	46	.head = CDS_LIST_HEAD_INIT(health_state_list.head),
	47	};
	48
	49	/*
	50	* This keeps track of the error state for unregistered thread. A thread
	51	* reporting a health error, normally unregisters and quits. This makes the TLS
	52	* health state not available to the health_check_state() call so on unregister
	53	* we update this global error array so we can keep track of which thread was
	54	* on error if the TLS health state has been removed.
	55	*/
	56	static enum health_flags global_error_state[HEALTH_NUM_TYPE];
	57
	58	/*
	59	* Lock health state global list mutex.
	60	*/
	61	static void state_lock(void)
	62	{
	63	pthread_mutex_lock(&health_mutex);
	64	}
	65
	66	/*
	67	* Unlock health state global list mutex.
	68	*/
	69	static void state_unlock(void)
	70	{
	71	pthread_mutex_unlock(&health_mutex);
	72	}
	73
8809eec0 MD	74	/*
	75	* Set time difference in res from time_a and time_b.
	76	*/
	77	static void time_diff(const struct timespec *time_a,
	78	const struct timespec time_b, struct timespec res)
	79	{
	80	if (time_a->tv_nsec - time_b->tv_nsec < 0) {
	81	res->tv_sec = time_a->tv_sec - time_b->tv_sec - 1;
	82	res->tv_nsec = 1000000000L + time_a->tv_sec - time_b->tv_sec;
	83	} else {
	84	res->tv_sec = time_a->tv_sec - time_b->tv_sec;
931a97e5	85	res->tv_nsec = time_a->tv_nsec - time_b->tv_nsec;
8809eec0 MD	86	}
	87	}
	88
	89	/*
	90	* Return true if time_a - time_b > diff, else false.
	91	*/
	92	static int time_diff_gt(const struct timespec *time_a,
	93	const struct timespec time_b, const struct timespec diff)
	94	{
	95	struct timespec res;
	96
	97	time_diff(time_a, time_b, &res);
	98	time_diff(&res, diff, &res);
	99
	100	if (res.tv_sec > 0) {
	101	return 1;
	102	} else if (res.tv_sec == 0 && res.tv_nsec > 0) {
	103	return 1;
	104	}
	105
	106	return 0;
	107	}
	108
44a5e5eb	109	/*
927ca06a DG	110	* Health mutex MUST be held across use of the returned struct health_state to
	111	* provide existence guarantee.
	112	*
	113	* Return the health_state object or NULL if not found.
	114	*/
	115	static struct health_state *find_health_state(enum health_type type)
	116	{
	117	struct health_state *state;
	118
	119	/* Find the right health state in the global TLS list. */
	120	cds_list_for_each_entry(state, &health_state_list.head, node) {
	121	if (state->type == type) {
	122	return state;
	123	}
	124	}
	125
	126	return NULL;
	127	}
	128
	129	/*
	130	* Check health of a specific health type. Note that if a thread has not yet
	131	* initialize its health subsystem or has quit, it's considered in a good
	132	* state.
44a5e5eb DG	133	*
	134	* Return 0 if health is bad or else 1.
	135	*/
927ca06a	136	int health_check_state(enum health_type type)
44a5e5eb	137	{
8809eec0	138	int retval = 1, ret;
139ac872	139	unsigned long current, last;
8809eec0	140	struct timespec current_time;
927ca06a DG	141	struct health_state *state;
	142
	143	assert(type < HEALTH_NUM_TYPE);
44a5e5eb	144
927ca06a DG	145	state_lock();
	146
	147	state = find_health_state(type);
	148	if (!state) {
	149	/* Check the global state since the state is not visiable anymore. */
	150	if (global_error_state[type] & HEALTH_ERROR) {
	151	retval = 0;
	152	}
	153	goto not_found;
	154	}
44a5e5eb	155
139ac872	156	last = state->last;
44a5e5eb	157	current = uatomic_read(&state->current);
44a5e5eb	158
8809eec0	159	ret = clock_gettime(CLOCK_MONOTONIC, &current_time);
931a97e5	160	if (ret < 0) {
8809eec0	161	PERROR("Error reading time\n");
139ac872	162	/* error */
8809eec0 MD	163	retval = 0;
8809eec0 MD	164	goto end;
44a5e5eb DG	165	}
44a5e5eb DG	166
8809eec0 MD	167	/*
	168	* Thread is in bad health if flag HEALTH_ERROR is set. It is also in bad
	169	* health if, after the delta delay has passed, its the progress counter
	170	* has not moved and it has NOT been waiting for a poll() call.
	171	*/
	172	if (uatomic_read(&state->flags) & HEALTH_ERROR) {
	173	retval = 0;
	174	goto end;
	175	}
44a5e5eb	176
139ac872	177	/*
8809eec0 MD	178	* Initial condition need to update the last counter and sample time, but
	179	* should not check health in this initial case, because we don't know how
	180	* much time has passed.
139ac872	181	*/
8809eec0 MD	182	if (state->last_time.tv_sec == 0 && state->last_time.tv_nsec == 0) {
	183	/* update last counter and last sample time */
	184	state->last = current;
	185	memcpy(&state->last_time, &current_time, sizeof(current_time));
	186	} else {
	187	if (time_diff_gt(&current_time, &state->last_time, &time_delta)) {
	188	if (current == last && !HEALTH_IS_IN_POLL(current)) {
	189	/* error */
	190	retval = 0;
	191	}
	192	/* update last counter and last sample time */
	193	state->last = current;
	194	memcpy(&state->last_time, &current_time, sizeof(current_time));
	195	}
	196	}
	197
	198	end:
77c7c900	199	DBG("Health state current %lu, last %lu, ret %d",
8809eec0	200	current, last, ret);
927ca06a DG	201	not_found:
927ca06a DG	202	state_unlock();
139ac872	203
8809eec0	204	return retval;
44a5e5eb	205	}
927ca06a DG	206
	207	/*
	208	* Init health state.
	209	*/
	210	void health_register(enum health_type type)
	211	{
	212	struct health_state *state;
	213
	214	assert(type < HEALTH_NUM_TYPE);
	215
	216	/* Init TLS state. */
	217	uatomic_set(&URCU_TLS(health_state).last, 0);
	218	uatomic_set(&URCU_TLS(health_state).last_time.tv_sec, 0);
	219	uatomic_set(&URCU_TLS(health_state).last_time.tv_nsec, 0);
	220	uatomic_set(&URCU_TLS(health_state).current, 0);
	221	uatomic_set(&URCU_TLS(health_state).flags, 0);
	222	uatomic_set(&URCU_TLS(health_state).type, type);
	223
	224	/* Add it to the global TLS state list. */
	225	state_lock();
	226	state = find_health_state(type);
	227	/*
	228	* Duplicates are not accepted, since lookups don't handle them at the
	229	* moment.
	230	*/
	231	assert(!state);
	232
	233	cds_list_add(&URCU_TLS(health_state).node, &health_state_list.head);
	234	state_unlock();
	235	}
	236
	237	/*
	238	* Remove node from global list.
	239	*/
	240	void health_unregister(void)
	241	{
	242	state_lock();
	243	/*
	244	* On error, set the global_error_state since we are about to remove
	245	* the node from the global list.
	246	*/
	247	if (uatomic_read(&URCU_TLS(health_state).flags) & HEALTH_ERROR) {
	248	uatomic_set(&global_error_state[URCU_TLS(health_state).type],
	249	HEALTH_ERROR);
	250	}
	251	cds_list_del(&URCU_TLS(health_state).node);
	252	state_unlock();
	253	}