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 }