X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fobdclass%2Fcl_object.c;h=60dd33c8bed141d2f2f1a64875e41f83bb5b4757;hb=35dc2e39288f15abab2d6bf7bb3f572d9670521c;hp=eefba725dd203b3a5f896a1f43f843acdaa7af39;hpb=e409c8d33474dd4dc1ae1200bfc94207b2a33093;p=fs%2Flustre-release.git diff --git a/lustre/obdclass/cl_object.c b/lustre/obdclass/cl_object.c index eefba72..60dd33c 100644 --- a/lustre/obdclass/cl_object.c +++ b/lustre/obdclass/cl_object.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) 2008, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. + * + * Copyright (c) 2011, 2012, Whamcloud, Inc. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -50,9 +50,6 @@ */ #define DEBUG_SUBSYSTEM S_CLASS -#ifndef EXPORT_SYMTAB -# define EXPORT_SYMTAB -#endif #include /* class_put_type() */ @@ -70,12 +67,14 @@ static cfs_mem_cache_t *cl_env_kmem; /** Lock class of cl_object_header::coh_page_guard */ -static cfs_lock_class_key_t cl_page_guard_class; +static struct lock_class_key cl_page_guard_class; /** Lock class of cl_object_header::coh_lock_guard */ -static cfs_lock_class_key_t cl_lock_guard_class; +static struct lock_class_key cl_lock_guard_class; /** Lock class of cl_object_header::coh_attr_guard */ -static cfs_lock_class_key_t cl_attr_guard_class; +static struct lock_class_key cl_attr_guard_class; +extern __u32 lu_context_tags_default; +extern __u32 lu_session_tags_default; /** * Initialize cl_object_header. */ @@ -86,12 +85,12 @@ int cl_object_header_init(struct cl_object_header *h) ENTRY; result = lu_object_header_init(&h->coh_lu); if (result == 0) { - cfs_spin_lock_init(&h->coh_page_guard); - cfs_spin_lock_init(&h->coh_lock_guard); - cfs_spin_lock_init(&h->coh_attr_guard); - cfs_lockdep_set_class(&h->coh_attr_guard, &cl_page_guard_class); - cfs_lockdep_set_class(&h->coh_attr_guard, &cl_lock_guard_class); - cfs_lockdep_set_class(&h->coh_attr_guard, &cl_attr_guard_class); + spin_lock_init(&h->coh_page_guard); + spin_lock_init(&h->coh_lock_guard); + spin_lock_init(&h->coh_attr_guard); + lockdep_set_class(&h->coh_page_guard, &cl_page_guard_class); + lockdep_set_class(&h->coh_lock_guard, &cl_lock_guard_class); + lockdep_set_class(&h->coh_attr_guard, &cl_attr_guard_class); h->coh_pages = 0; /* XXX hard coded GFP_* mask. */ INIT_RADIX_TREE(&h->coh_tree, GFP_ATOMIC); @@ -184,9 +183,9 @@ EXPORT_SYMBOL(cl_object_top); * * \see cl_attr, cl_object_attr_lock(), cl_object_operations::coo_attr_get(). */ -static cfs_spinlock_t *cl_object_attr_guard(struct cl_object *o) +static spinlock_t *cl_object_attr_guard(struct cl_object *o) { - return &cl_object_header(cl_object_top(o))->coh_attr_guard; + return &cl_object_header(cl_object_top(o))->coh_attr_guard; } /** @@ -198,7 +197,7 @@ static cfs_spinlock_t *cl_object_attr_guard(struct cl_object *o) */ void cl_object_attr_lock(struct cl_object *o) { - cfs_spin_lock(cl_object_attr_guard(o)); + spin_lock(cl_object_attr_guard(o)); } EXPORT_SYMBOL(cl_object_attr_lock); @@ -207,7 +206,7 @@ EXPORT_SYMBOL(cl_object_attr_lock); */ void cl_object_attr_unlock(struct cl_object *o) { - cfs_spin_unlock(cl_object_attr_guard(o)); + spin_unlock(cl_object_attr_guard(o)); } EXPORT_SYMBOL(cl_object_attr_unlock); @@ -348,7 +347,7 @@ void cl_object_kill(const struct lu_env *env, struct cl_object *obj) LASSERT(hdr->coh_tree.rnode == NULL); LASSERT(hdr->coh_pages == 0); - cfs_set_bit(LU_OBJECT_HEARD_BANSHEE, &hdr->coh_lu.loh_flags); + set_bit(LU_OBJECT_HEARD_BANSHEE, &hdr->coh_lu.loh_flags); /* * Destroy all locks. Object destruction (including cl_inode_fini()) * cannot cancel the locks, because in the case of a local client, @@ -377,47 +376,50 @@ EXPORT_SYMBOL(cl_object_prune); */ int cl_object_has_locks(struct cl_object *obj) { - struct cl_object_header *head = cl_object_header(obj); - int has; + struct cl_object_header *head = cl_object_header(obj); + int has; - cfs_spin_lock(&head->coh_lock_guard); - has = cfs_list_empty(&head->coh_locks); - cfs_spin_unlock(&head->coh_lock_guard); + spin_lock(&head->coh_lock_guard); + has = cfs_list_empty(&head->coh_locks); + spin_unlock(&head->coh_lock_guard); - return (has == 0); + return (has == 0); } EXPORT_SYMBOL(cl_object_has_locks); void cache_stats_init(struct cache_stats *cs, const char *name) { + int i; + cs->cs_name = name; - cfs_atomic_set(&cs->cs_lookup, 0); - cfs_atomic_set(&cs->cs_hit, 0); - cfs_atomic_set(&cs->cs_total, 0); - cfs_atomic_set(&cs->cs_busy, 0); + for (i = 0; i < CS_NR; i++) + cfs_atomic_set(&cs->cs_stats[i], 0); } int cache_stats_print(const struct cache_stats *cs, char *page, int count, int h) { - int nob = 0; -/* - lookup hit total cached create - env: ...... ...... ...... ...... ...... -*/ - if (h) - nob += snprintf(page, count, - " lookup hit total busy create\n"); - - nob += snprintf(page + nob, count - nob, - "%5.5s: %6u %6u %6u %6u %6u", - cs->cs_name, - cfs_atomic_read(&cs->cs_lookup), - cfs_atomic_read(&cs->cs_hit), - cfs_atomic_read(&cs->cs_total), - cfs_atomic_read(&cs->cs_busy), - cfs_atomic_read(&cs->cs_created)); - return nob; + int nob = 0; + int i; + /* + * lookup hit total cached create + * env: ...... ...... ...... ...... ...... + */ + if (h) { + const char *names[CS_NR] = CS_NAMES; + + nob += snprintf(page + nob, count - nob, "%6s", " "); + for (i = 0; i < CS_NR; i++) + nob += snprintf(page + nob, count - nob, + "%8s", names[i]); + nob += snprintf(page + nob, count - nob, "\n"); + } + + nob += snprintf(page + nob, count - nob, "%5.5s:", cs->cs_name); + for (i = 0; i < CS_NR; i++) + nob += snprintf(page + nob, count - nob, "%8u", + cfs_atomic_read(&cs->cs_stats[i])); + return nob; } /** @@ -455,11 +457,7 @@ EXPORT_SYMBOL(cl_site_fini); static struct cache_stats cl_env_stats = { .cs_name = "envs", - .cs_created = CFS_ATOMIC_INIT(0), - .cs_lookup = CFS_ATOMIC_INIT(0), - .cs_hit = CFS_ATOMIC_INIT(0), - .cs_total = CFS_ATOMIC_INIT(0), - .cs_busy = CFS_ATOMIC_INIT(0) + .cs_stats = { CFS_ATOMIC_INIT(0), } }; /** @@ -541,7 +539,7 @@ static CFS_LIST_HEAD(cl_envs); static unsigned cl_envs_cached_nr = 0; static unsigned cl_envs_cached_max = 128; /* XXX: prototype: arbitrary limit * for now. */ -static cfs_spinlock_t cl_envs_guard = CFS_SPIN_LOCK_UNLOCKED; +static DEFINE_SPINLOCK(cl_envs_guard); struct cl_env { void *ce_magic; @@ -586,13 +584,17 @@ struct cl_env { void *ce_debug; }; -#define CL_ENV_INC(counter) cfs_atomic_inc(&cl_env_stats.counter) +#ifdef CONFIG_DEBUG_PAGESTATE_TRACKING +#define CL_ENV_INC(counter) cfs_atomic_inc(&cl_env_stats.cs_stats[CS_##counter]) -#define CL_ENV_DEC(counter) \ - do { \ - LASSERT(cfs_atomic_read(&cl_env_stats.counter) > 0); \ - cfs_atomic_dec(&cl_env_stats.counter); \ - } while (0) +#define CL_ENV_DEC(counter) do { \ + LASSERT(cfs_atomic_read(&cl_env_stats.cs_stats[CS_##counter]) > 0); \ + cfs_atomic_dec(&cl_env_stats.cs_stats[CS_##counter]); \ +} while (0) +#else +#define CL_ENV_INC(counter) +#define CL_ENV_DEC(counter) +#endif static void cl_env_init0(struct cl_env *cle, void *debug) { @@ -602,7 +604,7 @@ static void cl_env_init0(struct cl_env *cle, void *debug) cle->ce_ref = 1; cle->ce_debug = debug; - CL_ENV_INC(cs_busy); + CL_ENV_INC(busy); } @@ -613,7 +615,8 @@ static void cl_env_init0(struct cl_env *cle, void *debug) static cfs_hash_t *cl_env_hash; -static unsigned cl_env_hops_hash(cfs_hash_t *lh, void *key, unsigned mask) +static unsigned cl_env_hops_hash(cfs_hash_t *lh, + const void *key, unsigned mask) { #if BITS_PER_LONG == 64 return cfs_hash_u64_hash((__u64)key, mask); @@ -629,7 +632,7 @@ static void *cl_env_hops_obj(cfs_hlist_node_t *hn) return (void *)cle; } -static int cl_env_hops_compare(void *key, cfs_hlist_node_t *hn) +static int cl_env_hops_keycmp(const void *key, cfs_hlist_node_t *hn) { struct cl_env *cle = cl_env_hops_obj(hn); @@ -637,12 +640,19 @@ static int cl_env_hops_compare(void *key, cfs_hlist_node_t *hn) return (key == cle->ce_owner); } +static void cl_env_hops_noop(cfs_hash_t *hs, cfs_hlist_node_t *hn) +{ + struct cl_env *cle = cfs_hlist_entry(hn, struct cl_env, ce_node); + LASSERT(cle->ce_magic == &cl_env_init0); +} + static cfs_hash_ops_t cl_env_hops = { - .hs_hash = cl_env_hops_hash, - .hs_compare = cl_env_hops_compare, - .hs_key = cl_env_hops_obj, - .hs_get = cl_env_hops_obj, - .hs_put = cl_env_hops_obj, + .hs_hash = cl_env_hops_hash, + .hs_key = cl_env_hops_obj, + .hs_keycmp = cl_env_hops_keycmp, + .hs_object = cl_env_hops_obj, + .hs_get = cl_env_hops_noop, + .hs_put_locked = cl_env_hops_noop, }; static inline struct cl_env *cl_env_fetch(void) @@ -679,8 +689,13 @@ static inline void cl_env_do_detach(struct cl_env *cle) } static int cl_env_store_init(void) { - cl_env_hash = cfs_hash_create("cl_env", 8, 10, &cl_env_hops, - CFS_HASH_REHASH); + cl_env_hash = cfs_hash_create("cl_env", + HASH_CL_ENV_BITS, HASH_CL_ENV_BITS, + HASH_CL_ENV_BKT_BITS, 0, + CFS_HASH_MIN_THETA, + CFS_HASH_MAX_THETA, + &cl_env_hops, + CFS_HASH_RW_BKTLOCK); return cl_env_hash != NULL ? 0 :-ENOMEM; } @@ -737,7 +752,7 @@ static inline struct cl_env *cl_env_detach(struct cl_env *cle) return cle; } -static struct lu_env *cl_env_new(__u32 tags, void *debug) +static struct lu_env *cl_env_new(__u32 ctx_tags, __u32 ses_tags, void *debug) { struct lu_env *env; struct cl_env *cle; @@ -749,9 +764,10 @@ static struct lu_env *cl_env_new(__u32 tags, void *debug) CFS_INIT_LIST_HEAD(&cle->ce_linkage); cle->ce_magic = &cl_env_init0; env = &cle->ce_lu; - rc = lu_env_init(env, LCT_CL_THREAD|tags); + rc = lu_env_init(env, LCT_CL_THREAD|ctx_tags); if (rc == 0) { - rc = lu_context_init(&cle->ce_ses, LCT_SESSION|tags); + rc = lu_context_init(&cle->ce_ses, + LCT_SESSION | ses_tags); if (rc == 0) { lu_context_enter(&cle->ce_ses); env->le_ses = &cle->ce_ses; @@ -763,8 +779,8 @@ static struct lu_env *cl_env_new(__u32 tags, void *debug) OBD_SLAB_FREE_PTR(cle, cl_env_kmem); env = ERR_PTR(rc); } else { - CL_ENV_INC(cs_created); - CL_ENV_INC(cs_total); + CL_ENV_INC(create); + CL_ENV_INC(total); } } else env = ERR_PTR(-ENOMEM); @@ -773,7 +789,7 @@ static struct lu_env *cl_env_new(__u32 tags, void *debug) static void cl_env_fini(struct cl_env *cle) { - CL_ENV_DEC(cs_total); + CL_ENV_DEC(total); lu_context_fini(&cle->ce_lu.le_ctx); lu_context_fini(&cle->ce_ses); OBD_SLAB_FREE_PTR(cle, cl_env_kmem); @@ -781,19 +797,19 @@ static void cl_env_fini(struct cl_env *cle) static struct lu_env *cl_env_obtain(void *debug) { - struct cl_env *cle; - struct lu_env *env; + struct cl_env *cle; + struct lu_env *env; - ENTRY; - cfs_spin_lock(&cl_envs_guard); - LASSERT(equi(cl_envs_cached_nr == 0, cfs_list_empty(&cl_envs))); - if (cl_envs_cached_nr > 0) { - int rc; + ENTRY; + spin_lock(&cl_envs_guard); + LASSERT(equi(cl_envs_cached_nr == 0, cfs_list_empty(&cl_envs))); + if (cl_envs_cached_nr > 0) { + int rc; - cle = container_of(cl_envs.next, struct cl_env, ce_linkage); - cfs_list_del_init(&cle->ce_linkage); - cl_envs_cached_nr--; - cfs_spin_unlock(&cl_envs_guard); + cle = container_of(cl_envs.next, struct cl_env, ce_linkage); + cfs_list_del_init(&cle->ce_linkage); + cl_envs_cached_nr--; + spin_unlock(&cl_envs_guard); env = &cle->ce_lu; rc = lu_env_refill(env); @@ -806,10 +822,11 @@ static struct lu_env *cl_env_obtain(void *debug) env = ERR_PTR(rc); } } else { - cfs_spin_unlock(&cl_envs_guard); - env = cl_env_new(0, debug); - } - RETURN(env); + spin_unlock(&cl_envs_guard); + env = cl_env_new(lu_context_tags_default, + lu_session_tags_default, debug); + } + RETURN(env); } static inline struct cl_env *cl_env_container(struct lu_env *env) @@ -822,7 +839,7 @@ struct lu_env *cl_env_peek(int *refcheck) struct lu_env *env; struct cl_env *cle; - CL_ENV_INC(cs_lookup); + CL_ENV_INC(lookup); /* check that we don't go far from untrusted pointer */ CLASSERT(offsetof(struct cl_env, ce_magic) == 0); @@ -830,7 +847,7 @@ struct lu_env *cl_env_peek(int *refcheck) env = NULL; cle = cl_env_fetch(); if (cle != NULL) { - CL_ENV_INC(cs_hit); + CL_ENV_INC(hit); env = &cle->ce_lu; *refcheck = ++cle->ce_ref; } @@ -882,7 +899,7 @@ struct lu_env *cl_env_alloc(int *refcheck, __u32 tags) struct lu_env *env; LASSERT(cl_env_peek(refcheck) == NULL); - env = cl_env_new(tags, __builtin_return_address(0)); + env = cl_env_new(tags, tags, __builtin_return_address(0)); if (!IS_ERR(env)) { struct cl_env *cle; @@ -908,23 +925,23 @@ static void cl_env_exit(struct cl_env *cle) */ unsigned cl_env_cache_purge(unsigned nr) { - struct cl_env *cle; - - ENTRY; - cfs_spin_lock(&cl_envs_guard); - for (; !cfs_list_empty(&cl_envs) && nr > 0; --nr) { - cle = container_of(cl_envs.next, struct cl_env, ce_linkage); - cfs_list_del_init(&cle->ce_linkage); - LASSERT(cl_envs_cached_nr > 0); - cl_envs_cached_nr--; - cfs_spin_unlock(&cl_envs_guard); - - cl_env_fini(cle); - cfs_spin_lock(&cl_envs_guard); - } - LASSERT(equi(cl_envs_cached_nr == 0, cfs_list_empty(&cl_envs))); - cfs_spin_unlock(&cl_envs_guard); - RETURN(nr); + struct cl_env *cle; + + ENTRY; + spin_lock(&cl_envs_guard); + for (; !cfs_list_empty(&cl_envs) && nr > 0; --nr) { + cle = container_of(cl_envs.next, struct cl_env, ce_linkage); + cfs_list_del_init(&cle->ce_linkage); + LASSERT(cl_envs_cached_nr > 0); + cl_envs_cached_nr--; + spin_unlock(&cl_envs_guard); + + cl_env_fini(cle); + spin_lock(&cl_envs_guard); + } + LASSERT(equi(cl_envs_cached_nr == 0, cfs_list_empty(&cl_envs))); + spin_unlock(&cl_envs_guard); + RETURN(nr); } EXPORT_SYMBOL(cl_env_cache_purge); @@ -946,7 +963,7 @@ void cl_env_put(struct lu_env *env, int *refcheck) CDEBUG(D_OTHER, "%d@%p\n", cle->ce_ref, cle); if (--cle->ce_ref == 0) { - CL_ENV_DEC(cs_busy); + CL_ENV_DEC(busy); cl_env_detach(cle); cle->ce_debug = NULL; cl_env_exit(cle); @@ -959,13 +976,13 @@ void cl_env_put(struct lu_env *env, int *refcheck) if (cl_envs_cached_nr < cl_envs_cached_max && (env->le_ctx.lc_tags & ~LCT_HAS_EXIT) == LCT_CL_THREAD && (env->le_ses->lc_tags & ~LCT_HAS_EXIT) == LCT_SESSION) { - cfs_spin_lock(&cl_envs_guard); - cfs_list_add(&cle->ce_linkage, &cl_envs); - cl_envs_cached_nr++; - cfs_spin_unlock(&cl_envs_guard); - } else - cl_env_fini(cle); - } + spin_lock(&cl_envs_guard); + cfs_list_add(&cle->ce_linkage, &cl_envs); + cl_envs_cached_nr++; + spin_unlock(&cl_envs_guard); + } else + cl_env_fini(cle); + } } EXPORT_SYMBOL(cl_env_put); @@ -1230,17 +1247,31 @@ int cl_global_init(void) return result; result = lu_kmem_init(cl_object_caches); - if (result == 0) { - LU_CONTEXT_KEY_INIT(&cl_key); - result = lu_context_key_register(&cl_key); - if (result == 0) { - result = cl_lock_init(); - if (result == 0) - result = cl_page_init(); - } - } if (result) - cl_env_store_fini(); + goto out_store; + + LU_CONTEXT_KEY_INIT(&cl_key); + result = lu_context_key_register(&cl_key); + if (result) + goto out_kmem; + + result = cl_lock_init(); + if (result) + goto out_context; + + result = cl_page_init(); + if (result) + goto out_lock; + + return 0; +out_lock: + cl_lock_fini(); +out_context: + lu_context_key_degister(&cl_key); +out_kmem: + lu_kmem_fini(cl_object_caches); +out_store: + cl_env_store_fini(); return result; }