src/bin/lttng-sessiond/session.hpp

   1 /*
   2  * Copyright (C) 2011 EfficiOS Inc.
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #ifndef _LTT_SESSION_H
   9 #define _LTT_SESSION_H
  10
  11 #include <limits.h>
  12 #include <memory>
  13 #include <stdbool.h>
  14 #include <urcu/list.h>
  15
  16 #include <common/dynamic-array.hpp>
  17 #include <common/hashtable/hashtable.hpp>
  18 #include <common/make-unique-wrapper.hpp>
  19 #include <common/pthread-lock.hpp>
  20 #include <lttng/location.h>
  21 #include <lttng/lttng-error.h>
  22 #include <lttng/rotation.h>
  23 #include <lttng/trace-format-descriptor-internal.hpp>
  24
  25 #include "snapshot.hpp"
  26 #include "trace-kernel.hpp"
  27 #include "consumer.hpp"
  28
  29 #define ASSERT_SESSION_LIST_LOCKED() LTTNG_ASSERT(session_trylock_list())
  30
  31 struct ltt_ust_session;
  32
  33 typedef void (*ltt_session_destroy_notifier)(const struct ltt_session *session,
  34                 void *user_data);
  35 typedef void (*ltt_session_clear_notifier)(const struct ltt_session *session,
  36                 void *user_data);
  37
  38 namespace lttng {
  39 namespace sessiond {
  40 namespace details {
  41 void locked_session_release(ltt_session *session);
  42 } /* namespace details */
  43 } /* namespace sessiond */
  44 } /* namespace lttng */
  45
  46 /*
  47  * Tracing session list
  48  *
  49  * Statically declared in session.c and can be accessed by using
  50  * session_get_list() function that returns the pointer to the list.
  51  */
  52 struct ltt_session_list {
  53         /*
  54          * This lock protects any read/write access to the list and
  55          * next_uuid. All public functions in session.c acquire this
  56          * lock and release it before returning. If none of those
  57          * functions are used, the lock MUST be acquired in order to
  58          * iterate or/and do any actions on that list.
  59          */
  60         pthread_mutex_t lock;
  61         /*
  62          * This condition variable is signaled on every removal from
  63          * the session list.
  64          */
  65         pthread_cond_t removal_cond;
  66
  67         /*
  68          * Session unique ID generator. The session list lock MUST be
  69          * upon update and read of this counter.
  70          */
  71         uint64_t next_uuid;
  72
  73         /* Linked list head */
  74         struct cds_list_head head;
  75 };
  76
  77 /*
  78  * This data structure contains information needed to identify a tracing
  79  * session for both LTTng and UST.
  80  */
  81 struct ltt_session {
  82         using id_t = uint64_t;
  83         using locked_ptr = std::unique_ptr<ltt_session,
  84                         lttng::details::create_unique_class<ltt_session,
  85                                         lttng::sessiond::details::locked_session_release>::deleter>;
  86         using sptr = std::shared_ptr<ltt_session>;
  87
  88         ltt_session()
  89         {
  90                 has_been_started = 0;
  91                 active = 0;
  92         };
  93         ~ltt_session() = default;
  94
  95         char name[NAME_MAX]{0};
  96         bool has_auto_generated_name{false};
  97         bool name_contains_creation_time{false};
  98         char hostname[LTTNG_HOST_NAME_MAX]{0}; /* Local hostname. */
  99         /* Path of the last closed chunk. */
 100         char last_chunk_path[LTTNG_PATH_MAX]{0};
 101         time_t creation_time{};
 102         struct ltt_kernel_session *kernel_session{};
 103         struct ltt_ust_session *ust_session{};
 104         struct urcu_ref ref {};
 105         /*
 106          * Protect any read/write on this session data structure. This lock must be
 107          * acquired *before* using any public functions declared below. Use
 108          * session_lock() and session_unlock() for that.
 109          */
 110         pthread_mutex_t lock{};
 111         struct cds_list_head list {};
 112         id_t id{}; /* session unique identifier */
 113         /* Indicates if the session has been added to the session list and ht.*/
 114         bool published{false};
 115         /* Indicates if a destroy command has been applied to this session. */
 116         bool destroyed{false};
 117         /* UID/GID of the user owning the session */
 118         uid_t uid{};
 119         gid_t gid{};
 120         /*
 121          * Network session handle. A value of 0 means that there is no remote
 122          * session established.
 123          */
 124         uint64_t net_handle{};
 125         /*
 126          * This consumer is only set when the create_session_uri call is made.
 127          * This contains the temporary information for a consumer output. Upon
 128          * creation of the UST or kernel session, this consumer, if available, is
 129          * copied into those sessions.
 130          */
 131         struct consumer_output *consumer{};
 132         /*
 133          * Indicates whether or not the user has specified an output directory
 134          * or if it was configured using the default configuration.
 135          */
 136         bool has_user_specified_directory{false};
 137         /* Did at least ONE start command has been triggered?. */
 138         bool has_been_started{false};
 139         /*
 140          * Is the session active? Start trace command sets this to true and the stop
 141          * command reset it to false.
 142          */
 143         bool active{false};
 144
 145         /* Snapshot representation in a session. */
 146         struct snapshot snapshot {};
 147         /* Indicate if the session has to output the traces or not. */
 148         unsigned int output_traces{};
 149         /*
 150          * This session is in snapshot mode. This means that channels enabled
 151          * will be set in overwrite mode by default and must be in mmap
 152          * output mode. Note that snapshots can be taken on a session that
 153          * is not in "snapshot_mode". This parameter only affects channel
 154          * creation defaults.
 155          */
 156         unsigned int snapshot_mode{};
 157         /*
 158          * A session that has channels that don't use 'mmap' output can't be
 159          * used to capture snapshots. This is set to true whenever a
 160          * 'splice' kernel channel is enabled.
 161          */
 162         bool has_non_mmap_channel{false};
 163         /*
 164          * Timer set when the session is created for live reading.
 165          */
 166         unsigned int live_timer{0};
 167         /*
 168          * Path where to keep the shared memory files.
 169          */
 170         char shm_path[PATH_MAX]{};
 171         /*
 172          * Node in ltt_sessions_ht_by_id.
 173          */
 174         struct lttng_ht_node_u64 node {};
 175         /*
 176          * Node in ltt_sessions_ht_by_name.
 177          */
 178         struct lttng_ht_node_str node_by_name {};
 179         /*
 180          * Timer to check periodically if a relay and/or consumer has completed
 181          * the last rotation.
 182          */
 183         bool rotation_pending_check_timer_enabled{false};
 184         timer_t rotation_pending_check_timer{};
 185         /* Timer to periodically rotate a session. */
 186         bool rotation_schedule_timer_enabled{false};
 187         timer_t rotation_schedule_timer{};
 188         /* Value for periodic rotations, 0 if disabled. */
 189         uint64_t rotate_timer_period{};
 190         /* Value for size-based rotations, 0 if disabled. */
 191         uint64_t rotate_size{};
 192         /*
 193          * Keep a state if this session was rotated after the last stop command.
 194          * We only allow one rotation after a stop. At destroy, we also need to
 195          * know if a rotation occurred since the last stop to rename the current
 196          * chunk. After a stop followed by rotate, all subsequent clear
 197          * (without prior start) will succeed, but will be effect-less.
 198          */
 199         bool rotated_after_last_stop{false};
 200         /*
 201          * Track whether the session was cleared after last stop. All subsequent
 202          * clear (without prior start) will succeed, but will be effect-less. A
 203          * subsequent rotate (without prior start) will return an error.
 204          */
 205         bool cleared_after_last_stop{false};
 206         /*
 207          * True if the session has had an explicit non-quiet rotation.
 208          */
 209         bool rotated{false};
 210         /*
 211          * Trigger for size-based rotations.
 212          */
 213         struct lttng_trigger *rotate_trigger{};
 214         LTTNG_OPTIONAL(uint64_t) most_recent_chunk_id{};
 215         struct lttng_trace_chunk *current_trace_chunk{};
 216         struct lttng_trace_chunk *chunk_being_archived{};
 217         /* Current state of a rotation. */
 218         enum lttng_rotation_state rotation_state { LTTNG_ROTATION_STATE_NO_ROTATION };
 219         bool quiet_rotation{false};
 220         char *last_archived_chunk_name{};
 221         LTTNG_OPTIONAL(uint64_t) last_archived_chunk_id{};
 222         struct lttng_dynamic_array destroy_notifiers {};
 223         struct lttng_dynamic_array clear_notifiers {};
 224         /* Session base path override. Set non-null. */
 225         char *base_path{};
 226         /* Trace output format */
 227         lttng::trace_format_descriptor::sptr trace_format;
 228 };
 229
 230 enum lttng_error_code session_create(const char *name,
 231                 uid_t uid,
 232                 gid_t gid,
 233                 lttng::trace_format_descriptor::uptr& trace_format,
 234                 struct ltt_session **out_session);
 235 void session_lock(struct ltt_session *session);
 236 void session_unlock(struct ltt_session *session);
 237
 238 /*
 239  * The session list lock covers more ground than its name implies. While
 240  * it does protect against concurent mutations of the session list, it is
 241  * also used as a multi-session lock when synchronizing newly-registered
 242  * 'user space tracer' and 'agent' applications.
 243  *
 244  * In other words, it prevents tracer configurations from changing while they
 245  * are being transmitted to the various applications.
 246  */
 247 void session_lock_list(void);
 248 int session_trylock_list(void);
 249 void session_unlock_list(void);
 250
 251 void session_destroy(struct ltt_session *session);
 252 int session_add_destroy_notifier(struct ltt_session *session,
 253                 ltt_session_destroy_notifier notifier, void *user_data);
 254
 255 int session_add_clear_notifier(struct ltt_session *session,
 256                 ltt_session_clear_notifier notifier, void *user_data);
 257 void session_notify_clear(struct ltt_session *session);
 258
 259 bool session_get(struct ltt_session *session);
 260 void session_put(struct ltt_session *session);
 261
 262 enum consumer_dst_type session_get_consumer_destination_type(
 263                 const struct ltt_session *session);
 264 const char *session_get_net_consumer_hostname(
 265                 const struct ltt_session *session);
 266 void session_get_net_consumer_ports(
 267                 const struct ltt_session *session,
 268                 uint16_t *control_port, uint16_t *data_port);
 269 struct lttng_trace_archive_location *session_get_trace_archive_location(
 270                 const struct ltt_session *session);
 271
 272 struct ltt_session *session_find_by_name(const char *name);
 273 struct ltt_session *session_find_by_id(ltt_session::id_t id);
 274
 275 struct ltt_session_list *session_get_list(void);
 276 void session_list_wait_empty(void);
 277
 278 bool session_access_ok(struct ltt_session *session, uid_t uid);
 279
 280 int session_reset_rotation_state(struct ltt_session *session,
 281                 enum lttng_rotation_state result);
 282
 283 /* Create a new trace chunk object from the session's configuration. */
 284 struct lttng_trace_chunk *session_create_new_trace_chunk(
 285                 const struct ltt_session *session,
 286                 const struct consumer_output *consumer_output_override,
 287                 const char *session_base_path_override,
 288                 const char *chunk_name_override);
 289
 290 /*
 291  * Set `new_trace_chunk` as the session's current trace chunk. A reference
 292  * to `new_trace_chunk` is acquired by the session. The chunk is created
 293  * on remote peers (consumer and relay daemons).
 294  *
 295  * A reference to the session's current trace chunk is returned through
 296  * `current_session_trace_chunk` on success.
 297  */
 298 int session_set_trace_chunk(struct ltt_session *session,
 299                 struct lttng_trace_chunk *new_trace_chunk,
 300                 struct lttng_trace_chunk **current_session_trace_chunk);
 301
 302 /*
 303  * Close a chunk on the remote peers of a session. Has no effect on the
 304  * ltt_session itself.
 305  */
 306 int session_close_trace_chunk(struct ltt_session *session,
 307                 struct lttng_trace_chunk *trace_chunk,
 308                 enum lttng_trace_chunk_command_type close_command,
 309                 char *path);
 310
 311 /* Open a packet in all channels of a given session. */
 312 enum lttng_error_code session_open_packets(struct ltt_session *session);
 313
 314 bool session_output_supports_trace_chunks(const struct ltt_session *session);
 315
 316 /*
 317  * Sample the id of a session looked up via its name.
 318  * Here the term "sampling" hint the caller that this return the id at a given
 319  * point in time with no guarantee that the session for which the id was
 320  * sampled still exist at that point.
 321  *
 322  * Return 0 when the session is not found,
 323  * Return 1 when the session is found and set `id`.
 324  */
 325 bool sample_session_id_by_name(const char *name, uint64_t *id);
 326
 327 namespace lttng {
 328 namespace sessiond {
 329
 330 /*
 331  * Session list lock must be acquired by the caller.
 332  * The caller must not keep the ownership of the returned locked session
 333  * for longer than strictly necessary. If your intention is to acquire
 334  * a reference to an ltt_session, see `find_session_by_id()`.
 335  */
 336 ltt_session::locked_ptr find_locked_session_by_id(ltt_session::id_t id);
 337
 338 /*
 339  * Session list lock must be acquired by the caller.
 340  * The caller must not keep the ownership of the returned locked session
 341  * for longer than strictly necessary. If your intention is to acquire
 342  * a reference to an ltt_session, see `find_session_by_id()`.
 343  */
 344 ltt_session::sptr find_session_by_id(ltt_session::id_t id);
 345
 346 } /* namespace sessiond */
 347 } /* namespace lttng */
 348
 349 #endif /* _LTT_SESSION_H */