src/common/health/health.c

   1 /*
   2  * Copyright (C) 2012 David Goulet <dgoulet@efficios.com>
   3  * Copyright (C) 2013 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   4  *
   5  * SPDX-License-Identifier: GPL-2.0-only
   6  *
   7  */
   8
   9 #define _LGPL_SOURCE
  10 #include <assert.h>
  11 #include <inttypes.h>
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <time.h>
  15
  16 #include <common/defaults.h>
  17 #include <common/error.h>
  18 #include <common/macros.h>
  19 #include <common/sessiond-comm/inet.h>
  20
  21 #include <lttng/health-internal.h>
  22
  23 /*
  24  * An application-specific error state for unregistered thread keeps
  25  * track of thread errors. A thread reporting a health error, normally
  26  * unregisters and quits. This makes the TLS health state not available
  27  * to the health_check_state() call so on unregister we update this
  28  * global error array so we can keep track of which thread was on error
  29  * if the TLS health state has been removed.
  30  */
  31 struct health_app {
  32         /* List of health state, for each application thread */
  33         struct cds_list_head list;
  34         /*
  35          * This lock ensures that TLS memory used for the node and its
  36          * container structure don't get reclaimed after the TLS owner
  37          * thread exits until we have finished using it.
  38          */
  39         pthread_mutex_t lock;
  40         int nr_types;
  41         struct timespec time_delta;
  42         /* Health flags containing thread type error state */
  43         enum health_flags *flags;
  44 };
  45
  46 /* Define TLS health state. */
  47 DEFINE_URCU_TLS(struct health_state, health_state);
  48
  49 /*
  50  * Initialize health check subsytem.
  51  */
  52 static
  53 void health_init(struct health_app *ha)
  54 {
  55         /*
  56          * Get the maximum value between the default delta value and the TCP
  57          * timeout with a safety net of the default health check delta.
  58          */
  59         ha->time_delta.tv_sec = max_t(unsigned long,
  60                         lttcomm_inet_tcp_timeout + DEFAULT_HEALTH_CHECK_DELTA_S,
  61                         ha->time_delta.tv_sec);
  62         DBG("Health check time delta in seconds set to %lu",
  63                 ha->time_delta.tv_sec);
  64 }
  65
  66 struct health_app *health_app_create(int nr_types)
  67 {
  68         struct health_app *ha;
  69
  70         ha = zmalloc(sizeof(*ha));
  71         if (!ha) {
  72                 return NULL;
  73         }
  74         ha->flags = zmalloc(sizeof(*ha->flags) * nr_types);
  75         if (!ha->flags) {
  76                 goto error_flags;
  77         }
  78         CDS_INIT_LIST_HEAD(&ha->list);
  79         pthread_mutex_init(&ha->lock, NULL);
  80         ha->nr_types = nr_types;
  81         ha->time_delta.tv_sec = DEFAULT_HEALTH_CHECK_DELTA_S;
  82         ha->time_delta.tv_nsec = DEFAULT_HEALTH_CHECK_DELTA_NS;
  83         health_init(ha);
  84         return ha;
  85
  86 error_flags:
  87         free(ha);
  88         return NULL;
  89 }
  90
  91 void health_app_destroy(struct health_app *ha)
  92 {
  93         free(ha->flags);
  94         free(ha);
  95 }
  96
  97 /*
  98  * Lock health state global list mutex.
  99  */
 100 static void state_lock(struct health_app *ha)
 101 {
 102         pthread_mutex_lock(&ha->lock);
 103 }
 104
 105 /*
 106  * Unlock health state global list mutex.
 107  */
 108 static void state_unlock(struct health_app *ha)
 109 {
 110         pthread_mutex_unlock(&ha->lock);
 111 }
 112
 113 /*
 114  * Set time difference in res from time_a and time_b.
 115  */
 116 static void time_diff(const struct timespec *time_a,
 117                 const struct timespec *time_b, struct timespec *res)
 118 {
 119         if (time_a->tv_nsec - time_b->tv_nsec < 0) {
 120                 res->tv_sec = time_a->tv_sec - time_b->tv_sec - 1;
 121                 res->tv_nsec = 1000000000L + time_a->tv_sec - time_b->tv_sec;
 122         } else {
 123                 res->tv_sec = time_a->tv_sec - time_b->tv_sec;
 124                 res->tv_nsec = time_a->tv_nsec - time_b->tv_nsec;
 125         }
 126 }
 127
 128 /*
 129  * Return true if time_a - time_b > diff, else false.
 130  */
 131 static int time_diff_gt(const struct timespec *time_a,
 132                 const struct timespec *time_b, const struct timespec *diff)
 133 {
 134         struct timespec res;
 135
 136         time_diff(time_a, time_b, &res);
 137         time_diff(&res, diff, &res);
 138
 139         if (res.tv_sec > 0) {
 140                 return 1;
 141         } else if (res.tv_sec == 0 && res.tv_nsec > 0) {
 142                 return 1;
 143         }
 144
 145         return 0;
 146 }
 147
 148 /*
 149  * Validate health state. Checks for the error flag or health conditions.
 150  *
 151  * Return 0 if health is bad or else 1.
 152  */
 153 static int validate_state(struct health_app *ha, struct health_state *state)
 154 {
 155         int retval = 1, ret;
 156         unsigned long current, last;
 157         struct timespec current_time;
 158
 159         assert(state);
 160
 161         last = state->last;
 162         current = uatomic_read(&state->current);
 163
 164         ret = lttng_clock_gettime(CLOCK_MONOTONIC, &current_time);
 165         if (ret < 0) {
 166                 PERROR("Error reading time\n");
 167                 /* error */
 168                 retval = 0;
 169                 goto end;
 170         }
 171
 172         /*
 173          * Thread is in bad health if flag HEALTH_ERROR is set. It is also in bad
 174          * health if, after the delta delay has passed, its the progress counter
 175          * has not moved and it has NOT been waiting for a poll() call.
 176          */
 177         if (uatomic_read(&state->flags) & HEALTH_ERROR) {
 178                 retval = 0;
 179                 goto end;
 180         }
 181
 182         /*
 183          * Initial condition need to update the last counter and sample time, but
 184          * should not check health in this initial case, because we don't know how
 185          * much time has passed.
 186          */
 187         if (state->last_time.tv_sec == 0 && state->last_time.tv_nsec == 0) {
 188                 /* update last counter and last sample time */
 189                 state->last = current;
 190                 memcpy(&state->last_time, &current_time, sizeof(current_time));
 191         } else {
 192                 if (time_diff_gt(&current_time, &state->last_time,
 193                                 &ha->time_delta)) {
 194                         if (current == last && !HEALTH_IS_IN_POLL(current)) {
 195                                 /* error */
 196                                 retval = 0;
 197                         }
 198                         /* update last counter and last sample time */
 199                         state->last = current;
 200                         memcpy(&state->last_time, &current_time, sizeof(current_time));
 201
 202                         /* On error, stop right now and notify caller. */
 203                         if (retval == 0) {
 204                                 goto end;
 205                         }
 206                 }
 207         }
 208
 209 end:
 210         DBG("Health state current %lu, last %lu, ret %d",
 211                         current, last, ret);
 212         return retval;
 213 }
 214
 215 /*
 216  * Check health of a specific health type. Note that if a thread has not yet
 217  * initialize its health subsystem or has quit, it's considered in a good
 218  * state.
 219  *
 220  * Return 0 if health is bad or else 1.
 221  */
 222 int health_check_state(struct health_app *ha, int type)
 223 {
 224         int retval = 1;
 225         struct health_state *state;
 226
 227         assert(type < ha->nr_types);
 228
 229         state_lock(ha);
 230
 231         cds_list_for_each_entry(state, &ha->list, node) {
 232                 int ret;
 233
 234                 if (state->type != type) {
 235                         continue;
 236                 }
 237
 238                 ret = validate_state(ha, state);
 239                 if (!ret) {
 240                         retval = 0;
 241                         goto end;
 242                 }
 243         }
 244
 245         /* Check the global state since some state might not be visible anymore. */
 246         if (ha->flags[type] & HEALTH_ERROR) {
 247                 retval = 0;
 248         }
 249
 250 end:
 251         state_unlock(ha);
 252
 253         DBG("Health check for type %d is %s", (int) type,
 254                         (retval == 0) ? "BAD" : "GOOD");
 255         return retval;
 256 }
 257
 258 /*
 259  * Init health state.
 260  */
 261 void health_register(struct health_app *ha, int type)
 262 {
 263         assert(type < ha->nr_types);
 264
 265         /* Init TLS state. */
 266         uatomic_set(&URCU_TLS(health_state).last, 0);
 267         uatomic_set(&URCU_TLS(health_state).last_time.tv_sec, 0);
 268         uatomic_set(&URCU_TLS(health_state).last_time.tv_nsec, 0);
 269         uatomic_set(&URCU_TLS(health_state).current, 0);
 270         uatomic_set(&URCU_TLS(health_state).flags, 0);
 271         uatomic_set(&URCU_TLS(health_state).type, type);
 272
 273         /* Add it to the global TLS state list. */
 274         state_lock(ha);
 275         cds_list_add(&URCU_TLS(health_state).node, &ha->list);
 276         state_unlock(ha);
 277 }
 278
 279 /*
 280  * Remove node from global list.
 281  */
 282 void health_unregister(struct health_app *ha)
 283 {
 284         state_lock(ha);
 285         /*
 286          * On error, set the global_error_state since we are about to remove
 287          * the node from the global list.
 288          */
 289         if (uatomic_read(&URCU_TLS(health_state).flags) & HEALTH_ERROR) {
 290                 uatomic_set(&ha->flags[URCU_TLS(health_state).type],
 291                                 HEALTH_ERROR);
 292         }
 293         cds_list_del(&URCU_TLS(health_state).node);
 294         state_unlock(ha);
 295 }