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