X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fldlm%2Fldlm_resource.c;h=baf935ee4c17ef8f3b29150cd6cf7a4521bce898;hb=3cce65712d94cffe8f1626545845b95b88aef672;hp=ccb832b24e327955ea12a828713a60b948e8a9b5;hpb=e920be6814512b1aa8696ea36d697d3b698c13e8;p=fs%2Flustre-release.git diff --git a/lustre/ldlm/ldlm_resource.c b/lustre/ldlm/ldlm_resource.c index ccb832b..baf935e 100644 --- a/lustre/ldlm/ldlm_resource.c +++ b/lustre/ldlm/ldlm_resource.c @@ -23,7 +23,7 @@ * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2010, 2016, Intel Corporation. + * Copyright (c) 2010, 2017, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -43,6 +43,7 @@ struct kmem_cache *ldlm_resource_slab, *ldlm_lock_slab; struct kmem_cache *ldlm_interval_tree_slab; +struct kmem_cache *ldlm_inodebits_slab; int ldlm_srv_namespace_nr = 0; int ldlm_cli_namespace_nr = 0; @@ -58,26 +59,45 @@ LIST_HEAD(ldlm_cli_active_namespace_list); /* Client namespaces that don't have any locks in them */ LIST_HEAD(ldlm_cli_inactive_namespace_list); -static struct proc_dir_entry *ldlm_type_proc_dir; -static struct proc_dir_entry *ldlm_ns_proc_dir; -struct proc_dir_entry *ldlm_svc_proc_dir; +static struct dentry *ldlm_debugfs_dir; +static struct dentry *ldlm_ns_debugfs_dir; +struct dentry *ldlm_svc_debugfs_dir; /* during debug dump certain amount of granted locks for one resource to avoid * DDOS. */ static unsigned int ldlm_dump_granted_max = 256; -#ifdef CONFIG_PROC_FS -static ssize_t -lprocfs_dump_ns_seq_write(struct file *file, const char __user *buffer, - size_t count, loff_t *off) +static ssize_t ldebugfs_dump_ns_seq_write(struct file *file, + const char __user *buffer, + size_t count, loff_t *off) { ldlm_dump_all_namespaces(LDLM_NAMESPACE_SERVER, D_DLMTRACE); ldlm_dump_all_namespaces(LDLM_NAMESPACE_CLIENT, D_DLMTRACE); RETURN(count); } -LPROC_SEQ_FOPS_WR_ONLY(ldlm, dump_ns); -LPROC_SEQ_FOPS_RW_TYPE(ldlm_rw, uint); +LDEBUGFS_FOPS_WR_ONLY(ldlm, dump_ns); + +static int ldlm_rw_uint_seq_show(struct seq_file *m, void *v) +{ + seq_printf(m, "%u\n", *(unsigned int *)m->private); + return 0; +} + +static ssize_t +ldlm_rw_uint_seq_write(struct file *file, const char __user *buffer, + size_t count, loff_t *off) +{ + struct seq_file *seq = file->private_data; + + if (!count) + return 0; + + return kstrtouint_from_user(buffer, count, 0, + (unsigned int *)seq->private); +} + +LDEBUGFS_SEQ_FOPS(ldlm_rw_uint); #ifdef HAVE_SERVER_SUPPORT @@ -144,7 +164,7 @@ static ssize_t seq_watermark_write(struct file *file, static int seq_watermark_open(struct inode *inode, struct file *file) { - return single_open(file, seq_watermark_show, PDE_DATA(inode)); + return single_open(file, seq_watermark_show, inode->i_private); } static const struct file_operations ldlm_watermark_fops = { @@ -165,7 +185,7 @@ static int seq_granted_show(struct seq_file *m, void *data) static int seq_granted_open(struct inode *inode, struct file *file) { - return single_open(file, seq_granted_show, PDE_DATA(inode)); + return single_open(file, seq_granted_show, inode->i_private); } static const struct file_operations ldlm_granted_fops = { @@ -178,59 +198,62 @@ static const struct file_operations ldlm_granted_fops = { #endif /* HAVE_SERVER_SUPPORT */ -int ldlm_proc_setup(void) -{ - int rc; - struct lprocfs_vars list[] = { - { .name = "dump_namespaces", - .fops = &ldlm_dump_ns_fops, - .proc_mode = 0222 }, - { .name = "dump_granted_max", - .fops = &ldlm_rw_uint_fops, - .data = &ldlm_dump_granted_max }, +static struct lprocfs_vars ldlm_debugfs_list[] = { + { .name = "dump_namespaces", + .fops = &ldlm_dump_ns_fops, + .proc_mode = 0222 }, + { .name = "dump_granted_max", + .fops = &ldlm_rw_uint_fops, + .data = &ldlm_dump_granted_max }, #ifdef HAVE_SERVER_SUPPORT - { .name = "lock_reclaim_threshold_mb", - .fops = &ldlm_watermark_fops, - .data = &ldlm_reclaim_threshold_mb }, - { .name = "lock_limit_mb", - .fops = &ldlm_watermark_fops, - .data = &ldlm_lock_limit_mb }, - { .name = "lock_granted_count", - .fops = &ldlm_granted_fops, - .data = &ldlm_granted_total }, + { .name = "lock_reclaim_threshold_mb", + .fops = &ldlm_watermark_fops, + .data = &ldlm_reclaim_threshold_mb }, + { .name = "lock_limit_mb", + .fops = &ldlm_watermark_fops, + .data = &ldlm_lock_limit_mb }, + { .name = "lock_granted_count", + .fops = &ldlm_granted_fops, + .data = &ldlm_granted_total }, #endif - { NULL }}; - ENTRY; - LASSERT(ldlm_ns_proc_dir == NULL); + { NULL } +}; - ldlm_type_proc_dir = lprocfs_register(OBD_LDLM_DEVICENAME, - proc_lustre_root, - NULL, NULL); - if (IS_ERR(ldlm_type_proc_dir)) { - CERROR("LProcFS failed in ldlm-init\n"); - rc = PTR_ERR(ldlm_type_proc_dir); +int ldlm_debugfs_setup(void) +{ + int rc; + + ENTRY; + ldlm_debugfs_dir = ldebugfs_register(OBD_LDLM_DEVICENAME, + debugfs_lustre_root, + NULL, NULL); + if (IS_ERR_OR_NULL(ldlm_debugfs_dir)) { + CERROR("LDebugFS failed in ldlm-init\n"); + rc = ldlm_debugfs_dir ? PTR_ERR(ldlm_debugfs_dir) : -ENOMEM; GOTO(err, rc); } - ldlm_ns_proc_dir = lprocfs_register("namespaces", - ldlm_type_proc_dir, - NULL, NULL); - if (IS_ERR(ldlm_ns_proc_dir)) { + ldlm_ns_debugfs_dir = ldebugfs_register("namespaces", + ldlm_debugfs_dir, + NULL, NULL); + if (IS_ERR_OR_NULL(ldlm_ns_debugfs_dir)) { CERROR("LProcFS failed in ldlm-init\n"); - rc = PTR_ERR(ldlm_ns_proc_dir); + rc = ldlm_ns_debugfs_dir ? PTR_ERR(ldlm_ns_debugfs_dir) + : -ENOMEM; GOTO(err_type, rc); } - ldlm_svc_proc_dir = lprocfs_register("services", - ldlm_type_proc_dir, - NULL, NULL); - if (IS_ERR(ldlm_svc_proc_dir)) { + ldlm_svc_debugfs_dir = ldebugfs_register("services", + ldlm_debugfs_dir, + NULL, NULL); + if (IS_ERR_OR_NULL(ldlm_svc_debugfs_dir)) { CERROR("LProcFS failed in ldlm-init\n"); - rc = PTR_ERR(ldlm_svc_proc_dir); + rc = ldlm_svc_debugfs_dir ? PTR_ERR(ldlm_svc_debugfs_dir) + : -ENOMEM; GOTO(err_ns, rc); } - rc = lprocfs_add_vars(ldlm_type_proc_dir, list, NULL); + rc = ldebugfs_add_vars(ldlm_debugfs_dir, ldlm_debugfs_list, NULL); if (rc != 0) { CERROR("LProcFS failed in ldlm-init\n"); GOTO(err_svc, rc); @@ -239,26 +262,32 @@ int ldlm_proc_setup(void) RETURN(0); err_svc: - lprocfs_remove(&ldlm_svc_proc_dir); + ldebugfs_remove(&ldlm_svc_debugfs_dir); err_ns: - lprocfs_remove(&ldlm_ns_proc_dir); + ldebugfs_remove(&ldlm_ns_debugfs_dir); err_type: - lprocfs_remove(&ldlm_type_proc_dir); + ldebugfs_remove(&ldlm_debugfs_dir); err: - ldlm_svc_proc_dir = NULL; - RETURN(rc); + ldlm_svc_debugfs_dir = NULL; + ldlm_ns_debugfs_dir = NULL; + ldlm_debugfs_dir = NULL; + RETURN(rc); } -void ldlm_proc_cleanup(void) +void ldlm_debugfs_cleanup(void) { - if (ldlm_svc_proc_dir) - lprocfs_remove(&ldlm_svc_proc_dir); + if (!IS_ERR_OR_NULL(ldlm_svc_debugfs_dir)) + ldebugfs_remove(&ldlm_svc_debugfs_dir); - if (ldlm_ns_proc_dir) - lprocfs_remove(&ldlm_ns_proc_dir); + if (!IS_ERR_OR_NULL(ldlm_ns_debugfs_dir)) + ldebugfs_remove(&ldlm_ns_debugfs_dir); - if (ldlm_type_proc_dir) - lprocfs_remove(&ldlm_type_proc_dir); + if (!IS_ERR_OR_NULL(ldlm_debugfs_dir)) + ldebugfs_remove(&ldlm_debugfs_dir); + + ldlm_svc_debugfs_dir = NULL; + ldlm_ns_debugfs_dir = NULL; + ldlm_debugfs_dir = NULL; } static ssize_t resource_count_show(struct kobject *kobj, struct attribute *attr, @@ -323,10 +352,10 @@ static ssize_t lru_size_store(struct kobject *kobj, struct attribute *attr, int err; if (strncmp(buffer, "clear", 5) == 0) { - CDEBUG(D_DLMTRACE, - "dropping all unused locks from namespace %s\n", - ldlm_ns_name(ns)); - if (ns_connect_lru_resize(ns)) { + CDEBUG(D_DLMTRACE, + "dropping all unused locks from namespace %s\n", + ldlm_ns_name(ns)); + if (ns_connect_lru_resize(ns)) { /* Try to cancel all @ns_nr_unused locks. */ ldlm_cancel_lru(ns, ns->ns_nr_unused, 0, LDLM_LRU_FLAG_PASSED | @@ -344,8 +373,8 @@ static ssize_t lru_size_store(struct kobject *kobj, struct attribute *attr, err = kstrtoul(buffer, 10, &tmp); if (err != 0) { CERROR("lru_size: invalid value written\n"); - return -EINVAL; - } + return -EINVAL; + } lru_resize = (tmp == 0); if (ns_connect_lru_resize(ns)) { @@ -368,7 +397,7 @@ static ssize_t lru_size_store(struct kobject *kobj, struct attribute *attr, ldlm_ns_name(ns)); ns->ns_connect_flags &= ~OBD_CONNECT_LRU_RESIZE; } - } else { + } else { CDEBUG(D_DLMTRACE, "changing namespace %s max_unused from %u to %u\n", ldlm_ns_name(ns), ns->ns_max_unused, @@ -379,16 +408,16 @@ static ssize_t lru_size_store(struct kobject *kobj, struct attribute *attr, /* Make sure that LRU resize was originally supported before * turning it on here. */ - if (lru_resize && - (ns->ns_orig_connect_flags & OBD_CONNECT_LRU_RESIZE)) { - CDEBUG(D_DLMTRACE, - "enable lru_resize for namespace %s\n", - ldlm_ns_name(ns)); - ns->ns_connect_flags |= OBD_CONNECT_LRU_RESIZE; - } - } + if (lru_resize && + (ns->ns_orig_connect_flags & OBD_CONNECT_LRU_RESIZE)) { + CDEBUG(D_DLMTRACE, + "enable lru_resize for namespace %s\n", + ldlm_ns_name(ns)); + ns->ns_connect_flags |= OBD_CONNECT_LRU_RESIZE; + } + } - return count; + return count; } LUSTRE_RW_ATTR(lru_size); @@ -462,6 +491,32 @@ static ssize_t early_lock_cancel_store(struct kobject *kobj, } LUSTRE_RW_ATTR(early_lock_cancel); +static ssize_t dirty_age_limit_show(struct kobject *kobj, + struct attribute *attr, char *buf) +{ + struct ldlm_namespace *ns = container_of(kobj, struct ldlm_namespace, + ns_kobj); + + return sprintf(buf, "%llu\n", ns->ns_dirty_age_limit); +} + +static ssize_t dirty_age_limit_store(struct kobject *kobj, + struct attribute *attr, + const char *buffer, size_t count) +{ + struct ldlm_namespace *ns = container_of(kobj, struct ldlm_namespace, + ns_kobj); + unsigned long long tmp; + + if (kstrtoull(buffer, 10, &tmp)) + return -EINVAL; + + ns->ns_dirty_age_limit = tmp; + + return count; +} +LUSTRE_RW_ATTR(dirty_age_limit); + #ifdef HAVE_SERVER_SUPPORT static ssize_t ctime_age_limit_show(struct kobject *kobj, struct attribute *attr, char *buf) @@ -619,6 +674,7 @@ static struct attribute *ldlm_ns_attrs[] = { &lustre_attr_lru_size.attr, &lustre_attr_lru_max_age.attr, &lustre_attr_early_lock_cancel.attr, + &lustre_attr_dirty_age_limit.attr, #ifdef HAVE_SERVER_SUPPORT &lustre_attr_ctime_age_limit.attr, &lustre_attr_lock_timeouts.attr, @@ -643,13 +699,13 @@ static struct kobj_type ldlm_ns_ktype = { .release = ldlm_ns_release, }; -static void ldlm_namespace_proc_unregister(struct ldlm_namespace *ns) +static void ldlm_namespace_debugfs_unregister(struct ldlm_namespace *ns) { - if (ns->ns_proc_dir_entry == NULL) - CERROR("dlm namespace %s has no procfs dir?\n", - ldlm_ns_name(ns)); + if (IS_ERR_OR_NULL(ns->ns_debugfs_entry)) + CERROR("dlm namespace %s has no procfs dir?\n", + ldlm_ns_name(ns)); else - lprocfs_remove(&ns->ns_proc_dir_entry); + ldebugfs_remove(&ns->ns_debugfs_entry); if (ns->ns_stats != NULL) lprocfs_free_stats(&ns->ns_stats); @@ -682,55 +738,47 @@ int ldlm_namespace_sysfs_register(struct ldlm_namespace *ns) return err; } -static int ldlm_namespace_proc_register(struct ldlm_namespace *ns) +static int ldlm_namespace_debugfs_register(struct ldlm_namespace *ns) { - struct proc_dir_entry *ns_pde; - - LASSERT(ns != NULL); - LASSERT(ns->ns_rs_hash != NULL); + struct dentry *ns_entry; - if (ns->ns_proc_dir_entry != NULL) { - ns_pde = ns->ns_proc_dir_entry; + if (!IS_ERR_OR_NULL(ns->ns_debugfs_entry)) { + ns_entry = ns->ns_debugfs_entry; } else { - ns_pde = proc_mkdir(ldlm_ns_name(ns), ldlm_ns_proc_dir); - if (ns_pde == NULL) + ns_entry = debugfs_create_dir(ldlm_ns_name(ns), + ldlm_ns_debugfs_dir); + if (!ns_entry) return -ENOMEM; - ns->ns_proc_dir_entry = ns_pde; + ns->ns_debugfs_entry = ns_entry; } return 0; } #undef MAX_STRING_SIZE -#else /* CONFIG_PROC_FS */ - -#define ldlm_namespace_proc_unregister(ns) ({;}) -#define ldlm_namespace_proc_register(ns) ({0;}) - -#endif /* CONFIG_PROC_FS */ static unsigned ldlm_res_hop_hash(struct cfs_hash *hs, - const void *key, unsigned mask) + const void *key, unsigned int mask) { - const struct ldlm_res_id *id = key; - unsigned val = 0; - unsigned i; + const struct ldlm_res_id *id = key; + unsigned int val = 0; + unsigned int i; - for (i = 0; i < RES_NAME_SIZE; i++) - val += id->name[i]; - return val & mask; + for (i = 0; i < RES_NAME_SIZE; i++) + val += id->name[i]; + return val & mask; } static unsigned ldlm_res_hop_fid_hash(struct cfs_hash *hs, const void *key, unsigned mask) { - const struct ldlm_res_id *id = key; - struct lu_fid fid; - __u32 hash; - __u32 val; + const struct ldlm_res_id *id = key; + struct lu_fid fid; + __u32 hash; + __u32 val; - fid.f_seq = id->name[LUSTRE_RES_ID_SEQ_OFF]; - fid.f_oid = (__u32)id->name[LUSTRE_RES_ID_VER_OID_OFF]; - fid.f_ver = (__u32)(id->name[LUSTRE_RES_ID_VER_OID_OFF] >> 32); + fid.f_seq = id->name[LUSTRE_RES_ID_SEQ_OFF]; + fid.f_oid = (__u32)id->name[LUSTRE_RES_ID_VER_OID_OFF]; + fid.f_ver = (__u32)(id->name[LUSTRE_RES_ID_VER_OID_OFF] >> 32); hash = fid_flatten32(&fid); hash += (hash >> 4) + (hash << 12); /* mixing oid and seq */ @@ -752,19 +800,19 @@ static unsigned ldlm_res_hop_fid_hash(struct cfs_hash *hs, static void *ldlm_res_hop_key(struct hlist_node *hnode) { - struct ldlm_resource *res; + struct ldlm_resource *res; res = hlist_entry(hnode, struct ldlm_resource, lr_hash); - return &res->lr_name; + return &res->lr_name; } static int ldlm_res_hop_keycmp(const void *key, struct hlist_node *hnode) { - struct ldlm_resource *res; + struct ldlm_resource *res; res = hlist_entry(hnode, struct ldlm_resource, lr_hash); - return ldlm_res_eq((const struct ldlm_res_id *)key, - (const struct ldlm_res_id *)&res->lr_name); + return ldlm_res_eq((const struct ldlm_res_id *)key, + (const struct ldlm_res_id *)&res->lr_name); } static void *ldlm_res_hop_object(struct hlist_node *hnode) @@ -775,38 +823,38 @@ static void *ldlm_res_hop_object(struct hlist_node *hnode) static void ldlm_res_hop_get_locked(struct cfs_hash *hs, struct hlist_node *hnode) { - struct ldlm_resource *res; + struct ldlm_resource *res; res = hlist_entry(hnode, struct ldlm_resource, lr_hash); - ldlm_resource_getref(res); + ldlm_resource_getref(res); } static void ldlm_res_hop_put(struct cfs_hash *hs, struct hlist_node *hnode) { - struct ldlm_resource *res; + struct ldlm_resource *res; res = hlist_entry(hnode, struct ldlm_resource, lr_hash); - ldlm_resource_putref(res); + ldlm_resource_putref(res); } static struct cfs_hash_ops ldlm_ns_hash_ops = { - .hs_hash = ldlm_res_hop_hash, - .hs_key = ldlm_res_hop_key, - .hs_keycmp = ldlm_res_hop_keycmp, - .hs_keycpy = NULL, - .hs_object = ldlm_res_hop_object, - .hs_get = ldlm_res_hop_get_locked, - .hs_put = ldlm_res_hop_put + .hs_hash = ldlm_res_hop_hash, + .hs_key = ldlm_res_hop_key, + .hs_keycmp = ldlm_res_hop_keycmp, + .hs_keycpy = NULL, + .hs_object = ldlm_res_hop_object, + .hs_get = ldlm_res_hop_get_locked, + .hs_put = ldlm_res_hop_put }; static struct cfs_hash_ops ldlm_ns_fid_hash_ops = { - .hs_hash = ldlm_res_hop_fid_hash, - .hs_key = ldlm_res_hop_key, - .hs_keycmp = ldlm_res_hop_keycmp, - .hs_keycpy = NULL, - .hs_object = ldlm_res_hop_object, - .hs_get = ldlm_res_hop_get_locked, - .hs_put = ldlm_res_hop_put + .hs_hash = ldlm_res_hop_fid_hash, + .hs_key = ldlm_res_hop_key, + .hs_keycmp = ldlm_res_hop_keycmp, + .hs_keycpy = NULL, + .hs_object = ldlm_res_hop_object, + .hs_get = ldlm_res_hop_get_locked, + .hs_put = ldlm_res_hop_put }; typedef struct ldlm_ns_hash_def { @@ -821,45 +869,45 @@ typedef struct ldlm_ns_hash_def { static struct ldlm_ns_hash_def ldlm_ns_hash_defs[] = { - { - .nsd_type = LDLM_NS_TYPE_MDC, - .nsd_bkt_bits = 11, - .nsd_all_bits = 16, - .nsd_hops = &ldlm_ns_fid_hash_ops, - }, - { - .nsd_type = LDLM_NS_TYPE_MDT, - .nsd_bkt_bits = 14, - .nsd_all_bits = 21, - .nsd_hops = &ldlm_ns_fid_hash_ops, - }, - { - .nsd_type = LDLM_NS_TYPE_OSC, - .nsd_bkt_bits = 8, - .nsd_all_bits = 12, - .nsd_hops = &ldlm_ns_hash_ops, - }, - { - .nsd_type = LDLM_NS_TYPE_OST, - .nsd_bkt_bits = 11, - .nsd_all_bits = 17, - .nsd_hops = &ldlm_ns_hash_ops, - }, - { - .nsd_type = LDLM_NS_TYPE_MGC, - .nsd_bkt_bits = 4, - .nsd_all_bits = 4, - .nsd_hops = &ldlm_ns_hash_ops, - }, - { - .nsd_type = LDLM_NS_TYPE_MGT, - .nsd_bkt_bits = 4, - .nsd_all_bits = 4, - .nsd_hops = &ldlm_ns_hash_ops, - }, - { - .nsd_type = LDLM_NS_TYPE_UNKNOWN, - }, + { + .nsd_type = LDLM_NS_TYPE_MDC, + .nsd_bkt_bits = 11, + .nsd_all_bits = 16, + .nsd_hops = &ldlm_ns_fid_hash_ops, + }, + { + .nsd_type = LDLM_NS_TYPE_MDT, + .nsd_bkt_bits = 14, + .nsd_all_bits = 21, + .nsd_hops = &ldlm_ns_fid_hash_ops, + }, + { + .nsd_type = LDLM_NS_TYPE_OSC, + .nsd_bkt_bits = 8, + .nsd_all_bits = 12, + .nsd_hops = &ldlm_ns_hash_ops, + }, + { + .nsd_type = LDLM_NS_TYPE_OST, + .nsd_bkt_bits = 11, + .nsd_all_bits = 17, + .nsd_hops = &ldlm_ns_hash_ops, + }, + { + .nsd_type = LDLM_NS_TYPE_MGC, + .nsd_bkt_bits = 4, + .nsd_all_bits = 4, + .nsd_hops = &ldlm_ns_hash_ops, + }, + { + .nsd_type = LDLM_NS_TYPE_MGT, + .nsd_bkt_bits = 4, + .nsd_all_bits = 4, + .nsd_hops = &ldlm_ns_hash_ops, + }, + { + .nsd_type = LDLM_NS_TYPE_UNKNOWN, + }, }; /** @@ -876,54 +924,57 @@ struct ldlm_namespace *ldlm_namespace_new(struct obd_device *obd, char *name, struct cfs_hash_bd bd; int idx; int rc; + ENTRY; + LASSERT(obd != NULL); - LASSERT(obd != NULL); - - rc = ldlm_get_ref(); - if (rc) { - CERROR("ldlm_get_ref failed: %d\n", rc); - RETURN(NULL); - } - - for (idx = 0;;idx++) { - nsd = &ldlm_ns_hash_defs[idx]; - if (nsd->nsd_type == LDLM_NS_TYPE_UNKNOWN) { - CERROR("Unknown type %d for ns %s\n", ns_type, name); - GOTO(out_ref, NULL); - } - - if (nsd->nsd_type == ns_type) - break; - } - - OBD_ALLOC_PTR(ns); - if (!ns) - GOTO(out_ref, NULL); - - ns->ns_rs_hash = cfs_hash_create(name, - nsd->nsd_all_bits, nsd->nsd_all_bits, - nsd->nsd_bkt_bits, sizeof(*nsb), - CFS_HASH_MIN_THETA, - CFS_HASH_MAX_THETA, - nsd->nsd_hops, - CFS_HASH_DEPTH | - CFS_HASH_BIGNAME | - CFS_HASH_SPIN_BKTLOCK | - CFS_HASH_NO_ITEMREF); - if (ns->ns_rs_hash == NULL) - GOTO(out_ns, NULL); - - cfs_hash_for_each_bucket(ns->ns_rs_hash, &bd, idx) { - nsb = cfs_hash_bd_extra_get(ns->ns_rs_hash, &bd); - at_init(&nsb->nsb_at_estimate, ldlm_enqueue_min, 0); - nsb->nsb_namespace = ns; + rc = ldlm_get_ref(); + if (rc) { + CERROR("ldlm_get_ref failed: %d\n", rc); + RETURN(NULL); + } + + for (idx = 0; ; idx++) { + nsd = &ldlm_ns_hash_defs[idx]; + if (nsd->nsd_type == LDLM_NS_TYPE_UNKNOWN) { + CERROR("Unknown type %d for ns %s\n", ns_type, name); + GOTO(out_ref, NULL); + } + + if (nsd->nsd_type == ns_type) + break; + } + + OBD_ALLOC_PTR(ns); + if (!ns) + GOTO(out_ref, NULL); + + ns->ns_rs_hash = cfs_hash_create(name, + nsd->nsd_all_bits, nsd->nsd_all_bits, + nsd->nsd_bkt_bits, sizeof(*nsb), + CFS_HASH_MIN_THETA, + CFS_HASH_MAX_THETA, + nsd->nsd_hops, + CFS_HASH_DEPTH | + CFS_HASH_BIGNAME | + CFS_HASH_SPIN_BKTLOCK | + CFS_HASH_NO_ITEMREF); + if (ns->ns_rs_hash == NULL) + GOTO(out_ns, NULL); + + cfs_hash_for_each_bucket(ns->ns_rs_hash, &bd, idx) { + nsb = cfs_hash_bd_extra_get(ns->ns_rs_hash, &bd); + at_init(&nsb->nsb_at_estimate, ldlm_enqueue_min, 0); + nsb->nsb_namespace = ns; nsb->nsb_reclaim_start = 0; - } + } - ns->ns_obd = obd; - ns->ns_appetite = apt; - ns->ns_client = client; + ns->ns_obd = obd; + ns->ns_appetite = apt; + ns->ns_client = client; + ns->ns_name = kstrdup(name, GFP_KERNEL); + if (!ns->ns_name) + goto out_hash; INIT_LIST_HEAD(&ns->ns_list_chain); INIT_LIST_HEAD(&ns->ns_unused_list); @@ -935,16 +986,18 @@ struct ldlm_namespace *ldlm_namespace_new(struct obd_device *obd, char *name, ns->ns_contention_time = NS_DEFAULT_CONTENTION_SECONDS; ns->ns_contended_locks = NS_DEFAULT_CONTENDED_LOCKS; - ns->ns_max_parallel_ast = LDLM_DEFAULT_PARALLEL_AST_LIMIT; - ns->ns_nr_unused = 0; - ns->ns_max_unused = LDLM_DEFAULT_LRU_SIZE; + ns->ns_max_parallel_ast = LDLM_DEFAULT_PARALLEL_AST_LIMIT; + ns->ns_nr_unused = 0; + ns->ns_max_unused = LDLM_DEFAULT_LRU_SIZE; ns->ns_max_age = ktime_set(LDLM_DEFAULT_MAX_ALIVE, 0); - ns->ns_ctime_age_limit = LDLM_CTIME_AGE_LIMIT; - ns->ns_timeouts = 0; - ns->ns_orig_connect_flags = 0; - ns->ns_connect_flags = 0; - ns->ns_stopping = 0; + ns->ns_ctime_age_limit = LDLM_CTIME_AGE_LIMIT; + ns->ns_dirty_age_limit = LDLM_DIRTY_AGE_LIMIT; + ns->ns_timeouts = 0; + ns->ns_orig_connect_flags = 0; + ns->ns_connect_flags = 0; + ns->ns_stopping = 0; ns->ns_reclaim_start = 0; + ns->ns_last_pos = &ns->ns_unused_list; rc = ldlm_namespace_sysfs_register(ns); if (rc) { @@ -952,38 +1005,37 @@ struct ldlm_namespace *ldlm_namespace_new(struct obd_device *obd, char *name, GOTO(out_hash, rc); } - rc = ldlm_namespace_proc_register(ns); + rc = ldlm_namespace_debugfs_register(ns); if (rc) { CERROR("Can't initialize ns proc, rc %d\n", rc); GOTO(out_sysfs, rc); } - idx = ldlm_namespace_nr_read(client); - rc = ldlm_pool_init(&ns->ns_pool, ns, idx, client); - if (rc) { - CERROR("Can't initialize lock pool, rc %d\n", rc); - GOTO(out_proc, rc); - } + idx = ldlm_namespace_nr_read(client); + rc = ldlm_pool_init(&ns->ns_pool, ns, idx, client); + if (rc) { + CERROR("Can't initialize lock pool, rc %d\n", rc); + GOTO(out_proc, rc); + } - ldlm_namespace_register(ns, client); - RETURN(ns); + ldlm_namespace_register(ns, client); + RETURN(ns); out_proc: - ldlm_namespace_proc_unregister(ns); + ldlm_namespace_debugfs_unregister(ns); out_sysfs: ldlm_namespace_sysfs_unregister(ns); ldlm_namespace_cleanup(ns, 0); out_hash: - cfs_hash_putref(ns->ns_rs_hash); + kfree(ns->ns_name); + cfs_hash_putref(ns->ns_rs_hash); out_ns: OBD_FREE_PTR(ns); out_ref: - ldlm_put_ref(); - RETURN(NULL); + ldlm_put_ref(); + RETURN(NULL); } EXPORT_SYMBOL(ldlm_namespace_new); -extern struct ldlm_lock *ldlm_lock_get(struct ldlm_lock *lock); - /** * Cancel and destroy all locks on a resource. * @@ -999,8 +1051,8 @@ static void cleanup_resource(struct ldlm_resource *res, struct list_head *q, int rc = 0, client = ns_is_client(ldlm_res_to_ns(res)); bool local_only = !!(flags & LDLM_FL_LOCAL_ONLY); - do { - struct ldlm_lock *lock = NULL; + do { + struct ldlm_lock *lock = NULL; /* First, we look for non-cleaned-yet lock * all cleaned locks are marked by CLEANED flag. */ @@ -1017,69 +1069,70 @@ static void cleanup_resource(struct ldlm_resource *res, struct list_head *q, break; } - if (lock == NULL) { - unlock_res(res); - break; - } + if (lock == NULL) { + unlock_res(res); + break; + } - /* Set CBPENDING so nothing in the cancellation path + /* Set CBPENDING so nothing in the cancellation path * can match this lock. */ ldlm_set_cbpending(lock); ldlm_set_failed(lock); - lock->l_flags |= flags; + lock->l_flags |= flags; - /* ... without sending a CANCEL message for local_only. */ - if (local_only) + /* ... without sending a CANCEL message for local_only. */ + if (local_only) ldlm_set_local_only(lock); - if (local_only && (lock->l_readers || lock->l_writers)) { - /* This is a little bit gross, but much better than the - * alternative: pretend that we got a blocking AST from - * the server, so that when the lock is decref'd, it - * will go away ... */ - unlock_res(res); - LDLM_DEBUG(lock, "setting FL_LOCAL_ONLY"); + if (local_only && (lock->l_readers || lock->l_writers)) { + /* + * This is a little bit gross, but much better than the + * alternative: pretend that we got a blocking AST from + * the server, so that when the lock is decref'd, it + * will go away ... + */ + unlock_res(res); + LDLM_DEBUG(lock, "setting FL_LOCAL_ONLY"); if (lock->l_flags & LDLM_FL_FAIL_LOC) { set_current_state(TASK_UNINTERRUPTIBLE); schedule_timeout(cfs_time_seconds(4)); set_current_state(TASK_RUNNING); } - if (lock->l_completion_ast) + if (lock->l_completion_ast) lock->l_completion_ast(lock, LDLM_FL_FAILED, NULL); - LDLM_LOCK_RELEASE(lock); - continue; - } + LDLM_LOCK_RELEASE(lock); + continue; + } - if (client) { - struct lustre_handle lockh; + if (client) { + struct lustre_handle lockh; - unlock_res(res); - ldlm_lock2handle(lock, &lockh); + unlock_res(res); + ldlm_lock2handle(lock, &lockh); rc = ldlm_cli_cancel(&lockh, LCF_LOCAL); - if (rc) - CERROR("ldlm_cli_cancel: %d\n", rc); - } else { - unlock_res(res); - LDLM_DEBUG(lock, "Freeing a lock still held by a " - "client node"); + if (rc) + CERROR("ldlm_cli_cancel: %d\n", rc); + } else { + unlock_res(res); + LDLM_DEBUG(lock, + "Freeing a lock still held by a client node"); ldlm_lock_cancel(lock); - } - LDLM_LOCK_RELEASE(lock); - } while (1); + } + LDLM_LOCK_RELEASE(lock); + } while (1); } static int ldlm_resource_clean(struct cfs_hash *hs, struct cfs_hash_bd *bd, struct hlist_node *hnode, void *arg) { - struct ldlm_resource *res = cfs_hash_object(hs, hnode); + struct ldlm_resource *res = cfs_hash_object(hs, hnode); __u64 flags = *(__u64 *)arg; - cleanup_resource(res, &res->lr_granted, flags); - cleanup_resource(res, &res->lr_converting, flags); - cleanup_resource(res, &res->lr_waiting, flags); + cleanup_resource(res, &res->lr_granted, flags); + cleanup_resource(res, &res->lr_waiting, flags); - return 0; + return 0; } static int ldlm_resource_complain(struct cfs_hash *hs, struct cfs_hash_bd *bd, @@ -1093,7 +1146,8 @@ static int ldlm_resource_complain(struct cfs_hash *hs, struct cfs_hash_bd *bd, ldlm_ns_name(ldlm_res_to_ns(res)), PLDLMRES(res), res, atomic_read(&res->lr_refcount) - 1); - ldlm_resource_dump(D_ERROR, res); + /* Use D_NETERROR since it is in the default mask */ + ldlm_resource_dump(D_NETERROR, res); unlock_res(res); return 0; } @@ -1107,10 +1161,10 @@ static int ldlm_resource_complain(struct cfs_hash *hs, struct cfs_hash_bd *bd, */ int ldlm_namespace_cleanup(struct ldlm_namespace *ns, __u64 flags) { - if (ns == NULL) { - CDEBUG(D_INFO, "NULL ns, skipping cleanup\n"); - return ELDLM_OK; - } + if (ns == NULL) { + CDEBUG(D_INFO, "NULL ns, skipping cleanup\n"); + return ELDLM_OK; + } cfs_hash_for_each_nolock(ns->ns_rs_hash, ldlm_resource_clean, &flags, 0); @@ -1140,8 +1194,8 @@ static int __ldlm_namespace_free(struct ldlm_namespace *ns, int force) ldlm_ns_name(ns), atomic_read(&ns->ns_bref)); force_wait: if (force) - lwi = LWI_TIMEOUT(msecs_to_jiffies(obd_timeout * - MSEC_PER_SEC) / 4, NULL, NULL); + lwi = LWI_TIMEOUT(cfs_time_seconds(1) / 4, + NULL, NULL); rc = l_wait_event(ns->ns_waitq, atomic_read(&ns->ns_bref) == 0, &lwi); @@ -1183,35 +1237,36 @@ void ldlm_namespace_free_prior(struct ldlm_namespace *ns, struct obd_import *imp, int force) { - int rc; - ENTRY; - if (!ns) { - EXIT; - return; - } + int rc; + + ENTRY; + if (!ns) { + EXIT; + return; + } spin_lock(&ns->ns_lock); ns->ns_stopping = 1; spin_unlock(&ns->ns_lock); - /* - * Can fail with -EINTR when force == 0 in which case try harder. - */ - rc = __ldlm_namespace_free(ns, force); - if (rc != ELDLM_OK) { - if (imp) { - ptlrpc_disconnect_import(imp, 0); - ptlrpc_invalidate_import(imp); - } - - /* - * With all requests dropped and the import inactive - * we are gaurenteed all reference will be dropped. - */ - rc = __ldlm_namespace_free(ns, 1); - LASSERT(rc == 0); - } - EXIT; + /* + * Can fail with -EINTR when force == 0 in which case try harder. + */ + rc = __ldlm_namespace_free(ns, force); + if (rc != ELDLM_OK) { + if (imp) { + ptlrpc_disconnect_import(imp, 0); + ptlrpc_invalidate_import(imp); + } + + /* + * With all requests dropped and the import inactive + * we are gaurenteed all reference will be dropped. + */ + rc = __ldlm_namespace_free(ns, 1); + LASSERT(rc == 0); + } + EXIT; } EXPORT_SYMBOL(ldlm_namespace_free_prior); @@ -1222,11 +1277,11 @@ EXPORT_SYMBOL(ldlm_namespace_free_prior); */ void ldlm_namespace_free_post(struct ldlm_namespace *ns) { - ENTRY; - if (!ns) { - EXIT; - return; - } + ENTRY; + if (!ns) { + EXIT; + return; + } /* Make sure that nobody can find this ns in its list. */ ldlm_namespace_unregister(ns, ns->ns_client); @@ -1235,12 +1290,14 @@ void ldlm_namespace_free_post(struct ldlm_namespace *ns) * Removing it after @dir may cause oops. */ ldlm_pool_fini(&ns->ns_pool); - ldlm_namespace_proc_unregister(ns); + ldlm_namespace_debugfs_unregister(ns); ldlm_namespace_sysfs_unregister(ns); cfs_hash_putref(ns->ns_rs_hash); + kfree(ns->ns_name); /* Namespace \a ns should be not on list at this time, otherwise * this will cause issues related to using freed \a ns in poold - * thread. */ + * thread. + */ LASSERT(list_empty(&ns->ns_list_chain)); OBD_FREE_PTR(ns); ldlm_put_ref(); @@ -1267,11 +1324,11 @@ EXPORT_SYMBOL(ldlm_namespace_free_post); * held. */ void ldlm_namespace_free(struct ldlm_namespace *ns, - struct obd_import *imp, - int force) + struct obd_import *imp, + int force) { - ldlm_namespace_free_prior(ns, imp, force); - ldlm_namespace_free_post(ns); + ldlm_namespace_free_prior(ns, imp, force); + ldlm_namespace_free_post(ns); } EXPORT_SYMBOL(ldlm_namespace_free); @@ -1345,33 +1402,62 @@ struct ldlm_namespace *ldlm_namespace_first_locked(enum ldlm_side client) struct ldlm_namespace, ns_list_chain); } +static bool ldlm_resource_extent_new(struct ldlm_resource *res) +{ + int idx; + + OBD_SLAB_ALLOC(res->lr_itree, ldlm_interval_tree_slab, + sizeof(*res->lr_itree) * LCK_MODE_NUM); + if (res->lr_itree == NULL) + return false; + /* Initialize interval trees for each lock mode. */ + for (idx = 0; idx < LCK_MODE_NUM; idx++) { + res->lr_itree[idx].lit_size = 0; + res->lr_itree[idx].lit_mode = 1 << idx; + res->lr_itree[idx].lit_root = NULL; + } + return true; +} + +static bool ldlm_resource_inodebits_new(struct ldlm_resource *res) +{ + int i; + + OBD_ALLOC_PTR(res->lr_ibits_queues); + if (res->lr_ibits_queues == NULL) + return false; + for (i = 0; i < MDS_INODELOCK_NUMBITS; i++) + INIT_LIST_HEAD(&res->lr_ibits_queues->liq_waiting[i]); + return true; +} + /** Create and initialize new resource. */ static struct ldlm_resource *ldlm_resource_new(enum ldlm_type ldlm_type) { struct ldlm_resource *res; - int idx; + bool rc; OBD_SLAB_ALLOC_PTR_GFP(res, ldlm_resource_slab, GFP_NOFS); if (res == NULL) return NULL; - if (ldlm_type == LDLM_EXTENT) { - OBD_SLAB_ALLOC(res->lr_itree, ldlm_interval_tree_slab, - sizeof(*res->lr_itree) * LCK_MODE_NUM); - if (res->lr_itree == NULL) { - OBD_SLAB_FREE_PTR(res, ldlm_resource_slab); - return NULL; - } - /* Initialize interval trees for each lock mode. */ - for (idx = 0; idx < LCK_MODE_NUM; idx++) { - res->lr_itree[idx].lit_size = 0; - res->lr_itree[idx].lit_mode = 1 << idx; - res->lr_itree[idx].lit_root = NULL; - } + switch (ldlm_type) { + case LDLM_EXTENT: + rc = ldlm_resource_extent_new(res); + break; + case LDLM_IBITS: + rc = ldlm_resource_inodebits_new(res); + break; + default: + rc = true; + break; + } + if (!rc) { + OBD_SLAB_FREE_PTR(res, ldlm_resource_slab); + return NULL; } INIT_LIST_HEAD(&res->lr_granted); - INIT_LIST_HEAD(&res->lr_converting); INIT_LIST_HEAD(&res->lr_waiting); atomic_set(&res->lr_refcount, 1); @@ -1386,6 +1472,20 @@ static struct ldlm_resource *ldlm_resource_new(enum ldlm_type ldlm_type) return res; } +static void ldlm_resource_free(struct ldlm_resource *res) +{ + if (res->lr_type == LDLM_EXTENT) { + if (res->lr_itree != NULL) + OBD_SLAB_FREE(res->lr_itree, ldlm_interval_tree_slab, + sizeof(*res->lr_itree) * LCK_MODE_NUM); + } else if (res->lr_type == LDLM_IBITS) { + if (res->lr_ibits_queues != NULL) + OBD_FREE_PTR(res->lr_ibits_queues); + } + + OBD_SLAB_FREE(res, ldlm_resource_slab, sizeof *res); +} + /** * Return a reference to resource with given name, creating it if necessary. * Args: namespace with ns_lock unlocked @@ -1403,15 +1503,15 @@ ldlm_resource_get(struct ldlm_namespace *ns, struct ldlm_resource *parent, __u64 version; int ns_refcount = 0; - LASSERT(ns != NULL); - LASSERT(parent == NULL); - LASSERT(ns->ns_rs_hash != NULL); - LASSERT(name->name[0] != 0); + LASSERT(ns != NULL); + LASSERT(parent == NULL); + LASSERT(ns->ns_rs_hash != NULL); + LASSERT(name->name[0] != 0); - cfs_hash_bd_get_and_lock(ns->ns_rs_hash, (void *)name, &bd, 0); - hnode = cfs_hash_bd_lookup_locked(ns->ns_rs_hash, &bd, (void *)name); - if (hnode != NULL) { - cfs_hash_bd_unlock(ns->ns_rs_hash, &bd, 0); + cfs_hash_bd_get_and_lock(ns->ns_rs_hash, (void *)name, &bd, 0); + hnode = cfs_hash_bd_lookup_locked(ns->ns_rs_hash, &bd, (void *)name); + if (hnode != NULL) { + cfs_hash_bd_unlock(ns->ns_rs_hash, &bd, 0); GOTO(found, res); } @@ -1440,20 +1540,17 @@ ldlm_resource_get(struct ldlm_namespace *ns, struct ldlm_resource *parent, cfs_hash_bd_unlock(ns->ns_rs_hash, &bd, 1); /* Clean lu_ref for failed resource. */ lu_ref_fini(&res->lr_reference); - if (res->lr_itree != NULL) - OBD_SLAB_FREE(res->lr_itree, ldlm_interval_tree_slab, - sizeof(*res->lr_itree) * LCK_MODE_NUM); - OBD_SLAB_FREE(res, ldlm_resource_slab, sizeof *res); + ldlm_resource_free(res); found: res = hlist_entry(hnode, struct ldlm_resource, lr_hash); return res; } /* We won! Let's add the resource. */ - cfs_hash_bd_add_locked(ns->ns_rs_hash, &bd, &res->lr_hash); + cfs_hash_bd_add_locked(ns->ns_rs_hash, &bd, &res->lr_hash); if (cfs_hash_bd_count_get(&bd) == 1) ns_refcount = ldlm_namespace_get_return(ns); - cfs_hash_bd_unlock(ns->ns_rs_hash, &bd, 1); + cfs_hash_bd_unlock(ns->ns_rs_hash, &bd, 1); OBD_FAIL_TIMEOUT(OBD_FAIL_LDLM_CREATE_RESOURCE, 2); @@ -1484,28 +1581,23 @@ struct ldlm_resource *ldlm_resource_getref(struct ldlm_resource *res) static void __ldlm_resource_putref_final(struct cfs_hash_bd *bd, struct ldlm_resource *res) { - struct ldlm_ns_bucket *nsb = res->lr_ns_bucket; + struct ldlm_ns_bucket *nsb = res->lr_ns_bucket; if (!list_empty(&res->lr_granted)) { - ldlm_resource_dump(D_ERROR, res); - LBUG(); - } - - if (!list_empty(&res->lr_converting)) { - ldlm_resource_dump(D_ERROR, res); - LBUG(); - } + ldlm_resource_dump(D_ERROR, res); + LBUG(); + } if (!list_empty(&res->lr_waiting)) { - ldlm_resource_dump(D_ERROR, res); - LBUG(); - } + ldlm_resource_dump(D_ERROR, res); + LBUG(); + } - cfs_hash_bd_del_locked(nsb->nsb_namespace->ns_rs_hash, - bd, &res->lr_hash); - lu_ref_fini(&res->lr_reference); - if (cfs_hash_bd_count_get(bd) == 0) - ldlm_namespace_put(nsb->nsb_namespace); + cfs_hash_bd_del_locked(nsb->nsb_namespace->ns_rs_hash, + bd, &res->lr_hash); + lu_ref_fini(&res->lr_reference); + if (cfs_hash_bd_count_get(bd) == 0) + ldlm_namespace_put(nsb->nsb_namespace); } /* Returns 1 if the resource was freed, 0 if it remains. */ @@ -1524,10 +1616,7 @@ int ldlm_resource_putref(struct ldlm_resource *res) cfs_hash_bd_unlock(ns->ns_rs_hash, &bd, 1); if (ns->ns_lvbo && ns->ns_lvbo->lvbo_free) ns->ns_lvbo->lvbo_free(res); - if (res->lr_itree != NULL) - OBD_SLAB_FREE(res->lr_itree, ldlm_interval_tree_slab, - sizeof(*res->lr_itree) * LCK_MODE_NUM); - OBD_SLAB_FREE(res, ldlm_resource_slab, sizeof *res); + ldlm_resource_free(res); return 1; } return 0; @@ -1552,6 +1641,9 @@ void ldlm_resource_add_lock(struct ldlm_resource *res, struct list_head *head, LASSERT(list_empty(&lock->l_res_link)); list_add_tail(&lock->l_res_link, head); + + if (res->lr_type == LDLM_IBITS) + ldlm_inodebits_add_lock(res, head, lock); } /** @@ -1560,13 +1652,13 @@ void ldlm_resource_add_lock(struct ldlm_resource *res, struct list_head *head, * Obtain resource description from the lock we are inserting after. */ void ldlm_resource_insert_lock_after(struct ldlm_lock *original, - struct ldlm_lock *new) + struct ldlm_lock *new) { - struct ldlm_resource *res = original->l_resource; + struct ldlm_resource *res = original->l_resource; - check_res_locked(res); + check_res_locked(res); - ldlm_resource_dump(D_INFO, res); + ldlm_resource_dump(D_INFO, res); LDLM_DEBUG(new, "About to insert this lock after %p: ", original); if (ldlm_is_destroyed(new)) { @@ -1582,21 +1674,28 @@ void ldlm_resource_insert_lock_after(struct ldlm_lock *original, void ldlm_resource_unlink_lock(struct ldlm_lock *lock) { - int type = lock->l_resource->lr_type; - - check_res_locked(lock->l_resource); - if (type == LDLM_IBITS || type == LDLM_PLAIN) - ldlm_unlink_lock_skiplist(lock); - else if (type == LDLM_EXTENT) - ldlm_extent_unlink_lock(lock); + int type = lock->l_resource->lr_type; + + check_res_locked(lock->l_resource); + switch (type) { + case LDLM_PLAIN: + ldlm_unlink_lock_skiplist(lock); + break; + case LDLM_EXTENT: + ldlm_extent_unlink_lock(lock); + break; + case LDLM_IBITS: + ldlm_inodebits_unlink_lock(lock); + break; + } list_del_init(&lock->l_res_link); } EXPORT_SYMBOL(ldlm_resource_unlink_lock); void ldlm_res2desc(struct ldlm_resource *res, struct ldlm_resource_desc *desc) { - desc->lr_type = res->lr_type; - desc->lr_name = res->lr_name; + desc->lr_type = res->lr_type; + desc->lr_name = res->lr_name; } /** @@ -1625,14 +1724,14 @@ void ldlm_dump_all_namespaces(enum ldlm_side client, int level) static int ldlm_res_hash_dump(struct cfs_hash *hs, struct cfs_hash_bd *bd, struct hlist_node *hnode, void *arg) { - struct ldlm_resource *res = cfs_hash_object(hs, hnode); - int level = (int)(unsigned long)arg; + struct ldlm_resource *res = cfs_hash_object(hs, hnode); + int level = (int)(unsigned long)arg; - lock_res(res); - ldlm_resource_dump(level, res); - unlock_res(res); + lock_res(res); + ldlm_resource_dump(level, res); + unlock_res(res); - return 0; + return 0; } /** @@ -1679,24 +1778,21 @@ void ldlm_resource_dump(int level, struct ldlm_resource *res) CDEBUG(level, "Granted locks (in reverse order):\n"); list_for_each_entry_reverse(lock, &res->lr_granted, l_res_link) { - LDLM_DEBUG_LIMIT(level, lock, "###"); - if (!(level & D_CANTMASK) && - ++granted > ldlm_dump_granted_max) { - CDEBUG(level, "only dump %d granted locks to " - "avoid DDOS.\n", granted); - break; - } - } - } - if (!list_empty(&res->lr_converting)) { - CDEBUG(level, "Converting locks:\n"); - list_for_each_entry(lock, &res->lr_converting, l_res_link) - LDLM_DEBUG_LIMIT(level, lock, "###"); - } + LDLM_DEBUG_LIMIT(level, lock, "###"); + if (!(level & D_CANTMASK) && + ++granted > ldlm_dump_granted_max) { + CDEBUG(level, + "only dump %d granted locks to avoid DDOS.\n", + granted); + break; + } + } + } + if (!list_empty(&res->lr_waiting)) { - CDEBUG(level, "Waiting locks:\n"); + CDEBUG(level, "Waiting locks:\n"); list_for_each_entry(lock, &res->lr_waiting, l_res_link) - LDLM_DEBUG_LIMIT(level, lock, "###"); - } + LDLM_DEBUG_LIMIT(level, lock, "###"); + } } EXPORT_SYMBOL(ldlm_resource_dump);