X-Git-Url: http://git.efficios.com/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fhashtable%2Fhashtable.c;h=f449fab8bd6dabab89302b86c9222d0569fc5cf6;hp=263df46839d37af58e2efe66770f5e1833c90f0f;hb=ab5be9fa2eb5ba9600a82cd18fd3cfcbac69169a;hpb=d88aee689d5bd0067f362a323cb69c37717df59f diff --git a/src/common/hashtable/hashtable.c b/src/common/hashtable/hashtable.c index 263df4683..f449fab8b 100644 --- a/src/common/hashtable/hashtable.c +++ b/src/common/hashtable/hashtable.c @@ -1,21 +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 @@ -27,11 +17,21 @@ #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; static unsigned long max_hash_buckets_size = 0; +/* + * Getter/lookup functions need to be called with RCU read-side lock + * held. However, modification functions (add, add_unique, replace, del) + * take the RCU lock internally, so it does not matter whether the + * caller hold the RCU lock or not. + */ + /* * Match function for string node. */ @@ -65,9 +65,21 @@ static int match_u64(struct cds_lfht_node *node, const void *key) return hash_match_key_u64(&match_node->key, (void *) key); } +/* + * Match function for two uint64_t node. + */ +static int match_two_u64(struct cds_lfht_node *node, const void *key) +{ + struct lttng_ht_node_two_u64 *match_node = + caa_container_of(node, struct lttng_ht_node_two_u64, node); + + return hash_match_key_two_u64((void *) &match_node->key, (void *) key); +} + /* * Return an allocated lttng hashtable. */ +LTTNG_HIDDEN struct lttng_ht *lttng_ht_new(unsigned long size, int type) { struct lttng_ht *ht; @@ -76,6 +88,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"); @@ -103,8 +122,13 @@ struct lttng_ht *lttng_ht_new(unsigned long size, int type) ht->match_fct = match_u64; ht->hash_fct = hash_key_u64; break; + case LTTNG_HT_TYPE_TWO_U64: + ht->match_fct = match_two_u64; + ht->hash_fct = hash_key_two_u64; + break; default: ERR("Unknown lttng hashtable type %d", type); + lttng_ht_destroy(ht); goto error; } @@ -119,6 +143,7 @@ error: /* * Free a lttng hashtable. */ +LTTNG_HIDDEN void lttng_ht_destroy(struct lttng_ht *ht) { int ret; @@ -131,6 +156,7 @@ void lttng_ht_destroy(struct lttng_ht *ht) /* * Init lttng ht node string. */ +LTTNG_HIDDEN void lttng_ht_node_init_str(struct lttng_ht_node_str *node, char *key) { assert(node); @@ -142,6 +168,7 @@ 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) { @@ -154,6 +181,7 @@ 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) { @@ -163,9 +191,24 @@ void lttng_ht_node_init_u64(struct lttng_ht_node_u64 *node, cds_lfht_node_init(&node->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); + + node->key.key1 = key1; + node->key.key2 = key2; + cds_lfht_node_init(&node->node); +} + /* * Free lttng ht node string. */ +LTTNG_HIDDEN void lttng_ht_node_free_str(struct lttng_ht_node_str *node) { assert(node); @@ -175,6 +218,7 @@ void lttng_ht_node_free_str(struct lttng_ht_node_str *node) /* * Free lttng ht node unsigned long. */ +LTTNG_HIDDEN void lttng_ht_node_free_ulong(struct lttng_ht_node_ulong *node) { assert(node); @@ -184,7 +228,18 @@ void lttng_ht_node_free_ulong(struct lttng_ht_node_ulong *node) /* * Free lttng ht node uint64_t. */ -void lttng_ht_node_free_u64(struct lttng_ht_node_ulong *node) +LTTNG_HIDDEN +void lttng_ht_node_free_u64(struct lttng_ht_node_u64 *node) +{ + 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); free(node); @@ -193,7 +248,8 @@ void lttng_ht_node_free_u64(struct lttng_ht_node_ulong *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); @@ -206,6 +262,7 @@ 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) { @@ -214,41 +271,70 @@ void lttng_ht_add_unique_str(struct lttng_ht *ht, assert(ht->ht); 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); } +/* + * 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); + + /* RCU read lock protects from ABA. */ + rcu_read_lock(); + cds_lfht_add(ht->ht, ht->hash_fct(node->key, lttng_ht_seed), + &node->node); + rcu_read_unlock(); +} + /* * 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); + /* RCU read lock protects from ABA. */ + rcu_read_lock(); cds_lfht_add(ht->ht, ht->hash_fct((void *) node->key, lttng_ht_seed), &node->node); + rcu_read_unlock(); } /* * 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); + /* RCU read lock protects from ABA. */ + rcu_read_lock(); cds_lfht_add(ht->ht, ht->hash_fct(&node->key, lttng_ht_seed), &node->node); + rcu_read_unlock(); } /* * 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) { @@ -257,15 +343,19 @@ void lttng_ht_add_unique_ulong(struct lttng_ht *ht, assert(ht->ht); assert(node); + /* RCU read lock protects from ABA. */ + rcu_read_lock(); node_ptr = cds_lfht_add_unique(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); } /* * 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) { @@ -274,15 +364,40 @@ void lttng_ht_add_unique_u64(struct lttng_ht *ht, assert(ht->ht); 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); +} + +/* + * 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); + + /* RCU read lock protects from ABA. */ + rcu_read_lock(); + node_ptr = cds_lfht_add_unique(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); } /* * 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) { @@ -291,9 +406,12 @@ struct lttng_ht_node_ulong *lttng_ht_add_replace_ulong(struct lttng_ht *ht, assert(ht->ht); assert(node); + /* RCU read lock protects from ABA. */ + rcu_read_lock(); node_ptr = cds_lfht_add_replace(ht->ht, ht->hash_fct((void *) node->key, lttng_ht_seed), ht->match_fct, (void *) node->key, &node->node); + rcu_read_unlock(); if (!node_ptr) { return NULL; } else { @@ -305,6 +423,7 @@ struct lttng_ht_node_ulong *lttng_ht_add_replace_ulong(struct lttng_ht *ht, /* * 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) { @@ -313,9 +432,12 @@ struct lttng_ht_node_u64 *lttng_ht_add_replace_u64(struct lttng_ht *ht, assert(ht->ht); assert(node); + /* RCU read lock protects from ABA. */ + rcu_read_lock(); node_ptr = cds_lfht_add_replace(ht->ht, ht->hash_fct(&node->key, lttng_ht_seed), ht->match_fct, &node->key, &node->node); + rcu_read_unlock(); if (!node_ptr) { return NULL; } else { @@ -327,18 +449,26 @@ struct lttng_ht_node_u64 *lttng_ht_add_replace_u64(struct lttng_ht *ht, /* * 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); - return cds_lfht_del(ht->ht, iter->iter.node); + /* RCU read lock protects from ABA. */ + rcu_read_lock(); + ret = cds_lfht_del(ht->ht, iter->iter.node); + rcu_read_unlock(); + return ret; } /* * Get first node in the hashtable. */ +LTTNG_HIDDEN void lttng_ht_get_first(struct lttng_ht *ht, struct lttng_ht_iter *iter) { assert(ht); @@ -351,6 +481,7 @@ 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); @@ -363,6 +494,7 @@ 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; @@ -371,7 +503,10 @@ unsigned long lttng_ht_get_count(struct lttng_ht *ht) assert(ht); assert(ht->ht); + /* RCU read lock protects from ABA and allows RCU traversal. */ + rcu_read_lock(); cds_lfht_count_nodes(ht->ht, &scb, &count, &sca); + rcu_read_unlock(); return count; } @@ -379,6 +514,7 @@ 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) { @@ -395,6 +531,7 @@ 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) { @@ -411,6 +548,7 @@ 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) { @@ -425,10 +563,18 @@ struct lttng_ht_node_u64 *lttng_ht_iter_get_node_u64( } /* - * lib constructor + * Return lttng ht stream and index id node from iterator. */ -static void __attribute__((constructor)) _init(void) +LTTNG_HIDDEN +struct lttng_ht_node_two_u64 *lttng_ht_iter_get_node_two_u64( + struct lttng_ht_iter *iter) { - /* Init hash table seed */ - lttng_ht_seed = (unsigned long) time(NULL); + struct cds_lfht_node *node; + + 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); }