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