X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=libcfs%2Flibcfs%2Fmodule.c;h=e8080f323c422a6093ec9bdc35c5a306b4ec372d;hp=2529b38ecd40809b6fc9a0af3cf0dcfe37505846;hb=ce8735993473c1055038f7422350c96b092d707d;hpb=e3a7c58aebafce40323db54bf6056029e5af4a70

diff --git a/libcfs/libcfs/module.c b/libcfs/libcfs/module.c
index 2529b38..e8080f3 100644
--- a/libcfs/libcfs/module.c
+++ b/libcfs/libcfs/module.c
@@ -15,455 +15,812 @@
  *
  * You should have received a copy of the GNU General Public License
  * version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
  *
  * GPL HEADER END
  */
 /*
  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
+ *
+ * Copyright (c) 2012, 2015, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
  * Lustre is a trademark of Sun Microsystems, Inc.
  */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/mm.h>
+#include <linux/string.h>
+#include <linux/stat.h>
+#include <linux/errno.h>
+#include <linux/unistd.h>
+#include <net/sock.h>
+#include <linux/uio.h>
+#include <linux/uaccess.h>
+
+#include <linux/fs.h>
+#include <linux/file.h>
+#include <linux/list.h>
+
+#include <linux/sysctl.h>
+#include <linux/proc_fs.h>
+#include <asm/div64.h>
 
-#ifndef EXPORT_SYMTAB
-# define EXPORT_SYMTAB
-#endif
 #define DEBUG_SUBSYSTEM S_LNET
 
 #include <libcfs/libcfs.h>
+#include <libcfs/libcfs_crypto.h>
 #include <lnet/lib-lnet.h>
-#include <lnet/lnet.h>
 #include "tracefile.h"
 
-void
-kportal_memhog_free (struct libcfs_device_userstate *ldu)
-{
-        cfs_page_t **level0p = &ldu->ldu_memhog_root_page;
-        cfs_page_t **level1p;
-        cfs_page_t **level2p;
-        int           count1;
-        int           count2;
-
-        if (*level0p != NULL) {
-
-                level1p = (cfs_page_t **)cfs_page_address(*level0p);
-                count1 = 0;
+#ifdef CONFIG_SYSCTL
+static struct ctl_table_header *lnet_table_header;
+#endif
 
-                while (count1 < CFS_PAGE_SIZE/sizeof(cfs_page_t *) &&
-                       *level1p != NULL) {
+static DECLARE_RWSEM(ioctl_list_sem);
+static LIST_HEAD(ioctl_list);
 
-                        level2p = (cfs_page_t **)cfs_page_address(*level1p);
-                        count2 = 0;
+int libcfs_register_ioctl(struct libcfs_ioctl_handler *hand)
+{
+	int rc = 0;
 
-                        while (count2 < CFS_PAGE_SIZE/sizeof(cfs_page_t *) &&
-                               *level2p != NULL) {
+	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);
 
-                                cfs_free_page(*level2p);
-                                ldu->ldu_memhog_pages--;
-                                level2p++;
-                                count2++;
-                        }
+	return rc;
+}
+EXPORT_SYMBOL(libcfs_register_ioctl);
 
-                        cfs_free_page(*level1p);
-                        ldu->ldu_memhog_pages--;
-                        level1p++;
-                        count1++;
-                }
+int libcfs_deregister_ioctl(struct libcfs_ioctl_handler *hand)
+{
+	int rc = 0;
 
-                cfs_free_page(*level0p);
-                ldu->ldu_memhog_pages--;
+	down_write(&ioctl_list_sem);
+	if (list_empty(&hand->item))
+		rc = -ENOENT;
+	else
+		list_del_init(&hand->item);
+	up_write(&ioctl_list_sem);
 
-                *level0p = NULL;
-        }
+	return rc;
+}
+EXPORT_SYMBOL(libcfs_deregister_ioctl);
 
-        LASSERT (ldu->ldu_memhog_pages == 0);
+int libcfs_ioctl(unsigned long cmd, void __user *uparam)
+{
+	struct libcfs_ioctl_data *data = NULL;
+	struct libcfs_ioctl_hdr  *hdr;
+	int			  err;
+	ENTRY;
+
+	/* 'cmd' and permissions get checked in our arch-specific caller */
+	err = libcfs_ioctl_getdata(&hdr, uparam);
+	if (err != 0) {
+		CDEBUG_LIMIT(D_ERROR,
+			     "libcfs ioctl: data header error %d\n", err);
+		RETURN(err);
+	}
+
+	if (hdr->ioc_version == LIBCFS_IOCTL_VERSION) {
+		/* The libcfs_ioctl_data_adjust() function performs adjustment
+		 * operations on the libcfs_ioctl_data structure to make
+		 * it usable by the code.  This doesn't need to be called
+		 * for new data structures added. */
+		data = container_of(hdr, struct libcfs_ioctl_data, ioc_hdr);
+		err = libcfs_ioctl_data_adjust(data);
+		if (err != 0)
+			GOTO(out, err);
+	}
+
+	CDEBUG(D_IOCTL, "libcfs ioctl cmd %lu\n", cmd);
+	switch (cmd) {
+	case IOC_LIBCFS_CLEAR_DEBUG:
+		libcfs_debug_clear_buffer();
+		break;
+	case IOC_LIBCFS_MARK_DEBUG:
+		if (data == NULL ||
+		    data->ioc_inlbuf1 == NULL ||
+		    data->ioc_inlbuf1[data->ioc_inllen1 - 1] != '\0')
+			GOTO(out, err = -EINVAL);
+
+		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;
+
+			if (err == 0) {
+				if (copy_to_user(uparam, hdr, hdr->ioc_len))
+					err = -EFAULT;
+			}
+			break;
+		}
+		up_read(&ioctl_list_sem);
+		break; }
+	}
+out:
+	LIBCFS_FREE(hdr, hdr->ioc_len);
+	RETURN(err);
 }
 
 int
-kportal_memhog_alloc (struct libcfs_device_userstate *ldu, int npages, int flags)
+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,
+				    void __user *buffer, int len))
 {
-        cfs_page_t **level0p;
-        cfs_page_t **level1p;
-        cfs_page_t **level2p;
-        int           count1;
-        int           count2;
+	int rc = handler(data, write, *ppos, buffer, *lenp);
+
+	if (rc < 0)
+		return rc;
+
+	if (write) {
+		*ppos += *lenp;
+	} else {
+		*lenp = rc;
+		*ppos += rc;
+	}
+	return 0;
+}
+EXPORT_SYMBOL(lprocfs_call_handler);
 
-        LASSERT (ldu->ldu_memhog_pages == 0);
-        LASSERT (ldu->ldu_memhog_root_page == NULL);
+static int __proc_dobitmasks(void *data, int write,
+			     loff_t pos, void __user *buffer, int nob)
+{
+	const int     tmpstrlen = 512;
+	char         *tmpstr;
+	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) {
+		libcfs_debug_mask2str(tmpstr, tmpstrlen, *mask, is_subsys);
+		rc = strlen(tmpstr);
+
+		if (pos >= rc) {
+			rc = 0;
+		} else {
+			rc = cfs_trace_copyout_string(buffer, nob,
+						      tmpstr + pos, "\n");
+		}
+	} else {
+		rc = cfs_trace_copyin_string(tmpstr, tmpstrlen, buffer, nob);
+		if (rc < 0) {
+			kfree(tmpstr);
+			return rc;
+		}
+
+		rc = libcfs_debug_str2mask(mask, tmpstr, is_subsys);
+		/* Always print LBUG/LASSERT to console, so keep this mask */
+		if (is_printk)
+			*mask |= D_EMERG;
+	}
+
+	kfree(tmpstr);
+	return rc;
+}
 
-        if (npages < 0)
-                return -EINVAL;
+static int
+proc_dobitmasks(struct ctl_table *table, int write,
+		void __user *buffer, size_t *lenp, loff_t *ppos)
+{
+	return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
+				    __proc_dobitmasks);
+}
 
-        if (npages == 0)
-                return 0;
+static int min_watchdog_ratelimit;		/* disable ratelimiting */
+static int max_watchdog_ratelimit = (24*60*60); /* limit to once per day */
 
-        level0p = &ldu->ldu_memhog_root_page;
-        *level0p = cfs_alloc_page(flags);
-        if (*level0p == NULL)
-                return -ENOMEM;
-        ldu->ldu_memhog_pages++;
+static int __proc_dump_kernel(void *data, int write,
+			      loff_t pos, void __user *buffer, int nob)
+{
+	if (!write)
+		return 0;
 
-        level1p = (cfs_page_t **)cfs_page_address(*level0p);
-        count1 = 0;
-        memset(level1p, 0, CFS_PAGE_SIZE);
+	return cfs_trace_dump_debug_buffer_usrstr(buffer, nob);
+}
 
-        while (ldu->ldu_memhog_pages < npages &&
-               count1 < CFS_PAGE_SIZE/sizeof(cfs_page_t *)) {
+static int
+proc_dump_kernel(struct ctl_table *table, int write, void __user *buffer,
+		 size_t *lenp, loff_t *ppos)
+{
+	return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
+				    __proc_dump_kernel);
+}
 
-                if (cfs_signal_pending())
-                        return (-EINTR);
+static int __proc_daemon_file(void *data, int write,
+			      loff_t pos, void __user *buffer, int nob)
+{
+	if (!write) {
+		int len = strlen(cfs_tracefile);
 
-                *level1p = cfs_alloc_page(flags);
-                if (*level1p == NULL)
-                        return -ENOMEM;
-                ldu->ldu_memhog_pages++;
+		if (pos >= len)
+			return 0;
 
-                level2p = (cfs_page_t **)cfs_page_address(*level1p);
-                count2 = 0;
-                memset(level2p, 0, CFS_PAGE_SIZE);
+		return cfs_trace_copyout_string(buffer, nob,
+						cfs_tracefile + pos, "\n");
+	}
 
-                while (ldu->ldu_memhog_pages < npages &&
-                       count2 < CFS_PAGE_SIZE/sizeof(cfs_page_t *)) {
+	return cfs_trace_daemon_command_usrstr(buffer, nob);
+}
 
-                        if (cfs_signal_pending())
-                                return (-EINTR);
+static int
+proc_daemon_file(struct ctl_table *table, int write, void __user *buffer,
+		 size_t *lenp, loff_t *ppos)
+{
+	return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
+				    __proc_daemon_file);
+}
 
-                        *level2p = cfs_alloc_page(flags);
-                        if (*level2p == NULL)
-                                return (-ENOMEM);
-                        ldu->ldu_memhog_pages++;
+static int __proc_debug_mb(void *data, int write,
+			   loff_t pos, void __user *buffer, int nob)
+{
+	if (!write) {
+		char tmpstr[32];
+		int  len = snprintf(tmpstr, sizeof(tmpstr), "%d",
+				    cfs_trace_get_debug_mb());
 
-                        level2p++;
-                        count2++;
-                }
+		if (pos >= len)
+			return 0;
 
-                level1p++;
-                count1++;
-        }
+		return cfs_trace_copyout_string(buffer, nob, tmpstr + pos,
+						"\n");
+	}
 
-        return 0;
+	return cfs_trace_set_debug_mb_usrstr(buffer, nob);
 }
 
-/* called when opening /dev/device */
-static int libcfs_psdev_open(unsigned long flags, void *args)
+static int
+proc_debug_mb(struct ctl_table *table, int write, void __user *buffer,
+	      size_t *lenp, loff_t *ppos)
 {
-        struct libcfs_device_userstate *ldu;
-        ENTRY;
-
-        PORTAL_MODULE_USE;
+	return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
+				    __proc_debug_mb);
+}
 
-        LIBCFS_ALLOC(ldu, sizeof(*ldu));
-        if (ldu != NULL) {
-                ldu->ldu_memhog_pages = 0;
-                ldu->ldu_memhog_root_page = NULL;
-        }
-        *(struct libcfs_device_userstate **)args = ldu;
+static int
+proc_console_max_delay_cs(struct ctl_table *table, int write,
+			  void __user *buffer, size_t *lenp, loff_t *ppos)
+{
+	int rc, max_delay_cs;
+	struct ctl_table dummy = *table;
+	cfs_duration_t d;
+
+	dummy.data = &max_delay_cs;
+	dummy.proc_handler = &proc_dointvec;
+
+	if (!write) { /* read */
+		max_delay_cs = cfs_duration_sec(libcfs_console_max_delay * 100);
+		rc = proc_dointvec(&dummy, write, buffer, lenp, ppos);
+		return rc;
+	}
+
+	/* write */
+	max_delay_cs = 0;
+	rc = proc_dointvec(&dummy, write, buffer, lenp, ppos);
+	if (rc < 0)
+		return rc;
+	if (max_delay_cs <= 0)
+		return -EINVAL;
+
+	d = cfs_time_seconds(max_delay_cs) / 100;
+	if (d == 0 || d < libcfs_console_min_delay)
+		return -EINVAL;
+	libcfs_console_max_delay = d;
+
+	return rc;
+}
 
-        RETURN(0);
+static int
+proc_console_min_delay_cs(struct ctl_table *table, int write,
+			  void __user *buffer, size_t *lenp, loff_t *ppos)
+{
+	int rc, min_delay_cs;
+	struct ctl_table dummy = *table;
+	cfs_duration_t d;
+
+	dummy.data = &min_delay_cs;
+	dummy.proc_handler = &proc_dointvec;
+
+	if (!write) { /* read */
+		min_delay_cs = cfs_duration_sec(libcfs_console_min_delay * 100);
+		rc = proc_dointvec(&dummy, write, buffer, lenp, ppos);
+		return rc;
+	}
+
+	/* write */
+	min_delay_cs = 0;
+	rc = proc_dointvec(&dummy, write, buffer, lenp, ppos);
+	if (rc < 0)
+		return rc;
+	if (min_delay_cs <= 0)
+		return -EINVAL;
+
+	d = cfs_time_seconds(min_delay_cs) / 100;
+	if (d == 0 || d > libcfs_console_max_delay)
+		return -EINVAL;
+	libcfs_console_min_delay = d;
+
+	return rc;
 }
 
-/* called when closing /dev/device */
-static int libcfs_psdev_release(unsigned long flags, void *args)
+static int
+proc_console_backoff(struct ctl_table *table, int write, void __user *buffer,
+		     size_t *lenp, loff_t *ppos)
 {
-        struct libcfs_device_userstate *ldu;
-        ENTRY;
+	int rc, backoff;
+	struct ctl_table dummy = *table;
 
-        ldu = (struct libcfs_device_userstate *)args;
-        if (ldu != NULL) {
-                kportal_memhog_free(ldu);
-                LIBCFS_FREE(ldu, sizeof(*ldu));
-        }
+	dummy.data = &backoff;
+	dummy.proc_handler = &proc_dointvec;
 
-        PORTAL_MODULE_UNUSE;
-        RETURN(0);
-}
+	if (!write) { /* read */
+		backoff = libcfs_console_backoff;
+		rc = proc_dointvec(&dummy, write, buffer, lenp, ppos);
+		return rc;
+	}
 
-static cfs_rw_semaphore_t ioctl_list_sem;
-static cfs_list_t ioctl_list;
+	/* write */
+	backoff = 0;
+	rc = proc_dointvec(&dummy, write, buffer, lenp, ppos);
+	if (rc < 0)
+		return rc;
 
-int libcfs_register_ioctl(struct libcfs_ioctl_handler *hand)
-{
-        int rc = 0;
+	if (backoff <= 0)
+		return -EINVAL;
 
-        cfs_down_write(&ioctl_list_sem);
-        if (!cfs_list_empty(&hand->item))
-                rc = -EBUSY;
-        else
-                cfs_list_add_tail(&hand->item, &ioctl_list);
-        cfs_up_write(&ioctl_list_sem);
+	libcfs_console_backoff = backoff;
 
-        return rc;
+	return rc;
 }
-EXPORT_SYMBOL(libcfs_register_ioctl);
 
-int libcfs_deregister_ioctl(struct libcfs_ioctl_handler *hand)
+static int
+libcfs_force_lbug(struct ctl_table *table, int write, void __user *buffer,
+		  size_t *lenp, loff_t *ppos)
 {
-        int rc = 0;
+	if (write)
+		LBUG();
+	return 0;
+}
 
-        cfs_down_write(&ioctl_list_sem);
-        if (cfs_list_empty(&hand->item))
-                rc = -ENOENT;
-        else
-                cfs_list_del_init(&hand->item);
-        cfs_up_write(&ioctl_list_sem);
+static int
+proc_fail_loc(struct ctl_table *table, int write, void __user *buffer,
+	      size_t *lenp, loff_t *ppos)
+{
+	int rc;
+	long old_fail_loc = cfs_fail_loc;
 
-        return rc;
+	rc = proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
+	if (old_fail_loc != cfs_fail_loc)
+		wake_up(&cfs_race_waitq);
+	return rc;
 }
-EXPORT_SYMBOL(libcfs_deregister_ioctl);
 
-static int libcfs_ioctl_int(struct cfs_psdev_file *pfile,unsigned long cmd,
-                            void *arg, struct libcfs_ioctl_data *data)
+static int __proc_cpt_table(void *data, int write,
+			    loff_t pos, void __user *buffer, int nob)
 {
-        int err = -EINVAL;
-        ENTRY;
-
-        switch (cmd) {
-        case IOC_LIBCFS_CLEAR_DEBUG:
-                libcfs_debug_clear_buffer();
-                RETURN(0);
-        /*
-         * case IOC_LIBCFS_PANIC:
-         * Handled in arch/cfs_module.c
-         */
-        case IOC_LIBCFS_MARK_DEBUG:
-                if (data->ioc_inlbuf1 == NULL ||
-                    data->ioc_inlbuf1[data->ioc_inllen1 - 1] != '\0')
-                        RETURN(-EINVAL);
-                libcfs_debug_mark_buffer(data->ioc_inlbuf1);
-                RETURN(0);
-#if LWT_SUPPORT
-        case IOC_LIBCFS_LWT_CONTROL:
-                err = lwt_control ((data->ioc_flags & 1) != 0, 
-                                   (data->ioc_flags & 2) != 0);
-                break;
-
-        case IOC_LIBCFS_LWT_SNAPSHOT: {
-                cfs_cycles_t   now;
-                int            ncpu;
-                int            total_size;
-
-                err = lwt_snapshot (&now, &ncpu, &total_size,
-                                    data->ioc_pbuf1, data->ioc_plen1);
-                data->ioc_u64[0] = now;
-                data->ioc_u32[0] = ncpu;
-                data->ioc_u32[1] = total_size;
-
-                /* Hedge against broken user/kernel typedefs (e.g. cycles_t) */
-                data->ioc_u32[2] = sizeof(lwt_event_t);
-                data->ioc_u32[3] = offsetof(lwt_event_t, lwte_where);
-
-                if (err == 0 &&
-                    libcfs_ioctl_popdata(arg, data, sizeof (*data)))
-                        err = -EFAULT;
-                break;
-        }
-
-        case IOC_LIBCFS_LWT_LOOKUP_STRING:
-                err = lwt_lookup_string (&data->ioc_count, data->ioc_pbuf1,
-                                         data->ioc_pbuf2, data->ioc_plen2);
-                if (err == 0 &&
-                    libcfs_ioctl_popdata(arg, data, sizeof (*data)))
-                        err = -EFAULT;
-                break;
-#endif
-        case IOC_LIBCFS_MEMHOG:
-                if (pfile->private_data == NULL) {
-                        err = -EINVAL;
-                } else {
-                        kportal_memhog_free(pfile->private_data);
-                        /* XXX The ioc_flags is not GFP flags now, need to be fixed */
-                        err = kportal_memhog_alloc(pfile->private_data,
-                                                   data->ioc_count,
-                                                   data->ioc_flags);
-                        if (err != 0)
-                                kportal_memhog_free(pfile->private_data);
-                }
-                break;
-
-        case IOC_LIBCFS_PING_TEST: {
-                extern void (kping_client)(struct libcfs_ioctl_data *);
-                void (*ping)(struct libcfs_ioctl_data *);
-
-                CDEBUG(D_IOCTL, "doing %d pings to nid %s (%s)\n",
-                       data->ioc_count, libcfs_nid2str(data->ioc_nid),
-                       libcfs_nid2str(data->ioc_nid));
-                ping = PORTAL_SYMBOL_GET(kping_client);
-                if (!ping)
-                        CERROR("PORTAL_SYMBOL_GET failed\n");
-                else {
-                        ping(data);
-                        PORTAL_SYMBOL_PUT(kping_client);
-                }
-                RETURN(0);
-        }
-
-        default: {
-                struct libcfs_ioctl_handler *hand;
-                err = -EINVAL;
-                cfs_down_read(&ioctl_list_sem);
-                cfs_list_for_each_entry_typed(hand, &ioctl_list,
-                        struct libcfs_ioctl_handler, item) {
-                        err = hand->handle_ioctl(cmd, data);
-                        if (err != -EINVAL) {
-                                if (err == 0)
-                                        err = libcfs_ioctl_popdata(arg, 
-                                                        data, sizeof (*data));
-                                break;
-                        }
-                }
-                cfs_up_read(&ioctl_list_sem);
-                break;
-        }
-        }
-
-        RETURN(err);
+	char *buf = NULL;
+	int   len = 4096;
+	int   rc  = 0;
+
+	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);
+		if (rc >= 0)
+			break;
+
+		if (rc == -EFBIG) {
+			LIBCFS_FREE(buf, len);
+			len <<= 1;
+			continue;
+		}
+		goto out;
+	}
+
+	if (pos >= rc) {
+		rc = 0;
+		goto out;
+	}
+
+	rc = cfs_trace_copyout_string(buffer, nob, buf + pos, NULL);
+out:
+	if (buf != NULL)
+		LIBCFS_FREE(buf, len);
+	return rc;
 }
 
-static int libcfs_ioctl(struct cfs_psdev_file *pfile, unsigned long cmd, void *arg)
+static int
+proc_cpt_table(struct ctl_table *table, int write, void __user *buffer,
+	       size_t *lenp, loff_t *ppos)
 {
-        char    *buf;
-        struct libcfs_ioctl_data *data;
-        int err = 0;
-        ENTRY;
-
-        LIBCFS_ALLOC_GFP(buf, 1024, CFS_ALLOC_STD);
-        if (buf == NULL)
-                RETURN(-ENOMEM);
-
-        /* 'cmd' and permissions get checked in our arch-specific caller */
-        if (libcfs_ioctl_getdata(buf, buf + 800, (void *)arg)) {
-                CERROR("PORTALS ioctl: data error\n");
-                GOTO(out, err = -EINVAL);
-        }
-        data = (struct libcfs_ioctl_data *)buf;
+	return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
+				    __proc_cpt_table);
+}
 
-        err = libcfs_ioctl_int(pfile, cmd, arg, data);
+static int __proc_cpt_distance(void *data, int write,
+			       loff_t pos, void __user *buffer, int nob)
+{
+	char *buf = NULL;
+	int   len = 4096;
+	int   rc  = 0;
+
+	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);
+		if (rc >= 0)
+			break;
+
+		if (rc == -EFBIG) {
+			LIBCFS_FREE(buf, len);
+			len <<= 1;
+			continue;
+		}
+		goto out;
+	}
+
+	if (pos >= rc) {
+		rc = 0;
+		goto out;
+	}
+
+	rc = cfs_trace_copyout_string(buffer, nob, buf + pos, NULL);
+ out:
+	if (buf != NULL)
+		LIBCFS_FREE(buf, len);
+	return rc;
+}
 
-out:
-        LIBCFS_FREE(buf, 1024);
-        RETURN(err);
+static int
+proc_cpt_distance(struct ctl_table *table, int write, void __user *buffer,
+	       size_t *lenp, loff_t *ppos)
+{
+	return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
+				     __proc_cpt_distance);
 }
 
+static struct ctl_table lnet_table[] = {
+	/*
+	 * NB No .strategy entries have been provided since sysctl(8) prefers
+	 * to go via /proc for portability.
+	 */
+	{
+		INIT_CTL_NAME
+		.procname	= "debug",
+		.data		= &libcfs_debug,
+		.maxlen		= sizeof(int),
+		.mode		= 0644,
+		.proc_handler	= &proc_dobitmasks,
+	},
+	{
+		INIT_CTL_NAME
+		.procname	= "subsystem_debug",
+		.data		= &libcfs_subsystem_debug,
+		.maxlen		= sizeof(int),
+		.mode		= 0644,
+		.proc_handler	= &proc_dobitmasks,
+	},
+	{
+		INIT_CTL_NAME
+		.procname	= "printk",
+		.data		= &libcfs_printk,
+		.maxlen		= sizeof(int),
+		.mode		= 0644,
+		.proc_handler	= &proc_dobitmasks,
+	},
+	{
+		INIT_CTL_NAME
+		.procname	= "console_ratelimit",
+		.data		= &libcfs_console_ratelimit,
+		.maxlen		= sizeof(int),
+		.mode		= 0644,
+		.proc_handler	= &proc_dointvec
+	},
+	{
+		INIT_CTL_NAME
+		.procname	= "console_max_delay_centisecs",
+		.maxlen		= sizeof(int),
+		.mode		= 0644,
+		.proc_handler	= &proc_console_max_delay_cs
+	},
+	{
+		INIT_CTL_NAME
+		.procname	= "console_min_delay_centisecs",
+		.maxlen		= sizeof(int),
+		.mode		= 0644,
+		.proc_handler	= &proc_console_min_delay_cs
+	},
+	{
+		INIT_CTL_NAME
+		.procname	= "console_backoff",
+		.maxlen		= sizeof(int),
+		.mode		= 0644,
+		.proc_handler	= &proc_console_backoff
+	},
+	{
+		INIT_CTL_NAME
+		.procname	= "debug_path",
+		.data		= libcfs_debug_file_path_arr,
+		.maxlen		= sizeof(libcfs_debug_file_path_arr),
+		.mode		= 0644,
+		.proc_handler	= &proc_dostring,
+	},
+	{
+		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,
+	},
+	{
+		INIT_CTL_NAME
+		.procname	= "lnet_memused",
+		.data		= (int *)&libcfs_kmemory.counter,
+		.maxlen		= sizeof(int),
+		.mode		= 0444,
+		.proc_handler	= &proc_dointvec,
+	},
+	{
+		INIT_CTL_NAME
+		.procname	= "catastrophe",
+		.data		= &libcfs_catastrophe,
+		.maxlen		= sizeof(int),
+		.mode		= 0444,
+		.proc_handler	= &proc_dointvec,
+	},
+	{
+		INIT_CTL_NAME
+		.procname	= "panic_on_lbug",
+		.data		= &libcfs_panic_on_lbug,
+		.maxlen		= sizeof(int),
+		.mode		= 0644,
+		.proc_handler	= &proc_dointvec,
+	},
+	{
+		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	= "debug_mb",
+		.mode		= 0644,
+		.proc_handler	= &proc_debug_mb,
+	},
+	{
+		INIT_CTL_NAME
+		.procname	= "watchdog_ratelimit",
+		.data		= &libcfs_watchdog_ratelimit,
+		.maxlen		= sizeof(int),
+		.mode		= 0644,
+		.proc_handler	= &proc_dointvec_minmax,
+		.extra1		= &min_watchdog_ratelimit,
+		.extra2		= &max_watchdog_ratelimit,
+	},
+	{
+		INIT_CTL_NAME
+		.procname	= "force_lbug",
+		.data		= NULL,
+		.maxlen		= 0,
+		.mode		= 0200,
+		.proc_handler	= &libcfs_force_lbug
+	},
+	{
+		INIT_CTL_NAME
+		.procname	= "fail_loc",
+		.data		= &cfs_fail_loc,
+		.maxlen		= sizeof(cfs_fail_loc),
+		.mode		= 0644,
+		.proc_handler	= &proc_fail_loc
+	},
+	{
+		INIT_CTL_NAME
+		.procname	= "fail_val",
+		.data		= &cfs_fail_val,
+		.maxlen		= sizeof(int),
+		.mode		= 0644,
+		.proc_handler	= &proc_dointvec
+	},
+	{
+		INIT_CTL_NAME
+		.procname	= "fail_err",
+		.data		= &cfs_fail_err,
+		.maxlen		= sizeof(cfs_fail_err),
+		.mode		= 0644,
+		.proc_handler	= &proc_dointvec,
+	},
+	{
+	}
+};
 
-struct cfs_psdev_ops libcfs_psdev_ops = {
-        libcfs_psdev_open,
-        libcfs_psdev_release,
-        NULL,
-        NULL,
-        libcfs_ioctl
+#ifdef CONFIG_SYSCTL
+static struct ctl_table top_table[] = {
+	{
+		INIT_CTL_NAME
+		.procname       = "lnet",
+		.mode           = 0555,
+		.data           = NULL,
+		.maxlen         = 0,
+		.child          = lnet_table,
+	},
+	{ 0 }
 };
+#endif
 
-extern int insert_proc(void);
-extern void remove_proc(void);
-MODULE_AUTHOR("Peter J. Braam <braam@clusterfs.com>");
-MODULE_DESCRIPTION("Portals v3.1");
-MODULE_LICENSE("GPL");
+static int insert_proc(void)
+{
+#ifdef CONFIG_SYSCTL
+	if (lnet_table_header == NULL)
+		lnet_table_header = register_sysctl_table(top_table);
+#endif
+	return 0;
+}
 
-extern cfs_psdev_t libcfs_dev;
-extern cfs_rw_semaphore_t cfs_tracefile_sem;
-extern cfs_mutex_t cfs_trace_thread_mutex;
+static void remove_proc(void)
+{
+#ifdef CONFIG_SYSCTL
+	if (lnet_table_header != NULL)
+		unregister_sysctl_table(lnet_table_header);
 
-extern void libcfs_init_nidstrings(void);
-extern int libcfs_arch_init(void);
-extern void libcfs_arch_cleanup(void);
+	lnet_table_header = NULL;
+#endif
+}
 
-static int init_libcfs_module(void)
+static int __init libcfs_init(void)
 {
-        int rc;
-
-        libcfs_arch_init();
-        libcfs_init_nidstrings();
-        cfs_init_rwsem(&cfs_tracefile_sem);
-        cfs_mutex_init(&cfs_trace_thread_mutex);
-        cfs_init_rwsem(&ioctl_list_sem);
-        CFS_INIT_LIST_HEAD(&ioctl_list);
-        cfs_waitq_init(&cfs_race_waitq);
-
-        rc = libcfs_debug_init(5 * 1024 * 1024);
-        if (rc < 0) {
-                printk(CFS_KERN_ERR "LustreError: libcfs_debug_init: %d\n", rc);
-                return (rc);
-        }
-
-#if LWT_SUPPORT
-        rc = lwt_init();
-        if (rc != 0) {
-                CERROR("lwt_init: error %d\n", rc);
-                goto cleanup_debug;
-        }
-#endif
-        rc = cfs_psdev_register(&libcfs_dev);
-        if (rc) {
-                CERROR("misc_register: error %d\n", rc);
-                goto cleanup_lwt;
-        }
-
-        rc = cfs_wi_startup();
-        if (rc) {
-                CERROR("startup workitem: error %d\n", rc);
-                goto cleanup_deregister;
-        }
-
-        rc = insert_proc();
-        if (rc) {
-                CERROR("insert_proc: error %d\n", rc);
-                goto cleanup_wi;
-        }
-
-        CDEBUG (D_OTHER, "portals setup OK\n");
-        return (0);
-
- cleanup_wi:
-        cfs_wi_shutdown();
- cleanup_deregister:
-        cfs_psdev_deregister(&libcfs_dev);
- cleanup_lwt:
-#if LWT_SUPPORT
-        lwt_fini();
- cleanup_debug:
-#endif
-        libcfs_debug_cleanup();
-        return rc;
+	int rc;
+
+	rc = libcfs_debug_init(5 * 1024 * 1024);
+	if (rc < 0) {
+		printk(KERN_ERR "LustreError: libcfs_debug_init: %d\n", rc);
+		return (rc);
+	}
+
+	rc = cfs_cpu_init();
+	if (rc != 0)
+		goto cleanup_debug;
+
+	rc = misc_register(&libcfs_dev);
+	if (rc) {
+		CERROR("misc_register: error %d\n", rc);
+		goto cleanup_cpu;
+	}
+
+	rc = cfs_wi_startup();
+	if (rc) {
+		CERROR("initialize workitem: error %d\n", rc);
+		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);
+		goto cleanup_deregister;
+	}
+
+	rc = cfs_crypto_register();
+	if (rc) {
+		CERROR("cfs_crypto_regster: error %d\n", rc);
+		goto cleanup_wi;
+	}
+
+
+	rc = insert_proc();
+	if (rc) {
+		CERROR("insert_proc: error %d\n", rc);
+		goto cleanup_crypto;
+	}
+
+	CDEBUG (D_OTHER, "portals setup OK\n");
+	return 0;
+cleanup_crypto:
+	cfs_crypto_unregister();
+cleanup_wi:
+	cfs_wi_shutdown();
+cleanup_deregister:
+	misc_deregister(&libcfs_dev);
+cleanup_cpu:
+	cfs_cpu_fini();
+cleanup_debug:
+	libcfs_debug_cleanup();
+	return rc;
 }
 
-static void exit_libcfs_module(void)
+static void __exit libcfs_exit(void)
 {
-        int rc;
+	int rc;
 
-        remove_proc();
+	remove_proc();
 
-        CDEBUG(D_MALLOC, "before Portals cleanup: kmem %d\n",
-               cfs_atomic_read(&libcfs_kmemory));
+	CDEBUG(D_MALLOC, "before Portals cleanup: kmem %d\n",
+	       atomic_read(&libcfs_kmemory));
 
-        cfs_wi_shutdown();
-        rc = cfs_psdev_deregister(&libcfs_dev);
-        if (rc)
-                CERROR("misc_deregister error %d\n", rc);
+	if (cfs_sched_rehash != NULL) {
+		cfs_wi_sched_destroy(cfs_sched_rehash);
+		cfs_sched_rehash = NULL;
+	}
 
-#if LWT_SUPPORT
-        lwt_fini();
-#endif
+	cfs_crypto_unregister();
+	cfs_wi_shutdown();
 
-        if (cfs_atomic_read(&libcfs_kmemory) != 0)
-                CERROR("Portals memory leaked: %d bytes\n",
-                       cfs_atomic_read(&libcfs_kmemory));
+	misc_deregister(&libcfs_dev);
 
-        rc = libcfs_debug_cleanup();
-        if (rc)
-                printk(CFS_KERN_ERR "LustreError: libcfs_debug_cleanup: %d\n",
-                       rc);
+	cfs_cpu_fini();
 
-        cfs_fini_rwsem(&ioctl_list_sem);
-        cfs_fini_rwsem(&cfs_tracefile_sem);
+	if (atomic_read(&libcfs_kmemory) != 0)
+		CERROR("Portals memory leaked: %d bytes\n",
+		       atomic_read(&libcfs_kmemory));
 
-        libcfs_arch_cleanup();
+	rc = libcfs_debug_cleanup();
+	if (rc)
+		printk(KERN_ERR "LustreError: libcfs_debug_cleanup: %d\n",
+		       rc);
 }
 
-cfs_module(libcfs, "1.0.0", init_libcfs_module, exit_libcfs_module);
+MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");
+MODULE_DESCRIPTION("Lustre helper library");
+MODULE_VERSION(LIBCFS_VERSION);
+MODULE_LICENSE("GPL");
+
+module_init(libcfs_init);
+module_exit(libcfs_exit);