tests/regression/tools/health/health_exit.c

   1 /*
   2  * Copyright (C) 2012 Christian Babeux <christian.babeux@efficios.com>
   3  * Copyright (C) 2014 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   4  *
   5  * SPDX-License-Identifier: GPL-2.0-only
   6  *
   7  */
   8
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <pthread.h>
  12 #include <urcu.h>
  13
  14 /*
  15  * Check if the specified environment variable is set.
  16  * Return 1 if set, otherwise 0.
  17  */
  18 static
  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
  31 /* Session daemon */
  32
  33 int __testpoint_sessiond_thread_manage_clients(void)
  34 {
  35         const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_CLIENTS_EXIT";
  36
  37         if (check_env_var(var)) {
  38                 rcu_unregister_thread();
  39                 pthread_exit(NULL);
  40         }
  41
  42         return 0;
  43 }
  44
  45 int __testpoint_sessiond_thread_registration_apps(void)
  46 {
  47         const char *var = "LTTNG_SESSIOND_THREAD_REG_APPS_EXIT";
  48
  49         if (check_env_var(var)) {
  50                 pthread_exit(NULL);
  51         }
  52
  53         return 0;
  54 }
  55
  56 int __testpoint_sessiond_thread_manage_apps(void)
  57 {
  58         const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_APPS_EXIT";
  59
  60         if (check_env_var(var)) {
  61                 rcu_unregister_thread();
  62                 pthread_exit(NULL);
  63         }
  64
  65         return 0;
  66 }
  67
  68 int __testpoint_sessiond_thread_manage_kernel(void)
  69 {
  70         const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_KERNEL_EXIT";
  71
  72         if (check_env_var(var)) {
  73                 pthread_exit(NULL);
  74         }
  75
  76         return 0;
  77 }
  78
  79 int __testpoint_sessiond_thread_manage_consumer(void)
  80 {
  81         const char *var = "LTTNG_SESSIOND_THREAD_MANAGE_CONSUMER_EXIT";
  82
  83         if (check_env_var(var)) {
  84                 pthread_exit(NULL);
  85         }
  86
  87         return 0;
  88 }
  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 }