src/common/consumer-timer.c

   1 /*
   2  * Copyright (C) 2012 - Julien Desfossez <julien.desfossez@efficios.com>
   3  *                      David Goulet <dgoulet@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 _GNU_SOURCE
  20 #include <assert.h>
  21 #include <inttypes.h>
  22 #include <signal.h>
  23
  24 #include <common/common.h>
  25
  26 #include "consumer-timer.h"
  27 #include "ust-consumer/ust-consumer.h"
  28
  29 static struct timer_signal_data timer_signal = {
  30         .tid = 0,
  31         .setup_done = 0,
  32         .qs_done = 0,
  33         .lock = PTHREAD_MUTEX_INITIALIZER,
  34 };
  35
  36 /*
  37  * Set custom signal mask to current thread.
  38  */
  39 static void setmask(sigset_t *mask)
  40 {
  41         int ret;
  42
  43         ret = sigemptyset(mask);
  44         if (ret) {
  45                 PERROR("sigemptyset");
  46         }
  47         ret = sigaddset(mask, LTTNG_CONSUMER_SIG_SWITCH);
  48         if (ret) {
  49                 PERROR("sigaddset");
  50         }
  51         ret = sigaddset(mask, LTTNG_CONSUMER_SIG_TEARDOWN);
  52         if (ret) {
  53                 PERROR("sigaddset");
  54         }
  55 }
  56
  57 /*
  58  * Execute action on a timer switch.
  59  *
  60  * Beware: metadata_switch_timer() should *never* take a mutex also held
  61  * while consumer_timer_switch_stop() is called. It would result in
  62  * deadlocks.
  63  */
  64 static void metadata_switch_timer(struct lttng_consumer_local_data *ctx,
  65                 int sig, siginfo_t *si, void *uc)
  66 {
  67         int ret;
  68         struct lttng_consumer_channel *channel;
  69
  70         channel = si->si_value.sival_ptr;
  71         assert(channel);
  72
  73         if (channel->switch_timer_error) {
  74                 return;
  75         }
  76
  77         DBG("Switch timer for channel %" PRIu64, channel->key);
  78         switch (ctx->type) {
  79         case LTTNG_CONSUMER32_UST:
  80         case LTTNG_CONSUMER64_UST:
  81                 ret = lttng_ustconsumer_request_metadata(ctx, channel);
  82                 if (ret < 0) {
  83                         channel->switch_timer_error = 1;
  84                 }
  85                 break;
  86         case LTTNG_CONSUMER_KERNEL:
  87         case LTTNG_CONSUMER_UNKNOWN:
  88                 assert(0);
  89                 break;
  90         }
  91 }
  92
  93 static
  94 void consumer_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 channel. */
 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, LTTNG_CONSUMER_SIG_SWITCH)) {
 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 "chan". 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_CONSUMER_SIG_TEARDOWN, so signal management thread wakes
 132          * up.
 133          */
 134         kill(getpid(), LTTNG_CONSUMER_SIG_TEARDOWN);
 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  * Set the timer for periodical metadata flush.
 146  */
 147 void consumer_timer_switch_start(struct lttng_consumer_channel *channel,
 148                 unsigned int switch_timer_interval)
 149 {
 150         int ret;
 151         struct sigevent sev;
 152         struct itimerspec its;
 153
 154         assert(channel);
 155         assert(channel->key);
 156
 157         if (switch_timer_interval == 0) {
 158                 return;
 159         }
 160
 161         sev.sigev_notify = SIGEV_SIGNAL;
 162         sev.sigev_signo = LTTNG_CONSUMER_SIG_SWITCH;
 163         sev.sigev_value.sival_ptr = channel;
 164         ret = timer_create(CLOCKID, &sev, &channel->switch_timer);
 165         if (ret == -1) {
 166                 PERROR("timer_create");
 167         }
 168         channel->switch_timer_enabled = 1;
 169
 170         its.it_value.tv_sec = switch_timer_interval / 1000000;
 171         its.it_value.tv_nsec = switch_timer_interval % 1000000;
 172         its.it_interval.tv_sec = its.it_value.tv_sec;
 173         its.it_interval.tv_nsec = its.it_value.tv_nsec;
 174
 175         ret = timer_settime(channel->switch_timer, 0, &its, NULL);
 176         if (ret == -1) {
 177                 PERROR("timer_settime");
 178         }
 179 }
 180
 181 /*
 182  * Stop and delete timer.
 183  */
 184 void consumer_timer_switch_stop(struct lttng_consumer_channel *channel)
 185 {
 186         int ret;
 187
 188         assert(channel);
 189
 190         ret = timer_delete(channel->switch_timer);
 191         if (ret == -1) {
 192                 PERROR("timer_delete");
 193         }
 194
 195         consumer_timer_signal_thread_qs(LTTNG_CONSUMER_SIG_SWITCH);
 196
 197         channel->switch_timer = 0;
 198         channel->switch_timer_enabled = 0;
 199 }
 200
 201 /*
 202  * Block the RT signals for the entire process. It must be called from the
 203  * consumer main before creating the threads
 204  */
 205 void consumer_signal_init(void)
 206 {
 207         int ret;
 208         sigset_t mask;
 209
 210         /* Block signal for entire process, so only our thread processes it. */
 211         setmask(&mask);
 212         ret = pthread_sigmask(SIG_BLOCK, &mask, NULL);
 213         if (ret) {
 214                 errno = ret;
 215                 PERROR("pthread_sigmask");
 216         }
 217 }
 218
 219 /*
 220  * This thread is the sighandler for signals LTTNG_CONSUMER_SIG_SWITCH and
 221  * LTTNG_CONSUMER_SIG_TEARDOWN that are emitted by the periodic timer to check
 222  * if new metadata is available.
 223  */
 224 void *consumer_timer_metadata_thread(void *data)
 225 {
 226         int signr;
 227         sigset_t mask;
 228         siginfo_t info;
 229         struct lttng_consumer_local_data *ctx = data;
 230
 231         /* Only self thread will receive signal mask. */
 232         setmask(&mask);
 233         CMM_STORE_SHARED(timer_signal.tid, pthread_self());
 234
 235         while (1) {
 236                 signr = sigwaitinfo(&mask, &info);
 237                 if (signr == -1) {
 238                         if (errno != EINTR) {
 239                                 PERROR("sigwaitinfo");
 240                         }
 241                         continue;
 242                 } else if (signr == LTTNG_CONSUMER_SIG_SWITCH) {
 243                         metadata_switch_timer(ctx, info.si_signo, &info, NULL);
 244                 } else if (signr == LTTNG_CONSUMER_SIG_TEARDOWN) {
 245                         cmm_smp_mb();
 246                         CMM_STORE_SHARED(timer_signal.qs_done, 1);
 247                         cmm_smp_mb();
 248                         DBG("Signal timer metadata thread teardown");
 249                 } else {
 250                         ERR("Unexpected signal %d\n", info.si_signo);
 251                 }
 252         }
 253
 254         return NULL;
 255 }