Whamcloud - gitweb
LU-5570 lnet: check router aliveness timestamp
[fs/lustre-release.git] / lnet / lnet / router_proc.c
index 77571e5..95d34c9 100644 (file)
@@ -1,7 +1,7 @@
-/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
- * vim:expandtab:shiftwidth=8:tabstop=8:
+/*
+ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  *
- * Copyright  2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2011, 2013, Intel Corporation.
  *
  *   This file is part of Portals
  *   http://sourceforge.net/projects/sandiaportals/
 
 #if defined(__KERNEL__) && defined(LNET_ROUTER)
 
-#if defined(__linux__)
-#include <linux/seq_file.h>
-#endif
-
-/* this is really lnet_proc.c */
+/* This is really lnet_proc.c. You might need to update sanity test 215
+ * if any file format is changed. */
 
-#define LNET_PROC_ROOT    "sys/lnet"
-#define LNET_PROC_STATS   LNET_PROC_ROOT"/stats"
-#define LNET_PROC_ROUTES  LNET_PROC_ROOT"/routes"
-#define LNET_PROC_ROUTERS LNET_PROC_ROOT"/routers"
-#define LNET_PROC_PEERS   LNET_PROC_ROOT"/peers"
-#define LNET_PROC_BUFFERS LNET_PROC_ROOT"/buffers"
-#define LNET_PROC_NIS     LNET_PROC_ROOT"/nis"
+static struct ctl_table_header *lnet_table_header = NULL;
 
-static int
-lnet_router_proc_stats_read (char *page, char **start, off_t off,
-                             int count, int *eof, void *data)
-{
-        lnet_counters_t *ctrs;
-        int              rc;
-
-        *start = page;
-        *eof = 1;
-        if (off != 0)
-                return 0;
+#define LNET_LOFFT_BITS                (sizeof(loff_t) * 8)
+/*
+ * NB: max allowed LNET_CPT_BITS is 8 on 64-bit system and 2 on 32-bit system
+ */
+#define LNET_PROC_CPT_BITS     (LNET_CPT_BITS + 1)
+/* change version, 16 bits or 8 bits */
+#define LNET_PROC_VER_BITS     MAX(((MIN(LNET_LOFFT_BITS, 64)) / 4), 8)
+
+#define LNET_PROC_HASH_BITS    LNET_PEER_HASH_BITS
+/*
+ * bits for peer hash offset
+ * NB: we don't use the highest bit of *ppos because it's signed
+ */
+#define LNET_PROC_HOFF_BITS    (LNET_LOFFT_BITS -       \
+                                LNET_PROC_CPT_BITS -    \
+                                LNET_PROC_VER_BITS -    \
+                                LNET_PROC_HASH_BITS - 1)
+/* bits for hash index + position */
+#define LNET_PROC_HPOS_BITS    (LNET_PROC_HASH_BITS + LNET_PROC_HOFF_BITS)
+/* bits for peer hash table + hash version */
+#define LNET_PROC_VPOS_BITS    (LNET_PROC_HPOS_BITS + LNET_PROC_VER_BITS)
 
-        LIBCFS_ALLOC(ctrs, sizeof(*ctrs));
-        if (ctrs == NULL)
-                return -ENOMEM;
+#define LNET_PROC_CPT_MASK     ((1ULL << LNET_PROC_CPT_BITS) - 1)
+#define LNET_PROC_VER_MASK     ((1ULL << LNET_PROC_VER_BITS) - 1)
+#define LNET_PROC_HASH_MASK    ((1ULL << LNET_PROC_HASH_BITS) - 1)
+#define LNET_PROC_HOFF_MASK    ((1ULL << LNET_PROC_HOFF_BITS) - 1)
 
-        LNET_LOCK();
-        *ctrs = the_lnet.ln_counters;
-        LNET_UNLOCK();
+#define LNET_PROC_CPT_GET(pos)                         \
+       (int)(((pos) >> LNET_PROC_VPOS_BITS) & LNET_PROC_CPT_MASK)
 
-        rc = sprintf(page,
-                     "%u %u %u %u %u %u %u "LPU64" "LPU64" "LPU64" "LPU64"\n",
-                     ctrs->msgs_alloc, ctrs->msgs_max,
-                     ctrs->errors,
-                     ctrs->send_count, ctrs->recv_count,
-                     ctrs->route_count, ctrs->drop_count,
-                     ctrs->send_length, ctrs->recv_length,
-                     ctrs->route_length, ctrs->drop_length);
+#define LNET_PROC_VER_GET(pos)                         \
+       (int)(((pos) >> LNET_PROC_HPOS_BITS) & LNET_PROC_VER_MASK)
 
-        LIBCFS_FREE(ctrs, sizeof(*ctrs));
-        return rc;
-}
+#define LNET_PROC_HASH_GET(pos)                                \
+       (int)(((pos) >> LNET_PROC_HOFF_BITS) & LNET_PROC_HASH_MASK)
 
-static int
-lnet_router_proc_stats_write(struct file *file, const char *ubuffer,
-                     unsigned long count, void *data)
-{
-        LNET_LOCK();
-        memset(&the_lnet.ln_counters, 0, sizeof(the_lnet.ln_counters));
-        LNET_UNLOCK();
+#define LNET_PROC_HOFF_GET(pos)                                \
+       (int)((pos) & LNET_PROC_HOFF_MASK)
 
-        return (count);
-}
+#define LNET_PROC_POS_MAKE(cpt, ver, hash, off)                \
+       (((((loff_t)(cpt)) & LNET_PROC_CPT_MASK) << LNET_PROC_VPOS_BITS) |   \
+       ((((loff_t)(ver)) & LNET_PROC_VER_MASK) << LNET_PROC_HPOS_BITS) |   \
+       ((((loff_t)(hash)) & LNET_PROC_HASH_MASK) << LNET_PROC_HOFF_BITS) | \
+       ((off) & LNET_PROC_HOFF_MASK))
 
-typedef struct {
-        __u64                lrsi_version;
-        lnet_remotenet_t    *lrsi_net;
-        lnet_route_t        *lrsi_route;
-        loff_t               lrsi_off;
-} lnet_route_seq_iterator_t;
+#define LNET_PROC_VERSION(v)   ((unsigned int)((v) & LNET_PROC_VER_MASK))
 
-int
-lnet_route_seq_seek (lnet_route_seq_iterator_t *lrsi, loff_t off)
+static int __proc_lnet_stats(void *data, int write,
+                            loff_t pos, void __user *buffer, int nob)
 {
-        struct list_head  *n;
-        struct list_head  *r;
-        int                rc;
-        loff_t             here;
-
-        if (off == 0) {
-                lrsi->lrsi_net = NULL;
-                lrsi->lrsi_route = NULL;
-                lrsi->lrsi_off = 0;
-                return 0;
-        }
-
-        LNET_LOCK();
+        int              rc;
+        lnet_counters_t *ctrs;
+        int              len;
+        char            *tmpstr;
+        const int        tmpsiz = 256; /* 7 %u and 4 LPU64 */
 
-        if (lrsi->lrsi_net != NULL &&
-            lrsi->lrsi_version != the_lnet.ln_remote_nets_version) {
-                /* tables have changed */
-                rc = -ESTALE;
-                goto out;
+        if (write) {
+               lnet_counters_reset();
+               return 0;
         }
 
-        if (lrsi->lrsi_net == NULL || lrsi->lrsi_off > off) {
-                /* search from start */
-                n = the_lnet.ln_remote_nets.next;
-                r = NULL;
-                here = 1;
-        } else {
-                /* continue search */
-                n = &lrsi->lrsi_net->lrn_list;
-                r = &lrsi->lrsi_route->lr_list;
-                here = lrsi->lrsi_off;
-        }
+        /* read */
 
-        lrsi->lrsi_version = the_lnet.ln_remote_nets_version;
-        lrsi->lrsi_off        = off;
-
-        while (n != &the_lnet.ln_remote_nets) {
-                lnet_remotenet_t *rnet =
-                        list_entry(n, lnet_remotenet_t, lrn_list);
-
-                if (r == NULL)
-                        r = rnet->lrn_routes.next;
-
-                while (r != &rnet->lrn_routes) {
-                        lnet_route_t *re =
-                                list_entry(r, lnet_route_t,
-                                           lr_list);
-
-                        if (here == off) {
-                                lrsi->lrsi_net = rnet;
-                                lrsi->lrsi_route = re;
-                                rc = 0;
-                                goto out;
-                        }
-
-                        r = r->next;
-                        here++;
-                }
+        LIBCFS_ALLOC(ctrs, sizeof(*ctrs));
+        if (ctrs == NULL)
+                return -ENOMEM;
 
-                r = NULL;
-                n = n->next;
+        LIBCFS_ALLOC(tmpstr, tmpsiz);
+        if (tmpstr == NULL) {
+                LIBCFS_FREE(ctrs, sizeof(*ctrs));
+                return -ENOMEM;
         }
 
-        lrsi->lrsi_net   = NULL;
-        lrsi->lrsi_route = NULL;
-        rc             = -ENOENT;
- out:
-        LNET_UNLOCK();
-        return rc;
-}
-
-static void *
-lnet_route_seq_start (struct seq_file *s, loff_t *pos)
-{
-        lnet_route_seq_iterator_t *lrsi;
-        int                        rc;
+       lnet_counters_get(ctrs);
 
-        LIBCFS_ALLOC(lrsi, sizeof(*lrsi));
-        if (lrsi == NULL)
-                return NULL;
-
-        lrsi->lrsi_net = NULL;
-        rc = lnet_route_seq_seek(lrsi, *pos);
-        if (rc == 0)
-                return lrsi;
-
-        LIBCFS_FREE(lrsi, sizeof(*lrsi));
-        return NULL;
-}
-
-static void
-lnet_route_seq_stop (struct seq_file *s, void *iter)
-{
-        lnet_route_seq_iterator_t  *lrsi = iter;
-
-        if (lrsi != NULL)
-                LIBCFS_FREE(lrsi, sizeof(*lrsi));
-}
+        len = snprintf(tmpstr, tmpsiz,
+                       "%u %u %u %u %u %u %u "LPU64" "LPU64" "
+                       LPU64" "LPU64,
+                       ctrs->msgs_alloc, ctrs->msgs_max,
+                       ctrs->errors,
+                       ctrs->send_count, ctrs->recv_count,
+                       ctrs->route_count, ctrs->drop_count,
+                       ctrs->send_length, ctrs->recv_length,
+                       ctrs->route_length, ctrs->drop_length);
 
-static void *
-lnet_route_seq_next (struct seq_file *s, void *iter, loff_t *pos)
-{
-        lnet_route_seq_iterator_t *lrsi = iter;
-        int                        rc;
-        loff_t                     next = *pos + 1;
-
-        rc = lnet_route_seq_seek(lrsi, next);
-        if (rc != 0) {
-                LIBCFS_FREE(lrsi, sizeof(*lrsi));
-                return NULL;
-        }
+        if (pos >= min_t(int, len, strlen(tmpstr)))
+                rc = 0;
+        else
+                rc = cfs_trace_copyout_string(buffer, nob,
+                                              tmpstr + pos, "\n");
 
-        *pos = next;
-        return lrsi;
+        LIBCFS_FREE(tmpstr, tmpsiz);
+        LIBCFS_FREE(ctrs, sizeof(*ctrs));
+        return rc;
 }
 
 static int
-lnet_route_seq_show (struct seq_file *s, void *iter)
+proc_lnet_stats(struct ctl_table *table, int write, void __user *buffer,
+               size_t *lenp, loff_t *ppos)
 {
-        lnet_route_seq_iterator_t *lrsi = iter;
-        __u32                      net;
-        unsigned int               hops;
-        lnet_nid_t                 nid;
-        int                        alive;
-
-        if (lrsi->lrsi_off == 0) {
-                seq_printf(s, "Routing %s\n",
-                           the_lnet.ln_routing ? "enabled" : "disabled");
-                seq_printf(s, "%-8s %4s %7s %s\n",
-                           "net", "hops", "state", "router");
-                return 0;
-        }
-
-        LASSERT (lrsi->lrsi_net != NULL);
-        LASSERT (lrsi->lrsi_route != NULL);
-
-        LNET_LOCK();
-
-        if (lrsi->lrsi_version != the_lnet.ln_remote_nets_version) {
-                LNET_UNLOCK();
-                return -ESTALE;
-        }
-
-        net   = lrsi->lrsi_net->lrn_net;
-        hops  = lrsi->lrsi_net->lrn_hops;
-        nid   = lrsi->lrsi_route->lr_gateway->lp_nid;
-        alive = lrsi->lrsi_route->lr_gateway->lp_alive;
-
-        LNET_UNLOCK();
-
-        seq_printf(s, "%-8s %4u %7s %s\n", libcfs_net2str(net), hops,
-                   alive ? "up" : "down", libcfs_nid2str(nid));
-        return 0;
+       return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
+                                   __proc_lnet_stats);
 }
 
-static struct seq_operations lnet_routes_sops = {
-        /* start */ lnet_route_seq_start,
-        /* stop */  lnet_route_seq_stop,
-        /* next */  lnet_route_seq_next,
-        /* show */  lnet_route_seq_show,
-};
-
 static int
-lnet_route_seq_open(struct inode *inode, struct file *file)
+proc_lnet_routes(struct ctl_table *table, int write, void __user *buffer,
+                size_t *lenp, loff_t *ppos)
 {
-        struct proc_dir_entry *dp = PDE(inode);
-        struct seq_file       *sf;
-        int                    rc;
-
-        rc = seq_open(file, &lnet_routes_sops);
-        if (rc == 0) {
-                sf = file->private_data;
-                sf->private = dp->data;
-        }
+       const int       tmpsiz = 256;
+       char            *tmpstr;
+       char            *s;
+       int             rc = 0;
+       int             len;
+       int             ver;
+       int             off;
 
-        return rc;
-}
+       CLASSERT(sizeof(loff_t) >= 4);
 
-static struct file_operations lnet_routes_fops;
+       off = LNET_PROC_HOFF_GET(*ppos);
+       ver = LNET_PROC_VER_GET(*ppos);
 
-static void
-lnet_init_routes_fops(void)
-{
-        lnet_routes_fops.owner   =  THIS_MODULE;
-        lnet_routes_fops.llseek  =  seq_lseek;
-        lnet_routes_fops.read    =  seq_read;
-        lnet_routes_fops.open    =  lnet_route_seq_open;
-        lnet_routes_fops.release =  seq_release;
-}
+        LASSERT (!write);
 
-typedef struct {
-        __u64                lrtrsi_version;
-        lnet_peer_t         *lrtrsi_router;
-        loff_t               lrtrsi_off;
-} lnet_router_seq_iterator_t;
-
-int
-lnet_router_seq_seek (lnet_router_seq_iterator_t *lrtrsi, loff_t off)
-{
-        struct list_head  *r;
-        lnet_peer_t       *lp;
-        int                rc;
-        loff_t             here;
-
-        if (off == 0) {
-                lrtrsi->lrtrsi_router = NULL;
-                lrtrsi->lrtrsi_off = 0;
+        if (*lenp == 0)
                 return 0;
-        }
-
-        LNET_LOCK();
 
-        lp = lrtrsi->lrtrsi_router;
-
-        if (lp != NULL &&
-            lrtrsi->lrtrsi_version != the_lnet.ln_routers_version) {
-                /* tables have changed */
-                rc = -ESTALE;
-                goto out;
-        }
-
-        if (lp == NULL || lrtrsi->lrtrsi_off > off) {
-                /* search from start */
-                r = the_lnet.ln_routers.next;
-                here = 1;
-        } else {
-                /* continue search */
-                r = &lp->lp_rtr_list;
-                here = lrtrsi->lrtrsi_off;
-        }
-
-        lrtrsi->lrtrsi_version = the_lnet.ln_routers_version;
-        lrtrsi->lrtrsi_off     = off;
-
-        while (r != &the_lnet.ln_routers) {
-                lnet_peer_t *rtr = list_entry(r, 
-                                              lnet_peer_t,
-                                              lp_rtr_list);
+        LIBCFS_ALLOC(tmpstr, tmpsiz);
+        if (tmpstr == NULL)
+                return -ENOMEM;
 
-                if (here == off) {
-                        lrtrsi->lrtrsi_router = rtr;
-                        rc = 0;
-                        goto out;
+        s = tmpstr; /* points to current position in tmpstr[] */
+
+        if (*ppos == 0) {
+                s += snprintf(s, tmpstr + tmpsiz - s, "Routing %s\n",
+                              the_lnet.ln_routing ? "enabled" : "disabled");
+                LASSERT (tmpstr + tmpsiz - s > 0);
+
+               s += snprintf(s, tmpstr + tmpsiz - s, "%-8s %4s %8s %7s %s\n",
+                             "net", "hops", "priority", "state", "router");
+                LASSERT (tmpstr + tmpsiz - s > 0);
+
+               lnet_net_lock(0);
+               ver = (unsigned int)the_lnet.ln_remote_nets_version;
+               lnet_net_unlock(0);
+               *ppos = LNET_PROC_POS_MAKE(0, ver, 0, off);
+       } else {
+               struct list_head        *n;
+               struct list_head        *r;
+               lnet_route_t            *route = NULL;
+               lnet_remotenet_t        *rnet  = NULL;
+               int                     skip  = off - 1;
+               struct list_head        *rn_list;
+               int                     i;
+
+               lnet_net_lock(0);
+
+               if (ver != LNET_PROC_VERSION(the_lnet.ln_remote_nets_version)) {
+                       lnet_net_unlock(0);
+                       LIBCFS_FREE(tmpstr, tmpsiz);
+                       return -ESTALE;
+               }
+
+               for (i = 0; i < LNET_REMOTE_NETS_HASH_SIZE && route == NULL;
+                    i++) {
+                       rn_list = &the_lnet.ln_remote_nets_hash[i];
+
+                       n = rn_list->next;
+
+                       while (n != rn_list && route == NULL) {
+                               rnet = list_entry(n, lnet_remotenet_t,
+                                                 lrn_list);
+
+                               r = rnet->lrn_routes.next;
+
+                               while (r != &rnet->lrn_routes) {
+                                       lnet_route_t *re =
+                                               list_entry(r, lnet_route_t,
+                                                          lr_list);
+                                       if (skip == 0) {
+                                               route = re;
+                                               break;
+                                       }
+
+                                       skip--;
+                                       r = r->next;
+                               }
+
+                               n = n->next;
+                       }
+               }
+
+                if (route != NULL) {
+                       __u32        net        = rnet->lrn_net;
+                       unsigned int hops       = route->lr_hops;
+                       unsigned int priority   = route->lr_priority;
+                       lnet_nid_t   nid        = route->lr_gateway->lp_nid;
+                       int          alive      = lnet_is_route_alive(route);
+
+                       s += snprintf(s, tmpstr + tmpsiz - s,
+                                     "%-8s %4u %8u %7s %s\n",
+                                     libcfs_net2str(net), hops,
+                                     priority,
+                                     alive ? "up" : "down",
+                                     libcfs_nid2str(nid));
+                       LASSERT(tmpstr + tmpsiz - s > 0);
+               }
+
+               lnet_net_unlock(0);
+        }
+
+        len = s - tmpstr;     /* how many bytes was written */
+
+        if (len > *lenp) {    /* linux-supplied buffer is too small */
+                rc = -EINVAL;
+        } else if (len > 0) { /* wrote something */
+               if (copy_to_user(buffer, tmpstr, len))
+                        rc = -EFAULT;
+                else {
+                       off += 1;
+                       *ppos = LNET_PROC_POS_MAKE(0, ver, 0, off);
                 }
-
-                r = r->next;
-                here++;
         }
 
-        lrtrsi->lrtrsi_router = NULL;
-        rc = -ENOENT;
- out:
-        LNET_UNLOCK();
-        return rc;
-}
-
-static void *
-lnet_router_seq_start (struct seq_file *s, loff_t *pos)
-{
-        lnet_router_seq_iterator_t *lrtrsi;
-        int                        rc;
+        LIBCFS_FREE(tmpstr, tmpsiz);
 
-        LIBCFS_ALLOC(lrtrsi, sizeof(*lrtrsi));
-        if (lrtrsi == NULL)
-                return NULL;
-
-        lrtrsi->lrtrsi_router = NULL;
-        rc = lnet_router_seq_seek(lrtrsi, *pos);
         if (rc == 0)
-                return lrtrsi;
-
-        LIBCFS_FREE(lrtrsi, sizeof(*lrtrsi));
-        return NULL;
-}
-
-static void
-lnet_router_seq_stop (struct seq_file *s, void *iter)
-{
-        lnet_router_seq_iterator_t  *lrtrsi = iter;
-
-        if (lrtrsi != NULL)
-                LIBCFS_FREE(lrtrsi, sizeof(*lrtrsi));
-}
-
-static void *
-lnet_router_seq_next (struct seq_file *s, void *iter, loff_t *pos)
-{
-        lnet_router_seq_iterator_t *lrtrsi = iter;
-        int                        rc;
-        loff_t                     next = *pos + 1;
-
-        rc = lnet_router_seq_seek(lrtrsi, next);
-        if (rc != 0) {
-                LIBCFS_FREE(lrtrsi, sizeof(*lrtrsi));
-                return NULL;
-        }
-
-        *pos = next;
-        return lrtrsi;
-}
+                *lenp = len;
 
-static int
-lnet_router_seq_show (struct seq_file *s, void *iter)
-{
-        lnet_router_seq_iterator_t *lrtrsi = iter;
-        lnet_peer_t *lp;
-        lnet_nid_t   nid;
-        int          alive;
-        int          alive_cnt;
-        int          nrefs;
-        int          nrtrrefs;
-        time_t       last_ping;
-
-        if (lrtrsi->lrtrsi_off == 0) {
-                seq_printf(s, "%-4s %7s %9s %6s %12s %s\n",
-                           "ref", "rtr_ref", "alive_cnt", "state", "last_ping", "router");
-                return 0;
-        }
-
-        lp = lrtrsi->lrtrsi_router;
-        LASSERT (lp != NULL);
-
-        LNET_LOCK();
-
-        if (lrtrsi->lrtrsi_version != the_lnet.ln_routers_version) {
-                LNET_UNLOCK();
-                return -ESTALE;
-        }
-
-        nid       = lp->lp_nid;
-        alive     = lp->lp_alive;
-        alive_cnt = lp->lp_alive_count;
-        nrefs     = lp->lp_refcount;
-        nrtrrefs  = lp->lp_rtr_refcount;
-        last_ping = lp->lp_ping_timestamp;
-
-        LNET_UNLOCK();
-
-        seq_printf(s,
-                   "%-4d %7d %9d %6s %12lu %s\n", nrefs, nrtrrefs,
-                   alive_cnt, alive ? "up" : "down",
-                   last_ping, libcfs_nid2str(nid));
-        return 0;
+        return rc;
 }
 
-static struct seq_operations lnet_routers_sops = {
-        /* start */ lnet_router_seq_start,
-        /* stop */  lnet_router_seq_stop,
-        /* next */  lnet_router_seq_next,
-        /* show */  lnet_router_seq_show,
-};
-
 static int
-lnet_router_seq_open(struct inode *inode, struct file *file)
+proc_lnet_routers(struct ctl_table *table, int write, void __user *buffer,
+                 size_t *lenp, loff_t *ppos)
 {
-        struct proc_dir_entry *dp = PDE(inode);
-        struct seq_file       *sf;
-        int                    rc;
-
-        rc = seq_open(file, &lnet_routers_sops);
-        if (rc == 0) {
-                sf = file->private_data;
-                sf->private = dp->data;
-        }
+        int        rc = 0;
+        char      *tmpstr;
+        char      *s;
+        const int  tmpsiz = 256;
+        int        len;
+        int        ver;
+       int        off;
 
-        return rc;
-}
+       off = LNET_PROC_HOFF_GET(*ppos);
+       ver = LNET_PROC_VER_GET(*ppos);
 
-static struct file_operations lnet_routers_fops;
+        LASSERT (!write);
 
-static void
-lnet_init_routers_fops(void)
-{
-        lnet_routers_fops.owner   =  THIS_MODULE;
-        lnet_routers_fops.llseek  =  seq_lseek;
-        lnet_routers_fops.read    =  seq_read;
-        lnet_routers_fops.open    =  lnet_router_seq_open;
-        lnet_routers_fops.release =  seq_release;
-}
-
-typedef struct {
-        unsigned long long   lpsi_version;
-        int                  lpsi_idx;
-        lnet_peer_t         *lpsi_peer;
-        loff_t               lpsi_off;
-} lnet_peer_seq_iterator_t;
-
-int
-lnet_peer_seq_seek (lnet_peer_seq_iterator_t *lpsi, loff_t off)
-{
-        int                idx;
-        struct list_head  *p;
-        loff_t             here;
-        int                rc;
-
-        if (off == 0) {
-                lpsi->lpsi_idx = 0;
-                lpsi->lpsi_peer = NULL;
-                lpsi->lpsi_off = 0;
+        if (*lenp == 0)
                 return 0;
-        }
 
-        LNET_LOCK();
-
-        if (lpsi->lpsi_peer != NULL &&
-            lpsi->lpsi_version != the_lnet.ln_peertable_version) {
-                /* tables have changed */
-                rc = -ESTALE;
-                goto out;
-        }
+        LIBCFS_ALLOC(tmpstr, tmpsiz);
+        if (tmpstr == NULL)
+                return -ENOMEM;
 
-        if (lpsi->lpsi_peer == NULL ||
-            lpsi->lpsi_off > off) {
-                /* search from start */
-                idx = 0;
-                p = NULL;
-                here = 1;
-        } else {
-                /* continue search */
-                idx = lpsi->lpsi_idx;
-                p = &lpsi->lpsi_peer->lp_hashlist;
-                here = lpsi->lpsi_off;
-        }
+        s = tmpstr; /* points to current position in tmpstr[] */
 
-        lpsi->lpsi_version = the_lnet.ln_peertable_version;
-        lpsi->lpsi_off     = off;
+        if (*ppos == 0) {
+               s += snprintf(s, tmpstr + tmpsiz - s,
+                             "%-4s %7s %9s %6s %12s %9s %8s %7s %s\n",
+                             "ref", "rtr_ref", "alive_cnt", "state",
+                             "last_ping", "ping_sent", "deadline",
+                             "down_ni", "router");
+               LASSERT(tmpstr + tmpsiz - s > 0);
 
-        while (idx < LNET_PEER_HASHSIZE) {
-                if (p == NULL)
-                        p = the_lnet.ln_peer_hash[idx].next;
+               lnet_net_lock(0);
+               ver = (unsigned int)the_lnet.ln_routers_version;
+               lnet_net_unlock(0);
+               *ppos = LNET_PROC_POS_MAKE(0, ver, 0, off);
+       } else {
+               struct list_head *r;
+               struct lnet_peer *peer = NULL;
+               int               skip = off - 1;
 
-                while (p != &the_lnet.ln_peer_hash[idx]) {
-                        lnet_peer_t *lp = list_entry(p, lnet_peer_t,
-                                                     lp_hashlist);
+               lnet_net_lock(0);
 
-                        if (here == off) {
-                                lpsi->lpsi_idx = idx;
-                                lpsi->lpsi_peer = lp;
-                                rc = 0;
-                                goto out;
-                        }
+               if (ver != LNET_PROC_VERSION(the_lnet.ln_routers_version)) {
+                       lnet_net_unlock(0);
 
-                        here++;
-                        p = lp->lp_hashlist.next;
+                        LIBCFS_FREE(tmpstr, tmpsiz);
+                        return -ESTALE;
                 }
 
-                p = NULL;
-                idx++;
-        }
-
-        lpsi->lpsi_idx  = 0;
-        lpsi->lpsi_peer = NULL;
-        rc              = -ENOENT;
- out:
-        LNET_UNLOCK();
-        return rc;
-}
-
-static void *
-lnet_peer_seq_start (struct seq_file *s, loff_t *pos)
-{
-        lnet_peer_seq_iterator_t *lpsi;
-        int                        rc;
-
-        LIBCFS_ALLOC(lpsi, sizeof(*lpsi));
-        if (lpsi == NULL)
-                return NULL;
-
-        lpsi->lpsi_idx = 0;
-        lpsi->lpsi_peer = NULL;
-        rc = lnet_peer_seq_seek(lpsi, *pos);
-        if (rc == 0)
-                return lpsi;
+                r = the_lnet.ln_routers.next;
 
-        LIBCFS_FREE(lpsi, sizeof(*lpsi));
-        return NULL;
-}
+               while (r != &the_lnet.ln_routers) {
+                       lnet_peer_t *lp = list_entry(r, lnet_peer_t,
+                                                    lp_rtr_list);
 
-static void
-lnet_peer_seq_stop (struct seq_file *s, void *iter)
-{
-        lnet_peer_seq_iterator_t  *lpsi = iter;
-
-        if (lpsi != NULL)
-                LIBCFS_FREE(lpsi, sizeof(*lpsi));
-}
+                        if (skip == 0) {
+                                peer = lp;
+                                break;
+                        }
 
-static void *
-lnet_peer_seq_next (struct seq_file *s, void *iter, loff_t *pos)
-{
-        lnet_peer_seq_iterator_t *lpsi = iter;
-        int                       rc;
-        loff_t                    next = *pos + 1;
-
-        rc = lnet_peer_seq_seek(lpsi, next);
-        if (rc != 0) {
-                LIBCFS_FREE(lpsi, sizeof(*lpsi));
-                return NULL;
-        }
+                        skip--;
+                        r = r->next;
+                }
 
-        *pos = next;
-        return lpsi;
-}
+                if (peer != NULL) {
+                        lnet_nid_t nid = peer->lp_nid;
+                        cfs_time_t now = cfs_time_current();
+                        cfs_time_t deadline = peer->lp_ping_deadline;
+                        int nrefs     = peer->lp_refcount;
+                        int nrtrrefs  = peer->lp_rtr_refcount;
+                        int alive_cnt = peer->lp_alive_count;
+                        int alive     = peer->lp_alive;
+                        int pingsent  = !peer->lp_ping_notsent;
+                        int last_ping = cfs_duration_sec(cfs_time_sub(now,
+                                                     peer->lp_ping_timestamp));
+                       int down_ni   = 0;
+                       lnet_route_t *rtr;
+
+                       if ((peer->lp_ping_feats &
+                            LNET_PING_FEAT_NI_STATUS) != 0) {
+                               list_for_each_entry(rtr, &peer->lp_routes,
+                                                   lr_gwlist) {
+                                       /* downis on any route should be the
+                                        * number of downis on the gateway */
+                                       if (rtr->lr_downis != 0) {
+                                               down_ni = rtr->lr_downis;
+                                               break;
+                                       }
+                               }
+                       }
+
+                        if (deadline == 0)
+                                s += snprintf(s, tmpstr + tmpsiz - s,
+                                              "%-4d %7d %9d %6s %12d %9d %8s %7d %s\n",
+                                              nrefs, nrtrrefs, alive_cnt,
+                                              alive ? "up" : "down", last_ping,
+                                              pingsent, "NA", down_ni,
+                                              libcfs_nid2str(nid));
+                        else
+                                s += snprintf(s, tmpstr + tmpsiz - s,
+                                              "%-4d %7d %9d %6s %12d %9d %8lu %7d %s\n",
+                                              nrefs, nrtrrefs, alive_cnt,
+                                              alive ? "up" : "down", last_ping,
+                                              pingsent,
+                                              cfs_duration_sec(cfs_time_sub(deadline, now)),
+                                              down_ni, libcfs_nid2str(nid));
+                        LASSERT (tmpstr + tmpsiz - s > 0);
+                }
 
-static int
-lnet_peer_seq_show (struct seq_file *s, void *iter)
-{
-        lnet_peer_seq_iterator_t *lpsi = iter;
-        char                     *aliveness = "NA";
-        lnet_peer_t              *lp;
-        lnet_nid_t                nid;
-        int                       maxcr;
-        int                       mintxcr;
-        int                       txcr;
-        int                       minrtrcr;
-        int                       rtrcr;
-        int                       txqnob;
-        int                       nrefs;
-
-        if (lpsi->lpsi_off == 0) {
-                seq_printf(s, "%-24s %4s %5s %5s %5s %5s %5s %5s %s\n",
-                           "nid", "refs", "state", "max",
-                           "rtr", "min", "tx", "min", "queue");
-                return 0;
+               lnet_net_unlock(0);
         }
 
-        LASSERT (lpsi->lpsi_peer != NULL);
-
-        LNET_LOCK();
+        len = s - tmpstr;     /* how many bytes was written */
 
-        if (lpsi->lpsi_version != the_lnet.ln_peertable_version) {
-                LNET_UNLOCK();
-                return -ESTALE;
+        if (len > *lenp) {    /* linux-supplied buffer is too small */
+                rc = -EINVAL;
+        } else if (len > 0) { /* wrote something */
+               if (copy_to_user(buffer, tmpstr, len))
+                        rc = -EFAULT;
+                else {
+                       off += 1;
+                       *ppos = LNET_PROC_POS_MAKE(0, ver, 0, off);
+                }
         }
 
-        lp = lpsi->lpsi_peer;
-
-        nid      = lp->lp_nid;
-        maxcr    = lp->lp_ni->ni_peertxcredits;
-        txcr     = lp->lp_txcredits;
-        mintxcr  = lp->lp_mintxcredits;
-        rtrcr    = lp->lp_rtrcredits;
-        minrtrcr = lp->lp_minrtrcredits;
-        txqnob   = lp->lp_txqnob;
-        nrefs    = lp->lp_refcount;
+        LIBCFS_FREE(tmpstr, tmpsiz);
 
-        if (lnet_isrouter(lp) || lp->lp_ni->ni_peertimeout > 0)
-                aliveness = lp->lp_alive ? "up" : "down";
-
-        LNET_UNLOCK();
+        if (rc == 0)
+                *lenp = len;
 
-        seq_printf(s, "%-24s %4d %5s %5d %5d %5d %5d %5d %d\n",
-                   libcfs_nid2str(nid), nrefs, aliveness,
-                   maxcr, rtrcr, minrtrcr, txcr, mintxcr, txqnob);
-        return 0;
+        return rc;
 }
 
-static struct seq_operations lnet_peer_sops = {
-        /* start */ lnet_peer_seq_start,
-        /* stop */  lnet_peer_seq_stop,
-        /* next */  lnet_peer_seq_next,
-        /* show */  lnet_peer_seq_show,
-};
-
 static int
-lnet_peer_seq_open(struct inode *inode, struct file *file)
-{
-        struct proc_dir_entry *dp = PDE(inode);
-        struct seq_file       *sf;
-        int                    rc;
-
-        rc = seq_open(file, &lnet_peer_sops);
-        if (rc == 0) {
-                sf = file->private_data;
-                sf->private = dp->data;
-        }
+proc_lnet_peers(struct ctl_table *table, int write, void __user *buffer,
+               size_t *lenp, loff_t *ppos)
+{
+       const int               tmpsiz  = 256;
+       struct lnet_peer_table  *ptable;
+       char                    *tmpstr;
+       char                    *s;
+       int                     cpt  = LNET_PROC_CPT_GET(*ppos);
+       int                     ver  = LNET_PROC_VER_GET(*ppos);
+       int                     hash = LNET_PROC_HASH_GET(*ppos);
+       int                     hoff = LNET_PROC_HOFF_GET(*ppos);
+       int                     rc = 0;
+       int                     len;
+
+       CLASSERT(LNET_PROC_HASH_BITS >= LNET_PEER_HASH_BITS);
+       LASSERT(!write);
+
+       if (*lenp == 0)
+               return 0;
+
+       if (cpt >= LNET_CPT_NUMBER) {
+               *lenp = 0;
+               return 0;
+       }
+
+        LIBCFS_ALLOC(tmpstr, tmpsiz);
+        if (tmpstr == NULL)
+                return -ENOMEM;
 
-        return rc;
-}
+        s = tmpstr; /* points to current position in tmpstr[] */
+
+        if (*ppos == 0) {
+                s += snprintf(s, tmpstr + tmpsiz - s,
+                              "%-24s %4s %5s %5s %5s %5s %5s %5s %5s %s\n",
+                              "nid", "refs", "state", "last", "max",
+                              "rtr", "min", "tx", "min", "queue");
+                LASSERT (tmpstr + tmpsiz - s > 0);
+
+               hoff++;
+       } else {
+               struct lnet_peer        *peer;
+               struct list_head        *p;
+               int                     skip;
+ again:
+               p = NULL;
+               peer = NULL;
+               skip = hoff - 1;
+
+               lnet_net_lock(cpt);
+               ptable = the_lnet.ln_peer_tables[cpt];
+               if (hoff == 1)
+                       ver = LNET_PROC_VERSION(ptable->pt_version);
+
+               if (ver != LNET_PROC_VERSION(ptable->pt_version)) {
+                       lnet_net_unlock(cpt);
+                       LIBCFS_FREE(tmpstr, tmpsiz);
+                       return -ESTALE;
+               }
+
+               while (hash < LNET_PEER_HASH_SIZE) {
+                       if (p == NULL)
+                               p = ptable->pt_hash[hash].next;
+
+                       while (p != &ptable->pt_hash[hash]) {
+                               lnet_peer_t *lp = list_entry(p, lnet_peer_t,
+                                                            lp_hashlist);
+                                if (skip == 0) {
+                                        peer = lp;
+
+                                        /* minor optimization: start from idx+1
+                                         * on next iteration if we've just
+                                         * drained lp_hashlist */
+                                       if (lp->lp_hashlist.next ==
+                                           &ptable->pt_hash[hash]) {
+                                               hoff = 1;
+                                               hash++;
+                                       } else {
+                                               hoff++;
+                                        }
+
+                                        break;
+                                }
+
+                                skip--;
+                                p = lp->lp_hashlist.next;
+                        }
 
-static struct file_operations lnet_peer_fops;
+                        if (peer != NULL)
+                                break;
 
-static void
-lnet_init_peer_fops(void)
-{
-        lnet_peer_fops.owner   =  THIS_MODULE;
-        lnet_peer_fops.llseek  =  seq_lseek;
-        lnet_peer_fops.read    =  seq_read;
-        lnet_peer_fops.open    =  lnet_peer_seq_open;
-        lnet_peer_fops.release =  seq_release;
-}
+                        p = NULL;
+                       hoff = 1;
+                       hash++;
+                }
 
-typedef struct {
-        int                  lbsi_idx;
-        loff_t               lbsi_off;
-} lnet_buffer_seq_iterator_t;
+                if (peer != NULL) {
+                        lnet_nid_t nid       = peer->lp_nid;
+                        int        nrefs     = peer->lp_refcount;
+                        int        lastalive = -1;
+                        char      *aliveness = "NA";
+                        int        maxcr     = peer->lp_ni->ni_peertxcredits;
+                        int        txcr      = peer->lp_txcredits;
+                        int        mintxcr   = peer->lp_mintxcredits;
+                        int        rtrcr     = peer->lp_rtrcredits;
+                        int        minrtrcr  = peer->lp_minrtrcredits;
+                        int        txqnob    = peer->lp_txqnob;
+
+                        if (lnet_peer_aliveness_enabled(peer)) {
+                               cfs_time_t     now = cfs_time_current();
+                               cfs_duration_t delta;
+
+                               aliveness = peer->lp_alive ? "up" : "down";
+                                delta = cfs_time_sub(now, peer->lp_last_alive);
+                                lastalive = cfs_duration_sec(delta);
+
+                                /* No need to mess up peers contents with
+                                 * arbitrarily long integers - it suffices to
+                                 * know that lastalive is more than 10000s old
+                                 */
+                                if (lastalive >= 10000)
+                                        lastalive = 9999;
+                        }
 
-int
-lnet_buffer_seq_seek (lnet_buffer_seq_iterator_t *lbsi, loff_t off)
-{
-        int                idx;
-        loff_t             here;
-        int                rc;
+                       lnet_net_unlock(cpt);
 
-        if (off == 0) {
-                lbsi->lbsi_idx = -1;
-                lbsi->lbsi_off = 0;
-                return 0;
-        }
+                        s += snprintf(s, tmpstr + tmpsiz - s,
+                                      "%-24s %4d %5s %5d %5d %5d %5d %5d %5d %d\n",
+                                      libcfs_nid2str(nid), nrefs, aliveness,
+                                      lastalive, maxcr, rtrcr, minrtrcr, txcr,
+                                      mintxcr, txqnob);
+                        LASSERT (tmpstr + tmpsiz - s > 0);
 
-        LNET_LOCK();
+               } else { /* peer is NULL */
+                       lnet_net_unlock(cpt);
+               }
 
-        if (lbsi->lbsi_idx < 0 ||
-            lbsi->lbsi_off > off) {
-                /* search from start */
-                idx = 0;
-                here = 1;
-        } else {
-                /* continue search */
-                idx = lbsi->lbsi_idx;
-                here = lbsi->lbsi_off;
+               if (hash == LNET_PEER_HASH_SIZE) {
+                       cpt++;
+                       hash = 0;
+                       hoff = 1;
+                       if (peer == NULL && cpt < LNET_CPT_NUMBER)
+                               goto again;
+               }
         }
 
-        lbsi->lbsi_off     = off;
+        len = s - tmpstr;     /* how many bytes was written */
 
-        while (idx < LNET_NRBPOOLS) {
-                if (here == off) {
-                        lbsi->lbsi_idx = idx;
-                        rc = 0;
-                        goto out;
-                }
-                here++;
-                idx++;
+        if (len > *lenp) {    /* linux-supplied buffer is too small */
+                rc = -EINVAL;
+        } else if (len > 0) { /* wrote something */
+               if (copy_to_user(buffer, tmpstr, len))
+                        rc = -EFAULT;
+                else
+                       *ppos = LNET_PROC_POS_MAKE(cpt, ver, hash, hoff);
         }
 
-        lbsi->lbsi_idx  = -1;
-        rc              = -ENOENT;
- out:
-        LNET_UNLOCK();
-        return rc;
-}
-
-static void *
-lnet_buffer_seq_start (struct seq_file *s, loff_t *pos)
-{
-        lnet_buffer_seq_iterator_t *lbsi;
-        int                        rc;
-
-        LIBCFS_ALLOC(lbsi, sizeof(*lbsi));
-        if (lbsi == NULL)
-                return NULL;
+        LIBCFS_FREE(tmpstr, tmpsiz);
 
-        lbsi->lbsi_idx = -1;
-        rc = lnet_buffer_seq_seek(lbsi, *pos);
         if (rc == 0)
-                return lbsi;
+                *lenp = len;
 
-        LIBCFS_FREE(lbsi, sizeof(*lbsi));
-        return NULL;
+        return rc;
 }
 
-static void
-lnet_buffer_seq_stop (struct seq_file *s, void *iter)
+static int __proc_lnet_buffers(void *data, int write,
+                              loff_t pos, void __user *buffer, int nob)
 {
-        lnet_buffer_seq_iterator_t  *lbsi = iter;
+       char            *s;
+       char            *tmpstr;
+       int             tmpsiz;
+       int             idx;
+       int             len;
+       int             rc;
+       int             i;
 
-        if (lbsi != NULL)
-                LIBCFS_FREE(lbsi, sizeof(*lbsi));
-}
+       LASSERT(!write);
 
-static void *
-lnet_buffer_seq_next (struct seq_file *s, void *iter, loff_t *pos)
-{
-        lnet_buffer_seq_iterator_t *lbsi = iter;
-        int                         rc;
-        loff_t                      next = *pos + 1;
-
-        rc = lnet_buffer_seq_seek(lbsi, next);
-        if (rc != 0) {
-                LIBCFS_FREE(lbsi, sizeof(*lbsi));
-                return NULL;
-        }
+       /* (4 %d) * 4 * LNET_CPT_NUMBER */
+       tmpsiz = 64 * (LNET_NRBPOOLS + 1) * LNET_CPT_NUMBER;
+        LIBCFS_ALLOC(tmpstr, tmpsiz);
+        if (tmpstr == NULL)
+                return -ENOMEM;
 
-        *pos = next;
-        return lbsi;
-}
+        s = tmpstr; /* points to current position in tmpstr[] */
 
-static int
-lnet_buffer_seq_show (struct seq_file *s, void *iter)
-{
-        lnet_buffer_seq_iterator_t *lbsi = iter;
-        lnet_rtrbufpool_t          *rbp;
-        int                         npages;
-        int                         nbuf;
-        int                         cr;
-        int                         mincr;
-
-        if (lbsi->lbsi_off == 0) {
-                seq_printf(s, "%5s %5s %7s %7s\n",
-                           "pages", "count", "credits", "min");
-                return 0;
-        }
+        s += snprintf(s, tmpstr + tmpsiz - s,
+                      "%5s %5s %7s %7s\n",
+                      "pages", "count", "credits", "min");
+        LASSERT (tmpstr + tmpsiz - s > 0);
 
-        LASSERT (lbsi->lbsi_idx >= 0 && lbsi->lbsi_idx < LNET_NRBPOOLS);
+       if (the_lnet.ln_rtrpools == NULL)
+               goto out; /* I'm not a router */
 
-        LNET_LOCK();
+       for (idx = 0; idx < LNET_NRBPOOLS; idx++) {
+               lnet_rtrbufpool_t *rbp;
 
-        rbp = &the_lnet.ln_rtrpools[lbsi->lbsi_idx];
+               lnet_net_lock(LNET_LOCK_EX);
+               cfs_percpt_for_each(rbp, i, the_lnet.ln_rtrpools) {
+                       s += snprintf(s, tmpstr + tmpsiz - s,
+                                     "%5d %5d %7d %7d\n",
+                                     rbp[idx].rbp_npages,
+                                     rbp[idx].rbp_nbuffers,
+                                     rbp[idx].rbp_credits,
+                                     rbp[idx].rbp_mincredits);
+                       LASSERT(tmpstr + tmpsiz - s > 0);
+               }
+               lnet_net_unlock(LNET_LOCK_EX);
+       }
 
-        npages = rbp->rbp_npages;
-        nbuf   = rbp->rbp_nbuffers;
-        cr     = rbp->rbp_credits;
-        mincr  = rbp->rbp_mincredits;
+ out:
+        len = s - tmpstr;
 
-        LNET_UNLOCK();
+        if (pos >= min_t(int, len, strlen(tmpstr)))
+                rc = 0;
+        else
+                rc = cfs_trace_copyout_string(buffer, nob,
+                                              tmpstr + pos, NULL);
 
-        seq_printf(s, "%5d %5d %7d %7d\n",
-                   npages, nbuf, cr, mincr);
-        return 0;
+        LIBCFS_FREE(tmpstr, tmpsiz);
+        return rc;
 }
 
-static struct seq_operations lnet_buffer_sops = {
-        /* start */ lnet_buffer_seq_start,
-        /* stop */  lnet_buffer_seq_stop,
-        /* next */  lnet_buffer_seq_next,
-        /* show */  lnet_buffer_seq_show,
-};
-
 static int
-lnet_buffer_seq_open(struct inode *inode, struct file *file)
+proc_lnet_buffers(struct ctl_table *table, int write, void __user *buffer,
+                 size_t *lenp, loff_t *ppos)
 {
-        struct proc_dir_entry *dp = PDE(inode);
-        struct seq_file       *sf;
-        int                    rc;
-
-        rc = seq_open(file, &lnet_buffer_sops);
-        if (rc == 0) {
-                sf = file->private_data;
-                sf->private = dp->data;
-        }
-
-        return rc;
+       return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
+                                   __proc_lnet_buffers);
 }
 
-static struct file_operations lnet_buffers_fops;
-
-static void
-lnet_init_buffers_fops(void)
+static int
+proc_lnet_nis(struct ctl_table *table, int write, void __user *buffer,
+             size_t *lenp, loff_t *ppos)
 {
-        lnet_buffers_fops.owner   =  THIS_MODULE;
-        lnet_buffers_fops.llseek  =  seq_lseek;
-        lnet_buffers_fops.read    =  seq_read;
-        lnet_buffers_fops.open    =  lnet_buffer_seq_open;
-        lnet_buffers_fops.release =  seq_release;
-}
+       int     tmpsiz = 128 * LNET_CPT_NUMBER;
+        int        rc = 0;
+        char      *tmpstr;
+        char      *s;
+        int        len;
 
-typedef struct {
-        lnet_ni_t           *lnsi_ni;
-        loff_t               lnsi_off;
-} lnet_ni_seq_iterator_t;
-
-int
-lnet_ni_seq_seek (lnet_ni_seq_iterator_t *lnsi, loff_t off)
-{
-        struct list_head  *n;
-        loff_t             here;
-        int                rc;
+        LASSERT (!write);
 
-        if (off == 0) {
-                lnsi->lnsi_ni = NULL;
-                lnsi->lnsi_off = 0;
+        if (*lenp == 0)
                 return 0;
-        }
 
-        LNET_LOCK();
+        LIBCFS_ALLOC(tmpstr, tmpsiz);
+        if (tmpstr == NULL)
+                return -ENOMEM;
+
+        s = tmpstr; /* points to current position in tmpstr[] */
 
-        if (lnsi->lnsi_ni == NULL ||
-            lnsi->lnsi_off > off) {
-                /* search from start */
-                n = NULL;
-                here = 1;
+        if (*ppos == 0) {
+                s += snprintf(s, tmpstr + tmpsiz - s,
+                              "%-24s %6s %5s %4s %4s %4s %5s %5s %5s\n",
+                              "nid", "status", "alive", "refs", "peer",
+                              "rtr", "max", "tx", "min");
+                LASSERT (tmpstr + tmpsiz - s > 0);
         } else {
-                /* continue search */
-                n = &lnsi->lnsi_ni->ni_list;
-                here = lnsi->lnsi_off;
-        }
+               struct list_head  *n;
+                lnet_ni_t         *ni   = NULL;
+                int                skip = *ppos - 1;
 
-        lnsi->lnsi_off = off;
+               lnet_net_lock(0);
 
-        if (n == NULL)
                 n = the_lnet.ln_nis.next;
 
-        while (n != &the_lnet.ln_nis) {
-                if (here == off) {
-                        lnsi->lnsi_ni = list_entry(n, lnet_ni_t, ni_list);
-                        rc = 0;
-                        goto out;
-                }
-                here++;
-                n = n->next;
-        }
+               while (n != &the_lnet.ln_nis) {
+                       lnet_ni_t *a_ni = list_entry(n, lnet_ni_t, ni_list);
 
-        lnsi->lnsi_ni  = NULL;
-        rc             = -ENOENT;
- out:
-        LNET_UNLOCK();
-        return rc;
-}
+                        if (skip == 0) {
+                                ni = a_ni;
+                                break;
+                        }
 
-static void *
-lnet_ni_seq_start (struct seq_file *s, loff_t *pos)
-{
-        lnet_ni_seq_iterator_t *lnsi;
-        int                     rc;
+                        skip--;
+                        n = n->next;
+                }
 
-        LIBCFS_ALLOC(lnsi, sizeof(*lnsi));
-        if (lnsi == NULL)
-                return NULL;
+                if (ni != NULL) {
+                       struct lnet_tx_queue    *tq;
+                       char    *stat;
+                       long    now = cfs_time_current_sec();
+                       int     last_alive = -1;
+                       int     i;
+                       int     j;
+
+                       if (the_lnet.ln_routing)
+                               last_alive = now - ni->ni_last_alive;
+
+                       /* @lo forever alive */
+                       if (ni->ni_lnd->lnd_type == LOLND)
+                               last_alive = 0;
+
+                       lnet_ni_lock(ni);
+                       LASSERT(ni->ni_status != NULL);
+                       stat = (ni->ni_status->ns_status ==
+                               LNET_NI_STATUS_UP) ? "up" : "down";
+                       lnet_ni_unlock(ni);
+
+                       /* we actually output credits information for
+                        * TX queue of each partition */
+                       cfs_percpt_for_each(tq, i, ni->ni_tx_queues) {
+                               for (j = 0; ni->ni_cpts != NULL &&
+                                    j < ni->ni_ncpts; j++) {
+                                       if (i == ni->ni_cpts[j])
+                                               break;
+                               }
+
+                               if (j == ni->ni_ncpts)
+                                       continue;
+
+                               if (i != 0)
+                                       lnet_net_lock(i);
+
+                               s += snprintf(s, tmpstr + tmpsiz - s,
+                                     "%-24s %6s %5d %4d %4d %4d %5d %5d %5d\n",
+                                     libcfs_nid2str(ni->ni_nid), stat,
+                                     last_alive, *ni->ni_refs[i],
+                                     ni->ni_peertxcredits,
+                                     ni->ni_peerrtrcredits,
+                                     tq->tq_credits_max,
+                                     tq->tq_credits, tq->tq_credits_min);
+                               if (i != 0)
+                                       lnet_net_unlock(i);
+                       }
+                       LASSERT(tmpstr + tmpsiz - s > 0);
+               }
+
+               lnet_net_unlock(0);
+        }
+
+        len = s - tmpstr;     /* how many bytes was written */
+
+        if (len > *lenp) {    /* linux-supplied buffer is too small */
+                rc = -EINVAL;
+        } else if (len > 0) { /* wrote something */
+               if (copy_to_user(buffer, tmpstr, len))
+                        rc = -EFAULT;
+                else
+                        *ppos += 1;
+        }
+
+        LIBCFS_FREE(tmpstr, tmpsiz);
 
-        lnsi->lnsi_ni = NULL;
-        rc = lnet_ni_seq_seek(lnsi, *pos);
         if (rc == 0)
-                return lnsi;
+                *lenp = len;
 
-        LIBCFS_FREE(lnsi, sizeof(*lnsi));
-        return NULL;
+        return rc;
 }
 
-static void
-lnet_ni_seq_stop (struct seq_file *s, void *iter)
-{
-        lnet_ni_seq_iterator_t  *lnsi = iter;
-
-        if (lnsi != NULL)
-                LIBCFS_FREE(lnsi, sizeof(*lnsi));
-}
+struct lnet_portal_rotors {
+       int             pr_value;
+       const char      *pr_name;
+       const char      *pr_desc;
+};
 
-static void *
-lnet_ni_seq_next (struct seq_file *s, void *iter, loff_t *pos)
-{
-        lnet_ni_seq_iterator_t *lnsi = iter;
-        int                     rc;
-        loff_t                  next = *pos + 1;
-
-        rc = lnet_ni_seq_seek(lnsi, next);
-        if (rc != 0) {
-                LIBCFS_FREE(lnsi, sizeof(*lnsi));
-                return NULL;
-        }
+static struct lnet_portal_rotors       portal_rotors[] = {
+       {
+               .pr_value = LNET_PTL_ROTOR_OFF,
+               .pr_name  = "OFF",
+               .pr_desc  = "Turn off message rotor for wildcard portals"
+       },
+       {
+               .pr_value = LNET_PTL_ROTOR_ON,
+               .pr_name  = "ON",
+               .pr_desc  = "round-robin dispatch all PUT messages for "
+                           "wildcard portals"
+       },
+       {
+               .pr_value = LNET_PTL_ROTOR_RR_RT,
+               .pr_name  = "RR_RT",
+               .pr_desc  = "round-robin dispatch routed PUT message for "
+                           "wildcard portals"
+       },
+       {
+               .pr_value = LNET_PTL_ROTOR_HASH_RT,
+               .pr_name  = "HASH_RT",
+               .pr_desc  = "dispatch routed PUT message by hashing source "
+                           "NID for wildcard portals"
+       },
+       {
+               .pr_value = -1,
+               .pr_name  = NULL,
+               .pr_desc  = NULL
+       },
+};
 
-        *pos = next;
-        return lnsi;
+extern int portal_rotor;
+
+static int __proc_lnet_portal_rotor(void *data, int write,
+                                   loff_t pos, void __user *buffer, int nob)
+{
+       const int       buf_len = 128;
+       char            *buf;
+       char            *tmp;
+       int             rc;
+       int             i;
+
+       LIBCFS_ALLOC(buf, buf_len);
+       if (buf == NULL)
+               return -ENOMEM;
+
+       if (!write) {
+               lnet_res_lock(0);
+
+               for (i = 0; portal_rotors[i].pr_value >= 0; i++) {
+                       if (portal_rotors[i].pr_value == portal_rotor)
+                               break;
+               }
+
+               LASSERT(portal_rotors[i].pr_value == portal_rotor);
+               lnet_res_unlock(0);
+
+               rc = snprintf(buf, buf_len,
+                             "{\n\tportals: all\n"
+                             "\trotor: %s\n\tdescription: %s\n}",
+                             portal_rotors[i].pr_name,
+                             portal_rotors[i].pr_desc);
+
+               if (pos >= min_t(int, rc, buf_len)) {
+                       rc = 0;
+               } else {
+                       rc = cfs_trace_copyout_string(buffer, nob,
+                                       buf + pos, "\n");
+               }
+               goto out;
+       }
+
+       rc = cfs_trace_copyin_string(buf, buf_len, buffer, nob);
+       if (rc < 0)
+               goto out;
+
+       tmp = cfs_trimwhite(buf);
+
+       rc = -EINVAL;
+       lnet_res_lock(0);
+       for (i = 0; portal_rotors[i].pr_name != NULL; i++) {
+               if (strncasecmp(portal_rotors[i].pr_name, tmp,
+                               strlen(portal_rotors[i].pr_name)) == 0) {
+                       portal_rotor = portal_rotors[i].pr_value;
+                       rc = 0;
+                       break;
+               }
+       }
+       lnet_res_unlock(0);
+out:
+       LIBCFS_FREE(buf, buf_len);
+       return rc;
 }
 
 static int
-lnet_ni_seq_show (struct seq_file *s, void *iter)
-{
-        lnet_ni_seq_iterator_t *lnsi = iter;
-        lnet_ni_t              *ni;
-        int                     maxtxcr;
-        int                     txcr;
-        int                     mintxcr;
-        int                     npeertxcr;
-        lnet_nid_t              nid;
-        int                     nref;
-
-        if (lnsi->lnsi_off == 0) {
-                seq_printf(s, "%-24s %4s %4s %5s %5s %5s\n",
-                           "nid", "refs", "peer", "max", "tx", "min");
-                return 0;
-        }
-
-        LASSERT (lnsi->lnsi_ni != NULL);
-
-        LNET_LOCK();
-
-        ni = lnsi->lnsi_ni;
-
-        maxtxcr   = ni->ni_maxtxcredits;
-        txcr      = ni->ni_txcredits;
-        mintxcr   = ni->ni_mintxcredits;
-        npeertxcr = ni->ni_peertxcredits;
-        nid       = ni->ni_nid;
-        nref      = ni->ni_refcount;
-
-        LNET_UNLOCK();
-
-        seq_printf(s, "%-24s %4d %4d %5d %5d %5d\n",
-                   libcfs_nid2str(nid), nref,
-                   npeertxcr, maxtxcr, txcr, mintxcr);
-        return 0;
-}
-
-static struct seq_operations lnet_ni_sops = {
-        /* start */ lnet_ni_seq_start,
-        /* stop */  lnet_ni_seq_stop,
-        /* next */  lnet_ni_seq_next,
-        /* show */  lnet_ni_seq_show,
+proc_lnet_portal_rotor(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_lnet_portal_rotor);
+}
+
+
+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       = "stats",
+               .mode           = 0644,
+               .proc_handler   = &proc_lnet_stats,
+       },
+       {
+               INIT_CTL_NAME
+               .procname       = "routes",
+               .mode           = 0444,
+               .proc_handler   = &proc_lnet_routes,
+       },
+       {
+               INIT_CTL_NAME
+               .procname       = "routers",
+               .mode           = 0444,
+               .proc_handler   = &proc_lnet_routers,
+       },
+       {
+               INIT_CTL_NAME
+               .procname       = "peers",
+               .mode           = 0444,
+               .proc_handler   = &proc_lnet_peers,
+       },
+       {
+               INIT_CTL_NAME
+               .procname       = "buffers",
+               .mode           = 0444,
+               .proc_handler   = &proc_lnet_buffers,
+       },
+       {
+               INIT_CTL_NAME
+               .procname       = "nis",
+               .mode           = 0444,
+               .proc_handler   = &proc_lnet_nis,
+       },
+       {
+               INIT_CTL_NAME
+               .procname       = "portal_rotor",
+               .mode           = 0644,
+               .proc_handler   = &proc_lnet_portal_rotor,
+       },
+       { 0 }
 };
 
-static int
-lnet_ni_seq_open(struct inode *inode, struct file *file)
-{
-        struct proc_dir_entry *dp = PDE(inode);
-        struct seq_file       *sf;
-        int                    rc;
-
-        rc = seq_open(file, &lnet_ni_sops);
-        if (rc == 0) {
-                sf = file->private_data;
-                sf->private = dp->data;
-        }
-
-        return rc;
-}
-
-static struct file_operations lnet_ni_fops;
-
-static void
-lnet_init_ni_fops(void)
-{
-        lnet_ni_fops.owner   =  THIS_MODULE;
-        lnet_ni_fops.llseek  =  seq_lseek;
-        lnet_ni_fops.read    =  seq_read;
-        lnet_ni_fops.open    =  lnet_ni_seq_open;
-        lnet_ni_fops.release =  seq_release;
-}
+static struct ctl_table top_table[] = {
+       {
+               INIT_CTL_NAME
+               .procname       = "lnet",
+               .mode           = 0555,
+               .data           = NULL,
+               .maxlen         = 0,
+               .child          = lnet_table,
+       },
+       { 0 }
+};
 
 void
 lnet_proc_init(void)
 {
-        struct proc_dir_entry *pde;
-
-#if 0
-        pde = proc_mkdir(LNET_PROC_ROOT, NULL);
-        if (pde == NULL) {
-                CERROR("couldn't create "LNET_PROC_ROOT"\n");
-                return; 
-        }
+#ifdef CONFIG_SYSCTL
+       if (lnet_table_header == NULL)
+               lnet_table_header = register_sysctl_table(top_table);
 #endif
-        /* Initialize LNET_PROC_STATS */
-        pde = create_proc_entry (LNET_PROC_STATS, 0644, NULL);
-        if (pde == NULL) {
-                CERROR("couldn't create proc entry %s\n", LNET_PROC_STATS);
-                return;
-        }
-
-        pde->data = NULL;
-        pde->read_proc = lnet_router_proc_stats_read;
-        pde->write_proc = lnet_router_proc_stats_write;
-
-        /* Initialize LNET_PROC_ROUTES */
-        pde = create_proc_entry (LNET_PROC_ROUTES, 0444, NULL);
-        if (pde == NULL) {
-                CERROR("couldn't create proc entry %s\n", LNET_PROC_ROUTES);
-                return;
-        }
-
-        lnet_init_routes_fops();
-        pde->proc_fops = &lnet_routes_fops;
-        pde->data = NULL;
-
-        /* Initialize LNET_PROC_ROUTERS */
-        pde = create_proc_entry (LNET_PROC_ROUTERS, 0444, NULL);
-        if (pde == NULL) {
-                CERROR("couldn't create proc entry %s\n", LNET_PROC_ROUTERS);
-                return;
-        }
-
-        lnet_init_routers_fops();
-        pde->proc_fops = &lnet_routers_fops;
-        pde->data = NULL;
-
-        /* Initialize LNET_PROC_PEERS */
-        pde = create_proc_entry (LNET_PROC_PEERS, 0444, NULL);
-        if (pde == NULL) {
-                CERROR("couldn't create proc entry %s\n", LNET_PROC_PEERS);
-                return;
-        }
-
-        lnet_init_peer_fops();
-        pde->proc_fops = &lnet_peer_fops;
-        pde->data = NULL;
-
-        /* Initialize LNET_PROC_BUFFERS */
-        pde = create_proc_entry (LNET_PROC_BUFFERS, 0444, NULL);
-        if (pde == NULL) {
-                CERROR("couldn't create proc entry %s\n", LNET_PROC_BUFFERS);
-                return;
-        }
-
-        lnet_init_buffers_fops();
-        pde->proc_fops = &lnet_buffers_fops;
-        pde->data = NULL;
-
-        /* Initialize LNET_PROC_NIS */
-        pde = create_proc_entry (LNET_PROC_NIS, 0444, NULL);
-        if (pde == NULL) {
-                CERROR("couldn't create proc entry %s\n", LNET_PROC_NIS);
-                return;
-        }
-
-        lnet_init_ni_fops();
-        pde->proc_fops = &lnet_ni_fops;
-        pde->data = NULL;
 }
 
 void
 lnet_proc_fini(void)
 {
-        remove_proc_entry(LNET_PROC_STATS, 0);
-        remove_proc_entry(LNET_PROC_ROUTES, 0);
-        remove_proc_entry(LNET_PROC_ROUTERS, 0);
-        remove_proc_entry(LNET_PROC_PEERS, 0);
-        remove_proc_entry(LNET_PROC_BUFFERS, 0);
-        remove_proc_entry(LNET_PROC_NIS, 0);
-#if 0   
-        remove_proc_entry(LNET_PROC_ROOT, 0);
+#ifdef CONFIG_SYSCTL
+       if (lnet_table_header != NULL)
+               unregister_sysctl_table(lnet_table_header);
+
+       lnet_table_header = NULL;
 #endif
 }