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 "lttng-ust-ctl.h"
  28 #include "lttng-ust-error.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(const void *_key, unsigned long seed)
  78 {
  79         uint64_t xored_key;
  80         const 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  * 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(
 337                 struct cds_list_head *buffer_reg_uid_list,
 338                 uint64_t chan_key, uint64_t *consumer_chan_key)
 339 {
 340         struct lttng_ht_iter iter;
 341         struct buffer_reg_uid *uid_reg = NULL;
 342         struct buffer_reg_session *session_reg = NULL;
 343         struct buffer_reg_channel *reg_chan;
 344         int ret = -1;
 345
 346         rcu_read_lock();
 347         /*
 348          * For the per-uid registry, we have to iterate since we don't have the
 349          * uid and bitness key.
 350          */
 351         cds_list_for_each_entry(uid_reg, buffer_reg_uid_list, lnode) {
 352                 session_reg = uid_reg->registry;
 353                 cds_lfht_for_each_entry(session_reg->channels->ht,
 354                                 &iter.iter, reg_chan, node.node) {
 355                         if (reg_chan->key == chan_key) {
 356                                 *consumer_chan_key = reg_chan->consumer_key;
 357                                 ret = 0;
 358                                 goto end;
 359                         }
 360                 }
 361         }
 362
 363 end:
 364         rcu_read_unlock();
 365         return ret;
 366 }
 367
 368 /*
 369  * Allocate and initialize a buffer registry channel with the given key. Set
 370  * regp with the object pointer.
 371  *
 372  * Return 0 on success or else a negative value keeping regp untouched.
 373  */
 374 int buffer_reg_channel_create(uint64_t key, struct buffer_reg_channel **regp)
 375 {
 376         struct buffer_reg_channel *reg;
 377
 378         assert(regp);
 379
 380         DBG3("Buffer registry channel create with key: %" PRIu64, key);
 381
 382         reg = zmalloc(sizeof(*reg));
 383         if (!reg) {
 384                 PERROR("zmalloc buffer registry channel");
 385                 return -ENOMEM;
 386         }
 387
 388         reg->key = key;
 389         CDS_INIT_LIST_HEAD(&reg->streams);
 390         pthread_mutex_init(&reg->stream_list_lock, NULL);
 391
 392         lttng_ht_node_init_u64(&reg->node, key);
 393         *regp = reg;
 394
 395         return 0;
 396 }
 397
 398 /*
 399  * Allocate and initialize a buffer registry stream. Set regp with the object
 400  * pointer.
 401  *
 402  * Return 0 on success or else a negative value keeping regp untouched.
 403  */
 404 int buffer_reg_stream_create(struct buffer_reg_stream **regp)
 405 {
 406         struct buffer_reg_stream *reg;
 407
 408         assert(regp);
 409
 410         DBG3("Buffer registry creating stream");
 411
 412         reg = zmalloc(sizeof(*reg));
 413         if (!reg) {
 414                 PERROR("zmalloc buffer registry stream");
 415                 return -ENOMEM;
 416         }
 417
 418         *regp = reg;
 419
 420         return 0;
 421 }
 422
 423 /*
 424  * Add stream to the list in the channel.
 425  */
 426 void buffer_reg_stream_add(struct buffer_reg_stream *stream,
 427                 struct buffer_reg_channel *channel)
 428 {
 429         assert(stream);
 430         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,
 442                 struct buffer_reg_channel *channel)
 443 {
 444         assert(session);
 445         assert(channel);
 446
 447         rcu_read_lock();
 448         lttng_ht_add_unique_u64(session->channels, &channel->node);
 449         rcu_read_unlock();
 450 }
 451
 452 /*
 453  * Find a buffer registry channel object with the given key. RCU read side lock
 454  * MUST be acquired and hold on until the object reference is not needed
 455  * anymore.
 456  *
 457  * Return the object pointer or NULL on error.
 458  */
 459 struct buffer_reg_channel *buffer_reg_channel_find(uint64_t key,
 460                 struct buffer_reg_uid *reg)
 461 {
 462         struct lttng_ht_node_u64 *node;
 463         struct lttng_ht_iter iter;
 464         struct buffer_reg_channel *chan = NULL;
 465         struct lttng_ht *ht;
 466
 467         assert(reg);
 468
 469         switch (reg->domain) {
 470         case LTTNG_DOMAIN_UST:
 471                 ht = reg->registry->channels;
 472                 break;
 473         default:
 474                 assert(0);
 475                 goto end;
 476         }
 477
 478         lttng_ht_lookup(ht, &key, &iter);
 479         node = lttng_ht_iter_get_node_u64(&iter);
 480         if (!node) {
 481                 goto end;
 482         }
 483         chan = caa_container_of(node, struct buffer_reg_channel, node);
 484
 485 end:
 486         return chan;
 487 }
 488
 489 /*
 490  * Destroy a buffer registry stream with the given domain.
 491  */
 492 void buffer_reg_stream_destroy(struct buffer_reg_stream *regp,
 493                 enum lttng_domain_type domain)
 494 {
 495         if (!regp) {
 496                 return;
 497         }
 498
 499         DBG3("Buffer registry stream destroy with handle %d",
 500                         regp->obj.ust->handle);
 501
 502         switch (domain) {
 503         case LTTNG_DOMAIN_UST:
 504         {
 505                 int ret;
 506
 507                 ret = ust_app_release_object(NULL, regp->obj.ust);
 508                 if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
 509                         ERR("Buffer reg stream release obj handle %d failed with ret %d",
 510                                         regp->obj.ust->handle, ret);
 511                 }
 512                 free(regp->obj.ust);
 513                 lttng_fd_put(LTTNG_FD_APPS, 2);
 514                 break;
 515         }
 516         default:
 517                 assert(0);
 518         }
 519
 520         free(regp);
 521         return;
 522 }
 523
 524 /*
 525  * Remove buffer registry channel object from the session hash table. RCU read
 526  * side lock MUST be acquired before calling this.
 527  */
 528 void buffer_reg_channel_remove(struct buffer_reg_session *session,
 529                 struct buffer_reg_channel *regp)
 530 {
 531         int ret;
 532         struct lttng_ht_iter iter;
 533
 534         assert(session);
 535         assert(regp);
 536
 537         iter.iter.node = &regp->node.node;
 538         ret = lttng_ht_del(session->channels, &iter);
 539         assert(!ret);
 540 }
 541
 542 /*
 543  * Destroy a buffer registry channel with the given domain.
 544  */
 545 void buffer_reg_channel_destroy(struct buffer_reg_channel *regp,
 546                 enum lttng_domain_type domain)
 547 {
 548         if (!regp) {
 549                 return;
 550         }
 551
 552         DBG3("Buffer registry channel destroy with key %" PRIu32, regp->key);
 553
 554         switch (domain) {
 555         case LTTNG_DOMAIN_UST:
 556         {
 557                 int ret;
 558                 struct buffer_reg_stream *sreg, *stmp;
 559                 /* Wipe stream */
 560                 cds_list_for_each_entry_safe(sreg, stmp, &regp->streams, lnode) {
 561                         cds_list_del(&sreg->lnode);
 562                         regp->stream_count--;
 563                         buffer_reg_stream_destroy(sreg, domain);
 564                 }
 565
 566                 if (regp->obj.ust) {
 567                         ret = ust_app_release_object(NULL, regp->obj.ust);
 568                         if (ret < 0 && ret != -EPIPE && ret != -LTTNG_UST_ERR_EXITING) {
 569                                 ERR("Buffer reg channel release obj handle %d failed with ret %d",
 570                                                 regp->obj.ust->handle, ret);
 571                         }
 572                         free(regp->obj.ust);
 573                 }
 574                 lttng_fd_put(LTTNG_FD_APPS, 1);
 575                 break;
 576         }
 577         default:
 578                 assert(0);
 579         }
 580
 581         free(regp);
 582         return;
 583 }
 584
 585 /*
 586  * Destroy a buffer registry session with the given domain.
 587  *
 588  * Should *NOT* be called with RCU read-side lock held.
 589  */
 590 static void buffer_reg_session_destroy(struct buffer_reg_session *regp,
 591                 enum lttng_domain_type domain)
 592 {
 593         int ret;
 594         struct lttng_ht_iter iter;
 595         struct buffer_reg_channel *reg_chan;
 596
 597         DBG3("Buffer registry session destroy");
 598
 599         /* Destroy all channels. */
 600         rcu_read_lock();
 601         cds_lfht_for_each_entry(regp->channels->ht, &iter.iter, reg_chan,
 602                         node.node) {
 603                 ret = lttng_ht_del(regp->channels, &iter);
 604                 assert(!ret);
 605                 buffer_reg_channel_destroy(reg_chan, domain);
 606         }
 607         rcu_read_unlock();
 608
 609         ht_cleanup_push(regp->channels);
 610
 611         switch (domain) {
 612         case LTTNG_DOMAIN_UST:
 613                 ust_registry_session_destroy(regp->reg.ust);
 614                 free(regp->reg.ust);
 615                 break;
 616         default:
 617                 assert(0);
 618         }
 619
 620         free(regp);
 621         return;
 622 }
 623
 624 /*
 625  * Remove buffer registry UID object from the global hash table.
 626  */
 627 void buffer_reg_uid_remove(struct buffer_reg_uid *regp)
 628 {
 629         int ret;
 630         struct lttng_ht_iter iter;
 631
 632         assert(regp);
 633
 634         rcu_read_lock();
 635         iter.iter.node = &regp->node.node;
 636         ret = lttng_ht_del(buffer_registry_uid, &iter);
 637         assert(!ret);
 638         rcu_read_unlock();
 639 }
 640
 641 static void rcu_free_buffer_reg_uid(struct rcu_head *head)
 642 {
 643         struct lttng_ht_node_u64 *node =
 644                 caa_container_of(head, struct lttng_ht_node_u64, head);
 645         struct buffer_reg_uid *reg =
 646                 caa_container_of(node, struct buffer_reg_uid, node);
 647
 648         buffer_reg_session_destroy(reg->registry, reg->domain);
 649         free(reg);
 650 }
 651
 652 static void rcu_free_buffer_reg_pid(struct rcu_head *head)
 653 {
 654         struct lttng_ht_node_u64 *node =
 655                 caa_container_of(head, struct lttng_ht_node_u64, head);
 656         struct buffer_reg_pid *reg =
 657                 caa_container_of(node, struct buffer_reg_pid, node);
 658
 659         buffer_reg_session_destroy(reg->registry, LTTNG_DOMAIN_UST);
 660         free(reg);
 661 }
 662
 663 /*
 664  * Destroy buffer registry per UID. The given pointer is NOT removed from any
 665  * list or hash table. Use buffer_reg_pid_remove() before calling this function
 666  * for the case that the object is in the global hash table.
 667  */
 668 void buffer_reg_uid_destroy(struct buffer_reg_uid *regp,
 669                 struct consumer_output *consumer)
 670 {
 671         struct consumer_socket *socket;
 672
 673         if (!regp) {
 674                 return;
 675         }
 676
 677         DBG3("Buffer registry per UID destroy with id: %" PRIu64 ", ABI: %u, uid: %d",
 678                         regp->session_id, regp->bits_per_long, regp->uid);
 679
 680         if (!consumer) {
 681                 goto destroy;
 682         }
 683
 684         rcu_read_lock();
 685         /* Get the right socket from the consumer object. */
 686         socket = consumer_find_socket_by_bitness(regp->bits_per_long,
 687                         consumer);
 688         if (!socket) {
 689                 goto unlock;
 690         }
 691
 692         switch (regp->domain) {
 693         case LTTNG_DOMAIN_UST:
 694                 if (regp->registry->reg.ust->metadata_key) {
 695                         /* Return value does not matter. This call will print errors. */
 696                         (void) consumer_close_metadata(socket,
 697                                         regp->registry->reg.ust->metadata_key);
 698                 }
 699                 break;
 700         default:
 701                 assert(0);
 702                 rcu_read_unlock();
 703                 return;
 704         }
 705
 706 unlock:
 707         rcu_read_unlock();
 708 destroy:
 709         call_rcu(&regp->node.head, rcu_free_buffer_reg_uid);
 710 }
 711
 712 /*
 713  * Remove buffer registry UID object from the global hash table. RCU read side
 714  * lock MUST be acquired before calling this.
 715  */
 716 void buffer_reg_pid_remove(struct buffer_reg_pid *regp)
 717 {
 718         int ret;
 719         struct lttng_ht_iter iter;
 720
 721         assert(regp);
 722
 723         iter.iter.node = &regp->node.node;
 724         ret = lttng_ht_del(buffer_registry_pid, &iter);
 725         assert(!ret);
 726 }
 727
 728 /*
 729  * Destroy buffer registry per PID. The pointer is NOT removed from the global
 730  * hash table. Call buffer_reg_pid_remove() before that if the object was
 731  * previously added to the global hash table.
 732  */
 733 void buffer_reg_pid_destroy(struct buffer_reg_pid *regp)
 734 {
 735         if (!regp) {
 736                 return;
 737         }
 738
 739         DBG3("Buffer registry per PID destroy with id: %" PRIu64,
 740                         regp->session_id);
 741
 742         /* This registry is only used by UST. */
 743         call_rcu(&regp->node.head, rcu_free_buffer_reg_pid);
 744 }
 745
 746 /*
 747  * Destroy per PID and UID registry hash table.
 748  *
 749  * Should *NOT* be called with RCU read-side lock held.
 750  */
 751 void buffer_reg_destroy_registries(void)
 752 {
 753         DBG3("Buffer registry destroy all registry");
 754         ht_cleanup_push(buffer_registry_uid);
 755         ht_cleanup_push(buffer_registry_pid);
 756 }