2 * Copyright (C) 2013 David Goulet <dgoulet@efficios.com>
4 * SPDX-License-Identifier: GPL-2.0-only
9 #include "buffer-registry.hpp"
10 #include "fd-limit.hpp"
11 #include "lttng-ust-ctl.hpp"
12 #include "lttng-ust-error.hpp"
13 #include "ust-consumer.hpp"
16 #include <common/common.hpp>
17 #include <common/hashtable/utils.hpp>
18 #include <common/urcu.hpp>
23 * Set in main.c during initialization process of the daemon. This contains
24 * buffer_reg_uid object which are global registry for per UID buffer. Object
25 * are indexed by session id and matched by the triplet
26 * <session_id/bits_per_long/uid>.
28 static struct lttng_ht
*buffer_registry_uid
;
31 * Initialized at the daemon start. This contains buffer_reg_pid object and
32 * indexed by session id.
34 static struct lttng_ht
*buffer_registry_pid
;
37 * Match function for the per UID registry hash table. It matches a registry
38 * uid object with the triplet <session_id/abi/uid>.
40 static int ht_match_reg_uid(struct cds_lfht_node
*node
, const void *_key
)
42 struct buffer_reg_uid
*reg
;
43 const struct buffer_reg_uid
*key
;
48 reg
= caa_container_of(node
, struct buffer_reg_uid
, node
.node
);
50 key
= (buffer_reg_uid
*) _key
;
52 if (key
->session_id
!= reg
->session_id
|| key
->bits_per_long
!= reg
->bits_per_long
||
53 key
->uid
!= reg
->uid
) {
64 * Hash function for the per UID registry hash table. This XOR the triplet
67 static unsigned long ht_hash_reg_uid(const void *_key
, unsigned long seed
)
70 const struct buffer_reg_uid
*key
= (buffer_reg_uid
*) _key
;
74 xored_key
= (uint64_t) (key
->session_id
^ key
->bits_per_long
^ key
->uid
);
75 return hash_key_u64(&xored_key
, seed
);
79 * Initialize global buffer per UID registry. Should only be called ONCE!.
81 void buffer_reg_init_uid_registry()
83 /* Should be called once. */
84 LTTNG_ASSERT(!buffer_registry_uid
);
85 buffer_registry_uid
= lttng_ht_new(0, LTTNG_HT_TYPE_U64
);
86 LTTNG_ASSERT(buffer_registry_uid
);
87 buffer_registry_uid
->match_fct
= ht_match_reg_uid
;
88 buffer_registry_uid
->hash_fct
= ht_hash_reg_uid
;
90 DBG3("Global buffer per UID registry initialized");
94 * Allocate and initialize object. Set regp with the object pointer.
96 * Return 0 on success else a negative value and regp is untouched.
98 int buffer_reg_uid_create(uint64_t session_id
,
99 uint32_t bits_per_long
,
101 enum lttng_domain_type domain
,
102 struct buffer_reg_uid
**regp
,
103 const char *root_shm_path
,
104 const char *shm_path
)
107 struct buffer_reg_uid
*reg
= nullptr;
111 reg
= zmalloc
<buffer_reg_uid
>();
113 PERROR("zmalloc buffer registry uid");
118 reg
->registry
= zmalloc
<buffer_reg_session
>();
119 if (!reg
->registry
) {
120 PERROR("zmalloc buffer registry uid session");
125 reg
->session_id
= session_id
;
126 reg
->bits_per_long
= bits_per_long
;
128 reg
->domain
= domain
;
130 strncpy(reg
->root_shm_path
, root_shm_path
, sizeof(reg
->root_shm_path
));
131 reg
->root_shm_path
[sizeof(reg
->root_shm_path
) - 1] = '\0';
132 strncpy(reg
->shm_path
, shm_path
, sizeof(reg
->shm_path
));
133 reg
->shm_path
[sizeof(reg
->shm_path
) - 1] = '\0';
134 DBG3("shm path '%s' is assigned to uid buffer registry for session id %" PRIu64
,
138 reg
->registry
->channels
= lttng_ht_new(0, LTTNG_HT_TYPE_U64
);
139 if (!reg
->registry
->channels
) {
144 cds_lfht_node_init(®
->node
.node
);
147 DBG3("Buffer registry per UID created id: %" PRIu64
", ABI: %u, uid: %d, domain: %d",
163 * Add a buffer registry per UID object to the global registry.
165 void buffer_reg_uid_add(struct buffer_reg_uid
*reg
)
167 struct cds_lfht_node
*nodep
;
168 struct lttng_ht
*ht
= buffer_registry_uid
;
172 DBG3("Buffer registry per UID adding to global registry with id: %" PRIu64
,
175 lttng::urcu::read_lock_guard read_lock
;
176 nodep
= cds_lfht_add_unique(
177 ht
->ht
, ht
->hash_fct(reg
, lttng_ht_seed
), ht
->match_fct
, reg
, ®
->node
.node
);
178 LTTNG_ASSERT(nodep
== ®
->node
.node
);
182 * Find a buffer registry per UID object with given params. RCU read side lock
183 * MUST be acquired before calling this and hold on to protect the object.
185 * Return the object pointer or NULL on error.
187 struct buffer_reg_uid
*buffer_reg_uid_find(uint64_t session_id
, uint32_t bits_per_long
, uid_t uid
)
189 struct lttng_ht_node_u64
*node
;
190 struct lttng_ht_iter iter
;
191 struct buffer_reg_uid
*reg
= nullptr, key
;
192 struct lttng_ht
*ht
= buffer_registry_uid
;
194 ASSERT_RCU_READ_LOCKED();
196 /* Setup key we are looking for. */
197 key
.session_id
= session_id
;
198 key
.bits_per_long
= bits_per_long
;
201 DBG3("Buffer registry per UID find id: %" PRIu64
", ABI: %u, uid: %d",
206 /* Custom lookup function since it's a different key. */
207 cds_lfht_lookup(ht
->ht
, ht
->hash_fct(&key
, lttng_ht_seed
), ht
->match_fct
, &key
, &iter
.iter
);
208 node
= lttng_ht_iter_get_node
<lttng_ht_node_u64
>(&iter
);
212 reg
= lttng::utils::container_of(node
, &buffer_reg_uid::node
);
219 * Initialize global buffer per PID registry. Should only be called ONCE!.
221 void buffer_reg_init_pid_registry()
223 /* Should be called once. */
224 LTTNG_ASSERT(!buffer_registry_pid
);
225 buffer_registry_pid
= lttng_ht_new(0, LTTNG_HT_TYPE_U64
);
226 LTTNG_ASSERT(buffer_registry_pid
);
228 DBG3("Global buffer per PID registry initialized");
232 * Allocate and initialize object. Set regp with the object pointer.
234 * Return 0 on success else a negative value and regp is untouched.
236 int buffer_reg_pid_create(uint64_t session_id
,
237 struct buffer_reg_pid
**regp
,
238 const char *root_shm_path
,
239 const char *shm_path
)
242 struct buffer_reg_pid
*reg
= nullptr;
246 reg
= zmalloc
<buffer_reg_pid
>();
248 PERROR("zmalloc buffer registry pid");
253 reg
->registry
= zmalloc
<buffer_reg_session
>();
254 if (!reg
->registry
) {
255 PERROR("zmalloc buffer registry pid session");
260 /* A cast is done here so we can use the session ID as a u64 ht node. */
261 reg
->session_id
= session_id
;
263 strncpy(reg
->root_shm_path
, root_shm_path
, sizeof(reg
->root_shm_path
));
264 reg
->root_shm_path
[sizeof(reg
->root_shm_path
) - 1] = '\0';
265 strncpy(reg
->shm_path
, shm_path
, sizeof(reg
->shm_path
));
266 reg
->shm_path
[sizeof(reg
->shm_path
) - 1] = '\0';
267 DBG3("shm path '%s' is assigned to pid buffer registry for session id %" PRIu64
,
271 reg
->registry
->channels
= lttng_ht_new(0, LTTNG_HT_TYPE_U64
);
272 if (!reg
->registry
->channels
) {
277 lttng_ht_node_init_u64(®
->node
, reg
->session_id
);
280 DBG3("Buffer registry per PID created with session id: %" PRIu64
, session_id
);
292 * Add a buffer registry per PID object to the global registry.
294 void buffer_reg_pid_add(struct buffer_reg_pid
*reg
)
298 DBG3("Buffer registry per PID adding to global registry with id: %" PRIu64
,
301 lttng::urcu::read_lock_guard read_lock
;
302 lttng_ht_add_unique_u64(buffer_registry_pid
, ®
->node
);
306 * Find a buffer registry per PID object with given params. RCU read side lock
307 * MUST be acquired before calling this and hold on to protect the object.
309 * Return the object pointer or NULL on error.
311 struct buffer_reg_pid
*buffer_reg_pid_find(uint64_t session_id
)
313 struct lttng_ht_node_u64
*node
;
314 struct lttng_ht_iter iter
;
315 struct buffer_reg_pid
*reg
= nullptr;
316 struct lttng_ht
*ht
= buffer_registry_pid
;
318 DBG3("Buffer registry per PID find id: %" PRIu64
, session_id
);
320 lttng_ht_lookup(ht
, &session_id
, &iter
);
321 node
= lttng_ht_iter_get_node
<lttng_ht_node_u64
>(&iter
);
325 reg
= lttng::utils::container_of(node
, &buffer_reg_pid::node
);
332 * Find the consumer channel key from a UST session per-uid channel key.
334 * Return the matching key or -1 if not found.
336 int buffer_reg_uid_consumer_channel_key(struct cds_list_head
*buffer_reg_uid_list
,
338 uint64_t *consumer_chan_key
)
340 struct lttng_ht_iter iter
;
341 struct buffer_reg_uid
*uid_reg
= nullptr;
342 struct buffer_reg_session
*session_reg
= nullptr;
343 struct buffer_reg_channel
*reg_chan
;
347 lttng::urcu::read_lock_guard read_lock
;
350 * For the per-uid registry, we have to iterate since we don't have the
351 * uid and bitness key.
353 cds_list_for_each_entry (uid_reg
, buffer_reg_uid_list
, lnode
) {
354 session_reg
= uid_reg
->registry
;
355 cds_lfht_for_each_entry (
356 session_reg
->channels
->ht
, &iter
.iter
, reg_chan
, node
.node
) {
357 if (reg_chan
->key
== chan_key
) {
358 *consumer_chan_key
= reg_chan
->consumer_key
;
370 * Allocate and initialize a buffer registry channel with the given key. Set
371 * regp with the object pointer.
373 * Return 0 on success or else a negative value keeping regp untouched.
375 int buffer_reg_channel_create(uint64_t key
, struct buffer_reg_channel
**regp
)
377 struct buffer_reg_channel
*reg
;
381 DBG3("Buffer registry channel create with key: %" PRIu64
, key
);
383 reg
= zmalloc
<buffer_reg_channel
>();
385 PERROR("zmalloc buffer registry channel");
390 CDS_INIT_LIST_HEAD(®
->streams
);
391 pthread_mutex_init(®
->stream_list_lock
, nullptr);
393 lttng_ht_node_init_u64(®
->node
, key
);
400 * Allocate and initialize a buffer registry stream. Set regp with the object
403 * Return 0 on success or else a negative value keeping regp untouched.
405 int buffer_reg_stream_create(struct buffer_reg_stream
**regp
)
407 struct buffer_reg_stream
*reg
;
411 DBG3("Buffer registry creating stream");
413 reg
= zmalloc
<buffer_reg_stream
>();
415 PERROR("zmalloc buffer registry stream");
425 * Add stream to the list in the channel.
427 void buffer_reg_stream_add(struct buffer_reg_stream
*stream
, struct buffer_reg_channel
*channel
)
429 LTTNG_ASSERT(stream
);
430 LTTNG_ASSERT(channel
);
432 pthread_mutex_lock(&channel
->stream_list_lock
);
433 cds_list_add_tail(&stream
->lnode
, &channel
->streams
);
434 channel
->stream_count
++;
435 pthread_mutex_unlock(&channel
->stream_list_lock
);
439 * Add a buffer registry channel object to the given session.
441 void buffer_reg_channel_add(struct buffer_reg_session
*session
, struct buffer_reg_channel
*channel
)
443 LTTNG_ASSERT(session
);
444 LTTNG_ASSERT(channel
);
446 lttng::urcu::read_lock_guard read_lock
;
447 lttng_ht_add_unique_u64(session
->channels
, &channel
->node
);
451 * Find a buffer registry channel object with the given key. RCU read side lock
452 * MUST be acquired and hold on until the object reference is not needed
455 * Return the object pointer or NULL on error.
457 struct buffer_reg_channel
*buffer_reg_channel_find(uint64_t key
, struct buffer_reg_uid
*reg
)
459 struct lttng_ht_node_u64
*node
;
460 struct lttng_ht_iter iter
;
461 struct buffer_reg_channel
*chan
= nullptr;
466 switch (reg
->domain
) {
467 case LTTNG_DOMAIN_UST
:
468 ht
= reg
->registry
->channels
;
475 lttng_ht_lookup(ht
, &key
, &iter
);
476 node
= lttng_ht_iter_get_node
<lttng_ht_node_u64
>(&iter
);
480 chan
= lttng::utils::container_of(node
, &buffer_reg_channel::node
);
487 * Destroy a buffer registry stream with the given domain.
489 void buffer_reg_stream_destroy(struct buffer_reg_stream
*regp
, enum lttng_domain_type domain
)
495 DBG3("Buffer registry stream destroy with handle %d", regp
->obj
.ust
->handle
);
498 case LTTNG_DOMAIN_UST
:
502 ret
= ust_app_release_object(nullptr, regp
->obj
.ust
);
503 if (ret
< 0 && ret
!= -EPIPE
&& ret
!= -LTTNG_UST_ERR_EXITING
) {
504 ERR("Buffer reg stream release obj handle %d failed with ret %d",
505 regp
->obj
.ust
->handle
,
509 lttng_fd_put(LTTNG_FD_APPS
, 2);
521 * Remove buffer registry channel object from the session hash table. RCU read
522 * side lock MUST be acquired before calling this.
524 void buffer_reg_channel_remove(struct buffer_reg_session
*session
, struct buffer_reg_channel
*regp
)
527 struct lttng_ht_iter iter
;
529 LTTNG_ASSERT(session
);
532 iter
.iter
.node
= ®p
->node
.node
;
533 ret
= lttng_ht_del(session
->channels
, &iter
);
538 * Destroy a buffer registry channel with the given domain.
540 void buffer_reg_channel_destroy(struct buffer_reg_channel
*regp
, enum lttng_domain_type domain
)
546 DBG3("Buffer registry channel destroy with key %" PRIu32
, regp
->key
);
549 case LTTNG_DOMAIN_UST
:
552 struct buffer_reg_stream
*sreg
, *stmp
;
554 cds_list_for_each_entry_safe (sreg
, stmp
, ®p
->streams
, lnode
) {
555 cds_list_del(&sreg
->lnode
);
556 regp
->stream_count
--;
557 buffer_reg_stream_destroy(sreg
, domain
);
561 ret
= ust_app_release_object(nullptr, regp
->obj
.ust
);
562 if (ret
< 0 && ret
!= -EPIPE
&& ret
!= -LTTNG_UST_ERR_EXITING
) {
563 ERR("Buffer reg channel release obj handle %d failed with ret %d",
564 regp
->obj
.ust
->handle
,
569 lttng_fd_put(LTTNG_FD_APPS
, 1);
581 * Destroy a buffer registry session with the given domain.
583 static void buffer_reg_session_destroy(struct buffer_reg_session
*regp
,
584 enum lttng_domain_type domain
)
587 struct lttng_ht_iter iter
;
588 struct buffer_reg_channel
*reg_chan
;
590 DBG3("Buffer registry session destroy");
592 /* Destroy all channels. */
594 lttng::urcu::read_lock_guard read_lock
;
596 cds_lfht_for_each_entry (regp
->channels
->ht
, &iter
.iter
, reg_chan
, node
.node
) {
597 ret
= lttng_ht_del(regp
->channels
, &iter
);
599 buffer_reg_channel_destroy(reg_chan
, domain
);
603 lttng_ht_destroy(regp
->channels
);
606 case LTTNG_DOMAIN_UST
:
607 ust_registry_session_destroy(regp
->reg
.ust
);
618 * Remove buffer registry UID object from the global hash table.
620 void buffer_reg_uid_remove(struct buffer_reg_uid
*regp
)
623 struct lttng_ht_iter iter
;
627 lttng::urcu::read_lock_guard read_lock
;
628 iter
.iter
.node
= ®p
->node
.node
;
629 ret
= lttng_ht_del(buffer_registry_uid
, &iter
);
633 static void rcu_free_buffer_reg_uid(struct rcu_head
*head
)
635 struct lttng_ht_node_u64
*node
= lttng::utils::container_of(head
, <tng_ht_node_u64::head
);
636 struct buffer_reg_uid
*reg
= lttng::utils::container_of(node
, &buffer_reg_uid::node
);
638 buffer_reg_session_destroy(reg
->registry
, reg
->domain
);
642 static void rcu_free_buffer_reg_pid(struct rcu_head
*head
)
644 struct lttng_ht_node_u64
*node
= lttng::utils::container_of(head
, <tng_ht_node_u64::head
);
645 struct buffer_reg_pid
*reg
= lttng::utils::container_of(node
, &buffer_reg_pid::node
);
647 buffer_reg_session_destroy(reg
->registry
, LTTNG_DOMAIN_UST
);
652 * Destroy buffer registry per UID. The given pointer is NOT removed from any
653 * list or hash table. Use buffer_reg_pid_remove() before calling this function
654 * for the case that the object is in the global hash table.
656 void buffer_reg_uid_destroy(struct buffer_reg_uid
*regp
, struct consumer_output
*consumer
)
658 struct consumer_socket
*socket
;
664 DBG3("Buffer registry per UID destroy with id: %" PRIu64
", ABI: %u, uid: %d",
674 lttng::urcu::read_lock_guard read_lock
;
675 /* Get the right socket from the consumer object. */
676 socket
= consumer_find_socket_by_bitness(regp
->bits_per_long
, consumer
);
681 switch (regp
->domain
) {
682 case LTTNG_DOMAIN_UST
:
683 if (regp
->registry
->reg
.ust
->_metadata_key
) {
684 /* Return value does not matter. This call will print errors. */
685 (void) consumer_close_metadata(
686 socket
, regp
->registry
->reg
.ust
->_metadata_key
);
696 call_rcu(®p
->node
.head
, rcu_free_buffer_reg_uid
);
700 * Remove buffer registry UID object from the global hash table. RCU read side
701 * lock MUST be acquired before calling this.
703 void buffer_reg_pid_remove(struct buffer_reg_pid
*regp
)
706 struct lttng_ht_iter iter
;
710 iter
.iter
.node
= ®p
->node
.node
;
711 ret
= lttng_ht_del(buffer_registry_pid
, &iter
);
716 * Destroy buffer registry per PID. The pointer is NOT removed from the global
717 * hash table. Call buffer_reg_pid_remove() before that if the object was
718 * previously added to the global hash table.
720 void buffer_reg_pid_destroy(struct buffer_reg_pid
*regp
)
726 DBG3("Buffer registry per PID destroy with id: %" PRIu64
, regp
->session_id
);
728 /* This registry is only used by UST. */
729 call_rcu(®p
->node
.head
, rcu_free_buffer_reg_pid
);
733 * Destroy per PID and UID registry hash table.
735 void buffer_reg_destroy_registries()
737 DBG3("Buffer registry destroy all registry");
738 lttng_ht_destroy(buffer_registry_uid
);
739 lttng_ht_destroy(buffer_registry_pid
);