X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fobdclass%2Flustre_handles.c;h=483325652e36865d7b09e76c786d67606f2cd4e4;hb=730a204e73667403e299936fafa0d3eb45099709;hp=9c91df35d2326726dac9bc6520081dc6aaa979a2;hpb=711e142d055fda62be482f74f2f73acac5e7e453;p=fs%2Flustre-release.git

diff --git a/lustre/obdclass/lustre_handles.c b/lustre/obdclass/lustre_handles.c
index 9c91df3..4833256 100644
--- a/lustre/obdclass/lustre_handles.c
+++ b/lustre/obdclass/lustre_handles.c
@@ -1,6 +1,4 @@
-/* -*- 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.
@@ -28,6 +26,8 @@
 /*
  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
+ *
+ * Copyright (c) 2011, 2013, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -47,44 +47,34 @@
 #include <lustre_handles.h>
 #include <lustre_lib.h>
 
-#if !defined(HAVE_RCU) || !defined(__KERNEL__)
+#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()         cfs_spin_lock(&bucket->lock)
-# define rcu_read_unlock()       cfs_spin_unlock(&bucket->lock)
-#endif /* ifndef HAVE_RCU */
+# 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 cfs_spinlock_t handle_base_lock;
+static spinlock_t handle_base_lock;
 
 static struct handle_bucket {
-        cfs_spinlock_t lock;
-        cfs_list_t head;
+	spinlock_t	lock;
+	cfs_list_t	head;
 } *handle_hash;
 
-static cfs_atomic_t handle_count = CFS_ATOMIC_INIT(0);
-
-#ifdef __arch_um__
-/* For unknown reason, UML uses kmalloc rather than vmalloc to allocate
- * memory(OBD_VMALLOC). Therefore, we have to redefine the
- * HANDLE_HASH_SIZE to make the hash heads don't exceed 128K.
- */
-#define HANDLE_HASH_SIZE 4096
-#else
-#define HANDLE_HASH_SIZE (1 << 14)
-#endif /* ifdef __arch_um__ */
-
+#define HANDLE_HASH_SIZE (1 << 16)
 #define HANDLE_HASH_MASK (HANDLE_HASH_SIZE - 1)
 
 /*
  * 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, portals_handle_addref_cb cb)
+void class_handle_hash(struct portals_handle *h,
+		       struct portals_handle_ops *ops)
 {
         struct handle_bucket *bucket;
         ENTRY;
@@ -96,35 +86,35 @@ void class_handle_hash(struct portals_handle *h, portals_handle_addref_cb cb)
          * This is fast, but simplistic cookie generation algorithm, it will
          * need a re-do at some point in the future for security.
          */
-        cfs_spin_lock(&handle_base_lock);
-        handle_base += HANDLE_INCR;
-
-        h->h_cookie = handle_base;
-        if (unlikely(handle_base == 0)) {
-                /*
-                 * Cookie of zero is "dangerous", because in many places it's
-                 * assumed that 0 means "unassigned" handle, not bound to any
-                 * object.
-                 */
-                CWARN("The universe has been exhausted: cookie wrap-around.\n");
-                handle_base += HANDLE_INCR;
-        }
-        cfs_spin_unlock(&handle_base_lock);
- 
-        cfs_atomic_inc(&handle_count);
-        h->h_addref = cb;
-        cfs_spin_lock_init(&h->h_lock);
-
-        bucket = &handle_hash[h->h_cookie & HANDLE_HASH_MASK];
-        cfs_spin_lock(&bucket->lock);
-        list_add_rcu(&h->h_link, &bucket->head);
-        h->h_in = 1;
-        cfs_spin_unlock(&bucket->lock);
-
-        CDEBUG(D_INFO, "added object %p with handle "LPX64" to hash\n",
-               h, h->h_cookie);
-        EXIT;
+	spin_lock(&handle_base_lock);
+	handle_base += HANDLE_INCR;
+
+	if (unlikely(handle_base == 0)) {
+		/*
+		 * Cookie of zero is "dangerous", because in many places it's
+		 * assumed that 0 means "unassigned" handle, not bound to any
+		 * object.
+		 */
+		CWARN("The universe has been exhausted: cookie wrap-around.\n");
+		handle_base += HANDLE_INCR;
+	}
+	h->h_cookie = handle_base;
+	spin_unlock(&handle_base_lock);
+
+	h->h_ops = ops;
+	spin_lock_init(&h->h_lock);
+
+	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);
+
+	CDEBUG(D_INFO, "added object %p with handle "LPX64" to hash\n",
+	       h, h->h_cookie);
+	EXIT;
 }
+EXPORT_SYMBOL(class_handle_hash);
 
 static void class_handle_unhash_nolock(struct portals_handle *h)
 {
@@ -137,45 +127,44 @@ static void class_handle_unhash_nolock(struct portals_handle *h)
         CDEBUG(D_INFO, "removing object %p with handle "LPX64" from hash\n",
                h, h->h_cookie);
 
-        cfs_spin_lock(&h->h_lock);
-        if (h->h_in == 0) {
-                cfs_spin_unlock(&h->h_lock);
-                return;
-        }
-        h->h_in = 0;
-        cfs_spin_unlock(&h->h_lock);
-        list_del_rcu(&h->h_link);
+	spin_lock(&h->h_lock);
+	if (h->h_in == 0) {
+		spin_unlock(&h->h_lock);
+		return;
+	}
+	h->h_in = 0;
+	spin_unlock(&h->h_lock);
+	list_del_rcu(&h->h_link);
 }
 
 void class_handle_unhash(struct portals_handle *h)
 {
-        struct handle_bucket *bucket;
-        bucket = handle_hash + (h->h_cookie & HANDLE_HASH_MASK);
-
-        cfs_spin_lock(&bucket->lock);
-        class_handle_unhash_nolock(h);
-        cfs_spin_unlock(&bucket->lock);
+	struct handle_bucket *bucket;
+	bucket = handle_hash + (h->h_cookie & HANDLE_HASH_MASK);
 
-        cfs_atomic_dec(&handle_count);
+	spin_lock(&bucket->lock);
+	class_handle_unhash_nolock(h);
+	spin_unlock(&bucket->lock);
 }
+EXPORT_SYMBOL(class_handle_unhash);
 
 void class_handle_hash_back(struct portals_handle *h)
 {
-        struct handle_bucket *bucket;
-        ENTRY;
+	struct handle_bucket *bucket;
+	ENTRY;
 
-        bucket = handle_hash + (h->h_cookie & HANDLE_HASH_MASK);
+	bucket = handle_hash + (h->h_cookie & HANDLE_HASH_MASK);
 
-        cfs_atomic_inc(&handle_count);
-        cfs_spin_lock(&bucket->lock);
-        list_add_rcu(&h->h_link, &bucket->head);
-        h->h_in = 1;
-        cfs_spin_unlock(&bucket->lock);
+	spin_lock(&bucket->lock);
+	list_add_rcu(&h->h_link, &bucket->head);
+	h->h_in = 1;
+	spin_unlock(&bucket->lock);
 
-        EXIT;
+	EXIT;
 }
+EXPORT_SYMBOL(class_handle_hash_back);
 
-void *class_handle2object(__u64 cookie)
+void *class_handle2object(__u64 cookie, const void *owner)
 {
         struct handle_bucket *bucket;
         struct portals_handle *h;
@@ -184,39 +173,40 @@ void *class_handle2object(__u64 cookie)
 
         LASSERT(handle_hash != NULL);
 
-        /* Be careful when you want to change this code. See the 
-         * rcu_read_lock() definition on top this file. - jxiong */
+	/* 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)
+		if (h->h_cookie != cookie || h->h_owner != owner)
                         continue;
 
-                cfs_spin_lock(&h->h_lock);
-                if (likely(h->h_in != 0)) {
-                        h->h_addref(h);
-                        retval = h;
-                }
-                cfs_spin_unlock(&h->h_lock);
-                break;
-        }
-        rcu_read_unlock();
-
-        RETURN(retval);
+		spin_lock(&h->h_lock);
+		if (likely(h->h_in != 0)) {
+			h->h_ops->hop_addref(h);
+			retval = h;
+		}
+		spin_unlock(&h->h_lock);
+		break;
+	}
+	rcu_read_unlock();
+
+	RETURN(retval);
 }
+EXPORT_SYMBOL(class_handle2object);
 
 void class_handle_free_cb(cfs_rcu_head_t *rcu)
 {
-        struct portals_handle *h = RCU2HANDLE(rcu);
-        if (h->h_free_cb) {
-                h->h_free_cb(h->h_ptr, h->h_size);
-        } else {
-                void *ptr = h->h_ptr;
-                unsigned int size = h->h_size;
-                OBD_FREE(ptr, size);
-        }
+	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)
 {
@@ -226,21 +216,21 @@ int class_handle_init(void)
 
         LASSERT(handle_hash == NULL);
 
-        OBD_VMALLOC(handle_hash, sizeof(*bucket) * HANDLE_HASH_SIZE);
+        OBD_ALLOC_LARGE(handle_hash, sizeof(*bucket) * HANDLE_HASH_SIZE);
         if (handle_hash == NULL)
                 return -ENOMEM;
 
-        cfs_spin_lock_init(&handle_base_lock);
-        for (bucket = handle_hash + HANDLE_HASH_SIZE - 1; bucket >= handle_hash;
-             bucket--) {
-                CFS_INIT_LIST_HEAD(&bucket->head);
-                cfs_spin_lock_init(&bucket->lock);
-        }
+	spin_lock_init(&handle_base_lock);
+	for (bucket = handle_hash + HANDLE_HASH_SIZE - 1; bucket >= handle_hash;
+	     bucket--) {
+		CFS_INIT_LIST_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]);
+	/** bug 21430: add randomness to the initial base */
+	cfs_get_random_bytes(seed, sizeof(seed));
+	do_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);
@@ -248,22 +238,26 @@ int class_handle_init(void)
         return 0;
 }
 
-static void cleanup_all_handles(void)
+static int cleanup_all_handles(void)
 {
-        int i;
+	int rc;
+	int i;
 
-        for (i = 0; i < HANDLE_HASH_SIZE; i++) {
-                struct portals_handle *h;
+	for (rc = i = 0; i < HANDLE_HASH_SIZE; i++) {
+		struct portals_handle *h;
 
-                cfs_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 addref %p\n",
-                               h->h_cookie, h, h->h_addref);
+		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);
 
-                        class_handle_unhash_nolock(h);
-                }
-                cfs_spin_unlock(&handle_hash[i].lock);
-        }
+			class_handle_unhash_nolock(h);
+			rc++;
+		}
+		spin_unlock(&handle_hash[i].lock);
+	}
+
+	return rc;
 }
 
 void class_handle_cleanup(void)
@@ -271,15 +265,11 @@ void class_handle_cleanup(void)
         int count;
         LASSERT(handle_hash != NULL);
 
-        count = cfs_atomic_read(&handle_count);
-        if (count != 0) {
-                CERROR("handle_count at cleanup: %d\n", count);
-                cleanup_all_handles();
-        }
+        count = cleanup_all_handles();
 
-        OBD_VFREE(handle_hash, sizeof(*handle_hash) * HANDLE_HASH_SIZE);
+        OBD_FREE_LARGE(handle_hash, sizeof(*handle_hash) * HANDLE_HASH_SIZE);
         handle_hash = NULL;
 
-        if (cfs_atomic_read(&handle_count))
-                CERROR("leaked %d handles\n", cfs_atomic_read(&handle_count));
+        if (count != 0)
+                CERROR("handle_count at cleanup: %d\n", count);
 }