src/bin/lttng-sessiond/ust-registry.hpp

   1 /*
   2  * Copyright (C) 2013 David Goulet <dgoulet@efficios.com>
   3  * Copyright (C) 2022 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   4  *
   5  * SPDX-License-Identifier: GPL-2.0-only
   6  *
   7  */
   8
   9 #ifndef LTTNG_UST_REGISTRY_H
  10 #define LTTNG_UST_REGISTRY_H
  11
  12 #include "event-class.hpp"
  13 #include "field.hpp"
  14 #include "lttng-ust-ctl.hpp"
  15 #include "session.hpp"
  16 #include "stream-class.hpp"
  17 #include "trace-class.hpp"
  18 #include "ust-clock-class.hpp"
  19 #include "ust-registry-channel.hpp"
  20 #include "ust-registry-event.hpp"
  21
  22 #include <common/format.hpp>
  23 #include <common/hashtable/hashtable.hpp>
  24 #include <common/locked-reference.hpp>
  25 #include <common/urcu.hpp>
  26 #include <common/uuid.hpp>
  27
  28 #include <lttng/domain.h>
  29
  30 #include <ctime>
  31 #include <memory>
  32 #include <pthread.h>
  33 #include <stdint.h>
  34 #include <string>
  35 #include <type_traits>
  36
  37 #define CTF_SPEC_MAJOR 1
  38 #define CTF_SPEC_MINOR 8
  39
  40 struct ust_app;
  41
  42 namespace lttng {
  43 namespace sessiond {
  44 namespace ust {
  45
  46 class registry_session;
  47
  48 namespace details {
  49
  50 template <class MappingIntegerType>
  51 typename trace::typed_enumeration_type<MappingIntegerType>::mappings
  52 mappings_from_ust_ctl_entries(const lttng_ust_ctl_enum_entry *in_entries, size_t in_entry_count)
  53 {
  54         typename trace::typed_enumeration_type<MappingIntegerType>::mappings mappings;
  55
  56         MappingIntegerType next_range_begin = 0;
  57         for (size_t entry_idx = 0; entry_idx < in_entry_count; entry_idx++) {
  58                 const auto& entry = in_entries[entry_idx];
  59                 MappingIntegerType range_begin, range_end;
  60
  61                 if (entry.u.extra.options & LTTNG_UST_CTL_UST_ENUM_ENTRY_OPTION_IS_AUTO) {
  62                         range_begin = range_end = next_range_begin;
  63                 } else {
  64                         range_begin = (MappingIntegerType) entry.start.value;
  65                         range_end = (MappingIntegerType) entry.end.value;
  66                 }
  67
  68                 next_range_begin = range_end + 1;
  69                 mappings.emplace_back(
  70                         entry.string,
  71                         typename trace::typed_enumeration_type<MappingIntegerType>::mapping::range_t{
  72                                 range_begin, range_end });
  73         }
  74
  75         return mappings;
  76 }
  77 } /* namespace details */
  78
  79 class registry_enum {
  80 public:
  81         using const_rcu_protected_reference =
  82                 lttng::locked_reference<const registry_enum, lttng::urcu::unique_read_lock>;
  83
  84         registry_enum(std::string name,
  85                       enum lttng::sessiond::trace::integer_type::signedness signedness);
  86         virtual ~registry_enum() = default;
  87         registry_enum(const registry_enum&) = delete;
  88         registry_enum(registry_enum&&) = delete;
  89         registry_enum& operator=(registry_enum&&) = delete;
  90         registry_enum& operator=(const registry_enum&) = delete;
  91
  92         std::string name;
  93         enum lttng::sessiond::trace::integer_type::signedness signedness;
  94         /* enum id in session */
  95         uint64_t id = -1ULL;
  96         /* Enumeration node in session hash table. */
  97         struct lttng_ht_node_str node;
  98         /* For delayed reclaim. */
  99         struct rcu_head rcu_head;
 100
 101         friend bool operator==(const registry_enum& lhs, const registry_enum& rhs) noexcept;
 102
 103 protected:
 104         virtual bool _is_equal(const registry_enum& other) const noexcept = 0;
 105 };
 106
 107 bool operator==(const registry_enum& lhs, const registry_enum& rhs) noexcept;
 108
 109 template <class MappingIntegerType>
 110 class registry_typed_enum : public registry_enum {
 111 public:
 112         registry_typed_enum(const char *in_name,
 113                             const lttng_ust_ctl_enum_entry *entries,
 114                             size_t entry_count) :
 115                 registry_enum(in_name,
 116                               std::is_signed<MappingIntegerType>::value ?
 117                                       lttng::sessiond::trace::integer_type::signedness::SIGNED :
 118                                       lttng::sessiond::trace::integer_type::signedness::UNSIGNED),
 119                 _mappings{ std::make_shared<
 120                         typename trace::typed_enumeration_type<MappingIntegerType>::mappings>(
 121                         details::mappings_from_ust_ctl_entries<MappingIntegerType>(entries,
 122                                                                                    entry_count)) }
 123         {
 124         }
 125
 126         const typename std::shared_ptr<const typename lttng::sessiond::trace::typed_enumeration_type<
 127                 MappingIntegerType>::mappings>
 128                 _mappings;
 129
 130 protected:
 131         bool _is_equal(const registry_enum& base_other) const noexcept override
 132         {
 133                 const auto& other = static_cast<decltype(*this)&>(base_other);
 134
 135                 /* Don't compare IDs as some comparisons are performed before an id is assigned. */
 136                 return this->name == other.name && *this->_mappings == *other._mappings;
 137         }
 138 };
 139
 140 using registry_signed_enum = registry_typed_enum<int64_t>;
 141 using registry_unsigned_enum = registry_typed_enum<uint64_t>;
 142
 143 } /* namespace ust */
 144 } /* namespace sessiond */
 145 } /* namespace lttng */
 146
 147 #ifdef HAVE_LIBLTTNG_UST_CTL
 148
 149 /*
 150  * Create per-uid registry with default values.
 151  *
 152  * Return new instance on success, nullptr on error.
 153  */
 154 lttng::sessiond::ust::registry_session *
 155 ust_registry_session_per_uid_create(const lttng::sessiond::trace::abi& abi,
 156                                     uint32_t major,
 157                                     uint32_t minor,
 158                                     const char *root_shm_path,
 159                                     const char *shm_path,
 160                                     uid_t euid,
 161                                     gid_t egid,
 162                                     uint64_t tracing_id,
 163                                     uid_t tracing_uid);
 164
 165 /*
 166  * Create per-pid registry with default values.
 167  *
 168  * Return new instance on success, nullptr on error.
 169  */
 170 lttng::sessiond::ust::registry_session *
 171 ust_registry_session_per_pid_create(struct ust_app *app,
 172                                     const lttng::sessiond::trace::abi& abi,
 173                                     uint32_t major,
 174                                     uint32_t minor,
 175                                     const char *root_shm_path,
 176                                     const char *shm_path,
 177                                     uid_t euid,
 178                                     gid_t egid,
 179                                     uint64_t tracing_id);
 180 void ust_registry_session_destroy(lttng::sessiond::ust::registry_session *session);
 181
 182 void ust_registry_channel_destroy_event(lttng::sessiond::ust::registry_channel *chan,
 183                                         lttng::sessiond::ust::registry_event *event);
 184
 185 #else /* HAVE_LIBLTTNG_UST_CTL */
 186
 187 static inline lttng::sessiond::ust::registry_session *
 188 ust_registry_session_per_uid_create(uint32_t bits_per_long __attribute__((unused)),
 189                                     uint32_t uint8_t_alignment __attribute__((unused)),
 190                                     uint32_t uint16_t_alignment __attribute__((unused)),
 191                                     uint32_t uint32_t_alignment __attribute__((unused)),
 192                                     uint32_t uint64_t_alignment __attribute__((unused)),
 193                                     uint32_t long_alignment __attribute__((unused)),
 194                                     int byte_order __attribute__((unused)),
 195                                     uint32_t major __attribute__((unused)),
 196                                     uint32_t minor __attribute__((unused)),
 197                                     const char *root_shm_path __attribute__((unused)),
 198                                     const char *shm_path __attribute__((unused)),
 199                                     uid_t euid __attribute__((unused)),
 200                                     gid_t egid __attribute__((unused)),
 201                                     uint64_t tracing_id __attribute__((unused)),
 202                                     uid_t tracing_uid __attribute__((unused)))
 203 {
 204         return nullptr;
 205 }
 206
 207 static inline lttng::sessiond::ust::registry_session *
 208 ust_registry_session_per_pid_create(struct ust_app *app __attribute__((unused)),
 209                                     uint32_t bits_per_long __attribute__((unused)),
 210                                     uint32_t uint8_t_alignment __attribute__((unused)),
 211                                     uint32_t uint16_t_alignment __attribute__((unused)),
 212                                     uint32_t uint32_t_alignment __attribute__((unused)),
 213                                     uint32_t uint64_t_alignment __attribute__((unused)),
 214                                     uint32_t long_alignment __attribute__((unused)),
 215                                     int byte_order __attribute__((unused)),
 216                                     uint32_t major __attribute__((unused)),
 217                                     uint32_t minor __attribute__((unused)),
 218                                     const char *root_shm_path __attribute__((unused)),
 219                                     const char *shm_path __attribute__((unused)),
 220                                     uid_t euid __attribute__((unused)),
 221                                     gid_t egid __attribute__((unused)),
 222                                     uint64_t tracing_id __attribute__((unused)))
 223 {
 224         return nullptr;
 225 }
 226
 227 static inline void ust_registry_session_destroy(lttng::sessiond::ust::registry_session *session
 228                                                 __attribute__((unused)))
 229 {
 230 }
 231
 232 static inline void ust_registry_destroy_event(lttng::sessiond::ust::registry_channel *chan
 233                                               __attribute__((unused)),
 234                                               lttng::sessiond::ust::registry_event *event
 235                                               __attribute__((unused)))
 236 {
 237 }
 238
 239 /* The app object can be NULL for registry shared across applications. */
 240 static inline int ust_metadata_session_statedump(lttng::sessiond::ust::registry_session *session
 241                                                  __attribute__((unused)))
 242 {
 243         return 0;
 244 }
 245
 246 static inline int ust_metadata_channel_statedump(lttng::sessiond::ust::registry_session *session
 247                                                  __attribute__((unused)),
 248                                                  lttng::sessiond::ust::registry_channel *chan
 249                                                  __attribute__((unused)))
 250 {
 251         return 0;
 252 }
 253
 254 static inline int ust_metadata_event_statedump(lttng::sessiond::ust::registry_session *session
 255                                                __attribute__((unused)),
 256                                                lttng::sessiond::ust::registry_channel *chan
 257                                                __attribute__((unused)),
 258                                                lttng::sessiond::ust::registry_event *event
 259                                                __attribute__((unused)))
 260 {
 261         return 0;
 262 }
 263
 264 #endif /* HAVE_LIBLTTNG_UST_CTL */
 265
 266 #endif /* LTTNG_UST_REGISTRY_H */