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