[lttng-tools.git] / tests / regression / tools / health / health_exit.c

/*
 * Copyright (C) 2012 Christian Babeux <christian.babeux@efficios.com>
 * Copyright (C) 2014 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 */

#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <urcu.h>

/*
 * Check if the specified environment variable is set.
 * Return 1 if set, otherwise 0.
 */
static
int check_env_var(const char *env)
{
	if (env) {
		char *env_val = getenv(env);
		if (env_val && (strncmp(env_val, "1", 1) == 0)) {
			return 1;
		}
	}

	return 0;
}

/* Session daemon */

int __testpoint_sessiond_thread_manage_clients(void);
int __testpoint_sessiond_thread_manage_clients(void)
{
	const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_CLIENTS_EXIT";

	if (check_env_var(var)) {
		rcu_unregister_thread();
		pthread_exit(NULL);
	}

	return 0;
}

int __testpoint_sessiond_thread_registration_apps(void);
int __testpoint_sessiond_thread_registration_apps(void)
{
	const char *var = "LTTNG_SESSIOND_THREAD_REG_APPS_EXIT";

	if (check_env_var(var)) {
		pthread_exit(NULL);
	}

	return 0;
}

int __testpoint_sessiond_thread_manage_apps(void);
int __testpoint_sessiond_thread_manage_apps(void)
{
	const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_APPS_EXIT";

	if (check_env_var(var)) {
		rcu_unregister_thread();
		pthread_exit(NULL);
	}

	return 0;
}

int __testpoint_sessiond_thread_manage_kernel(void);
int __testpoint_sessiond_thread_manage_kernel(void)
{
	const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_KERNEL_EXIT";

	if (check_env_var(var)) {
		pthread_exit(NULL);
	}

	return 0;
}

int __testpoint_sessiond_thread_manage_consumer(void);
int __testpoint_sessiond_thread_manage_consumer(void)
{
	const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_CONSUMER_EXIT";

	if (check_env_var(var)) {
		pthread_exit(NULL);
	}

	return 0;
}

int __testpoint_sessiond_thread_ht_cleanup(void);
int __testpoint_sessiond_thread_ht_cleanup(void)
{
	const char *var = "LTTNG_SESSIOND_THREAD_HT_CLEANUP_EXIT";

	if (check_env_var(var)) {
		rcu_unregister_thread();
		pthread_exit(NULL);
	}

	return 0;
}

int __testpoint_sessiond_thread_app_manage_notify(void);
int __testpoint_sessiond_thread_app_manage_notify(void)
{
	const char *var = "LTTNG_SESSIOND_THREAD_APP_MANAGE_NOTIFY_EXIT";

	if (check_env_var(var)) {
		rcu_unregister_thread();
		pthread_exit(NULL);
	}

	return 0;
}

int __testpoint_sessiond_thread_app_reg_dispatch(void);
int __testpoint_sessiond_thread_app_reg_dispatch(void)
{
	const char *var = "LTTNG_SESSIOND_THREAD_APP_REG_DISPATCH_EXIT";

	if (check_env_var(var)) {
		pthread_exit(NULL);
	}

	return 0;
}

/* Consumer daemon */

int __testpoint_consumerd_thread_channel(void);
int __testpoint_consumerd_thread_channel(void)
{
	const char *var = "LTTNG_CONSUMERD_THREAD_CHANNEL_EXIT";

	if (check_env_var(var)) {
		rcu_unregister_thread();
		pthread_exit(NULL);
	}

	return 0;
}

int __testpoint_consumerd_thread_metadata(void);
int __testpoint_consumerd_thread_metadata(void)
{
	const char *var = "LTTNG_CONSUMERD_THREAD_METADATA_EXIT";

	if (check_env_var(var)) {
		rcu_unregister_thread();
		pthread_exit(NULL);
	}

	return 0;
}

int __testpoint_consumerd_thread_data(void);
int __testpoint_consumerd_thread_data(void)
{
	const char *var = "LTTNG_CONSUMERD_THREAD_DATA_EXIT";

	if (check_env_var(var)) {
		rcu_unregister_thread();
		pthread_exit(NULL);
	}

	return 0;
}

int __testpoint_consumerd_thread_sessiond(void);
int __testpoint_consumerd_thread_sessiond(void)
{
	const char *var = "LTTNG_CONSUMERD_THREAD_SESSIOND_EXIT";

	if (check_env_var(var)) {
		rcu_unregister_thread();
		pthread_exit(NULL);
	}

	return 0;
}

int __testpoint_consumerd_thread_metadata_timer(void);
int __testpoint_consumerd_thread_metadata_timer(void)
{
	const char *var = "LTTNG_CONSUMERD_THREAD_METADATA_TIMER_EXIT";

	if (check_env_var(var)) {
		pthread_exit(NULL);
	}

	return 0;
}

/* Relay daemon */

int __testpoint_relayd_thread_dispatcher(void);
int __testpoint_relayd_thread_dispatcher(void)
{
	const char *var = "LTTNG_RELAYD_THREAD_DISPATCHER_EXIT";

	if (check_env_var(var)) {
		pthread_exit(NULL);
	}

	return 0;
}

int __testpoint_relayd_thread_worker(void);
int __testpoint_relayd_thread_worker(void)
{
	const char *var = "LTTNG_RELAYD_THREAD_WORKER_EXIT";

	if (check_env_var(var)) {
		rcu_unregister_thread();
		pthread_exit(NULL);
	}

	return 0;
}

int __testpoint_relayd_thread_listener(void);
int __testpoint_relayd_thread_listener(void)
{
	const char *var = "LTTNG_RELAYD_THREAD_LISTENER_EXIT";

	if (check_env_var(var)) {
		pthread_exit(NULL);
	}

	return 0;
}

int __testpoint_relayd_thread_live_dispatcher(void);
int __testpoint_relayd_thread_live_dispatcher(void)
{
	const char *var = "LTTNG_RELAYD_THREAD_LIVE_DISPATCHER_EXIT";

	if (check_env_var(var)) {
		pthread_exit(NULL);
	}

	return 0;
}

int __testpoint_relayd_thread_live_worker(void);
int __testpoint_relayd_thread_live_worker(void)
{
	const char *var = "LTTNG_RELAYD_THREAD_LIVE_WORKER_EXIT";

	if (check_env_var(var)) {
		rcu_unregister_thread();
		pthread_exit(NULL);
	}

	return 0;
}

int __testpoint_relayd_thread_live_listener(void);
int __testpoint_relayd_thread_live_listener(void)
{
	const char *var = "LTTNG_RELAYD_THREAD_LIVE_LISTENER_EXIT";

	if (check_env_var(var)) {
		pthread_exit(NULL);
	}

	return 0;
}
Commit	Line	Data
9e32c5c0	1	/*
9d16b343 MJ	2	* Copyright (C) 2012 Christian Babeux <christian.babeux@efficios.com>
9d16b343 MJ	3	* Copyright (C) 2014 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
9e32c5c0	4	*
9d16b343	5	* SPDX-License-Identifier: GPL-2.0-only
9e32c5c0	6	*
9e32c5c0 CB	7	*/
	8
	9	#include <stdlib.h>
	10	#include <string.h>
	11	#include <pthread.h>
7f2a8058	12	#include <urcu.h>
9e32c5c0 CB	13
	14	/*
	15	* Check if the specified environment variable is set.
	16	* Return 1 if set, otherwise 0.
	17	*/
a33d2d4a	18	static
9e32c5c0 CB	19	int check_env_var(const char *env)
	20	{
	21	if (env) {
	22	char *env_val = getenv(env);
	23	if (env_val && (strncmp(env_val, "1", 1) == 0)) {
	24	return 1;
	25	}
	26	}
	27
	28	return 0;
	29	}
	30
a33d2d4a MD	31	/* Session daemon */
a33d2d4a MD	32
1831ae68	33	int __testpoint_sessiond_thread_manage_clients(void);
e547b070	34	int __testpoint_sessiond_thread_manage_clients(void)
9e32c5c0	35	{
e547b070	36	const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_CLIENTS_EXIT";
9e32c5c0 CB	37
9e32c5c0 CB	38	if (check_env_var(var)) {
7f2a8058	39	rcu_unregister_thread();
9e32c5c0 CB	40	pthread_exit(NULL);
9e32c5c0 CB	41	}
6993eeb3 CB	42
6993eeb3 CB	43	return 0;
9e32c5c0 CB	44	}
9e32c5c0 CB	45
1831ae68	46	int __testpoint_sessiond_thread_registration_apps(void);
e547b070	47	int __testpoint_sessiond_thread_registration_apps(void)
9e32c5c0	48	{
e547b070	49	const char *var = "LTTNG_SESSIOND_THREAD_REG_APPS_EXIT";
9e32c5c0 CB	50
	51	if (check_env_var(var)) {
	52	pthread_exit(NULL);
	53	}
6993eeb3 CB	54
6993eeb3 CB	55	return 0;
9e32c5c0 CB	56	}
9e32c5c0 CB	57
1831ae68	58	int __testpoint_sessiond_thread_manage_apps(void);
e547b070	59	int __testpoint_sessiond_thread_manage_apps(void)
9e32c5c0	60	{
e547b070	61	const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_APPS_EXIT";
9e32c5c0 CB	62
9e32c5c0 CB	63	if (check_env_var(var)) {
7f2a8058	64	rcu_unregister_thread();
9e32c5c0 CB	65	pthread_exit(NULL);
9e32c5c0 CB	66	}
6993eeb3 CB	67
6993eeb3 CB	68	return 0;
9e32c5c0 CB	69	}
9e32c5c0 CB	70
1831ae68	71	int __testpoint_sessiond_thread_manage_kernel(void);
e547b070	72	int __testpoint_sessiond_thread_manage_kernel(void)
9e32c5c0	73	{
e547b070	74	const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_KERNEL_EXIT";
9e32c5c0 CB	75
	76	if (check_env_var(var)) {
	77	pthread_exit(NULL);
	78	}
6993eeb3 CB	79
6993eeb3 CB	80	return 0;
9e32c5c0 CB	81	}
9e32c5c0 CB	82
1831ae68	83	int __testpoint_sessiond_thread_manage_consumer(void);
e547b070	84	int __testpoint_sessiond_thread_manage_consumer(void)
9e32c5c0	85	{
e547b070	86	const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_CONSUMER_EXIT";
9e32c5c0 CB	87
	88	if (check_env_var(var)) {
	89	pthread_exit(NULL);
	90	}
6993eeb3 CB	91
6993eeb3 CB	92	return 0;
9e32c5c0	93	}
a33d2d4a	94
1831ae68	95	int __testpoint_sessiond_thread_ht_cleanup(void);
a33d2d4a MD	96	int __testpoint_sessiond_thread_ht_cleanup(void)
	97	{
	98	const char *var = "LTTNG_SESSIOND_THREAD_HT_CLEANUP_EXIT";
	99
	100	if (check_env_var(var)) {
	101	rcu_unregister_thread();
	102	pthread_exit(NULL);
	103	}
	104
	105	return 0;
	106	}
	107
1831ae68	108	int __testpoint_sessiond_thread_app_manage_notify(void);
a33d2d4a MD	109	int __testpoint_sessiond_thread_app_manage_notify(void)
	110	{
	111	const char *var = "LTTNG_SESSIOND_THREAD_APP_MANAGE_NOTIFY_EXIT";
	112
	113	if (check_env_var(var)) {
	114	rcu_unregister_thread();
	115	pthread_exit(NULL);
	116	}
	117
	118	return 0;
	119	}
	120
1831ae68	121	int __testpoint_sessiond_thread_app_reg_dispatch(void);
a33d2d4a MD	122	int __testpoint_sessiond_thread_app_reg_dispatch(void)
	123	{
	124	const char *var = "LTTNG_SESSIOND_THREAD_APP_REG_DISPATCH_EXIT";
	125
	126	if (check_env_var(var)) {
	127	pthread_exit(NULL);
	128	}
	129
	130	return 0;
	131	}
	132
	133	/* Consumer daemon */
	134
1831ae68	135	int __testpoint_consumerd_thread_channel(void);
a33d2d4a MD	136	int __testpoint_consumerd_thread_channel(void)
	137	{
	138	const char *var = "LTTNG_CONSUMERD_THREAD_CHANNEL_EXIT";
	139
	140	if (check_env_var(var)) {
	141	rcu_unregister_thread();
	142	pthread_exit(NULL);
	143	}
	144
	145	return 0;
	146	}
	147
1831ae68	148	int __testpoint_consumerd_thread_metadata(void);
a33d2d4a MD	149	int __testpoint_consumerd_thread_metadata(void)
	150	{
	151	const char *var = "LTTNG_CONSUMERD_THREAD_METADATA_EXIT";
	152
	153	if (check_env_var(var)) {
	154	rcu_unregister_thread();
	155	pthread_exit(NULL);
	156	}
	157
	158	return 0;
	159	}
	160
1831ae68	161	int __testpoint_consumerd_thread_data(void);
a33d2d4a MD	162	int __testpoint_consumerd_thread_data(void)
	163	{
	164	const char *var = "LTTNG_CONSUMERD_THREAD_DATA_EXIT";
	165
	166	if (check_env_var(var)) {
	167	rcu_unregister_thread();
	168	pthread_exit(NULL);
	169	}
	170
	171	return 0;
	172	}
	173
1831ae68	174	int __testpoint_consumerd_thread_sessiond(void);
a33d2d4a MD	175	int __testpoint_consumerd_thread_sessiond(void)
	176	{
	177	const char *var = "LTTNG_CONSUMERD_THREAD_SESSIOND_EXIT";
	178
	179	if (check_env_var(var)) {
	180	rcu_unregister_thread();
	181	pthread_exit(NULL);
	182	}
	183
	184	return 0;
	185	}
	186
1831ae68	187	int __testpoint_consumerd_thread_metadata_timer(void);
a33d2d4a MD	188	int __testpoint_consumerd_thread_metadata_timer(void)
	189	{
	190	const char *var = "LTTNG_CONSUMERD_THREAD_METADATA_TIMER_EXIT";
	191
	192	if (check_env_var(var)) {
	193	pthread_exit(NULL);
	194	}
	195
	196	return 0;
	197	}
	198
	199	/* Relay daemon */
	200
1831ae68	201	int __testpoint_relayd_thread_dispatcher(void);
a33d2d4a MD	202	int __testpoint_relayd_thread_dispatcher(void)
	203	{
	204	const char *var = "LTTNG_RELAYD_THREAD_DISPATCHER_EXIT";
	205
	206	if (check_env_var(var)) {
	207	pthread_exit(NULL);
	208	}
	209
	210	return 0;
	211	}
	212
1831ae68	213	int __testpoint_relayd_thread_worker(void);
a33d2d4a MD	214	int __testpoint_relayd_thread_worker(void)
	215	{
	216	const char *var = "LTTNG_RELAYD_THREAD_WORKER_EXIT";
	217
	218	if (check_env_var(var)) {
	219	rcu_unregister_thread();
	220	pthread_exit(NULL);
	221	}
	222
	223	return 0;
	224	}
	225
1831ae68	226	int __testpoint_relayd_thread_listener(void);
a33d2d4a MD	227	int __testpoint_relayd_thread_listener(void)
	228	{
	229	const char *var = "LTTNG_RELAYD_THREAD_LISTENER_EXIT";
	230
	231	if (check_env_var(var)) {
	232	pthread_exit(NULL);
	233	}
	234
	235	return 0;
	236	}
	237
1831ae68	238	int __testpoint_relayd_thread_live_dispatcher(void);
a33d2d4a MD	239	int __testpoint_relayd_thread_live_dispatcher(void)
	240	{
	241	const char *var = "LTTNG_RELAYD_THREAD_LIVE_DISPATCHER_EXIT";
	242
	243	if (check_env_var(var)) {
	244	pthread_exit(NULL);
	245	}
	246
	247	return 0;
	248	}
	249
1831ae68	250	int __testpoint_relayd_thread_live_worker(void);
a33d2d4a MD	251	int __testpoint_relayd_thread_live_worker(void)
	252	{
	253	const char *var = "LTTNG_RELAYD_THREAD_LIVE_WORKER_EXIT";
	254
	255	if (check_env_var(var)) {
	256	rcu_unregister_thread();
	257	pthread_exit(NULL);
	258	}
	259
	260	return 0;
	261	}
	262
1831ae68	263	int __testpoint_relayd_thread_live_listener(void);
a33d2d4a MD	264	int __testpoint_relayd_thread_live_listener(void)
	265	{
	266	const char *var = "LTTNG_RELAYD_THREAD_LIVE_LISTENER_EXIT";
	267
	268	if (check_env_var(var)) {
	269	pthread_exit(NULL);
	270	}
	271
	272	return 0;
	273	}