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