X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=libcfs%2Flibcfs%2Fmodule.c;h=1d2351ee23141f964608fb924aa089ddb81c8e02;hb=eb3d0504f2d7eed8c8c584af82ad609455071bd2;hp=e6e6d0caf8efa61edda054d0f4eb3456613f0774;hpb=fdb5d3d508edb6d76b6fcc1f23d5d9649211ab64;p=fs%2Flustre-release.git diff --git a/libcfs/libcfs/module.c b/libcfs/libcfs/module.c index e6e6d0c..1d2351e 100644 --- a/libcfs/libcfs/module.c +++ b/libcfs/libcfs/module.c @@ -58,40 +58,125 @@ static struct dentry *lnet_debugfs_root; -static DECLARE_RWSEM(ioctl_list_sem); -static LIST_HEAD(ioctl_list); +BLOCKING_NOTIFIER_HEAD(libcfs_ioctl_list); +EXPORT_SYMBOL(libcfs_ioctl_list); -int libcfs_register_ioctl(struct libcfs_ioctl_handler *hand) +static inline size_t libcfs_ioctl_packlen(struct libcfs_ioctl_data *data) { - int rc = 0; + size_t len = sizeof(*data); - down_write(&ioctl_list_sem); - if (!list_empty(&hand->item)) - rc = -EBUSY; - else - list_add_tail(&hand->item, &ioctl_list); - up_write(&ioctl_list_sem); + len += (data->ioc_inllen1 + 7) & ~7; + len += (data->ioc_inllen2 + 7) & ~7; + return len; +} - return rc; +static bool libcfs_ioctl_is_invalid(struct libcfs_ioctl_data *data) +{ + if (data->ioc_hdr.ioc_len > BIT(30)) + return true; + + if (data->ioc_inllen1 > BIT(30)) + return true; + + if (data->ioc_inllen2 > BIT(30)) + 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; } -EXPORT_SYMBOL(libcfs_register_ioctl); -int libcfs_deregister_ioctl(struct libcfs_ioctl_handler *hand) +int libcfs_ioctl_data_adjust(struct libcfs_ioctl_data *data) { - int rc = 0; + ENTRY; - down_write(&ioctl_list_sem); - if (list_empty(&hand->item)) - rc = -ENOENT; - else - list_del_init(&hand->item); - up_write(&ioctl_list_sem); + if (libcfs_ioctl_is_invalid(data)) { + CERROR("libcfs ioctl: parameter not correctly formatted\n"); + RETURN(-EINVAL); + } - return rc; + 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); } -EXPORT_SYMBOL(libcfs_deregister_ioctl); -int libcfs_ioctl(unsigned long cmd, void __user *uparam) +static int libcfs_ioctl(unsigned long cmd, void __user *uparam) { struct libcfs_ioctl_data *data = NULL; struct libcfs_ioctl_hdr *hdr; @@ -131,28 +216,52 @@ int libcfs_ioctl(unsigned long cmd, void __user *uparam) libcfs_debug_mark_buffer(data->ioc_inlbuf1); break; - default: { - struct libcfs_ioctl_handler *hand; - - err = -EINVAL; - down_read(&ioctl_list_sem); - list_for_each_entry(hand, &ioctl_list, item) { - err = hand->handle_ioctl(cmd, hdr); - if (err == -EINVAL) - continue; - + default: + err = blocking_notifier_call_chain(&libcfs_ioctl_list, + cmd, hdr); + if (!(err & NOTIFY_STOP_MASK)) + /* No-one claimed the ioctl */ + err = -EINVAL; + else + err = notifier_to_errno(err); + if (!err) if (copy_to_user(uparam, hdr, hdr->ioc_len)) err = -EFAULT; - break; - } - up_read(&ioctl_list_sem); - break; } + break; } out: LIBCFS_FREE(hdr, hdr->ioc_len); 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, @@ -525,11 +634,13 @@ static ssize_t lnet_debugfs_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos) { struct ctl_table *table = filp->private_data; - ssize_t rc; + ssize_t rc = -EINVAL; - rc = table->proc_handler(table, 0, buf, &count, ppos); - if (!rc) - rc = count; + if (table) { + rc = table->proc_handler(table, 0, buf, &count, ppos); + if (!rc) + rc = count; + } return rc; } @@ -538,11 +649,14 @@ static ssize_t lnet_debugfs_write(struct file *filp, const char __user *buf, size_t count, loff_t *ppos) { struct ctl_table *table = filp->private_data; - ssize_t rc; + ssize_t rc = -EINVAL; - rc = table->proc_handler(table, 1, (void __user *)buf, &count, ppos); - if (!rc) - rc = count; + if (table) { + rc = table->proc_handler(table, 1, (void __user *)buf, &count, + ppos); + if (!rc) + rc = count; + } return rc; } @@ -577,8 +691,7 @@ static const struct file_operations *lnet_debugfs_fops_select(umode_t mode) 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); @@ -594,24 +707,37 @@ void lnet_insert_debugfs(struct ctl_table *table, 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; +#ifndef HAVE_WAIT_VAR_EVENT + wait_bit_init(); +#endif rc = libcfs_debug_init(5 * 1024 * 1024); if (rc < 0) { printk(KERN_ERR "LustreError: libcfs_debug_init: %d\n", rc); @@ -634,12 +760,11 @@ static int __init libcfs_init(void) goto cleanup_deregister; } - /* max to 4 threads, should be enough for rehash */ - rc = min(cfs_cpt_weight(cfs_cpt_table, CFS_CPT_ANY), 4); - rc = cfs_wi_sched_create("cfs_rh", cfs_cpt_table, CFS_CPT_ANY, - rc, &cfs_sched_rehash); - if (rc != 0) { - CERROR("Startup workitem scheduler: error: %d\n", rc); + cfs_rehash_wq = alloc_workqueue("cfs_rh", WQ_SYSFS, 4); + if (!cfs_rehash_wq) { + rc = -ENOMEM; + CERROR("libcfs: failed to start rehash workqueue: rc = %d\n", + rc); goto cleanup_deregister; } @@ -649,7 +774,9 @@ static int __init libcfs_init(void) 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); CDEBUG (D_OTHER, "portals setup OK\n"); return 0; @@ -668,14 +795,16 @@ static void __exit libcfs_exit(void) { int rc; - lnet_remove_debugfs(); + /* Remove everthing */ + debugfs_remove_recursive(lnet_debugfs_root); + lnet_debugfs_root = NULL; CDEBUG(D_MALLOC, "before Portals cleanup: kmem %d\n", atomic_read(&libcfs_kmemory)); - if (cfs_sched_rehash != NULL) { - cfs_wi_sched_destroy(cfs_sched_rehash); - cfs_sched_rehash = NULL; + if (cfs_rehash_wq) { + destroy_workqueue(cfs_rehash_wq); + cfs_rehash_wq = NULL; } cfs_crypto_unregister(); @@ -685,6 +814,7 @@ static void __exit libcfs_exit(void) cfs_cpu_fini(); + /* the below message is checked in test-framework.sh check_mem_leak() */ if (atomic_read(&libcfs_kmemory) != 0) CERROR("Portals memory leaked: %d bytes\n", atomic_read(&libcfs_kmemory));