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