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 "kernel-consumer.h"
  30
  31 /*
  32  * Sending a single channel to the consumer with command ADD_CHANNEL.
  33  */
  34 int kernel_consumer_add_channel(int sock, struct ltt_kernel_channel *channel)
  35 {
  36         int ret;
  37         struct lttcomm_consumer_msg lkm;
  38
  39         /* Safety net */
  40         assert(channel);
  41
  42         DBG("Kernel consumer adding channel %s to kernel consumer",
  43                         channel->channel->name);
  44
  45         /* Prep channel message structure */
  46         consumer_init_channel_comm_msg(&lkm,
  47                         LTTNG_CONSUMER_ADD_CHANNEL,
  48                         channel->fd,
  49                         channel->channel->attr.subbuf_size,
  50                         0, /* Kernel */
  51                         channel->channel->name,
  52                         channel->stream_count);
  53
  54         ret = consumer_send_channel(sock, &lkm);
  55         if (ret < 0) {
  56                 goto error;
  57         }
  58
  59 error:
  60         return ret;
  61 }
  62
  63 /*
  64  * Sending metadata to the consumer with command ADD_CHANNEL and ADD_STREAM.
  65  */
  66 int kernel_consumer_add_metadata(int sock, struct ltt_kernel_session *session)
  67 {
  68         int ret;
  69         char tmp_path[PATH_MAX];
  70         const char *pathname;
  71         struct lttcomm_consumer_msg lkm;
  72         struct consumer_output *consumer;
  73
  74         /* Safety net */
  75         assert(session);
  76         assert(session->consumer);
  77
  78         DBG("Sending metadata %d to kernel consumer", session->metadata_stream_fd);
  79
  80         /* Get consumer output pointer */
  81         consumer = session->consumer;
  82
  83         /* Get the right path name destination */
  84         if (consumer->type == CONSUMER_DST_LOCAL) {
  85                 /* Set application path to the destination path */
  86                 ret = snprintf(tmp_path, sizeof(tmp_path), "%s/%s",
  87                                 consumer->dst.trace_path, consumer->subdir);
  88                 if (ret < 0) {
  89                         PERROR("snprintf metadata path");
  90                         goto error;
  91                 }
  92                 pathname = tmp_path;
  93
  94                 /* Create directory */
  95                 ret = run_as_mkdir_recursive(pathname, S_IRWXU | S_IRWXG,
  96                                 session->uid, session->gid);
  97                 if (ret < 0) {
  98                         if (ret != -EEXIST) {
  99                                 ERR("Trace directory creation error");
 100                                 goto error;
 101                         }
 102                 }
 103                 DBG3("Kernel local consumer tracefile path: %s", pathname);
 104         } else {
 105                 ret = snprintf(tmp_path, sizeof(tmp_path), "%s", consumer->subdir);
 106                 if (ret < 0) {
 107                         PERROR("snprintf metadata path");
 108                         goto error;
 109                 }
 110                 pathname = tmp_path;
 111                 DBG3("Kernel network consumer subdir path: %s", pathname);
 112         }
 113
 114         /* Prep channel message structure */
 115         consumer_init_channel_comm_msg(&lkm,
 116                         LTTNG_CONSUMER_ADD_CHANNEL,
 117                         session->metadata->fd,
 118                         session->metadata->conf->attr.subbuf_size,
 119                         0, /* for kernel */
 120                         "metadata",
 121                         1);
 122
 123         ret = consumer_send_channel(sock, &lkm);
 124         if (ret < 0) {
 125                 goto error;
 126         }
 127
 128         /* Prep stream message structure */
 129         consumer_init_stream_comm_msg(&lkm,
 130                         LTTNG_CONSUMER_ADD_STREAM,
 131                         session->metadata->fd,
 132                         session->metadata_stream_fd,
 133                         LTTNG_CONSUMER_ACTIVE_STREAM,
 134                         DEFAULT_KERNEL_CHANNEL_OUTPUT,
 135                         0, /* Kernel */
 136                         session->uid,
 137                         session->gid,
 138                         consumer->net_seq_index,
 139                         1, /* Metadata flag set */
 140                         "metadata",
 141                         pathname,
 142                         session->id);
 143
 144         /* Send stream and file descriptor */
 145         ret = consumer_send_stream(sock, consumer, &lkm,
 146                         &session->metadata_stream_fd, 1);
 147         if (ret < 0) {
 148                 goto error;
 149         }
 150
 151 error:
 152         return ret;
 153 }
 154
 155 /*
 156  * Sending a single stream to the consumer with command ADD_STREAM.
 157  */
 158 int kernel_consumer_add_stream(int sock, struct ltt_kernel_channel *channel,
 159                 struct ltt_kernel_stream *stream, struct ltt_kernel_session *session)
 160 {
 161         int ret;
 162         char tmp_path[PATH_MAX];
 163         const char *pathname;
 164         struct lttcomm_consumer_msg lkm;
 165         struct consumer_output *consumer;
 166
 167         assert(channel);
 168         assert(stream);
 169         assert(session);
 170         assert(session->consumer);
 171
 172         DBG("Sending stream %d of channel %s to kernel consumer",
 173                         stream->fd, channel->channel->name);
 174
 175         /* Get consumer output pointer */
 176         consumer = session->consumer;
 177
 178         /* Get the right path name destination */
 179         if (consumer->type == CONSUMER_DST_LOCAL) {
 180                 /* Set application path to the destination path */
 181                 ret = snprintf(tmp_path, sizeof(tmp_path), "%s/%s",
 182                                 consumer->dst.trace_path, consumer->subdir);
 183                 if (ret < 0) {
 184                         PERROR("snprintf stream path");
 185                         goto error;
 186                 }
 187                 pathname = tmp_path;
 188                 DBG3("Kernel local consumer tracefile path: %s", pathname);
 189         } else {
 190                 ret = snprintf(tmp_path, sizeof(tmp_path), "%s", consumer->subdir);
 191                 if (ret < 0) {
 192                         PERROR("snprintf stream path");
 193                         goto error;
 194                 }
 195                 pathname = tmp_path;
 196                 DBG3("Kernel network consumer subdir path: %s", pathname);
 197         }
 198
 199         /* Prep stream consumer message */
 200         consumer_init_stream_comm_msg(&lkm, LTTNG_CONSUMER_ADD_STREAM,
 201                         channel->fd,
 202                         stream->fd,
 203                         stream->state,
 204                         channel->channel->attr.output,
 205                         0, /* Kernel */
 206                         session->uid,
 207                         session->gid,
 208                         consumer->net_seq_index,
 209                         0, /* Metadata flag unset */
 210                         stream->name,
 211                         pathname,
 212                         session->id);
 213
 214         /* Send stream and file descriptor */
 215         ret = consumer_send_stream(sock, consumer, &lkm, &stream->fd, 1);
 216         if (ret < 0) {
 217                 goto error;
 218         }
 219
 220 error:
 221         return ret;
 222 }
 223
 224 /*
 225  * Send all stream fds of kernel channel to the consumer.
 226  */
 227 int kernel_consumer_send_channel_stream(int sock,
 228                 struct ltt_kernel_channel *channel, struct ltt_kernel_session *session)
 229 {
 230         int ret;
 231         struct ltt_kernel_stream *stream;
 232
 233         /* Safety net */
 234         assert(channel);
 235         assert(session);
 236         assert(session->consumer);
 237
 238         /* Bail out if consumer is disabled */
 239         if (!session->consumer->enabled) {
 240                 ret = LTTNG_OK;
 241                 goto error;
 242         }
 243
 244         DBG("Sending streams of channel %s to kernel consumer",
 245                         channel->channel->name);
 246
 247         ret = kernel_consumer_add_channel(sock, channel);
 248         if (ret < 0) {
 249                 goto error;
 250         }
 251
 252         /* Send streams */
 253         cds_list_for_each_entry(stream, &channel->stream_list.head, list) {
 254                 if (!stream->fd) {
 255                         continue;
 256                 }
 257
 258                 /* Add stream on the kernel consumer side. */
 259                 ret = kernel_consumer_add_stream(sock, channel, stream, session);
 260                 if (ret < 0) {
 261                         goto error;
 262                 }
 263         }
 264
 265 error:
 266         return ret;
 267 }
 268
 269 /*
 270  * Send all stream fds of the kernel session to the consumer.
 271  */
 272 int kernel_consumer_send_session(int sock, struct ltt_kernel_session *session)
 273 {
 274         int ret;
 275         struct ltt_kernel_channel *chan;
 276
 277         /* Safety net */
 278         assert(session);
 279         assert(session->consumer);
 280
 281         /* Bail out if consumer is disabled */
 282         if (!session->consumer->enabled) {
 283                 ret = LTTNG_OK;
 284                 goto error;
 285         }
 286
 287         DBG("Sending session stream to kernel consumer");
 288
 289         if (session->metadata_stream_fd >= 0) {
 290                 ret = kernel_consumer_add_metadata(sock, session);
 291                 if (ret < 0) {
 292                         goto error;
 293                 }
 294
 295                 /* Flag that at least the metadata has been sent to the consumer. */
 296                 session->consumer_fds_sent = 1;
 297         }
 298
 299         /* Send channel and streams of it */
 300         cds_list_for_each_entry(chan, &session->channel_list.head, list) {
 301                 ret = kernel_consumer_send_channel_stream(sock, chan, session);
 302                 if (ret < 0) {
 303                         goto error;
 304                 }
 305         }
 306
 307         DBG("Kernel consumer FDs of metadata and channel streams sent");
 308
 309         return 0;
 310
 311 error:
 312         return ret;
 313 }