[lttng-tools.git] / tests / regression / tools / health / health_stall.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 <lttng/lttng-export.h>

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

#define STALL_TIME 60

/*
 * 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;
}

static void do_stall(void)
{
	unsigned int sleep_time = STALL_TIME;

	while (sleep_time > 0) {
		sleep_time = sleep(sleep_time);
	}
}

/* Session daemon */

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

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}

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

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}

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

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}

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

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}

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

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}

LTTNG_EXPORT 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_STALL";

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}

LTTNG_EXPORT 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_STALL";

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}

/* Consumer daemon */

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

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}

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

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}

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

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}

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

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}

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

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}

/* Relay daemon */

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

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}

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

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}

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

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}

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

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}

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

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}

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

	if (check_env_var(var)) {
		do_stall();
	}

	return 0;
}
Commit	Line	Data
5862a19a	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>
5862a19a	4	*
9d16b343	5	* SPDX-License-Identifier: GPL-2.0-only
5862a19a	6	*
5862a19a CB	7	*/
5862a19a CB	8
4bd69c5f	9	#include <lttng/lttng-export.h>
28f23191 JG	10
28f23191 JG	11	#include <pthread.h>
5862a19a CB	12	#include <stdlib.h>
5862a19a CB	13	#include <string.h>
5862a19a	14	#include <unistd.h>
a33d2d4a	15	#include <urcu.h>
5862a19a CB	16
	17	#define STALL_TIME 60
	18
	19	/*
	20	* Check if the specified environment variable is set.
	21	* Return 1 if set, otherwise 0.
	22	*/
28f23191	23	static int check_env_var(const char *env)
5862a19a CB	24	{
	25	if (env) {
	26	char *env_val = getenv(env);
	27	if (env_val && (strncmp(env_val, "1", 1) == 0)) {
	28	return 1;
	29	}
	30	}
	31
	32	return 0;
	33	}
	34
28f23191	35	static void do_stall(void)
a33d2d4a MD	36	{
	37	unsigned int sleep_time = STALL_TIME;
	38
	39	while (sleep_time > 0) {
	40	sleep_time = sleep(sleep_time);
	41	}
	42	}
	43
	44	/* Session daemon */
	45
4bd69c5f	46	LTTNG_EXPORT int __testpoint_sessiond_thread_manage_clients(void);
a33d2d4a	47	int __testpoint_sessiond_thread_manage_clients(void)
5862a19a	48	{
e547b070	49	const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_CLIENTS_STALL";
5862a19a CB	50
5862a19a CB	51	if (check_env_var(var)) {
a33d2d4a	52	do_stall();
5862a19a	53	}
6993eeb3 CB	54
6993eeb3 CB	55	return 0;
5862a19a CB	56	}
5862a19a CB	57
4bd69c5f	58	LTTNG_EXPORT int __testpoint_sessiond_thread_registration_apps(void);
a33d2d4a	59	int __testpoint_sessiond_thread_registration_apps(void)
5862a19a	60	{
a33d2d4a	61	const char *var = "LTTNG_SESSIOND_THREAD_REG_APPS_STALL";
5862a19a CB	62
5862a19a CB	63	if (check_env_var(var)) {
a33d2d4a	64	do_stall();
5862a19a	65	}
6993eeb3 CB	66
6993eeb3 CB	67	return 0;
5862a19a CB	68	}
5862a19a CB	69
4bd69c5f	70	LTTNG_EXPORT int __testpoint_sessiond_thread_manage_apps(void);
a33d2d4a	71	int __testpoint_sessiond_thread_manage_apps(void)
5862a19a	72	{
e547b070	73	const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_APPS_STALL";
5862a19a CB	74
5862a19a CB	75	if (check_env_var(var)) {
a33d2d4a MD	76	do_stall();
	77	}
	78
	79	return 0;
	80	}
	81
4bd69c5f	82	LTTNG_EXPORT int __testpoint_sessiond_thread_manage_kernel(void);
a33d2d4a MD	83	int __testpoint_sessiond_thread_manage_kernel(void)
	84	{
	85	const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_KERNEL_STALL";
	86
	87	if (check_env_var(var)) {
	88	do_stall();
	89	}
	90
	91	return 0;
	92	}
	93
4bd69c5f	94	LTTNG_EXPORT int __testpoint_sessiond_thread_manage_consumer(void);
a33d2d4a MD	95	int __testpoint_sessiond_thread_manage_consumer(void)
	96	{
	97	const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_CONSUMER_STALL";
	98
	99	if (check_env_var(var)) {
	100	do_stall();
	101	}
	102
	103	return 0;
	104	}
	105
4bd69c5f	106	LTTNG_EXPORT int __testpoint_sessiond_thread_app_manage_notify(void);
a33d2d4a MD	107	int __testpoint_sessiond_thread_app_manage_notify(void)
	108	{
	109	const char *var = "LTTNG_SESSIOND_THREAD_APP_MANAGE_NOTIFY_STALL";
	110
	111	if (check_env_var(var)) {
	112	do_stall();
	113	}
	114
	115	return 0;
	116	}
	117
4bd69c5f	118	LTTNG_EXPORT int __testpoint_sessiond_thread_app_reg_dispatch(void);
a33d2d4a MD	119	int __testpoint_sessiond_thread_app_reg_dispatch(void)
	120	{
	121	const char *var = "LTTNG_SESSIOND_THREAD_APP_REG_DISPATCH_STALL";
	122
	123	if (check_env_var(var)) {
	124	do_stall();
	125	}
	126
	127	return 0;
	128	}
	129
	130	/* Consumer daemon */
	131
4bd69c5f	132	LTTNG_EXPORT int __testpoint_consumerd_thread_channel(void);
a33d2d4a MD	133	int __testpoint_consumerd_thread_channel(void)
	134	{
	135	const char *var = "LTTNG_CONSUMERD_THREAD_CHANNEL_STALL";
	136
	137	if (check_env_var(var)) {
	138	do_stall();
	139	}
	140
	141	return 0;
	142	}
	143
4bd69c5f	144	LTTNG_EXPORT int __testpoint_consumerd_thread_metadata(void);
a33d2d4a MD	145	int __testpoint_consumerd_thread_metadata(void)
	146	{
	147	const char *var = "LTTNG_CONSUMERD_THREAD_METADATA_STALL";
	148
	149	if (check_env_var(var)) {
	150	do_stall();
	151	}
	152
	153	return 0;
	154	}
	155
4bd69c5f	156	LTTNG_EXPORT int __testpoint_consumerd_thread_data(void);
a33d2d4a MD	157	int __testpoint_consumerd_thread_data(void)
	158	{
	159	const char *var = "LTTNG_CONSUMERD_THREAD_DATA_STALL";
	160
	161	if (check_env_var(var)) {
	162	do_stall();
	163	}
	164
	165	return 0;
	166	}
	167
4bd69c5f	168	LTTNG_EXPORT int __testpoint_consumerd_thread_sessiond(void);
a33d2d4a MD	169	int __testpoint_consumerd_thread_sessiond(void)
	170	{
	171	const char *var = "LTTNG_CONSUMERD_THREAD_SESSIOND_STALL";
	172
	173	if (check_env_var(var)) {
	174	do_stall();
	175	}
	176
	177	return 0;
	178	}
	179
4bd69c5f	180	LTTNG_EXPORT int __testpoint_consumerd_thread_metadata_timer(void);
a33d2d4a MD	181	int __testpoint_consumerd_thread_metadata_timer(void)
	182	{
	183	const char *var = "LTTNG_CONSUMERD_THREAD_METADATA_TIMER_STALL";
	184
	185	if (check_env_var(var)) {
	186	do_stall();
	187	}
	188
	189	return 0;
	190	}
	191
	192	/* Relay daemon */
	193
4bd69c5f	194	LTTNG_EXPORT int __testpoint_relayd_thread_dispatcher(void);
a33d2d4a MD	195	int __testpoint_relayd_thread_dispatcher(void)
	196	{
	197	const char *var = "LTTNG_RELAYD_THREAD_DISPATCHER_STALL";
	198
	199	if (check_env_var(var)) {
	200	do_stall();
	201	}
	202
	203	return 0;
	204	}
	205
4bd69c5f	206	LTTNG_EXPORT int __testpoint_relayd_thread_worker(void);
a33d2d4a MD	207	int __testpoint_relayd_thread_worker(void)
	208	{
	209	const char *var = "LTTNG_RELAYD_THREAD_WORKER_STALL";
	210
	211	if (check_env_var(var)) {
	212	do_stall();
	213	}
	214
	215	return 0;
	216	}
	217
4bd69c5f	218	LTTNG_EXPORT int __testpoint_relayd_thread_listener(void);
a33d2d4a MD	219	int __testpoint_relayd_thread_listener(void)
	220	{
	221	const char *var = "LTTNG_RELAYD_THREAD_LISTENER_STALL";
	222
	223	if (check_env_var(var)) {
	224	do_stall();
	225	}
	226
	227	return 0;
	228	}
	229
4bd69c5f	230	LTTNG_EXPORT int __testpoint_relayd_thread_live_dispatcher(void);
a33d2d4a MD	231	int __testpoint_relayd_thread_live_dispatcher(void)
	232	{
	233	const char *var = "LTTNG_RELAYD_THREAD_LIVE_DISPATCHER_STALL";
	234
	235	if (check_env_var(var)) {
	236	do_stall();
	237	}
	238
	239	return 0;
	240	}
	241
4bd69c5f	242	LTTNG_EXPORT int __testpoint_relayd_thread_live_worker(void);
a33d2d4a MD	243	int __testpoint_relayd_thread_live_worker(void)
	244	{
	245	const char *var = "LTTNG_RELAYD_THREAD_LIVE_WORKER_STALL";
	246
	247	if (check_env_var(var)) {
	248	do_stall();
	249	}
	250
	251	return 0;
	252	}
	253
4bd69c5f	254	LTTNG_EXPORT int __testpoint_relayd_thread_live_listener(void);
a33d2d4a MD	255	int __testpoint_relayd_thread_live_listener(void)
	256	{
	257	const char *var = "LTTNG_RELAYD_THREAD_LIVE_LISTENER_STALL";
	258
	259	if (check_env_var(var)) {
	260	do_stall();
5862a19a	261	}
6993eeb3 CB	262
6993eeb3 CB	263	return 0;
5862a19a	264	}