2 * Copyright (C) 2022 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 * SPDX-License-Identifier: GPL-2.0-only
8 #include "ust-registry-channel.hpp"
10 #include "ust-registry-event.hpp"
12 #include <common/error.hpp>
13 #include <common/exception.hpp>
14 #include <common/hashtable/utils.hpp>
15 #include <common/make-unique-wrapper.hpp>
16 #include <common/urcu.hpp>
18 namespace lst
= lttng::sessiond::trace
;
19 namespace lsu
= lttng::sessiond::ust
;
22 bool is_max_event_id(uint32_t id
)
24 return id
== UINT32_MAX
;
27 unsigned long ht_hash_event(const void *_key
, unsigned long seed
)
30 const lttng::sessiond::ust::registry_event
*key
=
31 (lttng::sessiond::ust::registry_event
*) _key
;
35 hashed_key
= (uint64_t) hash_key_str(key
->name
.c_str(), seed
);
37 return hash_key_u64(&hashed_key
, seed
);
41 * Hash table match function for event in the registry.
43 int ht_match_event(struct cds_lfht_node
*node
, const void *_key
)
45 const lttng::sessiond::ust::registry_event
*key
;
46 lttng::sessiond::ust::registry_event
*event
;
51 event
= lttng::utils::container_of(node
, <tng::sessiond::ust::registry_event::_node
);
52 key
= (lttng::sessiond::ust::registry_event
*) _key
;
54 /* It has to be a perfect match. First, compare the event names. */
55 if (event
->name
!= key
->name
) {
59 /* Compare log levels. */
60 if (event
->log_level
!= key
->log_level
) {
64 /* Compare the arrays of fields. */
65 if (*event
->payload
!= *key
->payload
) {
69 /* Compare model URI. */
70 if (event
->model_emf_uri
!= key
->model_emf_uri
) {
82 lsu::registry_channel::registry_channel(unsigned int channel_id
,
83 lsu::registry_channel::registered_listener_fn channel_registered_listener
,
84 lsu::registry_channel::event_added_listener_fn event_added_listener
) :
85 lst::stream_class(channel_id
, lst::stream_class::header_type::LARGE
),
88 _metadata_dumped
{false},
90 _is_registered_listener
{channel_registered_listener
},
91 _event_added_listener
{event_added_listener
},
94 _events
= lttng_ht_new(0, LTTNG_HT_TYPE_STRING
);
96 LTTNG_THROW_POSIX("Failed to allocate urcu events hash table", ENOMEM
);
99 /* Set custom match function. */
100 _events
->match_fct
= ht_match_event
;
101 _events
->hash_fct
= ht_hash_event
;
104 void lsu::registry_channel::add_event(
108 std::string signature
,
109 std::vector
<lst::field::cuptr
> event_fields
,
111 nonstd::optional
<std::string
> model_emf_uri
,
112 lttng_buffer_type buffer_type
,
114 uint32_t& out_event_id
)
117 struct cds_lfht_node
*nptr
;
118 lttng::urcu::read_lock_guard read_lock_guard
;
121 * This should not happen but since it comes from the UST tracer, an
122 * external party, don't assert and simply validate values.
124 if (session_objd
< 0) {
125 LTTNG_THROW_INVALID_ARGUMENT_ERROR(fmt::format(
126 "Invalid session object descriptor provided by application: session descriptor = {}, app = {}",
130 if (channel_objd
< 0) {
131 LTTNG_THROW_INVALID_ARGUMENT_ERROR(fmt::format(
132 "Invalid channel object descriptor provided by application: channel descriptor = {}, app = {}",
136 /* Check if we've reached the maximum possible id. */
137 if (is_max_event_id(_next_event_id
)) {
138 LTTNG_THROW_ERROR(fmt::format(
139 "Failed to allocate new event id (id would overflow): app = {}",
143 auto event
= lttng::make_unique_wrapper
<lsu::registry_event
, registry_event_destroy
>(
144 new lsu::registry_event(_next_event_id
, id
, session_objd
, channel_objd
,
145 std::move(name
), std::move(signature
),
146 std::move(event_fields
), loglevel_value
,
147 std::move(model_emf_uri
)));
149 DBG3("%s", fmt::format("UST registry creating event: event = {}", *event
).c_str());
152 * This is an add unique with a custom match function for event. The node
153 * are matched using the event name and signature.
155 nptr
= cds_lfht_add_unique(_events
->ht
, _events
->hash_fct(event
.get(), lttng_ht_seed
),
156 _events
->match_fct
, event
.get(), &event
->_node
);
157 if (nptr
!= &event
->_node
) {
158 if (buffer_type
== LTTNG_BUFFER_PER_UID
) {
160 * This is normal, we just have to send the event id of the
163 const auto existing_event
= lttng::utils::container_of(
164 nptr
, <tng::sessiond::ust::registry_event::_node
);
165 event_id
= existing_event
->id
;
167 LTTNG_THROW_INVALID_ARGUMENT_ERROR(fmt::format(
168 "UST registry create event add unique failed for event: event = {}",
172 const auto& event_ref
= *event
;
174 /* Ownership transferred to _events hash table. */
177 /* Request next event id if the node was successfully added. */
178 event_id
= event_ref
.id
;
181 * Only increment the next id here since we don't want to waste an ID when the event
182 * matches an existing one.
185 _event_added_listener(*this, event_ref
);
188 out_event_id
= event_id
;
191 lsu::registry_channel::~registry_channel()
193 lttng_ht_destroy(_events
);
196 const lttng::sessiond::trace::type
& lsu::registry_channel::get_context() const
198 LTTNG_ASSERT(_is_registered
);
199 return lst::stream_class::get_context();
202 void lsu::registry_channel::set_context(lttng::sessiond::trace::type::cuptr context
)
204 /* Must only be set once, on the first channel registration provided by an application. */
205 LTTNG_ASSERT(!_context
);
206 _context
= std::move(context
);
209 bool lsu::registry_channel::is_registered() const
211 return _is_registered
;
214 void lsu::registry_channel::set_as_registered()
216 if (!_is_registered
) {
217 _is_registered
= true;
218 _is_registered_listener(*this);
222 void lsu::registry_channel::_accept_on_event_classes(
223 lttng::sessiond::trace::trace_class_visitor
& visitor
) const
225 std::vector
<const lttng::sessiond::ust::registry_event
*> sorted_event_classes
;
228 lttng::urcu::read_lock_guard read_lock_guard
;
229 struct lttng_ht_iter iter
;
230 const lttng::sessiond::ust::registry_event
*event
;
233 DIAGNOSTIC_IGNORE_INVALID_OFFSETOF
234 cds_lfht_for_each_entry(_events
->ht
, &iter
.iter
, event
, _node
) {
235 sorted_event_classes
.emplace_back(event
);
240 std::sort(sorted_event_classes
.begin(), sorted_event_classes
.end(),
241 [](const lttng::sessiond::ust::registry_event
*a
,
242 const lttng::sessiond::ust::registry_event
*b
) {
243 return a
->id
< b
->id
;
246 for (const auto event
: sorted_event_classes
) {
247 event
->accept(visitor
);