src/bin/lttng-sessiond/timer.c

   1 /*
   2  * Copyright (C) 2017 - Julien Desfossez <jdesfossez@efficios.com>
   3  * Copyright (C) 2018 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License, version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc., 51
  16  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #define _LGPL_SOURCE
  20 #include <assert.h>
  21 #include <inttypes.h>
  22 #include <signal.h>
  23
  24 #include "timer.h"
  25 #include "health-sessiond.h"
  26 #include "rotation-thread.h"
  27
  28 #define LTTNG_SESSIOND_SIG_QS                           SIGRTMIN + 10
  29 #define LTTNG_SESSIOND_SIG_EXIT                         SIGRTMIN + 11
  30 #define LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK       SIGRTMIN + 12
  31 #define LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION           SIGRTMIN + 13
  32
  33 #define UINT_TO_PTR(value)                              \
  34         ({                                              \
  35                 assert(value <= UINTPTR_MAX);           \
  36                 (void *) (uintptr_t) value;             \
  37         })
  38 #define PTR_TO_UINT(ptr) ((uintptr_t) ptr)
  39
  40 /*
  41  * Handle timer teardown race wrt memory free of private data by sessiond
  42  * signals are handled by a single thread, which permits a synchronization
  43  * point between handling of each signal. Internal lock ensures mutual
  44  * exclusion.
  45  */
  46 static
  47 struct timer_signal_data {
  48         /* Thread managing signals. */
  49         pthread_t tid;
  50         int qs_done;
  51         pthread_mutex_t lock;
  52 } timer_signal = {
  53         .tid = 0,
  54         .qs_done = 0,
  55         .lock = PTHREAD_MUTEX_INITIALIZER,
  56 };
  57
  58 /*
  59  * Set custom signal mask to current thread.
  60  */
  61 static
  62 void setmask(sigset_t *mask)
  63 {
  64         int ret;
  65
  66         ret = sigemptyset(mask);
  67         if (ret) {
  68                 PERROR("sigemptyset");
  69         }
  70         ret = sigaddset(mask, LTTNG_SESSIOND_SIG_QS);
  71         if (ret) {
  72                 PERROR("sigaddset teardown");
  73         }
  74         ret = sigaddset(mask, LTTNG_SESSIOND_SIG_EXIT);
  75         if (ret) {
  76                 PERROR("sigaddset exit");
  77         }
  78         ret = sigaddset(mask, LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK);
  79         if (ret) {
  80                 PERROR("sigaddset pending rotation check");
  81         }
  82         ret = sigaddset(mask, LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION);
  83         if (ret) {
  84                 PERROR("sigaddset scheduled rotation");
  85         }
  86 }
  87
  88 /*
  89  * This is the same function as timer_signal_thread_qs, when it
  90  * returns, it means that no timer signr is currently pending or being handled
  91  * by the timer thread. This cannot be called from the timer thread.
  92  */
  93 static
  94 void timer_signal_thread_qs(unsigned int signr)
  95 {
  96         sigset_t pending_set;
  97         int ret;
  98
  99         /*
 100          * We need to be the only thread interacting with the thread
 101          * that manages signals for teardown synchronization.
 102          */
 103         pthread_mutex_lock(&timer_signal.lock);
 104
 105         /* Ensure we don't have any signal queued for this session. */
 106         for (;;) {
 107                 ret = sigemptyset(&pending_set);
 108                 if (ret == -1) {
 109                         PERROR("sigemptyset");
 110                 }
 111                 ret = sigpending(&pending_set);
 112                 if (ret == -1) {
 113                         PERROR("sigpending");
 114                 }
 115                 if (!sigismember(&pending_set, signr)) {
 116                         break;
 117                 }
 118                 caa_cpu_relax();
 119         }
 120
 121         /*
 122          * From this point, no new signal handler will be fired that would try to
 123          * access "session". However, we still need to wait for any currently
 124          * executing handler to complete.
 125          */
 126         cmm_smp_mb();
 127         CMM_STORE_SHARED(timer_signal.qs_done, 0);
 128         cmm_smp_mb();
 129
 130         /*
 131          * Kill with LTTNG_SESSIOND_SIG_QS, so signal management thread
 132          * wakes up.
 133          */
 134         kill(getpid(), LTTNG_SESSIOND_SIG_QS);
 135
 136         while (!CMM_LOAD_SHARED(timer_signal.qs_done)) {
 137                 caa_cpu_relax();
 138         }
 139         cmm_smp_mb();
 140
 141         pthread_mutex_unlock(&timer_signal.lock);
 142 }
 143
 144 /*
 145  * Start a timer on a session that will fire at a given interval
 146  * (timer_interval_us) and fire a given signal (signal).
 147  *
 148  * Returns a negative value on error, 0 if a timer was created, and
 149  * a positive value if no timer was created (not an error).
 150  */
 151 static
 152 int timer_start(timer_t *timer_id, struct ltt_session *session,
 153                 unsigned int timer_interval_us, int signal, bool one_shot)
 154 {
 155         int ret = 0, delete_ret;
 156         struct sigevent sev;
 157         struct itimerspec its;
 158
 159         sev.sigev_notify = SIGEV_SIGNAL;
 160         sev.sigev_signo = signal;
 161         sev.sigev_value.sival_ptr = session;
 162         ret = timer_create(CLOCK_MONOTONIC, &sev, timer_id);
 163         if (ret == -1) {
 164                 PERROR("timer_create");
 165                 goto end;
 166         }
 167
 168         its.it_value.tv_sec = timer_interval_us / 1000000;
 169         its.it_value.tv_nsec = (timer_interval_us % 1000000) * 1000;
 170         if (one_shot) {
 171                 its.it_interval.tv_sec = 0;
 172                 its.it_interval.tv_nsec = 0;
 173         } else {
 174                 its.it_interval.tv_sec = its.it_value.tv_sec;
 175                 its.it_interval.tv_nsec = its.it_value.tv_nsec;
 176         }
 177
 178         ret = timer_settime(*timer_id, 0, &its, NULL);
 179         if (ret == -1) {
 180                 PERROR("timer_settime");
 181                 goto error_destroy_timer;
 182         }
 183         goto end;
 184
 185 error_destroy_timer:
 186         delete_ret = timer_delete(*timer_id);
 187         if (delete_ret == -1) {
 188                 PERROR("timer_delete");
 189         }
 190
 191 end:
 192         return ret;
 193 }
 194
 195 static
 196 int timer_stop(timer_t *timer_id, int signal)
 197 {
 198         int ret = 0;
 199
 200         ret = timer_delete(*timer_id);
 201         if (ret == -1) {
 202                 PERROR("timer_delete");
 203                 goto end;
 204         }
 205
 206         timer_signal_thread_qs(signal);
 207         *timer_id = 0;
 208 end:
 209         return ret;
 210 }
 211
 212 int timer_session_rotation_pending_check_start(struct ltt_session *session,
 213                 unsigned int interval_us)
 214 {
 215         int ret;
 216
 217         if (!session_get(session)) {
 218                 ret = -1;
 219                 goto end;
 220         }
 221         DBG("Enabling session rotation pending check timer on session %" PRIu64,
 222                         session->id);
 223         /*
 224          * We arm this timer in a one-shot mode so we don't have to disable it
 225          * explicitly (which could deadlock if the timer thread is blocked
 226          * writing in the rotation_timer_pipe).
 227          *
 228          * Instead, we re-arm it if needed after the rotation_pending check as
 229          * returned. Also, this timer is usually only needed once, so there is
 230          * no need to go through the whole signal teardown scheme everytime.
 231          */
 232         ret = timer_start(&session->rotation_pending_check_timer,
 233                         session, interval_us,
 234                         LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK,
 235                         /* one-shot */ true);
 236         if (ret == 0) {
 237                 session->rotation_pending_check_timer_enabled = true;
 238         }
 239 end:
 240         return ret;
 241 }
 242
 243 /*
 244  * Call with session and session_list locks held.
 245  */
 246 int timer_session_rotation_pending_check_stop(struct ltt_session *session)
 247 {
 248         int ret;
 249
 250         assert(session);
 251
 252         DBG("Disabling session rotation pending check timer on session %" PRIu64,
 253                         session->id);
 254         ret = timer_stop(&session->rotation_pending_check_timer,
 255                         LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK);
 256         if (ret == -1) {
 257                 ERR("Failed to stop rotate_pending_check timer");
 258         } else {
 259                 session->rotation_pending_check_timer_enabled = false;
 260                 /*
 261                  * The timer's reference to the session can be released safely.
 262                  */
 263                 session_put(session);
 264         }
 265         return ret;
 266 }
 267
 268 /*
 269  * Call with session and session_list locks held.
 270  */
 271 int timer_session_rotation_schedule_timer_start(struct ltt_session *session,
 272                 unsigned int interval_us)
 273 {
 274         int ret;
 275
 276         if (!session_get(session)) {
 277                 ret = -1;
 278                 goto end;
 279         }
 280         DBG("Enabling scheduled rotation timer on session \"%s\" (%ui µs)", session->name,
 281                         interval_us);
 282         ret = timer_start(&session->rotation_schedule_timer, session,
 283                         interval_us, LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION,
 284                         /* one-shot */ false);
 285         if (ret < 0) {
 286                 goto end;
 287         }
 288         session->rotation_schedule_timer_enabled = true;
 289 end:
 290         return ret;
 291 }
 292
 293 /*
 294  * Call with session and session_list locks held.
 295  */
 296 int timer_session_rotation_schedule_timer_stop(struct ltt_session *session)
 297 {
 298         int ret = 0;
 299
 300         assert(session);
 301
 302         if (!session->rotation_schedule_timer_enabled) {
 303                 goto end;
 304         }
 305
 306         DBG("Disabling scheduled rotation timer on session %s", session->name);
 307         ret = timer_stop(&session->rotation_schedule_timer,
 308                         LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION);
 309         if (ret < 0) {
 310                 ERR("Failed to stop scheduled rotation timer of session \"%s\"",
 311                                 session->name);
 312                 goto end;
 313         }
 314
 315         session->rotation_schedule_timer_enabled = false;
 316         /* The timer's reference to the session can be released safely. */
 317         session_put(session);
 318         ret = 0;
 319 end:
 320         return ret;
 321 }
 322
 323 /*
 324  * Block the RT signals for the entire process. It must be called from the
 325  * sessiond main before creating the threads
 326  */
 327 int timer_signal_init(void)
 328 {
 329         int ret;
 330         sigset_t mask;
 331
 332         /* Block signal for entire process, so only our thread processes it. */
 333         setmask(&mask);
 334         ret = pthread_sigmask(SIG_BLOCK, &mask, NULL);
 335         if (ret) {
 336                 errno = ret;
 337                 PERROR("pthread_sigmask");
 338                 return -1;
 339         }
 340         return 0;
 341 }
 342
 343 /*
 344  * This thread is the sighandler for the timer signals.
 345  */
 346 void *timer_thread_func(void *data)
 347 {
 348         int signr;
 349         sigset_t mask;
 350         siginfo_t info;
 351         struct timer_thread_parameters *ctx = data;
 352
 353         rcu_register_thread();
 354         rcu_thread_online();
 355
 356         health_register(health_sessiond, HEALTH_SESSIOND_TYPE_TIMER);
 357         health_code_update();
 358
 359         /* Only self thread will receive signal mask. */
 360         setmask(&mask);
 361         CMM_STORE_SHARED(timer_signal.tid, pthread_self());
 362
 363         while (1) {
 364                 health_code_update();
 365
 366                 health_poll_entry();
 367                 signr = sigwaitinfo(&mask, &info);
 368                 health_poll_exit();
 369
 370                 /*
 371                  * NOTE: cascading conditions are used instead of a switch case
 372                  * since the use of SIGRTMIN in the definition of the signals'
 373                  * values prevents the reduction to an integer constant.
 374                  */
 375                 if (signr == -1) {
 376                         if (errno != EINTR) {
 377                                 PERROR("sigwaitinfo");
 378                         }
 379                         continue;
 380                 } else if (signr == LTTNG_SESSIOND_SIG_QS) {
 381                         cmm_smp_mb();
 382                         CMM_STORE_SHARED(timer_signal.qs_done, 1);
 383                         cmm_smp_mb();
 384                 } else if (signr == LTTNG_SESSIOND_SIG_EXIT) {
 385                         goto end;
 386                 } else if (signr == LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK) {
 387                         struct ltt_session *session =
 388                                         (struct ltt_session *) info.si_value.sival_ptr;
 389
 390                         rotation_thread_enqueue_job(ctx->rotation_thread_job_queue,
 391                                         ROTATION_THREAD_JOB_TYPE_CHECK_PENDING_ROTATION,
 392                                         session);
 393                         session_lock_list();
 394                         session_put(session);
 395                         session_unlock_list();
 396                 } else if (signr == LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION) {
 397                         rotation_thread_enqueue_job(ctx->rotation_thread_job_queue,
 398                                         ROTATION_THREAD_JOB_TYPE_SCHEDULED_ROTATION,
 399                                         (struct ltt_session *) info.si_value.sival_ptr);
 400                         /*
 401                          * The scheduled periodic rotation timer is not in
 402                          * "one-shot" mode. The reference to the session is not
 403                          * released since the timer is still enabled and can
 404                          * still fire.
 405                          */
 406                 } else {
 407                         ERR("Unexpected signal %d\n", info.si_signo);
 408                 }
 409         }
 410
 411 end:
 412         DBG("[timer-thread] Exit");
 413         health_unregister(health_sessiond);
 414         rcu_thread_offline();
 415         rcu_unregister_thread();
 416         return NULL;
 417 }
 418
 419 void timer_exit(void)
 420 {
 421         kill(getpid(), LTTNG_SESSIOND_SIG_EXIT);
 422 }