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