src/bin/lttng-sessiond/notification-thread-internal.h

   1 /*
   2  * Copyright (C) 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #ifndef NOTIFICATION_THREAD_INTERNAL_H
   9 #define NOTIFICATION_THREAD_INTERNAL_H
  10
  11 #include <common/compat/socket.h>
  12 #include <common/credentials.h>
  13 #include <common/payload.h>
  14 #include <lttng/notification/channel-internal.h>
  15 #include <lttng/ref-internal.h>
  16 #include <stdbool.h>
  17 #include <unistd.h>
  18 #include <urcu/rculfhash.h>
  19 #include <urcu/ref.h>
  20 #include <urcu/call-rcu.h>
  21 #include "notification-thread.h"
  22
  23 struct lttng_evaluation;
  24 struct notification_thread_handle;
  25
  26 struct channel_key {
  27         uint64_t key;
  28         enum lttng_domain_type domain;
  29 };
  30
  31 struct session_info {
  32         struct lttng_ref ref;
  33         char *name;
  34         uid_t uid;
  35         gid_t gid;
  36         /*
  37          * Hashtable containing back-refs (weak) to all channels in this session.
  38          * The hashtable's key is a hash of (struct channel_key) and
  39          * the value is of type (struct channel_info *).
  40          */
  41         struct cds_lfht *channel_infos_ht;
  42         struct lttng_session_trigger_list *trigger_list;
  43         /* Node in the notification thread state's sessions_ht. */
  44         struct cds_lfht_node sessions_ht_node;
  45         /*
  46          * Weak reference to the thread state's sessions_ht. Used for removal on
  47          * destruction.
  48          */
  49         struct cds_lfht *sessions_ht;
  50         uint64_t consumed_data_size;
  51         struct {
  52                 /* Whether a rotation is ongoing for this session. */
  53                 bool ongoing;
  54                 /* Identifier of the currently ongoing rotation. */
  55                 uint64_t id;
  56         } rotation;
  57         /* call_rcu delayed reclaim. */
  58         struct rcu_head rcu_node;
  59 };
  60
  61 struct channel_info {
  62         struct channel_key key;
  63         char *name;
  64         uint64_t capacity;
  65         /*
  66          * A channel info holds a reference (lttng_ref) on session_info.
  67          * session_info, in return, holds a weak reference to the channel.
  68          */
  69         struct session_info *session_info;
  70         /* Node in the notification thread state's channels_ht. */
  71         struct cds_lfht_node channels_ht_node;
  72         /* Node in the session_info's channels_ht. */
  73         struct cds_lfht_node session_info_channels_ht_node;
  74         /* call_rcu delayed reclaim. */
  75         struct rcu_head rcu_node;
  76 };
  77
  78 struct notification_client_list_element {
  79         struct notification_client *client;
  80         struct cds_list_head node;
  81 };
  82
  83 /*
  84  * Thread safety of notification_client and notification_client_list.
  85  *
  86  * The notification thread (main thread) and the action executor
  87  * interact through client lists. Hence, when the action executor
  88  * thread looks-up the list of clients subscribed to a given
  89  * condition, it will acquire a reference to the list and lock it
  90  * while attempting to communicate with the various clients.
  91  *
  92  * It is not necessary to reference-count clients as they are guaranteed
  93  * to be 'alive' if they are present in a list and that list is locked. Indeed,
  94  * removing references to the client from those subscription lists is part of
  95  * the work performed on destruction of a client.
  96  *
  97  * No provision for other access scenarios are taken into account;
  98  * this is the bare minimum to make these accesses safe and the
  99  * notification thread's state is _not_ "thread-safe" in any general
 100  * sense.
 101  */
 102 struct notification_client_list {
 103         pthread_mutex_t lock;
 104         struct urcu_ref ref;
 105         const struct lttng_trigger *trigger;
 106         struct cds_list_head list;
 107         /* Weak reference to container. */
 108         struct cds_lfht *notification_trigger_clients_ht;
 109         struct cds_lfht_node notification_trigger_clients_ht_node;
 110         /* call_rcu delayed reclaim. */
 111         struct rcu_head rcu_node;
 112 };
 113
 114 struct notification_client {
 115         /*
 116          * Nests within the notification_client_list lock.
 117          *
 118          * Protects the outbound communication and the active flag which
 119          * is used by both the notification and action executor threads.
 120          *
 121          * The remaining fields of the object can be used without any
 122          * synchronization as they are either immutable (id, creds, version) or
 123          * only accessed by the notification thread.
 124          */
 125         pthread_mutex_t lock;
 126         notification_client_id id;
 127         int socket;
 128         /* Client protocol version. */
 129         uint8_t major, minor;
 130         uid_t uid;
 131         gid_t gid;
 132         /*
 133          * Indicates if the credentials and versions of the client have been
 134          * checked.
 135          */
 136         bool validated;
 137         /*
 138          * Conditions to which the client's notification channel is subscribed.
 139          * List of struct lttng_condition_list_node. The condition member is
 140          * owned by the client.
 141          */
 142         struct cds_list_head condition_list;
 143         struct cds_lfht_node client_socket_ht_node;
 144         struct cds_lfht_node client_id_ht_node;
 145         struct {
 146                 /*
 147                  * If a client's communication is inactive, it means that a
 148                  * fatal error has occurred (could be either a protocol error or
 149                  * the socket API returned a fatal error). No further
 150                  * communication should be attempted; the client is queued for
 151                  * clean-up.
 152                  */
 153                 bool active;
 154                 struct {
 155                         /*
 156                          * During the reception of a message, the reception
 157                          * buffers' "size" is set to contain the current
 158                          * message's complete payload.
 159                          */
 160                         struct lttng_payload payload;
 161                         /* Bytes left to receive for the current message. */
 162                         size_t bytes_to_receive;
 163                         /* FDs left to receive for the current message. */
 164                         int fds_to_receive;
 165                         /* Type of the message being received. */
 166                         enum lttng_notification_channel_message_type msg_type;
 167                         /*
 168                          * Indicates whether or not credentials are expected
 169                          * from the client.
 170                          */
 171                         bool expect_creds;
 172                         /*
 173                          * Indicates whether or not credentials were received
 174                          * from the client.
 175                          */
 176                         bool creds_received;
 177                         /* Only used during credentials reception. */
 178                         lttng_sock_cred creds;
 179                 } inbound;
 180                 struct {
 181                         /*
 182                          * Indicates whether or not a notification addressed to
 183                          * this client was dropped because a command reply was
 184                          * already buffered.
 185                          *
 186                          * A notification is dropped whenever the buffer is not
 187                          * empty.
 188                          */
 189                         bool dropped_notification;
 190                         /*
 191                          * Indicates whether or not a command reply is already
 192                          * buffered. In this case, it means that the client is
 193                          * not consuming command replies before emitting a new
 194                          * one. This could be caused by a protocol error or a
 195                          * misbehaving/malicious client.
 196                          */
 197                         bool queued_command_reply;
 198                         struct lttng_payload payload;
 199                 } outbound;
 200         } communication;
 201         /* call_rcu delayed reclaim. */
 202         struct rcu_head rcu_node;
 203 };
 204
 205 enum client_transmission_status {
 206         CLIENT_TRANSMISSION_STATUS_COMPLETE,
 207         CLIENT_TRANSMISSION_STATUS_QUEUED,
 208         /* Communication failure. */
 209         CLIENT_TRANSMISSION_STATUS_FAIL,
 210         /* Fatal error. */
 211         CLIENT_TRANSMISSION_STATUS_ERROR,
 212 };
 213
 214 LTTNG_HIDDEN
 215 bool notification_client_list_get(struct notification_client_list *list);
 216
 217 LTTNG_HIDDEN
 218 void notification_client_list_put(struct notification_client_list *list);
 219
 220 /* Only returns a non-zero value if a fatal error occurred. */
 221 typedef int (*report_client_transmission_result_cb)(
 222                 struct notification_client *client,
 223                 enum client_transmission_status status,
 224                 void *user_data);
 225
 226 LTTNG_HIDDEN
 227 int notification_client_list_send_evaluation(
 228                 struct notification_client_list *list,
 229                 const struct lttng_condition *condition,
 230                 const struct lttng_evaluation *evaluation,
 231                 const struct lttng_credentials *trigger_creds,
 232                 const struct lttng_credentials *source_object_creds,
 233                 report_client_transmission_result_cb client_report,
 234                 void *user_data);
 235
 236 LTTNG_HIDDEN
 237 int notification_thread_client_communication_update(
 238                 struct notification_thread_handle *handle,
 239                 notification_client_id id,
 240                 enum client_transmission_status transmission_status);
 241
 242 #endif /* NOTIFICATION_THREAD_INTERNAL_H */