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