LU-6401 headers: Create single .h for lu_seq_range

[fs/lustre-release.git] / lustre / fid / lproc_fid.c

diff --git a/lustre/fid/lproc_fid.c b/lustre/fid/lproc_fid.c
index 3b9d170..2f7c670 100644 (file)
--- a/lustre/fid/lproc_fid.c
+++ b/lustre/fid/lproc_fid.c
@@ -27,7 +27,7 @@
  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2011, 2013, Intel Corporation.
+ * Copyright (c) 2011, 2014, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
@@ -50,9 +50,11 @@
 #include <lustre_fid.h>
 #include <lprocfs_status.h>
 #include "fid_internal.h"
-#include <md_object.h>
 
-#ifdef LPROCFS
+#ifdef CONFIG_PROC_FS
+
+/* Format: [0x64BIT_INT - 0x64BIT_INT] + 32 bytes just in case */
+#define MAX_FID_RANGE_STRLEN (32 + 2 * 2 * sizeof(__u64))
 /**
  * Reduce the SEQ range allocated to a node to a strict subset of the range
  * currently-allocated SEQ range.  If the specified range is "clear", then
@@ -62,25 +64,34 @@
  * safe for production use.
  */
 static int
-lprocfs_fid_write_common(const char *buffer, unsigned long count,
+lprocfs_fid_write_common(const char __user *buffer, size_t count,
                                struct lu_seq_range *range)
 {
        struct lu_seq_range tmp = { 0, };
        int rc;
+       char kernbuf[MAX_FID_RANGE_STRLEN];
        ENTRY;
 
        LASSERT(range != NULL);
 
-       if (count == 5 && strcmp(buffer, "clear") == 0) {
+       if (count >= sizeof(kernbuf))
+               RETURN(-EINVAL);
+
+       if (copy_from_user(kernbuf, buffer, count))
+               RETURN(-EFAULT);
+
+       kernbuf[count] = 0;
+
+       if (count == 5 && strcmp(kernbuf, "clear") == 0) {
                memset(range, 0, sizeof(*range));
                RETURN(0);
        }
 
        /* of the form "[0x0000000240000400 - 0x000000028000400]" */
-       rc = sscanf(buffer, "[%llx - %llx]\n",
+       rc = sscanf(kernbuf, "[%llx - %llx]\n",
                    (long long unsigned *)&tmp.lsr_start,
                    (long long unsigned *)&tmp.lsr_end);
-       if (!range_is_sane(&tmp) || range_is_zero(&tmp) ||
+       if (!lu_seq_range_is_sane(&tmp) || lu_seq_range_is_zero(&tmp) ||
            tmp.lsr_start < range->lsr_start || tmp.lsr_end > range->lsr_end)
                RETURN(-EINVAL);
        *range = tmp;
@@ -92,7 +103,7 @@ lprocfs_fid_write_common(const char *buffer, unsigned long count,
  * Server side procfs stuff.
  */
 static ssize_t
-lprocfs_server_fid_space_seq_write(struct file *file, const char *buffer,
+lprocfs_server_fid_space_seq_write(struct file *file, const char __user *buffer,
                                        size_t count, loff_t *off)
 {
        struct lu_server_seq *seq = ((struct seq_file *)file->private_data)->private;
@@ -155,7 +166,7 @@ lprocfs_server_fid_server_seq_show(struct seq_file *m, void *unused)
 }
 
 static ssize_t
-lprocfs_server_fid_width_seq_write(struct file *file, const char *buffer,
+lprocfs_server_fid_width_seq_write(struct file *file, const char __user *buffer,
                                        size_t count, loff_t *off)
 {
        struct lu_server_seq *seq = ((struct seq_file *)file->private_data)->private;
@@ -202,7 +213,7 @@ LPROC_SEQ_FOPS(lprocfs_server_fid_space);
 LPROC_SEQ_FOPS(lprocfs_server_fid_width);
 LPROC_SEQ_FOPS_RO(lprocfs_server_fid_server);
 
-struct lprocfs_seq_vars seq_server_proc_list[] = {
+struct lprocfs_vars seq_server_proc_list[] = {
        { .name =       "space",
          .fops =       &lprocfs_server_fid_space_fops  },
        { .name =       "width",
@@ -350,7 +361,10 @@ static int fldb_seq_open(struct inode *inode, struct file *file)
        fld = ss->lss_site->ss_server_fld;
        LASSERT(fld != NULL);
 
-       LPROCFS_ENTRY_CHECK(PDE(inode));
+       rc = LPROCFS_ENTRY_CHECK(inode);
+       if (rc < 0)
+               return rc;
+
        rc = seq_open(file, &fldb_sops);
        if (rc)
                return rc;
@@ -372,7 +386,7 @@ static int fldb_seq_open(struct inode *inode, struct file *file)
 
        env_init = 1;
        iops = &obj->do_index_ops->dio_it;
-       param->fsp_it = iops->init(&param->fsp_env, obj, 0, NULL);
+       param->fsp_it = iops->init(&param->fsp_env, obj, 0);
        if (IS_ERR(param->fsp_it))
                GOTO(out, rc = PTR_ERR(param->fsp_it));
 
@@ -421,26 +435,27 @@ static int fldb_seq_release(struct inode *inode, struct file *file)
        return 0;
 }
 
-static ssize_t fldb_seq_write(struct file *file, const char *buf,
+static ssize_t fldb_seq_write(struct file *file, const char __user *buf,
                              size_t len, loff_t *off)
 {
        struct seq_file         *seq = file->private_data;
        struct fld_seq_param    *param;
        struct lu_seq_range      range;
        int                      rc = 0;
-       char                    *buffer, *_buffer;
+       char                     _buffer[MAX_FID_RANGE_STRLEN];
+       char                    *buffer = _buffer;
        ENTRY;
 
        param = seq->private;
        if (param == NULL)
                RETURN(-EINVAL);
 
-       OBD_ALLOC(buffer, len + 1);
-       if (buffer == NULL)
-               RETURN(-ENOMEM);
-       memcpy(buffer, buf, len);
+       if (len >= sizeof(_buffer))
+               RETURN(-EINVAL);
+
+       if (copy_from_user(buffer, buf, len))
+               GOTO(out, rc = -EFAULT);
        buffer[len] = 0;
-       _buffer = buffer;
 
        /*
         * format - [0x0000000200000007-0x0000000200000008):0:mdt
@@ -478,7 +493,6 @@ static ssize_t fldb_seq_write(struct file *file, const char *buf,
                                   &range, &param->fsp_env);
 
 out:
-       OBD_FREE(_buffer, len + 1);
        RETURN(rc < 0 ? rc : len);
 }
 
@@ -494,7 +508,7 @@ const struct file_operations seq_fld_proc_seq_fops = {
 
 /* Client side procfs stuff */
 static ssize_t
-lprocfs_client_fid_space_seq_write(struct file *file, const char *buffer,
+lprocfs_client_fid_space_seq_write(struct file *file, const char __user *buffer,
                                   size_t count, loff_t *off)
 {
        struct lu_client_seq *seq = ((struct seq_file *)file->private_data)->private;
@@ -533,7 +547,7 @@ lprocfs_client_fid_space_seq_show(struct seq_file *m, void *unused)
 }
 
 static ssize_t
-lprocfs_client_fid_width_seq_write(struct file *file, const char *buffer,
+lprocfs_client_fid_width_seq_write(struct file *file, const char __user *buffer,
                                   size_t count, loff_t *off)
 {
        struct lu_client_seq *seq = ((struct seq_file *)file->private_data)->private;
@@ -559,10 +573,8 @@ lprocfs_client_fid_width_seq_write(struct file *file, const char *buffer,
        if (val <= max && val > 0) {
                seq->lcs_width = val;
 
-               if (rc == 0) {
-                       CDEBUG(D_INFO, "%s: Sequence size: "LPU64"\n",
-                              seq->lcs_name, seq->lcs_width);
-               }
+               CDEBUG(D_INFO, "%s: Sequence size: "LPU64"\n",
+                      seq->lcs_name, seq->lcs_width);
        }
        mutex_unlock(&seq->lcs_mutex);
 
@@ -625,7 +637,7 @@ LPROC_SEQ_FOPS(lprocfs_client_fid_width);
 LPROC_SEQ_FOPS_RO(lprocfs_client_fid_server);
 LPROC_SEQ_FOPS_RO(lprocfs_client_fid_fid);
 
-struct lprocfs_seq_vars seq_client_proc_list[] = {
+struct lprocfs_vars seq_client_proc_list[] = {
        { .name =       "space",
          .fops =       &lprocfs_client_fid_space_fops  },
        { .name =       "width",
@@ -636,4 +648,5 @@ struct lprocfs_seq_vars seq_client_proc_list[] = {
          .fops =       &lprocfs_client_fid_fid_fops    },
        { NULL }
 };
-#endif
+
+#endif /* CONFIG_PROC_FS */