2 * Copyright (C) 2013 - David Goulet <dgoulet@efficios.com>
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License, version 2 only, as
6 * published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc., 51
15 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 #include <common/common.h>
22 #include <common/hashtable/utils.h>
24 #include "buffer-registry.h"
26 #include "ust-consumer.h"
27 #include "lttng-ust-ctl.h"
28 #include "lttng-ust-error.h"
32 * Set in main.c during initialization process of the daemon. This contains
33 * buffer_reg_uid object which are global registry for per UID buffer. Object
34 * are indexed by session id and matched by the triplet
35 * <session_id/bits_per_long/uid>.
37 static struct lttng_ht
*buffer_registry_uid
;
40 * Initialized at the daemon start. This contains buffer_reg_pid object and
41 * indexed by session id.
43 static struct lttng_ht
*buffer_registry_pid
;
46 * Match function for the per UID registry hash table. It matches a registry
47 * uid object with the triplet <session_id/abi/uid>.
49 static int ht_match_reg_uid(struct cds_lfht_node
*node
, const void *_key
)
51 struct buffer_reg_uid
*reg
;
52 const struct buffer_reg_uid
*key
;
57 reg
= caa_container_of(node
, struct buffer_reg_uid
, node
.node
);
61 if (key
->session_id
!= reg
->session_id
||
62 key
->bits_per_long
!= reg
->bits_per_long
||
63 key
->uid
!= reg
->uid
) {
74 * Hash function for the per UID registry hash table. This XOR the triplet
77 static unsigned long ht_hash_reg_uid(const void *_key
, unsigned long seed
)
80 const struct buffer_reg_uid
*key
= _key
;
84 xored_key
= (uint64_t)(key
->session_id
^ key
->bits_per_long
^ key
->uid
);
85 return hash_key_u64(&xored_key
, seed
);
89 * Initialize global buffer per UID registry. Should only be called ONCE!.
91 void buffer_reg_init_uid_registry(void)
93 /* Should be called once. */
94 assert(!buffer_registry_uid
);
95 buffer_registry_uid
= lttng_ht_new(0, LTTNG_HT_TYPE_U64
);
96 assert(buffer_registry_uid
);
97 buffer_registry_uid
->match_fct
= ht_match_reg_uid
;
98 buffer_registry_uid
->hash_fct
= ht_hash_reg_uid
;
100 DBG3("Global buffer per UID registry initialized");
104 * Allocate and initialize object. Set regp with the object pointer.
106 * Return 0 on success else a negative value and regp is untouched.
108 int buffer_reg_uid_create(uint64_t session_id
, uint32_t bits_per_long
, uid_t uid
,
109 enum lttng_domain_type domain
, struct buffer_reg_uid
**regp
,
110 const char *root_shm_path
, const char *shm_path
)
113 struct buffer_reg_uid
*reg
= NULL
;
117 reg
= zmalloc(sizeof(*reg
));
119 PERROR("zmalloc buffer registry uid");
124 reg
->registry
= zmalloc(sizeof(struct buffer_reg_session
));
125 if (!reg
->registry
) {
126 PERROR("zmalloc buffer registry uid session");
131 reg
->session_id
= session_id
;
132 reg
->bits_per_long
= bits_per_long
;
134 reg
->domain
= domain
;
136 strncpy(reg
->root_shm_path
, root_shm_path
, sizeof(reg
->root_shm_path
));
137 reg
->root_shm_path
[sizeof(reg
->root_shm_path
) - 1] = '\0';
138 strncpy(reg
->shm_path
, shm_path
, sizeof(reg
->shm_path
));
139 reg
->shm_path
[sizeof(reg
->shm_path
) - 1] = '\0';
140 DBG3("shm path '%s' is assigned to uid buffer registry for session id %" PRIu64
,
141 reg
->shm_path
, session_id
);
143 reg
->registry
->channels
= lttng_ht_new(0, LTTNG_HT_TYPE_U64
);
144 if (!reg
->registry
->channels
) {
149 cds_lfht_node_init(®
->node
.node
);
152 DBG3("Buffer registry per UID created id: %" PRIu64
", ABI: %u, uid: %d, domain: %d",
153 session_id
, bits_per_long
, uid
, domain
);
165 * Add a buffer registry per UID object to the global registry.
167 void buffer_reg_uid_add(struct buffer_reg_uid
*reg
)
169 struct cds_lfht_node
*nodep
;
170 struct lttng_ht
*ht
= buffer_registry_uid
;
174 DBG3("Buffer registry per UID adding to global registry with id: %" PRIu64
,
178 nodep
= cds_lfht_add_unique(ht
->ht
, ht
->hash_fct(reg
, lttng_ht_seed
),
179 ht
->match_fct
, reg
, ®
->node
.node
);
180 assert(nodep
== ®
->node
.node
);
185 * Find a buffer registry per UID object with given params. RCU read side lock
186 * MUST be acquired before calling this and hold on to protect the object.
188 * Return the object pointer or NULL on error.
190 struct buffer_reg_uid
*buffer_reg_uid_find(uint64_t session_id
,
191 uint32_t bits_per_long
, uid_t uid
)
193 struct lttng_ht_node_u64
*node
;
194 struct lttng_ht_iter iter
;
195 struct buffer_reg_uid
*reg
= NULL
, key
;
196 struct lttng_ht
*ht
= buffer_registry_uid
;
198 /* Setup key we are looking for. */
199 key
.session_id
= session_id
;
200 key
.bits_per_long
= bits_per_long
;
203 DBG3("Buffer registry per UID find id: %" PRIu64
", ABI: %u, uid: %d",
204 session_id
, bits_per_long
, uid
);
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
,
209 node
= lttng_ht_iter_get_node_u64(&iter
);
213 reg
= caa_container_of(node
, struct buffer_reg_uid
, node
);
220 * Initialize global buffer per PID registry. Should only be called ONCE!.
222 void buffer_reg_init_pid_registry(void)
224 /* Should be called once. */
225 assert(!buffer_registry_pid
);
226 buffer_registry_pid
= lttng_ht_new(0, LTTNG_HT_TYPE_U64
);
227 assert(buffer_registry_pid
);
229 DBG3("Global buffer per PID registry initialized");
233 * Allocate and initialize object. Set regp with the object pointer.
235 * Return 0 on success else a negative value and regp is untouched.
237 int buffer_reg_pid_create(uint64_t session_id
, struct buffer_reg_pid
**regp
,
238 const char *root_shm_path
, const char *shm_path
)
241 struct buffer_reg_pid
*reg
= NULL
;
245 reg
= zmalloc(sizeof(*reg
));
247 PERROR("zmalloc buffer registry pid");
252 reg
->registry
= zmalloc(sizeof(struct buffer_reg_session
));
253 if (!reg
->registry
) {
254 PERROR("zmalloc buffer registry pid session");
259 /* A cast is done here so we can use the session ID as a u64 ht node. */
260 reg
->session_id
= session_id
;
262 strncpy(reg
->root_shm_path
, root_shm_path
, sizeof(reg
->root_shm_path
));
263 reg
->root_shm_path
[sizeof(reg
->root_shm_path
) - 1] = '\0';
264 strncpy(reg
->shm_path
, shm_path
, sizeof(reg
->shm_path
));
265 reg
->shm_path
[sizeof(reg
->shm_path
) - 1] = '\0';
266 DBG3("shm path '%s' is assigned to pid buffer registry for session id %" PRIu64
,
267 reg
->shm_path
, session_id
);
269 reg
->registry
->channels
= lttng_ht_new(0, LTTNG_HT_TYPE_U64
);
270 if (!reg
->registry
->channels
) {
275 lttng_ht_node_init_u64(®
->node
, reg
->session_id
);
278 DBG3("Buffer registry per PID created with session id: %" PRIu64
,
291 * Add a buffer registry per PID object to the global registry.
293 void buffer_reg_pid_add(struct buffer_reg_pid
*reg
)
297 DBG3("Buffer registry per PID adding to global registry with id: %" PRIu64
,
301 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
= NULL
;
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_u64(&iter
);
325 reg
= caa_container_of(node
, struct 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(
337 struct cds_list_head
*buffer_reg_uid_list
,
338 uint64_t chan_key
, uint64_t *consumer_chan_key
)
340 struct lttng_ht_iter iter
;
341 struct buffer_reg_uid
*uid_reg
= NULL
;
342 struct buffer_reg_session
*session_reg
= NULL
;
343 struct buffer_reg_channel
*reg_chan
;
348 * For the per-uid registry, we have to iterate since we don't have the
349 * uid and bitness key.
351 cds_list_for_each_entry(uid_reg
, buffer_reg_uid_list
, lnode
) {
352 session_reg
= uid_reg
->registry
;
353 cds_lfht_for_each_entry(session_reg
->channels
->ht
,
354 &iter
.iter
, reg_chan
, node
.node
) {
355 if (reg_chan
->key
== chan_key
) {
356 *consumer_chan_key
= reg_chan
->consumer_key
;
369 * Allocate and initialize a buffer registry channel with the given key. Set
370 * regp with the object pointer.
372 * Return 0 on success or else a negative value keeping regp untouched.
374 int buffer_reg_channel_create(uint64_t key
, struct buffer_reg_channel
**regp
)
376 struct buffer_reg_channel
*reg
;
380 DBG3("Buffer registry channel create with key: %" PRIu64
, key
);
382 reg
= zmalloc(sizeof(*reg
));
384 PERROR("zmalloc buffer registry channel");
389 CDS_INIT_LIST_HEAD(®
->streams
);
390 pthread_mutex_init(®
->stream_list_lock
, NULL
);
392 lttng_ht_node_init_u64(®
->node
, key
);
399 * Allocate and initialize a buffer registry stream. Set regp with the object
402 * Return 0 on success or else a negative value keeping regp untouched.
404 int buffer_reg_stream_create(struct buffer_reg_stream
**regp
)
406 struct buffer_reg_stream
*reg
;
410 DBG3("Buffer registry creating stream");
412 reg
= zmalloc(sizeof(*reg
));
414 PERROR("zmalloc buffer registry stream");
424 * Add stream to the list in the channel.
426 void buffer_reg_stream_add(struct buffer_reg_stream
*stream
,
427 struct buffer_reg_channel
*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
,
442 struct buffer_reg_channel
*channel
)
448 lttng_ht_add_unique_u64(session
->channels
, &channel
->node
);
453 * Find a buffer registry channel object with the given key. RCU read side lock
454 * MUST be acquired and hold on until the object reference is not needed
457 * Return the object pointer or NULL on error.
459 struct buffer_reg_channel
*buffer_reg_channel_find(uint64_t key
,
460 struct buffer_reg_uid
*reg
)
462 struct lttng_ht_node_u64
*node
;
463 struct lttng_ht_iter iter
;
464 struct buffer_reg_channel
*chan
= NULL
;
469 switch (reg
->domain
) {
470 case LTTNG_DOMAIN_UST
:
471 ht
= reg
->registry
->channels
;
478 lttng_ht_lookup(ht
, &key
, &iter
);
479 node
= lttng_ht_iter_get_node_u64(&iter
);
483 chan
= caa_container_of(node
, struct buffer_reg_channel
, node
);
490 * Destroy a buffer registry stream with the given domain.
492 void buffer_reg_stream_destroy(struct buffer_reg_stream
*regp
,
493 enum lttng_domain_type domain
)
499 DBG3("Buffer registry stream destroy with handle %d",
500 regp
->obj
.ust
->handle
);
503 case LTTNG_DOMAIN_UST
:
507 ret
= ust_app_release_object(NULL
, regp
->obj
.ust
);
508 if (ret
< 0 && ret
!= -EPIPE
&& ret
!= -LTTNG_UST_ERR_EXITING
) {
509 ERR("Buffer reg stream release obj handle %d failed with ret %d",
510 regp
->obj
.ust
->handle
, ret
);
513 lttng_fd_put(LTTNG_FD_APPS
, 2);
525 * Remove buffer registry channel object from the session hash table. RCU read
526 * side lock MUST be acquired before calling this.
528 void buffer_reg_channel_remove(struct buffer_reg_session
*session
,
529 struct buffer_reg_channel
*regp
)
532 struct lttng_ht_iter iter
;
537 iter
.iter
.node
= ®p
->node
.node
;
538 ret
= lttng_ht_del(session
->channels
, &iter
);
543 * Destroy a buffer registry channel with the given domain.
545 void buffer_reg_channel_destroy(struct buffer_reg_channel
*regp
,
546 enum lttng_domain_type domain
)
552 DBG3("Buffer registry channel destroy with key %" PRIu32
, regp
->key
);
555 case LTTNG_DOMAIN_UST
:
558 struct buffer_reg_stream
*sreg
, *stmp
;
560 cds_list_for_each_entry_safe(sreg
, stmp
, ®p
->streams
, lnode
) {
561 cds_list_del(&sreg
->lnode
);
562 regp
->stream_count
--;
563 buffer_reg_stream_destroy(sreg
, domain
);
567 ret
= ust_app_release_object(NULL
, regp
->obj
.ust
);
568 if (ret
< 0 && ret
!= -EPIPE
&& ret
!= -LTTNG_UST_ERR_EXITING
) {
569 ERR("Buffer reg channel release obj handle %d failed with ret %d",
570 regp
->obj
.ust
->handle
, ret
);
574 lttng_fd_put(LTTNG_FD_APPS
, 1);
586 * Destroy a buffer registry session with the given domain.
588 * Should *NOT* be called with RCU read-side lock held.
590 static void buffer_reg_session_destroy(struct buffer_reg_session
*regp
,
591 enum lttng_domain_type domain
)
594 struct lttng_ht_iter iter
;
595 struct buffer_reg_channel
*reg_chan
;
597 DBG3("Buffer registry session destroy");
599 /* Destroy all channels. */
601 cds_lfht_for_each_entry(regp
->channels
->ht
, &iter
.iter
, reg_chan
,
603 ret
= lttng_ht_del(regp
->channels
, &iter
);
605 buffer_reg_channel_destroy(reg_chan
, domain
);
609 ht_cleanup_push(regp
->channels
);
612 case LTTNG_DOMAIN_UST
:
613 ust_registry_session_destroy(regp
->reg
.ust
);
625 * Remove buffer registry UID object from the global hash table.
627 void buffer_reg_uid_remove(struct buffer_reg_uid
*regp
)
630 struct lttng_ht_iter iter
;
635 iter
.iter
.node
= ®p
->node
.node
;
636 ret
= lttng_ht_del(buffer_registry_uid
, &iter
);
641 static void rcu_free_buffer_reg_uid(struct rcu_head
*head
)
643 struct lttng_ht_node_u64
*node
=
644 caa_container_of(head
, struct lttng_ht_node_u64
, head
);
645 struct buffer_reg_uid
*reg
=
646 caa_container_of(node
, struct buffer_reg_uid
, node
);
648 buffer_reg_session_destroy(reg
->registry
, reg
->domain
);
652 static void rcu_free_buffer_reg_pid(struct rcu_head
*head
)
654 struct lttng_ht_node_u64
*node
=
655 caa_container_of(head
, struct lttng_ht_node_u64
, head
);
656 struct buffer_reg_pid
*reg
=
657 caa_container_of(node
, struct buffer_reg_pid
, node
);
659 buffer_reg_session_destroy(reg
->registry
, LTTNG_DOMAIN_UST
);
664 * Destroy buffer registry per UID. The given pointer is NOT removed from any
665 * list or hash table. Use buffer_reg_pid_remove() before calling this function
666 * for the case that the object is in the global hash table.
668 void buffer_reg_uid_destroy(struct buffer_reg_uid
*regp
,
669 struct consumer_output
*consumer
)
671 struct consumer_socket
*socket
;
677 DBG3("Buffer registry per UID destroy with id: %" PRIu64
", ABI: %u, uid: %d",
678 regp
->session_id
, regp
->bits_per_long
, regp
->uid
);
685 /* Get the right socket from the consumer object. */
686 socket
= consumer_find_socket_by_bitness(regp
->bits_per_long
,
692 switch (regp
->domain
) {
693 case LTTNG_DOMAIN_UST
:
694 if (regp
->registry
->reg
.ust
->metadata_key
) {
695 /* Return value does not matter. This call will print errors. */
696 (void) consumer_close_metadata(socket
,
697 regp
->registry
->reg
.ust
->metadata_key
);
709 call_rcu(®p
->node
.head
, rcu_free_buffer_reg_uid
);
713 * Remove buffer registry UID object from the global hash table. RCU read side
714 * lock MUST be acquired before calling this.
716 void buffer_reg_pid_remove(struct buffer_reg_pid
*regp
)
719 struct lttng_ht_iter iter
;
723 iter
.iter
.node
= ®p
->node
.node
;
724 ret
= lttng_ht_del(buffer_registry_pid
, &iter
);
729 * Destroy buffer registry per PID. The pointer is NOT removed from the global
730 * hash table. Call buffer_reg_pid_remove() before that if the object was
731 * previously added to the global hash table.
733 void buffer_reg_pid_destroy(struct buffer_reg_pid
*regp
)
739 DBG3("Buffer registry per PID destroy with id: %" PRIu64
,
742 /* This registry is only used by UST. */
743 call_rcu(®p
->node
.head
, rcu_free_buffer_reg_pid
);
747 * Destroy per PID and UID registry hash table.
749 * Should *NOT* be called with RCU read-side lock held.
751 void buffer_reg_destroy_registries(void)
753 DBG3("Buffer registry destroy all registry");
754 ht_cleanup_push(buffer_registry_uid
);
755 ht_cleanup_push(buffer_registry_pid
);
This page took 0.04745 seconds and 5 git commands to generate.