Whamcloud - gitweb
git://git.whamcloud.com / fs / lustre-release.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
LU-6447 mdt: mdt_identity_upcall to not block with rwlock held
[fs/lustre-release.git] / lustre / mdt / mdt_lproc.c
diff --git a/lustre/mdt/mdt_lproc.c b/lustre/mdt/mdt_lproc.c
index 58728e8..5141394 100644 (file)
--- a/lustre/mdt/mdt_lproc.c
+++ b/lustre/mdt/mdt_lproc.c
@@ -217,7 +217,8 @@ static int mdt_identity_expire_seq_show(struct seq_file *m, void *data)
        struct obd_device *obd = m->private;
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-       return seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_entry_expire);
+       seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_entry_expire);
+       return 0;
 }
 
 static ssize_t
@@ -227,13 +228,17 @@ mdt_identity_expire_seq_write(struct file *file, const char __user *buffer,
        struct seq_file   *m = file->private_data;
        struct obd_device *obd = m->private;
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-       int rc, val;
+       int rc;
+       __s64 val;
 
-       rc = lprocfs_write_helper(buffer, count, &val);
+       rc = lprocfs_str_to_s64(buffer, count, &val);
        if (rc)
                return rc;
+       if (val < 0 || val > INT_MAX)
+               return -ERANGE;
 
        mdt->mdt_identity_cache->uc_entry_expire = val;
+
        return count;
 }
 LPROC_SEQ_FOPS(mdt_identity_expire);
@@ -243,7 +248,8 @@ static int mdt_identity_acquire_expire_seq_show(struct seq_file *m, void *data)
        struct obd_device *obd = m->private;
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-       return seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_acquire_expire);
+       seq_printf(m, "%u\n", mdt->mdt_identity_cache->uc_acquire_expire);
+       return 0;
 }
 
 static ssize_t
@@ -254,13 +260,17 @@ mdt_identity_acquire_expire_seq_write(struct file *file,
        struct seq_file   *m = file->private_data;
        struct obd_device *obd = m->private;
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-       int rc, val;
+       int rc;
+       __s64 val;
 
-       rc = lprocfs_write_helper(buffer, count, &val);
+       rc = lprocfs_str_to_s64(buffer, count, &val);
        if (rc)
                return rc;
+       if (val < 0 || val > INT_MAX)
+               return -ERANGE;
 
        mdt->mdt_identity_cache->uc_acquire_expire = val;
+
        return count;
 }
 LPROC_SEQ_FOPS(mdt_identity_acquire_expire);
@@ -271,9 +281,9 @@ static int mdt_identity_upcall_seq_show(struct seq_file *m, void *data)
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
        struct upcall_cache *hash = mdt->mdt_identity_cache;
 
-       read_lock(&hash->uc_upcall_rwlock);
+       down_read(&hash->uc_upcall_rwsem);
        seq_printf(m, "%s\n", hash->uc_upcall);
-       read_unlock(&hash->uc_upcall_rwlock);
+       up_read(&hash->uc_upcall_rwsem);
        return 0;
 }
 
@@ -299,9 +309,9 @@ mdt_identity_upcall_seq_write(struct file *file, const char __user *buffer,
                GOTO(failed, rc = -EFAULT);
 
        /* Remove any extraneous bits from the upcall (e.g. linefeeds) */
-       write_lock(&hash->uc_upcall_rwlock);
+       down_write(&hash->uc_upcall_rwsem);
        sscanf(kernbuf, "%s", hash->uc_upcall);
-       write_unlock(&hash->uc_upcall_rwlock);
+       up_write(&hash->uc_upcall_rwsem);
 
        if (strcmp(hash->uc_name, mdt_obd_name(mdt)) != 0)
                CWARN("%s: write to upcall name %s\n",
@@ -330,11 +340,14 @@ lprocfs_identity_flush_seq_write(struct file *file, const char __user *buffer,
        struct seq_file   *m = file->private_data;
        struct obd_device *obd = m->private;
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-       int rc, uid;
+       int rc;
+       __s64 uid;
 
-       rc = lprocfs_write_helper(buffer, count, &uid);
+       rc = lprocfs_str_to_s64(buffer, count, &uid);
        if (rc)
                return rc;
+       if (uid < INT_MIN || uid > INT_MAX)
+               return -ERANGE;
 
        mdt_flush_identity(mdt->mdt_identity_cache, uid);
        return count;
@@ -479,7 +492,8 @@ static int mdt_evict_tgt_nids_seq_show(struct seq_file *m, void *data)
        struct obd_device *obd = m->private;
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-       return seq_printf(m, "%u\n", mdt->mdt_opts.mo_evict_tgt_nids);
+       seq_printf(m, "%u\n", mdt->mdt_opts.mo_evict_tgt_nids);
+       return 0;
 }
 
 static ssize_t
@@ -489,9 +503,10 @@ mdt_evict_tgt_nids_seq_write(struct file *file, const char __user *buffer,
        struct seq_file   *m = file->private_data;
        struct obd_device *obd = m->private;
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-       int val, rc;
+       __s64 val;
+       int rc;
 
-       rc = lprocfs_write_helper(buffer, count, &val);
+       rc = lprocfs_str_to_s64(buffer, count, &val);
        if (rc)
                return rc;
        mdt->mdt_opts.mo_evict_tgt_nids = !!val;
@@ -499,48 +514,13 @@ mdt_evict_tgt_nids_seq_write(struct file *file, const char __user *buffer,
 }
 LPROC_SEQ_FOPS(mdt_evict_tgt_nids);
 
-
-static int mdt_sec_level_seq_show(struct seq_file *m, void *data)
-{
-       struct obd_device *obd = m->private;
-       struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-
-       return seq_printf(m, "%d\n", mdt->mdt_lut.lut_sec_level);
-}
-
-static ssize_t
-mdt_sec_level_seq_write(struct file *file, const char __user *buffer,
-                       size_t count, loff_t *off)
-{
-       struct seq_file   *m = file->private_data;
-       struct obd_device *obd = m->private;
-       struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-       int val, rc;
-
-        rc = lprocfs_write_helper(buffer, count, &val);
-        if (rc)
-                return rc;
-
-        if (val > LUSTRE_SEC_ALL || val < LUSTRE_SEC_NONE)
-                return -EINVAL;
-
-        if (val == LUSTRE_SEC_SPECIFY) {
-                CWARN("security level %d will be supported in future.\n",
-                      LUSTRE_SEC_SPECIFY);
-                return -EINVAL;
-        }
-
-       mdt->mdt_lut.lut_sec_level = val;
-       return count;
-}
-LPROC_SEQ_FOPS(mdt_sec_level);
-
 static int mdt_cos_seq_show(struct seq_file *m, void *data)
 {
        struct obd_device *obd = m->private;
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-       return seq_printf(m, "%u\n", mdt_cos_is_enabled(mdt));
+       seq_printf(m, "%u\n", mdt_cos_is_enabled(mdt));
+       return 0;
 }
 
 static ssize_t
@@ -550,11 +530,15 @@ mdt_cos_seq_write(struct file *file, const char __user *buffer,
        struct seq_file   *m = file->private_data;
        struct obd_device *obd = m->private;
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-       int val, rc;
+       int rc;
+       __s64 val;
 
-       rc = lprocfs_write_helper(buffer, count, &val);
+       rc = lprocfs_str_to_s64(buffer, count, &val);
        if (rc)
                return rc;
+       if (val < INT_MIN || val > INT_MAX)
+               return -ERANGE;
+
        mdt_enable_cos(mdt, val);
        return count;
 }
@@ -566,8 +550,9 @@ static int mdt_root_squash_seq_show(struct seq_file *m, void *data)
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
        struct root_squash_info *squash = &mdt->mdt_squash;
 
-       return seq_printf(m, "%u:%u\n", squash->rsi_uid,
-                         squash->rsi_gid);
+       seq_printf(m, "%u:%u\n", squash->rsi_uid,
+                  squash->rsi_gid);
+       return 0;
 }
 
 static ssize_t
@@ -589,19 +574,19 @@ static int mdt_nosquash_nids_seq_show(struct seq_file *m, void *data)
        struct obd_device *obd = m->private;
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
        struct root_squash_info *squash = &mdt->mdt_squash;
-       int len = 0, rc;
+       int len = 0;
 
        down_read(&squash->rsi_sem);
        if (!list_empty(&squash->rsi_nosquash_nids)) {
                len = cfs_print_nidlist(m->buf + m->count, m->size - m->count,
                                        &squash->rsi_nosquash_nids);
                m->count += len;
-               rc = seq_printf(m, "\n");
+               seq_putc(m, '\n');
        } else
-               rc = seq_printf(m, "NONE\n");
+               seq_puts(m, "NONE\n");
        up_read(&squash->rsi_sem);
 
-       return rc;
+       return 0;
 }
 
 static ssize_t
@@ -623,7 +608,8 @@ static int mdt_enable_remote_dir_seq_show(struct seq_file *m, void *data)
        struct obd_device *obd = m->private;
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-       return seq_printf(m, "%u\n", mdt->mdt_enable_remote_dir);
+       seq_printf(m, "%u\n", mdt->mdt_enable_remote_dir);
+       return 0;
 }
 
 static ssize_t
@@ -633,14 +619,14 @@ mdt_enable_remote_dir_seq_write(struct file *file, const char __user *buffer,
        struct seq_file   *m = file->private_data;
        struct obd_device *obd = m->private;
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-       __u32 val;
+       __s64 val;
        int rc;
 
-       rc = lprocfs_write_helper(buffer, count, &val);
+       rc = lprocfs_str_to_s64(buffer, count, &val);
        if (rc)
                return rc;
 
-       if (val > 1)
+       if (val > 1 || val < 0)
                return -ERANGE;
 
        mdt->mdt_enable_remote_dir = val;
@@ -653,8 +639,9 @@ static int mdt_enable_remote_dir_gid_seq_show(struct seq_file *m, void *data)
        struct obd_device *obd = m->private;
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-       return seq_printf(m, "%d\n",
-                         (int)mdt->mdt_enable_remote_dir_gid);
+       seq_printf(m, "%d\n",
+                 (int)mdt->mdt_enable_remote_dir_gid);
+       return 0;
 }
 
 static ssize_t
@@ -665,10 +652,10 @@ mdt_enable_remote_dir_gid_seq_write(struct file *file,
        struct seq_file   *m = file->private_data;
        struct obd_device *obd = m->private;
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-       __u32 val;
+       __s64 val;
        int rc;
 
-       rc = lprocfs_write_helper(buffer, count, &val);
+       rc = lprocfs_str_to_s64(buffer, count, &val);
        if (rc)
                return rc;
 
@@ -692,7 +679,8 @@ static int mdt_slc_seq_show(struct seq_file *m, void *data)
        struct lu_target *tgt = obd->u.obt.obt_lut;
        char *slc_states[] = {"never", "blocking", "always" };
 
-       return seq_printf(m, "%s\n", slc_states[tgt->lut_sync_lock_cancel]);
+       seq_printf(m, "%s\n", slc_states[tgt->lut_sync_lock_cancel]);
+       return 0;
 }
 LPROC_SEQ_FOPS_RO(mdt_slc);
 
@@ -710,7 +698,8 @@ static int mdt_async_commit_count_seq_show(struct seq_file *m, void *data)
        struct obd_device *obd = m->private;
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
 
-       return seq_printf(m, "%d\n", atomic_read(&mdt->mdt_async_commit_count));
+       seq_printf(m, "%d\n", atomic_read(&mdt->mdt_async_commit_count));
+       return 0;
 }
 
 static ssize_t
@@ -720,13 +709,16 @@ mdt_async_commit_count_seq_write(struct file *file, const char __user *buffer,
        struct seq_file *m = file->private_data;
        struct obd_device *obd = m->private;
        struct mdt_device *mdt = mdt_dev(obd->obd_lu_dev);
-       int val;
+       __s64 val;
        int rc;
 
-       rc = lprocfs_write_helper(buffer, count, &val);
+       rc = lprocfs_str_to_s64(buffer, count, &val);
        if (rc)
                return rc;
 
+       if (val < INT_MIN || val > INT_MAX)
+               return -ERANGE;
+
        atomic_set(&mdt->mdt_async_commit_count, val);
 
        return count;
@@ -747,7 +739,8 @@ static int mdt_sync_count_seq_show(struct seq_file *m, void *data)
        struct obd_device *obd = m->private;
        struct lu_target *tgt = obd->u.obt.obt_lut;
 
-       return seq_printf(m, "%d\n", atomic_read(&tgt->lut_sync_count));
+       seq_printf(m, "%d\n", atomic_read(&tgt->lut_sync_count));
+       return 0;
 }
 
 static ssize_t
@@ -757,13 +750,16 @@ mdt_sync_count_seq_write(struct file *file, const char __user *buffer,
        struct seq_file *m = file->private_data;
        struct obd_device *obd = m->private;
        struct lu_target *tgt = obd->u.obt.obt_lut;
-       int val;
+       __s64 val;
        int rc;
 
-       rc = lprocfs_write_helper(buffer, count, &val);
+       rc = lprocfs_str_to_s64(buffer, count, &val);
        if (rc)
                return rc;
 
+       if (val < INT_MIN || val > INT_MAX)
+               return -ERANGE;
+
        atomic_set(&tgt->lut_sync_count, val);
 
        return count;
@@ -810,8 +806,6 @@ static struct lprocfs_vars lprocfs_mdt_obd_vars[] = {
          .fops =       &mdt_evict_tgt_nids_fops                },
        { .name =       "hash_stats",
          .fops =       &mdt_hash_fops                          },
-       { .name =       "sec_level",
-         .fops =       &mdt_sec_level_fops                     },
        { .name =       "commit_on_sharing",
          .fops =       &mdt_cos_fops                           },
        { .name =       "root_squash",
Lustre primary development and releases