X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fcommon%2Fhashtable%2Fhashtable.c;h=404734f544895a8b9463fe2673136ad75d38e6de;hb=a0377dfefe40662ba7d68617bce6ff467114136c;hp=d1049d1e2b9dea53b9747a0bcaf8cea4108833cd;hpb=42ce408ec43c984731b2cdb4a4dbbbb0196164b0;p=lttng-tools.git diff --git a/src/common/hashtable/hashtable.c b/src/common/hashtable/hashtable.c index d1049d1e2..404734f54 100644 --- a/src/common/hashtable/hashtable.c +++ b/src/common/hashtable/hashtable.c @@ -1,23 +1,11 @@ /* - * Copyright (C) 2011 - David Goulet + * Copyright (C) 2011 David Goulet * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License, version 2 only, - * as published by the Free Software Foundation. + * SPDX-License-Identifier: GPL-2.0-only * - * This program is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for - * more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE #define _LGPL_SOURCE -#include #include #include #include @@ -28,6 +16,9 @@ #include "hashtable.h" #include "utils.h" +/* seed_lock protects both seed_init and lttng_ht_seed. */ +static pthread_mutex_t seed_lock = PTHREAD_MUTEX_INITIALIZER; +static bool seed_init; unsigned long lttng_ht_seed; static unsigned long min_hash_alloc_size = 1; @@ -84,9 +75,28 @@ static int match_two_u64(struct cds_lfht_node *node, const void *key) return hash_match_key_two_u64((void *) &match_node->key, (void *) key); } +static inline +const char *lttng_ht_type_str(enum lttng_ht_type type) +{ + switch (type) { + case LTTNG_HT_TYPE_STRING: + return "STRING"; + case LTTNG_HT_TYPE_ULONG: + return "ULONG"; + case LTTNG_HT_TYPE_U64: + return "U64"; + case LTTNG_HT_TYPE_TWO_U64: + return "TWO_U64"; + default: + ERR("Unknown lttng hashtable type %d", type); + abort(); + } +} + /* * Return an allocated lttng hashtable. */ +LTTNG_HIDDEN struct lttng_ht *lttng_ht_new(unsigned long size, int type) { struct lttng_ht *ht; @@ -95,6 +105,13 @@ struct lttng_ht *lttng_ht_new(unsigned long size, int type) if (!size) size = DEFAULT_HT_SIZE; + pthread_mutex_lock(&seed_lock); + if (!seed_init) { + lttng_ht_seed = (unsigned long) time(NULL); + seed_init = true; + } + pthread_mutex_unlock(&seed_lock); + ht = zmalloc(sizeof(*ht)); if (ht == NULL) { PERROR("zmalloc lttng_ht"); @@ -107,7 +124,7 @@ struct lttng_ht *lttng_ht_new(unsigned long size, int type) * There is already an assert in the RCU hashtable code so if the ht is * NULL here there is a *huge* problem. */ - assert(ht->ht); + LTTNG_ASSERT(ht->ht); switch (type) { case LTTNG_HT_TYPE_STRING: @@ -132,7 +149,8 @@ struct lttng_ht *lttng_ht_new(unsigned long size, int type) goto error; } - DBG3("Created hashtable size %lu at %p of type %d", size, ht->ht, type); + DBG3("Created hashtable size %lu at %p of type %s", size, ht->ht, + lttng_ht_type_str(type)); return ht; @@ -143,21 +161,23 @@ error: /* * Free a lttng hashtable. */ +LTTNG_HIDDEN void lttng_ht_destroy(struct lttng_ht *ht) { int ret; ret = cds_lfht_destroy(ht->ht, NULL); - assert(!ret); + LTTNG_ASSERT(!ret); free(ht); } /* * Init lttng ht node string. */ +LTTNG_HIDDEN void lttng_ht_node_init_str(struct lttng_ht_node_str *node, char *key) { - assert(node); + LTTNG_ASSERT(node); node->key = key; cds_lfht_node_init(&node->node); @@ -166,10 +186,11 @@ void lttng_ht_node_init_str(struct lttng_ht_node_str *node, char *key) /* * Init lttng ht node unsigned long. */ +LTTNG_HIDDEN void lttng_ht_node_init_ulong(struct lttng_ht_node_ulong *node, unsigned long key) { - assert(node); + LTTNG_ASSERT(node); node->key = key; cds_lfht_node_init(&node->node); @@ -178,10 +199,11 @@ void lttng_ht_node_init_ulong(struct lttng_ht_node_ulong *node, /* * Init lttng ht node uint64_t. */ +LTTNG_HIDDEN void lttng_ht_node_init_u64(struct lttng_ht_node_u64 *node, uint64_t key) { - assert(node); + LTTNG_ASSERT(node); node->key = key; cds_lfht_node_init(&node->node); @@ -190,10 +212,11 @@ void lttng_ht_node_init_u64(struct lttng_ht_node_u64 *node, /* * Init lttng ht node with two uint64_t. */ +LTTNG_HIDDEN void lttng_ht_node_init_two_u64(struct lttng_ht_node_two_u64 *node, uint64_t key1, uint64_t key2) { - assert(node); + LTTNG_ASSERT(node); node->key.key1 = key1; node->key.key2 = key2; @@ -203,47 +226,52 @@ void lttng_ht_node_init_two_u64(struct lttng_ht_node_two_u64 *node, /* * Free lttng ht node string. */ +LTTNG_HIDDEN void lttng_ht_node_free_str(struct lttng_ht_node_str *node) { - assert(node); + LTTNG_ASSERT(node); free(node); } /* * Free lttng ht node unsigned long. */ +LTTNG_HIDDEN void lttng_ht_node_free_ulong(struct lttng_ht_node_ulong *node) { - assert(node); + LTTNG_ASSERT(node); free(node); } /* * Free lttng ht node uint64_t. */ +LTTNG_HIDDEN void lttng_ht_node_free_u64(struct lttng_ht_node_u64 *node) { - assert(node); + LTTNG_ASSERT(node); free(node); } /* * Free lttng ht node two uint64_t. */ +LTTNG_HIDDEN void lttng_ht_node_free_two_u64(struct lttng_ht_node_two_u64 *node) { - assert(node); + LTTNG_ASSERT(node); free(node); } /* * Lookup function in hashtable. */ -void lttng_ht_lookup(struct lttng_ht *ht, void *key, +LTTNG_HIDDEN +void lttng_ht_lookup(struct lttng_ht *ht, const void *key, struct lttng_ht_iter *iter) { - assert(ht); - assert(ht->ht); + LTTNG_ASSERT(ht); + LTTNG_ASSERT(ht->ht); cds_lfht_lookup(ht->ht, ht->hash_fct(key, lttng_ht_seed), ht->match_fct, key, &iter->iter); @@ -252,31 +280,33 @@ void lttng_ht_lookup(struct lttng_ht *ht, void *key, /* * Add unique string node to hashtable. */ +LTTNG_HIDDEN void lttng_ht_add_unique_str(struct lttng_ht *ht, struct lttng_ht_node_str *node) { struct cds_lfht_node *node_ptr; - assert(ht); - assert(ht->ht); - assert(node); + LTTNG_ASSERT(ht); + LTTNG_ASSERT(ht->ht); + LTTNG_ASSERT(node); /* RCU read lock protects from ABA. */ rcu_read_lock(); node_ptr = cds_lfht_add_unique(ht->ht, ht->hash_fct(node->key, lttng_ht_seed), ht->match_fct, node->key, &node->node); rcu_read_unlock(); - assert(node_ptr == &node->node); + LTTNG_ASSERT(node_ptr == &node->node); } /* * Add string node to hashtable. */ +LTTNG_HIDDEN void lttng_ht_add_str(struct lttng_ht *ht, struct lttng_ht_node_str *node) { - assert(ht); - assert(ht->ht); - assert(node); + LTTNG_ASSERT(ht); + LTTNG_ASSERT(ht->ht); + LTTNG_ASSERT(node); /* RCU read lock protects from ABA. */ rcu_read_lock(); @@ -288,11 +318,12 @@ void lttng_ht_add_str(struct lttng_ht *ht, /* * Add unsigned long node to hashtable. */ +LTTNG_HIDDEN void lttng_ht_add_ulong(struct lttng_ht *ht, struct lttng_ht_node_ulong *node) { - assert(ht); - assert(ht->ht); - assert(node); + LTTNG_ASSERT(ht); + LTTNG_ASSERT(ht->ht); + LTTNG_ASSERT(node); /* RCU read lock protects from ABA. */ rcu_read_lock(); @@ -303,13 +334,13 @@ void lttng_ht_add_ulong(struct lttng_ht *ht, struct lttng_ht_node_ulong *node) /* * Add uint64_t node to hashtable. - */ +LTTNG_HIDDEN void lttng_ht_add_u64(struct lttng_ht *ht, struct lttng_ht_node_u64 *node) { - assert(ht); - assert(ht->ht); - assert(node); + LTTNG_ASSERT(ht); + LTTNG_ASSERT(ht->ht); + LTTNG_ASSERT(node); /* RCU read lock protects from ABA. */ rcu_read_lock(); @@ -321,13 +352,14 @@ void lttng_ht_add_u64(struct lttng_ht *ht, struct lttng_ht_node_u64 *node) /* * Add unique unsigned long node to hashtable. */ +LTTNG_HIDDEN void lttng_ht_add_unique_ulong(struct lttng_ht *ht, struct lttng_ht_node_ulong *node) { struct cds_lfht_node *node_ptr; - assert(ht); - assert(ht->ht); - assert(node); + LTTNG_ASSERT(ht); + LTTNG_ASSERT(ht->ht); + LTTNG_ASSERT(node); /* RCU read lock protects from ABA. */ rcu_read_lock(); @@ -335,19 +367,20 @@ void lttng_ht_add_unique_ulong(struct lttng_ht *ht, ht->hash_fct((void *) node->key, lttng_ht_seed), ht->match_fct, (void *) node->key, &node->node); rcu_read_unlock(); - assert(node_ptr == &node->node); + LTTNG_ASSERT(node_ptr == &node->node); } /* * Add unique uint64_t node to hashtable. */ +LTTNG_HIDDEN void lttng_ht_add_unique_u64(struct lttng_ht *ht, struct lttng_ht_node_u64 *node) { struct cds_lfht_node *node_ptr; - assert(ht); - assert(ht->ht); - assert(node); + LTTNG_ASSERT(ht); + LTTNG_ASSERT(ht->ht); + LTTNG_ASSERT(node); /* RCU read lock protects from ABA. */ rcu_read_lock(); @@ -355,19 +388,20 @@ void lttng_ht_add_unique_u64(struct lttng_ht *ht, ht->hash_fct(&node->key, lttng_ht_seed), ht->match_fct, &node->key, &node->node); rcu_read_unlock(); - assert(node_ptr == &node->node); + LTTNG_ASSERT(node_ptr == &node->node); } /* * Add unique two uint64_t node to hashtable. */ +LTTNG_HIDDEN void lttng_ht_add_unique_two_u64(struct lttng_ht *ht, struct lttng_ht_node_two_u64 *node) { struct cds_lfht_node *node_ptr; - assert(ht); - assert(ht->ht); - assert(node); + LTTNG_ASSERT(ht); + LTTNG_ASSERT(ht->ht); + LTTNG_ASSERT(node); /* RCU read lock protects from ABA. */ rcu_read_lock(); @@ -375,19 +409,20 @@ void lttng_ht_add_unique_two_u64(struct lttng_ht *ht, ht->hash_fct((void *) &node->key, lttng_ht_seed), ht->match_fct, (void *) &node->key, &node->node); rcu_read_unlock(); - assert(node_ptr == &node->node); + LTTNG_ASSERT(node_ptr == &node->node); } /* * Add replace unsigned long node to hashtable. */ +LTTNG_HIDDEN struct lttng_ht_node_ulong *lttng_ht_add_replace_ulong(struct lttng_ht *ht, struct lttng_ht_node_ulong *node) { struct cds_lfht_node *node_ptr; - assert(ht); - assert(ht->ht); - assert(node); + LTTNG_ASSERT(ht); + LTTNG_ASSERT(ht->ht); + LTTNG_ASSERT(node); /* RCU read lock protects from ABA. */ rcu_read_lock(); @@ -400,19 +435,20 @@ struct lttng_ht_node_ulong *lttng_ht_add_replace_ulong(struct lttng_ht *ht, } else { return caa_container_of(node_ptr, struct lttng_ht_node_ulong, node); } - assert(node_ptr == &node->node); + LTTNG_ASSERT(node_ptr == &node->node); } /* * Add replace unsigned long node to hashtable. */ +LTTNG_HIDDEN struct lttng_ht_node_u64 *lttng_ht_add_replace_u64(struct lttng_ht *ht, struct lttng_ht_node_u64 *node) { struct cds_lfht_node *node_ptr; - assert(ht); - assert(ht->ht); - assert(node); + LTTNG_ASSERT(ht); + LTTNG_ASSERT(ht->ht); + LTTNG_ASSERT(node); /* RCU read lock protects from ABA. */ rcu_read_lock(); @@ -425,19 +461,20 @@ struct lttng_ht_node_u64 *lttng_ht_add_replace_u64(struct lttng_ht *ht, } else { return caa_container_of(node_ptr, struct lttng_ht_node_u64, node); } - assert(node_ptr == &node->node); + LTTNG_ASSERT(node_ptr == &node->node); } /* * Delete node from hashtable. */ +LTTNG_HIDDEN int lttng_ht_del(struct lttng_ht *ht, struct lttng_ht_iter *iter) { int ret; - assert(ht); - assert(ht->ht); - assert(iter); + LTTNG_ASSERT(ht); + LTTNG_ASSERT(ht->ht); + LTTNG_ASSERT(iter); /* RCU read lock protects from ABA. */ rcu_read_lock(); @@ -449,11 +486,12 @@ int lttng_ht_del(struct lttng_ht *ht, struct lttng_ht_iter *iter) /* * Get first node in the hashtable. */ +LTTNG_HIDDEN void lttng_ht_get_first(struct lttng_ht *ht, struct lttng_ht_iter *iter) { - assert(ht); - assert(ht->ht); - assert(iter); + LTTNG_ASSERT(ht); + LTTNG_ASSERT(ht->ht); + LTTNG_ASSERT(iter); cds_lfht_first(ht->ht, &iter->iter); } @@ -461,11 +499,12 @@ void lttng_ht_get_first(struct lttng_ht *ht, struct lttng_ht_iter *iter) /* * Get next node in the hashtable. */ +LTTNG_HIDDEN void lttng_ht_get_next(struct lttng_ht *ht, struct lttng_ht_iter *iter) { - assert(ht); - assert(ht->ht); - assert(iter); + LTTNG_ASSERT(ht); + LTTNG_ASSERT(ht->ht); + LTTNG_ASSERT(iter); cds_lfht_next(ht->ht, &iter->iter); } @@ -473,13 +512,14 @@ void lttng_ht_get_next(struct lttng_ht *ht, struct lttng_ht_iter *iter) /* * Return the number of nodes in the hashtable. */ +LTTNG_HIDDEN unsigned long lttng_ht_get_count(struct lttng_ht *ht) { long scb, sca; unsigned long count; - assert(ht); - assert(ht->ht); + LTTNG_ASSERT(ht); + LTTNG_ASSERT(ht->ht); /* RCU read lock protects from ABA and allows RCU traversal. */ rcu_read_lock(); @@ -492,12 +532,13 @@ unsigned long lttng_ht_get_count(struct lttng_ht *ht) /* * Return lttng ht string node from iterator. */ +LTTNG_HIDDEN struct lttng_ht_node_str *lttng_ht_iter_get_node_str( struct lttng_ht_iter *iter) { struct cds_lfht_node *node; - assert(iter); + LTTNG_ASSERT(iter); node = cds_lfht_iter_get_node(&iter->iter); if (!node) { return NULL; @@ -508,12 +549,13 @@ struct lttng_ht_node_str *lttng_ht_iter_get_node_str( /* * Return lttng ht unsigned long node from iterator. */ +LTTNG_HIDDEN struct lttng_ht_node_ulong *lttng_ht_iter_get_node_ulong( struct lttng_ht_iter *iter) { struct cds_lfht_node *node; - assert(iter); + LTTNG_ASSERT(iter); node = cds_lfht_iter_get_node(&iter->iter); if (!node) { return NULL; @@ -524,12 +566,13 @@ struct lttng_ht_node_ulong *lttng_ht_iter_get_node_ulong( /* * Return lttng ht unsigned long node from iterator. */ +LTTNG_HIDDEN struct lttng_ht_node_u64 *lttng_ht_iter_get_node_u64( struct lttng_ht_iter *iter) { struct cds_lfht_node *node; - assert(iter); + LTTNG_ASSERT(iter); node = cds_lfht_iter_get_node(&iter->iter); if (!node) { return NULL; @@ -540,24 +583,16 @@ struct lttng_ht_node_u64 *lttng_ht_iter_get_node_u64( /* * Return lttng ht stream and index id node from iterator. */ +LTTNG_HIDDEN struct lttng_ht_node_two_u64 *lttng_ht_iter_get_node_two_u64( struct lttng_ht_iter *iter) { struct cds_lfht_node *node; - assert(iter); + LTTNG_ASSERT(iter); node = cds_lfht_iter_get_node(&iter->iter); if (!node) { return NULL; } return caa_container_of(node, struct lttng_ht_node_two_u64, node); } - -/* - * lib constructor - */ -static void __attribute__((constructor)) _init(void) -{ - /* Init hash table seed */ - lttng_ht_seed = (unsigned long) time(NULL); -}