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

/*
 * Copyright 2019 - Francis Deslauriers <francis.deslauriers@efficios.com>
 * Copyright 2016 - Philippe Proulx <pproulx@efficios.com>
 * Copyright 2010-2011 - EfficiOS Inc. and Linux Foundation
 *
 * Some functions are based on older functions written by Mathieu Desnoyers.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#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.h"
#include "../common/metadata/decoder.h"
#include "../common/metadata/ctf-meta-configure-ir-trace.h"

#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: trace-id=%"PRIu64, trace->id);

	/* No metadata stream yet. */
	if (!metadata) {
		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;
	struct ctf_metadata_decoder_config cfg = {
		.log_level = session->log_level,
		.self_comp = session->self_comp,
		.clock_class_offset_s = 0,
		.clock_class_offset_ns = 0,
		.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	/*
bb18709b	2	* Copyright 2019 - Francis Deslauriers <francis.deslauriers@efficios.com>
7cdc2bab MD	3	* Copyright 2016 - Philippe Proulx <pproulx@efficios.com>
	4	* Copyright 2010-2011 - EfficiOS Inc. and Linux Foundation
	5	*
	6	* Some functions are based on older functions written by Mathieu Desnoyers.
	7	*
	8	* Permission is hereby granted, free of charge, to any person obtaining a copy
	9	* of this software and associated documentation files (the "Software"), to deal
	10	* in the Software without restriction, including without limitation the rights
	11	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	12	* copies of the Software, and to permit persons to whom the Software is
	13	* furnished to do so, subject to the following conditions:
	14	*
	15	* The above copyright notice and this permission notice shall be included in
	16	* all copies or substantial portions of the Software.
	17	*
	18	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	19	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	20	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	21	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	22	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	23	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	24	* SOFTWARE.
	25	*/
	26
5278d5ba	27	#define BT_COMP_LOG_SELF_COMP self_comp
1c0ceb65	28	#define BT_LOG_OUTPUT_LEVEL log_level
b03487ab	29	#define BT_LOG_TAG "PLUGIN/SRC.CTF.LTTNG-LIVE/META"
3fa1b6a3	30	#include "logging/comp-logging.h"
020bc26f	31
7cdc2bab MD	32	#include <stdio.h>
	33	#include <stdint.h>
	34	#include <stdlib.h>
	35	#include <stdbool.h>
	36	#include <glib.h>
57952005	37	#include "compat/memstream.h"
71c5da58	38	#include <babeltrace2/babeltrace.h>
7cdc2bab	39
7cdc2bab MD	40	#include "metadata.h"
7cdc2bab MD	41	#include "../common/metadata/decoder.h"
cd03c43c	42	#include "../common/metadata/ctf-meta-configure-ir-trace.h"
7cdc2bab MD	43
	44	#define TSDL_MAGIC 0x75d11d57
	45
	46	struct packet_header {
	47	uint32_t magic;
	48	uint8_t uuid[16];
	49	uint32_t checksum;
	50	uint32_t content_size;
	51	uint32_t packet_size;
	52	uint8_t compression_scheme;
	53	uint8_t encryption_scheme;
	54	uint8_t checksum_scheme;
	55	uint8_t major;
	56	uint8_t minor;
	57	} __attribute__((__packed__));
	58
bb18709b	59
7cdc2bab	60	static
1c0ceb65	61	bool stream_classes_all_have_default_clock_class(bt_trace_class *tc,
5278d5ba PP	62	bt_logging_level log_level,
5278d5ba PP	63	bt_self_component *self_comp)
7cdc2bab	64	{
bb18709b FD	65	uint64_t i, sc_count;
	66	const bt_clock_class *cc = NULL;
	67	const bt_stream_class *sc;
	68	bool ret = true;
7cdc2bab	69
bb18709b FD	70	sc_count = bt_trace_class_get_stream_class_count(tc);
	71	for (i = 0; i < sc_count; i++) {
	72	sc = bt_trace_class_borrow_stream_class_by_index_const(tc, i);
7cdc2bab	73
bb18709b	74	BT_ASSERT(sc);
7cdc2bab	75
bb18709b FD	76	cc = bt_stream_class_borrow_default_clock_class_const(sc);
	77	if (!cc) {
	78	ret = false;
f6e2a9d2 FD	79	BT_COMP_LOGE_APPEND_CAUSE(self_comp,
f6e2a9d2 FD	80	"Stream class doesn't have a default clock class: "
bb18709b FD	81	"sc-id=%" PRIu64 ", sc-name=\"%s\"",
	82	bt_stream_class_get_id(sc),
	83	bt_stream_class_get_name(sc));
	84	goto end;
7cdc2bab MD	85	}
	86	}
	87
7cdc2bab	88	end:
bb18709b FD	89	return ret;
	90	}
	91	/*
	92	* Iterate over the stream classes and returns the first clock class
	93	* encountered. This is useful to create message iterator inactivity message as
	94	* we don't need a particular clock class.
	95	*/
	96	static
	97	const bt_clock_class borrow_any_clock_class(bt_trace_class tc)
	98	{
	99	uint64_t i, sc_count;
	100	const bt_clock_class *cc = NULL;
	101	const bt_stream_class *sc;
	102
	103	sc_count = bt_trace_class_get_stream_class_count(tc);
	104	for (i = 0; i < sc_count; i++) {
	105	sc = bt_trace_class_borrow_stream_class_by_index_const(tc, i);
ec4a3354	106	BT_ASSERT_DBG(sc);
bb18709b FD	107
	108	cc = bt_stream_class_borrow_default_clock_class_const(sc);
	109	if (cc) {
	110	goto end;
	111	}
	112	}
	113	end:
ec4a3354	114	BT_ASSERT_DBG(cc);
bb18709b	115	return cc;
7cdc2bab MD	116	}
	117
	118	BT_HIDDEN
bb18709b	119	enum lttng_live_iterator_status lttng_live_metadata_update(
7cdc2bab MD	120	struct lttng_live_trace *trace)
	121	{
	122	struct lttng_live_session *session = trace->session;
7cdc2bab	123	struct lttng_live_metadata *metadata = trace->metadata;
7cdc2bab MD	124	size_t size, len_read = 0;
7cdc2bab MD	125	char *metadata_buf = NULL;
f797424a	126	bool keep_receiving;
7cdc2bab MD	127	FILE *fp = NULL;
7cdc2bab MD	128	enum ctf_metadata_decoder_status decoder_status;
bb18709b FD	129	enum lttng_live_iterator_status status =
bb18709b FD	130	LTTNG_LIVE_ITERATOR_STATUS_OK;
1c0ceb65	131	bt_logging_level log_level = trace->log_level;
5278d5ba	132	bt_self_component *self_comp = trace->self_comp;
f797424a	133	enum lttng_live_get_one_metadata_status metadata_status;
7cdc2bab	134
f555be5d FD	135	BT_COMP_LOGD("Updating metadata for trace: trace-id=%"PRIu64, trace->id);
f555be5d FD	136
7cdc2bab MD	137	/* No metadata stream yet. */
	138	if (!metadata) {
	139	if (session->new_streams_needed) {
bb18709b	140	status = LTTNG_LIVE_ITERATOR_STATUS_AGAIN;
7cdc2bab MD	141	} else {
7cdc2bab MD	142	session->new_streams_needed = true;
bb18709b	143	status = LTTNG_LIVE_ITERATOR_STATUS_CONTINUE;
7cdc2bab MD	144	}
	145	goto end;
	146	}
	147
d6e1f86b	148	if (trace->metadata_stream_state != LTTNG_LIVE_METADATA_STREAM_STATE_NEEDED) {
7cdc2bab MD	149	goto end;
	150	}
	151
8dd99d00 FD	152	/*
	153	* Open a new write only file handle to populate the `metadata_buf`
	154	* memory buffer so we can write in loop in it easily.
	155	*/
7cdc2bab MD	156	fp = bt_open_memstream(&metadata_buf, &size);
7cdc2bab MD	157	if (!fp) {
403657fd FD	158	if (errno == EINTR &&
403657fd FD	159	lttng_live_graph_is_canceled(session->lttng_live_msg_iter)) {
8dd99d00	160	session->lttng_live_msg_iter->was_interrupted = true;
403657fd FD	161	status = LTTNG_LIVE_ITERATOR_STATUS_AGAIN;
	162	} else {
	163	BT_COMP_LOGE_APPEND_CAUSE_ERRNO(self_comp,
	164	"Metadata open_memstream", ".");
	165	status = LTTNG_LIVE_ITERATOR_STATUS_ERROR;
	166	}
	167	goto end;
7cdc2bab MD	168	}
7cdc2bab MD	169
f797424a	170	keep_receiving = true;
7cdc2bab	171	/* Grab all available metadata. */
f797424a FD	172	while (keep_receiving) {
f797424a FD	173	size_t reply_len = 0;
7cdc2bab	174	/*
f797424a FD	175	* lttng_live_get_one_metadata_packet() asks the Relay Daemon
	176	* for new metadata. If new metadata is received, the function
	177	* writes it to the provided file handle and updates the
	178	* reply_len output parameter. We call this function in loop
	179	* until it returns _END meaning that no new metadata is
	180	* available.
	181	* We may receive a _CLOSED status if the metadata stream we
	182	* are requesting is no longer available on the relay.
	183	* If we receive an _ERROR status, it means there was a
	184	* networking, allocating, or some other unrecoverable error.
7cdc2bab	185	*/
f797424a FD	186	metadata_status = lttng_live_get_one_metadata_packet(trace, fp,
	187	&reply_len);
	188
	189	switch (metadata_status) {
	190	case LTTNG_LIVE_GET_ONE_METADATA_STATUS_OK:
	191	len_read += reply_len;
	192	break;
	193	case LTTNG_LIVE_GET_ONE_METADATA_STATUS_END:
	194	keep_receiving = false;
	195	break;
	196	case LTTNG_LIVE_GET_ONE_METADATA_STATUS_CLOSED:
f555be5d FD	197	BT_COMP_LOGD("Metadata stream was closed by the Relay, the trace is no longer active: "
	198	"trace-id=%"PRIu64", metadata-stream-id=%"PRIu64,
	199	trace->id, metadata->stream_id);
d6e1f86b FD	200	/*
	201	* The stream was closed and we received everything
	202	* there was to receive for this metadata stream.
	203	* We go on with the decoding of what we received. So
	204	* that data stream can be decoded.
	205	*/
f797424a	206	keep_receiving = false;
d6e1f86b	207	trace->metadata_stream_state = LTTNG_LIVE_METADATA_STREAM_STATE_CLOSED;
f797424a FD	208	break;
f797424a FD	209	case LTTNG_LIVE_GET_ONE_METADATA_STATUS_ERROR:
f555be5d FD	210	BT_COMP_LOGE_APPEND_CAUSE(self_comp,
	211	"Error getting one trace metadata packet: "
	212	"trace-id=%"PRIu64, trace->id);
f797424a FD	213	goto error;
f797424a FD	214	default:
24847fc7	215	bt_common_abort();
7cdc2bab	216	}
f797424a	217	}
7cdc2bab	218
8dd99d00	219	/* The memory buffer `metadata_buf` contains all the metadata. */
7cdc2bab	220	if (bt_close_memstream(&metadata_buf, &size, fp)) {
f555be5d	221	BT_COMP_LOGW_ERRNO("Metadata bt_close_memstream", ".");
7cdc2bab	222	}
67875d75	223
7cdc2bab MD	224	fp = NULL;
	225
	226	if (len_read == 0) {
	227	if (!trace->trace) {
bb18709b	228	status = LTTNG_LIVE_ITERATOR_STATUS_AGAIN;
7cdc2bab MD	229	goto end;
7cdc2bab MD	230	}
d6e1f86b FD	231
	232	/* The relay sent zero bytes of metdata. */
	233	trace->metadata_stream_state = LTTNG_LIVE_METADATA_STREAM_STATE_NOT_NEEDED;
7cdc2bab MD	234	goto end;
	235	}
	236
8dd99d00 FD	237	/*
	238	* Open a new reading file handle on the `metadata_buf` and pass it to
	239	* the metadata decoder.
	240	*/
7cdc2bab MD	241	fp = bt_fmemopen(metadata_buf, len_read, "rb");
7cdc2bab MD	242	if (!fp) {
403657fd FD	243	if (errno == EINTR &&
403657fd FD	244	lttng_live_graph_is_canceled(session->lttng_live_msg_iter)) {
8dd99d00	245	session->lttng_live_msg_iter->was_interrupted = true;
403657fd FD	246	status = LTTNG_LIVE_ITERATOR_STATUS_AGAIN;
	247	} else {
	248	BT_COMP_LOGE_APPEND_CAUSE_ERRNO(self_comp,
	249	"Cannot memory-open metadata buffer", ".");
	250	status = LTTNG_LIVE_ITERATOR_STATUS_ERROR;
	251	}
	252	goto end;
7cdc2bab MD	253	}
7cdc2bab MD	254
bb18709b	255	/*
526c3a49 PP	256	* The call to ctf_metadata_decoder_append_content() will append
526c3a49 PP	257	* new metadata to our current trace class.
bb18709b	258	*/
f555be5d	259	BT_COMP_LOGD("Appending new metadata to the ctf_trace class");
526c3a49 PP	260	decoder_status = ctf_metadata_decoder_append_content(
526c3a49 PP	261	metadata->decoder, fp);
7cdc2bab MD	262	switch (decoder_status) {
7cdc2bab MD	263	case CTF_METADATA_DECODER_STATUS_OK:
bb18709b	264	if (!trace->trace_class) {
cd03c43c PP	265	struct ctf_trace_class *tc =
	266	ctf_metadata_decoder_borrow_ctf_trace_class(
	267	metadata->decoder);
	268
bb18709b FD	269	trace->trace_class =
	270	ctf_metadata_decoder_get_ir_trace_class(
	271	metadata->decoder);
	272	trace->trace = bt_trace_create(trace->trace_class);
cd03c43c	273	if (!trace->trace) {
f6e2a9d2 FD	274	BT_COMP_LOGE_APPEND_CAUSE(self_comp,
f6e2a9d2 FD	275	"Failed to create bt_trace");
cd03c43c PP	276	goto error;
	277	}
	278	if (ctf_trace_class_configure_ir_trace(tc,
	279	trace->trace)) {
f6e2a9d2 FD	280	BT_COMP_LOGE_APPEND_CAUSE(self_comp,
f6e2a9d2 FD	281	"Failed to configure ctf trace class");
cd03c43c PP	282	goto error;
cd03c43c PP	283	}
bb18709b	284	if (!stream_classes_all_have_default_clock_class(
5278d5ba PP	285	trace->trace_class, log_level,
5278d5ba PP	286	self_comp)) {
bb18709b FD	287	/* Error logged in function. */
	288	goto error;
	289	}
	290	trace->clock_class =
	291	borrow_any_clock_class(trace->trace_class);
7cdc2bab	292	}
d6e1f86b FD	293
	294	/* The metadata was updated succesfully. */
	295	trace->metadata_stream_state = LTTNG_LIVE_METADATA_STREAM_STATE_NOT_NEEDED;
bb18709b	296
7cdc2bab	297	break;
26aa224b	298	default:
7cdc2bab MD	299	goto error;
	300	}
	301
	302	goto end;
f797424a	303
7cdc2bab	304	error:
403657fd	305	status = LTTNG_LIVE_ITERATOR_STATUS_ERROR;
7cdc2bab MD	306	end:
	307	if (fp) {
	308	int closeret;
	309
	310	closeret = fclose(fp);
	311	if (closeret) {
f555be5d	312	BT_COMP_LOGW_ERRNO("Error on fclose", ".");
7cdc2bab MD	313	}
7cdc2bab MD	314	}
6f79a7cf	315	free(metadata_buf);
7cdc2bab MD	316	return status;
	317	}
	318
	319	BT_HIDDEN
	320	int lttng_live_metadata_create_stream(struct lttng_live_session *session,
5278d5ba	321	uint64_t ctf_trace_id, uint64_t stream_id,
06994c71	322	const char *trace_name)
7cdc2bab	323	{
f6e2a9d2 FD	324	bt_self_component *self_comp = session->self_comp;
f6e2a9d2 FD	325	bt_logging_level log_level = session->log_level;
7cdc2bab MD	326	struct lttng_live_metadata *metadata = NULL;
7cdc2bab MD	327	struct lttng_live_trace *trace;
1f1f2720	328	struct ctf_metadata_decoder_config cfg = {
1c0ceb65	329	.log_level = session->log_level,
5278d5ba	330	.self_comp = session->self_comp,
1f1f2720 PP	331	.clock_class_offset_s = 0,
1f1f2720 PP	332	.clock_class_offset_ns = 0,
526c3a49	333	.create_trace_class = true,
1f1f2720	334	};
7cdc2bab MD	335
	336	metadata = g_new0(struct lttng_live_metadata, 1);
	337	if (!metadata) {
	338	return -1;
	339	}
1c0ceb65	340	metadata->log_level = session->log_level;
5278d5ba	341	metadata->self_comp = session->self_comp;
7cdc2bab	342	metadata->stream_id = stream_id;
bb18709b	343
16699f85	344	metadata->decoder = ctf_metadata_decoder_create(&cfg);
7cdc2bab	345	if (!metadata->decoder) {
f6e2a9d2 FD	346	BT_COMP_LOGE_APPEND_CAUSE(self_comp,
f6e2a9d2 FD	347	"Failed to create CTF metadata decoder");
7cdc2bab MD	348	goto error;
7cdc2bab MD	349	}
118fe47c FD	350	trace = lttng_live_session_borrow_or_create_trace_by_id(session,
118fe47c FD	351	ctf_trace_id);
7cdc2bab	352	if (!trace) {
f6e2a9d2 FD	353	BT_COMP_LOGE_APPEND_CAUSE(self_comp,
f6e2a9d2 FD	354	"Failed to borrow trace");
7cdc2bab MD	355	goto error;
7cdc2bab MD	356	}
7cdc2bab MD	357	trace->metadata = metadata;
	358	return 0;
	359
	360	error:
	361	ctf_metadata_decoder_destroy(metadata->decoder);
	362	g_free(metadata);
	363	return -1;
	364	}
	365
	366	BT_HIDDEN
	367	void lttng_live_metadata_fini(struct lttng_live_trace *trace)
	368	{
	369	struct lttng_live_metadata *metadata = trace->metadata;
	370
	371	if (!metadata) {
	372	return;
	373	}
7cdc2bab MD	374	ctf_metadata_decoder_destroy(metadata->decoder);
7cdc2bab MD	375	trace->metadata = NULL;
7cdc2bab MD	376	g_free(metadata);
7cdc2bab MD	377	}