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
  31 /*
  32  * Set custom signal mask to current thread.
  33  */
  34 static void setmask(sigset_t *mask)
  35 {
  36         int ret;
  37
  38         ret = sigemptyset(mask);
  39         if (ret) {
  40                 PERROR("sigemptyset");
  41         }
  42         ret = sigaddset(mask, LTTNG_CONSUMER_SIG_SWITCH);
  43         if (ret) {
  44                 PERROR("sigaddset");
  45         }
  46         ret = sigaddset(mask, LTTNG_CONSUMER_SIG_TEARDOWN);
  47         if (ret) {
  48                 PERROR("sigaddset");
  49         }
  50 }
  51
  52 /*
  53  * Execute action on a timer switch.
  54  */
  55 static void metadata_switch_timer(struct lttng_consumer_local_data *ctx,
  56                 int sig, siginfo_t *si, void *uc)
  57 {
  58         int ret;
  59         struct lttng_consumer_channel *channel;
  60
  61         channel = si->si_value.sival_ptr;
  62         assert(channel);
  63
  64         DBG("Switch timer for channel %" PRIu64, channel->key);
  65         switch (ctx->type) {
  66         case LTTNG_CONSUMER32_UST:
  67         case LTTNG_CONSUMER64_UST:
  68                 ret = lttng_ustconsumer_request_metadata(ctx, channel);
  69                 if (ret < 0) {
  70                         /*
  71                          * An error means that we were unable to request the metadata to
  72                          * the session daemon so stop the timer for that channel.
  73                          */
  74                         consumer_timer_switch_stop(channel);
  75                 }
  76                 break;
  77         case LTTNG_CONSUMER_KERNEL:
  78         case LTTNG_CONSUMER_UNKNOWN:
  79                 assert(0);
  80                 break;
  81         }
  82 }
  83
  84 /*
  85  * Set the timer for periodical metadata flush.
  86  */
  87 void consumer_timer_switch_start(struct lttng_consumer_channel *channel,
  88                 unsigned int switch_timer_interval)
  89 {
  90         int ret;
  91         struct sigevent sev;
  92         struct itimerspec its;
  93
  94         assert(channel);
  95         assert(channel->key);
  96
  97         if (switch_timer_interval == 0) {
  98                 return;
  99         }
 100
 101         sev.sigev_notify = SIGEV_SIGNAL;
 102         sev.sigev_signo = LTTNG_CONSUMER_SIG_SWITCH;
 103         sev.sigev_value.sival_ptr = channel;
 104         ret = timer_create(CLOCKID, &sev, &channel->switch_timer);
 105         if (ret == -1) {
 106                 PERROR("timer_create");
 107         }
 108         channel->switch_timer_enabled = 1;
 109
 110         its.it_value.tv_sec = switch_timer_interval / 1000000;
 111         its.it_value.tv_nsec = switch_timer_interval % 1000000;
 112         its.it_interval.tv_sec = its.it_value.tv_sec;
 113         its.it_interval.tv_nsec = its.it_value.tv_nsec;
 114
 115         ret = timer_settime(channel->switch_timer, 0, &its, NULL);
 116         if (ret == -1) {
 117                 PERROR("timer_settime");
 118         }
 119 }
 120
 121 /*
 122  * Stop and delete timer.
 123  */
 124 void consumer_timer_switch_stop(struct lttng_consumer_channel *channel)
 125 {
 126         int ret;
 127         sigset_t pending_set;
 128
 129         assert(channel);
 130
 131         ret = timer_delete(channel->switch_timer);
 132         if (ret == -1) {
 133                 PERROR("timer_delete");
 134         }
 135
 136         /* Ensure we don't have any signal queued for this channel. */
 137         for (;;) {
 138                 ret = sigemptyset(&pending_set);
 139                 if (ret == -1) {
 140                         PERROR("sigemptyset");
 141                 }
 142                 ret = sigpending(&pending_set);
 143                 if (ret == -1) {
 144                         PERROR("sigpending");
 145                 }
 146                 if (!sigismember(&pending_set, LTTNG_CONSUMER_SIG_SWITCH)) {
 147                         break;
 148                 }
 149                 caa_cpu_relax();
 150         }
 151
 152         /*
 153          * From this point, no new signal handler will be fired that would try to
 154          * access "chan". However, we still need to wait for any currently
 155          * executing handler to complete.
 156          */
 157         cmm_smp_mb();
 158         CMM_STORE_SHARED(timer_signal.qs_done, 0);
 159         cmm_smp_mb();
 160
 161         /*
 162          * Kill with LTTNG_CONSUMER_SIG_TEARDOWN, so signal management thread wakes
 163          * up.
 164          */
 165         kill(getpid(), LTTNG_CONSUMER_SIG_TEARDOWN);
 166
 167         while (!CMM_LOAD_SHARED(timer_signal.qs_done)) {
 168                 caa_cpu_relax();
 169         }
 170         cmm_smp_mb();
 171 }
 172
 173 /*
 174  * Block the RT signals for the entire process. It must be called from the
 175  * consumer main before creating the threads
 176  */
 177 void consumer_signal_init(void)
 178 {
 179         int ret;
 180         sigset_t mask;
 181
 182         /* Block signal for entire process, so only our thread processes it. */
 183         setmask(&mask);
 184         ret = pthread_sigmask(SIG_BLOCK, &mask, NULL);
 185         if (ret) {
 186                 errno = ret;
 187                 PERROR("pthread_sigmask");
 188         }
 189 }
 190
 191 /*
 192  * This thread is the sighandler for signals LTTNG_CONSUMER_SIG_SWITCH and
 193  * LTTNG_CONSUMER_SIG_TEARDOWN that are emitted by the periodic timer to check
 194  * if new metadata is available.
 195  */
 196 void *consumer_timer_metadata_thread(void *data)
 197 {
 198         int signr;
 199         sigset_t mask;
 200         siginfo_t info;
 201         struct lttng_consumer_local_data *ctx = data;
 202
 203         /* Only self thread will receive signal mask. */
 204         setmask(&mask);
 205         CMM_STORE_SHARED(timer_signal.tid, pthread_self());
 206
 207         while (1) {
 208                 signr = sigwaitinfo(&mask, &info);
 209                 if (signr == -1) {
 210                         if (errno != EINTR) {
 211                                 PERROR("sigwaitinfo");
 212                         }
 213                         continue;
 214                 } else if (signr == LTTNG_CONSUMER_SIG_SWITCH) {
 215                         metadata_switch_timer(ctx, info.si_signo, &info, NULL);
 216                 } else if (signr == LTTNG_CONSUMER_SIG_TEARDOWN) {
 217                         cmm_smp_mb();
 218                         CMM_STORE_SHARED(timer_signal.qs_done, 1);
 219                         cmm_smp_mb();
 220                         DBG("Signal timer metadata thread teardown");
 221                 } else {
 222                         ERR("Unexpected signal %d\n", info.si_signo);
 223                 }
 224         }
 225
 226         return NULL;
 227 }