LU-12930 various: use schedule_timeout_*interruptible

[fs/lustre-release.git] / lustre / ldlm / ldlm_resource.c

diff --git a/lustre/ldlm/ldlm_resource.c b/lustre/ldlm/ldlm_resource.c
index 735ea3d..490e7c5 100644 (file)
--- a/lustre/ldlm/ldlm_resource.c
+++ b/lustre/ldlm/ldlm_resource.c
@@ -111,9 +111,10 @@ static ssize_t seq_watermark_write(struct file *file,
                                   const char __user *buffer, size_t count,
                                   loff_t *off)
 {
+       struct seq_file *m = file->private_data;
        u64 value;
        __u64 watermark;
-       __u64 *data = ((struct seq_file *)file->private_data)->private;
+       __u64 *data = m->private;
        bool wm_low = (data == &ldlm_reclaim_threshold_mb) ? true : false;
        char kernbuf[22] = "";
        int rc;
@@ -834,56 +835,35 @@ static struct cfs_hash_ops ldlm_ns_hash_ops = {
        .hs_put         = ldlm_res_hop_put
 };
 
-typedef struct ldlm_ns_hash_def {
-       enum ldlm_ns_type       nsd_type;
+static struct {
        /** hash bucket bits */
        unsigned                nsd_bkt_bits;
        /** hash bits */
        unsigned                nsd_all_bits;
-       /** hash operations */
-       struct cfs_hash_ops *nsd_hops;
-} ldlm_ns_hash_def_t;
-
-static struct ldlm_ns_hash_def ldlm_ns_hash_defs[] =
-{
-       {
-               .nsd_type       = LDLM_NS_TYPE_MDC,
+} ldlm_ns_hash_defs[] = {
+       [LDLM_NS_TYPE_MDC] = {
                .nsd_bkt_bits   = 11,
                .nsd_all_bits   = 16,
-               .nsd_hops       = &ldlm_ns_hash_ops,
        },
-       {
-               .nsd_type       = LDLM_NS_TYPE_MDT,
+       [LDLM_NS_TYPE_MDT] = {
                .nsd_bkt_bits   = 14,
                .nsd_all_bits   = 21,
-               .nsd_hops       = &ldlm_ns_hash_ops,
        },
-       {
-               .nsd_type       = LDLM_NS_TYPE_OSC,
+       [LDLM_NS_TYPE_OSC] = {
                .nsd_bkt_bits   = 8,
                .nsd_all_bits   = 12,
-               .nsd_hops       = &ldlm_ns_hash_ops,
        },
-       {
-               .nsd_type       = LDLM_NS_TYPE_OST,
+       [LDLM_NS_TYPE_OST] = {
                .nsd_bkt_bits   = 11,
                .nsd_all_bits   = 17,
-               .nsd_hops       = &ldlm_ns_hash_ops,
        },
-       {
-               .nsd_type       = LDLM_NS_TYPE_MGC,
+       [LDLM_NS_TYPE_MGC] = {
                .nsd_bkt_bits   = 3,
                .nsd_all_bits   = 4,
-               .nsd_hops       = &ldlm_ns_hash_ops,
        },
-       {
-               .nsd_type       = LDLM_NS_TYPE_MGT,
+       [LDLM_NS_TYPE_MGT] = {
                .nsd_bkt_bits   = 3,
                .nsd_all_bits   = 4,
-               .nsd_hops       = &ldlm_ns_hash_ops,
-       },
-       {
-               .nsd_type       = LDLM_NS_TYPE_UNKNOWN,
        },
 };
 
@@ -896,7 +876,6 @@ struct ldlm_namespace *ldlm_namespace_new(struct obd_device *obd, char *name,
                                          enum ldlm_ns_type ns_type)
 {
        struct ldlm_namespace *ns = NULL;
-       struct ldlm_ns_hash_def *nsd;
        int idx;
        int rc;
 
@@ -909,15 +888,10 @@ struct ldlm_namespace *ldlm_namespace_new(struct obd_device *obd, char *name,
                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;
+       if (ns_type >= ARRAY_SIZE(ldlm_ns_hash_defs) ||
+           ldlm_ns_hash_defs[ns_type].nsd_bkt_bits == 0) {
+               CERROR("Unknown type %d for ns %s\n", ns_type, name);
+               GOTO(out_ref, NULL);
        }
 
        OBD_ALLOC_PTR(ns);
@@ -925,11 +899,13 @@ struct ldlm_namespace *ldlm_namespace_new(struct obd_device *obd, char *name,
                GOTO(out_ref, NULL);
 
        ns->ns_rs_hash = cfs_hash_create(name,
-                                        nsd->nsd_all_bits, nsd->nsd_all_bits,
-                                        nsd->nsd_bkt_bits, 0,
+                                        ldlm_ns_hash_defs[ns_type].nsd_all_bits,
+                                        ldlm_ns_hash_defs[ns_type].nsd_all_bits,
+                                        ldlm_ns_hash_defs[ns_type].nsd_bkt_bits,
+                                        0,
                                         CFS_HASH_MIN_THETA,
                                         CFS_HASH_MAX_THETA,
-                                        nsd->nsd_hops,
+                                        &ldlm_ns_hash_ops,
                                         CFS_HASH_DEPTH |
                                         CFS_HASH_BIGNAME |
                                         CFS_HASH_SPIN_BKTLOCK |
@@ -937,7 +913,9 @@ struct ldlm_namespace *ldlm_namespace_new(struct obd_device *obd, char *name,
        if (ns->ns_rs_hash == NULL)
                GOTO(out_ns, NULL);
 
-       ns->ns_bucket_bits = nsd->nsd_all_bits - nsd->nsd_bkt_bits;
+       ns->ns_bucket_bits = ldlm_ns_hash_defs[ns_type].nsd_all_bits -
+                            ldlm_ns_hash_defs[ns_type].nsd_bkt_bits;
+
        OBD_ALLOC_LARGE(ns->ns_rs_buckets,
                        BIT(ns->ns_bucket_bits) * sizeof(ns->ns_rs_buckets[0]));
        if (!ns->ns_rs_buckets)
@@ -1078,11 +1056,10 @@ static void cleanup_resource(struct ldlm_resource *res, struct list_head *q,
                         */
                        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_flags & LDLM_FL_FAIL_LOC)
+                               schedule_timeout_uninterruptible(
+                                       cfs_time_seconds(4));
+
                        if (lock->l_completion_ast)
                                lock->l_completion_ast(lock,
                                                       LDLM_FL_FAILED, NULL);