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         assert(session->rotation_pending_check_timer_enabled);
 252
 253         DBG("Disabling session rotation pending check timer on session %" PRIu64,
 254                         session->id);
 255         ret = timer_stop(&session->rotation_pending_check_timer,
 256                         LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK);
 257         if (ret == -1) {
 258                 ERR("Failed to stop rotate_pending_check timer");
 259         } else {
 260                 session->rotation_pending_check_timer_enabled = false;
 261                 /*
 262                  * The timer's reference to the session can be released safely.
 263                  */
 264                 session_put(session);
 265         }
 266         return ret;
 267 }
 268
 269 /*
 270  * Call with session and session_list locks held.
 271  */
 272 int timer_session_rotation_schedule_timer_start(struct ltt_session *session,
 273                 unsigned int interval_us)
 274 {
 275         int ret;
 276
 277         if (!session_get(session)) {
 278                 ret = -1;
 279                 goto end;
 280         }
 281         DBG("Enabling scheduled rotation timer on session \"%s\" (%ui µs)", session->name,
 282                         interval_us);
 283         ret = timer_start(&session->rotation_schedule_timer, session,
 284                         interval_us, LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION,
 285                         /* one-shot */ false);
 286         if (ret < 0) {
 287                 goto end;
 288         }
 289         session->rotation_schedule_timer_enabled = true;
 290 end:
 291         return ret;
 292 }
 293
 294 /*
 295  * Call with session and session_list locks held.
 296  */
 297 int timer_session_rotation_schedule_timer_stop(struct ltt_session *session)
 298 {
 299         int ret = 0;
 300
 301         assert(session);
 302
 303         if (!session->rotation_schedule_timer_enabled) {
 304                 goto end;
 305         }
 306
 307         DBG("Disabling scheduled rotation timer on session %s", session->name);
 308         ret = timer_stop(&session->rotation_schedule_timer,
 309                         LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION);
 310         if (ret < 0) {
 311                 ERR("Failed to stop scheduled rotation timer of session \"%s\"",
 312                                 session->name);
 313                 goto end;
 314         }
 315
 316         session->rotation_schedule_timer_enabled = false;
 317         /* The timer's reference to the session can be released safely. */
 318         session_put(session);
 319         ret = 0;
 320 end:
 321         return ret;
 322 }
 323
 324 /*
 325  * Block the RT signals for the entire process. It must be called from the
 326  * sessiond main before creating the threads
 327  */
 328 int timer_signal_init(void)
 329 {
 330         int ret;
 331         sigset_t mask;
 332
 333         /* Block signal for entire process, so only our thread processes it. */
 334         setmask(&mask);
 335         ret = pthread_sigmask(SIG_BLOCK, &mask, NULL);
 336         if (ret) {
 337                 errno = ret;
 338                 PERROR("pthread_sigmask");
 339                 return -1;
 340         }
 341         return 0;
 342 }
 343
 344 /*
 345  * This thread is the sighandler for the timer signals.
 346  */
 347 void *timer_thread_func(void *data)
 348 {
 349         int signr;
 350         sigset_t mask;
 351         siginfo_t info;
 352         struct timer_thread_parameters *ctx = data;
 353
 354         rcu_register_thread();
 355         rcu_thread_online();
 356
 357         health_register(health_sessiond, HEALTH_SESSIOND_TYPE_TIMER);
 358         health_code_update();
 359
 360         /* Only self thread will receive signal mask. */
 361         setmask(&mask);
 362         CMM_STORE_SHARED(timer_signal.tid, pthread_self());
 363
 364         while (1) {
 365                 health_code_update();
 366
 367                 health_poll_entry();
 368                 signr = sigwaitinfo(&mask, &info);
 369                 health_poll_exit();
 370
 371                 /*
 372                  * NOTE: cascading conditions are used instead of a switch case
 373                  * since the use of SIGRTMIN in the definition of the signals'
 374                  * values prevents the reduction to an integer constant.
 375                  */
 376                 if (signr == -1) {
 377                         if (errno != EINTR) {
 378                                 PERROR("sigwaitinfo");
 379                         }
 380                         continue;
 381                 } else if (signr == LTTNG_SESSIOND_SIG_QS) {
 382                         cmm_smp_mb();
 383                         CMM_STORE_SHARED(timer_signal.qs_done, 1);
 384                         cmm_smp_mb();
 385                 } else if (signr == LTTNG_SESSIOND_SIG_EXIT) {
 386                         goto end;
 387                 } else if (signr == LTTNG_SESSIOND_SIG_PENDING_ROTATION_CHECK) {
 388                         struct ltt_session *session =
 389                                         (struct ltt_session *) info.si_value.sival_ptr;
 390
 391                         rotation_thread_enqueue_job(ctx->rotation_thread_job_queue,
 392                                         ROTATION_THREAD_JOB_TYPE_CHECK_PENDING_ROTATION,
 393                                         session);
 394                 } else if (signr == LTTNG_SESSIOND_SIG_SCHEDULED_ROTATION) {
 395                         rotation_thread_enqueue_job(ctx->rotation_thread_job_queue,
 396                                         ROTATION_THREAD_JOB_TYPE_SCHEDULED_ROTATION,
 397                                         (struct ltt_session *) info.si_value.sival_ptr);
 398                         /*
 399                          * The scheduled periodic rotation timer is not in
 400                          * "one-shot" mode. The reference to the session is not
 401                          * released since the timer is still enabled and can
 402                          * still fire.
 403                          */
 404                 } else {
 405                         ERR("Unexpected signal %d\n", info.si_signo);
 406                 }
 407         }
 408
 409 end:
 410         DBG("[timer-thread] Exit");
 411         health_unregister(health_sessiond);
 412         rcu_thread_offline();
 413         rcu_unregister_thread();
 414         return NULL;
 415 }
 416
 417 void timer_exit(void)
 418 {
 419         kill(getpid(), LTTNG_SESSIOND_SIG_EXIT);
 420 }