src/bin/lttng-sessiond/buffer-registry.cpp

   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 "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"
  14 #include "utils.hpp"
  15
  16 #include <common/common.hpp>
  17 #include <common/hashtable/utils.hpp>
  18 #include <common/urcu.hpp>
  19
  20 #include <inttypes.h>
  21
  22 /*
  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>.
  27  */
  28 static struct lttng_ht *buffer_registry_uid;
  29
  30 /*
  31  * Initialized at the daemon start. This contains buffer_reg_pid object and
  32  * indexed by session id.
  33  */
  34 static struct lttng_ht *buffer_registry_pid;
  35
  36 /*
  37  * Match function for the per UID registry hash table. It matches a registry
  38  * uid object with the triplet <session_id/abi/uid>.
  39  */
  40 static int ht_match_reg_uid(struct cds_lfht_node *node, const void *_key)
  41 {
  42         struct buffer_reg_uid *reg;
  43         const struct buffer_reg_uid *key;
  44
  45         LTTNG_ASSERT(node);
  46         LTTNG_ASSERT(_key);
  47
  48         reg = caa_container_of(node, struct buffer_reg_uid, node.node);
  49         LTTNG_ASSERT(reg);
  50         key = (buffer_reg_uid *) _key;
  51
  52         if (key->session_id != reg->session_id || 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 = (buffer_reg_uid *) _key;
  71
  72         LTTNG_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()
  82 {
  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;
  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,
  99                           uint32_t bits_per_long,
 100                           uid_t uid,
 101                           enum lttng_domain_type domain,
 102                           struct buffer_reg_uid **regp,
 103                           const char *root_shm_path,
 104                           const char *shm_path)
 105 {
 106         int ret = 0;
 107         struct buffer_reg_uid *reg = nullptr;
 108
 109         LTTNG_ASSERT(regp);
 110
 111         reg = zmalloc<buffer_reg_uid>();
 112         if (!reg) {
 113                 PERROR("zmalloc buffer registry uid");
 114                 ret = -ENOMEM;
 115                 goto error;
 116         }
 117
 118         reg->registry = zmalloc<buffer_reg_session>();
 119         if (!reg->registry) {
 120                 PERROR("zmalloc buffer registry uid session");
 121                 ret = -ENOMEM;
 122                 goto error;
 123         }
 124
 125         reg->session_id = session_id;
 126         reg->bits_per_long = bits_per_long;
 127         reg->uid = uid;
 128         reg->domain = domain;
 129         if (shm_path[0]) {
 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,
 135                      reg->shm_path,
 136                      session_id);
 137         }
 138         reg->registry->channels = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
 139         if (!reg->registry->channels) {
 140                 ret = -ENOMEM;
 141                 goto error_session;
 142         }
 143
 144         cds_lfht_node_init(&reg->node.node);
 145         *regp = reg;
 146
 147         DBG3("Buffer registry per UID created id: %" PRIu64 ", ABI: %u, uid: %d, domain: %d",
 148              session_id,
 149              bits_per_long,
 150              uid,
 151              domain);
 152
 153         return 0;
 154
 155 error_session:
 156         free(reg->registry);
 157 error:
 158         free(reg);
 159         return ret;
 160 }
 161
 162 /*
 163  * Add a buffer registry per UID object to the global registry.
 164  */
 165 void buffer_reg_uid_add(struct buffer_reg_uid *reg)
 166 {
 167         struct cds_lfht_node *nodep;
 168         struct lttng_ht *ht = buffer_registry_uid;
 169
 170         LTTNG_ASSERT(reg);
 171
 172         DBG3("Buffer registry per UID adding to global registry with id: %" PRIu64,
 173              reg->session_id);
 174
 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, &reg->node.node);
 178         LTTNG_ASSERT(nodep == &reg->node.node);
 179 }
 180
 181 /*
 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.
 184  *
 185  * Return the object pointer or NULL on error.
 186  */
 187 struct buffer_reg_uid *buffer_reg_uid_find(uint64_t session_id, uint32_t bits_per_long, uid_t uid)
 188 {
 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;
 193
 194         ASSERT_RCU_READ_LOCKED();
 195
 196         /* Setup key we are looking for. */
 197         key.session_id = session_id;
 198         key.bits_per_long = bits_per_long;
 199         key.uid = uid;
 200
 201         DBG3("Buffer registry per UID find id: %" PRIu64 ", ABI: %u, uid: %d",
 202              session_id,
 203              bits_per_long,
 204              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, &key, &iter.iter);
 208         node = lttng_ht_iter_get_node_u64(&iter);
 209         if (!node) {
 210                 goto end;
 211         }
 212         reg = lttng::utils::container_of(node, &buffer_reg_uid::node);
 213
 214 end:
 215         return reg;
 216 }
 217
 218 /*
 219  * Initialize global buffer per PID registry. Should only be called ONCE!.
 220  */
 221 void buffer_reg_init_pid_registry()
 222 {
 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);
 227
 228         DBG3("Global buffer per PID registry initialized");
 229 }
 230
 231 /*
 232  * Allocate and initialize object. Set regp with the object pointer.
 233  *
 234  * Return 0 on success else a negative value and regp is untouched.
 235  */
 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)
 240 {
 241         int ret = 0;
 242         struct buffer_reg_pid *reg = nullptr;
 243
 244         LTTNG_ASSERT(regp);
 245
 246         reg = zmalloc<buffer_reg_pid>();
 247         if (!reg) {
 248                 PERROR("zmalloc buffer registry pid");
 249                 ret = -ENOMEM;
 250                 goto error;
 251         }
 252
 253         reg->registry = zmalloc<buffer_reg_session>();
 254         if (!reg->registry) {
 255                 PERROR("zmalloc buffer registry pid session");
 256                 ret = -ENOMEM;
 257                 goto error;
 258         }
 259
 260         /* A cast is done here so we can use the session ID as a u64 ht node. */
 261         reg->session_id = session_id;
 262         if (shm_path[0]) {
 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,
 268                      reg->shm_path,
 269                      session_id);
 270         }
 271         reg->registry->channels = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
 272         if (!reg->registry->channels) {
 273                 ret = -ENOMEM;
 274                 goto error_session;
 275         }
 276
 277         lttng_ht_node_init_u64(&reg->node, reg->session_id);
 278         *regp = reg;
 279
 280         DBG3("Buffer registry per PID created with session id: %" PRIu64, session_id);
 281
 282         return 0;
 283
 284 error_session:
 285         free(reg->registry);
 286 error:
 287         free(reg);
 288         return ret;
 289 }
 290
 291 /*
 292  * Add a buffer registry per PID object to the global registry.
 293  */
 294 void buffer_reg_pid_add(struct buffer_reg_pid *reg)
 295 {
 296         LTTNG_ASSERT(reg);
 297
 298         DBG3("Buffer registry per PID adding to global registry with id: %" PRIu64,
 299              reg->session_id);
 300
 301         lttng::urcu::read_lock_guard read_lock;
 302         lttng_ht_add_unique_u64(buffer_registry_pid, &reg->node);
 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  */
 311 struct buffer_reg_pid *buffer_reg_pid_find(uint64_t session_id)
 312 {
 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;
 317
 318         DBG3("Buffer registry per PID find id: %" PRIu64, session_id);
 319
 320         lttng_ht_lookup(ht, &session_id, &iter);
 321         node = lttng_ht_iter_get_node_u64(&iter);
 322         if (!node) {
 323                 goto end;
 324         }
 325         reg = lttng::utils::container_of(node, &buffer_reg_pid::node);
 326
 327 end:
 328         return reg;
 329 }
 330
 331 /*
 332  * Find the consumer channel key from a UST session per-uid channel key.
 333  *
 334  * Return the matching key or -1 if not found.
 335  */
 336 int buffer_reg_uid_consumer_channel_key(struct cds_list_head *buffer_reg_uid_list,
 337                                         uint64_t chan_key,
 338                                         uint64_t *consumer_chan_key)
 339 {
 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;
 344         int ret = -1;
 345
 346         {
 347                 lttng::urcu::read_lock_guard read_lock;
 348
 349                 /*
 350                  * For the per-uid registry, we have to iterate since we don't have the
 351                  * uid and bitness key.
 352                  */
 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;
 359                                         ret = 0;
 360                                         goto end;
 361                                 }
 362                         }
 363                 }
 364         }
 365 end:
 366         return ret;
 367 }
 368
 369 /*
 370  * Allocate and initialize a buffer registry channel with the given key. Set
 371  * regp with the object pointer.
 372  *
 373  * Return 0 on success or else a negative value keeping regp untouched.
 374  */
 375 int buffer_reg_channel_create(uint64_t key, struct buffer_reg_channel **regp)
 376 {
 377         struct buffer_reg_channel *reg;
 378
 379         LTTNG_ASSERT(regp);
 380
 381         DBG3("Buffer registry channel create with key: %" PRIu64, key);
 382
 383         reg = zmalloc<buffer_reg_channel>();
 384         if (!reg) {
 385                 PERROR("zmalloc buffer registry channel");
 386                 return -ENOMEM;
 387         }
 388
 389         reg->key = key;
 390         CDS_INIT_LIST_HEAD(&reg->streams);
 391         pthread_mutex_init(&reg->stream_list_lock, nullptr);
 392
 393         lttng_ht_node_init_u64(&reg->node, key);
 394         *regp = reg;
 395
 396         return 0;
 397 }
 398
 399 /*
 400  * Allocate and initialize a buffer registry stream. Set regp with the object
 401  * pointer.
 402  *
 403  * Return 0 on success or else a negative value keeping regp untouched.
 404  */
 405 int buffer_reg_stream_create(struct buffer_reg_stream **regp)
 406 {
 407         struct buffer_reg_stream *reg;
 408
 409         LTTNG_ASSERT(regp);
 410
 411         DBG3("Buffer registry creating stream");
 412
 413         reg = zmalloc<buffer_reg_stream>();
 414         if (!reg) {
 415                 PERROR("zmalloc buffer registry stream");
 416                 return -ENOMEM;
 417         }
 418
 419         *regp = reg;
 420
 421         return 0;
 422 }
 423
 424 /*
 425  * Add stream to the list in the channel.
 426  */
 427 void buffer_reg_stream_add(struct buffer_reg_stream *stream, struct buffer_reg_channel *channel)
 428 {
 429         LTTNG_ASSERT(stream);
 430         LTTNG_ASSERT(channel);
 431
 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);
 436 }
 437
 438 /*
 439  * Add a buffer registry channel object to the given session.
 440  */
 441 void buffer_reg_channel_add(struct buffer_reg_session *session, struct buffer_reg_channel *channel)
 442 {
 443         LTTNG_ASSERT(session);
 444         LTTNG_ASSERT(channel);
 445
 446         lttng::urcu::read_lock_guard read_lock;
 447         lttng_ht_add_unique_u64(session->channels, &channel->node);
 448 }
 449
 450 /*
 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
 453  * anymore.
 454  *
 455  * Return the object pointer or NULL on error.
 456  */
 457 struct buffer_reg_channel *buffer_reg_channel_find(uint64_t key, struct buffer_reg_uid *reg)
 458 {
 459         struct lttng_ht_node_u64 *node;
 460         struct lttng_ht_iter iter;
 461         struct buffer_reg_channel *chan = nullptr;
 462         struct lttng_ht *ht;
 463
 464         LTTNG_ASSERT(reg);
 465
 466         switch (reg->domain) {
 467         case LTTNG_DOMAIN_UST:
 468                 ht = reg->registry->channels;
 469                 break;
 470         default:
 471                 abort();
 472                 goto end;
 473         }
 474
 475         lttng_ht_lookup(ht, &key, &iter);
 476         node = lttng_ht_iter_get_node_u64(&iter);
 477         if (!node) {
 478                 goto end;
 479         }
 480         chan = lttng::utils::container_of(node, &buffer_reg_channel::node);
 481
 482 end:
 483         return chan;
 484 }
 485
 486 /*
 487  * Destroy a buffer registry stream with the given domain.
 488  */
 489 void buffer_reg_stream_destroy(struct buffer_reg_stream *regp, enum lttng_domain_type domain)
 490 {
 491         if (!regp) {
 492                 return;
 493         }
 494
 495         DBG3("Buffer registry stream destroy with handle %d", regp->obj.ust->handle);
 496
 497         switch (domain) {
 498         case LTTNG_DOMAIN_UST:
 499         {
 500                 int ret;
 501
 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,
 506                             ret);
 507                 }
 508                 free(regp->obj.ust);
 509                 lttng_fd_put(LTTNG_FD_APPS, 2);
 510                 break;
 511         }
 512         default:
 513                 abort();
 514         }
 515
 516         free(regp);
 517         return;
 518 }
 519
 520 /*
 521  * Remove buffer registry channel object from the session hash table. RCU read
 522  * side lock MUST be acquired before calling this.
 523  */
 524 void buffer_reg_channel_remove(struct buffer_reg_session *session, struct buffer_reg_channel *regp)
 525 {
 526         int ret;
 527         struct lttng_ht_iter iter;
 528
 529         LTTNG_ASSERT(session);
 530         LTTNG_ASSERT(regp);
 531
 532         iter.iter.node = &regp->node.node;
 533         ret = lttng_ht_del(session->channels, &iter);
 534         LTTNG_ASSERT(!ret);
 535 }
 536
 537 /*
 538  * Destroy a buffer registry channel with the given domain.
 539  */
 540 void buffer_reg_channel_destroy(struct buffer_reg_channel *regp, enum lttng_domain_type domain)
 541 {
 542         if (!regp) {
 543                 return;
 544         }
 545
 546         DBG3("Buffer registry channel destroy with key %" PRIu32, regp->key);
 547
 548         switch (domain) {
 549         case LTTNG_DOMAIN_UST:
 550         {
 551                 int ret;
 552                 struct buffer_reg_stream *sreg, *stmp;
 553                 /* Wipe stream */
 554                 cds_list_for_each_entry_safe (sreg, stmp, &regp->streams, lnode) {
 555                         cds_list_del(&sreg->lnode);
 556                         regp->stream_count--;
 557                         buffer_reg_stream_destroy(sreg, domain);
 558                 }
 559
 560                 if (regp->obj.ust) {
 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,
 565                                     ret);
 566                         }
 567                         free(regp->obj.ust);
 568                 }
 569                 lttng_fd_put(LTTNG_FD_APPS, 1);
 570                 break;
 571         }
 572         default:
 573                 abort();
 574         }
 575
 576         free(regp);
 577         return;
 578 }
 579
 580 /*
 581  * Destroy a buffer registry session with the given domain.
 582  */
 583 static void buffer_reg_session_destroy(struct buffer_reg_session *regp,
 584                                        enum lttng_domain_type domain)
 585 {
 586         int ret;
 587         struct lttng_ht_iter iter;
 588         struct buffer_reg_channel *reg_chan;
 589
 590         DBG3("Buffer registry session destroy");
 591
 592         /* Destroy all channels. */
 593         {
 594                 lttng::urcu::read_lock_guard read_lock;
 595
 596                 cds_lfht_for_each_entry (regp->channels->ht, &iter.iter, reg_chan, node.node) {
 597                         ret = lttng_ht_del(regp->channels, &iter);
 598                         LTTNG_ASSERT(!ret);
 599                         buffer_reg_channel_destroy(reg_chan, domain);
 600                 }
 601         }
 602
 603         lttng_ht_destroy(regp->channels);
 604
 605         switch (domain) {
 606         case LTTNG_DOMAIN_UST:
 607                 ust_registry_session_destroy(regp->reg.ust);
 608                 break;
 609         default:
 610                 abort();
 611         }
 612
 613         free(regp);
 614         return;
 615 }
 616
 617 /*
 618  * Remove buffer registry UID object from the global hash table.
 619  */
 620 void buffer_reg_uid_remove(struct buffer_reg_uid *regp)
 621 {
 622         int ret;
 623         struct lttng_ht_iter iter;
 624
 625         LTTNG_ASSERT(regp);
 626
 627         lttng::urcu::read_lock_guard read_lock;
 628         iter.iter.node = &regp->node.node;
 629         ret = lttng_ht_del(buffer_registry_uid, &iter);
 630         LTTNG_ASSERT(!ret);
 631 }
 632
 633 static void rcu_free_buffer_reg_uid(struct rcu_head *head)
 634 {
 635         struct lttng_ht_node_u64 *node = lttng::utils::container_of(head, &lttng_ht_node_u64::head);
 636         struct buffer_reg_uid *reg = lttng::utils::container_of(node, &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 = lttng::utils::container_of(head, &lttng_ht_node_u64::head);
 645         struct buffer_reg_pid *reg = lttng::utils::container_of(node, &buffer_reg_pid::node);
 646
 647         buffer_reg_session_destroy(reg->registry, LTTNG_DOMAIN_UST);
 648         free(reg);
 649 }
 650
 651 /*
 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.
 655  */
 656 void buffer_reg_uid_destroy(struct buffer_reg_uid *regp, struct consumer_output *consumer)
 657 {
 658         struct consumer_socket *socket;
 659
 660         if (!regp) {
 661                 return;
 662         }
 663
 664         DBG3("Buffer registry per UID destroy with id: %" PRIu64 ", ABI: %u, uid: %d",
 665              regp->session_id,
 666              regp->bits_per_long,
 667              regp->uid);
 668
 669         if (!consumer) {
 670                 goto destroy;
 671         }
 672
 673         {
 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);
 677                 if (!socket) {
 678                         goto destroy;
 679                 }
 680
 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);
 687                         }
 688                         break;
 689                 default:
 690                         abort();
 691                         return;
 692                 }
 693         }
 694
 695 destroy:
 696         call_rcu(&regp->node.head, rcu_free_buffer_reg_uid);
 697 }
 698
 699 /*
 700  * Remove buffer registry UID object from the global hash table. RCU read side
 701  * lock MUST be acquired before calling this.
 702  */
 703 void buffer_reg_pid_remove(struct buffer_reg_pid *regp)
 704 {
 705         int ret;
 706         struct lttng_ht_iter iter;
 707
 708         LTTNG_ASSERT(regp);
 709
 710         iter.iter.node = &regp->node.node;
 711         ret = lttng_ht_del(buffer_registry_pid, &iter);
 712         LTTNG_ASSERT(!ret);
 713 }
 714
 715 /*
 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.
 719  */
 720 void buffer_reg_pid_destroy(struct buffer_reg_pid *regp)
 721 {
 722         if (!regp) {
 723                 return;
 724         }
 725
 726         DBG3("Buffer registry per PID destroy with id: %" PRIu64, regp->session_id);
 727
 728         /* This registry is only used by UST. */
 729         call_rcu(&regp->node.head, rcu_free_buffer_reg_pid);
 730 }
 731
 732 /*
 733  * Destroy per PID and UID registry hash table.
 734  */
 735 void buffer_reg_destroy_registries()
 736 {
 737         DBG3("Buffer registry destroy all registry");
 738         lttng_ht_destroy(buffer_registry_uid);
 739         lttng_ht_destroy(buffer_registry_pid);
 740 }