From 6af1b241b018b363ea937461fa8712acaac177a4 Mon Sep 17 00:00:00 2001 From: pschwan Date: Mon, 16 Sep 2002 18:13:03 +0000 Subject: [PATCH] - add resource and lock counters to the namespace - add them to the namespace proc directories (which are, tragically, in the top level of the /proc tree until lprocfs gets sorted out) - fix a dangling resource refcount bug in ldlm_cli_cancel_unused --- lustre/include/linux/lustre_dlm.h | 4 ++++ lustre/ldlm/ldlm_lock.c | 14 +++++++++++--- lustre/ldlm/ldlm_lockd.c | 1 + lustre/ldlm/ldlm_request.c | 2 ++ lustre/ldlm/ldlm_resource.c | 36 +++++++++++++++++++++++++++++++++++- 5 files changed, 53 insertions(+), 4 deletions(-) diff --git a/lustre/include/linux/lustre_dlm.h b/lustre/include/linux/lustre_dlm.h index 86f339d..7404dda 100644 --- a/lustre/include/linux/lustre_dlm.h +++ b/lustre/include/linux/lustre_dlm.h @@ -92,6 +92,10 @@ struct ldlm_namespace { struct lustre_lock ns_lock; /* protects hash, refcount, list */ struct list_head ns_list_chain; /* position in global NS list */ struct proc_dir_entry *ns_proc_dir; + + spinlock_t ns_counter_lock; + __u64 ns_locks; + __u64 ns_resources; }; /* diff --git a/lustre/ldlm/ldlm_lock.c b/lustre/ldlm/ldlm_lock.c index c1a05d1..02cf2a2 100644 --- a/lustre/ldlm/ldlm_lock.c +++ b/lustre/ldlm/ldlm_lock.c @@ -136,10 +136,10 @@ struct ldlm_lock *ldlm_lock_get(struct ldlm_lock *lock) void ldlm_lock_put(struct ldlm_lock *lock) { - struct lustre_lock *nslock = &lock->l_resource->lr_namespace->ns_lock; + struct ldlm_namespace *ns = lock->l_resource->lr_namespace; ENTRY; - l_lock(nslock); + l_lock(&ns->ns_lock); lock->l_refc--; //LDLM_DEBUG(lock, "after refc--"); if (lock->l_refc < 0) @@ -150,6 +150,10 @@ void ldlm_lock_put(struct ldlm_lock *lock) LDLM_LOCK_PUT(lock->l_parent); if (lock->l_refc == 0 && (lock->l_flags & LDLM_FL_DESTROYED)) { + spin_lock(&ns->ns_counter_lock); + ns->ns_locks--; + spin_unlock(&ns->ns_counter_lock); + lock->l_resource = NULL; LDLM_DEBUG(lock, "final lock_put on destroyed lock, freeing"); if (lock->l_export && lock->l_export->exp_connection) @@ -158,7 +162,7 @@ void ldlm_lock_put(struct ldlm_lock *lock) CDEBUG(D_MALLOC, "kfreed 'lock': %d at %p (tot 0).\n", sizeof(*lock), lock); } - l_unlock(nslock); + l_unlock(&ns->ns_lock); EXIT; } @@ -233,6 +237,10 @@ static struct ldlm_lock *ldlm_lock_new(struct ldlm_lock *parent, INIT_LIST_HEAD(&lock->l_pending_chain); init_waitqueue_head(&lock->l_waitq); + spin_lock(&resource->lr_namespace->ns_counter_lock); + resource->lr_namespace->ns_locks++; + spin_unlock(&resource->lr_namespace->ns_counter_lock); + if (parent != NULL) { l_lock(&parent->l_resource->lr_namespace->ns_lock); lock->l_parent = parent; diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c index de84253..d7cb958 100644 --- a/lustre/ldlm/ldlm_lockd.c +++ b/lustre/ldlm/ldlm_lockd.c @@ -673,6 +673,7 @@ EXPORT_SYMBOL(ldlm_lock_change_resource); EXPORT_SYMBOL(ldlm_cli_convert); EXPORT_SYMBOL(ldlm_cli_enqueue); EXPORT_SYMBOL(ldlm_cli_cancel); +EXPORT_SYMBOL(ldlm_cli_cancel_unused); EXPORT_SYMBOL(ldlm_match_or_enqueue); EXPORT_SYMBOL(ldlm_it2str); EXPORT_SYMBOL(ldlm_test); diff --git a/lustre/ldlm/ldlm_request.c b/lustre/ldlm/ldlm_request.c index 400da08..e273834 100644 --- a/lustre/ldlm/ldlm_request.c +++ b/lustre/ldlm/ldlm_request.c @@ -450,5 +450,7 @@ int ldlm_cli_cancel_unused(struct ldlm_namespace *ns, __u64 *res_id) OBD_FREE(w, sizeof(*w)); } + ldlm_resource_put(res); + RETURN(0); } diff --git a/lustre/ldlm/ldlm_resource.c b/lustre/ldlm/ldlm_resource.c index ac53d84..3bf0c84 100644 --- a/lustre/ldlm/ldlm_resource.c +++ b/lustre/ldlm/ldlm_resource.c @@ -40,10 +40,23 @@ void ldlm_proc_cleanup(struct obd_device *obd) proc_lustre_remove_obd_entry("namespaces", obd); } +/* FIXME: This can go away when we start to really use lprocfs */ +static int lprocfs_ll_rd(char *page, char **start, off_t off, + int count, int *eof, void *data) +{ + int len; + __u64 *temp = (__u64 *)data; + + len = snprintf(page, count, "%Lu\n", *temp); + + return len; +} + struct ldlm_namespace *ldlm_namespace_new(char *name, __u32 client) { struct ldlm_namespace *ns = NULL; struct list_head *bucket; + struct proc_dir_entry *proc_entry; OBD_ALLOC(ns, sizeof(*ns)); if (!ns) { @@ -69,6 +82,9 @@ struct ldlm_namespace *ldlm_namespace_new(char *name, __u32 client) l_lock_init(&ns->ns_lock); ns->ns_refcount = 0; ns->ns_client = client; + spin_lock_init(&ns->ns_counter_lock); + ns->ns_locks = 0; + ns->ns_resources = 0; for (bucket = ns->ns_hash + RES_HASH_SIZE - 1; bucket >= ns->ns_hash; bucket--) @@ -76,10 +92,17 @@ struct ldlm_namespace *ldlm_namespace_new(char *name, __u32 client) spin_lock(&ldlm_namespace_lock); list_add(&ns->ns_list_chain, &ldlm_namespace_list); + spin_unlock(&ldlm_namespace_lock); + ns->ns_proc_dir = proc_mkdir(ns->ns_name, ldlm_ns_proc_dir); if (ns->ns_proc_dir == NULL) CERROR("Unable to create proc directory for namespace.\n"); - spin_unlock(&ldlm_namespace_lock); + proc_entry = create_proc_entry("resource_count", 0444, ns->ns_proc_dir); + proc_entry->read_proc = lprocfs_ll_rd; + proc_entry->data = &ns->ns_resources; + proc_entry = create_proc_entry("lock_count", 0444, ns->ns_proc_dir); + proc_entry->read_proc = lprocfs_ll_rd; + proc_entry->data = &ns->ns_locks; RETURN(ns); @@ -140,6 +163,8 @@ int ldlm_namespace_free(struct ldlm_namespace *ns) spin_lock(&ldlm_namespace_lock); list_del(&ns->ns_list_chain); + remove_proc_entry("resource_count", ns->ns_proc_dir); + remove_proc_entry("lock_count", ns->ns_proc_dir); remove_proc_entry(ns->ns_name, ldlm_ns_proc_dir); spin_unlock(&ldlm_namespace_lock); @@ -237,6 +262,10 @@ static struct ldlm_resource *ldlm_resource_add(struct ldlm_namespace *ns, RETURN(NULL); } + spin_lock(&ns->ns_counter_lock); + ns->ns_resources++; + spin_unlock(&ns->ns_counter_lock); + memcpy(res->lr_name, name, sizeof(res->lr_name)); res->lr_namespace = ns; ns->ns_refcount++; @@ -337,6 +366,11 @@ int ldlm_resource_put(struct ldlm_resource *res) kmem_cache_free(ldlm_resource_slab, res); l_unlock(&ns->ns_lock); + + spin_lock(&ns->ns_counter_lock); + ns->ns_resources--; + spin_unlock(&ns->ns_counter_lock); + rc = 1; } else { ENTRY; -- 1.8.3.1