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

   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 #ifndef LTTNG_UST_REGISTRY_SESSION_H
   9 #define LTTNG_UST_REGISTRY_SESSION_H
  10
  11 #include "clock-class.hpp"
  12 #include "session.hpp"
  13 #include "trace-class.hpp"
  14 #include "ust-clock-class.hpp"
  15 #include "ust-registry-channel.hpp"
  16 #include "ust-registry.hpp"
  17
  18 #include <common/make-unique-wrapper.hpp>
  19
  20 #include <cstdint>
  21 #include <ctime>
  22 #include <lttng/lttng.h>
  23 #include <string>
  24 #include <unistd.h>
  25
  26 namespace lttng {
  27 namespace sessiond {
  28 namespace ust {
  29
  30 class registry_enum;
  31 class registry_session;
  32
  33 namespace details {
  34 void locked_registry_session_release(registry_session *session);
  35 } /* namespace details */
  36
  37 class registry_session : public lttng::sessiond::trace::trace_class {
  38 public:
  39         using locked_ptr = std::unique_ptr<registry_session,
  40                         lttng::details::create_unique_class<registry_session,
  41                                         details::locked_registry_session_release>::
  42                                         deleter>;
  43
  44         virtual lttng_buffer_type get_buffering_scheme() const noexcept = 0;
  45         locked_ptr lock() noexcept;
  46
  47         void add_channel(uint64_t channel_key);
  48
  49         /* A channel is protected by its parent registry session's lock. */
  50         lttng::sessiond::ust::registry_channel& get_channel(uint64_t channel_key) const;
  51
  52         void remove_channel(uint64_t channel_key, bool notify);
  53
  54         void create_or_find_enum(int session_objd,
  55                         const char *enum_name,
  56                         struct lttng_ust_ctl_enum_entry *raw_entries,
  57                         size_t nr_entries,
  58                         uint64_t *enum_id);
  59         registry_enum::const_rcu_protected_reference get_enumeration(
  60                         const char *enum_name, uint64_t enum_id) const;
  61
  62         void regenerate_metadata();
  63         virtual ~registry_session();
  64
  65         virtual const lttng::sessiond::trace::type *get_packet_header() const noexcept override;
  66
  67         /*
  68          * With multiple writers and readers, use this lock to access
  69          * the registry. Can nest within the ust app session lock.
  70          * Also acts as a registry serialization lock. Used by registry
  71          * readers to serialize the registry information sent from the
  72          * sessiond to the consumerd.
  73          *
  74          * The consumer socket lock nests within this lock.
  75          */
  76         mutable pthread_mutex_t _lock;
  77
  78         /* Generated metadata, not null-terminated. */
  79         char *_metadata = nullptr; /*  */
  80         size_t _metadata_len = 0;
  81         /* Length of bytes sent to the consumer. */
  82         size_t _metadata_len_sent = 0;
  83         /* Current version of the metadata. */
  84         uint64_t _metadata_version = 0;
  85
  86         /*
  87          * Unique key to identify the metadata on the consumer side.
  88          */
  89         uint64_t _metadata_key = 0;
  90         /*
  91          * Indicates if the metadata is closed on the consumer side. This is to
  92          * avoid double close of metadata when an application unregisters AND
  93          * deletes its sessions.
  94          */
  95         bool _metadata_closed = false;
  96
  97 protected:
  98         /* Prevent instanciation of this base class. */
  99         registry_session(const struct lttng::sessiond::trace::abi& abi,
 100                         unsigned int app_tracer_version_major,
 101                         unsigned int app_tracer_version_minor,
 102                         const char *root_shm_path,
 103                         const char *shm_path,
 104                         uid_t euid,
 105                         gid_t egid,
 106                         uint64_t tracing_id);
 107         virtual void _visit_environment(
 108                         lttng::sessiond::trace::trace_class_visitor& trace_class_visitor)
 109                         const override;
 110         void _generate_metadata();
 111
 112 private:
 113         uint32_t _get_next_channel_id();
 114         void _increase_metadata_size(size_t reservation_length);
 115         void _append_metadata_fragment(const std::string& fragment);
 116         void _reset_metadata();
 117         void _destroy_enum(registry_enum *reg_enum) noexcept;
 118         registry_enum *_lookup_enum(const registry_enum *target_enum) const;
 119         lttng::sessiond::trace::type::cuptr _create_packet_header() const;
 120
 121         virtual void _accept_on_clock_classes(
 122                         lttng::sessiond::trace::trace_class_visitor& trace_class_visitor)
 123                         const override final;
 124         virtual void _accept_on_stream_classes(
 125                         lttng::sessiond::trace::trace_class_visitor& trace_class_visitor)
 126                         const override final;
 127
 128         /* Next channel ID available for a newly registered channel. */
 129         uint32_t _next_channel_id = 0;
 130
 131         /* Once this value reaches UINT32_MAX, no more id can be allocated. */
 132         uint32_t _used_channel_id = 0;
 133
 134         /* Next enumeration ID available. */
 135         uint64_t _next_enum_id = 0;
 136
 137         size_t _metadata_alloc_len = 0;
 138
 139         /*
 140          * Those fields are only used when a session is created with
 141          * the --shm-path option. In this case, the metadata is output
 142          * twice: once to the consumer, as ususal, but a second time
 143          * also in the shm path directly. This is done so that a copy
 144          * of the metadata that is as fresh as possible is available
 145          * on the event of a crash.
 146          *
 147          * root_shm_path contains the shm-path provided by the user, along with
 148          * the session's name and timestamp:
 149          *   e.g. /tmp/my_shm/my_session-20180612-135822
 150          *
 151          * shm_path contains the full path of the memory buffers:
 152          *   e.g. /tmp/my_shm/my_session-20180612-135822/ust/uid/1000/64-bit
 153          *
 154          * metadata_path contains the full path to the metadata file that
 155          * is kept for the "crash buffer" extraction:
 156          *  e.g.
 157          * /tmp/my_shm/my_session-20180612-135822/ust/uid/1000/64-bit/metadata
 158          *
 159          * Note that this is not the trace's final metadata file. It is
 160          * only meant to be used to read the contents of the ring buffers
 161          * in the event of a crash.
 162          *
 163          * metadata_fd is a file descriptor that points to the file at
 164          * 'metadata_path'.
 165          */
 166         const std::string _root_shm_path;
 167         const std::string _shm_path;
 168         const std::string _metadata_path;
 169
 170         /* File-backed metadata FD */
 171         int _metadata_fd = -1;
 172
 173         /*
 174          * Hash table containing channels sent by the UST tracer. MUST
 175          * be accessed with a RCU read side lock acquired.
 176          */
 177         lttng_ht::uptr _channels;
 178
 179         /* Enumerations table. */
 180         lttng_ht::uptr _enums;
 181
 182         /* User and group owning the session. */
 183         const uid_t _uid;
 184         const gid_t _gid;
 185
 186         /*
 187          * Copy of the tracer version when the first app is registered.
 188          * It is used if we need to regenerate the metadata.
 189          */
 190         const struct {
 191                 uint32_t major, minor;
 192         } _app_tracer_version;
 193
 194         /* The id of the parent session. */
 195         const ltt_session::id_t _tracing_id;
 196
 197         lttng::sessiond::ust::clock_class::cuptr _clock;
 198         const lttng::sessiond::trace::trace_class_visitor::cuptr _metadata_generating_visitor;
 199         lttng::sessiond::trace::type::cuptr _packet_header;
 200 };
 201
 202 } /* namespace ust */
 203 } /* namespace sessiond */
 204 } /* namespace lttng */
 205
 206 #endif /* LTTNG_UST_REGISTRY_SESSION_H */