Fix: notification: client with uid != trigger uid assert on gid check
[lttng-tools.git] / src / bin / lttng-sessiond / notification-thread-events.c
CommitLineData
ab0ee2ca 1/*
ab5be9fa 2 * Copyright (C) 2017 Jérémie Galarneau <jeremie.galarneau@efficios.com>
ab0ee2ca 3 *
ab5be9fa 4 * SPDX-License-Identifier: GPL-2.0-only
ab0ee2ca 5 *
ab0ee2ca
JG
6 */
7
f2b3ef9f
JG
8#include "lttng/action/action.h"
9#include "lttng/trigger/trigger-internal.h"
ab0ee2ca
JG
10#define _LGPL_SOURCE
11#include <urcu.h>
12#include <urcu/rculfhash.h>
13
ab0ee2ca
JG
14#include <common/defaults.h>
15#include <common/error.h>
16#include <common/futex.h>
17#include <common/unix.h>
18#include <common/dynamic-buffer.h>
19#include <common/hashtable/utils.h>
20#include <common/sessiond-comm/sessiond-comm.h>
21#include <common/macros.h>
22#include <lttng/condition/condition.h>
9b63a4aa 23#include <lttng/action/action-internal.h>
93ac2c44
JR
24#include <lttng/action/group-internal.h>
25#include <lttng/domain-internal.h>
ab0ee2ca
JG
26#include <lttng/notification/notification-internal.h>
27#include <lttng/condition/condition-internal.h>
28#include <lttng/condition/buffer-usage-internal.h>
e8360425 29#include <lttng/condition/session-consumed-size-internal.h>
ea9a44f0 30#include <lttng/condition/session-rotation-internal.h>
e393070a 31#include <lttng/condition/on-event-internal.h>
d02d7404 32#include <lttng/domain-internal.h>
ab0ee2ca 33#include <lttng/notification/channel-internal.h>
85c06c44 34#include <lttng/trigger/trigger-internal.h>
959e3c66 35#include <lttng/event-rule/event-rule-internal.h>
1da26331 36
ab0ee2ca
JG
37#include <time.h>
38#include <unistd.h>
39#include <assert.h>
40#include <inttypes.h>
d53ea4e4 41#include <fcntl.h>
ab0ee2ca 42
e98a976a 43#include "condition-internal.h"
90aa04a1 44#include "event-notifier-error-accounting.h"
1da26331
JG
45#include "notification-thread.h"
46#include "notification-thread-events.h"
47#include "notification-thread-commands.h"
48#include "lttng-sessiond.h"
49#include "kernel.h"
50
ab0ee2ca
JG
51#define CLIENT_POLL_MASK_IN (LPOLLIN | LPOLLERR | LPOLLHUP | LPOLLRDHUP)
52#define CLIENT_POLL_MASK_IN_OUT (CLIENT_POLL_MASK_IN | LPOLLOUT)
53
82b3cbf4
JR
54/* The tracers currently limit the capture size to PIPE_BUF (4kb on linux). */
55#define MAX_CAPTURE_SIZE (PIPE_BUF)
56
51eab943
JG
57enum lttng_object_type {
58 LTTNG_OBJECT_TYPE_UNKNOWN,
59 LTTNG_OBJECT_TYPE_NONE,
60 LTTNG_OBJECT_TYPE_CHANNEL,
61 LTTNG_OBJECT_TYPE_SESSION,
62};
63
ab0ee2ca 64struct lttng_trigger_list_element {
9e0bb80e 65 /* No ownership of the trigger object is assumed. */
f2b3ef9f 66 struct lttng_trigger *trigger;
ab0ee2ca
JG
67 struct cds_list_head node;
68};
69
70struct lttng_channel_trigger_list {
71 struct channel_key channel_key;
ea9a44f0 72 /* List of struct lttng_trigger_list_element. */
ab0ee2ca 73 struct cds_list_head list;
ea9a44f0 74 /* Node in the channel_triggers_ht */
ab0ee2ca 75 struct cds_lfht_node channel_triggers_ht_node;
83b934ad
MD
76 /* call_rcu delayed reclaim. */
77 struct rcu_head rcu_node;
ab0ee2ca
JG
78};
79
ea9a44f0
JG
80/*
81 * List of triggers applying to a given session.
82 *
83 * See:
84 * - lttng_session_trigger_list_create()
85 * - lttng_session_trigger_list_build()
86 * - lttng_session_trigger_list_destroy()
87 * - lttng_session_trigger_list_add()
88 */
89struct lttng_session_trigger_list {
90 /*
91 * Not owned by this; points to the session_info structure's
92 * session name.
93 */
94 const char *session_name;
95 /* List of struct lttng_trigger_list_element. */
96 struct cds_list_head list;
97 /* Node in the session_triggers_ht */
98 struct cds_lfht_node session_triggers_ht_node;
99 /*
100 * Weak reference to the notification system's session triggers
101 * hashtable.
102 *
103 * The session trigger list structure structure is owned by
104 * the session's session_info.
105 *
106 * The session_info is kept alive the the channel_infos holding a
107 * reference to it (reference counting). When those channels are
108 * destroyed (at runtime or on teardown), the reference they hold
109 * to the session_info are released. On destruction of session_info,
110 * session_info_destroy() will remove the list of triggers applying
111 * to this session from the notification system's state.
112 *
113 * This implies that the session_triggers_ht must be destroyed
114 * after the channels.
115 */
116 struct cds_lfht *session_triggers_ht;
117 /* Used for delayed RCU reclaim. */
118 struct rcu_head rcu_node;
119};
120
ab0ee2ca
JG
121struct lttng_trigger_ht_element {
122 struct lttng_trigger *trigger;
123 struct cds_lfht_node node;
242388e4 124 struct cds_lfht_node node_by_name_uid;
091fa780 125 struct cds_list_head client_list_trigger_node;
83b934ad
MD
126 /* call_rcu delayed reclaim. */
127 struct rcu_head rcu_node;
ab0ee2ca
JG
128};
129
130struct lttng_condition_list_element {
131 struct lttng_condition *condition;
132 struct cds_list_head node;
133};
134
ab0ee2ca
JG
135struct channel_state_sample {
136 struct channel_key key;
137 struct cds_lfht_node channel_state_ht_node;
138 uint64_t highest_usage;
139 uint64_t lowest_usage;
e8360425 140 uint64_t channel_total_consumed;
83b934ad
MD
141 /* call_rcu delayed reclaim. */
142 struct rcu_head rcu_node;
ab0ee2ca
JG
143};
144
e4db5ace 145static unsigned long hash_channel_key(struct channel_key *key);
ed327204 146static int evaluate_buffer_condition(const struct lttng_condition *condition,
e4db5ace 147 struct lttng_evaluation **evaluation,
e8360425
JD
148 const struct notification_thread_state *state,
149 const struct channel_state_sample *previous_sample,
150 const struct channel_state_sample *latest_sample,
151 uint64_t previous_session_consumed_total,
152 uint64_t latest_session_consumed_total,
153 struct channel_info *channel_info);
e4db5ace 154static
9b63a4aa
JG
155int send_evaluation_to_clients(const struct lttng_trigger *trigger,
156 const struct lttng_evaluation *evaluation,
e4db5ace
JR
157 struct notification_client_list *client_list,
158 struct notification_thread_state *state,
159 uid_t channel_uid, gid_t channel_gid);
160
8abe313a 161
ea9a44f0 162/* session_info API */
8abe313a
JG
163static
164void session_info_destroy(void *_data);
165static
166void session_info_get(struct session_info *session_info);
167static
168void session_info_put(struct session_info *session_info);
169static
170struct session_info *session_info_create(const char *name,
ea9a44f0 171 uid_t uid, gid_t gid,
1eee26c5
JG
172 struct lttng_session_trigger_list *trigger_list,
173 struct cds_lfht *sessions_ht);
8abe313a
JG
174static
175void session_info_add_channel(struct session_info *session_info,
176 struct channel_info *channel_info);
177static
178void session_info_remove_channel(struct session_info *session_info,
179 struct channel_info *channel_info);
180
ea9a44f0
JG
181/* lttng_session_trigger_list API */
182static
183struct lttng_session_trigger_list *lttng_session_trigger_list_create(
184 const char *session_name,
185 struct cds_lfht *session_triggers_ht);
186static
187struct lttng_session_trigger_list *lttng_session_trigger_list_build(
188 const struct notification_thread_state *state,
189 const char *session_name);
190static
191void lttng_session_trigger_list_destroy(
192 struct lttng_session_trigger_list *list);
193static
194int lttng_session_trigger_list_add(struct lttng_session_trigger_list *list,
f2b3ef9f 195 struct lttng_trigger *trigger);
ea9a44f0 196
f2b3ef9f
JG
197static
198int client_handle_transmission_status(
199 struct notification_client *client,
200 enum client_transmission_status transmission_status,
201 struct notification_thread_state *state);
ea9a44f0 202
8b524060
FD
203static
204int handle_one_event_notifier_notification(
205 struct notification_thread_state *state,
206 int pipe, enum lttng_domain_type domain);
207
242388e4
JR
208static
209void free_lttng_trigger_ht_element_rcu(struct rcu_head *node);
210
ab0ee2ca 211static
ac1889bf 212int match_client_socket(struct cds_lfht_node *node, const void *key)
ab0ee2ca
JG
213{
214 /* This double-cast is intended to supress pointer-to-cast warning. */
ac1889bf
JG
215 const int socket = (int) (intptr_t) key;
216 const struct notification_client *client = caa_container_of(node,
217 struct notification_client, client_socket_ht_node);
ab0ee2ca 218
ac1889bf
JG
219 return client->socket == socket;
220}
221
222static
223int match_client_id(struct cds_lfht_node *node, const void *key)
224{
225 /* This double-cast is intended to supress pointer-to-cast warning. */
226 const notification_client_id id = *((notification_client_id *) key);
227 const struct notification_client *client = caa_container_of(
228 node, struct notification_client, client_id_ht_node);
ab0ee2ca 229
ac1889bf 230 return client->id == id;
ab0ee2ca
JG
231}
232
233static
234int match_channel_trigger_list(struct cds_lfht_node *node, const void *key)
235{
236 struct channel_key *channel_key = (struct channel_key *) key;
237 struct lttng_channel_trigger_list *trigger_list;
238
239 trigger_list = caa_container_of(node, struct lttng_channel_trigger_list,
240 channel_triggers_ht_node);
241
242 return !!((channel_key->key == trigger_list->channel_key.key) &&
243 (channel_key->domain == trigger_list->channel_key.domain));
244}
245
51eab943
JG
246static
247int match_session_trigger_list(struct cds_lfht_node *node, const void *key)
248{
249 const char *session_name = (const char *) key;
250 struct lttng_session_trigger_list *trigger_list;
251
252 trigger_list = caa_container_of(node, struct lttng_session_trigger_list,
253 session_triggers_ht_node);
254
255 return !!(strcmp(trigger_list->session_name, session_name) == 0);
256}
257
ab0ee2ca
JG
258static
259int match_channel_state_sample(struct cds_lfht_node *node, const void *key)
260{
261 struct channel_key *channel_key = (struct channel_key *) key;
262 struct channel_state_sample *sample;
263
264 sample = caa_container_of(node, struct channel_state_sample,
265 channel_state_ht_node);
266
267 return !!((channel_key->key == sample->key.key) &&
268 (channel_key->domain == sample->key.domain));
269}
270
271static
272int match_channel_info(struct cds_lfht_node *node, const void *key)
273{
274 struct channel_key *channel_key = (struct channel_key *) key;
275 struct channel_info *channel_info;
276
277 channel_info = caa_container_of(node, struct channel_info,
278 channels_ht_node);
279
280 return !!((channel_key->key == channel_info->key.key) &&
281 (channel_key->domain == channel_info->key.domain));
282}
283
284static
242388e4 285int match_trigger(struct cds_lfht_node *node, const void *key)
ab0ee2ca 286{
242388e4
JR
287 struct lttng_trigger *trigger_key = (struct lttng_trigger *) key;
288 struct lttng_trigger_ht_element *trigger_ht_element;
ab0ee2ca 289
242388e4 290 trigger_ht_element = caa_container_of(node, struct lttng_trigger_ht_element,
ab0ee2ca 291 node);
ab0ee2ca 292
242388e4 293 return !!lttng_trigger_is_equal(trigger_key, trigger_ht_element->trigger);
ab0ee2ca
JG
294}
295
e7c93cf9
JR
296static
297int match_trigger_token(struct cds_lfht_node *node, const void *key)
298{
299 const uint64_t *_key = key;
300 struct notification_trigger_tokens_ht_element *element;
301
302 element = caa_container_of(node,
303 struct notification_trigger_tokens_ht_element, node);
304 return *_key == element->token;
305}
306
ab0ee2ca
JG
307static
308int match_client_list_condition(struct cds_lfht_node *node, const void *key)
309{
310 struct lttng_condition *condition_key = (struct lttng_condition *) key;
311 struct notification_client_list *client_list;
f82f93a1 312 const struct lttng_condition *condition;
ab0ee2ca
JG
313
314 assert(condition_key);
315
316 client_list = caa_container_of(node, struct notification_client_list,
505b2d90 317 notification_trigger_clients_ht_node);
091fa780 318 condition = client_list->condition;
ab0ee2ca
JG
319
320 return !!lttng_condition_is_equal(condition_key, condition);
321}
322
f82f93a1
JG
323static
324int match_session(struct cds_lfht_node *node, const void *key)
325{
326 const char *name = key;
327 struct session_info *session_info = caa_container_of(
328 node, struct session_info, sessions_ht_node);
329
330 return !strcmp(session_info->name, name);
331}
332
6900ae81
FD
333static
334const char *notification_command_type_str(
335 enum notification_thread_command_type type)
336{
337 switch (type) {
338 case NOTIFICATION_COMMAND_TYPE_REGISTER_TRIGGER:
339 return "REGISTER_TRIGGER";
340 case NOTIFICATION_COMMAND_TYPE_UNREGISTER_TRIGGER:
341 return "UNREGISTER_TRIGGER";
342 case NOTIFICATION_COMMAND_TYPE_ADD_CHANNEL:
343 return "ADD_CHANNEL";
344 case NOTIFICATION_COMMAND_TYPE_REMOVE_CHANNEL:
345 return "REMOVE_CHANNEL";
346 case NOTIFICATION_COMMAND_TYPE_SESSION_ROTATION_ONGOING:
347 return "SESSION_ROTATION_ONGOING";
348 case NOTIFICATION_COMMAND_TYPE_SESSION_ROTATION_COMPLETED:
349 return "SESSION_ROTATION_COMPLETED";
350 case NOTIFICATION_COMMAND_TYPE_ADD_TRACER_EVENT_SOURCE:
351 return "ADD_TRACER_EVENT_SOURCE";
352 case NOTIFICATION_COMMAND_TYPE_REMOVE_TRACER_EVENT_SOURCE:
353 return "REMOVE_TRACER_EVENT_SOURCE";
354 case NOTIFICATION_COMMAND_TYPE_LIST_TRIGGERS:
355 return "LIST_TRIGGERS";
356 case NOTIFICATION_COMMAND_TYPE_QUIT:
357 return "QUIT";
358 case NOTIFICATION_COMMAND_TYPE_CLIENT_COMMUNICATION_UPDATE:
359 return "CLIENT_COMMUNICATION_UPDATE";
360 default:
361 abort();
362 }
363}
364
242388e4
JR
365/*
366 * Match trigger based on name and credentials only.
367 * Name duplication is NOT allowed for the same uid.
368 */
369static
370int match_trigger_by_name_uid(struct cds_lfht_node *node,
371 const void *key)
372{
373 bool match = false;
374 const char *name;
375 const char *key_name;
376 enum lttng_trigger_status status;
377 const struct lttng_credentials *key_creds;
378 const struct lttng_credentials *node_creds;
379 const struct lttng_trigger *trigger_key =
380 (const struct lttng_trigger *) key;
381 const struct lttng_trigger_ht_element *trigger_ht_element =
382 caa_container_of(node,
383 struct lttng_trigger_ht_element,
384 node_by_name_uid);
385
386 status = lttng_trigger_get_name(trigger_ht_element->trigger, &name);
387 assert(status == LTTNG_TRIGGER_STATUS_OK);
388
389 status = lttng_trigger_get_name(trigger_key, &key_name);
390 assert(status == LTTNG_TRIGGER_STATUS_OK);
391
392 /* Compare the names. */
393 if (strcmp(name, key_name) != 0) {
394 goto end;
395 }
396
397 /* Compare the owners' UIDs. */
398 key_creds = lttng_trigger_get_credentials(trigger_key);
399 node_creds = lttng_trigger_get_credentials(trigger_ht_element->trigger);
400
401 match = lttng_credentials_is_equal_uid(key_creds, node_creds);
402
403end:
404 return match;
405}
406
407/*
408 * Hash trigger based on name and credentials only.
409 */
410static
411unsigned long hash_trigger_by_name_uid(const struct lttng_trigger *trigger)
412{
413 unsigned long hash = 0;
414 const struct lttng_credentials *trigger_creds;
415 const char *trigger_name;
416 enum lttng_trigger_status status;
417
418 status = lttng_trigger_get_name(trigger, &trigger_name);
419 if (status == LTTNG_TRIGGER_STATUS_OK) {
420 hash = hash_key_str(trigger_name, lttng_ht_seed);
421 }
422
423 trigger_creds = lttng_trigger_get_credentials(trigger);
424 hash ^= hash_key_ulong((void *) (unsigned long) LTTNG_OPTIONAL_GET(trigger_creds->uid),
425 lttng_ht_seed);
426
427 return hash;
428}
429
e4db5ace
JR
430static
431unsigned long hash_channel_key(struct channel_key *key)
432{
433 unsigned long key_hash = hash_key_u64(&key->key, lttng_ht_seed);
434 unsigned long domain_hash = hash_key_ulong(
435 (void *) (unsigned long) key->domain, lttng_ht_seed);
436
437 return key_hash ^ domain_hash;
438}
439
ac1889bf
JG
440static
441unsigned long hash_client_socket(int socket)
442{
443 return hash_key_ulong((void *) (unsigned long) socket, lttng_ht_seed);
444}
445
446static
447unsigned long hash_client_id(notification_client_id id)
448{
449 return hash_key_u64(&id, lttng_ht_seed);
450}
451
f82f93a1
JG
452/*
453 * Get the type of object to which a given condition applies. Bindings let
454 * the notification system evaluate a trigger's condition when a given
455 * object's state is updated.
456 *
457 * For instance, a condition bound to a channel will be evaluated everytime
458 * the channel's state is changed by a channel monitoring sample.
459 */
460static
461enum lttng_object_type get_condition_binding_object(
462 const struct lttng_condition *condition)
463{
464 switch (lttng_condition_get_type(condition)) {
465 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW:
466 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH:
467 case LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE:
e742b055 468 return LTTNG_OBJECT_TYPE_CHANNEL;
f82f93a1
JG
469 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_ONGOING:
470 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_COMPLETED:
471 return LTTNG_OBJECT_TYPE_SESSION;
d602bd6a 472 case LTTNG_CONDITION_TYPE_ON_EVENT:
959e3c66 473 return LTTNG_OBJECT_TYPE_NONE;
f82f93a1
JG
474 default:
475 return LTTNG_OBJECT_TYPE_UNKNOWN;
476 }
477}
478
83b934ad
MD
479static
480void free_channel_info_rcu(struct rcu_head *node)
481{
482 free(caa_container_of(node, struct channel_info, rcu_node));
483}
484
ab0ee2ca
JG
485static
486void channel_info_destroy(struct channel_info *channel_info)
487{
488 if (!channel_info) {
489 return;
490 }
491
8abe313a
JG
492 if (channel_info->session_info) {
493 session_info_remove_channel(channel_info->session_info,
494 channel_info);
495 session_info_put(channel_info->session_info);
ab0ee2ca 496 }
8abe313a
JG
497 if (channel_info->name) {
498 free(channel_info->name);
ab0ee2ca 499 }
83b934ad
MD
500 call_rcu(&channel_info->rcu_node, free_channel_info_rcu);
501}
502
503static
504void free_session_info_rcu(struct rcu_head *node)
505{
506 free(caa_container_of(node, struct session_info, rcu_node));
ab0ee2ca
JG
507}
508
8abe313a 509/* Don't call directly, use the ref-counting mechanism. */
ab0ee2ca 510static
8abe313a 511void session_info_destroy(void *_data)
ab0ee2ca 512{
8abe313a 513 struct session_info *session_info = _data;
3b68d0a3 514 int ret;
ab0ee2ca 515
8abe313a
JG
516 assert(session_info);
517 if (session_info->channel_infos_ht) {
3b68d0a3
JR
518 ret = cds_lfht_destroy(session_info->channel_infos_ht, NULL);
519 if (ret) {
4c3f302b 520 ERR("[notification-thread] Failed to destroy channel information hash table");
3b68d0a3 521 }
8abe313a 522 }
ea9a44f0 523 lttng_session_trigger_list_destroy(session_info->trigger_list);
1eee26c5
JG
524
525 rcu_read_lock();
526 cds_lfht_del(session_info->sessions_ht,
527 &session_info->sessions_ht_node);
528 rcu_read_unlock();
8abe313a 529 free(session_info->name);
83b934ad 530 call_rcu(&session_info->rcu_node, free_session_info_rcu);
8abe313a 531}
ab0ee2ca 532
8abe313a
JG
533static
534void session_info_get(struct session_info *session_info)
535{
536 if (!session_info) {
537 return;
538 }
539 lttng_ref_get(&session_info->ref);
540}
541
542static
543void session_info_put(struct session_info *session_info)
544{
545 if (!session_info) {
546 return;
ab0ee2ca 547 }
8abe313a
JG
548 lttng_ref_put(&session_info->ref);
549}
550
551static
ea9a44f0 552struct session_info *session_info_create(const char *name, uid_t uid, gid_t gid,
1eee26c5
JG
553 struct lttng_session_trigger_list *trigger_list,
554 struct cds_lfht *sessions_ht)
8abe313a
JG
555{
556 struct session_info *session_info;
ab0ee2ca 557
8abe313a 558 assert(name);
ab0ee2ca 559
8abe313a
JG
560 session_info = zmalloc(sizeof(*session_info));
561 if (!session_info) {
562 goto end;
563 }
564 lttng_ref_init(&session_info->ref, session_info_destroy);
565
566 session_info->channel_infos_ht = cds_lfht_new(DEFAULT_HT_SIZE,
567 1, 0, CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL);
568 if (!session_info->channel_infos_ht) {
ab0ee2ca
JG
569 goto error;
570 }
8abe313a
JG
571
572 cds_lfht_node_init(&session_info->sessions_ht_node);
573 session_info->name = strdup(name);
574 if (!session_info->name) {
ab0ee2ca
JG
575 goto error;
576 }
8abe313a
JG
577 session_info->uid = uid;
578 session_info->gid = gid;
ea9a44f0 579 session_info->trigger_list = trigger_list;
1eee26c5 580 session_info->sessions_ht = sessions_ht;
8abe313a
JG
581end:
582 return session_info;
583error:
584 session_info_put(session_info);
585 return NULL;
586}
587
588static
589void session_info_add_channel(struct session_info *session_info,
590 struct channel_info *channel_info)
591{
592 rcu_read_lock();
593 cds_lfht_add(session_info->channel_infos_ht,
594 hash_channel_key(&channel_info->key),
595 &channel_info->session_info_channels_ht_node);
596 rcu_read_unlock();
597}
598
599static
600void session_info_remove_channel(struct session_info *session_info,
601 struct channel_info *channel_info)
602{
603 rcu_read_lock();
604 cds_lfht_del(session_info->channel_infos_ht,
605 &channel_info->session_info_channels_ht_node);
606 rcu_read_unlock();
607}
608
609static
610struct channel_info *channel_info_create(const char *channel_name,
611 struct channel_key *channel_key, uint64_t channel_capacity,
612 struct session_info *session_info)
613{
614 struct channel_info *channel_info = zmalloc(sizeof(*channel_info));
615
616 if (!channel_info) {
617 goto end;
618 }
619
ab0ee2ca 620 cds_lfht_node_init(&channel_info->channels_ht_node);
8abe313a
JG
621 cds_lfht_node_init(&channel_info->session_info_channels_ht_node);
622 memcpy(&channel_info->key, channel_key, sizeof(*channel_key));
623 channel_info->capacity = channel_capacity;
624
625 channel_info->name = strdup(channel_name);
626 if (!channel_info->name) {
627 goto error;
628 }
629
630 /*
631 * Set the references between session and channel infos:
632 * - channel_info holds a strong reference to session_info
633 * - session_info holds a weak reference to channel_info
634 */
635 session_info_get(session_info);
636 session_info_add_channel(session_info, channel_info);
637 channel_info->session_info = session_info;
ab0ee2ca 638end:
8abe313a 639 return channel_info;
ab0ee2ca 640error:
8abe313a 641 channel_info_destroy(channel_info);
ab0ee2ca
JG
642 return NULL;
643}
644
f2b3ef9f 645LTTNG_HIDDEN
505b2d90
JG
646bool notification_client_list_get(struct notification_client_list *list)
647{
648 return urcu_ref_get_unless_zero(&list->ref);
649}
650
651static
652void free_notification_client_list_rcu(struct rcu_head *node)
653{
654 free(caa_container_of(node, struct notification_client_list,
655 rcu_node));
656}
657
658static
659void notification_client_list_release(struct urcu_ref *list_ref)
660{
661 struct notification_client_list *list =
662 container_of(list_ref, typeof(*list), ref);
663 struct notification_client_list_element *client_list_element, *tmp;
664
091fa780
FD
665 lttng_condition_put(list->condition);
666
505b2d90
JG
667 if (list->notification_trigger_clients_ht) {
668 rcu_read_lock();
091fa780 669
505b2d90
JG
670 cds_lfht_del(list->notification_trigger_clients_ht,
671 &list->notification_trigger_clients_ht_node);
672 rcu_read_unlock();
673 list->notification_trigger_clients_ht = NULL;
674 }
675 cds_list_for_each_entry_safe(client_list_element, tmp,
091fa780 676 &list->clients_list, node) {
505b2d90
JG
677 free(client_list_element);
678 }
091fa780
FD
679
680 assert(cds_list_empty(&list->triggers_list));
681
505b2d90
JG
682 pthread_mutex_destroy(&list->lock);
683 call_rcu(&list->rcu_node, free_notification_client_list_rcu);
684}
685
091fa780
FD
686static
687bool condition_applies_to_client(const struct lttng_condition *condition,
688 struct notification_client *client)
689{
690 bool applies = false;
691 struct lttng_condition_list_element *condition_list_element;
692
693 cds_list_for_each_entry(condition_list_element, &client->condition_list,
694 node) {
695 applies = lttng_condition_is_equal(
696 condition_list_element->condition,
697 condition);
698 if (applies) {
699 break;
700 }
701 }
702
703 return applies;
704}
705
505b2d90
JG
706static
707struct notification_client_list *notification_client_list_create(
091fa780
FD
708 struct notification_thread_state *state,
709 const struct lttng_condition *condition)
505b2d90 710{
091fa780
FD
711 struct notification_client *client;
712 struct cds_lfht_iter iter;
713 struct notification_client_list *client_list;
505b2d90 714
091fa780 715 client_list = zmalloc(sizeof(*client_list));
505b2d90 716 if (!client_list) {
091fa780
FD
717 PERROR("Failed to allocate notification client list");
718 goto end;
505b2d90 719 }
091fa780 720
505b2d90 721 pthread_mutex_init(&client_list->lock, NULL);
091fa780
FD
722 /*
723 * The trigger that owns the condition has the first reference to this
724 * client list.
725 */
505b2d90
JG
726 urcu_ref_init(&client_list->ref);
727 cds_lfht_node_init(&client_list->notification_trigger_clients_ht_node);
091fa780
FD
728 CDS_INIT_LIST_HEAD(&client_list->clients_list);
729 CDS_INIT_LIST_HEAD(&client_list->triggers_list);
505b2d90 730
091fa780
FD
731 /*
732 * Create a copy of the condition so that it's independent of any
733 * trigger. The client list may outlive the trigger object (which owns
734 * the condition) that is used to create it.
735 */
736 client_list->condition = lttng_condition_copy(condition);
737
738 /* Build a list of clients to which this new condition applies. */
739 cds_lfht_for_each_entry (state->client_socket_ht, &iter, client,
740 client_socket_ht_node) {
741 struct notification_client_list_element *client_list_element;
505b2d90 742
091fa780
FD
743 if (!condition_applies_to_client(condition, client)) {
744 continue;
745 }
746
747 client_list_element = zmalloc(sizeof(*client_list_element));
748 if (!client_list_element) {
749 goto error_put_client_list;
750 }
505b2d90 751
091fa780
FD
752 CDS_INIT_LIST_HEAD(&client_list_element->node);
753 client_list_element->client = client;
754 cds_list_add(&client_list_element->node, &client_list->clients_list);
755 }
756
757 client_list->notification_trigger_clients_ht =
505b2d90
JG
758 state->notification_trigger_clients_ht;
759
760 rcu_read_lock();
091fa780
FD
761 /*
762 * Add the client list to the global list of client list.
763 */
764 cds_lfht_add_unique(state->notification_trigger_clients_ht,
765 lttng_condition_hash(client_list->condition),
766 match_client_list_condition,
767 client_list->condition,
768 &client_list->notification_trigger_clients_ht_node);
505b2d90 769 rcu_read_unlock();
091fa780
FD
770 goto end;
771
772error_put_client_list:
773 notification_client_list_put(client_list);
774 client_list = NULL;
775
776end:
777 return client_list;
505b2d90
JG
778}
779
505b2d90
JG
780void notification_client_list_put(struct notification_client_list *list)
781{
782 if (!list) {
783 return;
784 }
785 return urcu_ref_put(&list->ref, notification_client_list_release);
786}
787
788/* Provides a reference to the returned list. */
ed327204
JG
789static
790struct notification_client_list *get_client_list_from_condition(
791 struct notification_thread_state *state,
792 const struct lttng_condition *condition)
793{
794 struct cds_lfht_node *node;
795 struct cds_lfht_iter iter;
505b2d90 796 struct notification_client_list *list = NULL;
ed327204 797
505b2d90 798 rcu_read_lock();
ed327204
JG
799 cds_lfht_lookup(state->notification_trigger_clients_ht,
800 lttng_condition_hash(condition),
801 match_client_list_condition,
802 condition,
803 &iter);
804 node = cds_lfht_iter_get_node(&iter);
505b2d90
JG
805 if (node) {
806 list = container_of(node, struct notification_client_list,
807 notification_trigger_clients_ht_node);
808 list = notification_client_list_get(list) ? list : NULL;
809 }
ed327204 810
505b2d90
JG
811 rcu_read_unlock();
812 return list;
ed327204
JG
813}
814
e4db5ace 815static
f82f93a1
JG
816int evaluate_channel_condition_for_client(
817 const struct lttng_condition *condition,
818 struct notification_thread_state *state,
819 struct lttng_evaluation **evaluation,
820 uid_t *session_uid, gid_t *session_gid)
e4db5ace
JR
821{
822 int ret;
823 struct cds_lfht_iter iter;
824 struct cds_lfht_node *node;
825 struct channel_info *channel_info = NULL;
826 struct channel_key *channel_key = NULL;
827 struct channel_state_sample *last_sample = NULL;
828 struct lttng_channel_trigger_list *channel_trigger_list = NULL;
e4db5ace 829
505b2d90
JG
830 rcu_read_lock();
831
f82f93a1 832 /* Find the channel associated with the condition. */
e4db5ace 833 cds_lfht_for_each_entry(state->channel_triggers_ht, &iter,
f82f93a1 834 channel_trigger_list, channel_triggers_ht_node) {
e4db5ace
JR
835 struct lttng_trigger_list_element *element;
836
837 cds_list_for_each_entry(element, &channel_trigger_list->list, node) {
9b63a4aa 838 const struct lttng_condition *current_condition =
f82f93a1 839 lttng_trigger_get_const_condition(
e4db5ace
JR
840 element->trigger);
841
842 assert(current_condition);
843 if (!lttng_condition_is_equal(condition,
2ae99f0b 844 current_condition)) {
e4db5ace
JR
845 continue;
846 }
847
848 /* Found the trigger, save the channel key. */
849 channel_key = &channel_trigger_list->channel_key;
850 break;
851 }
852 if (channel_key) {
853 /* The channel key was found stop iteration. */
854 break;
855 }
856 }
857
858 if (!channel_key){
859 /* No channel found; normal exit. */
f82f93a1 860 DBG("[notification-thread] No known channel associated with newly subscribed-to condition");
e4db5ace
JR
861 ret = 0;
862 goto end;
863 }
864
865 /* Fetch channel info for the matching channel. */
866 cds_lfht_lookup(state->channels_ht,
867 hash_channel_key(channel_key),
868 match_channel_info,
869 channel_key,
870 &iter);
871 node = cds_lfht_iter_get_node(&iter);
872 assert(node);
873 channel_info = caa_container_of(node, struct channel_info,
874 channels_ht_node);
875
876 /* Retrieve the channel's last sample, if it exists. */
877 cds_lfht_lookup(state->channel_state_ht,
878 hash_channel_key(channel_key),
879 match_channel_state_sample,
880 channel_key,
881 &iter);
882 node = cds_lfht_iter_get_node(&iter);
883 if (node) {
884 last_sample = caa_container_of(node,
885 struct channel_state_sample,
886 channel_state_ht_node);
887 } else {
888 /* Nothing to evaluate, no sample was ever taken. Normal exit */
889 DBG("[notification-thread] No channel sample associated with newly subscribed-to condition");
890 ret = 0;
891 goto end;
892 }
893
f82f93a1 894 ret = evaluate_buffer_condition(condition, evaluation, state,
e8360425
JD
895 NULL, last_sample,
896 0, channel_info->session_info->consumed_data_size,
897 channel_info);
e4db5ace 898 if (ret) {
066a3c82 899 WARN("[notification-thread] Fatal error occurred while evaluating a newly subscribed-to condition");
e4db5ace
JR
900 goto end;
901 }
902
f82f93a1
JG
903 *session_uid = channel_info->session_info->uid;
904 *session_gid = channel_info->session_info->gid;
905end:
505b2d90 906 rcu_read_unlock();
f82f93a1
JG
907 return ret;
908}
909
910static
911const char *get_condition_session_name(const struct lttng_condition *condition)
912{
913 const char *session_name = NULL;
914 enum lttng_condition_status status;
915
916 switch (lttng_condition_get_type(condition)) {
917 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW:
918 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH:
919 status = lttng_condition_buffer_usage_get_session_name(
920 condition, &session_name);
921 break;
922 case LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE:
923 status = lttng_condition_session_consumed_size_get_session_name(
924 condition, &session_name);
925 break;
926 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_ONGOING:
927 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_COMPLETED:
928 status = lttng_condition_session_rotation_get_session_name(
929 condition, &session_name);
930 break;
931 default:
932 abort();
933 }
934 if (status != LTTNG_CONDITION_STATUS_OK) {
935 ERR("[notification-thread] Failed to retrieve session rotation condition's session name");
936 goto end;
937 }
938end:
939 return session_name;
940}
941
f82f93a1
JG
942static
943int evaluate_session_condition_for_client(
944 const struct lttng_condition *condition,
945 struct notification_thread_state *state,
946 struct lttng_evaluation **evaluation,
947 uid_t *session_uid, gid_t *session_gid)
948{
949 int ret;
950 struct cds_lfht_iter iter;
951 struct cds_lfht_node *node;
952 const char *session_name;
953 struct session_info *session_info = NULL;
954
505b2d90 955 rcu_read_lock();
f82f93a1
JG
956 session_name = get_condition_session_name(condition);
957
958 /* Find the session associated with the trigger. */
959 cds_lfht_lookup(state->sessions_ht,
960 hash_key_str(session_name, lttng_ht_seed),
961 match_session,
962 session_name,
963 &iter);
964 node = cds_lfht_iter_get_node(&iter);
965 if (!node) {
966 DBG("[notification-thread] No known session matching name \"%s\"",
967 session_name);
968 ret = 0;
969 goto end;
970 }
971
972 session_info = caa_container_of(node, struct session_info,
973 sessions_ht_node);
974 session_info_get(session_info);
975
976 /*
977 * Evaluation is performed in-line here since only one type of
978 * session-bound condition is handled for the moment.
979 */
980 switch (lttng_condition_get_type(condition)) {
981 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_ONGOING:
982 if (!session_info->rotation.ongoing) {
be558f88 983 ret = 0;
f82f93a1
JG
984 goto end_session_put;
985 }
986
987 *evaluation = lttng_evaluation_session_rotation_ongoing_create(
988 session_info->rotation.id);
989 if (!*evaluation) {
990 /* Fatal error. */
991 ERR("[notification-thread] Failed to create session rotation ongoing evaluation for session \"%s\"",
992 session_info->name);
993 ret = -1;
994 goto end_session_put;
995 }
996 ret = 0;
997 break;
998 default:
999 ret = 0;
1000 goto end_session_put;
1001 }
1002
1003 *session_uid = session_info->uid;
1004 *session_gid = session_info->gid;
1005
1006end_session_put:
1007 session_info_put(session_info);
1008end:
505b2d90 1009 rcu_read_unlock();
f82f93a1
JG
1010 return ret;
1011}
1012
f82f93a1
JG
1013static
1014int evaluate_condition_for_client(const struct lttng_trigger *trigger,
1015 const struct lttng_condition *condition,
1016 struct notification_client *client,
1017 struct notification_thread_state *state)
1018{
1019 int ret;
1020 struct lttng_evaluation *evaluation = NULL;
505b2d90
JG
1021 struct notification_client_list client_list = {
1022 .lock = PTHREAD_MUTEX_INITIALIZER,
1023 };
f82f93a1
JG
1024 struct notification_client_list_element client_list_element = { 0 };
1025 uid_t object_uid = 0;
1026 gid_t object_gid = 0;
1027
1028 assert(trigger);
1029 assert(condition);
1030 assert(client);
1031 assert(state);
1032
1033 switch (get_condition_binding_object(condition)) {
1034 case LTTNG_OBJECT_TYPE_SESSION:
1035 ret = evaluate_session_condition_for_client(condition, state,
1036 &evaluation, &object_uid, &object_gid);
1037 break;
1038 case LTTNG_OBJECT_TYPE_CHANNEL:
1039 ret = evaluate_channel_condition_for_client(condition, state,
1040 &evaluation, &object_uid, &object_gid);
1041 break;
1042 case LTTNG_OBJECT_TYPE_NONE:
7e802d0a 1043 DBG("[notification-thread] Newly subscribed-to condition not bound to object, nothing to evaluate");
f82f93a1
JG
1044 ret = 0;
1045 goto end;
1046 case LTTNG_OBJECT_TYPE_UNKNOWN:
1047 default:
1048 ret = -1;
1049 goto end;
1050 }
af0c318d
JG
1051 if (ret) {
1052 /* Fatal error. */
1053 goto end;
1054 }
e4db5ace
JR
1055 if (!evaluation) {
1056 /* Evaluation yielded nothing. Normal exit. */
1057 DBG("[notification-thread] Newly subscribed-to condition evaluated to false, nothing to report to client");
1058 ret = 0;
1059 goto end;
1060 }
1061
1062 /*
1063 * Create a temporary client list with the client currently
1064 * subscribing.
1065 */
505b2d90 1066 cds_lfht_node_init(&client_list.notification_trigger_clients_ht_node);
091fa780 1067 CDS_INIT_LIST_HEAD(&client_list.clients_list);
e4db5ace
JR
1068
1069 CDS_INIT_LIST_HEAD(&client_list_element.node);
1070 client_list_element.client = client;
091fa780 1071 cds_list_add(&client_list_element.node, &client_list.clients_list);
e4db5ace
JR
1072
1073 /* Send evaluation result to the newly-subscribed client. */
1074 DBG("[notification-thread] Newly subscribed-to condition evaluated to true, notifying client");
1075 ret = send_evaluation_to_clients(trigger, evaluation, &client_list,
f82f93a1 1076 state, object_uid, object_gid);
e4db5ace
JR
1077
1078end:
1079 return ret;
1080}
1081
ab0ee2ca
JG
1082static
1083int notification_thread_client_subscribe(struct notification_client *client,
1084 struct lttng_condition *condition,
1085 struct notification_thread_state *state,
1086 enum lttng_notification_channel_status *_status)
1087{
1088 int ret = 0;
505b2d90 1089 struct notification_client_list *client_list = NULL;
ab0ee2ca
JG
1090 struct lttng_condition_list_element *condition_list_element = NULL;
1091 struct notification_client_list_element *client_list_element = NULL;
a3ed2a4e 1092 struct lttng_trigger_ht_element *trigger_ht_element;
ab0ee2ca
JG
1093 enum lttng_notification_channel_status status =
1094 LTTNG_NOTIFICATION_CHANNEL_STATUS_OK;
1095
1096 /*
1097 * Ensure that the client has not already subscribed to this condition
1098 * before.
1099 */
1100 cds_list_for_each_entry(condition_list_element, &client->condition_list, node) {
1101 if (lttng_condition_is_equal(condition_list_element->condition,
1102 condition)) {
1103 status = LTTNG_NOTIFICATION_CHANNEL_STATUS_ALREADY_SUBSCRIBED;
1104 goto end;
1105 }
1106 }
1107
1108 condition_list_element = zmalloc(sizeof(*condition_list_element));
1109 if (!condition_list_element) {
1110 ret = -1;
1111 goto error;
1112 }
1113 client_list_element = zmalloc(sizeof(*client_list_element));
1114 if (!client_list_element) {
1115 ret = -1;
1116 goto error;
1117 }
1118
ab0ee2ca
JG
1119 /*
1120 * Add the newly-subscribed condition to the client's subscription list.
1121 */
1122 CDS_INIT_LIST_HEAD(&condition_list_element->node);
1123 condition_list_element->condition = condition;
1124 cds_list_add(&condition_list_element->node, &client->condition_list);
1125
ed327204
JG
1126 client_list = get_client_list_from_condition(state, condition);
1127 if (!client_list) {
2ae99f0b
JG
1128 /*
1129 * No notification-emiting trigger registered with this
1130 * condition. We don't evaluate the condition right away
1131 * since this trigger is not registered yet.
1132 */
4fb43b68 1133 free(client_list_element);
505b2d90 1134 goto end;
ab0ee2ca
JG
1135 }
1136
2ae99f0b
JG
1137 /*
1138 * The condition to which the client just subscribed is evaluated
1139 * at this point so that conditions that are already TRUE result
1140 * in a notification being sent out.
505b2d90 1141 *
57644a7f
JG
1142 * Note the iteration on all triggers which share an identical
1143 * `condition` than the one to which the client is registering. This is
1144 * done to ensure that the client receives a distinct notification for
1145 * all triggers that have a `notify` action that have this condition.
2ae99f0b 1146 */
091fa780
FD
1147 pthread_mutex_lock(&client_list->lock);
1148 cds_list_for_each_entry(trigger_ht_element,
1149 &client_list->triggers_list, client_list_trigger_node) {
1150 if (evaluate_condition_for_client(trigger_ht_element->trigger, condition,
1151 client, state)) {
1152 WARN("[notification-thread] Evaluation of a condition on client subscription failed, aborting.");
1153 ret = -1;
1154 free(client_list_element);
ecc7ed07 1155 pthread_mutex_unlock(&client_list->lock);
091fa780
FD
1156 goto end;
1157 }
e4db5ace 1158 }
091fa780 1159 pthread_mutex_unlock(&client_list->lock);
e4db5ace
JR
1160
1161 /*
1162 * Add the client to the list of clients interested in a given trigger
1163 * if a "notification" trigger with a corresponding condition was
1164 * added prior.
1165 */
ab0ee2ca
JG
1166 client_list_element->client = client;
1167 CDS_INIT_LIST_HEAD(&client_list_element->node);
505b2d90
JG
1168
1169 pthread_mutex_lock(&client_list->lock);
091fa780 1170 cds_list_add(&client_list_element->node, &client_list->clients_list);
505b2d90 1171 pthread_mutex_unlock(&client_list->lock);
ab0ee2ca
JG
1172end:
1173 if (_status) {
1174 *_status = status;
1175 }
505b2d90
JG
1176 if (client_list) {
1177 notification_client_list_put(client_list);
1178 }
ab0ee2ca
JG
1179 return ret;
1180error:
1181 free(condition_list_element);
1182 free(client_list_element);
1183 return ret;
1184}
1185
1186static
1187int notification_thread_client_unsubscribe(
1188 struct notification_client *client,
1189 struct lttng_condition *condition,
1190 struct notification_thread_state *state,
1191 enum lttng_notification_channel_status *_status)
1192{
ab0ee2ca
JG
1193 struct notification_client_list *client_list;
1194 struct lttng_condition_list_element *condition_list_element,
1195 *condition_tmp;
1196 struct notification_client_list_element *client_list_element,
1197 *client_tmp;
1198 bool condition_found = false;
1199 enum lttng_notification_channel_status status =
1200 LTTNG_NOTIFICATION_CHANNEL_STATUS_OK;
1201
1202 /* Remove the condition from the client's condition list. */
1203 cds_list_for_each_entry_safe(condition_list_element, condition_tmp,
1204 &client->condition_list, node) {
1205 if (!lttng_condition_is_equal(condition_list_element->condition,
1206 condition)) {
1207 continue;
1208 }
1209
1210 cds_list_del(&condition_list_element->node);
1211 /*
1212 * The caller may be iterating on the client's conditions to
1213 * tear down a client's connection. In this case, the condition
1214 * will be destroyed at the end.
1215 */
1216 if (condition != condition_list_element->condition) {
1217 lttng_condition_destroy(
1218 condition_list_element->condition);
1219 }
1220 free(condition_list_element);
1221 condition_found = true;
1222 break;
1223 }
1224
1225 if (!condition_found) {
1226 status = LTTNG_NOTIFICATION_CHANNEL_STATUS_UNKNOWN_CONDITION;
1227 goto end;
1228 }
1229
1230 /*
1231 * Remove the client from the list of clients interested the trigger
1232 * matching the condition.
1233 */
ed327204
JG
1234 client_list = get_client_list_from_condition(state, condition);
1235 if (!client_list) {
505b2d90 1236 goto end;
ab0ee2ca
JG
1237 }
1238
505b2d90 1239 pthread_mutex_lock(&client_list->lock);
ab0ee2ca 1240 cds_list_for_each_entry_safe(client_list_element, client_tmp,
091fa780 1241 &client_list->clients_list, node) {
505b2d90 1242 if (client_list_element->client->id != client->id) {
ab0ee2ca
JG
1243 continue;
1244 }
1245 cds_list_del(&client_list_element->node);
1246 free(client_list_element);
1247 break;
1248 }
505b2d90
JG
1249 pthread_mutex_unlock(&client_list->lock);
1250 notification_client_list_put(client_list);
1251 client_list = NULL;
ab0ee2ca
JG
1252end:
1253 lttng_condition_destroy(condition);
1254 if (_status) {
1255 *_status = status;
1256 }
1257 return 0;
1258}
1259
83b934ad
MD
1260static
1261void free_notification_client_rcu(struct rcu_head *node)
1262{
1263 free(caa_container_of(node, struct notification_client, rcu_node));
1264}
1265
ab0ee2ca
JG
1266static
1267void notification_client_destroy(struct notification_client *client,
1268 struct notification_thread_state *state)
1269{
ab0ee2ca
JG
1270 if (!client) {
1271 return;
1272 }
1273
505b2d90
JG
1274 /*
1275 * The client object is not reachable by other threads, no need to lock
1276 * the client here.
1277 */
ab0ee2ca
JG
1278 if (client->socket >= 0) {
1279 (void) lttcomm_close_unix_sock(client->socket);
ac1889bf 1280 client->socket = -1;
ab0ee2ca 1281 }
505b2d90 1282 client->communication.active = false;
882093ee
JR
1283 lttng_payload_reset(&client->communication.inbound.payload);
1284 lttng_payload_reset(&client->communication.outbound.payload);
505b2d90 1285 pthread_mutex_destroy(&client->lock);
83b934ad 1286 call_rcu(&client->rcu_node, free_notification_client_rcu);
ab0ee2ca
JG
1287}
1288
1289/*
1290 * Call with rcu_read_lock held (and hold for the lifetime of the returned
1291 * client pointer).
1292 */
1293static
1294struct notification_client *get_client_from_socket(int socket,
1295 struct notification_thread_state *state)
1296{
1297 struct cds_lfht_iter iter;
1298 struct cds_lfht_node *node;
1299 struct notification_client *client = NULL;
1300
1301 cds_lfht_lookup(state->client_socket_ht,
ac1889bf
JG
1302 hash_client_socket(socket),
1303 match_client_socket,
ab0ee2ca
JG
1304 (void *) (unsigned long) socket,
1305 &iter);
1306 node = cds_lfht_iter_get_node(&iter);
1307 if (!node) {
1308 goto end;
1309 }
1310
1311 client = caa_container_of(node, struct notification_client,
1312 client_socket_ht_node);
1313end:
1314 return client;
1315}
1316
f2b3ef9f
JG
1317/*
1318 * Call with rcu_read_lock held (and hold for the lifetime of the returned
1319 * client pointer).
1320 */
1321static
1322struct notification_client *get_client_from_id(notification_client_id id,
1323 struct notification_thread_state *state)
1324{
1325 struct cds_lfht_iter iter;
1326 struct cds_lfht_node *node;
1327 struct notification_client *client = NULL;
1328
1329 cds_lfht_lookup(state->client_id_ht,
1330 hash_client_id(id),
1331 match_client_id,
1332 &id,
1333 &iter);
1334 node = cds_lfht_iter_get_node(&iter);
1335 if (!node) {
1336 goto end;
1337 }
1338
1339 client = caa_container_of(node, struct notification_client,
1340 client_id_ht_node);
1341end:
1342 return client;
1343}
1344
ab0ee2ca 1345static
e8360425 1346bool buffer_usage_condition_applies_to_channel(
51eab943
JG
1347 const struct lttng_condition *condition,
1348 const struct channel_info *channel_info)
ab0ee2ca
JG
1349{
1350 enum lttng_condition_status status;
e8360425
JD
1351 enum lttng_domain_type condition_domain;
1352 const char *condition_session_name = NULL;
1353 const char *condition_channel_name = NULL;
ab0ee2ca 1354
e8360425
JD
1355 status = lttng_condition_buffer_usage_get_domain_type(condition,
1356 &condition_domain);
1357 assert(status == LTTNG_CONDITION_STATUS_OK);
1358 if (channel_info->key.domain != condition_domain) {
ab0ee2ca
JG
1359 goto fail;
1360 }
1361
e8360425
JD
1362 status = lttng_condition_buffer_usage_get_session_name(
1363 condition, &condition_session_name);
1364 assert((status == LTTNG_CONDITION_STATUS_OK) && condition_session_name);
1365
1366 status = lttng_condition_buffer_usage_get_channel_name(
1367 condition, &condition_channel_name);
1368 assert((status == LTTNG_CONDITION_STATUS_OK) && condition_channel_name);
1369
1370 if (strcmp(channel_info->session_info->name, condition_session_name)) {
1371 goto fail;
1372 }
1373 if (strcmp(channel_info->name, condition_channel_name)) {
ab0ee2ca
JG
1374 goto fail;
1375 }
1376
e8360425
JD
1377 return true;
1378fail:
1379 return false;
1380}
1381
1382static
1383bool session_consumed_size_condition_applies_to_channel(
51eab943
JG
1384 const struct lttng_condition *condition,
1385 const struct channel_info *channel_info)
e8360425
JD
1386{
1387 enum lttng_condition_status status;
1388 const char *condition_session_name = NULL;
1389
1390 status = lttng_condition_session_consumed_size_get_session_name(
1391 condition, &condition_session_name);
1392 assert((status == LTTNG_CONDITION_STATUS_OK) && condition_session_name);
1393
1394 if (strcmp(channel_info->session_info->name, condition_session_name)) {
ab0ee2ca
JG
1395 goto fail;
1396 }
1397
e8360425
JD
1398 return true;
1399fail:
1400 return false;
1401}
ab0ee2ca 1402
51eab943
JG
1403static
1404bool trigger_applies_to_channel(const struct lttng_trigger *trigger,
1405 const struct channel_info *channel_info)
1406{
1407 const struct lttng_condition *condition;
e8360425 1408 bool trigger_applies;
ab0ee2ca 1409
51eab943 1410 condition = lttng_trigger_get_const_condition(trigger);
e8360425 1411 if (!condition) {
ab0ee2ca
JG
1412 goto fail;
1413 }
e8360425
JD
1414
1415 switch (lttng_condition_get_type(condition)) {
1416 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW:
1417 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH:
1418 trigger_applies = buffer_usage_condition_applies_to_channel(
1419 condition, channel_info);
1420 break;
1421 case LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE:
1422 trigger_applies = session_consumed_size_condition_applies_to_channel(
1423 condition, channel_info);
1424 break;
1425 default:
ab0ee2ca
JG
1426 goto fail;
1427 }
1428
e8360425 1429 return trigger_applies;
ab0ee2ca
JG
1430fail:
1431 return false;
1432}
1433
ed327204
JG
1434/* Must be called with RCU read lock held. */
1435static
1436struct lttng_session_trigger_list *get_session_trigger_list(
1437 struct notification_thread_state *state,
1438 const char *session_name)
1439{
1440 struct lttng_session_trigger_list *list = NULL;
1441 struct cds_lfht_node *node;
1442 struct cds_lfht_iter iter;
1443
1444 cds_lfht_lookup(state->session_triggers_ht,
1445 hash_key_str(session_name, lttng_ht_seed),
1446 match_session_trigger_list,
1447 session_name,
1448 &iter);
1449 node = cds_lfht_iter_get_node(&iter);
1450 if (!node) {
1451 /*
1452 * Not an error, the list of triggers applying to that session
1453 * will be initialized when the session is created.
1454 */
1455 DBG("[notification-thread] No trigger list found for session \"%s\" as it is not yet known to the notification system",
1456 session_name);
1457 goto end;
1458 }
1459
e742b055 1460 list = caa_container_of(node,
ed327204
JG
1461 struct lttng_session_trigger_list,
1462 session_triggers_ht_node);
1463end:
1464 return list;
1465}
1466
ea9a44f0
JG
1467/*
1468 * Allocate an empty lttng_session_trigger_list for the session named
1469 * 'session_name'.
1470 *
1471 * No ownership of 'session_name' is assumed by the session trigger list.
1472 * It is the caller's responsability to ensure the session name is alive
1473 * for as long as this list is.
1474 */
1475static
1476struct lttng_session_trigger_list *lttng_session_trigger_list_create(
1477 const char *session_name,
1478 struct cds_lfht *session_triggers_ht)
1479{
1480 struct lttng_session_trigger_list *list;
1481
1482 list = zmalloc(sizeof(*list));
1483 if (!list) {
1484 goto end;
1485 }
1486 list->session_name = session_name;
1487 CDS_INIT_LIST_HEAD(&list->list);
1488 cds_lfht_node_init(&list->session_triggers_ht_node);
1489 list->session_triggers_ht = session_triggers_ht;
1490
1491 rcu_read_lock();
1492 /* Publish the list through the session_triggers_ht. */
1493 cds_lfht_add(session_triggers_ht,
1494 hash_key_str(session_name, lttng_ht_seed),
1495 &list->session_triggers_ht_node);
1496 rcu_read_unlock();
1497end:
1498 return list;
1499}
1500
1501static
1502void free_session_trigger_list_rcu(struct rcu_head *node)
1503{
1504 free(caa_container_of(node, struct lttng_session_trigger_list,
1505 rcu_node));
1506}
1507
1508static
1509void lttng_session_trigger_list_destroy(struct lttng_session_trigger_list *list)
1510{
1511 struct lttng_trigger_list_element *trigger_list_element, *tmp;
1512
1513 /* Empty the list element by element, and then free the list itself. */
1514 cds_list_for_each_entry_safe(trigger_list_element, tmp,
1515 &list->list, node) {
1516 cds_list_del(&trigger_list_element->node);
1517 free(trigger_list_element);
1518 }
1519 rcu_read_lock();
1520 /* Unpublish the list from the session_triggers_ht. */
1521 cds_lfht_del(list->session_triggers_ht,
1522 &list->session_triggers_ht_node);
1523 rcu_read_unlock();
1524 call_rcu(&list->rcu_node, free_session_trigger_list_rcu);
1525}
1526
1527static
1528int lttng_session_trigger_list_add(struct lttng_session_trigger_list *list,
f2b3ef9f 1529 struct lttng_trigger *trigger)
ea9a44f0
JG
1530{
1531 int ret = 0;
1532 struct lttng_trigger_list_element *new_element =
1533 zmalloc(sizeof(*new_element));
1534
1535 if (!new_element) {
1536 ret = -1;
1537 goto end;
1538 }
1539 CDS_INIT_LIST_HEAD(&new_element->node);
1540 new_element->trigger = trigger;
1541 cds_list_add(&new_element->node, &list->list);
1542end:
1543 return ret;
1544}
1545
1546static
1547bool trigger_applies_to_session(const struct lttng_trigger *trigger,
1548 const char *session_name)
1549{
1550 bool applies = false;
1551 const struct lttng_condition *condition;
1552
1553 condition = lttng_trigger_get_const_condition(trigger);
1554 switch (lttng_condition_get_type(condition)) {
1555 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_ONGOING:
1556 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_COMPLETED:
1557 {
1558 enum lttng_condition_status condition_status;
1559 const char *condition_session_name;
1560
1561 condition_status = lttng_condition_session_rotation_get_session_name(
1562 condition, &condition_session_name);
1563 if (condition_status != LTTNG_CONDITION_STATUS_OK) {
1564 ERR("[notification-thread] Failed to retrieve session rotation condition's session name");
1565 goto end;
1566 }
1567
1568 assert(condition_session_name);
1569 applies = !strcmp(condition_session_name, session_name);
1570 break;
1571 }
1572 default:
1573 goto end;
1574 }
1575end:
1576 return applies;
1577}
1578
1579/*
1580 * Allocate and initialize an lttng_session_trigger_list which contains
1581 * all triggers that apply to the session named 'session_name'.
1582 *
1583 * No ownership of 'session_name' is assumed by the session trigger list.
1584 * It is the caller's responsability to ensure the session name is alive
1585 * for as long as this list is.
1586 */
1587static
1588struct lttng_session_trigger_list *lttng_session_trigger_list_build(
1589 const struct notification_thread_state *state,
1590 const char *session_name)
1591{
1592 int trigger_count = 0;
1593 struct lttng_session_trigger_list *session_trigger_list = NULL;
1594 struct lttng_trigger_ht_element *trigger_ht_element = NULL;
1595 struct cds_lfht_iter iter;
1596
1597 session_trigger_list = lttng_session_trigger_list_create(session_name,
1598 state->session_triggers_ht);
1599
1600 /* Add all triggers applying to the session named 'session_name'. */
1601 cds_lfht_for_each_entry(state->triggers_ht, &iter, trigger_ht_element,
1602 node) {
1603 int ret;
1604
1605 if (!trigger_applies_to_session(trigger_ht_element->trigger,
1606 session_name)) {
1607 continue;
1608 }
1609
1610 ret = lttng_session_trigger_list_add(session_trigger_list,
1611 trigger_ht_element->trigger);
1612 if (ret) {
1613 goto error;
1614 }
1615
1616 trigger_count++;
1617 }
1618
1619 DBG("[notification-thread] Found %i triggers that apply to newly created session",
1620 trigger_count);
1621 return session_trigger_list;
1622error:
1623 lttng_session_trigger_list_destroy(session_trigger_list);
1624 return NULL;
1625}
1626
8abe313a
JG
1627static
1628struct session_info *find_or_create_session_info(
1629 struct notification_thread_state *state,
1630 const char *name, uid_t uid, gid_t gid)
1631{
1632 struct session_info *session = NULL;
1633 struct cds_lfht_node *node;
1634 struct cds_lfht_iter iter;
ea9a44f0 1635 struct lttng_session_trigger_list *trigger_list;
8abe313a
JG
1636
1637 rcu_read_lock();
1638 cds_lfht_lookup(state->sessions_ht,
1639 hash_key_str(name, lttng_ht_seed),
1640 match_session,
1641 name,
1642 &iter);
1643 node = cds_lfht_iter_get_node(&iter);
1644 if (node) {
1645 DBG("[notification-thread] Found session info of session \"%s\" (uid = %i, gid = %i)",
1646 name, uid, gid);
1647 session = caa_container_of(node, struct session_info,
1648 sessions_ht_node);
1649 assert(session->uid == uid);
1650 assert(session->gid == gid);
1eee26c5
JG
1651 session_info_get(session);
1652 goto end;
ea9a44f0
JG
1653 }
1654
1655 trigger_list = lttng_session_trigger_list_build(state, name);
1656 if (!trigger_list) {
1657 goto error;
8abe313a
JG
1658 }
1659
1eee26c5
JG
1660 session = session_info_create(name, uid, gid, trigger_list,
1661 state->sessions_ht);
8abe313a
JG
1662 if (!session) {
1663 ERR("[notification-thread] Failed to allocation session info for session \"%s\" (uid = %i, gid = %i)",
1664 name, uid, gid);
b248644d 1665 lttng_session_trigger_list_destroy(trigger_list);
ea9a44f0 1666 goto error;
8abe313a 1667 }
ea9a44f0 1668 trigger_list = NULL;
577983cb
JG
1669
1670 cds_lfht_add(state->sessions_ht, hash_key_str(name, lttng_ht_seed),
9b63a4aa 1671 &session->sessions_ht_node);
1eee26c5 1672end:
8abe313a
JG
1673 rcu_read_unlock();
1674 return session;
ea9a44f0
JG
1675error:
1676 rcu_read_unlock();
1677 session_info_put(session);
1678 return NULL;
8abe313a
JG
1679}
1680
ab0ee2ca
JG
1681static
1682int handle_notification_thread_command_add_channel(
8abe313a
JG
1683 struct notification_thread_state *state,
1684 const char *session_name, uid_t session_uid, gid_t session_gid,
1685 const char *channel_name, enum lttng_domain_type channel_domain,
1686 uint64_t channel_key_int, uint64_t channel_capacity,
1687 enum lttng_error_code *cmd_result)
ab0ee2ca
JG
1688{
1689 struct cds_list_head trigger_list;
8abe313a
JG
1690 struct channel_info *new_channel_info = NULL;
1691 struct channel_key channel_key = {
1692 .key = channel_key_int,
1693 .domain = channel_domain,
1694 };
ab0ee2ca
JG
1695 struct lttng_channel_trigger_list *channel_trigger_list = NULL;
1696 struct lttng_trigger_ht_element *trigger_ht_element = NULL;
1697 int trigger_count = 0;
1698 struct cds_lfht_iter iter;
8abe313a 1699 struct session_info *session_info = NULL;
ab0ee2ca
JG
1700
1701 DBG("[notification-thread] Adding channel %s from session %s, channel key = %" PRIu64 " in %s domain",
8abe313a 1702 channel_name, session_name, channel_key_int,
526200e4 1703 lttng_domain_type_str(channel_domain));
ab0ee2ca
JG
1704
1705 CDS_INIT_LIST_HEAD(&trigger_list);
1706
8abe313a
JG
1707 session_info = find_or_create_session_info(state, session_name,
1708 session_uid, session_gid);
1709 if (!session_info) {
a9577b76 1710 /* Allocation error or an internal error occurred. */
ab0ee2ca
JG
1711 goto error;
1712 }
1713
8abe313a
JG
1714 new_channel_info = channel_info_create(channel_name, &channel_key,
1715 channel_capacity, session_info);
1716 if (!new_channel_info) {
1717 goto error;
1718 }
ab0ee2ca 1719
83b934ad 1720 rcu_read_lock();
ab0ee2ca
JG
1721 /* Build a list of all triggers applying to the new channel. */
1722 cds_lfht_for_each_entry(state->triggers_ht, &iter, trigger_ht_element,
1723 node) {
1724 struct lttng_trigger_list_element *new_element;
1725
1726 if (!trigger_applies_to_channel(trigger_ht_element->trigger,
8abe313a 1727 new_channel_info)) {
ab0ee2ca
JG
1728 continue;
1729 }
1730
1731 new_element = zmalloc(sizeof(*new_element));
1732 if (!new_element) {
83b934ad 1733 rcu_read_unlock();
ab0ee2ca
JG
1734 goto error;
1735 }
1736 CDS_INIT_LIST_HEAD(&new_element->node);
1737 new_element->trigger = trigger_ht_element->trigger;
1738 cds_list_add(&new_element->node, &trigger_list);
1739 trigger_count++;
1740 }
83b934ad 1741 rcu_read_unlock();
ab0ee2ca
JG
1742
1743 DBG("[notification-thread] Found %i triggers that apply to newly added channel",
1744 trigger_count);
1745 channel_trigger_list = zmalloc(sizeof(*channel_trigger_list));
1746 if (!channel_trigger_list) {
1747 goto error;
1748 }
8abe313a 1749 channel_trigger_list->channel_key = new_channel_info->key;
ab0ee2ca
JG
1750 CDS_INIT_LIST_HEAD(&channel_trigger_list->list);
1751 cds_lfht_node_init(&channel_trigger_list->channel_triggers_ht_node);
1752 cds_list_splice(&trigger_list, &channel_trigger_list->list);
1753
1754 rcu_read_lock();
1755 /* Add channel to the channel_ht which owns the channel_infos. */
1756 cds_lfht_add(state->channels_ht,
8abe313a 1757 hash_channel_key(&new_channel_info->key),
ab0ee2ca
JG
1758 &new_channel_info->channels_ht_node);
1759 /*
1760 * Add the list of triggers associated with this channel to the
1761 * channel_triggers_ht.
1762 */
1763 cds_lfht_add(state->channel_triggers_ht,
8abe313a 1764 hash_channel_key(&new_channel_info->key),
ab0ee2ca
JG
1765 &channel_trigger_list->channel_triggers_ht_node);
1766 rcu_read_unlock();
1eee26c5 1767 session_info_put(session_info);
ab0ee2ca
JG
1768 *cmd_result = LTTNG_OK;
1769 return 0;
1770error:
ab0ee2ca 1771 channel_info_destroy(new_channel_info);
8abe313a 1772 session_info_put(session_info);
ab0ee2ca
JG
1773 return 1;
1774}
1775
83b934ad
MD
1776static
1777void free_channel_trigger_list_rcu(struct rcu_head *node)
1778{
1779 free(caa_container_of(node, struct lttng_channel_trigger_list,
1780 rcu_node));
1781}
1782
1783static
1784void free_channel_state_sample_rcu(struct rcu_head *node)
1785{
1786 free(caa_container_of(node, struct channel_state_sample,
1787 rcu_node));
1788}
1789
ab0ee2ca
JG
1790static
1791int handle_notification_thread_command_remove_channel(
1792 struct notification_thread_state *state,
1793 uint64_t channel_key, enum lttng_domain_type domain,
1794 enum lttng_error_code *cmd_result)
1795{
1796 struct cds_lfht_node *node;
1797 struct cds_lfht_iter iter;
1798 struct lttng_channel_trigger_list *trigger_list;
1799 struct lttng_trigger_list_element *trigger_list_element, *tmp;
1800 struct channel_key key = { .key = channel_key, .domain = domain };
1801 struct channel_info *channel_info;
1802
1803 DBG("[notification-thread] Removing channel key = %" PRIu64 " in %s domain",
526200e4 1804 channel_key, lttng_domain_type_str(domain));
ab0ee2ca
JG
1805
1806 rcu_read_lock();
1807
1808 cds_lfht_lookup(state->channel_triggers_ht,
1809 hash_channel_key(&key),
1810 match_channel_trigger_list,
1811 &key,
1812 &iter);
1813 node = cds_lfht_iter_get_node(&iter);
1814 /*
1815 * There is a severe internal error if we are being asked to remove a
1816 * channel that doesn't exist.
1817 */
1818 if (!node) {
1819 ERR("[notification-thread] Channel being removed is unknown to the notification thread");
1820 goto end;
1821 }
1822
1823 /* Free the list of triggers associated with this channel. */
1824 trigger_list = caa_container_of(node, struct lttng_channel_trigger_list,
1825 channel_triggers_ht_node);
1826 cds_list_for_each_entry_safe(trigger_list_element, tmp,
1827 &trigger_list->list, node) {
1828 cds_list_del(&trigger_list_element->node);
1829 free(trigger_list_element);
1830 }
1831 cds_lfht_del(state->channel_triggers_ht, node);
83b934ad 1832 call_rcu(&trigger_list->rcu_node, free_channel_trigger_list_rcu);
ab0ee2ca
JG
1833
1834 /* Free sampled channel state. */
1835 cds_lfht_lookup(state->channel_state_ht,
1836 hash_channel_key(&key),
1837 match_channel_state_sample,
1838 &key,
1839 &iter);
1840 node = cds_lfht_iter_get_node(&iter);
1841 /*
1842 * This is expected to be NULL if the channel is destroyed before we
1843 * received a sample.
1844 */
1845 if (node) {
1846 struct channel_state_sample *sample = caa_container_of(node,
1847 struct channel_state_sample,
1848 channel_state_ht_node);
1849
1850 cds_lfht_del(state->channel_state_ht, node);
83b934ad 1851 call_rcu(&sample->rcu_node, free_channel_state_sample_rcu);
ab0ee2ca
JG
1852 }
1853
1854 /* Remove the channel from the channels_ht and free it. */
1855 cds_lfht_lookup(state->channels_ht,
1856 hash_channel_key(&key),
1857 match_channel_info,
1858 &key,
1859 &iter);
1860 node = cds_lfht_iter_get_node(&iter);
1861 assert(node);
1862 channel_info = caa_container_of(node, struct channel_info,
1863 channels_ht_node);
1864 cds_lfht_del(state->channels_ht, node);
1865 channel_info_destroy(channel_info);
1866end:
1867 rcu_read_unlock();
1868 *cmd_result = LTTNG_OK;
1869 return 0;
1870}
1871
0ca52944 1872static
ed327204 1873int handle_notification_thread_command_session_rotation(
0ca52944 1874 struct notification_thread_state *state,
ed327204
JG
1875 enum notification_thread_command_type cmd_type,
1876 const char *session_name, uid_t session_uid, gid_t session_gid,
1877 uint64_t trace_archive_chunk_id,
1878 struct lttng_trace_archive_location *location,
1879 enum lttng_error_code *_cmd_result)
0ca52944 1880{
ed327204
JG
1881 int ret = 0;
1882 enum lttng_error_code cmd_result = LTTNG_OK;
1883 struct lttng_session_trigger_list *trigger_list;
1884 struct lttng_trigger_list_element *trigger_list_element;
1885 struct session_info *session_info;
f2b3ef9f 1886 const struct lttng_credentials session_creds = {
ff588497
JR
1887 .uid = LTTNG_OPTIONAL_INIT_VALUE(session_uid),
1888 .gid = LTTNG_OPTIONAL_INIT_VALUE(session_gid),
f2b3ef9f 1889 };
0ca52944 1890
ed327204
JG
1891 rcu_read_lock();
1892
1893 session_info = find_or_create_session_info(state, session_name,
1894 session_uid, session_gid);
1895 if (!session_info) {
a9577b76 1896 /* Allocation error or an internal error occurred. */
ed327204
JG
1897 ret = -1;
1898 cmd_result = LTTNG_ERR_NOMEM;
1899 goto end;
1900 }
1901
1902 session_info->rotation.ongoing =
1903 cmd_type == NOTIFICATION_COMMAND_TYPE_SESSION_ROTATION_ONGOING;
1904 session_info->rotation.id = trace_archive_chunk_id;
1905 trigger_list = get_session_trigger_list(state, session_name);
1906 if (!trigger_list) {
1907 DBG("[notification-thread] No triggers applying to session \"%s\" found",
1908 session_name);
1909 goto end;
1910 }
1911
1912 cds_list_for_each_entry(trigger_list_element, &trigger_list->list,
1913 node) {
1914 const struct lttng_condition *condition;
f2b3ef9f 1915 struct lttng_trigger *trigger;
ed327204
JG
1916 struct notification_client_list *client_list;
1917 struct lttng_evaluation *evaluation = NULL;
1918 enum lttng_condition_type condition_type;
f2b3ef9f 1919 enum action_executor_status executor_status;
ed327204
JG
1920
1921 trigger = trigger_list_element->trigger;
1922 condition = lttng_trigger_get_const_condition(trigger);
1923 assert(condition);
1924 condition_type = lttng_condition_get_type(condition);
1925
1926 if (condition_type == LTTNG_CONDITION_TYPE_SESSION_ROTATION_ONGOING &&
1927 cmd_type != NOTIFICATION_COMMAND_TYPE_SESSION_ROTATION_ONGOING) {
1928 continue;
1929 } else if (condition_type == LTTNG_CONDITION_TYPE_SESSION_ROTATION_COMPLETED &&
1930 cmd_type != NOTIFICATION_COMMAND_TYPE_SESSION_ROTATION_COMPLETED) {
1931 continue;
1932 }
1933
ed327204 1934 client_list = get_client_list_from_condition(state, condition);
ed327204
JG
1935 if (cmd_type == NOTIFICATION_COMMAND_TYPE_SESSION_ROTATION_ONGOING) {
1936 evaluation = lttng_evaluation_session_rotation_ongoing_create(
1937 trace_archive_chunk_id);
1938 } else {
1939 evaluation = lttng_evaluation_session_rotation_completed_create(
1940 trace_archive_chunk_id, location);
1941 }
1942
1943 if (!evaluation) {
1944 /* Internal error */
1945 ret = -1;
1946 cmd_result = LTTNG_ERR_UNK;
505b2d90 1947 goto put_list;
ed327204
JG
1948 }
1949
f2b3ef9f
JG
1950 /*
1951 * Ownership of `evaluation` transferred to the action executor
1952 * no matter the result.
1953 */
1954 executor_status = action_executor_enqueue(state->executor,
1955 trigger, evaluation, &session_creds,
1956 client_list);
1957 evaluation = NULL;
1958 switch (executor_status) {
1959 case ACTION_EXECUTOR_STATUS_OK:
1960 break;
1961 case ACTION_EXECUTOR_STATUS_ERROR:
1962 case ACTION_EXECUTOR_STATUS_INVALID:
1963 /*
1964 * TODO Add trigger identification (name/id) when
1965 * it is added to the API.
1966 */
1967 ERR("Fatal error occurred while enqueuing action associated with session rotation trigger");
1968 ret = -1;
1969 goto put_list;
1970 case ACTION_EXECUTOR_STATUS_OVERFLOW:
1971 /*
1972 * TODO Add trigger identification (name/id) when
1973 * it is added to the API.
1974 *
1975 * Not a fatal error.
1976 */
1977 WARN("No space left when enqueuing action associated with session rotation trigger");
1978 ret = 0;
1979 goto put_list;
1980 default:
1981 abort();
1982 }
1983
505b2d90
JG
1984put_list:
1985 notification_client_list_put(client_list);
ed327204 1986 if (caa_unlikely(ret)) {
505b2d90 1987 break;
ed327204
JG
1988 }
1989 }
1990end:
1991 session_info_put(session_info);
1992 *_cmd_result = cmd_result;
1993 rcu_read_unlock();
1994 return ret;
0ca52944
JG
1995}
1996
d02d7404
JR
1997static
1998int handle_notification_thread_command_add_tracer_event_source(
1999 struct notification_thread_state *state,
2000 int tracer_event_source_fd,
2001 enum lttng_domain_type domain_type,
2002 enum lttng_error_code *_cmd_result)
2003{
2004 int ret = 0;
2005 enum lttng_error_code cmd_result = LTTNG_OK;
2006 struct notification_event_tracer_event_source_element *element = NULL;
2007
2008 element = zmalloc(sizeof(*element));
2009 if (!element) {
2010 cmd_result = LTTNG_ERR_NOMEM;
2011 ret = -1;
2012 goto end;
2013 }
2014
d02d7404
JR
2015 element->fd = tracer_event_source_fd;
2016 element->domain = domain_type;
2017
2018 cds_list_add(&element->node, &state->tracer_event_sources_list);
2019
2020 DBG3("[notification-thread] Adding tracer event source fd to poll set: tracer_event_source_fd = %d, domain = '%s'",
2021 tracer_event_source_fd,
2022 lttng_domain_type_str(domain_type));
2023
2024 /* Adding the read side pipe to the event poll. */
2025 ret = lttng_poll_add(&state->events, tracer_event_source_fd, LPOLLIN | LPOLLERR);
2026 if (ret < 0) {
2027 ERR("[notification-thread] Failed to add tracer event source to poll set: tracer_event_source_fd = %d, domain = '%s'",
2028 tracer_event_source_fd,
2029 lttng_domain_type_str(element->domain));
2030 cds_list_del(&element->node);
2031 free(element);
2032 goto end;
2033 }
2034
2035 element->is_fd_in_poll_set = true;
2036
2037end:
2038 *_cmd_result = cmd_result;
2039 return ret;
2040}
2041
8b524060
FD
2042static
2043int drain_event_notifier_notification_pipe(
2044 struct notification_thread_state *state,
2045 int pipe, enum lttng_domain_type domain)
2046{
2047 struct lttng_poll_event events = {0};
2048 int ret;
2049
2050 ret = lttng_poll_create(&events, 1, LTTNG_CLOEXEC);
2051 if (ret < 0) {
2052 ERR("[notification-thread] Error creating lttng_poll_event");
2053 goto end;
2054 }
2055
2056 ret = lttng_poll_add(&events, pipe, LPOLLIN);
2057 if (ret < 0) {
2058 ERR("[notification-thread] Error adding fd event notifier notification pipe to lttng_poll_event: fd = %d",
2059 pipe);
2060 goto end;
2061 }
2062
2063 while (true) {
2064 /*
2065 * Continue to consume notifications as long as there are new
2066 * ones coming in. The tracer has been asked to stop producing
2067 * them.
2068 *
2069 * LPOLLIN is explicitly checked since LPOLLHUP is implicitly
2070 * monitored (on Linux, at least) and will be returned when
2071 * the pipe is closed but empty.
2072 */
2073 ret = lttng_poll_wait_interruptible(&events, 0);
a17b133b 2074 if (ret == 0 || (LTTNG_POLL_GETEV(&events, 0) & LPOLLIN) == 0) {
8b524060
FD
2075 /* No more notification to be read on this pipe. */
2076 ret = 0;
2077 goto end;
2078 } else if (ret < 0) {
2079 PERROR("Failed on lttng_poll_wait_interruptible() call");
2080 ret = -1;
2081 goto end;
2082 }
2083
2084 ret = handle_one_event_notifier_notification(state, pipe, domain);
2085 if (ret) {
2086 ERR("[notification-thread] Error consuming an event notifier notification from pipe: fd = %d",
2087 pipe);
2088 }
2089 }
2090end:
2091 lttng_poll_clean(&events);
2092 return ret;
2093}
2094
d02d7404
JR
2095static
2096int handle_notification_thread_command_remove_tracer_event_source(
2097 struct notification_thread_state *state,
2098 int tracer_event_source_fd,
2099 enum lttng_error_code *_cmd_result)
2100{
2101 int ret = 0;
2fb5e9b7 2102 bool found = false;
d02d7404
JR
2103 enum lttng_error_code cmd_result = LTTNG_OK;
2104 struct notification_event_tracer_event_source_element *source_element = NULL, *tmp;
2105
2106 cds_list_for_each_entry_safe(source_element, tmp,
2107 &state->tracer_event_sources_list, node) {
2108 if (source_element->fd != tracer_event_source_fd) {
2109 continue;
2110 }
2111
2112 DBG("[notification-thread] Removed tracer event source from poll set: tracer_event_source_fd = %d, domain = '%s'",
2113 tracer_event_source_fd,
2114 lttng_domain_type_str(source_element->domain));
2115 cds_list_del(&source_element->node);
2fb5e9b7 2116 found = true;
d02d7404
JR
2117 break;
2118 }
2119
2fb5e9b7
JG
2120 if (!found) {
2121 /*
2122 * This is temporarily allowed since the poll activity set is
2123 * not properly cleaned-up for the moment. This is adressed in
2124 * an upcoming fix.
2125 */
2126 source_element = NULL;
2127 goto end;
2128 }
d02d7404
JR
2129
2130 if (!source_element->is_fd_in_poll_set) {
2131 /* Skip the poll set removal. */
2132 goto end;
2133 }
2134
2135 DBG3("[notification-thread] Removing tracer event source from poll set: tracer_event_source_fd = %d, domain = '%s'",
2136 tracer_event_source_fd,
2137 lttng_domain_type_str(source_element->domain));
2138
2139 /* Removing the fd from the event poll set. */
2140 ret = lttng_poll_del(&state->events, tracer_event_source_fd);
2141 if (ret < 0) {
2142 ERR("[notification-thread] Failed to remove tracer event source from poll set: tracer_event_source_fd = %d, domain = '%s'",
2143 tracer_event_source_fd,
2144 lttng_domain_type_str(source_element->domain));
2145 cmd_result = LTTNG_ERR_FATAL;
2146 goto end;
2147 }
2148
173900f6
JG
2149 source_element->is_fd_in_poll_set = false;
2150
8b524060
FD
2151 ret = drain_event_notifier_notification_pipe(state, tracer_event_source_fd,
2152 source_element->domain);
2153 if (ret) {
2154 ERR("[notification-thread] Error draining event notifier notification: tracer_event_source_fd = %d, domain = %s",
2155 tracer_event_source_fd,
2156 lttng_domain_type_str(source_element->domain));
2157 cmd_result = LTTNG_ERR_FATAL;
2158 goto end;
2159 }
2160
2161 /*
2162 * The drain_event_notifier_notification_pipe() call might have read
2163 * data from an fd that we received in event in the latest _poll_wait()
2164 * call. Make sure the thread call poll_wait() again to ensure we have
2165 * a clean state.
2166 */
2167 state->restart_poll = true;
2168
d02d7404
JR
2169end:
2170 free(source_element);
2171 *_cmd_result = cmd_result;
2172 return ret;
2173}
2174
90aa04a1
FD
2175static
2176int condition_on_event_update_error_count(struct lttng_trigger *trigger)
2177{
2178 int ret = 0;
2179 uint64_t error_count = 0;
2180 struct lttng_condition *condition;
2181 enum event_notifier_error_accounting_status status;
2182
2183 condition = lttng_trigger_get_condition(trigger);
2184 assert(lttng_condition_get_type(condition) ==
2185 LTTNG_CONDITION_TYPE_ON_EVENT);
2186
2187 status = event_notifier_error_accounting_get_count(trigger, &error_count);
2188 if (status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) {
2189 uid_t trigger_owner_uid;
2190 const char *trigger_name;
2191 const enum lttng_trigger_status trigger_status =
2192 lttng_trigger_get_owner_uid(
2193 trigger, &trigger_owner_uid);
2194
2195 assert(trigger_status == LTTNG_TRIGGER_STATUS_OK);
2196 if (lttng_trigger_get_name(trigger, &trigger_name) != LTTNG_TRIGGER_STATUS_OK) {
2197 trigger_name = "(unnamed)";
2198 }
2199
2200 ERR("Failed to get event notifier error count of trigger for update: trigger owner = %d, trigger name = '%s'",
2201 trigger_owner_uid, trigger_name);
2202 ret = -1;
2203 }
2204
2205 lttng_condition_on_event_set_error_count(condition, error_count);
2206 return ret;
2207}
2208
d02d7404
JR
2209int handle_notification_thread_remove_tracer_event_source_no_result(
2210 struct notification_thread_state *state,
2211 int tracer_event_source_fd)
2212{
2213 int ret;
2214 enum lttng_error_code cmd_result;
2215
2216 ret = handle_notification_thread_command_remove_tracer_event_source(
2217 state, tracer_event_source_fd, &cmd_result);
2218 (void) cmd_result;
2219 return ret;
2220}
2221
fbc9f37d
JR
2222static int handle_notification_thread_command_list_triggers(
2223 struct notification_thread_handle *handle,
2224 struct notification_thread_state *state,
2225 uid_t client_uid,
2226 struct lttng_triggers **triggers,
2227 enum lttng_error_code *_cmd_result)
2228{
2229 int ret = 0;
2230 enum lttng_error_code cmd_result = LTTNG_OK;
2231 struct cds_lfht_iter iter;
2232 struct lttng_trigger_ht_element *trigger_ht_element;
2233 struct lttng_triggers *local_triggers = NULL;
2234 const struct lttng_credentials *creds;
2235
2236 rcu_read_lock();
2237
2238 local_triggers = lttng_triggers_create();
2239 if (!local_triggers) {
2240 /* Not a fatal error. */
2241 cmd_result = LTTNG_ERR_NOMEM;
2242 goto end;
2243 }
2244
2245 cds_lfht_for_each_entry(state->triggers_ht, &iter,
2246 trigger_ht_element, node) {
2247 /*
2248 * Only return the triggers to which the client has access.
2249 * The root user has visibility over all triggers.
2250 */
2251 creds = lttng_trigger_get_credentials(trigger_ht_element->trigger);
2252 if (client_uid != lttng_credentials_get_uid(creds) && client_uid != 0) {
2253 continue;
2254 }
2255
6487ad53 2256 if (lttng_trigger_needs_tracer_notifier(trigger_ht_element->trigger)) {
90aa04a1
FD
2257 ret = condition_on_event_update_error_count(
2258 trigger_ht_element->trigger);
2259 assert(!ret);
2260 }
2261
fbc9f37d
JR
2262 ret = lttng_triggers_add(local_triggers,
2263 trigger_ht_element->trigger);
2264 if (ret < 0) {
2265 /* Not a fatal error. */
2266 ret = 0;
2267 cmd_result = LTTNG_ERR_NOMEM;
2268 goto end;
2269 }
2270 }
2271
2272 /* Transferring ownership to the caller. */
2273 *triggers = local_triggers;
2274 local_triggers = NULL;
2275
2276end:
2277 rcu_read_unlock();
2278 lttng_triggers_destroy(local_triggers);
2279 *_cmd_result = cmd_result;
2280 return ret;
2281}
2282
1da26331 2283static
959e3c66 2284bool condition_is_supported(struct lttng_condition *condition)
1da26331 2285{
959e3c66 2286 bool is_supported;
1da26331
JG
2287
2288 switch (lttng_condition_get_type(condition)) {
2289 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_LOW:
2290 case LTTNG_CONDITION_TYPE_BUFFER_USAGE_HIGH:
2291 {
959e3c66 2292 int ret;
1da26331
JG
2293 enum lttng_domain_type domain;
2294
2295 ret = lttng_condition_buffer_usage_get_domain_type(condition,
2296 &domain);
959e3c66 2297 assert(ret == 0);
1da26331
JG
2298
2299 if (domain != LTTNG_DOMAIN_KERNEL) {
959e3c66 2300 is_supported = true;
1da26331
JG
2301 goto end;
2302 }
2303
2304 /*
2305 * Older kernel tracers don't expose the API to monitor their
2306 * buffers. Therefore, we reject triggers that require that
2307 * mechanism to be available to be evaluated.
959e3c66
JR
2308 *
2309 * Assume unsupported on error.
1da26331 2310 */
959e3c66
JR
2311 is_supported = kernel_supports_ring_buffer_snapshot_sample_positions() == 1;
2312 break;
2313 }
d602bd6a 2314 case LTTNG_CONDITION_TYPE_ON_EVENT:
959e3c66
JR
2315 {
2316 const struct lttng_event_rule *event_rule;
2317 enum lttng_domain_type domain;
2318 const enum lttng_condition_status status =
d602bd6a 2319 lttng_condition_on_event_get_rule(
959e3c66
JR
2320 condition, &event_rule);
2321
2322 assert(status == LTTNG_CONDITION_STATUS_OK);
2323
2324 domain = lttng_event_rule_get_domain_type(event_rule);
2325 if (domain != LTTNG_DOMAIN_KERNEL) {
2326 is_supported = true;
2327 goto end;
2328 }
2329
2330 /*
2331 * Older kernel tracers can't emit notification. Therefore, we
2332 * reject triggers that require that mechanism to be available
2333 * to be evaluated.
2334 *
2335 * Assume unsupported on error.
2336 */
2337 is_supported = kernel_supports_event_notifiers() == 1;
1da26331
JG
2338 break;
2339 }
2340 default:
959e3c66 2341 is_supported = true;
1da26331
JG
2342 }
2343end:
959e3c66 2344 return is_supported;
1da26331
JG
2345}
2346
51eab943
JG
2347/* Must be called with RCU read lock held. */
2348static
f2b3ef9f 2349int bind_trigger_to_matching_session(struct lttng_trigger *trigger,
51eab943
JG
2350 struct notification_thread_state *state)
2351{
2352 int ret = 0;
51eab943
JG
2353 const struct lttng_condition *condition;
2354 const char *session_name;
2355 struct lttng_session_trigger_list *trigger_list;
2356
2357 condition = lttng_trigger_get_const_condition(trigger);
2358 switch (lttng_condition_get_type(condition)) {
2359 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_ONGOING:
2360 case LTTNG_CONDITION_TYPE_SESSION_ROTATION_COMPLETED:
2361 {
2362 enum lttng_condition_status status;
2363
2364 status = lttng_condition_session_rotation_get_session_name(
2365 condition, &session_name);
2366 if (status != LTTNG_CONDITION_STATUS_OK) {
2367 ERR("[notification-thread] Failed to bind trigger to session: unable to get 'session_rotation' condition's session name");
2368 ret = -1;
2369 goto end;
2370 }
2371 break;
2372 }
2373 default:
2374 ret = -1;
2375 goto end;
2376 }
2377
ed327204
JG
2378 trigger_list = get_session_trigger_list(state, session_name);
2379 if (!trigger_list) {
51eab943
JG
2380 DBG("[notification-thread] Unable to bind trigger applying to session \"%s\" as it is not yet known to the notification system",
2381 session_name);
2382 goto end;
51eab943 2383
ed327204 2384 }
51eab943
JG
2385
2386 DBG("[notification-thread] Newly registered trigger bound to session \"%s\"",
2387 session_name);
2388 ret = lttng_session_trigger_list_add(trigger_list, trigger);
2389end:
2390 return ret;
2391}
2392
2393/* Must be called with RCU read lock held. */
2394static
f2b3ef9f 2395int bind_trigger_to_matching_channels(struct lttng_trigger *trigger,
51eab943
JG
2396 struct notification_thread_state *state)
2397{
2398 int ret = 0;
2399 struct cds_lfht_node *node;
2400 struct cds_lfht_iter iter;
2401 struct channel_info *channel;
2402
2403 cds_lfht_for_each_entry(state->channels_ht, &iter, channel,
2404 channels_ht_node) {
2405 struct lttng_trigger_list_element *trigger_list_element;
2406 struct lttng_channel_trigger_list *trigger_list;
a5d64ae7 2407 struct cds_lfht_iter lookup_iter;
51eab943
JG
2408
2409 if (!trigger_applies_to_channel(trigger, channel)) {
2410 continue;
2411 }
2412
2413 cds_lfht_lookup(state->channel_triggers_ht,
2414 hash_channel_key(&channel->key),
2415 match_channel_trigger_list,
2416 &channel->key,
a5d64ae7
MD
2417 &lookup_iter);
2418 node = cds_lfht_iter_get_node(&lookup_iter);
51eab943
JG
2419 assert(node);
2420 trigger_list = caa_container_of(node,
2421 struct lttng_channel_trigger_list,
2422 channel_triggers_ht_node);
2423
2424 trigger_list_element = zmalloc(sizeof(*trigger_list_element));
2425 if (!trigger_list_element) {
2426 ret = -1;
2427 goto end;
2428 }
2429 CDS_INIT_LIST_HEAD(&trigger_list_element->node);
2430 trigger_list_element->trigger = trigger;
2431 cds_list_add(&trigger_list_element->node, &trigger_list->list);
2432 DBG("[notification-thread] Newly registered trigger bound to channel \"%s\"",
2433 channel->name);
2434 }
2435end:
2436 return ret;
2437}
2438
f2b3ef9f
JG
2439static
2440bool is_trigger_action_notify(const struct lttng_trigger *trigger)
2441{
2442 bool is_notify = false;
2443 unsigned int i, count;
2444 enum lttng_action_status action_status;
2445 const struct lttng_action *action =
2446 lttng_trigger_get_const_action(trigger);
2447 enum lttng_action_type action_type;
2448
2449 assert(action);
17182cfd 2450 action_type = lttng_action_get_type(action);
f2b3ef9f
JG
2451 if (action_type == LTTNG_ACTION_TYPE_NOTIFY) {
2452 is_notify = true;
2453 goto end;
2454 } else if (action_type != LTTNG_ACTION_TYPE_GROUP) {
2455 goto end;
2456 }
2457
2458 action_status = lttng_action_group_get_count(action, &count);
2459 assert(action_status == LTTNG_ACTION_STATUS_OK);
2460
2461 for (i = 0; i < count; i++) {
2462 const struct lttng_action *inner_action =
2463 lttng_action_group_get_at_index(
2464 action, i);
2465
17182cfd 2466 action_type = lttng_action_get_type(inner_action);
f2b3ef9f
JG
2467 if (action_type == LTTNG_ACTION_TYPE_NOTIFY) {
2468 is_notify = true;
2469 goto end;
2470 }
2471 }
2472
2473end:
2474 return is_notify;
2475}
2476
242388e4
JR
2477static bool trigger_name_taken(struct notification_thread_state *state,
2478 const struct lttng_trigger *trigger)
2479{
2480 struct cds_lfht_iter iter;
2481
2482 /*
2483 * No duplicata is allowed in the triggers_by_name_uid_ht.
2484 * The match is done against the trigger name and uid.
2485 */
2486 cds_lfht_lookup(state->triggers_by_name_uid_ht,
2487 hash_trigger_by_name_uid(trigger),
2488 match_trigger_by_name_uid,
2489 trigger,
2490 &iter);
2491 return !!cds_lfht_iter_get_node(&iter);
2492}
2493
2494static
2495enum lttng_error_code generate_trigger_name(
2496 struct notification_thread_state *state,
2497 struct lttng_trigger *trigger, const char **name)
2498{
2499 enum lttng_error_code ret_code = LTTNG_OK;
2500 bool taken = false;
2501 enum lttng_trigger_status status;
2502
2503 do {
2504 const int ret = lttng_trigger_generate_name(trigger,
2505 state->trigger_id.name_offset++);
2506 if (ret) {
2507 /* The only reason this can fail right now. */
2508 ret_code = LTTNG_ERR_NOMEM;
2509 break;
2510 }
2511
2512 status = lttng_trigger_get_name(trigger, name);
2513 assert(status == LTTNG_TRIGGER_STATUS_OK);
2514
2515 taken = trigger_name_taken(state, trigger);
2516 } while (taken || state->trigger_id.name_offset == UINT64_MAX);
2517
2518 return ret_code;
2519}
2520
2758e38b
FD
2521static inline
2522void notif_thread_state_remove_trigger_ht_elem(
2523 struct notification_thread_state *state,
2524 struct lttng_trigger_ht_element *trigger_ht_element)
2525{
2526 assert(state);
2527 assert(trigger_ht_element);
2528
2529 cds_lfht_del(state->triggers_ht, &trigger_ht_element->node);
2530 cds_lfht_del(state->triggers_by_name_uid_ht, &trigger_ht_element->node_by_name_uid);
2531}
2532
6487ad53
FD
2533static
2534enum lttng_error_code setup_tracer_notifier(
2535 struct notification_thread_state *state,
2536 struct lttng_trigger *trigger)
2537{
2538 enum lttng_error_code ret;
2539 enum event_notifier_error_accounting_status error_accounting_status;
2540 struct cds_lfht_node *node;
2541 uint64_t error_counter_index = 0;
2542 struct lttng_condition *condition = lttng_trigger_get_condition(trigger);
2543 struct notification_trigger_tokens_ht_element *trigger_tokens_ht_element = NULL;
2544
2545 trigger_tokens_ht_element = zmalloc(sizeof(*trigger_tokens_ht_element));
2546 if (!trigger_tokens_ht_element) {
2547 ret = LTTNG_ERR_NOMEM;
2548 goto end;
2549 }
2550
2551 /* Add trigger token to the trigger_tokens_ht. */
2552 cds_lfht_node_init(&trigger_tokens_ht_element->node);
2553 trigger_tokens_ht_element->token = LTTNG_OPTIONAL_GET(trigger->tracer_token);
2554 trigger_tokens_ht_element->trigger = trigger;
2555
2556 node = cds_lfht_add_unique(state->trigger_tokens_ht,
2557 hash_key_u64(&trigger_tokens_ht_element->token, lttng_ht_seed),
2558 match_trigger_token,
2559 &trigger_tokens_ht_element->token,
2560 &trigger_tokens_ht_element->node);
2561 if (node != &trigger_tokens_ht_element->node) {
2562 ret = LTTNG_ERR_TRIGGER_EXISTS;
2563 goto error_free_ht_element;
2564 }
2565
2566 error_accounting_status = event_notifier_error_accounting_register_event_notifier(
2567 trigger, &error_counter_index);
2568 if (error_accounting_status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) {
2569 if (error_accounting_status == EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_NO_INDEX_AVAILABLE) {
2570 DBG("Trigger group error accounting counter full.");
2571 ret = LTTNG_ERR_EVENT_NOTIFIER_ERROR_ACCOUNTING_FULL;
2572 } else {
2573 ERR("Error registering trigger for error accounting");
2574 ret = LTTNG_ERR_EVENT_NOTIFIER_REGISTRATION;
2575 }
2576
2577 goto error_remove_ht_element;
2578 }
2579
2580 lttng_condition_on_event_set_error_counter_index(
2581 condition, error_counter_index);
2582
2583 ret = LTTNG_OK;
2584 goto end;
2585
2586error_remove_ht_element:
2587 cds_lfht_del(state->trigger_tokens_ht, &trigger_tokens_ht_element->node);
2588error_free_ht_element:
2589 free(trigger_tokens_ht_element);
2590end:
2591 return ret;
2592}
2593
ab0ee2ca 2594/*
f2b3ef9f 2595 * FIXME A client's credentials are not checked when registering a trigger.
ab0ee2ca 2596 *
1da26331 2597 * The effects of this are benign since:
ab0ee2ca 2598 * - The client will succeed in registering the trigger, as it is valid,
51eab943 2599 * - The trigger will, internally, be bound to the channel/session,
ab0ee2ca
JG
2600 * - The notifications will not be sent since the client's credentials
2601 * are checked against the channel at that moment.
1da26331
JG
2602 *
2603 * If this function returns a non-zero value, it means something is
50ca7858 2604 * fundamentally broken and the whole subsystem/thread will be torn down.
1da26331
JG
2605 *
2606 * If a non-fatal error occurs, just set the cmd_result to the appropriate
2607 * error code.
ab0ee2ca
JG
2608 */
2609static
2610int handle_notification_thread_command_register_trigger(
8abe313a
JG
2611 struct notification_thread_state *state,
2612 struct lttng_trigger *trigger,
2613 enum lttng_error_code *cmd_result)
ab0ee2ca
JG
2614{
2615 int ret = 0;
2616 struct lttng_condition *condition;
ab0ee2ca
JG
2617 struct notification_client_list *client_list = NULL;
2618 struct lttng_trigger_ht_element *trigger_ht_element = NULL;
ab0ee2ca 2619 struct cds_lfht_node *node;
242388e4 2620 const char* trigger_name;
ab0ee2ca 2621 bool free_trigger = true;
f2b3ef9f
JG
2622 struct lttng_evaluation *evaluation = NULL;
2623 struct lttng_credentials object_creds;
ff588497
JR
2624 uid_t object_uid;
2625 gid_t object_gid;
f2b3ef9f 2626 enum action_executor_status executor_status;
e6887944
JR
2627 const uint64_t trigger_tracer_token =
2628 state->trigger_id.next_tracer_token++;
ab0ee2ca
JG
2629
2630 rcu_read_lock();
2631
e6887944
JR
2632 /* Set the trigger's tracer token. */
2633 lttng_trigger_set_tracer_token(trigger, trigger_tracer_token);
2634
242388e4
JR
2635 if (lttng_trigger_get_name(trigger, &trigger_name) ==
2636 LTTNG_TRIGGER_STATUS_UNSET) {
2637 const enum lttng_error_code ret_code = generate_trigger_name(
2638 state, trigger, &trigger_name);
2639
2640 if (ret_code != LTTNG_OK) {
2641 /* Fatal error. */
2642 ret = -1;
2643 *cmd_result = ret_code;
2644 goto error;
2645 }
2646 } else if (trigger_name_taken(state, trigger)) {
2647 /* Not a fatal error. */
2648 *cmd_result = LTTNG_ERR_TRIGGER_EXISTS;
2649 ret = 0;
2650 goto error;
2651 }
2652
ab0ee2ca 2653 condition = lttng_trigger_get_condition(trigger);
1da26331
JG
2654 assert(condition);
2655
959e3c66
JR
2656 /* Some conditions require tracers to implement a minimal ABI version. */
2657 if (!condition_is_supported(condition)) {
1da26331
JG
2658 *cmd_result = LTTNG_ERR_NOT_SUPPORTED;
2659 goto error;
1da26331
JG
2660 }
2661
ab0ee2ca
JG
2662 trigger_ht_element = zmalloc(sizeof(*trigger_ht_element));
2663 if (!trigger_ht_element) {
2664 ret = -1;
2665 goto error;
2666 }
2667
2668 /* Add trigger to the trigger_ht. */
2669 cds_lfht_node_init(&trigger_ht_element->node);
242388e4 2670 cds_lfht_node_init(&trigger_ht_element->node_by_name_uid);
ab0ee2ca
JG
2671 trigger_ht_element->trigger = trigger;
2672
2673 node = cds_lfht_add_unique(state->triggers_ht,
2674 lttng_condition_hash(condition),
242388e4
JR
2675 match_trigger,
2676 trigger,
ab0ee2ca
JG
2677 &trigger_ht_element->node);
2678 if (node != &trigger_ht_element->node) {
2679 /* Not a fatal error, simply report it to the client. */
2680 *cmd_result = LTTNG_ERR_TRIGGER_EXISTS;
2681 goto error_free_ht_element;
2682 }
2683
242388e4
JR
2684 node = cds_lfht_add_unique(state->triggers_by_name_uid_ht,
2685 hash_trigger_by_name_uid(trigger),
2686 match_trigger_by_name_uid,
2687 trigger,
2688 &trigger_ht_element->node_by_name_uid);
2689 if (node != &trigger_ht_element->node_by_name_uid) {
2690 /* Not a fatal error, simply report it to the client. */
2691 cds_lfht_del(state->triggers_ht, &trigger_ht_element->node);
2692 *cmd_result = LTTNG_ERR_TRIGGER_EXISTS;
2693 goto error_free_ht_element;
2694 }
2695
6487ad53
FD
2696 /*
2697 * Some triggers might need a tracer notifier depending on its
2698 * condition and actions.
2699 */
2700 if (lttng_trigger_needs_tracer_notifier(trigger)) {
2701 enum lttng_error_code error_code;
e7c93cf9 2702
6487ad53
FD
2703 error_code = setup_tracer_notifier(state, trigger);
2704 if (error_code != LTTNG_OK) {
2758e38b
FD
2705 notif_thread_state_remove_trigger_ht_elem(state,
2706 trigger_ht_element);
6487ad53
FD
2707 if (error_code == LTTNG_ERR_NOMEM) {
2708 ret = -1;
2709 } else {
2710 *cmd_result = error_code;
2711 ret = 0;
90aa04a1
FD
2712 }
2713
6487ad53 2714 goto error_free_ht_element;
90aa04a1 2715 }
e7c93cf9
JR
2716 }
2717
ab0ee2ca
JG
2718 /*
2719 * The rest only applies to triggers that have a "notify" action.
2720 * It is not skipped as this is the only action type currently
2721 * supported.
2722 */
f2b3ef9f 2723 if (is_trigger_action_notify(trigger)) {
091fa780
FD
2724 /*
2725 * Find or create the client list of this condition. It may
2726 * already be present if another trigger is already registered
2727 * with the same condition.
2728 */
2729 client_list = get_client_list_from_condition(state, condition);
f2b3ef9f 2730 if (!client_list) {
091fa780
FD
2731 /*
2732 * No client list for this condition yet. We create new
2733 * one and build it up.
2734 */
2735 client_list = notification_client_list_create(state, condition);
2736 if (!client_list) {
2737 ERR("Error creating notification client list for trigger %s", trigger->name);
2738 goto error_free_ht_element;
f2b3ef9f 2739 }
ab0ee2ca 2740 }
f2b3ef9f 2741
091fa780
FD
2742 CDS_INIT_LIST_HEAD(&trigger_ht_element->client_list_trigger_node);
2743
2744 pthread_mutex_lock(&client_list->lock);
2745 cds_list_add(&trigger_ht_element->client_list_trigger_node, &client_list->triggers_list);
2746 pthread_mutex_unlock(&client_list->lock);
ab0ee2ca
JG
2747 }
2748
091fa780
FD
2749 /*
2750 * Ownership of the trigger and of its wrapper was transfered to
2751 * the triggers_ht. Same for token ht element if necessary.
2752 */
2753 trigger_ht_element = NULL;
2754 free_trigger = false;
2755
f82f93a1 2756 switch (get_condition_binding_object(condition)) {
51eab943
JG
2757 case LTTNG_OBJECT_TYPE_SESSION:
2758 /* Add the trigger to the list if it matches a known session. */
2759 ret = bind_trigger_to_matching_session(trigger, state);
2760 if (ret) {
091fa780 2761 goto error_free_ht_element;
ab0ee2ca 2762 }
f82f93a1 2763 break;
51eab943
JG
2764 case LTTNG_OBJECT_TYPE_CHANNEL:
2765 /*
2766 * Add the trigger to list of triggers bound to the channels
2767 * currently known.
2768 */
2769 ret = bind_trigger_to_matching_channels(trigger, state);
2770 if (ret) {
091fa780 2771 goto error_free_ht_element;
ab0ee2ca 2772 }
51eab943
JG
2773 break;
2774 case LTTNG_OBJECT_TYPE_NONE:
2775 break;
2776 default:
f2b3ef9f 2777 ERR("Unknown object type on which to bind a newly registered trigger was encountered");
51eab943 2778 ret = -1;
091fa780 2779 goto error_free_ht_element;
ab0ee2ca
JG
2780 }
2781
2ae99f0b 2782 /*
f2b3ef9f
JG
2783 * The new trigger's condition must be evaluated against the current
2784 * state.
2785 *
2786 * In the case of `notify` action, nothing preventing clients from
2787 * subscribing to a condition before the corresponding trigger is
2788 * registered, we have to evaluate this new condition right away.
2ae99f0b
JG
2789 *
2790 * At some point, we were waiting for the next "evaluation" (e.g. on
2791 * reception of a channel sample) to evaluate this new condition, but
2792 * that was broken.
2793 *
2794 * The reason it was broken is that waiting for the next sample
2795 * does not allow us to properly handle transitions for edge-triggered
2796 * conditions.
2797 *
2798 * Consider this example: when we handle a new channel sample, we
2799 * evaluate each conditions twice: once with the previous state, and
2800 * again with the newest state. We then use those two results to
2801 * determine whether a state change happened: a condition was false and
2802 * became true. If a state change happened, we have to notify clients.
2803 *
2804 * Now, if a client subscribes to a given notification and registers
2805 * a trigger *after* that subscription, we have to make sure the
2806 * condition is evaluated at this point while considering only the
2807 * current state. Otherwise, the next evaluation cycle may only see
2808 * that the evaluations remain the same (true for samples n-1 and n) and
2809 * the client will never know that the condition has been met.
2810 */
f2b3ef9f
JG
2811 switch (get_condition_binding_object(condition)) {
2812 case LTTNG_OBJECT_TYPE_SESSION:
2813 ret = evaluate_session_condition_for_client(condition, state,
ff588497
JR
2814 &evaluation, &object_uid,
2815 &object_gid);
bc8daafb
JG
2816 LTTNG_OPTIONAL_SET(&object_creds.uid, object_uid);
2817 LTTNG_OPTIONAL_SET(&object_creds.gid, object_gid);
b42ada90 2818 break;
f2b3ef9f
JG
2819 case LTTNG_OBJECT_TYPE_CHANNEL:
2820 ret = evaluate_channel_condition_for_client(condition, state,
ff588497
JR
2821 &evaluation, &object_uid,
2822 &object_gid);
bc8daafb
JG
2823 LTTNG_OPTIONAL_SET(&object_creds.uid, object_uid);
2824 LTTNG_OPTIONAL_SET(&object_creds.gid, object_gid);
f2b3ef9f
JG
2825 break;
2826 case LTTNG_OBJECT_TYPE_NONE:
2827 ret = 0;
242388e4 2828 break;
f2b3ef9f
JG
2829 case LTTNG_OBJECT_TYPE_UNKNOWN:
2830 default:
2831 ret = -1;
242388e4 2832 break;
f2b3ef9f
JG
2833 }
2834
2835 if (ret) {
2836 /* Fatal error. */
091fa780 2837 goto error_free_ht_element;
f2b3ef9f
JG
2838 }
2839
2840 DBG("Newly registered trigger's condition evaluated to %s",
2841 evaluation ? "true" : "false");
2842 if (!evaluation) {
2843 /* Evaluation yielded nothing. Normal exit. */
2844 ret = 0;
091fa780 2845 goto success;
2ae99f0b
JG
2846 }
2847
2848 /*
f2b3ef9f
JG
2849 * Ownership of `evaluation` transferred to the action executor
2850 * no matter the result.
2ae99f0b 2851 */
f2b3ef9f
JG
2852 executor_status = action_executor_enqueue(state->executor, trigger,
2853 evaluation, &object_creds, client_list);
2854 evaluation = NULL;
2855 switch (executor_status) {
2856 case ACTION_EXECUTOR_STATUS_OK:
2857 break;
2858 case ACTION_EXECUTOR_STATUS_ERROR:
2859 case ACTION_EXECUTOR_STATUS_INVALID:
2860 /*
2861 * TODO Add trigger identification (name/id) when
2862 * it is added to the API.
2863 */
2864 ERR("Fatal error occurred while enqueuing action associated to newly registered trigger");
2865 ret = -1;
091fa780 2866 goto error_free_ht_element;
f2b3ef9f
JG
2867 case ACTION_EXECUTOR_STATUS_OVERFLOW:
2868 /*
2869 * TODO Add trigger identification (name/id) when
2870 * it is added to the API.
2871 *
2872 * Not a fatal error.
2873 */
2874 WARN("No space left when enqueuing action associated to newly registered trigger");
2875 ret = 0;
091fa780 2876 goto success;
f2b3ef9f
JG
2877 default:
2878 abort();
2879 }
2ae99f0b 2880
091fa780 2881success:
ab0ee2ca 2882 *cmd_result = LTTNG_OK;
e6887944
JR
2883 DBG("Registered trigger: name = `%s`, tracer token = %" PRIu64,
2884 trigger_name, trigger_tracer_token);
091fa780 2885 goto end;
505b2d90 2886
ab0ee2ca 2887error_free_ht_element:
242388e4
JR
2888 if (trigger_ht_element) {
2889 /* Delayed removal due to RCU constraint on delete. */
2890 call_rcu(&trigger_ht_element->rcu_node,
2891 free_lttng_trigger_ht_element_rcu);
2892 }
ab0ee2ca
JG
2893error:
2894 if (free_trigger) {
ab0ee2ca
JG
2895 lttng_trigger_destroy(trigger);
2896 }
091fa780 2897end:
ab0ee2ca
JG
2898 rcu_read_unlock();
2899 return ret;
2900}
2901
83b934ad
MD
2902static
2903void free_lttng_trigger_ht_element_rcu(struct rcu_head *node)
2904{
2905 free(caa_container_of(node, struct lttng_trigger_ht_element,
2906 rcu_node));
2907}
2908
e7c93cf9
JR
2909static
2910void free_notification_trigger_tokens_ht_element_rcu(struct rcu_head *node)
2911{
2912 free(caa_container_of(node, struct notification_trigger_tokens_ht_element,
2913 rcu_node));
2914}
2915
6487ad53
FD
2916static
2917void teardown_tracer_notifier(struct notification_thread_state *state,
2918 const struct lttng_trigger *trigger)
2919{
2920 struct cds_lfht_iter iter;
2921 struct notification_trigger_tokens_ht_element *trigger_tokens_ht_element;
2922
2923 cds_lfht_for_each_entry(state->trigger_tokens_ht, &iter,
2924 trigger_tokens_ht_element, node) {
2925
2926 if (!lttng_trigger_is_equal(trigger,
2927 trigger_tokens_ht_element->trigger)) {
2928 continue;
2929 }
2930
2931 event_notifier_error_accounting_unregister_event_notifier(
2932 trigger_tokens_ht_element->trigger);
2933
2934 /* TODO talk to all app and remove it */
2935 DBG("[notification-thread] Removed trigger from tokens_ht");
2936 cds_lfht_del(state->trigger_tokens_ht,
2937 &trigger_tokens_ht_element->node);
2938
2939 call_rcu(&trigger_tokens_ht_element->rcu_node,
2940 free_notification_trigger_tokens_ht_element_rcu);
2941
2942 break;
2943 }
2944}
2945
cc2295b5 2946static
ab0ee2ca
JG
2947int handle_notification_thread_command_unregister_trigger(
2948 struct notification_thread_state *state,
ac16173e 2949 const struct lttng_trigger *trigger,
ab0ee2ca
JG
2950 enum lttng_error_code *_cmd_reply)
2951{
2952 struct cds_lfht_iter iter;
ed327204 2953 struct cds_lfht_node *triggers_ht_node;
ab0ee2ca
JG
2954 struct lttng_channel_trigger_list *trigger_list;
2955 struct notification_client_list *client_list;
ab0ee2ca 2956 struct lttng_trigger_ht_element *trigger_ht_element = NULL;
ac16173e 2957 const struct lttng_condition *condition = lttng_trigger_get_const_condition(
ab0ee2ca 2958 trigger);
ab0ee2ca
JG
2959 enum lttng_error_code cmd_reply;
2960
2961 rcu_read_lock();
2962
2963 cds_lfht_lookup(state->triggers_ht,
2964 lttng_condition_hash(condition),
242388e4
JR
2965 match_trigger,
2966 trigger,
ab0ee2ca
JG
2967 &iter);
2968 triggers_ht_node = cds_lfht_iter_get_node(&iter);
2969 if (!triggers_ht_node) {
2970 cmd_reply = LTTNG_ERR_TRIGGER_NOT_FOUND;
2971 goto end;
2972 } else {
2973 cmd_reply = LTTNG_OK;
2974 }
2975
2976 /* Remove trigger from channel_triggers_ht. */
2977 cds_lfht_for_each_entry(state->channel_triggers_ht, &iter, trigger_list,
2978 channel_triggers_ht_node) {
2979 struct lttng_trigger_list_element *trigger_element, *tmp;
2980
2981 cds_list_for_each_entry_safe(trigger_element, tmp,
2982 &trigger_list->list, node) {
e8f7fa11 2983 if (!lttng_trigger_is_equal(trigger, trigger_element->trigger)) {
ab0ee2ca
JG
2984 continue;
2985 }
2986
2987 DBG("[notification-thread] Removed trigger from channel_triggers_ht");
2988 cds_list_del(&trigger_element->node);
e4db5ace
JR
2989 /* A trigger can only appear once per channel */
2990 break;
ab0ee2ca
JG
2991 }
2992 }
2993
6487ad53
FD
2994 if (lttng_trigger_needs_tracer_notifier(trigger)) {
2995 teardown_tracer_notifier(state, trigger);
e7c93cf9
JR
2996 }
2997
091fa780
FD
2998 trigger_ht_element = caa_container_of(triggers_ht_node,
2999 struct lttng_trigger_ht_element, node);
3000
51367634
JR
3001 if (is_trigger_action_notify(trigger)) {
3002 /*
3003 * Remove and release the client list from
3004 * notification_trigger_clients_ht.
3005 */
3006 client_list = get_client_list_from_condition(state, condition);
3007 assert(client_list);
ed327204 3008
091fa780
FD
3009 pthread_mutex_lock(&client_list->lock);
3010 cds_list_del(&trigger_ht_element->client_list_trigger_node);
3011 pthread_mutex_unlock(&client_list->lock);
3012
51367634
JR
3013 /* Put new reference and the hashtable's reference. */
3014 notification_client_list_put(client_list);
3015 notification_client_list_put(client_list);
3016 client_list = NULL;
3017 }
ab0ee2ca 3018
2758e38b
FD
3019 /* Remove trigger from triggers_ht. */
3020 notif_thread_state_remove_trigger_ht_elem(state, trigger_ht_element);
ab0ee2ca 3021
7ca172c1 3022 /* Release the ownership of the trigger. */
ab0ee2ca 3023 lttng_trigger_destroy(trigger_ht_element->trigger);
83b934ad 3024 call_rcu(&trigger_ht_element->rcu_node, free_lttng_trigger_ht_element_rcu);
ab0ee2ca
JG
3025end:
3026 rcu_read_unlock();
3027 if (_cmd_reply) {
3028 *_cmd_reply = cmd_reply;
3029 }
3030 return 0;
3031}
3032
3033/* Returns 0 on success, 1 on exit requested, negative value on error. */
3034int handle_notification_thread_command(
3035 struct notification_thread_handle *handle,
3036 struct notification_thread_state *state)
3037{
3038 int ret;
3039 uint64_t counter;
3040 struct notification_thread_command *cmd;
3041
8abe313a 3042 /* Read the event pipe to put it back into a quiescent state. */
18aeca05 3043 ret = lttng_read(lttng_pipe_get_readfd(handle->cmd_queue.event_pipe), &counter,
8abe313a 3044 sizeof(counter));
18aeca05 3045 if (ret != sizeof(counter)) {
ab0ee2ca
JG
3046 goto error;
3047 }
3048
3049 pthread_mutex_lock(&handle->cmd_queue.lock);
3050 cmd = cds_list_first_entry(&handle->cmd_queue.list,
3051 struct notification_thread_command, cmd_list_node);
97a71ea6
JR
3052 cds_list_del(&cmd->cmd_list_node);
3053 pthread_mutex_unlock(&handle->cmd_queue.lock);
6900ae81
FD
3054
3055 DBG("[notification-thread] Received `%s` command",
3056 notification_command_type_str(cmd->type));
ab0ee2ca
JG
3057 switch (cmd->type) {
3058 case NOTIFICATION_COMMAND_TYPE_REGISTER_TRIGGER:
ac16173e
JG
3059 ret = handle_notification_thread_command_register_trigger(state,
3060 cmd->parameters.register_trigger.trigger,
ab0ee2ca
JG
3061 &cmd->reply_code);
3062 break;
3063 case NOTIFICATION_COMMAND_TYPE_UNREGISTER_TRIGGER:
ab0ee2ca 3064 ret = handle_notification_thread_command_unregister_trigger(
ac16173e
JG
3065 state,
3066 cmd->parameters.unregister_trigger.trigger,
ab0ee2ca
JG
3067 &cmd->reply_code);
3068 break;
3069 case NOTIFICATION_COMMAND_TYPE_ADD_CHANNEL:
ab0ee2ca 3070 ret = handle_notification_thread_command_add_channel(
8abe313a
JG
3071 state,
3072 cmd->parameters.add_channel.session.name,
3073 cmd->parameters.add_channel.session.uid,
3074 cmd->parameters.add_channel.session.gid,
3075 cmd->parameters.add_channel.channel.name,
3076 cmd->parameters.add_channel.channel.domain,
3077 cmd->parameters.add_channel.channel.key,
3078 cmd->parameters.add_channel.channel.capacity,
ab0ee2ca
JG
3079 &cmd->reply_code);
3080 break;
3081 case NOTIFICATION_COMMAND_TYPE_REMOVE_CHANNEL:
ab0ee2ca
JG
3082 ret = handle_notification_thread_command_remove_channel(
3083 state, cmd->parameters.remove_channel.key,
3084 cmd->parameters.remove_channel.domain,
3085 &cmd->reply_code);
3086 break;
0ca52944 3087 case NOTIFICATION_COMMAND_TYPE_SESSION_ROTATION_ONGOING:
0ca52944 3088 case NOTIFICATION_COMMAND_TYPE_SESSION_ROTATION_COMPLETED:
ed327204 3089 ret = handle_notification_thread_command_session_rotation(
0ca52944 3090 state,
ed327204
JG
3091 cmd->type,
3092 cmd->parameters.session_rotation.session_name,
3093 cmd->parameters.session_rotation.uid,
3094 cmd->parameters.session_rotation.gid,
3095 cmd->parameters.session_rotation.trace_archive_chunk_id,
3096 cmd->parameters.session_rotation.location,
0ca52944
JG
3097 &cmd->reply_code);
3098 break;
d02d7404
JR
3099 case NOTIFICATION_COMMAND_TYPE_ADD_TRACER_EVENT_SOURCE:
3100 ret = handle_notification_thread_command_add_tracer_event_source(
3101 state,
3102 cmd->parameters.tracer_event_source.tracer_event_source_fd,
3103 cmd->parameters.tracer_event_source.domain,
3104 &cmd->reply_code);
3105 break;
3106 case NOTIFICATION_COMMAND_TYPE_REMOVE_TRACER_EVENT_SOURCE:
3107 ret = handle_notification_thread_command_remove_tracer_event_source(
3108 state,
3109 cmd->parameters.tracer_event_source.tracer_event_source_fd,
3110 &cmd->reply_code);
3111 break;
fbc9f37d
JR
3112 case NOTIFICATION_COMMAND_TYPE_LIST_TRIGGERS:
3113 {
3114 struct lttng_triggers *triggers = NULL;
3115
3116 ret = handle_notification_thread_command_list_triggers(
3117 handle,
3118 state,
3119 cmd->parameters.list_triggers.uid,
3120 &triggers,
3121 &cmd->reply_code);
3122 cmd->reply.list_triggers.triggers = triggers;
3123 ret = 0;
3124 break;
3125 }
ab0ee2ca 3126 case NOTIFICATION_COMMAND_TYPE_QUIT:
ab0ee2ca
JG
3127 cmd->reply_code = LTTNG_OK;
3128 ret = 1;
3129 goto end;
f2b3ef9f
JG
3130 case NOTIFICATION_COMMAND_TYPE_CLIENT_COMMUNICATION_UPDATE:
3131 {
3132 const enum client_transmission_status client_status =
3133 cmd->parameters.client_communication_update
3134 .status;
3135 const notification_client_id client_id =
3136 cmd->parameters.client_communication_update.id;
3137 struct notification_client *client;
3138
3139 rcu_read_lock();
3140 client = get_client_from_id(client_id, state);
3141
3142 if (!client) {
3143 /*
3144 * Client error was probably already picked-up by the
3145 * notification thread or it has disconnected
3146 * gracefully while this command was queued.
3147 */
3148 DBG("Failed to find notification client to update communication status, client id = %" PRIu64,
3149 client_id);
3150 ret = 0;
3151 } else {
f2b3ef9f
JG
3152 ret = client_handle_transmission_status(
3153 client, client_status, state);
f2b3ef9f
JG
3154 }
3155 rcu_read_unlock();
3156 break;
3157 }
ab0ee2ca
JG
3158 default:
3159 ERR("[notification-thread] Unknown internal command received");
3160 goto error_unlock;
3161 }
3162
3163 if (ret) {
3164 goto error_unlock;
3165 }
3166end:
0ab399e0
JG
3167 if (cmd->is_async) {
3168 free(cmd);
3169 cmd = NULL;
3170 } else {
3171 lttng_waiter_wake_up(&cmd->reply_waiter);
3172 }
ab0ee2ca
JG
3173 return ret;
3174error_unlock:
3175 /* Wake-up and return a fatal error to the calling thread. */
8ada111f 3176 lttng_waiter_wake_up(&cmd->reply_waiter);
ab0ee2ca
JG
3177 cmd->reply_code = LTTNG_ERR_FATAL;
3178error:
3179 /* Indicate a fatal error to the caller. */
3180 return -1;
3181}
3182
ab0ee2ca
JG
3183static
3184int socket_set_non_blocking(int socket)
3185{
3186 int ret, flags;
3187
3188 /* Set the pipe as non-blocking. */
3189 ret = fcntl(socket, F_GETFL, 0);
3190 if (ret == -1) {
3191 PERROR("fcntl get socket flags");
3192 goto end;
3193 }
3194 flags = ret;
3195
3196 ret = fcntl(socket, F_SETFL, flags | O_NONBLOCK);
3197 if (ret == -1) {
3198 PERROR("fcntl set O_NONBLOCK socket flag");
3199 goto end;
3200 }
3201 DBG("Client socket (fd = %i) set as non-blocking", socket);
3202end:
3203 return ret;
3204}
3205
3206static
14fa22f8 3207int client_reset_inbound_state(struct notification_client *client)
ab0ee2ca
JG
3208{
3209 int ret;
3210
882093ee
JR
3211
3212 lttng_payload_clear(&client->communication.inbound.payload);
ab0ee2ca
JG
3213
3214 client->communication.inbound.bytes_to_receive =
3215 sizeof(struct lttng_notification_channel_message);
3216 client->communication.inbound.msg_type =
3217 LTTNG_NOTIFICATION_CHANNEL_MESSAGE_TYPE_UNKNOWN;