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