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