X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fobdclass%2Flustre_handles.c;h=27f69715e582d122eae908a2e38b06dae03c4178;hb=a813e81870096bcfecbe12aeeed8e1b0114cd474;hp=44ebea0ca0464f2000f1b37e5bca183b4088add7;hpb=1271ea42d82dbf8bc72e8fc47a08cecc44f978ae;p=fs%2Flustre-release.git diff --git a/lustre/obdclass/lustre_handles.c b/lustre/obdclass/lustre_handles.c index 44ebea0..27f6971 100644 --- a/lustre/obdclass/lustre_handles.c +++ b/lustre/obdclass/lustre_handles.c @@ -15,11 +15,7 @@ * * You should have received a copy of the GNU General Public License * version 2 along with this program; If not, see - * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf - * - * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. + * http://www.gnu.org/licenses/gpl-2.0.html * * GPL HEADER END */ @@ -27,7 +23,7 @@ * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2012, Intel Corporation. + * Copyright (c) 2011, 2017, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -39,31 +35,21 @@ */ #define DEBUG_SUBSYSTEM S_CLASS -#ifndef __KERNEL__ -# include -#endif + +#include #include #include #include -#ifndef __KERNEL__ -# define list_add_rcu cfs_list_add -# define list_del_rcu cfs_list_del -# define list_for_each_rcu cfs_list_for_each -# define list_for_each_safe_rcu cfs_list_for_each_safe -# define list_for_each_entry_rcu cfs_list_for_each_entry -# define rcu_read_lock() spin_lock(&bucket->lock) -# define rcu_read_unlock() spin_unlock(&bucket->lock) -#endif /* !__KERNEL__ */ static __u64 handle_base; #define HANDLE_INCR 7 -static spinlock_t handle_base_lock; +static DEFINE_SPINLOCK(handle_base_lock); static struct handle_bucket { - spinlock_t lock; - cfs_list_t head; + spinlock_t lock; + struct hlist_head head; } *handle_hash; #define HANDLE_HASH_SIZE (1 << 16) @@ -73,19 +59,19 @@ static struct handle_bucket { * Generate a unique 64bit cookie (hash) for a handle and insert it into * global (per-node) hash-table. */ -void class_handle_hash(struct portals_handle *h, - struct portals_handle_ops *ops) +void class_handle_hash(struct portals_handle *h, const char *owner) { - struct handle_bucket *bucket; - ENTRY; + struct handle_bucket *bucket; - LASSERT(h != NULL); - LASSERT(cfs_list_empty(&h->h_link)); + ENTRY; - /* - * This is fast, but simplistic cookie generation algorithm, it will - * need a re-do at some point in the future for security. - */ + LASSERT(h != NULL); + LASSERT(hlist_unhashed(&h->h_link)); + + /* + * This is fast, but simplistic cookie generation algorithm, it will + * need a re-do at some point in the future for security. + */ spin_lock(&handle_base_lock); handle_base += HANDLE_INCR; @@ -101,16 +87,14 @@ void class_handle_hash(struct portals_handle *h, h->h_cookie = handle_base; spin_unlock(&handle_base_lock); - h->h_ops = ops; - spin_lock_init(&h->h_lock); + h->h_owner = owner; bucket = &handle_hash[h->h_cookie & HANDLE_HASH_MASK]; spin_lock(&bucket->lock); - list_add_rcu(&h->h_link, &bucket->head); - h->h_in = 1; + hlist_add_head_rcu(&h->h_link, &bucket->head); spin_unlock(&bucket->lock); - CDEBUG(D_INFO, "added object %p with handle "LPX64" to hash\n", + CDEBUG(D_INFO, "added object %p with handle %#llx to hash\n", h, h->h_cookie); EXIT; } @@ -118,23 +102,16 @@ EXPORT_SYMBOL(class_handle_hash); static void class_handle_unhash_nolock(struct portals_handle *h) { - if (cfs_list_empty(&h->h_link)) { - CERROR("removing an already-removed handle ("LPX64")\n", - h->h_cookie); - return; - } - - CDEBUG(D_INFO, "removing object %p with handle "LPX64" from hash\n", - h, h->h_cookie); - - spin_lock(&h->h_lock); - if (h->h_in == 0) { - spin_unlock(&h->h_lock); + if (hlist_unhashed(&h->h_link)) { + CERROR("removing an already-removed handle (%#llx)\n", + h->h_cookie); return; } - h->h_in = 0; - spin_unlock(&h->h_lock); - list_del_rcu(&h->h_link); + + CDEBUG(D_INFO, "removing object %p with handle %#llx from hash\n", + h, h->h_cookie); + + hlist_del_init_rcu(&h->h_link); } void class_handle_unhash(struct portals_handle *h) @@ -148,46 +125,33 @@ void class_handle_unhash(struct portals_handle *h) } EXPORT_SYMBOL(class_handle_unhash); -void class_handle_hash_back(struct portals_handle *h) +void *class_handle2object(u64 cookie, const char *owner) { struct handle_bucket *bucket; - ENTRY; - - bucket = handle_hash + (h->h_cookie & HANDLE_HASH_MASK); - - spin_lock(&bucket->lock); - list_add_rcu(&h->h_link, &bucket->head); - h->h_in = 1; - spin_unlock(&bucket->lock); - - EXIT; -} -EXPORT_SYMBOL(class_handle_hash_back); + struct portals_handle *h; + void *retval = NULL; -void *class_handle2object(__u64 cookie) -{ - struct handle_bucket *bucket; - struct portals_handle *h; - void *retval = NULL; - ENTRY; + ENTRY; - LASSERT(handle_hash != NULL); + LASSERT(handle_hash != NULL); - /* Be careful when you want to change this code. See the - * rcu_read_lock() definition on top this file. - jxiong */ - bucket = handle_hash + (cookie & HANDLE_HASH_MASK); + /* + * Be careful when you want to change this code. See the + * rcu_read_lock() definition on top this file. - jxiong + */ + bucket = handle_hash + (cookie & HANDLE_HASH_MASK); - rcu_read_lock(); - list_for_each_entry_rcu(h, &bucket->head, h_link) { - if (h->h_cookie != cookie) - continue; + rcu_read_lock(); + hlist_for_each_entry_rcu(h, &bucket->head, h_link) { + if (h->h_cookie != cookie || h->h_owner != owner) + continue; - spin_lock(&h->h_lock); - if (likely(h->h_in != 0)) { - h->h_ops->hop_addref(h); + if (refcount_inc_not_zero(&h->h_ref)) { + CDEBUG(D_INFO, "GET %s %p refcount=%d\n", + h->h_owner, h, + refcount_read(&h->h_ref)); retval = h; } - spin_unlock(&h->h_lock); break; } rcu_read_unlock(); @@ -196,46 +160,26 @@ void *class_handle2object(__u64 cookie) } EXPORT_SYMBOL(class_handle2object); -void class_handle_free_cb(cfs_rcu_head_t *rcu) -{ - struct portals_handle *h = RCU2HANDLE(rcu); - void *ptr = (void *)(unsigned long)h->h_cookie; - - if (h->h_ops->hop_free != NULL) - h->h_ops->hop_free(ptr, h->h_size); - else - OBD_FREE(ptr, h->h_size); -} -EXPORT_SYMBOL(class_handle_free_cb); - int class_handle_init(void) { - struct handle_bucket *bucket; - struct timeval tv; - int seed[2]; + struct handle_bucket *bucket; - LASSERT(handle_hash == NULL); + LASSERT(handle_hash == NULL); - OBD_ALLOC_LARGE(handle_hash, sizeof(*bucket) * HANDLE_HASH_SIZE); - if (handle_hash == NULL) - return -ENOMEM; + OBD_ALLOC_LARGE(handle_hash, sizeof(*bucket) * HANDLE_HASH_SIZE); + if (handle_hash == NULL) + return -ENOMEM; - spin_lock_init(&handle_base_lock); for (bucket = handle_hash + HANDLE_HASH_SIZE - 1; bucket >= handle_hash; bucket--) { - CFS_INIT_LIST_HEAD(&bucket->head); + INIT_HLIST_HEAD(&bucket->head); spin_lock_init(&bucket->lock); } - /** bug 21430: add randomness to the initial base */ - cfs_get_random_bytes(seed, sizeof(seed)); - cfs_gettimeofday(&tv); - cfs_srand(tv.tv_sec ^ seed[0], tv.tv_usec ^ seed[1]); - - cfs_get_random_bytes(&handle_base, sizeof(handle_base)); - LASSERT(handle_base != 0ULL); + get_random_bytes(&handle_base, sizeof(handle_base)); + LASSERT(handle_base != 0ULL); - return 0; + return 0; } static int cleanup_all_handles(void) @@ -247,9 +191,9 @@ static int cleanup_all_handles(void) struct portals_handle *h; spin_lock(&handle_hash[i].lock); - list_for_each_entry_rcu(h, &(handle_hash[i].head), h_link) { - CERROR("force clean handle "LPX64" addr %p ops %p\n", - h->h_cookie, h, h->h_ops); + hlist_for_each_entry_rcu(h, &handle_hash[i].head, h_link) { + CERROR("force clean handle %#llx addr %p owner %p\n", + h->h_cookie, h, h->h_owner); class_handle_unhash_nolock(h); rc++; @@ -262,14 +206,15 @@ static int cleanup_all_handles(void) void class_handle_cleanup(void) { - int count; - LASSERT(handle_hash != NULL); + int count; + + LASSERT(handle_hash != NULL); - count = cleanup_all_handles(); + count = cleanup_all_handles(); - OBD_FREE_LARGE(handle_hash, sizeof(*handle_hash) * HANDLE_HASH_SIZE); - handle_hash = NULL; + OBD_FREE_LARGE(handle_hash, sizeof(*handle_hash) * HANDLE_HASH_SIZE); + handle_hash = NULL; - if (count != 0) - CERROR("handle_count at cleanup: %d\n", count); + if (count != 0) + CERROR("handle_count at cleanup: %d\n", count); }