#include <libcfs/libcfs.h>
#if CFS_HASH_DEBUG_LEVEL >= CFS_HASH_DEBUG_1
-static unsigned int warn_on_depth = 0;
+static unsigned int warn_on_depth = 8;
CFS_MODULE_PARM(warn_on_depth, "i", uint, 0644,
"warning when hash depth is high.");
#endif
static void
cfs_hash_bd_from_key(cfs_hash_t *hs, cfs_hash_bucket_t **bkts,
- unsigned int bits, void *key, cfs_hash_bd_t *bd)
+ unsigned int bits, const void *key, cfs_hash_bd_t *bd)
{
unsigned int index = cfs_hash_id(hs, key, (1U << bits) - 1);
}
void
-cfs_hash_bd_get(cfs_hash_t *hs, void *key, cfs_hash_bd_t *bd)
+cfs_hash_bd_get(cfs_hash_t *hs, const void *key, cfs_hash_bd_t *bd)
{
/* NB: caller should hold hs->hs_rwlock if REHASH is set */
if (likely(hs->hs_rehash_buckets == NULL)) {
static cfs_hlist_node_t *
cfs_hash_bd_lookup_intent(cfs_hash_t *hs, cfs_hash_bd_t *bd,
- void *key, cfs_hlist_node_t *hnode,
+ const void *key, cfs_hlist_node_t *hnode,
cfs_hash_lookup_intent_t intent)
{
}
cfs_hlist_node_t *
-cfs_hash_bd_lookup_locked(cfs_hash_t *hs, cfs_hash_bd_t *bd, void *key)
+cfs_hash_bd_lookup_locked(cfs_hash_t *hs, cfs_hash_bd_t *bd, const void *key)
{
return cfs_hash_bd_lookup_intent(hs, bd, key, NULL,
CFS_HS_LOOKUP_IT_FIND);
cfs_hlist_node_t *
cfs_hash_bd_findadd_locked(cfs_hash_t *hs, cfs_hash_bd_t *bd,
- void *key, cfs_hlist_node_t *hnode,
+ const void *key, cfs_hlist_node_t *hnode,
int noref)
{
return cfs_hash_bd_lookup_intent(hs, bd, key, hnode,
cfs_hlist_node_t *
cfs_hash_bd_finddel_locked(cfs_hash_t *hs, cfs_hash_bd_t *bd,
- void *key, cfs_hlist_node_t *hnode)
+ const void *key, cfs_hlist_node_t *hnode)
{
/* hnode can be NULL, we find the first item with @key */
return cfs_hash_bd_lookup_intent(hs, bd, key, hnode,
static cfs_hlist_node_t *
cfs_hash_multi_bd_lookup_locked(cfs_hash_t *hs, cfs_hash_bd_t *bds,
- unsigned n, void *key)
+ unsigned n, const void *key)
{
cfs_hlist_node_t *ehnode;
unsigned i;
static cfs_hlist_node_t *
cfs_hash_multi_bd_findadd_locked(cfs_hash_t *hs,
- cfs_hash_bd_t *bds, unsigned n, void *key,
+ cfs_hash_bd_t *bds, unsigned n, const void *key,
cfs_hlist_node_t *hnode, int noref)
{
cfs_hlist_node_t *ehnode;
static cfs_hlist_node_t *
cfs_hash_multi_bd_finddel_locked(cfs_hash_t *hs, cfs_hash_bd_t *bds,
- unsigned n, void *key, cfs_hlist_node_t *hnode)
+ unsigned n, const void *key,
+ cfs_hlist_node_t *hnode)
{
cfs_hlist_node_t *ehnode;
unsigned i;
}
void
-cfs_hash_dual_bd_get(cfs_hash_t *hs, void *key, cfs_hash_bd_t *bds)
+cfs_hash_dual_bd_get(cfs_hash_t *hs, const void *key, cfs_hash_bd_t *bds)
{
/* NB: caller should hold hs_lock.rw if REHASH is set */
cfs_hash_bd_from_key(hs, hs->hs_buckets,
CFS_EXPORT_SYMBOL(cfs_hash_dual_bd_unlock);
cfs_hlist_node_t *
-cfs_hash_dual_bd_lookup_locked(cfs_hash_t *hs, cfs_hash_bd_t *bds, void *key)
+cfs_hash_dual_bd_lookup_locked(cfs_hash_t *hs, cfs_hash_bd_t *bds,
+ const void *key)
{
return cfs_hash_multi_bd_lookup_locked(hs, bds, 2, key);
}
cfs_hlist_node_t *
cfs_hash_dual_bd_findadd_locked(cfs_hash_t *hs, cfs_hash_bd_t *bds,
- void *key, cfs_hlist_node_t *hnode,
+ const void *key, cfs_hlist_node_t *hnode,
int noref)
{
return cfs_hash_multi_bd_findadd_locked(hs, bds, 2, key,
cfs_hlist_node_t *
cfs_hash_dual_bd_finddel_locked(cfs_hash_t *hs, cfs_hash_bd_t *bds,
- void *key, cfs_hlist_node_t *hnode)
+ const void *key, cfs_hlist_node_t *hnode)
{
return cfs_hash_multi_bd_finddel_locked(hs, bds, 2, key, hnode);
}
* ops->hs_get function will be called when the item is added.
*/
void
-cfs_hash_add(cfs_hash_t *hs, void *key, cfs_hlist_node_t *hnode)
+cfs_hash_add(cfs_hash_t *hs, const void *key, cfs_hlist_node_t *hnode)
{
cfs_hash_bd_t bd;
int bits;
CFS_EXPORT_SYMBOL(cfs_hash_add);
static cfs_hlist_node_t *
-cfs_hash_find_or_add(cfs_hash_t *hs, void *key,
+cfs_hash_find_or_add(cfs_hash_t *hs, const void *key,
cfs_hlist_node_t *hnode, int noref)
{
cfs_hlist_node_t *ehnode;
* Returns 0 on success or -EALREADY on key collisions.
*/
int
-cfs_hash_add_unique(cfs_hash_t *hs, void *key, cfs_hlist_node_t *hnode)
+cfs_hash_add_unique(cfs_hash_t *hs, const void *key, cfs_hlist_node_t *hnode)
{
- RETURN(cfs_hash_find_or_add(hs, key, hnode, 1) != hnode ?
- -EALREADY : 0);
+ return cfs_hash_find_or_add(hs, key, hnode, 1) != hnode ?
+ -EALREADY : 0;
}
CFS_EXPORT_SYMBOL(cfs_hash_add_unique);
* Otherwise ops->hs_get is called on the item which was added.
*/
void *
-cfs_hash_findadd_unique(cfs_hash_t *hs, void *key,
+cfs_hash_findadd_unique(cfs_hash_t *hs, const void *key,
cfs_hlist_node_t *hnode)
{
hnode = cfs_hash_find_or_add(hs, key, hnode, 0);
* on the removed object.
*/
void *
-cfs_hash_del(cfs_hash_t *hs, void *key, cfs_hlist_node_t *hnode)
+cfs_hash_del(cfs_hash_t *hs, const void *key, cfs_hlist_node_t *hnode)
{
void *obj = NULL;
int bits = 0;
* will be returned and ops->hs_put is called on the removed object.
*/
void *
-cfs_hash_del_key(cfs_hash_t *hs, void *key)
+cfs_hash_del_key(cfs_hash_t *hs, const void *key)
{
return cfs_hash_del(hs, key, NULL);
}
* in the hash @hs NULL is returned.
*/
void *
-cfs_hash_lookup(cfs_hash_t *hs, void *key)
+cfs_hash_lookup(cfs_hash_t *hs, const void *key)
{
void *obj = NULL;
cfs_hlist_node_t *hnode;
{
cfs_hlist_node_t *hnode;
cfs_hlist_node_t *tmp;
- void *obj;
cfs_hash_bd_t bd;
__u32 version;
int count = 0;
cfs_hash_bd_for_each_hlist(hs, &bd, hhead) {
for (hnode = hhead->first; hnode != NULL;) {
cfs_hash_bucket_validate(hs, &bd, hnode);
- obj = cfs_hash_get(hs, hnode);
+ cfs_hash_get(hs, hnode);
cfs_hash_bd_unlock(hs, &bd, 0);
cfs_hash_unlock(hs, 0);
rc = func(hs, &bd, hnode, data);
if (stop_on_change)
- (void)cfs_hash_put(hs, hnode);
+ cfs_hash_put(hs, hnode);
cfs_cond_resched();
count++;
cfs_hlist_head_t *hhead;
cfs_hlist_node_t *hnode;
cfs_hash_bd_t bd;
- ENTRY;
cfs_hash_for_each_enter(hs);
cfs_hash_lock(hs, 0);
if (hindex >= CFS_HASH_NHLIST(hs))
goto out;
- bd.bd_bucket = hs->hs_buckets[hindex >> hs->hs_bkt_bits];
- bd.bd_offset = hindex & (CFS_HASH_BKT_NHLIST(hs) - 1);
+ cfs_hash_bd_index_set(hs, hindex, &bd);
cfs_hash_bd_lock(hs, &bd, 0);
hhead = cfs_hash_bd_hhead(hs, &bd);
out:
cfs_hash_unlock(hs, 0);
cfs_hash_for_each_exit(hs);
- EXIT;
}
CFS_EXPORT_SYMBOL(cfs_hash_hlist_for_each);
* is held so the callback must never sleep.
*/
void
-cfs_hash_for_each_key(cfs_hash_t *hs, void *key,
+cfs_hash_for_each_key(cfs_hash_t *hs, const void *key,
cfs_hash_for_each_cb_t func, void *data)
{
cfs_hlist_node_t *hnode;
cfs_hash_bd_t bds[2];
unsigned i;
- ENTRY;
cfs_hash_lock(hs, 0);
cfs_hash_dual_bd_unlock(hs, bds, 0);
cfs_hash_unlock(hs, 0);
-
- EXIT;
}
CFS_EXPORT_SYMBOL(cfs_hash_for_each_key);
cfs_hash_rehash(cfs_hash_t *hs, int do_rehash)
{
int rc;
- ENTRY;
LASSERT(cfs_hash_with_rehash(hs) && !cfs_hash_with_no_lock(hs));
int count = 0;
int rc = 0;
int i;
- ENTRY;
LASSERT (hs != NULL && cfs_hash_with_rehash(hs));
if (rc != 0)
CDEBUG(D_INFO, "early quit of of rehashing: %d\n", rc);
/* cfs_workitem require us to always return 0 */
- RETURN(0);
+ return 0;
}
/**
* the registered cfs_hash_get() and cfs_hash_put() functions will
* not be called.
*/
-void cfs_hash_rehash_key(cfs_hash_t *hs, void *old_key,
+void cfs_hash_rehash_key(cfs_hash_t *hs, const void *old_key,
void *new_key, cfs_hlist_node_t *hnode)
{
cfs_hash_bd_t bds[3];
git://git.whamcloud.com / fs / lustre-release.git / blobdiff