* Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2012, Intel Corporation.
+ * Copyright (c) 2011, 2014, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#define DEBUG_SUBSYSTEM S_CLASS
-#ifdef __KERNEL__
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <asm/uaccess.h>
#include <linux/miscdevice.h>
#include <linux/seq_file.h>
-#else
-# include <liblustre.h>
-#endif
#include <libcfs/libcfs.h>
#include <obd_support.h>
#include <obd_class.h>
#include <lnet/lnetctl.h>
#include <lprocfs_status.h>
+#include <lustre_ioctl.h>
#include <lustre_ver.h>
-#include <lustre/lustre_build_version.h>
-#ifdef __KERNEL__
int proc_version;
/* buffer MUST be at least the size of obd_ioctl_hdr */
-int obd_ioctl_getdata(char **buf, int *len, void *arg)
+int obd_ioctl_getdata(char **buf, int *len, void __user *arg)
{
- struct obd_ioctl_hdr hdr;
- struct obd_ioctl_data *data;
- int err;
- int offset = 0;
- ENTRY;
+ struct obd_ioctl_hdr hdr;
+ struct obd_ioctl_data *data;
+ int offset = 0;
+ ENTRY;
- err = copy_from_user(&hdr, (void *)arg, sizeof(hdr));
- if ( err )
- RETURN(err);
+ if (copy_from_user(&hdr, arg, sizeof(hdr)))
+ RETURN(-EFAULT);
if (hdr.ioc_version != OBD_IOCTL_VERSION) {
CERROR("Version mismatch kernel (%x) vs application (%x)\n",
*len = hdr.ioc_len;
data = (struct obd_ioctl_data *)*buf;
- err = copy_from_user(*buf, (void *)arg, hdr.ioc_len);
- if ( err ) {
- OBD_FREE_LARGE(*buf, hdr.ioc_len);
- RETURN(err);
- }
+ if (copy_from_user(*buf, arg, hdr.ioc_len)) {
+ OBD_FREE_LARGE(*buf, hdr.ioc_len);
+ RETURN(-EFAULT);
+ }
if (obd_ioctl_is_invalid(data)) {
CERROR("ioctl not correctly formatted\n");
offset += cfs_size_round(data->ioc_inllen3);
}
- if (data->ioc_inllen4) {
- data->ioc_inlbuf4 = &data->ioc_bulk[0] + offset;
- }
+ if (data->ioc_inllen4)
+ data->ioc_inlbuf4 = &data->ioc_bulk[0] + offset;
- EXIT;
- return 0;
+ RETURN(0);
}
EXPORT_SYMBOL(obd_ioctl_getdata);
-int obd_ioctl_popdata(void *arg, void *data, int len)
+int obd_ioctl_popdata(void __user *arg, void *data, int len)
{
int err;
+ ENTRY;
- err = copy_to_user(arg, data, len);
- if (err)
- err = -EFAULT;
- return err;
+ err = copy_to_user(arg, data, len) ? -EFAULT : 0;
+ RETURN(err);
}
-EXPORT_SYMBOL(obd_ioctl_popdata);
/* opening /dev/obd */
static int obd_class_open(struct inode * inode, struct file * file)
.fops = &obd_psdev_fops,
};
-#endif
-#ifdef LPROCFS
+#ifdef CONFIG_PROC_FS
static int obd_proc_version_seq_show(struct seq_file *m, void *v)
{
- return seq_printf(m, "lustre: %s\nkernel: %s\nbuild: %s\n",
- LUSTRE_VERSION_STRING, "patchless_client",
- BUILD_VERSION);
+ seq_printf(m, "lustre: %s", LUSTRE_VERSION_STRING);
+ return 0;
}
LPROC_SEQ_FOPS_RO(obd_proc_version);
static int obd_proc_pinger_seq_show(struct seq_file *m, void *v)
{
- return seq_printf(m, "%s\n",
+ seq_printf(m, "%s\n",
#ifdef ENABLE_PINGER
- "on"
+ "on"
#else
- "off"
+ "off"
#endif
- );
+ );
+ return 0;
}
LPROC_SEQ_FOPS_RO(obd_proc_pinger);
bool healthy = true;
int i;
- if (libcfs_catastrophe)
+ if (libcfs_catastrophe) {
seq_printf(m, "LBUG\n");
+ healthy = false;
+ }
read_lock(&obd_dev_lock);
for (i = 0; i < class_devno_max(); i++) {
if (obd_health_check(NULL, obd)) {
seq_printf(m, "device %s reported unhealthy\n",
- obd->obd_name);
+ obd->obd_name);
healthy = false;
}
class_decref(obd, __FUNCTION__, current);
read_unlock(&obd_dev_lock);
if (healthy)
- return seq_printf(m, "healthy\n");
-
- seq_printf(m, "NOT HEALTHY\n");
+ seq_puts(m, "healthy\n");
+ else
+ seq_puts(m, "NOT HEALTHY\n");
return 0;
}
LPROC_SEQ_FOPS_RO(obd_proc_health);
static int obd_proc_jobid_var_seq_show(struct seq_file *m, void *v)
{
- return seq_printf(m, "%s\n", obd_jobid_var);
+ if (strlen(obd_jobid_var) != 0)
+ seq_printf(m, "%s\n", obd_jobid_var);
+ return 0;
}
static ssize_t
-obd_proc_jobid_var_seq_write(struct file *file, const char *buffer,
- size_t count, loff_t *off)
+obd_proc_jobid_var_seq_write(struct file *file, const char __user *buffer,
+ size_t count, loff_t *off)
{
if (!count || count > JOBSTATS_JOBID_VAR_MAX_LEN)
return -EINVAL;
memset(obd_jobid_var, 0, JOBSTATS_JOBID_VAR_MAX_LEN + 1);
+
+ /* This might leave the var invalid on error, which is probably fine.*/
+ if (copy_from_user(obd_jobid_var, buffer, count))
+ return -EFAULT;
+
/* Trim the trailing '\n' if any */
- memcpy(obd_jobid_var, buffer, count - (buffer[count - 1] == '\n'));
+ if (obd_jobid_var[count - 1] == '\n')
+ obd_jobid_var[count - 1] = 0;
+
return count;
}
LPROC_SEQ_FOPS(obd_proc_jobid_var);
+static int obd_proc_jobid_name_seq_show(struct seq_file *m, void *v)
+{
+ if (strlen(obd_jobid_node) != 0)
+ seq_printf(m, "%s\n", obd_jobid_node);
+ return 0;
+}
+
+static ssize_t obd_proc_jobid_name_seq_write(struct file *file,
+ const char __user *buffer,
+ size_t count, loff_t *off)
+{
+ if (count == 0 || count > LUSTRE_JOBID_SIZE)
+ return -EINVAL;
+
+ /* clear previous value */
+ memset(obd_jobid_node, 0, LUSTRE_JOBID_SIZE);
+
+ if (copy_from_user(obd_jobid_node, buffer, count))
+ return -EFAULT;
+
+ /* Trim the trailing '\n' if any */
+ if (obd_jobid_node[count - 1] == '\n') {
+ /* Don't echo just a newline */
+ if (count == 1)
+ return -EINVAL;
+ obd_jobid_node[count - 1] = 0;
+ }
+
+ return count;
+}
+LPROC_SEQ_FOPS(obd_proc_jobid_name);
+
/* Root for /proc/fs/lustre */
struct proc_dir_entry *proc_lustre_root = NULL;
EXPORT_SYMBOL(proc_lustre_root);
-struct lprocfs_seq_vars lprocfs_base[] = {
+static struct lprocfs_vars lprocfs_base[] = {
{ .name = "version",
.fops = &obd_proc_version_fops },
{ .name = "pinger",
.fops = &obd_proc_health_fops },
{ .name = "jobid_var",
.fops = &obd_proc_jobid_var_fops},
- { 0 }
+ { .name = "jobid_name",
+ .fops = &obd_proc_jobid_name_fops},
+ { NULL }
};
#else
#define lprocfs_base NULL
-#endif /* LPROCFS */
+#endif /* CONFIG_PROC_FS */
-#ifdef __KERNEL__
static void *obd_device_list_seq_start(struct seq_file *p, loff_t *pos)
{
if (*pos >= class_devno_max())
else
status = "--";
- return seq_printf(p, "%3d %s %s %s %s %d\n",
- (int)index, status, obd->obd_type->typ_name,
- obd->obd_name, obd->obd_uuid.uuid,
- atomic_read(&obd->obd_refcount));
+ seq_printf(p, "%3d %s %s %s %s %d\n",
+ (int)index, status, obd->obd_type->typ_name,
+ obd->obd_name, obd->obd_uuid.uuid,
+ atomic_read(&obd->obd_refcount));
+ return 0;
}
-struct seq_operations obd_device_list_sops = {
+static const struct seq_operations obd_device_list_sops = {
.start = obd_device_list_seq_start,
.stop = obd_device_list_seq_stop,
.next = obd_device_list_seq_next,
return 0;
}
-struct file_operations obd_device_list_fops = {
+static const struct file_operations obd_device_list_fops = {
.owner = THIS_MODULE,
.open = obd_device_list_open,
.read = seq_read,
.llseek = seq_lseek,
.release = seq_release,
};
-#endif
int class_procfs_init(void)
{
-#ifdef __KERNEL__
+ struct proc_dir_entry *entry;
int rc;
ENTRY;
obd_sysctl_init();
- proc_lustre_root = lprocfs_seq_register("fs/lustre", NULL,
- lprocfs_base, NULL);
+
+ entry = lprocfs_register("fs/lustre", NULL, lprocfs_base, NULL);
+ if (IS_ERR(entry)) {
+ rc = PTR_ERR(entry);
+ CERROR("cannot create '/proc/fs/lustre': rc = %d\n", rc);
+ RETURN(rc);
+ }
+
+ proc_lustre_root = entry;
+
rc = lprocfs_seq_create(proc_lustre_root, "devices", 0444,
&obd_device_list_fops, NULL);
- if (rc)
- CERROR("error adding /proc/fs/lustre/devices file\n");
-#else
- ENTRY;
-#endif
- RETURN(0);
+ if (rc < 0) {
+ CERROR("cannot create '/proc/fs/lustre/devices': rc = %d\n",
+ rc);
+ GOTO(out_proc, rc);
+ }
+
+ RETURN(rc);
+
+out_proc:
+ lprocfs_remove(&proc_lustre_root);
+
+ RETURN(rc);
}
-#ifdef __KERNEL__
int class_procfs_clean(void)
{
ENTRY;
}
RETURN(0);
}
-#endif