[lttng-tools.git] / src / bin / lttng-sessiond / ust-registry-channel.cpp

/*
 * Copyright (C) 2022 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 */

#include "ust-registry-channel.hpp"
#include "ust-app.hpp"
#include "ust-registry-event.hpp"

#include <common/error.hpp>
#include <common/exception.hpp>
#include <common/hashtable/utils.hpp>
#include <common/make-unique-wrapper.hpp>
#include <common/make-unique.hpp>
#include <common/urcu.hpp>

namespace lst = lttng::sessiond::trace;
namespace lsu = lttng::sessiond::ust;

namespace {
bool is_max_event_id(uint32_t id)
{
	return id == UINT32_MAX;
}

unsigned long ht_hash_event(const void *_key, unsigned long seed)
{
	uint64_t hashed_key;
	const lttng::sessiond::ust::registry_event *key =
			(lttng::sessiond::ust::registry_event *) _key;

	LTTNG_ASSERT(key);

	hashed_key = (uint64_t) hash_key_str(key->name.c_str(), seed);

	return hash_key_u64(&hashed_key, seed);
}

/*
 * Hash table match function for event in the registry.
 */
int ht_match_event(struct cds_lfht_node *node, const void *_key)
{
	const lttng::sessiond::ust::registry_event *key;
	lttng::sessiond::ust::registry_event *event;

	LTTNG_ASSERT(node);
	LTTNG_ASSERT(_key);

	event = lttng::utils::container_of(node, &lttng::sessiond::ust::registry_event::_node);
	key = (lttng::sessiond::ust::registry_event *) _key;

	/* It has to be a perfect match. First, compare the event names. */
	if (event->name != key->name) {
		goto no_match;
	}

	/* Compare log levels. */
	if (event->log_level != key->log_level) {
		goto no_match;
	}

	/* Compare the arrays of fields. */
	if (*event->payload != *key->payload) {
		goto no_match;
	}

	/* Compare model URI. */
	if (event->model_emf_uri != key->model_emf_uri) {
		goto no_match;
	}

	/* Match */
	return 1;

no_match:
	return 0;
}

lst::type::cuptr create_event_header(const lst::abi& trace_abi, lst::stream_class::header_type header_type)
{
	lst::structure_type::fields event_header_fields;

	if (header_type == lst::stream_class::header_type::COMPACT) {
		auto enum_mappings = std::make_shared<lst::unsigned_enumeration_type::mappings>();
		lst::unsigned_enumeration_type::mapping compact_mapping{
				"compact", lst::unsigned_enumeration_type::mapping::range_t(0, 30)};
		lst::unsigned_enumeration_type::mapping extended_mapping{"extended"};

		enum_mappings->emplace_back(compact_mapping);
		enum_mappings->emplace_back(extended_mapping);

		lst::type::cuptr choice_enum = lttng::make_unique<lst::unsigned_enumeration_type>(1,
				trace_abi.byte_order, 5, lst::integer_type::base::DECIMAL,
				std::move(enum_mappings),
				std::initializer_list<lst::integer_type::role>(
						{lst::integer_type::role::EVENT_RECORD_CLASS_ID}));

		lst::variant_type<lst::unsigned_enumeration_type::mapping::range_t::range_integer_t>::
				choices variant_choices;

		lst::structure_type::fields compact_fields;
		compact_fields.emplace_back(lttng::make_unique<lst::field>("timestamp",
				lttng::make_unique<lst::integer_type>(1, trace_abi.byte_order, 27,
						lst::integer_type::signedness::UNSIGNED,
						lst::integer_type::base::DECIMAL,
						std::initializer_list<lst::integer_type::
										role>({lst::integer_type::role::
										DEFAULT_CLOCK_TIMESTAMP}))));

		auto compact_type = lttng::make_unique<lst::structure_type>(
				0, std::move(compact_fields));
		variant_choices.emplace_back(std::move(compact_mapping), std::move(compact_type));

		lst::structure_type::fields extended_fields;
		extended_fields.emplace_back(lttng::make_unique<lst::field>("id",
				lttng::make_unique<lst::integer_type>(trace_abi.uint32_t_alignment,
						trace_abi.byte_order, 32,
						lst::integer_type::signedness::UNSIGNED,
						lst::integer_type::base::DECIMAL,
						std::initializer_list<lst::integer_type::
										role>({lst::integer_type::role::
										EVENT_RECORD_CLASS_ID}))));
		extended_fields.emplace_back(lttng::make_unique<lst::field>("timestamp",
				lttng::make_unique<lst::integer_type>(trace_abi.uint64_t_alignment,
						trace_abi.byte_order, 64,
						lst::integer_type::signedness::UNSIGNED,
						lst::integer_type::base::DECIMAL,
						std::initializer_list<lst::integer_type::
										role>({lst::integer_type::role::
										DEFAULT_CLOCK_TIMESTAMP}))));

		lst::type::cuptr extended_type = lttng::make_unique<lst::structure_type>(0, std::move(extended_fields));
		variant_choices.emplace_back(std::move(extended_mapping), std::move(extended_type));

		auto variant = lttng::make_unique<lst::variant_type<
				lst::unsigned_enumeration_type::mapping::range_t::range_integer_t>>(
				0,
				lst::field_location(lst::field_location::root::EVENT_RECORD_HEADER,
						{"id"}),
				std::move(variant_choices));

		event_header_fields.emplace_back(lttng::make_unique<lst::field>("id", std::move(choice_enum)));
		event_header_fields.emplace_back(
				lttng::make_unique<lst::field>("v", std::move(variant)));
	} else {
		auto enum_mappings = std::make_shared<lst::unsigned_enumeration_type::mappings>();
		lst::unsigned_enumeration_type::mapping compact_mapping{"compact",
				lst::unsigned_enumeration_type::mapping::range_t(0, 65534)};
		lst::unsigned_enumeration_type::mapping extended_mapping{"extended"};
		enum_mappings->emplace_back(compact_mapping);
		enum_mappings->emplace_back(extended_mapping);

		auto choice_enum = lttng::make_unique<lst::unsigned_enumeration_type>(
				trace_abi.uint16_t_alignment, trace_abi.byte_order, 16,
				lst::integer_type::base::DECIMAL, std::move(enum_mappings),
				std::initializer_list<lst::integer_type::role>(
						{lst::integer_type::role::EVENT_RECORD_CLASS_ID}));

		lst::variant_type<lst::unsigned_enumeration_type::mapping::range_t::range_integer_t>::
				choices variant_choices;

		lst::structure_type::fields compact_fields;
		compact_fields.emplace_back(lttng::make_unique<lst::field>("timestamp",
				lttng::make_unique<lst::integer_type>(trace_abi.uint32_t_alignment,
						trace_abi.byte_order, 32,
						lst::integer_type::signedness::UNSIGNED,
						lst::integer_type::base::DECIMAL,
						std::initializer_list<lst::integer_type::
										role>({lst::integer_type::role::
										DEFAULT_CLOCK_TIMESTAMP}))));

		lst::type::cuptr compact_type = lttng::make_unique<lst::structure_type>(
				0, std::move(compact_fields));
		variant_choices.emplace_back(std::move(compact_mapping), std::move(compact_type));

		lst::structure_type::fields extended_fields;
		extended_fields.emplace_back(lttng::make_unique<lst::field>("id",
				lttng::make_unique<lst::integer_type>(trace_abi.uint32_t_alignment,
						trace_abi.byte_order, 32,
						lst::integer_type::signedness::UNSIGNED,
						lst::integer_type::base::DECIMAL,
						std::initializer_list<lst::integer_type::
										role>({lst::integer_type::role::
										EVENT_RECORD_CLASS_ID}))));
		extended_fields.emplace_back(lttng::make_unique<lst::field>("timestamp",
				lttng::make_unique<lst::integer_type>(trace_abi.uint64_t_alignment,
						trace_abi.byte_order, 64,
						lst::integer_type::signedness::UNSIGNED,
						lst::integer_type::base::DECIMAL,
						std::initializer_list<lst::integer_type::
										role>({lst::integer_type::role::
										DEFAULT_CLOCK_TIMESTAMP}))));

		auto extended_type = lttng::make_unique<lst::structure_type>(
				0, std::move(extended_fields));
		variant_choices.emplace_back(std::move(extended_mapping), std::move(extended_type));

		auto variant = lttng::make_unique<lst::variant_type<
				lst::unsigned_enumeration_type::mapping::range_t::range_integer_t>>(
				0,
				lst::field_location(lst::field_location::root::EVENT_RECORD_HEADER,
						{"id"}),
				std::move(variant_choices));

		event_header_fields.emplace_back(
				lttng::make_unique<lst::field>("id", std::move(choice_enum)));
		event_header_fields.emplace_back(
				lttng::make_unique<lst::field>("v", std::move(variant)));
	}

	return lttng::make_unique<lst::structure_type>(0, std::move(event_header_fields));
}

lst::type::cuptr create_packet_context(const lst::abi& trace_abi)
{
	lst::structure_type::fields packet_context_fields;

	/* uint64_t timestamp_begin */
	packet_context_fields.emplace_back(lttng::make_unique<lst::field>("timestamp_begin",
			lttng::make_unique<lst::integer_type>(trace_abi.uint64_t_alignment,
					trace_abi.byte_order, 64,
					lst::integer_type::signedness::UNSIGNED,
					lst::integer_type::base::DECIMAL,
					std::initializer_list<lst::integer_type::role>({lst::integer_type::role::DEFAULT_CLOCK_TIMESTAMP}))));

	/* uint64_t timestamp_end */
	packet_context_fields.emplace_back(lttng::make_unique<lst::field>("timestamp_end",
			lttng::make_unique<lst::integer_type>(trace_abi.uint64_t_alignment,
					trace_abi.byte_order, 64,
					lst::integer_type::signedness::UNSIGNED,
					lst::integer_type::base::DECIMAL,
					std::initializer_list<lst::integer_type::role>({lst::integer_type::role::PACKET_END_DEFAULT_CLOCK_TIMESTAMP}))));

	/* uint64_t content_size */
	packet_context_fields.emplace_back(lttng::make_unique<lst::field>("content_size",
			lttng::make_unique<lst::integer_type>(trace_abi.uint64_t_alignment,
					trace_abi.byte_order, 64,
					lst::integer_type::signedness::UNSIGNED,
					lst::integer_type::base::DECIMAL,
					std::initializer_list<lst::integer_type::role>({lst::integer_type::role::PACKET_CONTENT_LENGTH}))));

	/* uint64_t packet_size */
	packet_context_fields.emplace_back(lttng::make_unique<lst::field>("packet_size",
			lttng::make_unique<lst::integer_type>(trace_abi.uint64_t_alignment,
					trace_abi.byte_order, 64,
					lst::integer_type::signedness::UNSIGNED,
					lst::integer_type::base::DECIMAL,
					std::initializer_list<lst::integer_type::role>({lst::integer_type::role::PACKET_TOTAL_LENGTH}))));

	/* uint64_t packet_seq_num */
	packet_context_fields.emplace_back(lttng::make_unique<lst::field>("packet_seq_num",
			lttng::make_unique<lst::integer_type>(trace_abi.uint64_t_alignment,
					trace_abi.byte_order, 64,
					lst::integer_type::signedness::UNSIGNED,
					lst::integer_type::base::DECIMAL,
					std::initializer_list<lst::integer_type::role>({lst::integer_type::role::PACKET_SEQUENCE_NUMBER}))));

	/* unsigned long events_discarded */
	packet_context_fields.emplace_back(lttng::make_unique<lst::field>("events_discarded",
			lttng::make_unique<lst::integer_type>(trace_abi.long_alignment,
					trace_abi.byte_order, trace_abi.bits_per_long,
					lst::integer_type::signedness::UNSIGNED,
					lst::integer_type::base::DECIMAL,
					std::initializer_list<lst::integer_type::role>({lst::integer_type::role::DISCARDED_EVENT_RECORD_COUNTER_SNAPSHOT}))));

	/* uint32_t cpu_id */
	packet_context_fields.emplace_back(lttng::make_unique<lst::field>("cpu_id",
			lttng::make_unique<lst::integer_type>(trace_abi.uint32_t_alignment,
					trace_abi.byte_order, 32,
					lst::integer_type::signedness::UNSIGNED,
					lst::integer_type::base::DECIMAL)));

	return lttng::make_unique<lst::structure_type>(0, std::move(packet_context_fields));
}
}; /* namespace */

lsu::registry_channel::registry_channel(unsigned int channel_id,
		const lst::abi& trace_abi,
		std::string in_default_clock_class_name,
		lsu::registry_channel::registered_listener_fn channel_registered_listener,
		lsu::registry_channel::event_added_listener_fn event_added_listener) :
	lst::stream_class(channel_id,
			lst::stream_class::header_type::LARGE,
			std::move(in_default_clock_class_name)),
	_key{-1ULL},
	_consumer_key{-1ULL},
	_next_event_id{0},
	_is_registered_listener{channel_registered_listener},
	_event_added_listener{event_added_listener},
	_is_registered{false}
{
	_events = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
	if (!_events) {
		LTTNG_THROW_POSIX("Failed to allocate urcu events hash table", ENOMEM);
	}

	/* Set custom match function. */
	_events->match_fct = ht_match_event;
	_events->hash_fct = ht_hash_event;

	_rcu_head = {};
	/*
	 * Node's key is initialized by the channel's parent session. Its value is irrelevant to the
	 * channel object itself.
	 */
	_node = {};

	_packet_context = create_packet_context(trace_abi);
	_event_header = create_event_header(trace_abi, header_type_);
}

void lsu::registry_channel::add_event(
		int session_objd,
		int channel_objd,
		std::string name,
		std::string signature,
		std::vector<lst::field::cuptr> event_fields,
		int loglevel_value,
		nonstd::optional<std::string> model_emf_uri,
		lttng_buffer_type buffer_type,
		const ust_app& app,
		uint32_t& out_event_id)
{
	uint32_t event_id;
	struct cds_lfht_node *nptr;
	lttng::urcu::read_lock_guard read_lock_guard;

	/*
	 * This should not happen but since it comes from the UST tracer, an
	 * external party, don't assert and simply validate values.
	 */
	if (session_objd < 0) {
		LTTNG_THROW_INVALID_ARGUMENT_ERROR(fmt::format(
				"Invalid session object descriptor provided by application: session descriptor = {}, app = {}",
				session_objd, app));
	}

	if (channel_objd < 0) {
		LTTNG_THROW_INVALID_ARGUMENT_ERROR(fmt::format(
				"Invalid channel object descriptor provided by application: channel descriptor = {}, app = {}",
				channel_objd, app));
	}

	/* Check if we've reached the maximum possible id. */
	if (is_max_event_id(_next_event_id)) {
		LTTNG_THROW_ERROR(fmt::format(
				"Failed to allocate new event id (id would overflow): app = {}",
				app));
	}

	auto event = lttng::make_unique_wrapper<lsu::registry_event, registry_event_destroy>(
			new lsu::registry_event(_next_event_id, id, session_objd, channel_objd,
					std::move(name), std::move(signature),
					std::move(event_fields), loglevel_value,
					std::move(model_emf_uri)));

	DBG3("%s", fmt::format("UST registry creating event: event = {}", *event).c_str());

	/*
	 * This is an add unique with a custom match function for event. The node
	 * are matched using the event name and signature.
	 */
	nptr = cds_lfht_add_unique(_events->ht, _events->hash_fct(event.get(), lttng_ht_seed),
			_events->match_fct, event.get(), &event->_node);
	if (nptr != &event->_node) {
		if (buffer_type == LTTNG_BUFFER_PER_UID) {
			/*
			 * This is normal, we just have to send the event id of the
			 * returned node.
			 */
			const auto existing_event = lttng::utils::container_of(
					nptr, &lttng::sessiond::ust::registry_event::_node);
			event_id = existing_event->id;
		} else {
			LTTNG_THROW_INVALID_ARGUMENT_ERROR(fmt::format(
					"UST registry create event add unique failed for event: event = {}",
					*event));
		}
	} else {
		const auto& event_ref = *event;

		/* Ownership transferred to _events hash table. */
		event.release();

		/* Request next event id if the node was successfully added. */
		event_id = event_ref.id;

		/*
		 * Only increment the next id here since we don't want to waste an ID when the event
		 * matches an existing one.
		 */
		_next_event_id++;
		_event_added_listener(*this, event_ref);
	}

	out_event_id = event_id;
}

lsu::registry_channel::~registry_channel()
{
	lttng_ht_destroy(_events);
}

const lttng::sessiond::trace::type* lsu::registry_channel::get_event_context() const
{
	LTTNG_ASSERT(_is_registered);
	return lst::stream_class::get_event_context();
}

void lsu::registry_channel::set_event_context(lttng::sessiond::trace::type::cuptr context)
{
	/* Must only be set once, on the first channel registration provided by an application. */
	LTTNG_ASSERT(!_event_context);
	_event_context = std::move(context);
}

bool lsu::registry_channel::is_registered() const
{
	return _is_registered;
}

void lsu::registry_channel::set_as_registered()
{
	if (!_is_registered) {
		_is_registered = true;
		_is_registered_listener(*this);
	}
}

void lsu::registry_channel::_accept_on_event_classes(
		lttng::sessiond::trace::trace_class_visitor& visitor) const
{
	std::vector<const lttng::sessiond::ust::registry_event *> sorted_event_classes;

	{
		lttng::urcu::read_lock_guard read_lock_guard;
		struct lttng_ht_iter iter;
		const lttng::sessiond::ust::registry_event *event;

		DIAGNOSTIC_PUSH
		DIAGNOSTIC_IGNORE_INVALID_OFFSETOF
		cds_lfht_for_each_entry(_events->ht, &iter.iter, event, _node) {
			sorted_event_classes.emplace_back(event);
		}
		DIAGNOSTIC_POP
	}

	std::sort(sorted_event_classes.begin(), sorted_event_classes.end(),
			[](const lttng::sessiond::ust::registry_event *a,
					const lttng::sessiond::ust::registry_event *b) {
				return a->id < b->id;
			});

	for (const auto event : sorted_event_classes) {
		event->accept(visitor);
	}
}
Commit	Line	Data
d7bfb9b0 JG	1	/*
	2	* Copyright (C) 2022 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	3	*
	4	* SPDX-License-Identifier: GPL-2.0-only
	5	*
	6	*/
	7
	8	#include "ust-registry-channel.hpp"
	9	#include "ust-app.hpp"
	10	#include "ust-registry-event.hpp"
	11
	12	#include <common/error.hpp>
	13	#include <common/exception.hpp>
	14	#include <common/hashtable/utils.hpp>
	15	#include <common/make-unique-wrapper.hpp>
24ed18f2	16	#include <common/make-unique.hpp>
d7bfb9b0 JG	17	#include <common/urcu.hpp>
	18
	19	namespace lst = lttng::sessiond::trace;
	20	namespace lsu = lttng::sessiond::ust;
	21
	22	namespace {
	23	bool is_max_event_id(uint32_t id)
	24	{
	25	return id == UINT32_MAX;
	26	}
	27
	28	unsigned long ht_hash_event(const void *_key, unsigned long seed)
	29	{
	30	uint64_t hashed_key;
	31	const lttng::sessiond::ust::registry_event *key =
	32	(lttng::sessiond::ust::registry_event *) _key;
	33
	34	LTTNG_ASSERT(key);
	35
	36	hashed_key = (uint64_t) hash_key_str(key->name.c_str(), seed);
	37
	38	return hash_key_u64(&hashed_key, seed);
	39	}
	40
	41	/*
	42	* Hash table match function for event in the registry.
	43	*/
	44	int ht_match_event(struct cds_lfht_node node, const void _key)
	45	{
	46	const lttng::sessiond::ust::registry_event *key;
	47	lttng::sessiond::ust::registry_event *event;
	48
	49	LTTNG_ASSERT(node);
	50	LTTNG_ASSERT(_key);
	51
f139a4f9	52	event = lttng::utils::container_of(node, &lttng::sessiond::ust::registry_event::_node);
d7bfb9b0 JG	53	key = (lttng::sessiond::ust::registry_event *) _key;
	54
	55	/* It has to be a perfect match. First, compare the event names. */
	56	if (event->name != key->name) {
	57	goto no_match;
	58	}
	59
	60	/* Compare log levels. */
	61	if (event->log_level != key->log_level) {
	62	goto no_match;
	63	}
	64
	65	/* Compare the arrays of fields. */
	66	if (event->payload != key->payload) {
	67	goto no_match;
	68	}
	69
	70	/* Compare model URI. */
	71	if (event->model_emf_uri != key->model_emf_uri) {
	72	goto no_match;
	73	}
	74
	75	/* Match */
	76	return 1;
	77
	78	no_match:
	79	return 0;
	80	}
24ed18f2 JG	81
	82	lst::type::cuptr create_event_header(const lst::abi& trace_abi, lst::stream_class::header_type header_type)
	83	{
	84	lst::structure_type::fields event_header_fields;
	85
	86	if (header_type == lst::stream_class::header_type::COMPACT) {
	87	auto enum_mappings = std::make_shared<lst::unsigned_enumeration_type::mappings>();
45110cdd JG	88	lst::unsigned_enumeration_type::mapping compact_mapping{
	89	"compact", lst::unsigned_enumeration_type::mapping::range_t(0, 30)};
	90	lst::unsigned_enumeration_type::mapping extended_mapping{"extended"};
24ed18f2	91
45110cdd JG	92	enum_mappings->emplace_back(compact_mapping);
45110cdd JG	93	enum_mappings->emplace_back(extended_mapping);
24ed18f2 JG	94
	95	lst::type::cuptr choice_enum = lttng::make_unique<lst::unsigned_enumeration_type>(1,
	96	trace_abi.byte_order, 5, lst::integer_type::base::DECIMAL,
	97	std::move(enum_mappings),
	98	std::initializer_list<lst::integer_type::role>(
	99	{lst::integer_type::role::EVENT_RECORD_CLASS_ID}));
	100
45110cdd JG	101	lst::variant_type<lst::unsigned_enumeration_type::mapping::range_t::range_integer_t>::
45110cdd JG	102	choices variant_choices;
24ed18f2 JG	103
	104	lst::structure_type::fields compact_fields;
	105	compact_fields.emplace_back(lttng::make_unique<lst::field>("timestamp",
	106	lttng::make_unique<lst::integer_type>(1, trace_abi.byte_order, 27,
	107	lst::integer_type::signedness::UNSIGNED,
	108	lst::integer_type::base::DECIMAL,
	109	std::initializer_list<lst::integer_type::
	110	role>({lst::integer_type::role::
	111	DEFAULT_CLOCK_TIMESTAMP}))));
	112
45110cdd	113	auto compact_type = lttng::make_unique<lst::structure_type>(
24ed18f2	114	0, std::move(compact_fields));
45110cdd	115	variant_choices.emplace_back(std::move(compact_mapping), std::move(compact_type));
24ed18f2 JG	116
	117	lst::structure_type::fields extended_fields;
	118	extended_fields.emplace_back(lttng::make_unique<lst::field>("id",
	119	lttng::make_unique<lst::integer_type>(trace_abi.uint32_t_alignment,
	120	trace_abi.byte_order, 32,
	121	lst::integer_type::signedness::UNSIGNED,
	122	lst::integer_type::base::DECIMAL,
	123	std::initializer_list<lst::integer_type::
	124	role>({lst::integer_type::role::
	125	EVENT_RECORD_CLASS_ID}))));
	126	extended_fields.emplace_back(lttng::make_unique<lst::field>("timestamp",
	127	lttng::make_unique<lst::integer_type>(trace_abi.uint64_t_alignment,
	128	trace_abi.byte_order, 64,
	129	lst::integer_type::signedness::UNSIGNED,
	130	lst::integer_type::base::DECIMAL,
	131	std::initializer_list<lst::integer_type::
	132	role>({lst::integer_type::role::
	133	DEFAULT_CLOCK_TIMESTAMP}))));
	134
45110cdd JG	135	lst::type::cuptr extended_type = lttng::make_unique<lst::structure_type>(0, std::move(extended_fields));
45110cdd JG	136	variant_choices.emplace_back(std::move(extended_mapping), std::move(extended_type));
24ed18f2	137
45110cdd JG	138	auto variant = lttng::make_unique<lst::variant_type<
	139	lst::unsigned_enumeration_type::mapping::range_t::range_integer_t>>(
	140	0,
eda1aa02 JG	141	lst::field_location(lst::field_location::root::EVENT_RECORD_HEADER,
	142	{"id"}),
	143	std::move(variant_choices));
24ed18f2 JG	144
	145	event_header_fields.emplace_back(lttng::make_unique<lst::field>("id", std::move(choice_enum)));
	146	event_header_fields.emplace_back(
	147	lttng::make_unique<lst::field>("v", std::move(variant)));
	148	} else {
	149	auto enum_mappings = std::make_shared<lst::unsigned_enumeration_type::mappings>();
45110cdd JG	150	lst::unsigned_enumeration_type::mapping compact_mapping{"compact",
	151	lst::unsigned_enumeration_type::mapping::range_t(0, 65534)};
	152	lst::unsigned_enumeration_type::mapping extended_mapping{"extended"};
	153	enum_mappings->emplace_back(compact_mapping);
	154	enum_mappings->emplace_back(extended_mapping);
24ed18f2	155
45110cdd	156	auto choice_enum = lttng::make_unique<lst::unsigned_enumeration_type>(
24ed18f2 JG	157	trace_abi.uint16_t_alignment, trace_abi.byte_order, 16,
	158	lst::integer_type::base::DECIMAL, std::move(enum_mappings),
	159	std::initializer_list<lst::integer_type::role>(
	160	{lst::integer_type::role::EVENT_RECORD_CLASS_ID}));
	161
45110cdd JG	162	lst::variant_type<lst::unsigned_enumeration_type::mapping::range_t::range_integer_t>::
45110cdd JG	163	choices variant_choices;
24ed18f2 JG	164
	165	lst::structure_type::fields compact_fields;
	166	compact_fields.emplace_back(lttng::make_unique<lst::field>("timestamp",
	167	lttng::make_unique<lst::integer_type>(trace_abi.uint32_t_alignment,
	168	trace_abi.byte_order, 32,
	169	lst::integer_type::signedness::UNSIGNED,
	170	lst::integer_type::base::DECIMAL,
	171	std::initializer_list<lst::integer_type::
	172	role>({lst::integer_type::role::
	173	DEFAULT_CLOCK_TIMESTAMP}))));
	174
45110cdd	175	lst::type::cuptr compact_type = lttng::make_unique<lst::structure_type>(
24ed18f2	176	0, std::move(compact_fields));
45110cdd	177	variant_choices.emplace_back(std::move(compact_mapping), std::move(compact_type));
24ed18f2 JG	178
	179	lst::structure_type::fields extended_fields;
	180	extended_fields.emplace_back(lttng::make_unique<lst::field>("id",
	181	lttng::make_unique<lst::integer_type>(trace_abi.uint32_t_alignment,
	182	trace_abi.byte_order, 32,
	183	lst::integer_type::signedness::UNSIGNED,
	184	lst::integer_type::base::DECIMAL,
	185	std::initializer_list<lst::integer_type::
	186	role>({lst::integer_type::role::
	187	EVENT_RECORD_CLASS_ID}))));
	188	extended_fields.emplace_back(lttng::make_unique<lst::field>("timestamp",
	189	lttng::make_unique<lst::integer_type>(trace_abi.uint64_t_alignment,
	190	trace_abi.byte_order, 64,
	191	lst::integer_type::signedness::UNSIGNED,
	192	lst::integer_type::base::DECIMAL,
	193	std::initializer_list<lst::integer_type::
	194	role>({lst::integer_type::role::
	195	DEFAULT_CLOCK_TIMESTAMP}))));
	196
45110cdd JG	197	auto extended_type = lttng::make_unique<lst::structure_type>(
	198	0, std::move(extended_fields));
	199	variant_choices.emplace_back(std::move(extended_mapping), std::move(extended_type));
24ed18f2	200
45110cdd JG	201	auto variant = lttng::make_unique<lst::variant_type<
	202	lst::unsigned_enumeration_type::mapping::range_t::range_integer_t>>(
	203	0,
eda1aa02 JG	204	lst::field_location(lst::field_location::root::EVENT_RECORD_HEADER,
	205	{"id"}),
	206	std::move(variant_choices));
24ed18f2	207
45110cdd JG	208	event_header_fields.emplace_back(
45110cdd JG	209	lttng::make_unique<lst::field>("id", std::move(choice_enum)));
24ed18f2 JG	210	event_header_fields.emplace_back(
	211	lttng::make_unique<lst::field>("v", std::move(variant)));
	212	}
	213
	214	return lttng::make_unique<lst::structure_type>(0, std::move(event_header_fields));
	215	}
	216
	217	lst::type::cuptr create_packet_context(const lst::abi& trace_abi)
	218	{
	219	lst::structure_type::fields packet_context_fields;
	220
	221	/* uint64_t timestamp_begin */
	222	packet_context_fields.emplace_back(lttng::make_unique<lst::field>("timestamp_begin",
	223	lttng::make_unique<lst::integer_type>(trace_abi.uint64_t_alignment,
	224	trace_abi.byte_order, 64,
	225	lst::integer_type::signedness::UNSIGNED,
	226	lst::integer_type::base::DECIMAL,
	227	std::initializer_list<lst::integer_type::role>({lst::integer_type::role::DEFAULT_CLOCK_TIMESTAMP}))));
	228
	229	/* uint64_t timestamp_end */
	230	packet_context_fields.emplace_back(lttng::make_unique<lst::field>("timestamp_end",
	231	lttng::make_unique<lst::integer_type>(trace_abi.uint64_t_alignment,
	232	trace_abi.byte_order, 64,
	233	lst::integer_type::signedness::UNSIGNED,
	234	lst::integer_type::base::DECIMAL,
	235	std::initializer_list<lst::integer_type::role>({lst::integer_type::role::PACKET_END_DEFAULT_CLOCK_TIMESTAMP}))));
	236
	237	/* uint64_t content_size */
	238	packet_context_fields.emplace_back(lttng::make_unique<lst::field>("content_size",
	239	lttng::make_unique<lst::integer_type>(trace_abi.uint64_t_alignment,
	240	trace_abi.byte_order, 64,
	241	lst::integer_type::signedness::UNSIGNED,
	242	lst::integer_type::base::DECIMAL,
	243	std::initializer_list<lst::integer_type::role>({lst::integer_type::role::PACKET_CONTENT_LENGTH}))));
	244
	245	/* uint64_t packet_size */
	246	packet_context_fields.emplace_back(lttng::make_unique<lst::field>("packet_size",
	247	lttng::make_unique<lst::integer_type>(trace_abi.uint64_t_alignment,
	248	trace_abi.byte_order, 64,
	249	lst::integer_type::signedness::UNSIGNED,
	250	lst::integer_type::base::DECIMAL,
	251	std::initializer_list<lst::integer_type::role>({lst::integer_type::role::PACKET_TOTAL_LENGTH}))));
	252
	253	/* uint64_t packet_seq_num */
	254	packet_context_fields.emplace_back(lttng::make_unique<lst::field>("packet_seq_num",
	255	lttng::make_unique<lst::integer_type>(trace_abi.uint64_t_alignment,
	256	trace_abi.byte_order, 64,
	257	lst::integer_type::signedness::UNSIGNED,
	258	lst::integer_type::base::DECIMAL,
	259	std::initializer_list<lst::integer_type::role>({lst::integer_type::role::PACKET_SEQUENCE_NUMBER}))));
	260
	261	/* unsigned long events_discarded */
	262	packet_context_fields.emplace_back(lttng::make_unique<lst::field>("events_discarded",
	263	lttng::make_unique<lst::integer_type>(trace_abi.long_alignment,
	264	trace_abi.byte_order, trace_abi.bits_per_long,
	265	lst::integer_type::signedness::UNSIGNED,
	266	lst::integer_type::base::DECIMAL,
	267	std::initializer_list<lst::integer_type::role>({lst::integer_type::role::DISCARDED_EVENT_RECORD_COUNTER_SNAPSHOT}))));
	268
	269	/* uint32_t cpu_id */
	270	packet_context_fields.emplace_back(lttng::make_unique<lst::field>("cpu_id",
	271	lttng::make_unique<lst::integer_type>(trace_abi.uint32_t_alignment,
	272	trace_abi.byte_order, 32,
	273	lst::integer_type::signedness::UNSIGNED,
274	lst::integer_type::base::DECIMAL)));
275
276	return lttng::make_unique<lst::structure_type>(0, std::move(packet_context_fields));
277	}
d7bfb9b0 JG	278	}; /* namespace */
	279
	280	lsu::registry_channel::registry_channel(unsigned int channel_id,
24ed18f2 JG	281	const lst::abi& trace_abi,
24ed18f2 JG	282	std::string in_default_clock_class_name,
d7bfb9b0 JG	283	lsu::registry_channel::registered_listener_fn channel_registered_listener,
d7bfb9b0 JG	284	lsu::registry_channel::event_added_listener_fn event_added_listener) :
24ed18f2 JG	285	lst::stream_class(channel_id,
	286	lst::stream_class::header_type::LARGE,
	287	std::move(in_default_clock_class_name)),
d7bfb9b0 JG	288	_key{-1ULL},
d7bfb9b0 JG	289	_consumer_key{-1ULL},
d7bfb9b0 JG	290	_next_event_id{0},
	291	_is_registered_listener{channel_registered_listener},
	292	_event_added_listener{event_added_listener},
	293	_is_registered{false}
	294	{
	295	_events = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
	296	if (!_events) {
	297	LTTNG_THROW_POSIX("Failed to allocate urcu events hash table", ENOMEM);
	298	}
	299
	300	/* Set custom match function. */
	301	_events->match_fct = ht_match_event;
	302	_events->hash_fct = ht_hash_event;
36038679 JG	303
	304	_rcu_head = {};
	305	/*
	306	* Node's key is initialized by the channel's parent session. Its value is irrelevant to the
	307	* channel object itself.
	308	*/
	309	_node = {};
24ed18f2 JG	310
	311	_packet_context = create_packet_context(trace_abi);
	312	_event_header = create_event_header(trace_abi, header_type_);
d7bfb9b0 JG	313	}
	314
	315	void lsu::registry_channel::add_event(
	316	int session_objd,
	317	int channel_objd,
	318	std::string name,
	319	std::string signature,
	320	std::vector<lst::field::cuptr> event_fields,
	321	int loglevel_value,
	322	nonstd::optional<std::string> model_emf_uri,
	323	lttng_buffer_type buffer_type,
	324	const ust_app& app,
	325	uint32_t& out_event_id)
	326	{
	327	uint32_t event_id;
	328	struct cds_lfht_node *nptr;
	329	lttng::urcu::read_lock_guard read_lock_guard;
	330
	331	/*
	332	* This should not happen but since it comes from the UST tracer, an
	333	* external party, don't assert and simply validate values.
	334	*/
	335	if (session_objd < 0) {
	336	LTTNG_THROW_INVALID_ARGUMENT_ERROR(fmt::format(
	337	"Invalid session object descriptor provided by application: session descriptor = {}, app = {}",
	338	session_objd, app));
	339	}
	340
	341	if (channel_objd < 0) {
	342	LTTNG_THROW_INVALID_ARGUMENT_ERROR(fmt::format(
	343	"Invalid channel object descriptor provided by application: channel descriptor = {}, app = {}",
	344	channel_objd, app));
	345	}
	346
	347	/* Check if we've reached the maximum possible id. */
	348	if (is_max_event_id(_next_event_id)) {
	349	LTTNG_THROW_ERROR(fmt::format(
	350	"Failed to allocate new event id (id would overflow): app = {}",
	351	app));
	352	}
	353
	354	auto event = lttng::make_unique_wrapper<lsu::registry_event, registry_event_destroy>(
	355	new lsu::registry_event(_next_event_id, id, session_objd, channel_objd,
	356	std::move(name), std::move(signature),
	357	std::move(event_fields), loglevel_value,
	358	std::move(model_emf_uri)));
	359
	360	DBG3("%s", fmt::format("UST registry creating event: event = {}", *event).c_str());
	361
	362	/*
	363	* This is an add unique with a custom match function for event. The node
	364	* are matched using the event name and signature.
	365	*/
	366	nptr = cds_lfht_add_unique(_events->ht, _events->hash_fct(event.get(), lttng_ht_seed),
f139a4f9 JG	367	_events->match_fct, event.get(), &event->_node);
f139a4f9 JG	368	if (nptr != &event->_node) {
d7bfb9b0 JG	369	if (buffer_type == LTTNG_BUFFER_PER_UID) {
	370	/*
	371	* This is normal, we just have to send the event id of the
	372	* returned node.
	373	*/
f139a4f9 JG	374	const auto existing_event = lttng::utils::container_of(
f139a4f9 JG	375	nptr, &lttng::sessiond::ust::registry_event::_node);
d7bfb9b0 JG	376	event_id = existing_event->id;
	377	} else {
	378	LTTNG_THROW_INVALID_ARGUMENT_ERROR(fmt::format(
	379	"UST registry create event add unique failed for event: event = {}",
	380	*event));
	381	}
	382	} else {
	383	const auto& event_ref = *event;
	384
	385	/* Ownership transferred to _events hash table. */
	386	event.release();
	387
	388	/* Request next event id if the node was successfully added. */
	389	event_id = event_ref.id;
	390
	391	/*
	392	* Only increment the next id here since we don't want to waste an ID when the event
	393	* matches an existing one.
	394	*/
	395	_next_event_id++;
	396	_event_added_listener(*this, event_ref);
	397	}
	398
	399	out_event_id = event_id;
	400	}
	401
	402	lsu::registry_channel::~registry_channel()
	403	{
	404	lttng_ht_destroy(_events);
	405	}
	406
24ed18f2	407	const lttng::sessiond::trace::type* lsu::registry_channel::get_event_context() const
d7bfb9b0 JG	408	{
d7bfb9b0 JG	409	LTTNG_ASSERT(_is_registered);
24ed18f2	410	return lst::stream_class::get_event_context();
d7bfb9b0 JG	411	}
d7bfb9b0 JG	412
24ed18f2	413	void lsu::registry_channel::set_event_context(lttng::sessiond::trace::type::cuptr context)
d7bfb9b0 JG	414	{
d7bfb9b0 JG	415	/* Must only be set once, on the first channel registration provided by an application. */
24ed18f2 JG	416	LTTNG_ASSERT(!_event_context);
24ed18f2 JG	417	_event_context = std::move(context);
d7bfb9b0 JG	418	}
	419
	420	bool lsu::registry_channel::is_registered() const
	421	{
	422	return _is_registered;
	423	}
	424
	425	void lsu::registry_channel::set_as_registered()
	426	{
	427	if (!_is_registered) {
	428	_is_registered = true;
	429	_is_registered_listener(*this);
	430	}
	431	}
	432
	433	void lsu::registry_channel::_accept_on_event_classes(
	434	lttng::sessiond::trace::trace_class_visitor& visitor) const
	435	{
	436	std::vector<const lttng::sessiond::ust::registry_event *> sorted_event_classes;
	437
	438	{
	439	lttng::urcu::read_lock_guard read_lock_guard;
	440	struct lttng_ht_iter iter;
	441	const lttng::sessiond::ust::registry_event *event;
	442
	443	DIAGNOSTIC_PUSH
	444	DIAGNOSTIC_IGNORE_INVALID_OFFSETOF
f139a4f9	445	cds_lfht_for_each_entry(_events->ht, &iter.iter, event, _node) {
d7bfb9b0 JG	446	sorted_event_classes.emplace_back(event);
	447	}
	448	DIAGNOSTIC_POP
	449	}
	450
	451	std::sort(sorted_event_classes.begin(), sorted_event_classes.end(),
	452	[](const lttng::sessiond::ust::registry_event *a,
	453	const lttng::sessiond::ust::registry_event *b) {
	454	return a->id < b->id;
	455	});
	456
	457	for (const auto event : sorted_event_classes) {
	458	event->accept(visitor);
	459	}
	460	}