src/bin/lttng-relayd/lttng-relayd.h

   1 /*
   2  * Copyright (C) 2012 - Julien Desfossez <jdesfossez@efficios.com>
   3  *                      David Goulet <dgoulet@efficios.com>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License, version 2 only,
   7  * as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #ifndef LTTNG_RELAYD_H
  20 #define LTTNG_RELAYD_H
  21
  22 #define _LGPL_SOURCE
  23 #include <limits.h>
  24 #include <urcu.h>
  25 #include <urcu/wfqueue.h>
  26
  27 #include <common/hashtable/hashtable.h>
  28 #include <common/index/ctf-index.h>
  29
  30 #include "ctf-trace.h"
  31
  32 /*
  33  * Queue used to enqueue relay requests
  34  */
  35 struct relay_cmd_queue {
  36         struct cds_wfq_queue queue;
  37         int32_t futex;
  38 };
  39
  40 enum connection_type {
  41         RELAY_DATA                  = 1,
  42         RELAY_CONTROL               = 2,
  43         RELAY_VIEWER_COMMAND        = 3,
  44         RELAY_VIEWER_NOTIFICATION   = 4,
  45 };
  46
  47 /*
  48  * Represents a session for the relay point of view
  49  */
  50 struct relay_session {
  51         /*
  52          * This session id is used to identify a set of stream to a tracing session
  53          * but also make sure we have a unique session id associated with a session
  54          * daemon which can provide multiple data source.
  55          */
  56         uint64_t id;
  57         struct lttcomm_sock *sock;
  58         char session_name[NAME_MAX];
  59         char hostname[HOST_NAME_MAX];
  60         uint32_t live_timer;
  61         struct lttng_ht_node_ulong session_n;
  62         struct rcu_head rcu_node;
  63         uint32_t viewer_attached;
  64         uint32_t stream_count;
  65         /* Tell if this session is for a snapshot or not. */
  66         unsigned int snapshot:1;
  67
  68         /*
  69          * Indicate version protocol for this session. This is especially useful
  70          * for the data thread that has no idea which version it operates on since
  71          * linking control/data sockets is non trivial.
  72          */
  73         uint64_t minor;
  74         uint64_t major;
  75 };
  76
  77 /*
  78  * Represents a stream in the relay
  79  */
  80 struct relay_stream {
  81         uint64_t stream_handle;
  82         uint64_t prev_seq;      /* previous data sequence number encountered */
  83         struct lttng_ht_node_ulong stream_n;
  84         struct relay_session *session;
  85         struct rcu_head rcu_node;
  86         int fd;
  87         /* FD on which to write the index data. */
  88         int index_fd;
  89         /* FD on which to read the index data for the viewer. */
  90         int read_index_fd;
  91
  92         char *path_name;
  93         char *channel_name;
  94         /* on-disk circular buffer of tracefiles */
  95         uint64_t tracefile_size;
  96         uint64_t tracefile_size_current;
  97         uint64_t tracefile_count;
  98         uint64_t tracefile_count_current;
  99         /* To inform the viewer up to where it can go back in time. */
 100         uint64_t oldest_tracefile_id;
 101
 102         uint64_t total_index_received;
 103         struct relay_viewer_stream *viewer_stream;
 104         uint64_t last_net_seq_num;
 105
 106         /*
 107          * This node is added to the *control* connection hash table and the
 108          * pointer is copied in here so we can access it when deleting this object.
 109          * When deleting this, the ctf trace ht MUST NOT be destroyed. This happens
 110          * at connection deletion.
 111          */
 112         struct lttng_ht_node_str ctf_trace_node;
 113         struct lttng_ht *ctf_traces_ht;
 114
 115         /*
 116          * To protect from concurrent read/update between the
 117          * streaming-side and the viewer-side.
 118          * This lock must be held, we reading/updating the
 119          * ctf_trace pointer.
 120          */
 121         pthread_mutex_t lock;
 122
 123         struct ctf_trace *ctf_trace;
 124         /*
 125          * If the stream is inactive, this field is updated with the live beacon
 126          * timestamp end, when it is active, this field == -1ULL.
 127          */
 128         uint64_t beacon_ts_end;
 129         /*
 130          * To protect the update of the close_write_flag and the checks of
 131          * the tracefile_count_current.
 132          * It is taken before checking whenever we need to know if the
 133          * writer and reader are working in the same tracefile.
 134          */
 135         pthread_mutex_t viewer_stream_rotation_lock;
 136
 137         /* Information telling us when to close the stream  */
 138         unsigned int close_flag:1;
 139         /* Indicate if the stream was initialized for a data pending command. */
 140         unsigned int data_pending_check_done:1;
 141         unsigned int metadata_flag:1;
 142         /*
 143          * To detect when we start overwriting old data, it is used to
 144          * update the oldest_tracefile_id.
 145          */
 146         unsigned int tracefile_overwrite:1;
 147 };
 148
 149 /*
 150  * Shadow copy of the relay_stream structure for the viewer side.  The only
 151  * fields updated by the writer (streaming side) after allocation are :
 152  * total_index_received and close_flag. Everything else is updated by the
 153  * reader (viewer side).
 154  */
 155 struct relay_viewer_stream {
 156         uint64_t stream_handle;
 157         uint64_t session_id;
 158         int read_fd;
 159         int index_read_fd;
 160         char *path_name;
 161         char *channel_name;
 162         uint64_t last_sent_index;
 163         uint64_t total_index_received;
 164         uint64_t tracefile_count;
 165         uint64_t tracefile_count_current;
 166         /* Stop after reading this tracefile. */
 167         uint64_t tracefile_count_last;
 168         struct lttng_ht_node_u64 stream_n;
 169         struct rcu_head rcu_node;
 170         struct ctf_trace *ctf_trace;
 171         /*
 172          * This lock blocks only when the writer is about to start overwriting
 173          * a file currently read by the reader.
 174          *
 175          * This is nested INSIDE the viewer_stream_rotation_lock.
 176          */
 177         pthread_mutex_t overwrite_lock;
 178         /* Information telling us if the stream is a metadata stream. */
 179         unsigned int metadata_flag:1;
 180         /*
 181          * Information telling us that the stream is closed in write, so
 182          * we don't expect new indexes and we can read up to EOF.
 183          */
 184         unsigned int close_write_flag:1;
 185         /*
 186          * If the streaming side closes a FD in use in the viewer side,
 187          * it sets this flag to inform that it is a normal error.
 188          */
 189         unsigned int abort_flag:1;
 190 };
 191
 192 /*
 193  * Internal structure to map a socket with the corresponding session.
 194  * A hashtable indexed on the socket FD is used for the lookups.
 195  */
 196 struct relay_command {
 197         struct lttcomm_sock *sock;
 198         struct relay_session *session;
 199         struct cds_wfq_node node;
 200         struct lttng_ht_node_ulong sock_n;
 201         struct rcu_head rcu_node;
 202         enum connection_type type;
 203         unsigned int version_check_done:1;
 204         /* protocol version to use for this session */
 205         uint32_t major;
 206         uint32_t minor;
 207         struct lttng_ht *ctf_traces_ht; /* indexed by path name */
 208         uint64_t session_id;
 209 };
 210
 211 struct relay_local_data {
 212         struct lttng_ht *sessions_ht;
 213 };
 214
 215 extern char *opt_output_path;
 216
 217 extern struct lttng_ht *relay_streams_ht;
 218 extern struct lttng_ht *viewer_streams_ht;
 219 extern struct lttng_ht *indexes_ht;
 220
 221 extern const char *tracing_group_name;
 222
 223 struct relay_stream *relay_stream_find_by_id(uint64_t stream_id);
 224
 225 #endif /* LTTNG_RELAYD_H */