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