/*
- * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
+ * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
*
- * 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 _LGPL_SOURCE
-#include <assert.h>
#include <string.h>
#include <urcu.h>
#include <urcu/compiler.h>
#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;
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.
*/
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");
* 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:
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;
int ret;
ret = cds_lfht_destroy(ht->ht, NULL);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
free(ht);
}
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);
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);
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);
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;
LTTNG_HIDDEN
void lttng_ht_node_free_str(struct lttng_ht_node_str *node)
{
- assert(node);
+ LTTNG_ASSERT(node);
free(node);
}
LTTNG_HIDDEN
void lttng_ht_node_free_ulong(struct lttng_ht_node_ulong *node)
{
- assert(node);
+ LTTNG_ASSERT(node);
free(node);
}
LTTNG_HIDDEN
void lttng_ht_node_free_u64(struct lttng_ht_node_u64 *node)
{
- assert(node);
+ LTTNG_ASSERT(node);
free(node);
}
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.
*/
LTTNG_HIDDEN
-void lttng_ht_lookup(struct lttng_ht *ht, void *key,
+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);
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);
}
/*
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();
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();
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();
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();
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);
}
/*
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();
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);
}
/*
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();
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);
}
/*
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();
} else {
return caa_container_of(node_ptr, struct lttng_ht_node_ulong, node);
}
- assert(node_ptr == &node->node);
+ LTTNG_ASSERT(node_ptr == &node->node);
}
/*
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();
} else {
return caa_container_of(node_ptr, struct lttng_ht_node_u64, node);
}
- assert(node_ptr == &node->node);
+ LTTNG_ASSERT(node_ptr == &node->node);
}
/*
{
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();
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);
}
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);
}
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();
{
struct cds_lfht_node *node;
- assert(iter);
+ LTTNG_ASSERT(iter);
node = cds_lfht_iter_get_node(&iter->iter);
if (!node) {
return NULL;
{
struct cds_lfht_node *node;
- assert(iter);
+ LTTNG_ASSERT(iter);
node = cds_lfht_iter_get_node(&iter->iter);
if (!node) {
return NULL;
{
struct cds_lfht_node *node;
- assert(iter);
+ LTTNG_ASSERT(iter);
node = cds_lfht_iter_get_node(&iter->iter);
if (!node) {
return NULL;
{
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);
-}
projects / lttng-tools.git / blobdiff