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