-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
- *
+/*
* GPL HEADER START
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
/*
* Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
+ *
+ * Copyright (c) 2011, Whamcloud, Inc.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#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
+struct cfs_wi_sched *cfs_sched_rehash;
+
static inline void
cfs_hash_nl_lock(cfs_hash_lock_t *lock, int exclusive) {}
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)) {
hs->hs_dep_bits = hs->hs_cur_bits;
cfs_spin_unlock(&hs->hs_dep_lock);
- cfs_wi_schedule(&hs->hs_dep_wi);
+ cfs_wi_schedule(cfs_sched_rehash, &hs->hs_dep_wi);
# endif
}
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);
}
static void cfs_hash_depth_wi_init(cfs_hash_t *hs)
{
- cfs_spin_lock_init(&hs->hs_dep_lock);
- cfs_wi_init(&hs->hs_dep_wi, hs,
- cfs_hash_dep_print, CFS_WI_SCHED_ANY);
+ cfs_spin_lock_init(&hs->hs_dep_lock);
+ cfs_wi_init(&hs->hs_dep_wi, hs, cfs_hash_dep_print);
}
static void cfs_hash_depth_wi_cancel(cfs_hash_t *hs)
{
- if (cfs_wi_cancel(&hs->hs_dep_wi))
+ if (cfs_wi_deschedule(cfs_sched_rehash, &hs->hs_dep_wi))
return;
cfs_spin_lock(&hs->hs_dep_lock);
hs->hs_ops = ops;
hs->hs_extra_bytes = extra_bytes;
hs->hs_rehash_bits = 0;
- cfs_wi_init(&hs->hs_rehash_wi, hs,
- cfs_hash_rehash_worker, CFS_WI_SCHED_ANY);
+ cfs_wi_init(&hs->hs_rehash_wi, hs, cfs_hash_rehash_worker);
cfs_hash_depth_wi_init(hs);
if (cfs_hash_with_rehash(hs))
* 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;
* 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;
cfs_hash_lock(hs, 0);
cfs_hash_dual_bd_get_and_lock(hs, key, bds, 1);
- if (bds[1].bd_bucket == NULL && hnode != NULL)
- cfs_hash_bd_del_locked(hs, &bds[0], hnode);
- else
- hnode = cfs_hash_dual_bd_finddel_locked(hs, bds, key, hnode);
+ /* NB: do nothing if @hnode is not in hash table */
+ if (hnode == NULL || !cfs_hlist_unhashed(hnode)) {
+ if (bds[1].bd_bucket == NULL && hnode != NULL) {
+ cfs_hash_bd_del_locked(hs, &bds[0], hnode);
+ } else {
+ hnode = cfs_hash_dual_bd_finddel_locked(hs, bds,
+ key, hnode);
+ }
+ }
if (hnode != NULL) {
obj = cfs_hash_object(hs, hnode);
* 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++;
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);
* 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;
if (!cfs_hash_is_rehashing(hs))
return;
- if (cfs_wi_cancel(&hs->hs_rehash_wi)) {
+ if (cfs_wi_deschedule(cfs_sched_rehash, &hs->hs_rehash_wi)) {
hs->hs_rehash_bits = 0;
return;
}
hs->hs_rehash_bits = rc;
if (!do_rehash) {
/* launch and return */
- cfs_wi_schedule(&hs->hs_rehash_wi);
+ cfs_wi_schedule(cfs_sched_rehash, &hs->hs_rehash_wi);
cfs_hash_unlock(hs, 1);
return 0;
}
hs->hs_cur_bits = hs->hs_rehash_bits;
out:
hs->hs_rehash_bits = 0;
- if (rc == -ESRCH)
- cfs_wi_exit(wi); /* never be scheduled again */
+ if (rc == -ESRCH) /* never be scheduled again */
+ cfs_wi_exit(cfs_sched_rehash, wi);
bsize = cfs_hash_bkt_size(hs);
cfs_hash_unlock(hs, 1);
/* can't refer to @hs anymore because it could be destroyed */
cfs_hash_buckets_free(bkts, bsize, new_size, old_size);
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 1 only if cfs_wi_exit is called */
+ return rc == -ESRCH;
}
/**
* 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];