X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fobdclass%2Flustre_handles.c;h=f790f7d289cd0c02498ea7a12a77d2afa3fabbba;hp=bc07df91b3d91a8c8101d5b8f99fa5413c5cd106;hb=9bda0a5cad190f33571ff6bce4235cd7fc4f76fd;hpb=a2a0746305449dbd925879b14dc2c0d6040bb8bf diff --git a/lustre/obdclass/lustre_handles.c b/lustre/obdclass/lustre_handles.c index bc07df9..f790f7d 100644 --- a/lustre/obdclass/lustre_handles.c +++ b/lustre/obdclass/lustre_handles.c @@ -1,165 +1,245 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: +/* + * GPL HEADER START * - * Copyright (C) 2002 Cluster File Systems, Inc. - * Author: Phil Schwan + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * - * This file is part of Lustre, http://www.lustre.org/ + * 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. * - * Lustre is free software; you can redistribute it and/or - * modify it under the terms of version 2 of the GNU General Public - * License as published by the Free Software Foundation. + * 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 version 2 for more details (a copy is included + * in the LICENSE file that accompanied this code). * - * Lustre 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 + * version 2 along with this program; If not, see + * http://www.gnu.org/licenses/gpl-2.0.html * - * You should have received a copy of the GNU General Public License - * along with Lustre; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * GPL HEADER END + */ +/* + * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. + * Use is subject to license terms. + * + * Copyright (c) 2011, 2017, Intel Corporation. + */ +/* + * This file is part of Lustre, http://www.lustre.org/ + * Lustre is a trademark of Sun Microsystems, Inc. + * + * lustre/obdclass/lustre_handles.c + * + * Author: Phil Schwan */ #define DEBUG_SUBSYSTEM S_CLASS -#ifdef __KERNEL__ -# include -# include -#else -# include -#endif - -#include -#include - -static spinlock_t handle_lock = SPIN_LOCK_UNLOCKED; -static spinlock_t random_lock = SPIN_LOCK_UNLOCKED; -static struct list_head *handle_hash = NULL; -static int handle_count = 0; - -#define HANDLE_HASH_SIZE (1 << 14) -#define HANDLE_HASH_MASK (HANDLE_HASH_SIZE - 1) -void class_handle_hash(struct portals_handle *h, portals_handle_addref_cb cb) -{ - struct list_head *bucket; - ENTRY; +#include - LASSERT(h != NULL); - LASSERT(list_empty(&h->h_link)); +#include +#include +#include - /* My hypothesis is that get_random_bytes, if called from two threads at - * the same time, will return the same bytes. -phil */ - spin_lock(&random_lock); - get_random_bytes(&h->h_cookie, sizeof(h->h_cookie)); - spin_unlock(&random_lock); - h->h_addref = cb; +static __u64 handle_base; +#define HANDLE_INCR 7 +static DEFINE_SPINLOCK(handle_base_lock); - bucket = handle_hash + (h->h_cookie & HANDLE_HASH_MASK); +static struct handle_bucket { + spinlock_t lock; + struct list_head head; +} *handle_hash; - CDEBUG(D_INFO, "adding object %p with handle "LPX64" to hash\n", - h, h->h_cookie); +#define HANDLE_HASH_SIZE (1 << 16) +#define HANDLE_HASH_MASK (HANDLE_HASH_SIZE - 1) - spin_lock(&handle_lock); - list_add(&h->h_link, bucket); - handle_count++; - spin_unlock(&handle_lock); - EXIT; +/* + * 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, + const struct portals_handle_ops *ops) +{ + struct handle_bucket *bucket; + + ENTRY; + + LASSERT(h != NULL); + LASSERT(list_empty(&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; + + 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 %#llx to hash\n", + h, h->h_cookie); + EXIT; } +EXPORT_SYMBOL(class_handle_hash); static void class_handle_unhash_nolock(struct portals_handle *h) { - LASSERT(!list_empty(&h->h_link)); - - CDEBUG(D_INFO, "removing object %p with handle "LPX64" from hash\n", - h, h->h_cookie); - - handle_count--; - list_del_init(&h->h_link); + if (list_empty(&h->h_link)) { + CERROR("removing an already-removed handle (%#llx)\n", + h->h_cookie); + return; + } + + CDEBUG(D_INFO, "removing object %p with handle %#llx from hash\n", + h, h->h_cookie); + + 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) { - spin_lock(&handle_lock); - class_handle_unhash_nolock(h); - spin_unlock(&handle_lock); + struct handle_bucket *bucket; + bucket = handle_hash + (h->h_cookie & HANDLE_HASH_MASK); + + spin_lock(&bucket->lock); + class_handle_unhash_nolock(h); + spin_unlock(&bucket->lock); } +EXPORT_SYMBOL(class_handle_unhash); -void *class_handle2object(__u64 cookie) +void *class_handle2object(u64 cookie, const struct portals_handle_ops *ops) { - struct list_head *bucket, *tmp; - void *retval = NULL; - ENTRY; - - LASSERT(handle_hash != NULL); - - spin_lock(&handle_lock); - bucket = handle_hash + (cookie & HANDLE_HASH_MASK); + struct handle_bucket *bucket; + struct portals_handle *h; + void *retval = NULL; + + ENTRY; + + 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); + + rcu_read_lock(); + list_for_each_entry_rcu(h, &bucket->head, h_link) { + if (h->h_cookie != cookie || h->h_ops != ops) + continue; + + 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); - list_for_each(tmp, bucket) { - struct portals_handle *h; - h = list_entry(tmp, struct portals_handle, h_link); +void class_handle_free_cb(struct rcu_head *rcu) +{ + struct portals_handle *h; + void *ptr; - if (h->h_cookie == cookie) { - h->h_addref(h); - retval = h; - break; - } - } - spin_unlock(&handle_lock); + h = container_of(rcu, struct portals_handle, h_rcu); + ptr = (void *)(unsigned long)h->h_cookie; - RETURN(retval); + 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 list_head *bucket; + 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_VMALLOC(handle_hash, sizeof(*handle_hash) * HANDLE_HASH_SIZE); - if (handle_hash == NULL) - return -ENOMEM; + for (bucket = handle_hash + HANDLE_HASH_SIZE - 1; bucket >= handle_hash; + bucket--) { + INIT_LIST_HEAD(&bucket->head); + spin_lock_init(&bucket->lock); + } - for (bucket = handle_hash + HANDLE_HASH_SIZE - 1; bucket >= handle_hash; - bucket--) - INIT_LIST_HEAD(bucket); + get_random_bytes(&handle_base, sizeof(handle_base)); + LASSERT(handle_base != 0ULL); - return 0; + return 0; } -static void cleanup_all_handles(void) +static int cleanup_all_handles(void) { - int i; - - spin_lock(&handle_lock); - for (i = 0; i < HANDLE_HASH_SIZE; i++) { - struct list_head *tmp, *pos; - list_for_each_safe(tmp, pos, &(handle_hash[i])) { - struct portals_handle *h; - h = list_entry(tmp, struct portals_handle, h_link); - - CERROR("forcing cleanup for handle "LPX64"\n", - h->h_cookie); - - class_handle_unhash_nolock(h); - } - } - spin_unlock(&handle_lock); + int rc; + int i; + + for (rc = i = 0; i < HANDLE_HASH_SIZE; i++) { + 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 %#llx addr %p ops %p\n", + h->h_cookie, h, h->h_ops); + + class_handle_unhash_nolock(h); + rc++; + } + spin_unlock(&handle_hash[i].lock); + } + + return rc; } void class_handle_cleanup(void) { - LASSERT(handle_hash != NULL); + int count; + + LASSERT(handle_hash != NULL); - if (handle_count != 0) { - CERROR("handle_count at cleanup: %d\n", handle_count); - cleanup_all_handles(); - } + count = cleanup_all_handles(); - OBD_VFREE(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 (handle_count) - CERROR("leaked %d handles\n", handle_count); + if (count != 0) + CERROR("handle_count at cleanup: %d\n", count); }