src/bin/lttng-sessiond/kernel-consumer.c

   1 /*
   2  * Copyright (C) 2012 - David Goulet <dgoulet@efficios.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License, version 2 only, as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with
  14  * this program; if not, write to the Free Software Foundation, Inc., 51
  15  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  16  */
  17
  18 #define _GNU_SOURCE
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <sys/stat.h>
  23 #include <unistd.h>
  24
  25 #include <common/common.h>
  26 #include <common/defaults.h>
  27
  28 #include "consumer.h"
  29 #include "health.h"
  30 #include "kernel-consumer.h"
  31
  32 static char *create_channel_path(struct consumer_output *consumer,
  33                 uid_t uid, gid_t gid)
  34 {
  35         int ret;
  36         char tmp_path[PATH_MAX];
  37         char *pathname = NULL;
  38
  39         assert(consumer);
  40
  41         /* Get the right path name destination */
  42         if (consumer->type == CONSUMER_DST_LOCAL) {
  43                 /* Set application path to the destination path */
  44                 ret = snprintf(tmp_path, sizeof(tmp_path), "%s%s",
  45                                 consumer->dst.trace_path, consumer->subdir);
  46                 if (ret < 0) {
  47                         PERROR("snprintf kernel channel path");
  48                         goto error;
  49                 }
  50                 pathname = strndup(tmp_path, sizeof(tmp_path));
  51
  52                 /* Create directory */
  53                 ret = run_as_mkdir_recursive(pathname, S_IRWXU | S_IRWXG, uid, gid);
  54                 if (ret < 0) {
  55                         if (ret != -EEXIST) {
  56                                 ERR("Trace directory creation error");
  57                                 goto error;
  58                         }
  59                 }
  60                 DBG3("Kernel local consumer tracefile path: %s", pathname);
  61         } else {
  62                 ret = snprintf(tmp_path, sizeof(tmp_path), "%s", consumer->subdir);
  63                 if (ret < 0) {
  64                         PERROR("snprintf kernel metadata path");
  65                         goto error;
  66                 }
  67                 pathname = strndup(tmp_path, sizeof(tmp_path));
  68                 DBG3("Kernel network consumer subdir path: %s", pathname);
  69         }
  70
  71         return pathname;
  72
  73 error:
  74         free(pathname);
  75         return NULL;
  76 }
  77
  78 /*
  79  * Sending a single channel to the consumer with command ADD_CHANNEL.
  80  */
  81 int kernel_consumer_add_channel(struct consumer_socket *sock,
  82                 struct ltt_kernel_channel *channel, struct ltt_kernel_session *session,
  83                 unsigned int monitor)
  84 {
  85         int ret;
  86         char *pathname;
  87         struct lttcomm_consumer_msg lkm;
  88         struct consumer_output *consumer;
  89
  90         /* Safety net */
  91         assert(channel);
  92         assert(session);
  93         assert(session->consumer);
  94
  95         consumer = session->consumer;
  96
  97         DBG("Kernel consumer adding channel %s to kernel consumer",
  98                         channel->channel->name);
  99
 100         if (monitor) {
 101                 pathname = create_channel_path(consumer, session->uid, session->gid);
 102                 if (!pathname) {
 103                         ret = -1;
 104                         goto error;
 105                 }
 106         } else {
 107                 /* Empty path. */
 108                 pathname = "";
 109         }
 110
 111         /* Prep channel message structure */
 112         consumer_init_channel_comm_msg(&lkm,
 113                         LTTNG_CONSUMER_ADD_CHANNEL,
 114                         channel->fd,
 115                         session->id,
 116                         pathname,
 117                         session->uid,
 118                         session->gid,
 119                         consumer->net_seq_index,
 120                         channel->channel->name,
 121                         channel->stream_count,
 122                         channel->channel->attr.output,
 123                         CONSUMER_CHANNEL_TYPE_DATA,
 124                         channel->channel->attr.tracefile_size,
 125                         channel->channel->attr.tracefile_count,
 126                         monitor);
 127
 128         health_code_update();
 129
 130         ret = consumer_send_channel(sock, &lkm);
 131         if (ret < 0) {
 132                 goto error;
 133         }
 134
 135         health_code_update();
 136
 137 error:
 138         return ret;
 139 }
 140
 141 /*
 142  * Sending metadata to the consumer with command ADD_CHANNEL and ADD_STREAM.
 143  */
 144 int kernel_consumer_add_metadata(struct consumer_socket *sock,
 145                 struct ltt_kernel_session *session, unsigned int monitor)
 146 {
 147         int ret;
 148         char *pathname;
 149         struct lttcomm_consumer_msg lkm;
 150         struct consumer_output *consumer;
 151
 152         /* Safety net */
 153         assert(session);
 154         assert(session->consumer);
 155         assert(sock);
 156
 157         DBG("Sending metadata %d to kernel consumer", session->metadata_stream_fd);
 158
 159         /* Get consumer output pointer */
 160         consumer = session->consumer;
 161
 162         if (monitor) {
 163                 pathname = create_channel_path(consumer, session->uid, session->gid);
 164                 if (!pathname) {
 165                         ret = -1;
 166                         goto error;
 167                 }
 168         } else {
 169                 /* Empty path. */
 170                 pathname = "";
 171         }
 172
 173         /* Prep channel message structure */
 174         consumer_init_channel_comm_msg(&lkm,
 175                         LTTNG_CONSUMER_ADD_CHANNEL,
 176                         session->metadata->fd,
 177                         session->id,
 178                         pathname,
 179                         session->uid,
 180                         session->gid,
 181                         consumer->net_seq_index,
 182                         DEFAULT_METADATA_NAME,
 183                         1,
 184                         DEFAULT_KERNEL_CHANNEL_OUTPUT,
 185                         CONSUMER_CHANNEL_TYPE_METADATA,
 186                         0, 0,
 187                         monitor);
 188
 189         health_code_update();
 190
 191         ret = consumer_send_channel(sock, &lkm);
 192         if (ret < 0) {
 193                 goto error;
 194         }
 195
 196         health_code_update();
 197
 198         /* Prep stream message structure */
 199         consumer_init_stream_comm_msg(&lkm,
 200                         LTTNG_CONSUMER_ADD_STREAM,
 201                         session->metadata->fd,
 202                         session->metadata_stream_fd,
 203                         0); /* CPU: 0 for metadata. */
 204
 205         /*
 206          * Set the no monitor flag. If set to 1, it indicates the consumer to NOT
 207          * monitor the stream but rather add it to a special list in the associated
 208          * channel. This is used to handle ephemeral stream used by the snapshot
 209          * command or store streams for the flight recorder mode.
 210          */
 211         lkm.u.stream.no_monitor = no_monitor;
 212
 213         health_code_update();
 214
 215         /* Send stream and file descriptor */
 216         ret = consumer_send_stream(sock, consumer, &lkm,
 217                         &session->metadata_stream_fd, 1);
 218         if (ret < 0) {
 219                 goto error;
 220         }
 221
 222         health_code_update();
 223
 224 error:
 225         return ret;
 226 }
 227
 228 /*
 229  * Sending a single stream to the consumer with command ADD_STREAM.
 230  */
 231 int kernel_consumer_add_stream(struct consumer_socket *sock,
 232                 struct ltt_kernel_channel *channel, struct ltt_kernel_stream *stream,
 233                 struct ltt_kernel_session *session, unsigned int monitor)
 234 {
 235         int ret;
 236         struct lttcomm_consumer_msg lkm;
 237         struct consumer_output *consumer;
 238
 239         assert(channel);
 240         assert(stream);
 241         assert(session);
 242         assert(session->consumer);
 243         assert(sock);
 244
 245         DBG("Sending stream %d of channel %s to kernel consumer",
 246                         stream->fd, channel->channel->name);
 247
 248         /* Get consumer output pointer */
 249         consumer = session->consumer;
 250
 251         /* Prep stream consumer message */
 252         consumer_init_stream_comm_msg(&lkm,
 253                         LTTNG_CONSUMER_ADD_STREAM,
 254                         channel->fd,
 255                         stream->fd,
 256                         stream->cpu);
 257
 258         health_code_update();
 259
 260         /* Send stream and file descriptor */
 261         ret = consumer_send_stream(sock, consumer, &lkm, &stream->fd, 1);
 262         if (ret < 0) {
 263                 goto error;
 264         }
 265
 266         health_code_update();
 267
 268 error:
 269         return ret;
 270 }
 271
 272 /*
 273  * Send all stream fds of kernel channel to the consumer.
 274  */
 275 int kernel_consumer_send_channel_stream(struct consumer_socket *sock,
 276                 struct ltt_kernel_channel *channel, struct ltt_kernel_session *session,
 277                 unsigned int monitor)
 278 {
 279         int ret;
 280         struct ltt_kernel_stream *stream;
 281
 282         /* Safety net */
 283         assert(channel);
 284         assert(session);
 285         assert(session->consumer);
 286         assert(sock);
 287
 288         /* Bail out if consumer is disabled */
 289         if (!session->consumer->enabled) {
 290                 ret = LTTNG_OK;
 291                 goto error;
 292         }
 293
 294         DBG("Sending streams of channel %s to kernel consumer",
 295                         channel->channel->name);
 296
 297         ret = kernel_consumer_add_channel(sock, channel, session, monitor);
 298         if (ret < 0) {
 299                 goto error;
 300         }
 301
 302         /* Send streams */
 303         cds_list_for_each_entry(stream, &channel->stream_list.head, list) {
 304                 if (!stream->fd) {
 305                         continue;
 306                 }
 307
 308                 /* Add stream on the kernel consumer side. */
 309                 ret = kernel_consumer_add_stream(sock, channel, stream, session,
 310                                 monitor);
 311                 if (ret < 0) {
 312                         goto error;
 313                 }
 314         }
 315
 316 error:
 317         return ret;
 318 }
 319
 320 /*
 321  * Send all stream fds of the kernel session to the consumer.
 322  */
 323 int kernel_consumer_send_session(struct consumer_socket *sock,
 324                 struct ltt_kernel_session *session)
 325 {
 326         int ret, monitor = 0;
 327         struct ltt_kernel_channel *chan;
 328
 329         /* Safety net */
 330         assert(session);
 331         assert(session->consumer);
 332         assert(sock);
 333
 334         /* Bail out if consumer is disabled */
 335         if (!session->consumer->enabled) {
 336                 ret = LTTNG_OK;
 337                 goto error;
 338         }
 339
 340         /* Don't monitor the streams on the consumer if in flight recorder. */
 341         if (session->output_traces) {
 342                 monitor = 1;
 343         }
 344
 345         DBG("Sending session stream to kernel consumer");
 346
 347         if (session->metadata_stream_fd >= 0) {
 348                 ret = kernel_consumer_add_metadata(sock, session, monitor);
 349                 if (ret < 0) {
 350                         goto error;
 351                 }
 352
 353                 /* Flag that at least the metadata has been sent to the consumer. */
 354                 session->consumer_fds_sent = 1;
 355         }
 356
 357         /* Send channel and streams of it */
 358         cds_list_for_each_entry(chan, &session->channel_list.head, list) {
 359                 ret = kernel_consumer_send_channel_stream(sock, chan, session,
 360                                 monitor);
 361                 if (ret < 0) {
 362                         goto error;
 363                 }
 364         }
 365
 366         DBG("Kernel consumer FDs of metadata and channel streams sent");
 367
 368         return 0;
 369
 370 error:
 371         return ret;
 372 }