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

diff --git a/libcfs/libcfs/module.c b/libcfs/libcfs/module.c
index efd4213..e8080f3 100644
--- a/libcfs/libcfs/module.c
+++ b/libcfs/libcfs/module.c
@@ -15,11 +15,7 @@
  *
  * 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
  */
@@ -27,332 +23,710 @@
  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
  *
- * Copyright (c) 2012, Intel Corporation.
+ * 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>
 
 #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)
+#ifdef CONFIG_SYSCTL
+static struct ctl_table_header *lnet_table_header;
+#endif
+
+static DECLARE_RWSEM(ioctl_list_sem);
+static LIST_HEAD(ioctl_list);
+
+int libcfs_register_ioctl(struct libcfs_ioctl_handler *hand)
 {
-	struct page **level0p = &ldu->ldu_memhog_root_page;
-	struct page **level1p;
-	struct page **level2p;
-	int           count1;
-	int           count2;
+	int rc = 0;
 
-	if (*level0p != NULL) {
-		level1p = (struct page **)page_address(*level0p);
-		count1 = 0;
+	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);
 
-		while (count1 < PAGE_CACHE_SIZE/sizeof(struct page *) &&
-		       *level1p != NULL) {
+	return rc;
+}
+EXPORT_SYMBOL(libcfs_register_ioctl);
 
-			level2p = (struct page **)page_address(*level1p);
-			count2 = 0;
+int libcfs_deregister_ioctl(struct libcfs_ioctl_handler *hand)
+{
+	int rc = 0;
 
-			while (count2 < PAGE_CACHE_SIZE/sizeof(struct page *) &&
-			       *level2p != NULL) {
+	down_write(&ioctl_list_sem);
+	if (list_empty(&hand->item))
+		rc = -ENOENT;
+	else
+		list_del_init(&hand->item);
+	up_write(&ioctl_list_sem);
 
-				__free_page(*level2p);
-				ldu->ldu_memhog_pages--;
-				level2p++;
-				count2++;
-			}
+	return rc;
+}
+EXPORT_SYMBOL(libcfs_deregister_ioctl);
 
-			__free_page(*level1p);
-			ldu->ldu_memhog_pages--;
-			level1p++;
-			count1++;
-		}
+int libcfs_ioctl(unsigned long cmd, void __user *uparam)
+{
+	struct libcfs_ioctl_data *data = NULL;
+	struct libcfs_ioctl_hdr  *hdr;
+	int			  err;
+	ENTRY;
 
-		__free_page(*level0p);
-		ldu->ldu_memhog_pages--;
+	/* '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);
+	}
 
-		*level0p = NULL;
+	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);
 	}
 
-	LASSERT(ldu->ldu_memhog_pages == 0);
+	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,
-		     gfp_t 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))
 {
-	struct page **level0p;
-	struct page **level1p;
-	struct page **level2p;
-	int           count1;
-	int           count2;
+	int rc = handler(data, write, *ppos, buffer, *lenp);
 
-	LASSERT(ldu->ldu_memhog_pages == 0);
-	LASSERT(ldu->ldu_memhog_root_page == NULL);
+	if (rc < 0)
+		return rc;
 
-	if (npages < 0)
-		return -EINVAL;
-
-	if (npages == 0)
-		return 0;
+	if (write) {
+		*ppos += *lenp;
+	} else {
+		*lenp = rc;
+		*ppos += rc;
+	}
+	return 0;
+}
+EXPORT_SYMBOL(lprocfs_call_handler);
 
-	level0p = &ldu->ldu_memhog_root_page;
-	*level0p = alloc_page(flags);
-	if (*level0p == NULL)
-		return -ENOMEM;
-	ldu->ldu_memhog_pages++;
+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;
+		}
 
-	level1p = (struct page **)page_address(*level0p);
-	count1 = 0;
-	memset(level1p, 0, PAGE_CACHE_SIZE);
+		rc = libcfs_debug_str2mask(mask, tmpstr, is_subsys);
+		/* Always print LBUG/LASSERT to console, so keep this mask */
+		if (is_printk)
+			*mask |= D_EMERG;
+	}
 
-	while (ldu->ldu_memhog_pages < npages &&
-	       count1 < PAGE_CACHE_SIZE/sizeof(struct page *)) {
+	kfree(tmpstr);
+	return rc;
+}
 
-		if (cfs_signal_pending())
-			return -EINTR;
+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);
+}
 
-		*level1p = alloc_page(flags);
-		if (*level1p == NULL)
-			return -ENOMEM;
-		ldu->ldu_memhog_pages++;
+static int min_watchdog_ratelimit;		/* disable ratelimiting */
+static int max_watchdog_ratelimit = (24*60*60); /* limit to once per day */
 
-		level2p = (struct page **)page_address(*level1p);
-		count2 = 0;
-		memset(level2p, 0, PAGE_CACHE_SIZE);
+static int __proc_dump_kernel(void *data, int write,
+			      loff_t pos, void __user *buffer, int nob)
+{
+	if (!write)
+		return 0;
 
-		while (ldu->ldu_memhog_pages < npages &&
-		       count2 < PAGE_CACHE_SIZE/sizeof(struct page *)) {
+	return cfs_trace_dump_debug_buffer_usrstr(buffer, nob);
+}
 
-			if (cfs_signal_pending())
-				return -EINTR;
+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);
+}
 
-			*level2p = alloc_page(flags);
-			if (*level2p == NULL)
-				return -ENOMEM;
-			ldu->ldu_memhog_pages++;
+static int __proc_daemon_file(void *data, int write,
+			      loff_t pos, void __user *buffer, int nob)
+{
+	if (!write) {
+		int len = strlen(cfs_tracefile);
 
-			level2p++;
-			count2++;
-		}
+		if (pos >= len)
+			return 0;
 
-		level1p++;
-		count1++;
+		return cfs_trace_copyout_string(buffer, nob,
+						cfs_tracefile + pos, "\n");
 	}
 
-	return 0;
+	return cfs_trace_daemon_command_usrstr(buffer, nob);
 }
 
-/* called when opening /dev/device */
-static int libcfs_psdev_open(unsigned long flags, void *args)
+static int
+proc_daemon_file(struct ctl_table *table, int write, void __user *buffer,
+		 size_t *lenp, loff_t *ppos)
 {
-	struct libcfs_device_userstate *ldu;
-	ENTRY;
+	return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
+				    __proc_daemon_file);
+}
+
+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());
 
-	try_module_get(THIS_MODULE);
+		if (pos >= len)
+			return 0;
 
-	LIBCFS_ALLOC(ldu, sizeof(*ldu));
-	if (ldu != NULL) {
-		ldu->ldu_memhog_pages = 0;
-		ldu->ldu_memhog_root_page = NULL;
+		return cfs_trace_copyout_string(buffer, nob, tmpstr + pos,
+						"\n");
 	}
-	*(struct libcfs_device_userstate **)args = ldu;
 
-	RETURN(0);
+	return cfs_trace_set_debug_mb_usrstr(buffer, nob);
 }
 
-/* called when closing /dev/device */
-static int libcfs_psdev_release(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;
+	return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
+				    __proc_debug_mb);
+}
 
-	ldu = (struct libcfs_device_userstate *)args;
-	if (ldu != NULL) {
-		kportal_memhog_free(ldu);
-		LIBCFS_FREE(ldu, sizeof(*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;
 	}
 
-	module_put(THIS_MODULE);
-	RETURN(0);
+	/* 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;
 }
 
-static struct rw_semaphore ioctl_list_sem;
-static struct list_head ioctl_list;
+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;
 
-int libcfs_register_ioctl(struct libcfs_ioctl_handler *hand)
+	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;
+}
+
+static int
+proc_console_backoff(struct ctl_table *table, int write, void __user *buffer,
+		     size_t *lenp, loff_t *ppos)
 {
-	int rc = 0;
+	int rc, backoff;
+	struct ctl_table dummy = *table;
 
-	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);
+	dummy.data = &backoff;
+	dummy.proc_handler = &proc_dointvec;
+
+	if (!write) { /* read */
+		backoff = libcfs_console_backoff;
+		rc = proc_dointvec(&dummy, write, buffer, lenp, ppos);
+		return rc;
+	}
+
+	/* write */
+	backoff = 0;
+	rc = proc_dointvec(&dummy, write, buffer, lenp, ppos);
+	if (rc < 0)
+		return rc;
+
+	if (backoff <= 0)
+		return -EINVAL;
+
+	libcfs_console_backoff = backoff;
 
 	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;
+}
 
-	down_write(&ioctl_list_sem);
-	if (list_empty(&hand->item))
-		rc = -ENOENT;
-	else
-		list_del_init(&hand->item);
-	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;
 
+	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);
-        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 = symbol_get(kping_client);
-		if (!ping) {
-			CERROR("symbol_get failed\n");
-		} else {
-			ping(data);
-			symbol_put(kping_client);
-		}
-		RETURN(0);
-	}
+	char *buf = NULL;
+	int   len = 4096;
+	int   rc  = 0;
 
-        default: {
-		struct libcfs_ioctl_handler *hand;
+	if (write)
+		return -EPERM;
 
-		err = -EINVAL;
-		down_read(&ioctl_list_sem);
-		list_for_each_entry(hand, &ioctl_list, item) {
-			err = hand->handle_ioctl(cmd, data);
-			if (err != -EINVAL) {
-				if (err == 0)
-					err = libcfs_ioctl_popdata(arg,
-							data, sizeof (*data));
-				break;
-			}
+	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;
 		}
-		up_read(&ioctl_list_sem);
-		break;
+		goto out;
 	}
+
+	if (pos >= rc) {
+		rc = 0;
+		goto out;
 	}
 
-	RETURN(err);
+	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;
+	return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
+				    __proc_cpt_table);
+}
 
-	LIBCFS_ALLOC_GFP(buf, 1024, GFP_IOFS);
-	if (buf == NULL)
-		RETURN(-ENOMEM);
+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;
 
-        /* '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;
+	if (write)
+		return -EPERM;
 
-        err = libcfs_ioctl_int(pfile, cmd, arg, data);
+	LASSERT(cfs_cpt_table != NULL);
 
-out:
-        LIBCFS_FREE(buf, 1024);
-        RETURN(err);
+	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;
 }
 
+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);
+}
 
-struct cfs_psdev_ops libcfs_psdev_ops = {
-        libcfs_psdev_open,
-        libcfs_psdev_release,
-        NULL,
-        NULL,
-        libcfs_ioctl
+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,
+	},
+	{
+	}
 };
 
-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");
+#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 struct miscdevice libcfs_dev;
-extern struct rw_semaphore cfs_tracefile_sem;
-extern struct mutex cfs_trace_thread_mutex;
-extern struct cfs_wi_sched *cfs_sched_rehash;
+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 void libcfs_init_nidstrings(void);
-extern int libcfs_arch_init(void);
-extern void libcfs_arch_cleanup(void);
+static void remove_proc(void)
+{
+#ifdef CONFIG_SYSCTL
+	if (lnet_table_header != NULL)
+		unregister_sysctl_table(lnet_table_header);
+
+	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();
-	init_rwsem(&cfs_tracefile_sem);
-	mutex_init(&cfs_trace_thread_mutex);
-	init_rwsem(&ioctl_list_sem);
-	INIT_LIST_HEAD(&ioctl_list);
-	init_waitqueue_head(&cfs_race_waitq);
-
 	rc = libcfs_debug_init(5 * 1024 * 1024);
 	if (rc < 0) {
 		printk(KERN_ERR "LustreError: libcfs_debug_init: %d\n", rc);
@@ -412,7 +786,7 @@ cleanup_debug:
 	return rc;
 }
 
-static void exit_libcfs_module(void)
+static void __exit libcfs_exit(void)
 {
 	int rc;
 
@@ -429,9 +803,7 @@ static void exit_libcfs_module(void)
 	cfs_crypto_unregister();
 	cfs_wi_shutdown();
 
-	rc = misc_deregister(&libcfs_dev);
-	if (rc)
-		CERROR("misc_deregister error %d\n", rc);
+	misc_deregister(&libcfs_dev);
 
 	cfs_cpu_fini();
 
@@ -443,11 +815,12 @@ static void exit_libcfs_module(void)
 	if (rc)
 		printk(KERN_ERR "LustreError: libcfs_debug_cleanup: %d\n",
 		       rc);
-
-	fini_rwsem(&ioctl_list_sem);
-	fini_rwsem(&cfs_tracefile_sem);
-
-	libcfs_arch_cleanup();
 }
 
-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);