X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fobdclass%2Flu_ref.c;h=cf674a9594f5752c29c215abff14c03dcd32bfe2;hp=6deddf783142e8bb2f1d47407acdf890f6d1b78d;hb=f07508d17b49574c7ea47a855c6e8af2b23c3add;hpb=2711e4428bc9b1574202ccd8c566557fb102424a diff --git a/lustre/obdclass/lu_ref.c b/lustre/obdclass/lu_ref.c index 6deddf7..cf674a9 100644 --- a/lustre/obdclass/lu_ref.c +++ b/lustre/obdclass/lu_ref.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) 2008, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2012, Intel Corporation. + * Copyright (c) 2012, 2017, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -42,12 +38,7 @@ #define DEBUG_SUBSYSTEM S_CLASS -#ifdef __KERNEL__ -# include -#else -# include -#endif - +#include #include #include #include @@ -71,17 +62,17 @@ } \ } while (0) -static cfs_mem_cache_t *lu_ref_link_kmem; +static struct kmem_cache *lu_ref_link_kmem; static struct lu_kmem_descr lu_ref_caches[] = { - { - .ckd_cache = &lu_ref_link_kmem, - .ckd_name = "lu_ref_link_kmem", - .ckd_size = sizeof (struct lu_ref_link) - }, - { - .ckd_cache = NULL - } + { + .ckd_cache = &lu_ref_link_kmem, + .ckd_name = "lu_ref_link_kmem", + .ckd_size = sizeof(struct lu_ref_link) + }, + { + .ckd_cache = NULL + } }; /** @@ -89,29 +80,28 @@ static struct lu_kmem_descr lu_ref_caches[] = { * * Protected by lu_ref_refs_guard. */ -static CFS_LIST_HEAD(lu_ref_refs); -static spinlock_t lu_ref_refs_guard; +static LIST_HEAD(lu_ref_refs); +static DEFINE_SPINLOCK(lu_ref_refs_guard); static struct lu_ref lu_ref_marker = { .lf_guard = __SPIN_LOCK_UNLOCKED(lu_ref_marker.lf_guard), - .lf_list = CFS_LIST_HEAD_INIT(lu_ref_marker.lf_list), - .lf_linkage = CFS_LIST_HEAD_INIT(lu_ref_marker.lf_linkage) + .lf_list = LIST_HEAD_INIT(lu_ref_marker.lf_list), + .lf_linkage = LIST_HEAD_INIT(lu_ref_marker.lf_linkage) }; void lu_ref_print(const struct lu_ref *ref) { - struct lu_ref_link *link; + struct lu_ref_link *link; - CERROR("lu_ref: %p %d %d %s:%d\n", - ref, ref->lf_refs, ref->lf_failed, ref->lf_func, ref->lf_line); - cfs_list_for_each_entry(link, &ref->lf_list, ll_linkage) { - CERROR(" link: %s %p\n", link->ll_scope, link->ll_source); - } + CERROR("lu_ref: %p %d %d %s:%d\n", + ref, ref->lf_refs, ref->lf_failed, ref->lf_func, ref->lf_line); + list_for_each_entry(link, &ref->lf_list, ll_linkage) { + CERROR(" link: %s %p\n", link->ll_scope, link->ll_source); + } } -EXPORT_SYMBOL(lu_ref_print); static int lu_ref_is_marker(const struct lu_ref *ref) { - return (ref == &lu_ref_marker); + return ref == &lu_ref_marker; } void lu_ref_print_all(void) @@ -119,7 +109,7 @@ void lu_ref_print_all(void) struct lu_ref *ref; spin_lock(&lu_ref_refs_guard); - cfs_list_for_each_entry(ref, &lu_ref_refs, lf_linkage) { + list_for_each_entry(ref, &lu_ref_refs, lf_linkage) { if (lu_ref_is_marker(ref)) continue; @@ -129,7 +119,6 @@ void lu_ref_print_all(void) } spin_unlock(&lu_ref_refs_guard); } -EXPORT_SYMBOL(lu_ref_print_all); void lu_ref_init_loc(struct lu_ref *ref, const char *func, const int line) { @@ -137,39 +126,41 @@ void lu_ref_init_loc(struct lu_ref *ref, const char *func, const int line) ref->lf_func = func; ref->lf_line = line; spin_lock_init(&ref->lf_guard); - CFS_INIT_LIST_HEAD(&ref->lf_list); + INIT_LIST_HEAD(&ref->lf_list); spin_lock(&lu_ref_refs_guard); - cfs_list_add(&ref->lf_linkage, &lu_ref_refs); + list_add(&ref->lf_linkage, &lu_ref_refs); spin_unlock(&lu_ref_refs_guard); } EXPORT_SYMBOL(lu_ref_init_loc); void lu_ref_fini(struct lu_ref *ref) { - REFASSERT(ref, cfs_list_empty(&ref->lf_list)); + spin_lock(&ref->lf_guard); + REFASSERT(ref, list_empty(&ref->lf_list)); REFASSERT(ref, ref->lf_refs == 0); + spin_unlock(&ref->lf_guard); spin_lock(&lu_ref_refs_guard); - cfs_list_del_init(&ref->lf_linkage); + list_del_init(&ref->lf_linkage); spin_unlock(&lu_ref_refs_guard); } EXPORT_SYMBOL(lu_ref_fini); static struct lu_ref_link *lu_ref_add_context(struct lu_ref *ref, - enum cfs_alloc_flags flags, - const char *scope, - const void *source) + int flags, + const char *scope, + const void *source) { - struct lu_ref_link *link; - - link = NULL; - if (lu_ref_link_kmem != NULL) { - OBD_SLAB_ALLOC_PTR_GFP(link, lu_ref_link_kmem, flags); - if (link != NULL) { - link->ll_ref = ref; - link->ll_scope = scope; - link->ll_source = source; + struct lu_ref_link *link; + + link = NULL; + if (lu_ref_link_kmem != NULL) { + OBD_SLAB_ALLOC_PTR_GFP(link, lu_ref_link_kmem, flags); + if (link != NULL) { + link->ll_ref = ref; + link->ll_scope = scope; + link->ll_source = source; spin_lock(&ref->lf_guard); - cfs_list_add_tail(&link->ll_linkage, &ref->lf_list); + list_add_tail(&link->ll_linkage, &ref->lf_list); ref->lf_refs++; spin_unlock(&ref->lf_guard); } @@ -187,8 +178,8 @@ static struct lu_ref_link *lu_ref_add_context(struct lu_ref *ref, void lu_ref_add(struct lu_ref *ref, const char *scope, const void *source) { - cfs_might_sleep(); - lu_ref_add_context(ref, CFS_ALLOC_STD, scope, source); + might_sleep(); + lu_ref_add_context(ref, GFP_NOFS, scope, source); } EXPORT_SYMBOL(lu_ref_add); @@ -199,7 +190,7 @@ void lu_ref_add_at(struct lu_ref *ref, struct lu_ref_link *link, link->ll_scope = scope; link->ll_source = source; spin_lock(&ref->lf_guard); - cfs_list_add_tail(&link->ll_linkage, &ref->lf_list); + list_add_tail(&link->ll_linkage, &ref->lf_list); ref->lf_refs++; spin_unlock(&ref->lf_guard); } @@ -211,14 +202,15 @@ EXPORT_SYMBOL(lu_ref_add_at); void lu_ref_add_atomic(struct lu_ref *ref, const char *scope, const void *source) { - lu_ref_add_context(ref, CFS_ALLOC_ATOMIC, scope, source); + lu_ref_add_context(ref, GFP_ATOMIC, scope, source); } EXPORT_SYMBOL(lu_ref_add_atomic); static inline int lu_ref_link_eq(const struct lu_ref_link *link, - const char *scope, const void *source) + const char *scope, + const void *source) { - return link->ll_source == source && !strcmp(link->ll_scope, scope); + return link->ll_source == source && !strcmp(link->ll_scope, scope); } /** @@ -232,22 +224,22 @@ static unsigned lu_ref_chain_max_length = 127; static struct lu_ref_link *lu_ref_find(struct lu_ref *ref, const char *scope, const void *source) { - struct lu_ref_link *link; - unsigned iterations; - - iterations = 0; - cfs_list_for_each_entry(link, &ref->lf_list, ll_linkage) { - ++iterations; - if (lu_ref_link_eq(link, scope, source)) { - if (iterations > lu_ref_chain_max_length) { - CWARN("Long lu_ref chain %d \"%s\":%p\n", - iterations, scope, source); - lu_ref_chain_max_length = iterations * 3 / 2; - } - return link; - } - } - return NULL; + struct lu_ref_link *link; + unsigned int iterations; + + iterations = 0; + list_for_each_entry(link, &ref->lf_list, ll_linkage) { + ++iterations; + if (lu_ref_link_eq(link, scope, source)) { + if (iterations > lu_ref_chain_max_length) { + CWARN("Long lu_ref chain %d \"%s\":%p\n", + iterations, scope, source); + lu_ref_chain_max_length = iterations * 3 / 2; + } + return link; + } + } + return NULL; } void lu_ref_del(struct lu_ref *ref, const char *scope, const void *source) @@ -257,7 +249,7 @@ void lu_ref_del(struct lu_ref *ref, const char *scope, const void *source) spin_lock(&ref->lf_guard); link = lu_ref_find(ref, scope, source); if (link != NULL) { - cfs_list_del(&link->ll_linkage); + list_del(&link->ll_linkage); ref->lf_refs--; spin_unlock(&ref->lf_guard); OBD_SLAB_FREE(link, lu_ref_link_kmem, sizeof(*link)); @@ -273,9 +265,8 @@ void lu_ref_set_at(struct lu_ref *ref, struct lu_ref_link *link, const char *scope, const void *source0, const void *source1) { - REFASSERT(ref, link != NULL && !IS_ERR(link)); - spin_lock(&ref->lf_guard); + REFASSERT(ref, link != NULL && !IS_ERR(link)); REFASSERT(ref, link->ll_ref == ref); REFASSERT(ref, lu_ref_link_eq(link, scope, source0)); link->ll_source = source1; @@ -286,24 +277,24 @@ EXPORT_SYMBOL(lu_ref_set_at); void lu_ref_del_at(struct lu_ref *ref, struct lu_ref_link *link, const char *scope, const void *source) { - REFASSERT(ref, link != NULL && !IS_ERR(link)); spin_lock(&ref->lf_guard); + REFASSERT(ref, link != NULL && !IS_ERR(link)); REFASSERT(ref, link->ll_ref == ref); REFASSERT(ref, lu_ref_link_eq(link, scope, source)); - cfs_list_del(&link->ll_linkage); + list_del(&link->ll_linkage); ref->lf_refs--; spin_unlock(&ref->lf_guard); } EXPORT_SYMBOL(lu_ref_del_at); -#if defined(__KERNEL__) && defined(LPROCFS) +#ifdef CONFIG_PROC_FS static void *lu_ref_seq_start(struct seq_file *seq, loff_t *pos) { struct lu_ref *ref = seq->private; spin_lock(&lu_ref_refs_guard); - if (cfs_list_empty(&ref->lf_linkage)) + if (list_empty(&ref->lf_linkage)) ref = NULL; spin_unlock(&lu_ref_refs_guard); @@ -312,19 +303,19 @@ static void *lu_ref_seq_start(struct seq_file *seq, loff_t *pos) static void *lu_ref_seq_next(struct seq_file *seq, void *p, loff_t *pos) { - struct lu_ref *ref = p; - struct lu_ref *next; + struct lu_ref *ref = p; + struct lu_ref *next; - LASSERT(seq->private == p); - LASSERT(!cfs_list_empty(&ref->lf_linkage)); + LASSERT(seq->private == p); + LASSERT(!list_empty(&ref->lf_linkage)); spin_lock(&lu_ref_refs_guard); - next = cfs_list_entry(ref->lf_linkage.next, struct lu_ref, lf_linkage); + next = list_entry(ref->lf_linkage.next, struct lu_ref, lf_linkage); if (&next->lf_linkage == &lu_ref_refs) { p = NULL; } else { (*pos)++; - cfs_list_move(&ref->lf_linkage, &next->lf_linkage); + list_move(&ref->lf_linkage, &next->lf_linkage); } spin_unlock(&lu_ref_refs_guard); return p; @@ -332,7 +323,7 @@ static void *lu_ref_seq_next(struct seq_file *seq, void *p, loff_t *pos) static void lu_ref_seq_stop(struct seq_file *seq, void *p) { - /* Nothing to do */ + /* Nothing to do */ } @@ -342,7 +333,7 @@ static int lu_ref_seq_show(struct seq_file *seq, void *p) struct lu_ref *next; spin_lock(&lu_ref_refs_guard); - next = cfs_list_entry(ref->lf_linkage.next, struct lu_ref, lf_linkage); + next = list_entry(ref->lf_linkage.next, struct lu_ref, lf_linkage); if ((&next->lf_linkage == &lu_ref_refs) || lu_ref_is_marker(next)) { spin_unlock(&lu_ref_refs_guard); return 0; @@ -350,19 +341,19 @@ static int lu_ref_seq_show(struct seq_file *seq, void *p) /* print the entry */ spin_lock(&next->lf_guard); - seq_printf(seq, "lu_ref: %p %d %d %s:%d\n", - next, next->lf_refs, next->lf_failed, - next->lf_func, next->lf_line); - if (next->lf_refs > 64) { - seq_printf(seq, " too many references, skip\n"); - } else { - struct lu_ref_link *link; - int i = 0; - - cfs_list_for_each_entry(link, &next->lf_list, ll_linkage) - seq_printf(seq, " #%d link: %s %p\n", - i++, link->ll_scope, link->ll_source); - } + seq_printf(seq, "lu_ref: %p %d %d %s:%d\n", + next, next->lf_refs, next->lf_failed, + next->lf_func, next->lf_line); + if (next->lf_refs > 64) { + seq_puts(seq, " too many references, skip\n"); + } else { + struct lu_ref_link *link; + int i = 0; + + list_for_each_entry(link, &next->lf_list, ll_linkage) + seq_printf(seq, " #%d link: %s %p\n", + i++, link->ll_scope, link->ll_source); + } spin_unlock(&next->lf_guard); spin_unlock(&lu_ref_refs_guard); @@ -370,10 +361,10 @@ static int lu_ref_seq_show(struct seq_file *seq, void *p) } static struct seq_operations lu_ref_seq_ops = { - .start = lu_ref_seq_start, - .stop = lu_ref_seq_stop, - .next = lu_ref_seq_next, - .show = lu_ref_seq_show + .start = lu_ref_seq_start, + .stop = lu_ref_seq_stop, + .next = lu_ref_seq_next, + .show = lu_ref_seq_show }; static int lu_ref_seq_open(struct inode *inode, struct file *file) @@ -384,43 +375,45 @@ static int lu_ref_seq_open(struct inode *inode, struct file *file) result = seq_open(file, &lu_ref_seq_ops); if (result == 0) { spin_lock(&lu_ref_refs_guard); - if (!cfs_list_empty(&marker->lf_linkage)) + if (!list_empty(&marker->lf_linkage)) result = -EAGAIN; else - cfs_list_add(&marker->lf_linkage, &lu_ref_refs); + list_add(&marker->lf_linkage, &lu_ref_refs); spin_unlock(&lu_ref_refs_guard); - if (result == 0) { - struct seq_file *f = file->private_data; - f->private = marker; - } else { - seq_release(inode, file); - } - } + if (result == 0) { + struct seq_file *f = file->private_data; + + f->private = marker; + } else { + seq_release(inode, file); + } + } - return result; + return result; } static int lu_ref_seq_release(struct inode *inode, struct file *file) { - struct lu_ref *ref = ((struct seq_file *)file->private_data)->private; + struct seq_file *m = file->private_data; + struct lu_ref *ref = m->private; spin_lock(&lu_ref_refs_guard); - cfs_list_del_init(&ref->lf_linkage); + list_del_init(&ref->lf_linkage); spin_unlock(&lu_ref_refs_guard); return seq_release(inode, file); } static struct file_operations lu_ref_dump_fops = { - .owner = THIS_MODULE, - .open = lu_ref_seq_open, - .read = seq_read, - .llseek = seq_lseek, - .release = lu_ref_seq_release + .owner = THIS_MODULE, + .open = lu_ref_seq_open, + .read = seq_read, + .llseek = seq_lseek, + .release = lu_ref_seq_release }; -#endif +#endif /* CONFIG_PROC_FS */ int lu_ref_global_init(void) { @@ -429,27 +422,26 @@ int lu_ref_global_init(void) CDEBUG(D_CONSOLE, "lu_ref tracking is enabled. Performance isn't.\n"); - spin_lock_init(&lu_ref_refs_guard); - result = lu_kmem_init(lu_ref_caches); + result = lu_kmem_init(lu_ref_caches); -#if defined(__KERNEL__) && defined(LPROCFS) - if (result == 0) { - result = lprocfs_seq_create(proc_lustre_root, "lu_refs", - 0444, &lu_ref_dump_fops, NULL); - if (result) - lu_kmem_fini(lu_ref_caches); - } -#endif +#ifdef CONFIG_PROC_FS + if (result == 0) { + result = lprocfs_seq_create(proc_lustre_root, "lu_refs", + 0444, &lu_ref_dump_fops, NULL); + if (result) + lu_kmem_fini(lu_ref_caches); + } +#endif /* CONFIG_PROC_FS */ - return result; + return result; } void lu_ref_global_fini(void) { -#if defined(__KERNEL__) && defined(LPROCFS) - lprocfs_remove_proc_entry("lu_refs", proc_lustre_root); -#endif - lu_kmem_fini(lu_ref_caches); +#ifdef CONFIG_PROC_FS + lprocfs_remove_proc_entry("lu_refs", proc_lustre_root); +#endif /* CONFIG_PROC_FS */ + lu_kmem_fini(lu_ref_caches); } #endif /* USE_LU_REF */