sessiond: notification: use lttng_payload for communications
[lttng-tools.git] / src / bin / lttng-sessiond / notification-thread-internal.h
CommitLineData
8abe313a 1/*
ab5be9fa 2 * Copyright (C) 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
8abe313a 3 *
ab5be9fa 4 * SPDX-License-Identifier: GPL-2.0-only
8abe313a 5 *
8abe313a
JG
6 */
7
8#ifndef NOTIFICATION_THREAD_INTERNAL_H
9#define NOTIFICATION_THREAD_INTERNAL_H
10
f2b3ef9f
JG
11#include <common/compat/socket.h>
12#include <common/credentials.h>
882093ee 13#include <common/payload.h>
f2b3ef9f 14#include <lttng/notification/channel-internal.h>
8abe313a 15#include <lttng/ref-internal.h>
f2b3ef9f 16#include <stdbool.h>
ae0a823f 17#include <unistd.h>
f2b3ef9f
JG
18#include <urcu/rculfhash.h>
19#include <urcu/ref.h>
20#include <urcu/call-rcu.h>
21#include "notification-thread.h"
22
23struct lttng_evaluation;
24struct notification_thread_handle;
8abe313a
JG
25
26struct channel_key {
27 uint64_t key;
28 enum lttng_domain_type domain;
29};
30
31struct session_info {
32 struct lttng_ref ref;
33 char *name;
34 uid_t uid;
35 gid_t gid;
36 /*
c7283958 37 * Hashtable containing back-refs (weak) to all channels in this session.
8abe313a
JG
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;
ea9a44f0 42 struct lttng_session_trigger_list *trigger_list;
8abe313a
JG
43 /* Node in the notification thread state's sessions_ht. */
44 struct cds_lfht_node sessions_ht_node;
1eee26c5
JG
45 /*
46 * Weak reference to the thread state's sessions_ht. Used for removal on
47 * destruction.
48 */
49 struct cds_lfht *sessions_ht;
e8360425 50 uint64_t consumed_data_size;
51eab943
JG
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;
83b934ad
MD
57 /* call_rcu delayed reclaim. */
58 struct rcu_head rcu_node;
8abe313a
JG
59};
60
61struct 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;
83b934ad
MD
74 /* call_rcu delayed reclaim. */
75 struct rcu_head rcu_node;
8abe313a
JG
76};
77
f2b3ef9f
JG
78struct 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 */
102struct 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
114struct notification_client {
6c24d3fd
JG
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 */
f2b3ef9f
JG
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 */
882093ee 160 struct lttng_payload payload;
f2b3ef9f
JG
161 /* Bytes left to receive for the current message. */
162 size_t bytes_to_receive;
882093ee
JR
163 /* FDs left to receive for the current message. */
164 int fds_to_receive;
f2b3ef9f
JG
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;
882093ee 198 struct lttng_payload payload;
f2b3ef9f
JG
199 } outbound;
200 } communication;
201 /* call_rcu delayed reclaim. */
202 struct rcu_head rcu_node;
203};
204
dd877ea6
JG
205enum 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};
f2b3ef9f
JG
213
214LTTNG_HIDDEN
215bool notification_client_list_get(struct notification_client_list *list);
216
217LTTNG_HIDDEN
218void notification_client_list_put(struct notification_client_list *list);
219
6c24d3fd 220/* Only returns a non-zero value if a fatal error occurred. */
f2b3ef9f
JG
221typedef int (*report_client_transmission_result_cb)(
222 struct notification_client *client,
223 enum client_transmission_status status,
224 void *user_data);
225
226LTTNG_HIDDEN
227int 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
236LTTNG_HIDDEN
237int notification_thread_client_communication_update(
238 struct notification_thread_handle *handle,
239 notification_client_id id,
240 enum client_transmission_status transmission_status);
241
8abe313a 242#endif /* NOTIFICATION_THREAD_INTERNAL_H */
This page took 0.063578 seconds and 4 git commands to generate.