src/plugins/ctf/lttng-live/data-stream.cpp

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright 2019 Francis Deslauriers <francis.deslauriers@efficios.com>
   5  * Copyright 2016 Philippe Proulx <pproulx@efficios.com>
   6  * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
   8  */
   9
  10 #include <glib.h>
  11 #include <inttypes.h>
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14
  15 #include <babeltrace2/babeltrace.h>
  16
  17 #include "common/assert.h"
  18 #include "compat/mman.h" /* IWYU pragma: keep  */
  19 #include "cpp-common/vendor/fmt/format.h"
  20
  21 #include "../common/src/msg-iter/msg-iter.hpp"
  22 #include "data-stream.hpp"
  23
  24 #define STREAM_NAME_PREFIX "stream-"
  25
  26 static enum ctf_msg_iter_medium_status medop_request_bytes(size_t request_sz, uint8_t **buffer_addr,
  27                                                            size_t *buffer_sz, void *data)
  28 {
  29     enum ctf_msg_iter_medium_status status = CTF_MSG_ITER_MEDIUM_STATUS_OK;
  30     lttng_live_stream_iterator *stream = (lttng_live_stream_iterator *) data;
  31     struct lttng_live_trace *trace = stream->trace;
  32     struct lttng_live_session *session = trace->session;
  33     struct lttng_live_msg_iter *live_msg_iter = session->lttng_live_msg_iter;
  34     uint64_t recv_len = 0;
  35     uint64_t len_left;
  36     uint64_t read_len;
  37
  38     BT_ASSERT(request_sz);
  39
  40     if (stream->has_stream_hung_up) {
  41         status = CTF_MSG_ITER_MEDIUM_STATUS_EOF;
  42         goto end;
  43     }
  44
  45     len_left = stream->base_offset + stream->len - stream->offset;
  46     if (!len_left) {
  47         lttng_live_stream_iterator_set_state(stream, LTTNG_LIVE_STREAM_ACTIVE_NO_DATA);
  48         status = CTF_MSG_ITER_MEDIUM_STATUS_AGAIN;
  49         goto end;
  50     }
  51
  52     read_len = MIN(request_sz, stream->buflen);
  53     read_len = MIN(read_len, len_left);
  54     status = lttng_live_get_stream_bytes(live_msg_iter, stream, stream->buf, stream->offset,
  55                                          read_len, &recv_len);
  56     *buffer_addr = stream->buf;
  57     *buffer_sz = recv_len;
  58     stream->offset += recv_len;
  59 end:
  60     return status;
  61 }
  62
  63 static bt_stream *medop_borrow_stream(bt_stream_class *stream_class, int64_t stream_id, void *data)
  64 {
  65     lttng_live_stream_iterator *lttng_live_stream = (lttng_live_stream_iterator *) data;
  66
  67     if (!lttng_live_stream->stream) {
  68         uint64_t stream_class_id = bt_stream_class_get_id(stream_class);
  69
  70         BT_CPPLOGI_SPEC(lttng_live_stream->logger,
  71                         "Creating stream {} (ID: {}) out of stream class {}",
  72                         lttng_live_stream->name->str, stream_id, stream_class_id);
  73
  74         if (stream_id < 0) {
  75             /*
  76              * No stream instance ID in the stream. It's possible
  77              * to encounter this situation with older version of
  78              * LTTng. In these cases, use the viewer_stream_id that
  79              * is unique for a live viewer session.
  80              */
  81             lttng_live_stream->stream = bt_stream_create_with_id(
  82                 stream_class, lttng_live_stream->trace->trace, lttng_live_stream->viewer_stream_id);
  83         } else {
  84             lttng_live_stream->stream = bt_stream_create_with_id(
  85                 stream_class, lttng_live_stream->trace->trace, (uint64_t) stream_id);
  86         }
  87
  88         if (!lttng_live_stream->stream) {
  89             BT_CPPLOGE_APPEND_CAUSE_SPEC(
  90                 lttng_live_stream->logger,
  91                 "Cannot create stream {} (stream class ID {}, stream ID {})",
  92                 lttng_live_stream->name->str, stream_class_id, stream_id);
  93             goto end;
  94         }
  95
  96         bt_stream_set_name(lttng_live_stream->stream, lttng_live_stream->name->str);
  97     }
  98
  99 end:
 100     return lttng_live_stream->stream;
 101 }
 102
 103 static struct ctf_msg_iter_medium_ops medops = {
 104     medop_request_bytes,
 105     nullptr,
 106     nullptr,
 107     medop_borrow_stream,
 108 };
 109
 110 enum lttng_live_iterator_status lttng_live_lazy_msg_init(struct lttng_live_session *session,
 111                                                          bt_self_message_iterator *self_msg_iter)
 112 {
 113     struct lttng_live_component *lttng_live = session->lttng_live_msg_iter->lttng_live_comp;
 114     uint64_t trace_idx, stream_iter_idx;
 115
 116     if (!session->lazy_stream_msg_init) {
 117         return LTTNG_LIVE_ITERATOR_STATUS_OK;
 118     }
 119
 120     BT_CPPLOGD_SPEC(session->logger,
 121                     "Lazily initializing self message iterator for live session: "
 122                     "session-id={}, self-msg-iter-addr={}",
 123                     session->id, fmt::ptr(self_msg_iter));
 124
 125     for (trace_idx = 0; trace_idx < session->traces->len; trace_idx++) {
 126         struct lttng_live_trace *trace =
 127             (lttng_live_trace *) g_ptr_array_index(session->traces, trace_idx);
 128
 129         for (stream_iter_idx = 0; stream_iter_idx < trace->stream_iterators->len;
 130              stream_iter_idx++) {
 131             struct ctf_trace_class *ctf_tc;
 132             struct lttng_live_stream_iterator *stream_iter =
 133                 (lttng_live_stream_iterator *) g_ptr_array_index(trace->stream_iterators,
 134                                                                  stream_iter_idx);
 135
 136             if (stream_iter->msg_iter) {
 137                 continue;
 138             }
 139             ctf_tc = ctf_metadata_decoder_borrow_ctf_trace_class(trace->metadata->decoder.get());
 140             BT_CPPLOGD_SPEC(stream_iter->logger,
 141                             "Creating CTF message iterator: session-id={}, ctf-tc-addr={}, "
 142                             "stream-iter-name={}, self-msg-iter-addr={}",
 143                             session->id, fmt::ptr(ctf_tc), stream_iter->name->str,
 144                             fmt::ptr(self_msg_iter));
 145             stream_iter->msg_iter =
 146                 ctf_msg_iter_create(ctf_tc, lttng_live->max_query_size, medops, stream_iter,
 147                                     self_msg_iter, stream_iter->logger)
 148                     .release();
 149             if (!stream_iter->msg_iter) {
 150                 BT_CPPLOGE_APPEND_CAUSE_SPEC(stream_iter->logger,
 151                                              "Failed to create CTF message iterator");
 152                 goto error;
 153             }
 154         }
 155     }
 156
 157     session->lazy_stream_msg_init = false;
 158
 159     return LTTNG_LIVE_ITERATOR_STATUS_OK;
 160
 161 error:
 162     return LTTNG_LIVE_ITERATOR_STATUS_ERROR;
 163 }
 164
 165 struct lttng_live_stream_iterator *
 166 lttng_live_stream_iterator_create(struct lttng_live_session *session, uint64_t ctf_trace_id,
 167                                   uint64_t stream_id, bt_self_message_iterator *self_msg_iter)
 168 {
 169     lttng_live_stream_iterator *stream_iter = nullptr;
 170
 171     BT_ASSERT(session);
 172     BT_ASSERT(session->lttng_live_msg_iter);
 173     BT_ASSERT(session->lttng_live_msg_iter->lttng_live_comp);
 174
 175     lttng_live_component *lttng_live = session->lttng_live_msg_iter->lttng_live_comp;
 176     lttng_live_trace *trace =
 177         lttng_live_session_borrow_or_create_trace_by_id(session, ctf_trace_id);
 178     if (!trace) {
 179         BT_CPPLOGE_APPEND_CAUSE_SPEC(session->logger, "Failed to borrow CTF trace.");
 180         goto error;
 181     }
 182
 183     stream_iter = new lttng_live_stream_iterator {session->logger};
 184     stream_iter->trace = trace;
 185     stream_iter->state = LTTNG_LIVE_STREAM_ACTIVE_NO_DATA;
 186     stream_iter->viewer_stream_id = stream_id;
 187
 188     stream_iter->ctf_stream_class_id.is_set = false;
 189     stream_iter->ctf_stream_class_id.value = UINT64_MAX;
 190
 191     stream_iter->last_inactivity_ts.is_set = false;
 192     stream_iter->last_inactivity_ts.value = 0;
 193
 194     if (trace->trace) {
 195         struct ctf_trace_class *ctf_tc =
 196             ctf_metadata_decoder_borrow_ctf_trace_class(trace->metadata->decoder.get());
 197         BT_ASSERT(!stream_iter->msg_iter);
 198         stream_iter->msg_iter = ctf_msg_iter_create(ctf_tc, lttng_live->max_query_size, medops,
 199                                                     stream_iter, self_msg_iter, stream_iter->logger)
 200                                     .release();
 201         if (!stream_iter->msg_iter) {
 202             BT_CPPLOGE_APPEND_CAUSE_SPEC(stream_iter->logger,
 203                                          "Failed to create CTF message iterator");
 204             goto error;
 205         }
 206     }
 207     stream_iter->buf = g_new0(uint8_t, lttng_live->max_query_size);
 208     if (!stream_iter->buf) {
 209         BT_CPPLOGE_APPEND_CAUSE_SPEC(stream_iter->logger,
 210                                      "Failed to allocate live stream iterator buffer");
 211         goto error;
 212     }
 213
 214     stream_iter->buflen = lttng_live->max_query_size;
 215     stream_iter->name = g_string_new(NULL);
 216     if (!stream_iter->name) {
 217         BT_CPPLOGE_APPEND_CAUSE_SPEC(stream_iter->logger,
 218                                      "Failed to allocate live stream iterator name buffer");
 219         goto error;
 220     }
 221
 222     g_string_printf(stream_iter->name, STREAM_NAME_PREFIX "%" PRIu64,
 223                     stream_iter->viewer_stream_id);
 224     g_ptr_array_add(trace->stream_iterators, stream_iter);
 225
 226     /* Track the number of active stream iterator. */
 227     session->lttng_live_msg_iter->active_stream_iter++;
 228
 229     goto end;
 230 error:
 231     lttng_live_stream_iterator_destroy(stream_iter);
 232     stream_iter = NULL;
 233 end:
 234     return stream_iter;
 235 }
 236
 237 void lttng_live_stream_iterator_destroy(struct lttng_live_stream_iterator *stream_iter)
 238 {
 239     if (!stream_iter) {
 240         return;
 241     }
 242
 243     if (stream_iter->stream) {
 244         BT_STREAM_PUT_REF_AND_RESET(stream_iter->stream);
 245     }
 246
 247     if (stream_iter->msg_iter) {
 248         ctf_msg_iter_destroy(stream_iter->msg_iter);
 249     }
 250     g_free(stream_iter->buf);
 251     if (stream_iter->name) {
 252         g_string_free(stream_iter->name, TRUE);
 253     }
 254
 255     bt_message_put_ref(stream_iter->current_msg);
 256
 257     /* Track the number of active stream iterator. */
 258     stream_iter->trace->session->lttng_live_msg_iter->active_stream_iter--;
 259
 260     delete stream_iter;
 261 }