Fix: sessiond: assertion fails when getting name of trigger
[lttng-tools.git] / src / bin / lttng-sessiond / buffer-registry.c
1 /*
2 * Copyright (C) 2013 David Goulet <dgoulet@efficios.com>
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 */
7
8 #define _LGPL_SOURCE
9 #include <inttypes.h>
10
11 #include <common/common.h>
12 #include <common/hashtable/utils.h>
13
14 #include "buffer-registry.h"
15 #include "fd-limit.h"
16 #include "ust-consumer.h"
17 #include "lttng-ust-ctl.h"
18 #include "lttng-ust-error.h"
19 #include "utils.h"
20
21 /*
22 * Set in main.c during initialization process of the daemon. This contains
23 * buffer_reg_uid object which are global registry for per UID buffer. Object
24 * are indexed by session id and matched by the triplet
25 * <session_id/bits_per_long/uid>.
26 */
27 static struct lttng_ht *buffer_registry_uid;
28
29 /*
30 * Initialized at the daemon start. This contains buffer_reg_pid object and
31 * indexed by session id.
32 */
33 static struct lttng_ht *buffer_registry_pid;
34
35 /*
36 * Match function for the per UID registry hash table. It matches a registry
37 * uid object with the triplet <session_id/abi/uid>.
38 */
39 static int ht_match_reg_uid(struct cds_lfht_node *node, const void *_key)
40 {
41 struct buffer_reg_uid *reg;
42 const struct buffer_reg_uid *key;
43
44 assert(node);
45 assert(_key);
46
47 reg = caa_container_of(node, struct buffer_reg_uid, node.node);
48 assert(reg);
49 key = _key;
50
51 if (key->session_id != reg->session_id ||
52 key->bits_per_long != reg->bits_per_long ||
53 key->uid != reg->uid) {
54 goto no_match;
55 }
56
57 /* Match */
58 return 1;
59 no_match:
60 return 0;
61 }
62
63 /*
64 * Hash function for the per UID registry hash table. This XOR the triplet
65 * together.
66 */
67 static unsigned long ht_hash_reg_uid(const void *_key, unsigned long seed)
68 {
69 uint64_t xored_key;
70 const struct buffer_reg_uid *key = _key;
71
72 assert(key);
73
74 xored_key = (uint64_t)(key->session_id ^ key->bits_per_long ^ key->uid);
75 return hash_key_u64(&xored_key, seed);
76 }
77
78 /*
79 * Initialize global buffer per UID registry. Should only be called ONCE!.
80 */
81 void buffer_reg_init_uid_registry(void)
82 {
83 /* Should be called once. */
84 assert(!buffer_registry_uid);
85 buffer_registry_uid = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
86 assert(buffer_registry_uid);
87 buffer_registry_uid->match_fct = ht_match_reg_uid;
88 buffer_registry_uid->hash_fct = ht_hash_reg_uid;
89
90 DBG3("Global buffer per UID registry initialized");
91 }
92
93 /*
94 * Allocate and initialize object. Set regp with the object pointer.
95 *
96 * Return 0 on success else a negative value and regp is untouched.
97 */
98 int buffer_reg_uid_create(uint64_t session_id, uint32_t bits_per_long, uid_t uid,
99 enum lttng_domain_type domain, struct buffer_reg_uid **regp,
100 const char *root_shm_path, const char *shm_path)
101 {
102 int ret = 0;
103 struct buffer_reg_uid *reg = NULL;
104
105 assert(regp);
106
107 reg = zmalloc(sizeof(*reg));
108 if (!reg) {
109 PERROR("zmalloc buffer registry uid");
110 ret = -ENOMEM;
111 goto error;
112 }
113
114 reg->registry = zmalloc(sizeof(struct buffer_reg_session));
115 if (!reg->registry) {
116 PERROR("zmalloc buffer registry uid session");
117 ret = -ENOMEM;
118 goto error;
119 }
120
121 reg->session_id = session_id;
122 reg->bits_per_long = bits_per_long;
123 reg->uid = uid;
124 reg->domain = domain;
125 if (shm_path[0]) {
126 strncpy(reg->root_shm_path, root_shm_path, sizeof(reg->root_shm_path));
127 reg->root_shm_path[sizeof(reg->root_shm_path) - 1] = '\0';
128 strncpy(reg->shm_path, shm_path, sizeof(reg->shm_path));
129 reg->shm_path[sizeof(reg->shm_path) - 1] = '\0';
130 DBG3("shm path '%s' is assigned to uid buffer registry for session id %" PRIu64,
131 reg->shm_path, session_id);
132 }
133 reg->registry->channels = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
134 if (!reg->registry->channels) {
135 ret = -ENOMEM;
136 goto error_session;
137 }
138
139 cds_lfht_node_init(&reg->node.node);
140 *regp = reg;
141
142 DBG3("Buffer registry per UID created id: %" PRIu64 ", ABI: %u, uid: %d, domain: %d",
143 session_id, bits_per_long, uid, domain);
144
145 return 0;
146
147 error_session:
148 free(reg->registry);
149 error:
150 free(reg);
151 return ret;
152 }
153
154 /*
155 * Add a buffer registry per UID object to the global registry.
156 */
157 void buffer_reg_uid_add(struct buffer_reg_uid *reg)
158 {
159 struct cds_lfht_node *nodep;
160 struct lttng_ht *ht = buffer_registry_uid;
161
162 assert(reg);
163
164 DBG3("Buffer registry per UID adding to global registry with id: %" PRIu64 ,
165 reg->session_id);
166
167 rcu_read_lock();
168 nodep = cds_lfht_add_unique(ht->ht, ht->hash_fct(reg, lttng_ht_seed),
169 ht->match_fct, reg, &reg->node.node);
170 assert(nodep == &reg->node.node);
171 rcu_read_unlock();
172 }
173
174 /*
175 * Find a buffer registry per UID object with given params. RCU read side lock
176 * MUST be acquired before calling this and hold on to protect the object.
177 *
178 * Return the object pointer or NULL on error.
179 */
180 struct buffer_reg_uid *buffer_reg_uid_find(uint64_t session_id,
181 uint32_t bits_per_long, uid_t uid)
182 {
183 struct lttng_ht_node_u64 *node;
184 struct lttng_ht_iter iter;
185 struct buffer_reg_uid *reg = NULL, key;
186 struct lttng_ht *ht = buffer_registry_uid;
187
188 /* Setup key we are looking for. */
189 key.session_id = session_id;
190 key.bits_per_long = bits_per_long;
191 key.uid = uid;
192
193 DBG3("Buffer registry per UID find id: %" PRIu64 ", ABI: %u, uid: %d",
194 session_id, bits_per_long, uid);
195
196 /* Custom lookup function since it's a different key. */
197 cds_lfht_lookup(ht->ht, ht->hash_fct(&key, lttng_ht_seed), ht->match_fct,
198 &key, &iter.iter);
199 node = lttng_ht_iter_get_node_u64(&iter);
200 if (!node) {
201 goto end;
202 }
203 reg = caa_container_of(node, struct buffer_reg_uid, node);
204
205 end:
206 return reg;
207 }
208
209 /*
210 * Initialize global buffer per PID registry. Should only be called ONCE!.
211 */
212 void buffer_reg_init_pid_registry(void)
213 {
214 /* Should be called once. */
215 assert(!buffer_registry_pid);
216 buffer_registry_pid = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
217 assert(buffer_registry_pid);
218
219 DBG3("Global buffer per PID registry initialized");
220 }
221
222 /*
223 * Allocate and initialize object. Set regp with the object pointer.
224 *
225 * Return 0 on success else a negative value and regp is untouched.
226 */
227 int buffer_reg_pid_create(uint64_t session_id, struct buffer_reg_pid **regp,
228 const char *root_shm_path, const char *shm_path)
229 {
230 int ret = 0;
231 struct buffer_reg_pid *reg = NULL;
232
233 assert(regp);
234
235 reg = zmalloc(sizeof(*reg));
236 if (!reg) {
237 PERROR("zmalloc buffer registry pid");
238 ret = -ENOMEM;
239 goto error;
240 }
241
242 reg->registry = zmalloc(sizeof(struct buffer_reg_session));
243 if (!reg->registry) {
244 PERROR("zmalloc buffer registry pid session");
245 ret = -ENOMEM;
246 goto error;
247 }
248
249 /* A cast is done here so we can use the session ID as a u64 ht node. */
250 reg->session_id = session_id;
251 if (shm_path[0]) {
252 strncpy(reg->root_shm_path, root_shm_path, sizeof(reg->root_shm_path));
253 reg->root_shm_path[sizeof(reg->root_shm_path) - 1] = '\0';
254 strncpy(reg->shm_path, shm_path, sizeof(reg->shm_path));
255 reg->shm_path[sizeof(reg->shm_path) - 1] = '\0';
256 DBG3("shm path '%s' is assigned to pid buffer registry for session id %" PRIu64,
257 reg->shm_path, session_id);
258 }
259 reg->registry->channels = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
260 if (!reg->registry->channels) {
261 ret = -ENOMEM;
262 goto error_session;
263 }
264
265 lttng_ht_node_init_u64(&reg->node, reg->session_id);
266 *regp = reg;
267
268 DBG3("Buffer registry per PID created with session id: %" PRIu64,
269 session_id);
270
271 return 0;
272
273 error_session:
274 free(reg->registry);
275 error:
276 free(reg);
277 return ret;
278 }
279
280 /*
281 * Add a buffer registry per PID object to the global registry.
282 */
283 void buffer_reg_pid_add(struct buffer_reg_pid *reg)
284 {
285 assert(reg);
286
287 DBG3("Buffer registry per PID adding to global registry with id: %" PRIu64,
288 reg->session_id);
289
290 rcu_read_lock();
291 lttng_ht_add_unique_u64(buffer_registry_pid, &reg->node);
292 rcu_read_unlock();
293 }
294
295 /*
296 * Find a buffer registry per PID object with given params. RCU read side lock
297 * MUST be acquired before calling this and hold on to protect the object.
298 *
299 * Return the object pointer or NULL on error.
300 */
301 struct buffer_reg_pid *buffer_reg_pid_find(uint64_t session_id)
302 {
303 struct lttng_ht_node_u64 *node;
304 struct lttng_ht_iter iter;
305 struct buffer_reg_pid *reg = NULL;
306 struct lttng_ht *ht = buffer_registry_pid;
307
308 DBG3("Buffer registry per PID find id: %" PRIu64, session_id);
309
310 lttng_ht_lookup(ht, &session_id, &iter);
311 node = lttng_ht_iter_get_node_u64(&iter);
312 if (!node) {
313 goto end;
314 }
315 reg = caa_container_of(node, struct buffer_reg_pid, node);
316
317 end:
318 return reg;
319 }
320
321 /*
322 * Find the consumer channel key from a UST session per-uid channel key.
323 *
324 * Return the matching key or -1 if not found.
325 */
326 int buffer_reg_uid_consumer_channel_key(
327 struct cds_list_head *buffer_reg_uid_list,
328 uint64_t chan_key, uint64_t *consumer_chan_key)
329 {
330 struct lttng_ht_iter iter;
331 struct buffer_reg_uid *uid_reg = NULL;
332 struct buffer_reg_session *session_reg = NULL;
333 struct buffer_reg_channel *reg_chan;
334 int ret = -1;
335
336 rcu_read_lock();
337 /*
338 * For the per-uid registry, we have to iterate since we don't have the
339 * uid and bitness key.
340 */
341 cds_list_for_each_entry(uid_reg, buffer_reg_uid_list, lnode) {
342 session_reg = uid_reg->registry;
343 cds_lfht_for_each_entry(session_reg->channels->ht,
344 &iter.iter, reg_chan, node.node) {
345 if (reg_chan->key == chan_key) {
346 *consumer_chan_key = reg_chan->consumer_key;
347 ret = 0;
348 goto end;
349 }
350 }
351 }
352
353 end:
354 rcu_read_unlock();
355 return ret;
356 }
357
358 /*
359 * Allocate and initialize a buffer registry channel with the given key. Set
360 * regp with the object pointer.
361 *
362 * Return 0 on success or else a negative value keeping regp untouched.
363 */
364 int buffer_reg_channel_create(uint64_t key, struct buffer_reg_channel **regp)
365 {
366 struct buffer_reg_channel *reg;
367
368 assert(regp);
369
370 DBG3("Buffer registry channel create with key: %" PRIu64, key);
371
372 reg = zmalloc(sizeof(*reg));
373 if (!reg) {
374 PERROR("zmalloc buffer registry channel");
375 return -ENOMEM;
376 }
377
378 reg->key = key;
379 CDS_INIT_LIST_HEAD(&reg->streams);
380 pthread_mutex_init(&reg->stream_list_lock, NULL);
381
382 lttng_ht_node_init_u64(&reg->node, key);
383 *regp = reg;
384
385 return 0;
386 }
387
388 /*
389 * Allocate and initialize a buffer registry stream. Set regp with the object
390 * pointer.
391 *
392 * Return 0 on success or else a negative value keeping regp untouched.
393 */
394 int buffer_reg_stream_create(struct buffer_reg_stream **regp)
395 {
396 struct buffer_reg_stream *reg;
397
398 assert(regp);
399
400 DBG3("Buffer registry creating stream");
401
402 reg = zmalloc(sizeof(*reg));
403 if (!reg) {
404 PERROR("zmalloc buffer registry stream");
405 return -ENOMEM;
406 }
407
408 *regp = reg;
409
410 return 0;
411 }
412
413 /*
414 * Add stream to the list in the channel.
415 */
416 void buffer_reg_stream_add(struct buffer_reg_stream *stream,
417 struct buffer_reg_channel *channel)
418 {
419 assert(stream);
420 assert(channel);
421
422 pthread_mutex_lock(&channel->stream_list_lock);
423 cds_list_add_tail(&stream->lnode, &channel->streams);
424 channel->stream_count++;
425 pthread_mutex_unlock(&channel->stream_list_lock);
426 }
427
428 /*
429 * Add a buffer registry channel object to the given session.
430 */
431 void buffer_reg_channel_add(struct buffer_reg_session *session,
432 struct buffer_reg_channel *channel)
433 {
434 assert(session);
435 assert(channel);
436
437 rcu_read_lock();
438 lttng_ht_add_unique_u64(session->channels, &channel->node);
439 rcu_read_unlock();
440 }
441
442 /*
443 * Find a buffer registry channel object with the given key. RCU read side lock
444 * MUST be acquired and hold on until the object reference is not needed
445 * anymore.
446 *
447 * Return the object pointer or NULL on error.
448 */
449 struct buffer_reg_channel *buffer_reg_channel_find(uint64_t key,
450 struct buffer_reg_uid *reg)
451 {
452 struct lttng_ht_node_u64 *node;
453 struct lttng_ht_iter iter;
454 struct buffer_reg_channel *chan = NULL;
455 struct lttng_ht *ht;
456
457 assert(reg);
458
459 switch (reg->domain) {
460 case LTTNG_DOMAIN_UST:
461 ht = reg->registry->channels;
462 break;
463 default:
464 assert(0);
465 goto end;
466 }
467
468 lttng_ht_lookup(ht, &key, &iter);
469 node = lttng_ht_iter_get_node_u64(&iter);
470 if (!node) {
471 goto end;
472 }
473 chan = caa_container_of(node, struct buffer_reg_channel, node);
474
475 end:
476 return chan;
477 }
478
479 /*
480 * Destroy a buffer registry stream with the given domain.
481 */
482 void buffer_reg_stream_destroy(struct buffer_reg_stream *regp,
483 enum lttng_domain_type domain)
484 {
485 if (!regp) {
486 return;
487 }
488
489 DBG3("Buffer registry stream destroy with handle %d",
490 regp->obj.ust->handle);
491
492 switch (domain) {
493 case LTTNG_DOMAIN_UST:
494 {
495 int ret;
496
497 ret = ust_app_release_object(NULL, regp->obj.ust);
498 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
499 ERR("Buffer reg stream release obj handle %d failed with ret %d",
500 regp->obj.ust->handle, ret);
501 }
502 free(regp->obj.ust);
503 lttng_fd_put(LTTNG_FD_APPS, 2);
504 break;
505 }
506 default:
507 assert(0);
508 }
509
510 free(regp);
511 return;
512 }
513
514 /*
515 * Remove buffer registry channel object from the session hash table. RCU read
516 * side lock MUST be acquired before calling this.
517 */
518 void buffer_reg_channel_remove(struct buffer_reg_session *session,
519 struct buffer_reg_channel *regp)
520 {
521 int ret;
522 struct lttng_ht_iter iter;
523
524 assert(session);
525 assert(regp);
526
527 iter.iter.node = &regp->node.node;
528 ret = lttng_ht_del(session->channels, &iter);
529 assert(!ret);
530 }
531
532 /*
533 * Destroy a buffer registry channel with the given domain.
534 */
535 void buffer_reg_channel_destroy(struct buffer_reg_channel *regp,
536 enum lttng_domain_type domain)
537 {
538 if (!regp) {
539 return;
540 }
541
542 DBG3("Buffer registry channel destroy with key %" PRIu32, regp->key);
543
544 switch (domain) {
545 case LTTNG_DOMAIN_UST:
546 {
547 int ret;
548 struct buffer_reg_stream *sreg, *stmp;
549 /* Wipe stream */
550 cds_list_for_each_entry_safe(sreg, stmp, &regp->streams, lnode) {
551 cds_list_del(&sreg->lnode);
552 regp->stream_count--;
553 buffer_reg_stream_destroy(sreg, domain);
554 }
555
556 if (regp->obj.ust) {
557 ret = ust_app_release_object(NULL, regp->obj.ust);
558 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
559 ERR("Buffer reg channel release obj handle %d failed with ret %d",
560 regp->obj.ust->handle, ret);
561 }
562 free(regp->obj.ust);
563 }
564 lttng_fd_put(LTTNG_FD_APPS, 1);
565 break;
566 }
567 default:
568 assert(0);
569 }
570
571 free(regp);
572 return;
573 }
574
575 /*
576 * Destroy a buffer registry session with the given domain.
577 *
578 * Should *NOT* be called with RCU read-side lock held.
579 */
580 static void buffer_reg_session_destroy(struct buffer_reg_session *regp,
581 enum lttng_domain_type domain)
582 {
583 int ret;
584 struct lttng_ht_iter iter;
585 struct buffer_reg_channel *reg_chan;
586
587 DBG3("Buffer registry session destroy");
588
589 /* Destroy all channels. */
590 rcu_read_lock();
591 cds_lfht_for_each_entry(regp->channels->ht, &iter.iter, reg_chan,
592 node.node) {
593 ret = lttng_ht_del(regp->channels, &iter);
594 assert(!ret);
595 buffer_reg_channel_destroy(reg_chan, domain);
596 }
597 rcu_read_unlock();
598
599 ht_cleanup_push(regp->channels);
600
601 switch (domain) {
602 case LTTNG_DOMAIN_UST:
603 ust_registry_session_destroy(regp->reg.ust);
604 free(regp->reg.ust);
605 break;
606 default:
607 assert(0);
608 }
609
610 free(regp);
611 return;
612 }
613
614 /*
615 * Remove buffer registry UID object from the global hash table.
616 */
617 void buffer_reg_uid_remove(struct buffer_reg_uid *regp)
618 {
619 int ret;
620 struct lttng_ht_iter iter;
621
622 assert(regp);
623
624 rcu_read_lock();
625 iter.iter.node = &regp->node.node;
626 ret = lttng_ht_del(buffer_registry_uid, &iter);
627 assert(!ret);
628 rcu_read_unlock();
629 }
630
631 static void rcu_free_buffer_reg_uid(struct rcu_head *head)
632 {
633 struct lttng_ht_node_u64 *node =
634 caa_container_of(head, struct lttng_ht_node_u64, head);
635 struct buffer_reg_uid *reg =
636 caa_container_of(node, struct buffer_reg_uid, node);
637
638 buffer_reg_session_destroy(reg->registry, reg->domain);
639 free(reg);
640 }
641
642 static void rcu_free_buffer_reg_pid(struct rcu_head *head)
643 {
644 struct lttng_ht_node_u64 *node =
645 caa_container_of(head, struct lttng_ht_node_u64, head);
646 struct buffer_reg_pid *reg =
647 caa_container_of(node, struct buffer_reg_pid, node);
648
649 buffer_reg_session_destroy(reg->registry, LTTNG_DOMAIN_UST);
650 free(reg);
651 }
652
653 /*
654 * Destroy buffer registry per UID. The given pointer is NOT removed from any
655 * list or hash table. Use buffer_reg_pid_remove() before calling this function
656 * for the case that the object is in the global hash table.
657 */
658 void buffer_reg_uid_destroy(struct buffer_reg_uid *regp,
659 struct consumer_output *consumer)
660 {
661 struct consumer_socket *socket;
662
663 if (!regp) {
664 return;
665 }
666
667 DBG3("Buffer registry per UID destroy with id: %" PRIu64 ", ABI: %u, uid: %d",
668 regp->session_id, regp->bits_per_long, regp->uid);
669
670 if (!consumer) {
671 goto destroy;
672 }
673
674 rcu_read_lock();
675 /* Get the right socket from the consumer object. */
676 socket = consumer_find_socket_by_bitness(regp->bits_per_long,
677 consumer);
678 if (!socket) {
679 goto unlock;
680 }
681
682 switch (regp->domain) {
683 case LTTNG_DOMAIN_UST:
684 if (regp->registry->reg.ust->metadata_key) {
685 /* Return value does not matter. This call will print errors. */
686 (void) consumer_close_metadata(socket,
687 regp->registry->reg.ust->metadata_key);
688 }
689 break;
690 default:
691 assert(0);
692 rcu_read_unlock();
693 return;
694 }
695
696 unlock:
697 rcu_read_unlock();
698 destroy:
699 call_rcu(&regp->node.head, rcu_free_buffer_reg_uid);
700 }
701
702 /*
703 * Remove buffer registry UID object from the global hash table. RCU read side
704 * lock MUST be acquired before calling this.
705 */
706 void buffer_reg_pid_remove(struct buffer_reg_pid *regp)
707 {
708 int ret;
709 struct lttng_ht_iter iter;
710
711 assert(regp);
712
713 iter.iter.node = &regp->node.node;
714 ret = lttng_ht_del(buffer_registry_pid, &iter);
715 assert(!ret);
716 }
717
718 /*
719 * Destroy buffer registry per PID. The pointer is NOT removed from the global
720 * hash table. Call buffer_reg_pid_remove() before that if the object was
721 * previously added to the global hash table.
722 */
723 void buffer_reg_pid_destroy(struct buffer_reg_pid *regp)
724 {
725 if (!regp) {
726 return;
727 }
728
729 DBG3("Buffer registry per PID destroy with id: %" PRIu64,
730 regp->session_id);
731
732 /* This registry is only used by UST. */
733 call_rcu(&regp->node.head, rcu_free_buffer_reg_pid);
734 }
735
736 /*
737 * Destroy per PID and UID registry hash table.
738 *
739 * Should *NOT* be called with RCU read-side lock held.
740 */
741 void buffer_reg_destroy_registries(void)
742 {
743 DBG3("Buffer registry destroy all registry");
744 ht_cleanup_push(buffer_registry_uid);
745 ht_cleanup_push(buffer_registry_pid);
746 }
This page took 0.046693 seconds and 4 git commands to generate.