[babeltrace.git] / src / plugins / ctf / lttng-live / metadata.cpp

/*
 * SPDX-License-Identifier: MIT
 *
 * Copyright 2019 Francis Deslauriers <francis.deslauriers@efficios.com>
 * Copyright 2016 Philippe Proulx <pproulx@efficios.com>
 * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
 */

#define BT_COMP_LOG_SELF_COMP self_comp
#define BT_LOG_OUTPUT_LEVEL   log_level
#define BT_LOG_TAG            "PLUGIN/SRC.CTF.LTTNG-LIVE/META"
#include "logging/comp-logging.h"

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
#include <glib.h>
#include "compat/memstream.h"
#include <babeltrace2/babeltrace.h>

#include "metadata.hpp"
#include "../common/metadata/decoder.hpp"
#include "../common/metadata/ctf-meta-configure-ir-trace.hpp"

#define TSDL_MAGIC 0x75d11d57

struct packet_header
{
    uint32_t magic;
    uint8_t uuid[16];
    uint32_t checksum;
    uint32_t content_size;
    uint32_t packet_size;
    uint8_t compression_scheme;
    uint8_t encryption_scheme;
    uint8_t checksum_scheme;
    uint8_t major;
    uint8_t minor;
} __attribute__((__packed__));

static bool stream_classes_all_have_default_clock_class(bt_trace_class *tc,
                                                        bt_logging_level log_level,
                                                        bt_self_component *self_comp)
{
    uint64_t i, sc_count;
    const bt_clock_class *cc = NULL;
    const bt_stream_class *sc;
    bool ret = true;

    sc_count = bt_trace_class_get_stream_class_count(tc);
    for (i = 0; i < sc_count; i++) {
        sc = bt_trace_class_borrow_stream_class_by_index_const(tc, i);

        BT_ASSERT(sc);

        cc = bt_stream_class_borrow_default_clock_class_const(sc);
        if (!cc) {
            ret = false;
            BT_COMP_LOGE_APPEND_CAUSE(self_comp,
                                      "Stream class doesn't have a default clock class: "
                                      "sc-id=%" PRIu64 ", sc-name=\"%s\"",
                                      bt_stream_class_get_id(sc), bt_stream_class_get_name(sc));
            goto end;
        }
    }

end:
    return ret;
}
/*
 * Iterate over the stream classes and returns the first clock class
 * encountered. This is useful to create message iterator inactivity message as
 * we don't need a particular clock class.
 */
static const bt_clock_class *borrow_any_clock_class(bt_trace_class *tc)
{
    uint64_t i, sc_count;
    const bt_clock_class *cc = NULL;
    const bt_stream_class *sc;

    sc_count = bt_trace_class_get_stream_class_count(tc);
    for (i = 0; i < sc_count; i++) {
        sc = bt_trace_class_borrow_stream_class_by_index_const(tc, i);
        BT_ASSERT_DBG(sc);

        cc = bt_stream_class_borrow_default_clock_class_const(sc);
        if (cc) {
            goto end;
        }
    }
end:
    BT_ASSERT_DBG(cc);
    return cc;
}

BT_HIDDEN
enum lttng_live_iterator_status lttng_live_metadata_update(struct lttng_live_trace *trace)
{
    struct lttng_live_session *session = trace->session;
    struct lttng_live_metadata *metadata = trace->metadata;
    size_t size, len_read = 0;
    char *metadata_buf = NULL;
    bool keep_receiving;
    FILE *fp = NULL;
    enum ctf_metadata_decoder_status decoder_status;
    enum lttng_live_iterator_status status = LTTNG_LIVE_ITERATOR_STATUS_OK;
    bt_logging_level log_level = trace->log_level;
    bt_self_component *self_comp = trace->self_comp;
    enum lttng_live_get_one_metadata_status metadata_status;

    BT_COMP_LOGD("Updating metadata for trace: session-id=%" PRIu64 ", trace-id=%" PRIu64,
                 session->id, trace->id);

    /* No metadata stream yet. */
    if (!metadata) {
        if (session->closed) {
            /*
             * The session is closed AND we never received any
             * metadata this indicates that we will never receive
             * any metadata.
             */
            status = LTTNG_LIVE_ITERATOR_STATUS_END;
        } else if (session->new_streams_needed) {
            status = LTTNG_LIVE_ITERATOR_STATUS_AGAIN;
        } else {
            session->new_streams_needed = true;
            status = LTTNG_LIVE_ITERATOR_STATUS_CONTINUE;
        }
        goto end;
    }

    if (trace->metadata_stream_state != LTTNG_LIVE_METADATA_STREAM_STATE_NEEDED) {
        goto end;
    }

    /*
     * Open a new write only file handle to populate the `metadata_buf`
     * memory buffer so we can write in loop in it easily.
     */
    fp = bt_open_memstream(&metadata_buf, &size);
    if (!fp) {
        if (errno == EINTR && lttng_live_graph_is_canceled(session->lttng_live_msg_iter)) {
            session->lttng_live_msg_iter->was_interrupted = true;
            status = LTTNG_LIVE_ITERATOR_STATUS_AGAIN;
        } else {
            BT_COMP_LOGE_APPEND_CAUSE_ERRNO(self_comp, "Metadata open_memstream", ".");
            status = LTTNG_LIVE_ITERATOR_STATUS_ERROR;
        }
        goto end;
    }

    keep_receiving = true;
    /* Grab all available metadata. */
    while (keep_receiving) {
        size_t reply_len = 0;
        /*
         * lttng_live_get_one_metadata_packet() asks the Relay Daemon
         * for new metadata. If new metadata is received, the function
         * writes it to the provided file handle and updates the
         * reply_len output parameter. We call this function in loop
         * until it returns _END meaning that no new metadata is
         * available.
         * We may receive a _CLOSED status if the metadata stream we
         * are requesting is no longer available on the relay.
         * If we receive an _ERROR status, it means there was a
         * networking, allocating, or some other unrecoverable error.
         */
        metadata_status = lttng_live_get_one_metadata_packet(trace, fp, &reply_len);

        switch (metadata_status) {
        case LTTNG_LIVE_GET_ONE_METADATA_STATUS_OK:
            len_read += reply_len;
            break;
        case LTTNG_LIVE_GET_ONE_METADATA_STATUS_END:
            keep_receiving = false;
            break;
        case LTTNG_LIVE_GET_ONE_METADATA_STATUS_CLOSED:
            BT_COMP_LOGD("Metadata stream was closed by the Relay, the trace is no longer active: "
                         "trace-id=%" PRIu64 ", metadata-stream-id=%" PRIu64,
                         trace->id, metadata->stream_id);
            /*
             * The stream was closed and we received everything
             * there was to receive for this metadata stream.
             * We go on with the decoding of what we received. So
             * that data stream can be decoded.
             */
            keep_receiving = false;
            trace->metadata_stream_state = LTTNG_LIVE_METADATA_STREAM_STATE_CLOSED;
            break;
        case LTTNG_LIVE_GET_ONE_METADATA_STATUS_ERROR:
            BT_COMP_LOGE_APPEND_CAUSE(self_comp,
                                      "Error getting one trace metadata packet: "
                                      "trace-id=%" PRIu64,
                                      trace->id);
            goto error;
        default:
            bt_common_abort();
        }
    }

    /* The memory buffer `metadata_buf` contains all the metadata. */
    if (bt_close_memstream(&metadata_buf, &size, fp)) {
        BT_COMP_LOGW_ERRNO("Metadata bt_close_memstream", ".");
    }

    fp = NULL;

    if (len_read == 0) {
        if (!trace->trace) {
            status = LTTNG_LIVE_ITERATOR_STATUS_AGAIN;
            goto end;
        }

        /* The relay sent zero bytes of metdata. */
        trace->metadata_stream_state = LTTNG_LIVE_METADATA_STREAM_STATE_NOT_NEEDED;
        goto end;
    }

    /*
     * Open a new reading file handle on the `metadata_buf` and pass it to
     * the metadata decoder.
     */
    fp = bt_fmemopen(metadata_buf, len_read, "rb");
    if (!fp) {
        if (errno == EINTR && lttng_live_graph_is_canceled(session->lttng_live_msg_iter)) {
            session->lttng_live_msg_iter->was_interrupted = true;
            status = LTTNG_LIVE_ITERATOR_STATUS_AGAIN;
        } else {
            BT_COMP_LOGE_APPEND_CAUSE_ERRNO(self_comp, "Cannot memory-open metadata buffer", ".");
            status = LTTNG_LIVE_ITERATOR_STATUS_ERROR;
        }
        goto end;
    }

    /*
     * The call to ctf_metadata_decoder_append_content() will append
     * new metadata to our current trace class.
     */
    BT_COMP_LOGD("Appending new metadata to the ctf_trace class");
    decoder_status = ctf_metadata_decoder_append_content(metadata->decoder, fp);
    switch (decoder_status) {
    case CTF_METADATA_DECODER_STATUS_OK:
        if (!trace->trace_class) {
            struct ctf_trace_class *tc =
                ctf_metadata_decoder_borrow_ctf_trace_class(metadata->decoder);

            trace->trace_class = ctf_metadata_decoder_get_ir_trace_class(metadata->decoder);
            trace->trace = bt_trace_create(trace->trace_class);
            if (!trace->trace) {
                BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to create bt_trace");
                goto error;
            }
            if (ctf_trace_class_configure_ir_trace(tc, trace->trace)) {
                BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to configure ctf trace class");
                goto error;
            }
            if (!stream_classes_all_have_default_clock_class(trace->trace_class, log_level,
                                                             self_comp)) {
                /* Error logged in function. */
                goto error;
            }
            trace->clock_class = borrow_any_clock_class(trace->trace_class);
        }

        /* The metadata was updated succesfully. */
        trace->metadata_stream_state = LTTNG_LIVE_METADATA_STREAM_STATE_NOT_NEEDED;

        break;
    default:
        goto error;
    }

    goto end;

error:
    status = LTTNG_LIVE_ITERATOR_STATUS_ERROR;
end:
    if (fp) {
        int closeret;

        closeret = fclose(fp);
        if (closeret) {
            BT_COMP_LOGW_ERRNO("Error on fclose", ".");
        }
    }
    free(metadata_buf);
    return status;
}

BT_HIDDEN
int lttng_live_metadata_create_stream(struct lttng_live_session *session, uint64_t ctf_trace_id,
                                      uint64_t stream_id, const char *trace_name)
{
    bt_self_component *self_comp = session->self_comp;
    bt_logging_level log_level = session->log_level;
    struct lttng_live_metadata *metadata = NULL;
    struct lttng_live_trace *trace;

    ctf_metadata_decoder_config cfg {};
    cfg.log_level = session->log_level;
    cfg.self_comp = session->self_comp;
    cfg.clock_class_offset_s = 0;
    cfg.clock_class_offset_ns = 0;
    cfg.create_trace_class = true;

    metadata = g_new0(struct lttng_live_metadata, 1);
    if (!metadata) {
        return -1;
    }
    metadata->log_level = session->log_level;
    metadata->self_comp = session->self_comp;
    metadata->stream_id = stream_id;

    metadata->decoder = ctf_metadata_decoder_create(&cfg);
    if (!metadata->decoder) {
        BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to create CTF metadata decoder");
        goto error;
    }
    trace = lttng_live_session_borrow_or_create_trace_by_id(session, ctf_trace_id);
    if (!trace) {
        BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to borrow trace");
        goto error;
    }
    trace->metadata = metadata;
    return 0;

error:
    ctf_metadata_decoder_destroy(metadata->decoder);
    g_free(metadata);
    return -1;
}

BT_HIDDEN
void lttng_live_metadata_fini(struct lttng_live_trace *trace)
{
    struct lttng_live_metadata *metadata = trace->metadata;

    if (!metadata) {
        return;
    }
    ctf_metadata_decoder_destroy(metadata->decoder);
    trace->metadata = NULL;
    g_free(metadata);
}
Commit	Line	Data
7cdc2bab	1	/*
0235b0db	2	* SPDX-License-Identifier: MIT
7cdc2bab	3	*
0235b0db MJ	4	* Copyright 2019 Francis Deslauriers <francis.deslauriers@efficios.com>
	5	* Copyright 2016 Philippe Proulx <pproulx@efficios.com>
	6	* Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
7cdc2bab MD	7	*/
7cdc2bab MD	8
2ece7dd0	9	#define BT_COMP_LOG_SELF_COMP self_comp
4164020e SM	10	#define BT_LOG_OUTPUT_LEVEL log_level
4164020e SM	11	#define BT_LOG_TAG "PLUGIN/SRC.CTF.LTTNG-LIVE/META"
d9c39b0a	12	#include "logging/comp-logging.h"
020bc26f	13
7cdc2bab MD	14	#include <stdio.h>
	15	#include <stdint.h>
	16	#include <stdlib.h>
	17	#include <stdbool.h>
	18	#include <glib.h>
578e048b	19	#include "compat/memstream.h"
3fadfbc0	20	#include <babeltrace2/babeltrace.h>
7cdc2bab	21
087cd0f5 SM	22	#include "metadata.hpp"
	23	#include "../common/metadata/decoder.hpp"
	24	#include "../common/metadata/ctf-meta-configure-ir-trace.hpp"
7cdc2bab	25
4164020e	26	#define TSDL_MAGIC 0x75d11d57
7cdc2bab	27
4164020e SM	28	struct packet_header
	29	{
	30	uint32_t magic;
	31	uint8_t uuid[16];
	32	uint32_t checksum;
	33	uint32_t content_size;
	34	uint32_t packet_size;
	35	uint8_t compression_scheme;
	36	uint8_t encryption_scheme;
	37	uint8_t checksum_scheme;
	38	uint8_t major;
	39	uint8_t minor;
	40	} __attribute__((__packed__));
14f28187	41
4164020e SM	42	static bool stream_classes_all_have_default_clock_class(bt_trace_class *tc,
	43	bt_logging_level log_level,
	44	bt_self_component *self_comp)
7cdc2bab	45	{
4164020e SM	46	uint64_t i, sc_count;
	47	const bt_clock_class *cc = NULL;
	48	const bt_stream_class *sc;
	49	bool ret = true;
	50
	51	sc_count = bt_trace_class_get_stream_class_count(tc);
	52	for (i = 0; i < sc_count; i++) {
	53	sc = bt_trace_class_borrow_stream_class_by_index_const(tc, i);
	54
	55	BT_ASSERT(sc);
	56
	57	cc = bt_stream_class_borrow_default_clock_class_const(sc);
	58	if (!cc) {
	59	ret = false;
	60	BT_COMP_LOGE_APPEND_CAUSE(self_comp,
	61	"Stream class doesn't have a default clock class: "
	62	"sc-id=%" PRIu64 ", sc-name=\"%s\"",
	63	bt_stream_class_get_id(sc), bt_stream_class_get_name(sc));
	64	goto end;
	65	}
	66	}
7cdc2bab	67
7cdc2bab	68	end:
4164020e	69	return ret;
14f28187 FD	70	}
	71	/*
	72	* Iterate over the stream classes and returns the first clock class
	73	* encountered. This is useful to create message iterator inactivity message as
	74	* we don't need a particular clock class.
	75	*/
4164020e	76	static const bt_clock_class borrow_any_clock_class(bt_trace_class tc)
14f28187	77	{
4164020e SM	78	uint64_t i, sc_count;
	79	const bt_clock_class *cc = NULL;
	80	const bt_stream_class *sc;
	81
	82	sc_count = bt_trace_class_get_stream_class_count(tc);
	83	for (i = 0; i < sc_count; i++) {
	84	sc = bt_trace_class_borrow_stream_class_by_index_const(tc, i);
	85	BT_ASSERT_DBG(sc);
	86
	87	cc = bt_stream_class_borrow_default_clock_class_const(sc);
	88	if (cc) {
	89	goto end;
	90	}
	91	}
14f28187	92	end:
4164020e SM	93	BT_ASSERT_DBG(cc);
4164020e SM	94	return cc;
7cdc2bab MD	95	}
	96
	97	BT_HIDDEN
4164020e	98	enum lttng_live_iterator_status lttng_live_metadata_update(struct lttng_live_trace *trace)
7cdc2bab	99	{
4164020e SM	100	struct lttng_live_session *session = trace->session;
	101	struct lttng_live_metadata *metadata = trace->metadata;
	102	size_t size, len_read = 0;
	103	char *metadata_buf = NULL;
	104	bool keep_receiving;
	105	FILE *fp = NULL;
	106	enum ctf_metadata_decoder_status decoder_status;
	107	enum lttng_live_iterator_status status = LTTNG_LIVE_ITERATOR_STATUS_OK;
	108	bt_logging_level log_level = trace->log_level;
	109	bt_self_component *self_comp = trace->self_comp;
	110	enum lttng_live_get_one_metadata_status metadata_status;
	111
	112	BT_COMP_LOGD("Updating metadata for trace: session-id=%" PRIu64 ", trace-id=%" PRIu64,
	113	session->id, trace->id);
	114
	115	/* No metadata stream yet. */
	116	if (!metadata) {
86080481 FD	117	if (session->closed) {
	118	/*
	119	* The session is closed AND we never received any
	120	* metadata this indicates that we will never receive
	121	* any metadata.
	122	*/
	123	status = LTTNG_LIVE_ITERATOR_STATUS_END;
	124	} else if (session->new_streams_needed) {
4164020e SM	125	status = LTTNG_LIVE_ITERATOR_STATUS_AGAIN;
	126	} else {
	127	session->new_streams_needed = true;
	128	status = LTTNG_LIVE_ITERATOR_STATUS_CONTINUE;
	129	}
	130	goto end;
	131	}
	132
	133	if (trace->metadata_stream_state != LTTNG_LIVE_METADATA_STREAM_STATE_NEEDED) {
	134	goto end;
	135	}
	136
	137	/*
	138	* Open a new write only file handle to populate the `metadata_buf`
	139	* memory buffer so we can write in loop in it easily.
	140	*/
	141	fp = bt_open_memstream(&metadata_buf, &size);
	142	if (!fp) {
	143	if (errno == EINTR && lttng_live_graph_is_canceled(session->lttng_live_msg_iter)) {
	144	session->lttng_live_msg_iter->was_interrupted = true;
	145	status = LTTNG_LIVE_ITERATOR_STATUS_AGAIN;
	146	} else {
	147	BT_COMP_LOGE_APPEND_CAUSE_ERRNO(self_comp, "Metadata open_memstream", ".");
	148	status = LTTNG_LIVE_ITERATOR_STATUS_ERROR;
	149	}
	150	goto end;
	151	}
	152
	153	keep_receiving = true;
	154	/* Grab all available metadata. */
	155	while (keep_receiving) {
	156	size_t reply_len = 0;
	157	/*
	158	* lttng_live_get_one_metadata_packet() asks the Relay Daemon
	159	* for new metadata. If new metadata is received, the function
	160	* writes it to the provided file handle and updates the
	161	* reply_len output parameter. We call this function in loop
	162	* until it returns _END meaning that no new metadata is
	163	* available.
	164	* We may receive a _CLOSED status if the metadata stream we
	165	* are requesting is no longer available on the relay.
	166	* If we receive an _ERROR status, it means there was a
	167	* networking, allocating, or some other unrecoverable error.
	168	*/
	169	metadata_status = lttng_live_get_one_metadata_packet(trace, fp, &reply_len);
	170
	171	switch (metadata_status) {
	172	case LTTNG_LIVE_GET_ONE_METADATA_STATUS_OK:
	173	len_read += reply_len;
	174	break;
	175	case LTTNG_LIVE_GET_ONE_METADATA_STATUS_END:
	176	keep_receiving = false;
	177	break;
	178	case LTTNG_LIVE_GET_ONE_METADATA_STATUS_CLOSED:
	179	BT_COMP_LOGD("Metadata stream was closed by the Relay, the trace is no longer active: "
	180	"trace-id=%" PRIu64 ", metadata-stream-id=%" PRIu64,
	181	trace->id, metadata->stream_id);
	182	/*
	183	* The stream was closed and we received everything
	184	* there was to receive for this metadata stream.
	185	* We go on with the decoding of what we received. So
	186	* that data stream can be decoded.
	187	*/
	188	keep_receiving = false;
189	trace->metadata_stream_state = LTTNG_LIVE_METADATA_STREAM_STATE_CLOSED;
190	break;
191	case LTTNG_LIVE_GET_ONE_METADATA_STATUS_ERROR:
192	BT_COMP_LOGE_APPEND_CAUSE(self_comp,
193	"Error getting one trace metadata packet: "
194	"trace-id=%" PRIu64,
195	trace->id);
196	goto error;
197	default:
198	bt_common_abort();
199	}
200	}
201
202	/* The memory buffer `metadata_buf` contains all the metadata. */
203	if (bt_close_memstream(&metadata_buf, &size, fp)) {
204	BT_COMP_LOGW_ERRNO("Metadata bt_close_memstream", ".");
205	}
206
207	fp = NULL;
208
209	if (len_read == 0) {
210	if (!trace->trace) {
211	status = LTTNG_LIVE_ITERATOR_STATUS_AGAIN;
212	goto end;
213	}
214
215	/* The relay sent zero bytes of metdata. */
216	trace->metadata_stream_state = LTTNG_LIVE_METADATA_STREAM_STATE_NOT_NEEDED;
217	goto end;
218	}
219
220	/*
221	* Open a new reading file handle on the `metadata_buf` and pass it to
222	* the metadata decoder.
223	*/
224	fp = bt_fmemopen(metadata_buf, len_read, "rb");
225	if (!fp) {
226	if (errno == EINTR && lttng_live_graph_is_canceled(session->lttng_live_msg_iter)) {
227	session->lttng_live_msg_iter->was_interrupted = true;
228	status = LTTNG_LIVE_ITERATOR_STATUS_AGAIN;
229	} else {
230	BT_COMP_LOGE_APPEND_CAUSE_ERRNO(self_comp, "Cannot memory-open metadata buffer", ".");
231	status = LTTNG_LIVE_ITERATOR_STATUS_ERROR;
232	}
233	goto end;
234	}
235
236	/*
237	* The call to ctf_metadata_decoder_append_content() will append
238	* new metadata to our current trace class.
239	*/
240	BT_COMP_LOGD("Appending new metadata to the ctf_trace class");
241	decoder_status = ctf_metadata_decoder_append_content(metadata->decoder, fp);
242	switch (decoder_status) {
243	case CTF_METADATA_DECODER_STATUS_OK:
244	if (!trace->trace_class) {
245	struct ctf_trace_class *tc =
246	ctf_metadata_decoder_borrow_ctf_trace_class(metadata->decoder);
247
248	trace->trace_class = ctf_metadata_decoder_get_ir_trace_class(metadata->decoder);
249	trace->trace = bt_trace_create(trace->trace_class);
250	if (!trace->trace) {
251	BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to create bt_trace");
252	goto error;
253	}
254	if (ctf_trace_class_configure_ir_trace(tc, trace->trace)) {
255	BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to configure ctf trace class");
256	goto error;
257	}
258	if (!stream_classes_all_have_default_clock_class(trace->trace_class, log_level,
259	self_comp)) {
260	/* Error logged in function. */
261	goto error;
262	}
263	trace->clock_class = borrow_any_clock_class(trace->trace_class);
264	}
265
266	/* The metadata was updated succesfully. */
267	trace->metadata_stream_state = LTTNG_LIVE_METADATA_STREAM_STATE_NOT_NEEDED;
268
269	break;
270	default:
271	goto error;
272	}
273
274	goto end;
c28512ab	275
7cdc2bab	276	error:
4164020e	277	status = LTTNG_LIVE_ITERATOR_STATUS_ERROR;
7cdc2bab	278	end:
4164020e SM	279	if (fp) {
	280	int closeret;
	281
	282	closeret = fclose(fp);
	283	if (closeret) {
	284	BT_COMP_LOGW_ERRNO("Error on fclose", ".");
	285	}
	286	}
	287	free(metadata_buf);
	288	return status;
7cdc2bab MD	289	}
	290
	291	BT_HIDDEN
4164020e SM	292	int lttng_live_metadata_create_stream(struct lttng_live_session *session, uint64_t ctf_trace_id,
4164020e SM	293	uint64_t stream_id, const char *trace_name)
7cdc2bab	294	{
4164020e SM	295	bt_self_component *self_comp = session->self_comp;
	296	bt_logging_level log_level = session->log_level;
	297	struct lttng_live_metadata *metadata = NULL;
	298	struct lttng_live_trace *trace;
	299
	300	ctf_metadata_decoder_config cfg {};
	301	cfg.log_level = session->log_level;
	302	cfg.self_comp = session->self_comp;
	303	cfg.clock_class_offset_s = 0;
	304	cfg.clock_class_offset_ns = 0;
	305	cfg.create_trace_class = true;
	306
	307	metadata = g_new0(struct lttng_live_metadata, 1);
	308	if (!metadata) {
	309	return -1;
	310	}
	311	metadata->log_level = session->log_level;
	312	metadata->self_comp = session->self_comp;
	313	metadata->stream_id = stream_id;
	314
	315	metadata->decoder = ctf_metadata_decoder_create(&cfg);
	316	if (!metadata->decoder) {
	317	BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to create CTF metadata decoder");
	318	goto error;
	319	}
	320	trace = lttng_live_session_borrow_or_create_trace_by_id(session, ctf_trace_id);
	321	if (!trace) {
	322	BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Failed to borrow trace");
	323	goto error;
	324	}
	325	trace->metadata = metadata;
	326	return 0;
7cdc2bab MD	327
7cdc2bab MD	328	error:
4164020e SM	329	ctf_metadata_decoder_destroy(metadata->decoder);
	330	g_free(metadata);
	331	return -1;
7cdc2bab MD	332	}
	333
	334	BT_HIDDEN
	335	void lttng_live_metadata_fini(struct lttng_live_trace *trace)
	336	{
4164020e SM	337	struct lttng_live_metadata *metadata = trace->metadata;
	338
	339	if (!metadata) {
	340	return;
	341	}
	342	ctf_metadata_decoder_destroy(metadata->decoder);
	343	trace->metadata = NULL;
	344	g_free(metadata);
7cdc2bab	345	}