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