src/bin/lttng-sessiond/ust-registry-session.cpp

   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 "field.hpp"
   9 #include "lttng-sessiond.hpp"
  10 #include "notification-thread-commands.hpp"
  11 #include "session.hpp"
  12 #include "trace-class.hpp"
  13 #include "tsdl-trace-class-visitor.hpp"
  14 #include "ust-app.hpp"
  15 #include "ust-field-convert.hpp"
  16 #include "ust-registry.hpp"
  17
  18 #include <common/compat/directory-handle.hpp>
  19 #include <common/error.hpp>
  20 #include <common/exception.hpp>
  21 #include <common/format.hpp>
  22 #include <common/hashtable/utils.hpp>
  23 #include <common/macros.hpp>
  24 #include <common/make-unique.hpp>
  25 #include <common/pthread-lock.hpp>
  26 #include <common/runas.hpp>
  27 #include <common/time.hpp>
  28 #include <common/urcu.hpp>
  29
  30 #include <fcntl.h>
  31 #include <functional>
  32 #include <initializer_list>
  33 #include <mutex>
  34 #include <sstream>
  35 #include <string>
  36
  37 namespace ls = lttng::sessiond;
  38 namespace lst = lttng::sessiond::trace;
  39 namespace lsu = lttng::sessiond::ust;
  40
  41 namespace {
  42 lttng_uuid generate_uuid_or_throw()
  43 {
  44         lttng_uuid new_uuid;
  45
  46         if (lttng_uuid_generate(new_uuid)) {
  47                 LTTNG_THROW_POSIX("Failed to generate UST uuid", errno);
  48         }
  49
  50         return new_uuid;
  51 }
  52
  53 int get_count_order(unsigned int count)
  54 {
  55         int order;
  56
  57         order = lttng_fls(count) - 1;
  58         if (count & (count - 1)) {
  59                 order++;
  60         }
  61
  62         LTTNG_ASSERT(order >= 0);
  63         return order;
  64 }
  65
  66 void clear_metadata_file(int fd)
  67 {
  68         const auto lseek_ret = lseek(fd, 0, SEEK_SET);
  69         if (lseek_ret < 0) {
  70                 LTTNG_THROW_POSIX("Failed to seek to the beginning of the metadata file while clearing it", errno);
  71         }
  72
  73         const auto ret = ftruncate(fd, 0);
  74         if (ret < 0) {
  75                 LTTNG_THROW_POSIX("Failed to truncate the metadata file while clearing it", errno);
  76         }
  77 }
  78
  79 /*
  80  * Validate that the id has reached the maximum allowed or not.
  81  */
  82 bool is_max_channel_id(uint32_t id)
  83 {
  84         return id == UINT32_MAX;
  85 }
  86
  87 void destroy_channel_rcu(struct rcu_head *head)
  88 {
  89         DIAGNOSTIC_PUSH
  90         DIAGNOSTIC_IGNORE_INVALID_OFFSETOF
  91         lsu::registry_channel *chan =
  92                 lttng::utils::container_of(head, &lsu::registry_channel::_rcu_head);
  93         DIAGNOSTIC_POP
  94
  95         delete chan;
  96 }
  97
  98 /*
  99  * Destroy every element of the registry and free the memory. This does NOT
 100  * free the registry pointer since it might not have been allocated before so
 101  * it's the caller responsability.
 102  *
 103  * Called from ~registry_session(), must not throw.
 104  */
 105 void destroy_channel(lsu::registry_channel *chan, bool notify) noexcept
 106 {
 107         struct lttng_ht_iter iter;
 108         lttng::sessiond::ust::registry_event *event;
 109         enum lttng_error_code cmd_ret;
 110
 111         LTTNG_ASSERT(chan);
 112
 113         if (notify) {
 114                 cmd_ret = notification_thread_command_remove_channel(
 115                                 the_notification_thread_handle,
 116                                 chan->_consumer_key, LTTNG_DOMAIN_UST);
 117                 if (cmd_ret != LTTNG_OK) {
 118                         ERR("Failed to remove channel from notification thread");
 119                 }
 120         }
 121
 122         if (chan->_events) {
 123                 lttng::urcu::read_lock_guard read_lock_guard;
 124
 125                 /* Destroy all event associated with this registry. */
 126                 DIAGNOSTIC_PUSH
 127                 DIAGNOSTIC_IGNORE_INVALID_OFFSETOF
 128                 cds_lfht_for_each_entry(
 129                                 chan->_events->ht, &iter.iter, event, _node) {
 130                         /* Delete the node from the ht and free it. */
 131                         ust_registry_channel_destroy_event(chan, event);
 132                 }
 133                 DIAGNOSTIC_POP
 134         }
 135
 136         call_rcu(&chan->_rcu_head, destroy_channel_rcu);
 137 }
 138
 139 void destroy_enum(lsu::registry_enum *reg_enum)
 140 {
 141         if (!reg_enum) {
 142                 return;
 143         }
 144
 145         delete reg_enum;
 146 }
 147
 148 void destroy_enum_rcu(struct rcu_head *head)
 149 {
 150         DIAGNOSTIC_PUSH
 151         DIAGNOSTIC_IGNORE_INVALID_OFFSETOF
 152         lsu::registry_enum *reg_enum =
 153                 lttng::utils::container_of(head, &lsu::registry_enum::rcu_head);
 154         DIAGNOSTIC_POP
 155
 156         destroy_enum(reg_enum);
 157 }
 158
 159 /*
 160  * Hash table match function for enumerations in the session. Match is
 161  * performed on enumeration name, and confirmed by comparing the enum
 162  * entries.
 163  */
 164 int ht_match_enum(struct cds_lfht_node *node, const void *_key)
 165 {
 166         lsu::registry_enum *_enum;
 167         const lsu::registry_enum *key;
 168
 169         LTTNG_ASSERT(node);
 170         LTTNG_ASSERT(_key);
 171
 172         DIAGNOSTIC_PUSH
 173         DIAGNOSTIC_IGNORE_INVALID_OFFSETOF
 174         _enum = caa_container_of(node, lsu::registry_enum,
 175                         node.node);
 176         DIAGNOSTIC_POP
 177
 178         LTTNG_ASSERT(_enum);
 179         key = (lsu::registry_enum *) _key;
 180
 181         return *_enum == *key;
 182 }
 183
 184 /*
 185  * Hash table match function for enumerations in the session. Match is
 186  * performed by enumeration ID.
 187  */
 188 int ht_match_enum_id(struct cds_lfht_node *node, const void *_key)
 189 {
 190         lsu::registry_enum *_enum;
 191         const lsu::registry_enum *key = (lsu::registry_enum *) _key;
 192
 193         LTTNG_ASSERT(node);
 194         LTTNG_ASSERT(_key);
 195
 196         DIAGNOSTIC_PUSH
 197         DIAGNOSTIC_IGNORE_INVALID_OFFSETOF
 198         _enum = caa_container_of(node, lsu::registry_enum, node.node);
 199         DIAGNOSTIC_POP
 200
 201         LTTNG_ASSERT(_enum);
 202
 203         if (_enum->id != key->id) {
 204                 goto no_match;
 205         }
 206
 207         /* Match. */
 208         return 1;
 209
 210 no_match:
 211         return 0;
 212 }
 213
 214 /*
 215  * Hash table hash function for enumerations in the session. The
 216  * enumeration name is used for hashing.
 217  */
 218 unsigned long ht_hash_enum(void *_key, unsigned long seed)
 219 {
 220         lsu::registry_enum *key = (lsu::registry_enum *) _key;
 221
 222         LTTNG_ASSERT(key);
 223         return hash_key_str(key->name.c_str(), seed);
 224 }
 225
 226 } /* namespace */
 227
 228 void lsu::details::locked_registry_session_release(lsu::registry_session *session)
 229 {
 230         pthread_mutex_unlock(&session->_lock);
 231 }
 232
 233 lsu::registry_session::registry_session(const struct lst::abi& in_abi,
 234                 uint32_t major,
 235                 uint32_t minor,
 236                 const char *root_shm_path,
 237                 const char *shm_path,
 238                 uid_t euid,
 239                 gid_t egid,
 240                 uint64_t tracing_id) :
 241         lst::trace_class(in_abi, generate_uuid_or_throw()),
 242         _root_shm_path{root_shm_path ? root_shm_path : ""},
 243         _shm_path{shm_path ? shm_path : ""},
 244         _metadata_path{_shm_path.size() > 0 ? fmt::format("{}/metadata", _shm_path) :
 245                                                     std::string("")},
 246         _uid{euid},
 247         _gid{egid},
 248         _app_tracer_version{.major = major, .minor = minor},
 249         _tracing_id{tracing_id},
 250         _metadata_generating_visitor{lttng::make_unique<ls::tsdl::trace_class_visitor>(
 251                         abi, [this](const std::string& fragment) {
 252                                 _append_metadata_fragment(fragment);
 253                         })}
 254 {
 255         pthread_mutex_init(&_lock, NULL);
 256         if (_shm_path.size() > 0) {
 257                 if (run_as_mkdir_recursive(_shm_path.c_str(), S_IRWXU | S_IRWXG, euid, egid)) {
 258                         LTTNG_THROW_POSIX("run_as_mkdir_recursive", errno);
 259                 }
 260         }
 261
 262         if (_metadata_path.size() > 0) {
 263                 /* Create metadata file. */
 264                 const int ret = run_as_open(_metadata_path.c_str(), O_WRONLY | O_CREAT | O_EXCL,
 265                                 S_IRUSR | S_IWUSR, euid, egid);
 266                 if (ret < 0) {
 267                         LTTNG_THROW_POSIX(fmt::format("Failed to open metadata file during registry session creation: path = {}",
 268                                         _metadata_path), errno);
 269                 }
 270
 271                 _metadata_fd = ret;
 272         }
 273
 274         _enums.reset(lttng_ht_new(0, LTTNG_HT_TYPE_STRING));
 275         if (!_enums) {
 276                 LTTNG_THROW_POSIX("Failed to create enums hash table", ENOMEM);
 277         }
 278
 279         /* hash/match functions are specified at call site. */
 280         _enums->match_fct = NULL;
 281         _enums->hash_fct = NULL;
 282
 283         _channels.reset(lttng_ht_new(0, LTTNG_HT_TYPE_U64));
 284         if (!_channels) {
 285                 LTTNG_THROW_POSIX("Failed to create channels hash table", ENOMEM);
 286         }
 287 }
 288
 289 /*
 290  * For a given enumeration in a registry, delete the entry and destroy
 291  * the enumeration.
 292  *
 293  * Note that this is used by ~registry_session() and must not throw.
 294  */
 295 void lsu::registry_session::_destroy_enum(lsu::registry_enum *reg_enum) noexcept
 296 {
 297         int ret;
 298         lttng::urcu::read_lock_guard read_lock_guard;
 299
 300         LTTNG_ASSERT(reg_enum);
 301         ASSERT_RCU_READ_LOCKED();
 302
 303         /* Delete the node first. */
 304         struct lttng_ht_iter iter;
 305         iter.iter.node = &reg_enum->node.node;
 306         ret = lttng_ht_del(_enums.get(), &iter);
 307         LTTNG_ASSERT(!ret);
 308         call_rcu(&reg_enum->rcu_head, destroy_enum_rcu);
 309 }
 310
 311 lsu::registry_session::~registry_session()
 312 {
 313         int ret;
 314         struct lttng_ht_iter iter;
 315         lsu::registry_channel *chan;
 316         lsu::registry_enum *reg_enum;
 317
 318         /* On error, EBUSY can be returned if lock. Code flow error. */
 319         ret = pthread_mutex_destroy(&_lock);
 320         LTTNG_ASSERT(!ret);
 321
 322         if (_channels) {
 323                 lttng::urcu::read_lock_guard read_lock_guard;
 324
 325                 /* Destroy all event associated with this registry. */
 326                 DIAGNOSTIC_PUSH
 327                 DIAGNOSTIC_IGNORE_INVALID_OFFSETOF
 328                 cds_lfht_for_each_entry(_channels->ht, &iter.iter, chan, _node.node) {
 329                         /* Delete the node from the ht and free it. */
 330                         ret = lttng_ht_del(_channels.get(), &iter);
 331                         LTTNG_ASSERT(!ret);
 332                         destroy_channel(chan, true);
 333                 }
 334                 DIAGNOSTIC_POP
 335         }
 336
 337         free(_metadata);
 338         if (_metadata_fd >= 0) {
 339                 ret = close(_metadata_fd);
 340                 if (ret) {
 341                         PERROR("close");
 342                 }
 343
 344                 ret = run_as_unlink(_metadata_path.c_str(), _uid, _gid);
 345                 if (ret) {
 346                         PERROR("unlink");
 347                 }
 348         }
 349
 350         if (_root_shm_path[0]) {
 351                 /* Try to delete the directory hierarchy. */
 352                 (void) run_as_rmdir_recursive(_root_shm_path.c_str(), _uid, _gid,
 353                                 LTTNG_DIRECTORY_HANDLE_SKIP_NON_EMPTY_FLAG);
 354         }
 355
 356         /* Destroy the enum hash table */
 357         if (_enums) {
 358                 lttng::urcu::read_lock_guard read_lock_guard;
 359
 360                 /* Destroy all enum entries associated with this registry. */
 361                 DIAGNOSTIC_PUSH
 362                 DIAGNOSTIC_IGNORE_INVALID_OFFSETOF
 363                 cds_lfht_for_each_entry (_enums->ht, &iter.iter, reg_enum, node.node) {
 364                         _destroy_enum(reg_enum);
 365                 }
 366                 DIAGNOSTIC_POP
 367         }
 368 }
 369
 370 lsu::registry_session::locked_ptr lsu::registry_session::lock() noexcept
 371 {
 372         pthread_mutex_lock(&_lock);
 373         return locked_ptr(this);
 374 }
 375
 376 /*
 377  * Initialize registry with default values.
 378  */
 379 void lsu::registry_session::add_channel(uint64_t key)
 380 {
 381         lttng::pthread::lock_guard session_lock_guard(_lock);
 382
 383         /*
 384          * Assign a channel ID right now since the event notification comes
 385          * *before* the channel notify so the ID needs to be set at this point so
 386          * the metadata can be dumped for that event.
 387          */
 388         if (is_max_channel_id(_used_channel_id)) {
 389                 LTTNG_THROW_ERROR(fmt::format("Failed to allocate unique id for channel under session while adding channel"));
 390         }
 391
 392         auto chan = new lsu::registry_channel(
 393                         _get_next_channel_id(), abi, _clock.name,
 394                         /* Registered channel listener. */
 395                         [this](const lsu::registry_channel& registered_channel) {
 396                                 /*
 397                                  * Channel registration completed, serialize it's layout's
 398                                  * description.
 399                                  */
 400                                 registered_channel.accept(*_metadata_generating_visitor);
 401                         },
 402                         /* Added event listener. */
 403                         [this](const lsu::registry_channel& channel,
 404                                         const lsu::registry_event& added_event) {
 405                                 /*
 406                                  * The channel and its event classes will be dumped at once when
 407                                  * it is registered. This check prevents event classes from being
 408                                  * declared before their stream class.
 409                                  */
 410                                 if (channel.is_registered()) {
 411                                         added_event.accept(*_metadata_generating_visitor);
 412                                 }
 413                         });
 414
 415         lttng::urcu::read_lock_guard rcu_read_lock_guard;
 416         lttng_ht_node_init_u64(&chan->_node, key);
 417         lttng_ht_add_unique_u64(_channels.get(), &chan->_node);
 418 }
 419
 420 lttng::sessiond::ust::registry_channel& lsu::registry_session::get_channel(
 421                 uint64_t channel_key) const
 422 {
 423         lttng::urcu::read_lock_guard read_lock_guard;
 424         struct lttng_ht_node_u64 *node;
 425         struct lttng_ht_iter iter;
 426
 427         ASSERT_LOCKED(_lock);
 428
 429         lttng_ht_lookup(_channels.get(), &channel_key, &iter);
 430         node = lttng_ht_iter_get_node_u64(&iter);
 431         if (!node) {
 432                 LTTNG_THROW_INVALID_ARGUMENT_ERROR(fmt::format(
 433                                 "Invalid channel key provided: channel key = {}", channel_key));
 434         }
 435
 436         DIAGNOSTIC_PUSH
 437         DIAGNOSTIC_IGNORE_INVALID_OFFSETOF
 438         auto chan = lttng::utils::container_of(node, &lsu::registry_channel::_node);
 439         DIAGNOSTIC_POP
 440         return *chan;
 441 }
 442
 443 void lsu::registry_session::remove_channel(uint64_t channel_key, bool notify)
 444 {
 445         struct lttng_ht_iter iter;
 446         int ret;
 447         lttng::urcu::read_lock_guard read_lock_guard;
 448
 449         ASSERT_LOCKED(_lock);
 450         auto& channel = get_channel(channel_key);
 451
 452         iter.iter.node = &channel._node.node;
 453         ret = lttng_ht_del(_channels.get(), &iter);
 454         LTTNG_ASSERT(!ret);
 455         destroy_channel(&channel, notify);
 456 }
 457
 458 void lsu::registry_session::_visit_environment(
 459                 lttng::sessiond::trace::trace_class_visitor& visitor) const
 460 {
 461         ASSERT_LOCKED(_lock);
 462
 463         visitor.visit(lst::environment_field<const char *>("domain", "ust"));
 464         visitor.visit(lst::environment_field<const char *>("tracer_name", "lttng-ust"));
 465         visitor.visit(lst::environment_field<int64_t>("tracer_major", _app_tracer_version.major));
 466         visitor.visit(lst::environment_field<int64_t>("tracer_minor", _app_tracer_version.minor));
 467         visitor.visit(lst::environment_field<const char *>("tracer_buffering_scheme",
 468                         get_buffering_scheme() == LTTNG_BUFFER_PER_PID ? "pid" : "uid"));
 469         visitor.visit(lst::environment_field<int64_t>("architecture_bit_width", abi.bits_per_long));
 470
 471         {
 472                 /* The caller already holds the session and session list locks. */
 473                 ASSERT_SESSION_LIST_LOCKED();
 474                 const auto session = lttng::sessiond::find_session_by_id(_tracing_id);
 475
 476                 LTTNG_ASSERT(session);
 477                 ASSERT_LOCKED(session->lock);
 478
 479                 visitor.visit(lst::environment_field<const char *>("trace_name",
 480                                 session->has_auto_generated_name ? DEFAULT_SESSION_NAME :
 481                                                                          session->name));
 482                 visitor.visit(lst::environment_field<std::string>("trace_creation_datetime",
 483                                 lttng::utils::time_to_iso8601_str(session->creation_time)));
 484                 visitor.visit(lst::environment_field<const char *>("hostname", session->hostname));
 485         }
 486 }
 487
 488 void lsu::registry_session::_accept_on_clock_classes(lst::trace_class_visitor& visitor) const
 489 {
 490         ASSERT_LOCKED(_lock);
 491         _clock.accept(visitor);
 492 }
 493
 494 void lsu::registry_session::_accept_on_stream_classes(lst::trace_class_visitor& visitor) const
 495 {
 496         ASSERT_LOCKED(_lock);
 497
 498         std::vector<const lttng::sessiond::ust::registry_channel *> sorted_stream_classes;
 499
 500         {
 501                 lttng::urcu::read_lock_guard rcu_lock_guard;
 502                 const lsu::registry_channel *channel;
 503                 lttng_ht_iter channel_it;
 504
 505                 DIAGNOSTIC_PUSH
 506                 DIAGNOSTIC_IGNORE_INVALID_OFFSETOF
 507                 cds_lfht_for_each_entry(_channels->ht, &channel_it.iter, channel, _node.node) {
 508                         sorted_stream_classes.emplace_back(channel);
 509                 }
 510                 DIAGNOSTIC_POP
 511         }
 512
 513         std::sort(sorted_stream_classes.begin(), sorted_stream_classes.end(),
 514                         [](const lttng::sessiond::ust::registry_channel *a,
 515                                         const lttng::sessiond::ust::registry_channel *b) {
 516                                 return a->id < b->id;
 517                         });
 518
 519         for (const auto stream_class : sorted_stream_classes) {
 520                 stream_class->accept(visitor);
 521         }
 522 }
 523
 524 /*
 525  * Return next available channel id and increment the used counter. The
 526  * is_max_channel_id function MUST be called before in order to validate
 527  * if the maximum number of IDs have been reached. If not, it is safe to call
 528  * this function.
 529  *
 530  * Return a unique channel ID. If max is reached, the used_channel_id counter
 531  * is returned.
 532  */
 533 uint32_t lsu::registry_session::_get_next_channel_id()
 534 {
 535         if (is_max_channel_id(_used_channel_id)) {
 536                 return _used_channel_id;
 537         }
 538
 539         _used_channel_id++;
 540         return _next_channel_id++;
 541 }
 542
 543 void lsu::registry_session::_increase_metadata_size(size_t reservation_length)
 544 {
 545         const auto new_len = _metadata_len + reservation_length;
 546         auto new_alloc_len = new_len;
 547         const auto old_alloc_len = _metadata_alloc_len;
 548
 549         /* Rounding the new allocation length to the next power of 2 would overflow. */
 550         if (new_alloc_len > (UINT32_MAX >> 1)) {
 551                 LTTNG_THROW_ERROR("Failed to reserve trace metadata storage as the new size would overflow");
 552         }
 553
 554         /* The current allocation length is already the largest we can afford. */
 555         if ((old_alloc_len << 1) > (UINT32_MAX >> 1)) {
 556                 LTTNG_THROW_ERROR("Failed to reserve trace metadata storage as the max size was already reached");
 557         }
 558
 559         if (new_alloc_len > old_alloc_len) {
 560                 new_alloc_len = std::max<size_t>(
 561                                 1U << get_count_order(new_alloc_len), old_alloc_len << 1);
 562
 563                 auto newptr = (char *) realloc(_metadata, new_alloc_len);
 564                 if (!newptr) {
 565                         LTTNG_THROW_POSIX("Failed to allocate trace metadata storage", errno);
 566                 }
 567
 568                 _metadata = newptr;
 569
 570                 /* We zero directly the memory from start of allocation. */
 571                 memset(&_metadata[old_alloc_len], 0, new_alloc_len - old_alloc_len);
 572                 _metadata_alloc_len = new_alloc_len;
 573         }
 574
 575         _metadata_len += reservation_length;
 576 }
 577
 578 void lsu::registry_session::_append_metadata_fragment(const std::string& fragment)
 579 {
 580         const auto offset = _metadata_len;
 581
 582         _increase_metadata_size(fragment.size());
 583         memcpy(&_metadata[offset], fragment.c_str(), fragment.size());
 584
 585         if (_metadata_fd >= 0) {
 586                 const auto bytes_written =
 587                                 lttng_write(_metadata_fd, fragment.c_str(), fragment.size());
 588
 589                 if (bytes_written != fragment.size()) {
 590                         LTTNG_THROW_POSIX("Failed to write trace metadata fragment to file",
 591                                         errno);
 592                 }
 593         }
 594 }
 595
 596 void lsu::registry_session::_reset_metadata()
 597 {
 598         _metadata_len_sent = 0;
 599         memset(_metadata, 0, _metadata_alloc_len);
 600         _metadata_len = 0;
 601
 602         if (_metadata_fd > 0) {
 603                 /* Clear the metadata file's content. */
 604                 clear_metadata_file(_metadata_fd);
 605         }
 606 }
 607
 608 void lsu::registry_session::_generate_metadata()
 609 {
 610         accept(*_metadata_generating_visitor);
 611 }
 612
 613 void lsu::registry_session::regenerate_metadata()
 614 {
 615         lttng::pthread::lock_guard registry_lock(_lock);
 616
 617         _metadata_version++;
 618         _reset_metadata();
 619         _generate_metadata();
 620 }
 621
 622 /*
 623  * Lookup enumeration by enum ID.
 624  *
 625  * Note that there is no need to lock the registry session as this only
 626  * performs an RCU-protected look-up. The function also return an rcu-protected
 627  * reference, which ensures that the caller keeps the RCU read lock until it
 628  * disposes of the object.
 629  */
 630 lsu::registry_enum::const_rcu_protected_reference
 631 lsu::registry_session::get_enumeration(const char *enum_name, uint64_t enum_id) const
 632 {
 633         lsu::registry_enum *reg_enum = NULL;
 634         struct lttng_ht_node_str *node;
 635         struct lttng_ht_iter iter;
 636         lttng::urcu::unique_read_lock rcu_lock;
 637         /*
 638          * Hack: only the name is used for hashing; the rest of the attributes
 639          * can be fudged.
 640          */
 641         lsu::registry_signed_enum reg_enum_lookup(enum_name, nullptr, 0);
 642
 643         ASSERT_RCU_READ_LOCKED();
 644
 645         reg_enum_lookup.id = enum_id;
 646         cds_lfht_lookup(_enums->ht,
 647                         ht_hash_enum((void *) &reg_enum_lookup, lttng_ht_seed),
 648                         ht_match_enum_id, &reg_enum_lookup, &iter.iter);
 649         node = lttng_ht_iter_get_node_str(&iter);
 650         if (!node) {
 651                 LTTNG_THROW_PROTOCOL_ERROR(fmt::format(
 652                                 "Unknown enumeration referenced by application event field: enum name = `{}`, enum id = {}",
 653                                 enum_name, enum_id));
 654         }
 655
 656         DIAGNOSTIC_PUSH
 657         DIAGNOSTIC_IGNORE_INVALID_OFFSETOF
 658         reg_enum = lttng::utils::container_of(node, &lsu::registry_enum::node);
 659         DIAGNOSTIC_POP
 660
 661         return lsu::registry_enum::const_rcu_protected_reference{*reg_enum, std::move(rcu_lock)};
 662 }
 663
 664 lst::type::cuptr lsu::registry_session::get_packet_header() const
 665 {
 666         lst::structure_type::fields packet_header_fields;
 667
 668         /* uint32_t magic */
 669         packet_header_fields.emplace_back(lttng::make_unique<lst::field>("magic",
 670                         lttng::make_unique<lst::integer_type>(abi.uint32_t_alignment,
 671                                         abi.byte_order, 32, lst::integer_type::signedness::UNSIGNED,
 672                                         lst::integer_type::base::HEXADECIMAL,
 673                                         std::initializer_list<lst::integer_type::role>({lst::integer_type::role::PACKET_MAGIC_NUMBER}))));
 674
 675         /* uuid */
 676         packet_header_fields.emplace_back(lttng::make_unique<lst::field>("uuid",
 677                         lttng::make_unique<lst::static_length_blob_type>(0, 16,
 678                                         std::initializer_list<lst::static_length_blob_type::role>({lst::static_length_blob_type::role::TRACE_CLASS_UUID}))));
 679
 680         /* uint32_t stream_id */
 681         packet_header_fields.emplace_back(lttng::make_unique<lst::field>("stream_id",
 682                         lttng::make_unique<lst::integer_type>(abi.uint32_t_alignment,
 683                                         abi.byte_order, 32, lst::integer_type::signedness::UNSIGNED,
 684                                         lst::integer_type::base::DECIMAL,
 685                                         std::initializer_list<lst::integer_type::role>({lst::integer_type::role::DATA_STREAM_CLASS_ID}))));
 686
 687         /* uint64_t stream_instance_id */
 688         packet_header_fields.emplace_back(lttng::make_unique<lst::field>("stream_instance_id",
 689                         lttng::make_unique<lst::integer_type>(abi.uint64_t_alignment,
 690                                         abi.byte_order, 64, lst::integer_type::signedness::UNSIGNED,
 691                                         lst::integer_type::base::DECIMAL,
 692                                         std::initializer_list<lst::integer_type::role>({lst::integer_type::role::DATA_STREAM_ID}))));
 693
 694         return lttng::make_unique<lst::structure_type>(0, std::move(packet_header_fields));
 695 }
 696
 697 /*
 698  * Lookup enumeration by name and comparing enumeration entries.
 699  * Needs to be called from RCU read-side critical section.
 700  */
 701 lsu::registry_enum *lsu::registry_session::_lookup_enum(
 702                 const lsu::registry_enum *reg_enum_lookup) const
 703 {
 704         lsu::registry_enum *reg_enum = NULL;
 705         struct lttng_ht_node_str *node;
 706         struct lttng_ht_iter iter;
 707
 708         ASSERT_RCU_READ_LOCKED();
 709
 710         cds_lfht_lookup(_enums->ht, ht_hash_enum((void *) reg_enum_lookup, lttng_ht_seed),
 711                         ht_match_enum, reg_enum_lookup, &iter.iter);
 712         node = lttng_ht_iter_get_node_str(&iter);
 713         if (!node) {
 714                 goto end;
 715         }
 716
 717         DIAGNOSTIC_PUSH
 718         DIAGNOSTIC_IGNORE_INVALID_OFFSETOF
 719         reg_enum = lttng::utils::container_of(node, &lsu::registry_enum::node);
 720         DIAGNOSTIC_POP
 721
 722 end:
 723         return reg_enum;
 724 }
 725
 726 /*
 727  * Create a lsu::registry_enum from the given parameters and add it to the
 728  * registry hash table, or find it if already there.
 729  *
 730  * Should be called with session registry mutex held.
 731  *
 732  * We receive ownership of entries.
 733  */
 734 void lsu::registry_session::create_or_find_enum(
 735                 int session_objd, const char *enum_name,
 736                 struct lttng_ust_ctl_enum_entry *raw_entries, size_t nr_entries,
 737                 uint64_t *enum_id)
 738 {
 739         struct cds_lfht_node *nodep;
 740         lsu::registry_enum *reg_enum = NULL, *old_reg_enum;
 741         lttng::urcu::read_lock_guard read_lock_guard;
 742         auto entries = lttng::make_unique_wrapper<lttng_ust_ctl_enum_entry, lttng::free>(raw_entries);
 743
 744         LTTNG_ASSERT(enum_name);
 745
 746         /*
 747          * This should not happen but since it comes from the UST tracer, an
 748          * external party, don't assert and simply validate values.
 749          */
 750         if (session_objd < 0) {
 751                 LTTNG_THROW_INVALID_ARGUMENT_ERROR(fmt::format(
 752                                 "Invalid parameters used to create or look-up enumeration from registry session: session_objd = {}",
 753                                 session_objd));
 754         }
 755         if (nr_entries == 0) {
 756                 LTTNG_THROW_INVALID_ARGUMENT_ERROR(fmt::format(
 757                                 "Invalid parameters used to create or look-up enumeration from registry session: nr_entries = {}",
 758                                 nr_entries));
 759         }
 760         if (lttng_strnlen(enum_name, LTTNG_UST_ABI_SYM_NAME_LEN) ==
 761                                         LTTNG_UST_ABI_SYM_NAME_LEN) {
 762                 LTTNG_THROW_INVALID_ARGUMENT_ERROR(
 763                                 "Invalid parameters used to create or look-up enumeration from registry session: enumeration name is not null terminated");
 764         }
 765
 766         if (entries->start.signedness) {
 767                 reg_enum = new lsu::registry_signed_enum(
 768                                 enum_name, entries.get(), nr_entries);
 769         } else {
 770                 reg_enum = new lsu::registry_unsigned_enum(
 771                                 enum_name, entries.get(), nr_entries);
 772         }
 773
 774         old_reg_enum = _lookup_enum(reg_enum);
 775         if (old_reg_enum) {
 776                 DBG("enum %s already in sess_objd: %u", enum_name, session_objd);
 777                 /* Fall through. Use prior enum. */
 778                 destroy_enum(reg_enum);
 779                 reg_enum = old_reg_enum;
 780         } else {
 781                 DBG("UST registry creating enum: %s, sess_objd: %u",
 782                                 enum_name, session_objd);
 783                 if (_next_enum_id == -1ULL) {
 784                         destroy_enum(reg_enum);
 785                         LTTNG_THROW_ERROR("Failed to allocate unique enumeration ID as it would overflow");
 786                 }
 787
 788                 reg_enum->id = _next_enum_id++;
 789                 nodep = cds_lfht_add_unique(_enums->ht,
 790                                 ht_hash_enum(reg_enum, lttng_ht_seed),
 791                                 ht_match_enum_id, reg_enum,
 792                                 &reg_enum->node.node);
 793                 LTTNG_ASSERT(nodep == &reg_enum->node.node);
 794         }
 795
 796         DBG("UST registry reply with enum %s with id %" PRIu64 " in sess_objd: %u",
 797                         enum_name, reg_enum->id, session_objd);
 798         *enum_id = reg_enum->id;
 799 }