[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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	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)
{
	const char *var = "LTTNG_RELAYD_THREAD_DISPATCHER_EXIT";

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

	return 0;
}

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)
{
	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)
{
	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)
{
	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)
{
	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
e547b070	33	int __testpoint_sessiond_thread_manage_clients(void)
9e32c5c0	34	{
e547b070	35	const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_CLIENTS_EXIT";
9e32c5c0 CB	36
9e32c5c0 CB	37	if (check_env_var(var)) {
7f2a8058	38	rcu_unregister_thread();
9e32c5c0 CB	39	pthread_exit(NULL);
9e32c5c0 CB	40	}
6993eeb3 CB	41
6993eeb3 CB	42	return 0;
9e32c5c0 CB	43	}
9e32c5c0 CB	44
e547b070	45	int __testpoint_sessiond_thread_registration_apps(void)
9e32c5c0	46	{
e547b070	47	const char *var = "LTTNG_SESSIOND_THREAD_REG_APPS_EXIT";
9e32c5c0 CB	48
	49	if (check_env_var(var)) {
	50	pthread_exit(NULL);
	51	}
6993eeb3 CB	52
6993eeb3 CB	53	return 0;
9e32c5c0 CB	54	}
9e32c5c0 CB	55
e547b070	56	int __testpoint_sessiond_thread_manage_apps(void)
9e32c5c0	57	{
e547b070	58	const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_APPS_EXIT";
9e32c5c0 CB	59
9e32c5c0 CB	60	if (check_env_var(var)) {
7f2a8058	61	rcu_unregister_thread();
9e32c5c0 CB	62	pthread_exit(NULL);
9e32c5c0 CB	63	}
6993eeb3 CB	64
6993eeb3 CB	65	return 0;
9e32c5c0 CB	66	}
9e32c5c0 CB	67
e547b070	68	int __testpoint_sessiond_thread_manage_kernel(void)
9e32c5c0	69	{
e547b070	70	const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_KERNEL_EXIT";
9e32c5c0 CB	71
	72	if (check_env_var(var)) {
	73	pthread_exit(NULL);
	74	}
6993eeb3 CB	75
6993eeb3 CB	76	return 0;
9e32c5c0 CB	77	}
9e32c5c0 CB	78
e547b070	79	int __testpoint_sessiond_thread_manage_consumer(void)
9e32c5c0	80	{
e547b070	81	const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_CONSUMER_EXIT";
9e32c5c0 CB	82
	83	if (check_env_var(var)) {
	84	pthread_exit(NULL);
	85	}
6993eeb3 CB	86
6993eeb3 CB	87	return 0;
9e32c5c0	88	}
a33d2d4a MD	89
	90	int __testpoint_sessiond_thread_ht_cleanup(void)
	91	{
	92	const char *var = "LTTNG_SESSIOND_THREAD_HT_CLEANUP_EXIT";
	93
	94	if (check_env_var(var)) {
	95	rcu_unregister_thread();
	96	pthread_exit(NULL);
	97	}
	98
	99	return 0;
	100	}
	101
	102	int __testpoint_sessiond_thread_app_manage_notify(void)
	103	{
	104	const char *var = "LTTNG_SESSIOND_THREAD_APP_MANAGE_NOTIFY_EXIT";
	105
	106	if (check_env_var(var)) {
	107	rcu_unregister_thread();
	108	pthread_exit(NULL);
	109	}
	110
	111	return 0;
	112	}
	113
	114	int __testpoint_sessiond_thread_app_reg_dispatch(void)
	115	{
	116	const char *var = "LTTNG_SESSIOND_THREAD_APP_REG_DISPATCH_EXIT";
	117
	118	if (check_env_var(var)) {
	119	pthread_exit(NULL);
	120	}
	121
	122	return 0;
	123	}
	124
	125	/* Consumer daemon */
	126
	127	int __testpoint_consumerd_thread_channel(void)
	128	{
	129	const char *var = "LTTNG_CONSUMERD_THREAD_CHANNEL_EXIT";
	130
	131	if (check_env_var(var)) {
	132	rcu_unregister_thread();
	133	pthread_exit(NULL);
	134	}
	135
	136	return 0;
	137	}
	138
	139	int __testpoint_consumerd_thread_metadata(void)
	140	{
	141	const char *var = "LTTNG_CONSUMERD_THREAD_METADATA_EXIT";
	142
	143	if (check_env_var(var)) {
	144	rcu_unregister_thread();
	145	pthread_exit(NULL);
	146	}
	147
	148	return 0;
	149	}
	150
	151	int __testpoint_consumerd_thread_data(void)
	152	{
153	const char *var = "LTTNG_CONSUMERD_THREAD_DATA_EXIT";
154
155	if (check_env_var(var)) {
156	rcu_unregister_thread();
157	pthread_exit(NULL);
158	}
159
160	return 0;
161	}
162
163	int __testpoint_consumerd_thread_sessiond(void)
164	{
165	const char *var = "LTTNG_CONSUMERD_THREAD_SESSIOND_EXIT";
166
167	if (check_env_var(var)) {
168	rcu_unregister_thread();
169	pthread_exit(NULL);
170	}
171
172	return 0;
173	}
174
175	int __testpoint_consumerd_thread_metadata_timer(void)
176	{
177	const char *var = "LTTNG_CONSUMERD_THREAD_METADATA_TIMER_EXIT";
178
179	if (check_env_var(var)) {
180	pthread_exit(NULL);
181	}
182
183	return 0;
184	}
185
186	/* Relay daemon */
187
188	int __testpoint_relayd_thread_dispatcher(void)
189	{
190	const char *var = "LTTNG_RELAYD_THREAD_DISPATCHER_EXIT";
191
192	if (check_env_var(var)) {
193	pthread_exit(NULL);
194	}
195
196	return 0;
197	}
198
199	int __testpoint_relayd_thread_worker(void)
200	{
201	const char *var = "LTTNG_RELAYD_THREAD_WORKER_EXIT";
202
203	if (check_env_var(var)) {
204	rcu_unregister_thread();
205	pthread_exit(NULL);
206	}
207
208	return 0;
209	}
210
211	int __testpoint_relayd_thread_listener(void)
212	{
213	const char *var = "LTTNG_RELAYD_THREAD_LISTENER_EXIT";
214
215	if (check_env_var(var)) {
216	pthread_exit(NULL);
217	}
218
219	return 0;
220	}
221
222	int __testpoint_relayd_thread_live_dispatcher(void)
223	{
224	const char *var = "LTTNG_RELAYD_THREAD_LIVE_DISPATCHER_EXIT";
225
226	if (check_env_var(var)) {
227	pthread_exit(NULL);
228	}
229
230	return 0;
231	}
232
233	int __testpoint_relayd_thread_live_worker(void)
234	{
235	const char *var = "LTTNG_RELAYD_THREAD_LIVE_WORKER_EXIT";
236
237	if (check_env_var(var)) {
238	rcu_unregister_thread();
239	pthread_exit(NULL);
240	}
241
242	return 0;
243	}
244
245	int __testpoint_relayd_thread_live_listener(void)
246	{
247	const char *var = "LTTNG_RELAYD_THREAD_LIVE_LISTENER_EXIT";
248
249	if (check_env_var(var)) {
250	pthread_exit(NULL);
251	}
252
253	return 0;
254	}