Whamcloud - gitweb
LU-3963 libcfs: remove proc handler wrappers
[fs/lustre-release.git] / libcfs / libcfs / linux / linux-proc.c
index 06c7593..d5a979b 100644 (file)
@@ -1,6 +1,4 @@
-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
- *
+/*
  * GPL HEADER START
  *
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  * GPL HEADER END
  */
 /*
- * Copyright  2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  * Use is subject to license terms.
+ *
+ * Copyright (c) 2011, 2012, Intel Corporation.
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
  * Author: Phil Schwan <phil@clusterfs.com>
  */
 
-#ifndef EXPORT_SYMTAB
-# define EXPORT_SYMTAB
-#endif
-
-#ifndef AUTOCONF_INCLUDED
-#include <linux/config.h>
-#endif
 #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/smp_lock.h>
 #include <linux/unistd.h>
 #include <net/sock.h>
 #include <linux/uio.h>
 
-#include <asm/system.h>
 #include <asm/uaccess.h>
 
 #include <linux/fs.h>
 #include <asm/div64.h>
 #include "tracefile.h"
 
-static cfs_sysctl_table_header_t *lnet_table_header = NULL;
+#ifdef CONFIG_SYSCTL
+static struct ctl_table_header *lnet_table_header = NULL;
+#endif
 extern char lnet_upcall[1024];
 /**
  * The path of debug log dump upcall script.
  */
 extern char lnet_debug_log_upcall[1024];
 
-#ifndef HAVE_SYSCTL_UNNUMBERED
-#define CTL_LNET        (0x100)
-enum {
-        PSDEV_DEBUG = 1,          /* control debugging */
-        PSDEV_SUBSYSTEM_DEBUG,    /* control debugging */
-        PSDEV_PRINTK,             /* force all messages to console */
-        PSDEV_CONSOLE_RATELIMIT,  /* ratelimit console messages */
-        PSDEV_CONSOLE_MAX_DELAY_CS, /* maximum delay over which we skip messages */
-        PSDEV_CONSOLE_MIN_DELAY_CS, /* initial delay over which we skip messages */
-        PSDEV_CONSOLE_BACKOFF,    /* delay increase factor */
-        PSDEV_DEBUG_PATH,         /* crashdump log location */
-        PSDEV_DEBUG_DUMP_PATH,    /* crashdump tracelog location */
-        PSDEV_LNET_UPCALL,        /* User mode upcall script  */
-        PSDEV_LNET_MEMUSED,       /* bytes currently PORTAL_ALLOCated */
-        PSDEV_LNET_CATASTROPHE,   /* if we have LBUGged or panic'd */
-        PSDEV_LNET_PANIC_ON_LBUG, /* flag to panic on LBUG */
-        PSDEV_LNET_DUMP_KERNEL,   /* snapshot kernel debug buffer to file */
-        PSDEV_LNET_DAEMON_FILE,   /* spool kernel debug buffer to file */
-        PSDEV_LNET_DEBUG_MB,      /* size of debug buffer */
-        PSDEV_LNET_DEBUG_LOG_UPCALL, /* debug log upcall script */
-        PSDEV_LNET_WATCHDOG_RATELIMIT,  /* ratelimit watchdog messages  */
-        PSDEV_LNET_FORCE_LBUG,    /* hook to force an LBUG */
-};
-#else
-#define CTL_LNET                        CTL_UNNUMBERED
-#define PSDEV_DEBUG                     CTL_UNNUMBERED
-#define PSDEV_SUBSYSTEM_DEBUG           CTL_UNNUMBERED
-#define PSDEV_PRINTK                    CTL_UNNUMBERED
-#define PSDEV_CONSOLE_RATELIMIT         CTL_UNNUMBERED
-#define PSDEV_CONSOLE_MAX_DELAY_CS      CTL_UNNUMBERED
-#define PSDEV_CONSOLE_MIN_DELAY_CS      CTL_UNNUMBERED
-#define PSDEV_CONSOLE_BACKOFF           CTL_UNNUMBERED
-#define PSDEV_DEBUG_PATH                CTL_UNNUMBERED
-#define PSDEV_DEBUG_DUMP_PATH           CTL_UNNUMBERED
-#define PSDEV_LNET_UPCALL               CTL_UNNUMBERED
-#define PSDEV_LNET_MEMUSED              CTL_UNNUMBERED
-#define PSDEV_LNET_CATASTROPHE          CTL_UNNUMBERED
-#define PSDEV_LNET_PANIC_ON_LBUG        CTL_UNNUMBERED
-#define PSDEV_LNET_DUMP_KERNEL          CTL_UNNUMBERED
-#define PSDEV_LNET_DAEMON_FILE          CTL_UNNUMBERED
-#define PSDEV_LNET_DEBUG_MB             CTL_UNNUMBERED
-#define PSDEV_LNET_DEBUG_LOG_UPCALL     CTL_UNNUMBERED
-#define PSDEV_LNET_WATCHDOG_RATELIMIT   CTL_UNNUMBERED
-#define PSDEV_LNET_FORCE_LBUG           CTL_UNNUMBERED
-#endif
-
-
-int
-proc_call_handler(void *data, int write,
-                  loff_t *ppos, void *buffer, size_t *lenp,
-                  int (*handler)(void *data, int write,
-                                 loff_t pos, void *buffer, int len))
+int lprocfs_call_handler(void *data, int write, loff_t *ppos, void *buffer,
+                        size_t *lenp, int (*handler)(void *data, int write,
+                        loff_t pos, void *buffer, int len))
 {
         int rc = handler(data, write, *ppos, buffer, *lenp);
 
@@ -149,7 +93,7 @@ proc_call_handler(void *data, int write,
         }
         return 0;
 }
-EXPORT_SYMBOL(proc_call_handler);
+EXPORT_SYMBOL(lprocfs_call_handler);
 
 static int __proc_dobitmasks(void *data, int write,
                              loff_t pos, void *buffer, int nob)
@@ -177,8 +121,10 @@ static int __proc_dobitmasks(void *data, int write,
                 }
         } else {
                 rc = cfs_trace_copyin_string(tmpstr, tmpstrlen, buffer, nob);
-                if (rc < 0)
-                        return rc;
+               if (rc < 0) {
+                       cfs_trace_free_string_buffer(tmpstr, tmpstrlen);
+                       return rc;
+               }
 
                 rc = libcfs_debug_str2mask(mask, tmpstr, is_subsys);
                 /* Always print LBUG/LASSERT to console, so keep this mask */
@@ -190,7 +136,13 @@ static int __proc_dobitmasks(void *data, int write,
         return rc;
 }
 
-DECLARE_PROC_HANDLER(proc_dobitmasks)
+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);
+}
 
 static int min_watchdog_ratelimit = 0;          /* disable ratelimiting */
 static int max_watchdog_ratelimit = (24*60*60); /* limit to once per day */
@@ -204,7 +156,13 @@ static int __proc_dump_kernel(void *data, int write,
         return cfs_trace_dump_debug_buffer_usrstr(buffer, nob);
 }
 
-DECLARE_PROC_HANDLER(proc_dump_kernel)
+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);
+}
 
 static int __proc_daemon_file(void *data, int write,
                               loff_t pos, void *buffer, int nob)
@@ -222,7 +180,13 @@ static int __proc_daemon_file(void *data, int write,
         return cfs_trace_daemon_command_usrstr(buffer, nob);
 }
 
-DECLARE_PROC_HANDLER(proc_daemon_file)
+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);
+}
 
 static int __proc_debug_mb(void *data, int write,
                            loff_t pos, void *buffer, int nob)
@@ -242,26 +206,34 @@ static int __proc_debug_mb(void *data, int write,
         return cfs_trace_set_debug_mb_usrstr(buffer, nob);
 }
 
-DECLARE_PROC_HANDLER(proc_debug_mb)
+static int
+proc_debug_mb(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_debug_mb);
+}
 
-int LL_PROC_PROTO(proc_console_max_delay_cs)
+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;
-        cfs_sysctl_table_t dummy = *table;
-        cfs_duration_t d;
+       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 = ll_proc_dointvec(&dummy, write, filp, buffer, lenp, ppos);
+               rc = proc_dointvec(&dummy, write, buffer, lenp, ppos);
                 return rc;
         }
 
         /* write */
         max_delay_cs = 0;
-        rc = ll_proc_dointvec(&dummy, write, filp, buffer, lenp, ppos);
+       rc = proc_dointvec(&dummy, write, buffer, lenp, ppos);
         if (rc < 0)
                 return rc;
         if (max_delay_cs <= 0)
@@ -275,251 +247,349 @@ int LL_PROC_PROTO(proc_console_max_delay_cs)
         return rc;
 }
 
-int LL_PROC_PROTO(proc_console_min_delay_cs)
+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;
-        cfs_sysctl_table_t 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 = ll_proc_dointvec(&dummy, write, filp, buffer, lenp, ppos);
-                return rc;
-        }
-
-        /* write */
-        min_delay_cs = 0;
-        rc = ll_proc_dointvec(&dummy, write, filp, 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;
+       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;
 }
 
-int LL_PROC_PROTO(proc_console_backoff)
+static int
+proc_console_backoff(struct ctl_table *table, int write, void __user *buffer,
+                    size_t *lenp, loff_t *ppos)
 {
-        int rc, backoff;
-        cfs_sysctl_table_t dummy = *table;
+       int rc, backoff;
+       struct ctl_table dummy = *table;
 
-        dummy.data = &backoff;
-        dummy.proc_handler = &proc_dointvec;
+       dummy.data = &backoff;
+       dummy.proc_handler = &proc_dointvec;
 
-        if (!write) { /* read */
-                backoff= libcfs_console_backoff;
-                rc = ll_proc_dointvec(&dummy, write, filp, buffer, lenp, ppos);
-                return rc;
-        }
+       if (!write) { /* read */
+               backoff= libcfs_console_backoff;
+               rc = proc_dointvec(&dummy, write, buffer, lenp, ppos);
+               return rc;
+       }
 
-        /* write */
-        backoff = 0;
-        rc = ll_proc_dointvec(&dummy, write, filp, buffer, lenp, ppos);
-        if (rc < 0)
-                return rc;
-        if (backoff <= 0)
-                return -EINVAL;
+       /* 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;
+       libcfs_console_backoff = backoff;
 
-        return rc;
+       return rc;
 }
 
-int LL_PROC_PROTO(libcfs_force_lbug)
+static int
+libcfs_force_lbug(struct ctl_table *table, int write, void __user *buffer,
+                 size_t *lenp, loff_t *ppos)
 {
         if (write)
                 LBUG();
         return 0;
 }
 
-static cfs_sysctl_table_t lnet_table[] = {
-        /*
-         * NB No .strategy entries have been provided since sysctl(8) prefers
-         * to go via /proc for portability.
-         */
-        {
-                .ctl_name = PSDEV_DEBUG,
-                .procname = "debug",
-                .data     = &libcfs_debug,
-                .maxlen   = sizeof(int),
-                .mode     = 0644,
-                .proc_handler = &proc_dobitmasks,
-        },
-        {
-                .ctl_name = PSDEV_SUBSYSTEM_DEBUG,
-                .procname = "subsystem_debug",
-                .data     = &libcfs_subsystem_debug,
-                .maxlen   = sizeof(int),
-                .mode     = 0644,
-                .proc_handler = &proc_dobitmasks,
-        },
-        {
-                .ctl_name = PSDEV_PRINTK,
-                .procname = "printk",
-                .data     = &libcfs_printk,
-                .maxlen   = sizeof(int),
-                .mode     = 0644,
-                .proc_handler = &proc_dobitmasks,
-        },
-        {
-                .ctl_name = PSDEV_CONSOLE_RATELIMIT,
-                .procname = "console_ratelimit",
-                .data     = &libcfs_console_ratelimit,
-                .maxlen   = sizeof(int),
-                .mode     = 0644,
-                .proc_handler = &proc_dointvec
-        },
-        {
-                .ctl_name = PSDEV_CONSOLE_MAX_DELAY_CS,
-                .procname = "console_max_delay_centisecs",
-                .maxlen   = sizeof(int),
-                .mode     = 0644,
-                .proc_handler = &proc_console_max_delay_cs
-        },
-        {
-                .ctl_name = PSDEV_CONSOLE_MIN_DELAY_CS,
-                .procname = "console_min_delay_centisecs",
-                .maxlen   = sizeof(int),
-                .mode     = 0644,
-                .proc_handler = &proc_console_min_delay_cs
-        },
-        {
-                .ctl_name = PSDEV_CONSOLE_BACKOFF,
-                .procname = "console_backoff",
-                .maxlen   = sizeof(int),
-                .mode     = 0644,
-                .proc_handler = &proc_console_backoff
-        },
+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;
 
-        {
-                .ctl_name = PSDEV_DEBUG_PATH,
-                .procname = "debug_path",
-                .data     = libcfs_debug_file_path_arr,
-                .maxlen   = sizeof(libcfs_debug_file_path_arr),
-                .mode     = 0644,
-                .proc_handler = &proc_dostring,
-        },
+       rc = proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
+       if (old_fail_loc != cfs_fail_loc)
+               wake_up(&cfs_race_waitq);
+       return rc;
+}
 
-        {
-                .ctl_name = PSDEV_LNET_UPCALL,
-                .procname = "upcall",
-                .data     = lnet_upcall,
-                .maxlen   = sizeof(lnet_upcall),
-                .mode     = 0644,
-                .proc_handler = &proc_dostring,
-        },
-        {
-                .ctl_name = PSDEV_LNET_DEBUG_LOG_UPCALL,
-                .procname = "debug_log_upcall",
-                .data     = lnet_debug_log_upcall,
-                .maxlen   = sizeof(lnet_debug_log_upcall),
-                .mode     = 0644,
-                .proc_handler = &proc_dostring,
-        },
-        {
-                .ctl_name = PSDEV_LNET_MEMUSED,
-                .procname = "memused",
-                .data     = (int *)&libcfs_kmemory.counter,
-                .maxlen   = sizeof(int),
-                .mode     = 0444,
-                .proc_handler = &proc_dointvec,
-                .strategy = &sysctl_intvec,
-        },
-        {
-                .ctl_name = PSDEV_LNET_CATASTROPHE,
-                .procname = "catastrophe",
-                .data     = &libcfs_catastrophe,
-                .maxlen   = sizeof(int),
-                .mode     = 0444,
-                .proc_handler = &proc_dointvec,
-                .strategy = &sysctl_intvec,
-        },
-        {
-                .ctl_name = PSDEV_LNET_PANIC_ON_LBUG,
-                .procname = "panic_on_lbug",
-                .data     = &libcfs_panic_on_lbug,
-                .maxlen   = sizeof(int),
-                .mode     = 0644,
-                .proc_handler = &proc_dointvec,
-                .strategy = &sysctl_intvec,
-        },
-        {
-                .ctl_name = PSDEV_LNET_DUMP_KERNEL,
-                .procname = "dump_kernel",
-                .maxlen   = 256,
-                .mode     = 0200,
-                .proc_handler = &proc_dump_kernel,
-        },
-        {
-                .ctl_name = PSDEV_LNET_DAEMON_FILE,
-                .procname = "daemon_file",
-                .mode     = 0644,
-                .maxlen   = 256,
-                .proc_handler = &proc_daemon_file,
-        },
-        {
-                .ctl_name = PSDEV_LNET_DEBUG_MB,
-                .procname = "debug_mb",
-                .mode     = 0644,
-                .proc_handler = &proc_debug_mb,
-        },
-        {
-                .ctl_name = PSDEV_LNET_WATCHDOG_RATELIMIT,
-                .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,
-        },
-        {       .ctl_name = PSDEV_LNET_FORCE_LBUG,
-                .procname = "force_lbug",
-                .data     = NULL,
-                .maxlen   = 0,
-                .mode     = 0200,
-                .proc_handler = &libcfs_force_lbug
-        },
-        {0}
+static int __proc_cpt_table(void *data, int write,
+                           loff_t pos, void *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_table_print(cfs_cpt_table, buf, len);
+               if (rc >= 0)
+                       break;
+
+               LIBCFS_FREE(buf, len);
+               if (rc == -EFBIG) {
+                       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_table(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_table);
+}
+
+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       = "upcall",
+               .data           = lnet_upcall,
+               .maxlen         = sizeof(lnet_upcall),
+               .mode           = 0644,
+               .proc_handler   = &proc_dostring,
+       },
+       {
+               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_STRATEGY
+       },
+       {
+               INIT_CTL_NAME
+               .procname       = "catastrophe",
+               .data           = &libcfs_catastrophe,
+               .maxlen         = sizeof(int),
+               .mode           = 0444,
+               .proc_handler   = &proc_dointvec,
+               INIT_STRATEGY
+       },
+       {
+               INIT_CTL_NAME
+               .procname       = "panic_on_lbug",
+               .data           = &libcfs_panic_on_lbug,
+               .maxlen         = sizeof(int),
+               .mode           = 0644,
+               .proc_handler   = &proc_dointvec,
+               INIT_STRATEGY
+       },
+       {
+               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,
+       },
+       { 0 }
 };
 
-static cfs_sysctl_table_t top_table[] = {
-        {
-                .ctl_name = CTL_LNET,
-                .procname = "lnet",
-                .mode     = 0555,
-                .data     = NULL,
-                .maxlen   = 0,
-                .child    = lnet_table,
-        },
+#ifdef CONFIG_SYSCTL
+static struct ctl_table top_table[] = {
         {
-                .ctl_name = 0
-        }
+               INIT_CTL_NAME
+               .procname       = "lnet",
+               .mode           = 0555,
+               .data           = NULL,
+               .maxlen         = 0,
+               .child          = lnet_table,
+       },
+       { 0 }
 };
+#endif
 
 int insert_proc(void)
 {
 #ifdef CONFIG_SYSCTL
-        if (lnet_table_header == NULL)
-                lnet_table_header = cfs_register_sysctl_table(top_table, 0);
+       if (lnet_table_header == NULL)
+               lnet_table_header = register_sysctl_table(top_table);
 #endif
-        return 0;
+       return 0;
 }
 
 void remove_proc(void)
 {
 #ifdef CONFIG_SYSCTL
-        if (lnet_table_header != NULL)
-                cfs_unregister_sysctl_table(lnet_table_header);
+       if (lnet_table_header != NULL)
+               unregister_sysctl_table(lnet_table_header);
 
-        lnet_table_header = NULL;
+       lnet_table_header = NULL;
 #endif
 }