Whamcloud - gitweb
git://git.whamcloud.com / fs / lustre-release.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
LU-8259 osd-ldiskfs update all *_seq_write() to use "const char __user *buffer"
[fs/lustre-release.git] / lustre / osd-ldiskfs / osd_lproc.c
diff --git a/lustre/osd-ldiskfs/osd_lproc.c b/lustre/osd-ldiskfs/osd_lproc.c
index 18a01a8..599d7e2 100644 (file)
--- a/lustre/osd-ldiskfs/osd_lproc.c
+++ b/lustre/osd-ldiskfs/osd_lproc.c
@@ -27,7 +27,7 @@
  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2011, 2014, Intel Corporation.
+ * Copyright (c) 2011, 2015, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -173,10 +173,11 @@ static int osd_brw_stats_seq_show(struct seq_file *seq, void *v)
         return 0;
 }
 
-static ssize_t osd_brw_stats_seq_write(struct file *file, const char *buf,
-                                       size_t len, loff_t *off)
+static ssize_t osd_brw_stats_seq_write(struct file *file,
+                                      const char __user *buf,
+                                      size_t len, loff_t *off)
 {
-        struct seq_file *seq = file->private_data;
+       struct seq_file *seq = file->private_data;
         struct osd_device *osd = seq->private;
         int i;
 
@@ -243,7 +244,8 @@ static int ldiskfs_osd_fstype_seq_show(struct seq_file *m, void *data)
        struct osd_device *osd = osd_dt_dev((struct dt_device *)m->private);
 
        LASSERT(osd != NULL);
-       return seq_printf(m, "ldiskfs\n");
+       seq_puts(m, "ldiskfs\n");
+       return 0;
 }
 LPROC_SEQ_FOPS_RO(ldiskfs_osd_fstype);
 
@@ -255,7 +257,8 @@ static int ldiskfs_osd_mntdev_seq_show(struct seq_file *m, void *data)
        if (unlikely(osd->od_mnt == NULL))
                return -EINPROGRESS;
 
-       return seq_printf(m, "%s\n", osd->od_mntdev);
+       seq_printf(m, "%s\n", osd->od_mntdev);
+       return 0;
 }
 LPROC_SEQ_FOPS_RO(ldiskfs_osd_mntdev);
 
@@ -267,23 +270,25 @@ static int ldiskfs_osd_cache_seq_show(struct seq_file *m, void *data)
        if (unlikely(osd->od_mnt == NULL))
                return -EINPROGRESS;
 
-       return seq_printf(m, "%u\n", osd->od_read_cache);
+       seq_printf(m, "%u\n", osd->od_read_cache);
+       return 0;
 }
 
 static ssize_t
-ldiskfs_osd_cache_seq_write(struct file *file, const char *buffer,
+ldiskfs_osd_cache_seq_write(struct file *file, const char __user *buffer,
                            size_t count, loff_t *off)
 {
-       struct seq_file   *m = file->private_data;
-       struct dt_device  *dt = m->private;
+       struct seq_file *m = file->private_data;
+       struct dt_device *dt = m->private;
        struct osd_device *osd = osd_dt_dev(dt);
-       int                val, rc;
+       int rc;
+       __s64 val;
 
        LASSERT(osd != NULL);
        if (unlikely(osd->od_mnt == NULL))
                return -EINPROGRESS;
 
-       rc = lprocfs_write_helper(buffer, count, &val);
+       rc = lprocfs_str_to_s64(buffer, count, &val);
        if (rc)
                return rc;
 
@@ -300,23 +305,25 @@ static int ldiskfs_osd_wcache_seq_show(struct seq_file *m, void *data)
        if (unlikely(osd->od_mnt == NULL))
                return -EINPROGRESS;
 
-       return seq_printf(m, "%u\n", osd->od_writethrough_cache);
+       seq_printf(m, "%u\n", osd->od_writethrough_cache);
+       return 0;
 }
 
 static ssize_t
-ldiskfs_osd_wcache_seq_write(struct file *file, const char *buffer,
+ldiskfs_osd_wcache_seq_write(struct file *file, const char __user *buffer,
                                size_t count, loff_t *off)
 {
-       struct seq_file   *m = file->private_data;
-       struct dt_device  *dt = m->private;
+       struct seq_file *m = file->private_data;
+       struct dt_device *dt = m->private;
        struct osd_device *osd = osd_dt_dev(dt);
-       int                val, rc;
+       int rc;
+       __s64 val;
 
        LASSERT(osd != NULL);
        if (unlikely(osd->od_mnt == NULL))
                return -EINPROGRESS;
 
-       rc = lprocfs_write_helper(buffer, count, &val);
+       rc = lprocfs_str_to_s64(buffer, count, &val);
        if (rc)
                return rc;
 
@@ -326,7 +333,7 @@ ldiskfs_osd_wcache_seq_write(struct file *file, const char *buffer,
 LPROC_SEQ_FOPS(ldiskfs_osd_wcache);
 
 static ssize_t
-lprocfs_osd_force_sync_seq_write(struct file *file, const char *buffer,
+lprocfs_osd_force_sync_seq_write(struct file *file, const char __user *buffer,
                                        size_t count, loff_t *off)
 {
        struct seq_file   *m = file->private_data;
@@ -351,22 +358,24 @@ LPROC_SEQ_FOPS_WO_TYPE(ldiskfs, osd_force_sync);
 
 static int ldiskfs_osd_pdo_seq_show(struct seq_file *m, void *data)
 {
-       return seq_printf(m, "%s\n", ldiskfs_pdo ? "ON" : "OFF");
+       seq_printf(m, "%s\n", ldiskfs_pdo ? "ON" : "OFF");
+       return 0;
 }
 
 static ssize_t
-ldiskfs_osd_pdo_seq_write(struct file *file, const char *buffer,
+ldiskfs_osd_pdo_seq_write(struct file *file, const char __user *buffer,
                                size_t count, loff_t *off)
 {
-       int pdo, rc;
+       int rc;
+       __s64 pdo;
 
-        rc = lprocfs_write_helper(buffer, count, &pdo);
-        if (rc != 0)
-                return rc;
+       rc = lprocfs_str_to_s64(buffer, count, &pdo);
+       if (rc != 0)
+               return rc;
 
-        ldiskfs_pdo = !!pdo;
+       ldiskfs_pdo = !!pdo;
 
-        return count;
+       return count;
 }
 LPROC_SEQ_FOPS(ldiskfs_osd_pdo);
 
@@ -378,23 +387,25 @@ static int ldiskfs_osd_auto_scrub_seq_show(struct seq_file *m, void *data)
        if (unlikely(dev->od_mnt == NULL))
                return -EINPROGRESS;
 
-       return seq_printf(m, "%d\n", !dev->od_noscrub);
+       seq_printf(m, "%d\n", !dev->od_noscrub);
+       return 0;
 }
 
 static ssize_t
-ldiskfs_osd_auto_scrub_seq_write(struct file *file, const char *buffer,
+ldiskfs_osd_auto_scrub_seq_write(struct file *file, const char __user *buffer,
                                        size_t count, loff_t *off)
 {
-       struct seq_file   *m = file->private_data;
-       struct dt_device  *dt = m->private;
+       struct seq_file *m = file->private_data;
+       struct dt_device *dt = m->private;
        struct osd_device *dev = osd_dt_dev(dt);
-       int val, rc;
+       int rc;
+       __s64 val;
 
        LASSERT(dev != NULL);
        if (unlikely(dev->od_mnt == NULL))
                return -EINPROGRESS;
 
-       rc = lprocfs_write_helper(buffer, count, &val);
+       rc = lprocfs_str_to_s64(buffer, count, &val);
        if (rc)
                return rc;
 
@@ -411,23 +422,26 @@ static int ldiskfs_osd_full_scrub_ratio_seq_show(struct seq_file *m, void *data)
        if (unlikely(dev->od_mnt == NULL))
                return -EINPROGRESS;
 
-       return seq_printf(m, LPU64"\n", dev->od_full_scrub_ratio);
+       seq_printf(m, LPU64"\n", dev->od_full_scrub_ratio);
+       return 0;
 }
 
 static ssize_t
-ldiskfs_osd_full_scrub_ratio_seq_write(struct file *file, const char *buffer,
+ldiskfs_osd_full_scrub_ratio_seq_write(struct file *file,
+                                      const char __user *buffer,
                                       size_t count, loff_t *off)
 {
-       struct seq_file   *m = file->private_data;
-       struct dt_device  *dt = m->private;
+       struct seq_file *m = file->private_data;
+       struct dt_device *dt = m->private;
        struct osd_device *dev = osd_dt_dev(dt);
-       int val, rc;
+       int rc;
+       __s64 val;
 
        LASSERT(dev != NULL);
        if (unlikely(dev->od_mnt == NULL))
                return -EINPROGRESS;
 
-       rc = lprocfs_write_helper(buffer, count, &val);
+       rc = lprocfs_str_to_s64(buffer, count, &val);
        if (rc != 0)
                return rc;
 
@@ -448,25 +462,27 @@ static int ldiskfs_osd_full_scrub_threshold_rate_seq_show(struct seq_file *m,
        if (unlikely(dev->od_mnt == NULL))
                return -EINPROGRESS;
 
-       return seq_printf(m, LPU64" (bad OI mappings/minute)\n",
-                         dev->od_full_scrub_threshold_rate);
+       seq_printf(m, LPU64" (bad OI mappings/minute)\n",
+                  dev->od_full_scrub_threshold_rate);
+       return 0;
 }
 
 static ssize_t
 ldiskfs_osd_full_scrub_threshold_rate_seq_write(struct file *file,
-                                               const char *buffer,
+                                               const char __user *buffer,
                                                size_t count, loff_t *off)
 {
-       struct seq_file   *m = file->private_data;
-       struct dt_device  *dt = m->private;
+       struct seq_file *m = file->private_data;
+       struct dt_device *dt = m->private;
        struct osd_device *dev = osd_dt_dev(dt);
-       int val, rc;
+       int rc;
+       __s64 val;
 
        LASSERT(dev != NULL);
        if (unlikely(dev->od_mnt == NULL))
                return -EINPROGRESS;
 
-       rc = lprocfs_write_helper(buffer, count, &val);
+       rc = lprocfs_str_to_s64(buffer, count, &val);
        if (rc != 0)
                return rc;
 
@@ -481,18 +497,19 @@ LPROC_SEQ_FOPS(ldiskfs_osd_full_scrub_threshold_rate);
 static int
 ldiskfs_osd_track_declares_assert_seq_show(struct seq_file *m, void *data)
 {
-       return seq_printf(m, "%d\n", ldiskfs_track_declares_assert);
+       seq_printf(m, "%d\n", ldiskfs_track_declares_assert);
+       return 0;
 }
 
 static ssize_t
 ldiskfs_osd_track_declares_assert_seq_write(struct file *file,
-                                               const char *buffer,
+                                               const char __user *buffer,
                                                size_t count, loff_t *off)
 {
-       int     track_declares_assert;
-       int     rc;
+       __s64 track_declares_assert;
+       int rc;
 
-       rc = lprocfs_write_helper(buffer, count, &track_declares_assert);
+       rc = lprocfs_str_to_s64(buffer, count, &track_declares_assert);
        if (rc != 0)
                return rc;
 
@@ -522,26 +539,29 @@ static int ldiskfs_osd_readcache_seq_show(struct seq_file *m, void *data)
        if (unlikely(osd->od_mnt == NULL))
                return -EINPROGRESS;
 
-       return seq_printf(m, LPU64"\n", osd->od_readcache_max_filesize);
+       seq_printf(m, LPU64"\n", osd->od_readcache_max_filesize);
+       return 0;
 }
 
 static ssize_t
-ldiskfs_osd_readcache_seq_write(struct file *file, const char *buffer,
+ldiskfs_osd_readcache_seq_write(struct file *file, const char __user *buffer,
                                size_t count, loff_t *off)
 {
-       struct seq_file   *m = file->private_data;
-       struct dt_device  *dt = m->private;
+       struct seq_file *m = file->private_data;
+       struct dt_device *dt = m->private;
        struct osd_device *osd = osd_dt_dev(dt);
-       __u64              val;
-       int                rc;
+       __s64 val;
+       int rc;
 
        LASSERT(osd != NULL);
        if (unlikely(osd->od_mnt == NULL))
                return -EINPROGRESS;
 
-       rc = lprocfs_write_u64_helper(buffer, count, &val);
+       rc = lprocfs_str_to_s64(buffer, count, &val);
        if (rc)
                return rc;
+       if (val < 0)
+               return -ERANGE;
 
        osd->od_readcache_max_filesize = val > OSD_MAX_CACHE_SIZE ?
                                         OSD_MAX_CACHE_SIZE : val;
@@ -558,26 +578,28 @@ static int ldiskfs_osd_index_in_idif_seq_show(struct seq_file *m, void *data)
        if (unlikely(dev->od_mnt == NULL))
                return -EINPROGRESS;
 
-       return seq_printf(m, "%d\n", (int)(dev->od_index_in_idif));
+       seq_printf(m, "%d\n", (int)(dev->od_index_in_idif));
+       return 0;
 }
 
 static ssize_t
-ldiskfs_osd_index_in_idif_seq_write(struct file *file, const char *buffer,
+ldiskfs_osd_index_in_idif_seq_write(struct file *file,
+                                   const char __user *buffer,
                                    size_t count, loff_t *off)
 {
-       struct lu_env            env;
-       struct seq_file         *m      = file->private_data;
-       struct dt_device        *dt     = m->private;
-       struct osd_device       *dev    = osd_dt_dev(dt);
-       struct lu_target        *tgt;
-       int                      val;
-       int                      rc;
+       struct lu_env env;
+       struct seq_file *m = file->private_data;
+       struct dt_device *dt = m->private;
+       struct osd_device *dev = osd_dt_dev(dt);
+       struct lu_target *tgt;
+       __s64 val;
+       int rc;
 
        LASSERT(dev != NULL);
        if (unlikely(dev->od_mnt == NULL))
                return -EINPROGRESS;
 
-       rc = lprocfs_write_helper(buffer, count, &val);
+       rc = lprocfs_str_to_s64(buffer, count, &val);
        if (rc != 0)
                return rc;
 
Lustre primary development and releases