*/
/*
* This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
*/
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <libcfs/libcfs.h>
#include <libcfs/libcfs_crypto.h>
#include <lnet/lib-lnet.h>
+#include <libcfs/crypto/llcrypt.h>
#include "tracefile.h"
+struct lnet_debugfs_symlink_def {
+ const char *name;
+ const char *target;
+};
+
static struct dentry *lnet_debugfs_root;
BLOCKING_NOTIFIER_HEAD(libcfs_ioctl_list);
EXPORT_SYMBOL(libcfs_ioctl_list);
-int libcfs_ioctl(unsigned long cmd, void __user *uparam)
+static inline size_t libcfs_ioctl_packlen(struct libcfs_ioctl_data *data)
+{
+ size_t len = sizeof(*data);
+
+ len += (data->ioc_inllen1 + 7) & ~7;
+ len += (data->ioc_inllen2 + 7) & ~7;
+ return len;
+}
+
+static bool libcfs_ioctl_is_invalid(struct libcfs_ioctl_data *data)
+{
+ const int maxlen = 1 << 30;
+ if (data->ioc_hdr.ioc_len > maxlen)
+ return true;
+
+ if (data->ioc_inllen1 > maxlen)
+ return true;
+
+ if (data->ioc_inllen2 > maxlen)
+ return true;
+
+ if (data->ioc_inlbuf1 && !data->ioc_inllen1)
+ return true;
+
+ if (data->ioc_inlbuf2 && !data->ioc_inllen2)
+ return true;
+
+ if (data->ioc_pbuf1 && !data->ioc_plen1)
+ return true;
+
+ if (data->ioc_pbuf2 && !data->ioc_plen2)
+ return true;
+
+ if (data->ioc_plen1 && !data->ioc_pbuf1)
+ return true;
+
+ if (data->ioc_plen2 && !data->ioc_pbuf2)
+ return true;
+
+ if (libcfs_ioctl_packlen(data) != data->ioc_hdr.ioc_len)
+ return true;
+
+ if (data->ioc_inllen1 &&
+ data->ioc_bulk[((data->ioc_inllen1 + 7) & ~7) +
+ data->ioc_inllen2 - 1] != '\0')
+ return true;
+
+ return false;
+}
+
+int libcfs_ioctl_data_adjust(struct libcfs_ioctl_data *data)
+{
+ ENTRY;
+
+ if (libcfs_ioctl_is_invalid(data)) {
+ CERROR("libcfs ioctl: parameter not correctly formatted\n");
+ RETURN(-EINVAL);
+ }
+
+ if (data->ioc_inllen1 != 0)
+ data->ioc_inlbuf1 = &data->ioc_bulk[0];
+
+ if (data->ioc_inllen2 != 0)
+ data->ioc_inlbuf2 = &data->ioc_bulk[0] +
+ cfs_size_round(data->ioc_inllen1);
+
+ RETURN(0);
+}
+
+int libcfs_ioctl_getdata(struct libcfs_ioctl_hdr **hdr_pp,
+ struct libcfs_ioctl_hdr __user *uhdr)
+{
+ struct libcfs_ioctl_hdr hdr;
+ int err;
+
+ ENTRY;
+ if (copy_from_user(&hdr, uhdr, sizeof(hdr)))
+ RETURN(-EFAULT);
+
+ if (hdr.ioc_version != LIBCFS_IOCTL_VERSION &&
+ hdr.ioc_version != LIBCFS_IOCTL_VERSION2) {
+ CERROR("libcfs ioctl: version mismatch expected %#x, got %#x\n",
+ LIBCFS_IOCTL_VERSION, hdr.ioc_version);
+ RETURN(-EINVAL);
+ }
+
+ if (hdr.ioc_len < sizeof(struct libcfs_ioctl_hdr)) {
+ CERROR("libcfs ioctl: user buffer too small for ioctl\n");
+ RETURN(-EINVAL);
+ }
+
+ if (hdr.ioc_len > LIBCFS_IOC_DATA_MAX) {
+ CERROR("libcfs ioctl: user buffer is too large %d/%d\n",
+ hdr.ioc_len, LIBCFS_IOC_DATA_MAX);
+ RETURN(-EINVAL);
+ }
+
+ LIBCFS_ALLOC(*hdr_pp, hdr.ioc_len);
+ if (*hdr_pp == NULL)
+ RETURN(-ENOMEM);
+
+ if (copy_from_user(*hdr_pp, uhdr, hdr.ioc_len))
+ GOTO(free, err = -EFAULT);
+
+ if ((*hdr_pp)->ioc_version != hdr.ioc_version ||
+ (*hdr_pp)->ioc_len != hdr.ioc_len) {
+ GOTO(free, err = -EINVAL);
+ }
+
+ RETURN(0);
+
+free:
+ LIBCFS_FREE(*hdr_pp, hdr.ioc_len);
+ RETURN(err);
+}
+
+static int libcfs_ioctl(unsigned long cmd, void __user *uparam)
{
struct libcfs_ioctl_data *data = NULL;
struct libcfs_ioctl_hdr *hdr;
err = -EINVAL;
else
err = notifier_to_errno(err);
- if (!err)
- if (copy_to_user(uparam, hdr, hdr->ioc_len))
- err = -EFAULT;
+ if (copy_to_user(uparam, hdr, hdr->ioc_len) && !err)
+ err = -EFAULT;
break;
}
out:
RETURN(err);
}
+static long
+libcfs_psdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+ if (!capable(CAP_SYS_ADMIN))
+ return -EACCES;
+
+ if (_IOC_TYPE(cmd) != IOC_LIBCFS_TYPE ||
+ _IOC_NR(cmd) < IOC_LIBCFS_MIN_NR ||
+ _IOC_NR(cmd) > IOC_LIBCFS_MAX_NR) {
+ CDEBUG(D_IOCTL, "invalid ioctl ( type %d, nr %d, size %d )\n",
+ _IOC_TYPE(cmd), _IOC_NR(cmd), _IOC_SIZE(cmd));
+ return -EINVAL;
+ }
+
+ return libcfs_ioctl(cmd, (void __user *)arg);
+}
+
+static const struct file_operations libcfs_fops = {
+ .owner = THIS_MODULE,
+ .unlocked_ioctl = libcfs_psdev_ioctl,
+};
+
+static struct miscdevice libcfs_dev = {
+ .minor = MISC_DYNAMIC_MINOR,
+ .name = "lnet",
+ .fops = &libcfs_fops,
+};
+
int lprocfs_call_handler(void *data, int write, loff_t *ppos,
void __user *buffer, size_t *lenp,
int (*handler)(void *data, int write, loff_t pos,
loff_t pos, void __user *buffer, int nob)
{
const int tmpstrlen = 512;
- char *tmpstr;
+ char *tmpstr = NULL;
int rc;
unsigned int *mask = data;
int is_subsys = (mask == &libcfs_subsystem_debug) ? 1 : 0;
int is_printk = (mask == &libcfs_printk) ? 1 : 0;
- rc = cfs_trace_allocate_string_buffer(&tmpstr, tmpstrlen);
- if (rc < 0)
- return rc;
-
if (!write) {
+ tmpstr = kmalloc(tmpstrlen, GFP_KERNEL | __GFP_ZERO);
+ if (!tmpstr)
+ return -ENOMEM;
libcfs_debug_mask2str(tmpstr, tmpstrlen, *mask, is_subsys);
rc = strlen(tmpstr);
tmpstr + pos, "\n");
}
} else {
- rc = cfs_trace_copyin_string(tmpstr, tmpstrlen, buffer, nob);
- if (rc < 0) {
- kfree(tmpstr);
- return rc;
- }
+ tmpstr = memdup_user_nul(buffer, nob);
+ if (IS_ERR(tmpstr))
+ return PTR_ERR(tmpstr);
- rc = libcfs_debug_str2mask(mask, tmpstr, is_subsys);
+ rc = libcfs_debug_str2mask(mask, strim(tmpstr), is_subsys);
/* Always print LBUG/LASSERT to console, so keep this mask */
if (is_printk)
*mask |= D_EMERG;
int rc;
long old_fail_loc = cfs_fail_loc;
- rc = proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
- if (old_fail_loc != cfs_fail_loc)
+ if (!*lenp || *ppos) {
+ *lenp = 0;
+ return 0;
+ }
+
+ if (write) {
+ char *kbuf = memdup_user_nul(buffer, *lenp);
+
+ if (IS_ERR(kbuf))
+ return PTR_ERR(kbuf);
+ rc = kstrtoul(kbuf, 0, &cfs_fail_loc);
+ kfree(kbuf);
+ *ppos += *lenp;
+ } else {
+ char kbuf[64/3+3];
+
+ rc = scnprintf(kbuf, sizeof(kbuf), "%lu\n", cfs_fail_loc);
+ if (copy_to_user(buffer, kbuf, rc))
+ rc = -EFAULT;
+ else {
+ *lenp = rc;
+ *ppos += rc;
+ }
+ }
+
+ if (old_fail_loc != cfs_fail_loc) {
+ cfs_race_state = 1;
wake_up(&cfs_race_waitq);
+ }
+ return rc;
+}
+
+int debugfs_doint(struct ctl_table *table, int write,
+ void __user *buffer, size_t *lenp, loff_t *ppos)
+{
+ int rc;
+
+ if (!*lenp || *ppos) {
+ *lenp = 0;
+ return 0;
+ }
+
+ if (write) {
+ char *kbuf = memdup_user_nul(buffer, *lenp);
+ int val;
+
+ if (IS_ERR(kbuf))
+ return PTR_ERR(kbuf);
+
+ rc = kstrtoint(kbuf, 0, &val);
+ kfree(kbuf);
+ if (!rc) {
+ if (table->extra1 && val < *(int *)table->extra1)
+ val = *(int *)table->extra1;
+ if (table->extra2 && val > *(int *)table->extra2)
+ val = *(int *)table->extra2;
+ *(int *)table->data = val;
+ }
+ *ppos += *lenp;
+ } else {
+ char kbuf[64/3+3];
+
+ rc = scnprintf(kbuf, sizeof(kbuf), "%u\n", *(int *)table->data);
+ if (copy_to_user(buffer, kbuf, rc))
+ rc = -EFAULT;
+ else {
+ *lenp = rc;
+ *ppos += rc;
+ }
+ }
+
return rc;
}
+EXPORT_SYMBOL(debugfs_doint);
+
+static int debugfs_dou64(struct ctl_table *table, int write,
+ void __user *buffer, size_t *lenp, loff_t *ppos)
+{
+ int rc;
+
+ if (!*lenp || *ppos) {
+ *lenp = 0;
+ return 0;
+ }
+
+ if (write) {
+ char *kbuf = memdup_user_nul(buffer, *lenp);
+ unsigned long long val;
+
+ if (IS_ERR(kbuf))
+ return PTR_ERR(kbuf);
+
+ rc = kstrtoull(kbuf, 0, &val);
+ kfree(kbuf);
+ if (!rc)
+ *(u64 *)table->data = val;
+ *ppos += *lenp;
+ } else {
+ char kbuf[64/3+3];
+
+ rc = scnprintf(kbuf, sizeof(kbuf), "%llu\n",
+ (unsigned long long)*(u64 *)table->data);
+ if (copy_to_user(buffer, kbuf, rc))
+ rc = -EFAULT;
+ else {
+ *lenp = rc;
+ *ppos += rc;
+ }
+ }
+
+ return rc;
+}
+
+static int debugfs_dostring(struct ctl_table *table, int write,
+ void __user *buffer, size_t *lenp, loff_t *ppos)
+{
+ int len = *lenp;
+ char *kbuf = table->data;
+
+ if (!len || *ppos) {
+ *lenp = 0;
+ return 0;
+ }
+ if (len > table->maxlen)
+ len = table->maxlen;
+ if (write) {
+ if (copy_from_user(kbuf, buffer, len))
+ return -EFAULT;
+ memset(kbuf+len, 0, table->maxlen - len);
+ *ppos = *lenp;
+ } else {
+ len = strnlen(kbuf, len);
+ if (copy_to_user(buffer, kbuf, len))
+ return -EFAULT;
+ if (len < *lenp) {
+ if (copy_to_user(buffer+len, "\n", 1))
+ return -EFAULT;
+ len += 1;
+ }
+ *ppos += len;
+ *lenp -= len;
+ }
+ return len;
+}
static int __proc_cpt_table(void *data, int write,
loff_t pos, void __user *buffer, int nob)
if (write)
return -EPERM;
- LASSERT(cfs_cpt_table != NULL);
-
while (1) {
LIBCFS_ALLOC(buf, len);
if (buf == NULL)
return -ENOMEM;
- rc = cfs_cpt_table_print(cfs_cpt_table, buf, len);
+ rc = cfs_cpt_table_print(cfs_cpt_tab, buf, len);
if (rc >= 0)
break;
if (write)
return -EPERM;
- LASSERT(cfs_cpt_table != NULL);
-
while (1) {
LIBCFS_ALLOC(buf, len);
if (buf == NULL)
return -ENOMEM;
- rc = cfs_cpt_distance_print(cfs_cpt_table, buf, len);
+ rc = cfs_cpt_distance_print(cfs_cpt_tab, buf, len);
if (rc >= 0)
break;
static struct ctl_table lnet_table[] = {
{
- INIT_CTL_NAME
.procname = "debug",
.data = &libcfs_debug,
.maxlen = sizeof(int),
.proc_handler = &proc_dobitmasks,
},
{
- INIT_CTL_NAME
.procname = "subsystem_debug",
.data = &libcfs_subsystem_debug,
.maxlen = sizeof(int),
.proc_handler = &proc_dobitmasks,
},
{
- INIT_CTL_NAME
.procname = "printk",
.data = &libcfs_printk,
.maxlen = sizeof(int),
.proc_handler = &proc_dobitmasks,
},
{
- INIT_CTL_NAME
.procname = "cpu_partition_table",
.maxlen = 128,
.mode = 0444,
.proc_handler = &proc_cpt_table,
},
{
- INIT_CTL_NAME
.procname = "cpu_partition_distance",
.maxlen = 128,
.mode = 0444,
.proc_handler = &proc_cpt_distance,
},
{
- INIT_CTL_NAME
.procname = "debug_log_upcall",
.data = lnet_debug_log_upcall,
.maxlen = sizeof(lnet_debug_log_upcall),
.mode = 0644,
- .proc_handler = &proc_dostring,
+ .proc_handler = &debugfs_dostring,
},
{
- INIT_CTL_NAME
.procname = "lnet_memused",
- .data = (int *)&libcfs_kmemory.counter,
- .maxlen = sizeof(int),
+ .data = (u64 *)&libcfs_kmem.counter,
+ .maxlen = sizeof(u64),
.mode = 0444,
- .proc_handler = &proc_dointvec,
+ .proc_handler = &debugfs_dou64,
},
{
- INIT_CTL_NAME
.procname = "catastrophe",
.data = &libcfs_catastrophe,
.maxlen = sizeof(int),
.mode = 0444,
- .proc_handler = &proc_dointvec,
+ .proc_handler = &debugfs_doint,
},
{
- INIT_CTL_NAME
.procname = "dump_kernel",
.maxlen = 256,
.mode = 0200,
.proc_handler = &proc_dump_kernel,
},
{
- INIT_CTL_NAME
.procname = "daemon_file",
.mode = 0644,
.maxlen = 256,
.proc_handler = &proc_daemon_file,
},
{
- INIT_CTL_NAME
.procname = "watchdog_ratelimit",
.data = &libcfs_watchdog_ratelimit,
.maxlen = sizeof(int),
.mode = 0644,
- .proc_handler = &proc_dointvec_minmax,
+ .proc_handler = &debugfs_doint,
.extra1 = &min_watchdog_ratelimit,
.extra2 = &max_watchdog_ratelimit,
},
{
- INIT_CTL_NAME
.procname = "force_lbug",
.data = NULL,
.maxlen = 0,
.proc_handler = &libcfs_force_lbug
},
{
- INIT_CTL_NAME
.procname = "fail_loc",
.data = &cfs_fail_loc,
.maxlen = sizeof(cfs_fail_loc),
.proc_handler = &proc_fail_loc
},
{
- INIT_CTL_NAME
.procname = "fail_val",
.data = &cfs_fail_val,
.maxlen = sizeof(int),
.mode = 0644,
- .proc_handler = &proc_dointvec
+ .proc_handler = &debugfs_doint
},
{
- INIT_CTL_NAME
.procname = "fail_err",
.data = &cfs_fail_err,
.maxlen = sizeof(cfs_fail_err),
.mode = 0644,
- .proc_handler = &proc_dointvec,
+ .proc_handler = &debugfs_doint,
},
{
}
return &lnet_debugfs_file_operations_rw;
}
-void lnet_insert_debugfs(struct ctl_table *table,
- const struct lnet_debugfs_symlink_def *symlinks)
+void lnet_insert_debugfs(struct ctl_table *table)
{
if (!lnet_debugfs_root)
lnet_debugfs_root = debugfs_create_dir("lnet", NULL);
debugfs_create_file(table->procname, table->mode,
lnet_debugfs_root, table,
lnet_debugfs_fops_select(table->mode));
+}
+EXPORT_SYMBOL_GPL(lnet_insert_debugfs);
+static void lnet_insert_debugfs_links(
+ const struct lnet_debugfs_symlink_def *symlinks)
+{
for (; symlinks && symlinks->name; symlinks++)
debugfs_create_symlink(symlinks->name, lnet_debugfs_root,
symlinks->target);
}
-EXPORT_SYMBOL_GPL(lnet_insert_debugfs);
-static void lnet_remove_debugfs(void)
+void lnet_remove_debugfs(struct ctl_table *table)
{
- debugfs_remove_recursive(lnet_debugfs_root);
+ for (; table && table->procname; table++) {
+ struct qstr dname = QSTR_INIT(table->procname,
+ strlen(table->procname));
+ struct dentry *dentry;
- lnet_debugfs_root = NULL;
+ dentry = d_hash_and_lookup(lnet_debugfs_root, &dname);
+ debugfs_remove(dentry);
+ }
}
+EXPORT_SYMBOL_GPL(lnet_remove_debugfs);
static int __init libcfs_init(void)
{
int rc;
+ cfs_arch_init();
+
+ init_libcfs_vfree_atomic();
+
rc = libcfs_debug_init(5 * 1024 * 1024);
if (rc < 0) {
- printk(KERN_ERR "LustreError: libcfs_debug_init: %d\n", rc);
+ pr_err("LustreError: libcfs_debug_init: rc = %d\n", rc);
return (rc);
}
+ cfs_debug_init();
+
rc = cfs_cpu_init();
if (rc != 0)
goto cleanup_debug;
goto cleanup_wi;
}
- lnet_insert_debugfs(lnet_table, lnet_debugfs_symlinks);
+ lnet_insert_debugfs(lnet_table);
+ if (!IS_ERR_OR_NULL(lnet_debugfs_root))
+ lnet_insert_debugfs_links(lnet_debugfs_symlinks);
+
+ rc = llcrypt_init();
+ if (rc) {
+ CERROR("llcrypt_init: error %d\n", rc);
+ goto cleanup_wi;
+ }
CDEBUG (D_OTHER, "portals setup OK\n");
return 0;
{
int rc;
- lnet_remove_debugfs();
+ /* Remove everthing */
+ debugfs_remove_recursive(lnet_debugfs_root);
+ lnet_debugfs_root = NULL;
+
+ CDEBUG(D_MALLOC, "before Portals cleanup: kmem %lld\n",
+ libcfs_kmem_read());
- CDEBUG(D_MALLOC, "before Portals cleanup: kmem %d\n",
- atomic_read(&libcfs_kmemory));
+ llcrypt_exit();
if (cfs_rehash_wq) {
destroy_workqueue(cfs_rehash_wq);
cfs_cpu_fini();
- if (atomic_read(&libcfs_kmemory) != 0)
- CERROR("Portals memory leaked: %d bytes\n",
- atomic_read(&libcfs_kmemory));
+ /* the below message is checked in test-framework.sh check_mem_leak() */
+ if (libcfs_kmem_read() != 0)
+ CERROR("Portals memory leaked: %lld bytes\n",
+ libcfs_kmem_read());
rc = libcfs_debug_cleanup();
if (rc)
- printk(KERN_ERR "LustreError: libcfs_debug_cleanup: %d\n",
- rc);
+ pr_err("LustreError: libcfs_debug_cleanup: rc = %d\n", rc);
+
+ exit_libcfs_vfree_atomic();
}
MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");
git://git.whamcloud.com / fs / lustre-release.git / blobdiff