Whamcloud - gitweb
LU-5485 lnet: peer aliveness status and NI status
[fs/lustre-release.git] / lnet / lnet / router.c
index da0373b..091cfd9 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  *
- * Copyright (c) 2011, 2012, Intel Corporation.
+ * Copyright (c) 2011, 2013, Intel Corporation.
  *
  *   This file is part of Portals
  *   http://sourceforge.net/projects/sandiaportals/
 #define LNET_NRB_TINY          (LNET_NRB_TINY_MIN * 4)
 #define LNET_NRB_SMALL_MIN     4096    /* min value for each CPT */
 #define LNET_NRB_SMALL         (LNET_NRB_SMALL_MIN * 4)
+#define LNET_NRB_SMALL_PAGES   1
 #define LNET_NRB_LARGE_MIN     256     /* min value for each CPT */
 #define LNET_NRB_LARGE         (LNET_NRB_LARGE_MIN * 4)
+#define LNET_NRB_LARGE_PAGES   ((LNET_MTU + PAGE_CACHE_SIZE - 1) >> \
+                                 PAGE_CACHE_SHIFT)
 
 static char *forwarding = "";
 CFS_MODULE_PARM(forwarding, "s", charp, 0444,
@@ -84,7 +87,7 @@ static int check_routers_before_use = 0;
 CFS_MODULE_PARM(check_routers_before_use, "i", int, 0444,
                "Assume routers are down and ping them before use");
 
-static int avoid_asym_router_failure = 1;
+int avoid_asym_router_failure = 1;
 CFS_MODULE_PARM(avoid_asym_router_failure, "i", int, 0644,
                "Avoid asymmetrical router failures (0 to disable)");
 
@@ -180,24 +183,24 @@ lnet_rtr_addref_locked(lnet_peer_t *lp)
        LASSERT(lp->lp_rtr_refcount >= 0);
 
        /* lnet_net_lock must be exclusively locked */
-        lp->lp_rtr_refcount++;
-        if (lp->lp_rtr_refcount == 1) {
-                cfs_list_t *pos;
+       lp->lp_rtr_refcount++;
+       if (lp->lp_rtr_refcount == 1) {
+               struct list_head *pos;
 
-                /* a simple insertion sort */
-                cfs_list_for_each_prev(pos, &the_lnet.ln_routers) {
-                        lnet_peer_t *rtr = cfs_list_entry(pos, lnet_peer_t,
-                                                          lp_rtr_list);
+               /* a simple insertion sort */
+               list_for_each_prev(pos, &the_lnet.ln_routers) {
+                       lnet_peer_t *rtr = list_entry(pos, lnet_peer_t,
+                                                     lp_rtr_list);
 
-                        if (rtr->lp_nid < lp->lp_nid)
-                                break;
-                }
+                       if (rtr->lp_nid < lp->lp_nid)
+                               break;
+               }
 
-                cfs_list_add(&lp->lp_rtr_list, pos);
-                /* addref for the_lnet.ln_routers */
-                lnet_peer_addref_locked(lp);
-                the_lnet.ln_routers_version++;
-        }
+               list_add(&lp->lp_rtr_list, pos);
+               /* addref for the_lnet.ln_routers */
+               lnet_peer_addref_locked(lp);
+               the_lnet.ln_routers_version++;
+       }
 }
 
 static void
@@ -209,36 +212,38 @@ lnet_rtr_decref_locked(lnet_peer_t *lp)
        /* lnet_net_lock must be exclusively locked */
        lp->lp_rtr_refcount--;
        if (lp->lp_rtr_refcount == 0) {
-               LASSERT(cfs_list_empty(&lp->lp_routes));
+               LASSERT(list_empty(&lp->lp_routes));
 
                if (lp->lp_rcd != NULL) {
-                       cfs_list_add(&lp->lp_rcd->rcd_list,
-                                    &the_lnet.ln_rcd_deathrow);
-                        lp->lp_rcd = NULL;
-                }
+                       list_add(&lp->lp_rcd->rcd_list,
+                                &the_lnet.ln_rcd_deathrow);
+                       lp->lp_rcd = NULL;
+               }
 
-                cfs_list_del(&lp->lp_rtr_list);
-                /* decref for the_lnet.ln_routers */
-                lnet_peer_decref_locked(lp);
-                the_lnet.ln_routers_version++;
-        }
+               list_del(&lp->lp_rtr_list);
+               /* decref for the_lnet.ln_routers */
+               lnet_peer_decref_locked(lp);
+               the_lnet.ln_routers_version++;
+       }
 }
 
 lnet_remotenet_t *
 lnet_find_net_locked (__u32 net)
 {
-        lnet_remotenet_t *rnet;
-        cfs_list_t       *tmp;
+       lnet_remotenet_t *rnet;
+       struct list_head *tmp;
+       struct list_head *rn_list;
 
-        LASSERT (!the_lnet.ln_shutdown);
+       LASSERT(!the_lnet.ln_shutdown);
 
-        cfs_list_for_each (tmp, &the_lnet.ln_remote_nets) {
-                rnet = cfs_list_entry(tmp, lnet_remotenet_t, lrn_list);
+       rn_list = lnet_net2rnethash(net);
+       list_for_each(tmp, rn_list) {
+               rnet = list_entry(tmp, lnet_remotenet_t, lrn_list);
 
-                if (rnet->lrn_net == net)
-                        return rnet;
-        }
-        return NULL;
+               if (rnet->lrn_net == net)
+                       return rnet;
+       }
+       return NULL;
 }
 
 static void lnet_shuffle_seed(void)
@@ -247,99 +252,101 @@ static void lnet_shuffle_seed(void)
         int lnd_type, seed[2];
         struct timeval tv;
         lnet_ni_t *ni;
-        cfs_list_t *tmp;
+       struct list_head *tmp;
 
         if (seeded)
                 return;
 
         cfs_get_random_bytes(seed, sizeof(seed));
 
-        /* Nodes with small feet have little entropy
-         * the NID for this node gives the most entropy in the low bits */
-        cfs_list_for_each(tmp, &the_lnet.ln_nis) {
-                ni = cfs_list_entry(tmp, lnet_ni_t, ni_list);
-                lnd_type = LNET_NETTYP(LNET_NIDNET(ni->ni_nid));
+       /* Nodes with small feet have little entropy
+        * the NID for this node gives the most entropy in the low bits */
+       list_for_each(tmp, &the_lnet.ln_nis) {
+               ni = list_entry(tmp, lnet_ni_t, ni_list);
+               lnd_type = LNET_NETTYP(LNET_NIDNET(ni->ni_nid));
 
-                if (lnd_type != LOLND)
-                        seed[0] ^= (LNET_NIDADDR(ni->ni_nid) | lnd_type);
-        }
+               if (lnd_type != LOLND)
+                       seed[0] ^= (LNET_NIDADDR(ni->ni_nid) | lnd_type);
+       }
 
-        cfs_gettimeofday(&tv);
-        cfs_srand(tv.tv_sec ^ seed[0], tv.tv_usec ^ seed[1]);
-        seeded = 1;
-        return;
+       do_gettimeofday(&tv);
+       cfs_srand(tv.tv_sec ^ seed[0], tv.tv_usec ^ seed[1]);
+       seeded = 1;
+       return;
 }
 
 /* NB expects LNET_LOCK held */
 void
 lnet_add_route_to_rnet (lnet_remotenet_t *rnet, lnet_route_t *route)
 {
-        unsigned int      len = 0;
-        unsigned int      offset = 0;
-        cfs_list_t       *e;
+       unsigned int      len = 0;
+       unsigned int      offset = 0;
+       struct list_head *e;
 
-        lnet_shuffle_seed();
+       lnet_shuffle_seed();
 
-        cfs_list_for_each (e, &rnet->lrn_routes) {
-                len++;
-        }
+       list_for_each(e, &rnet->lrn_routes) {
+               len++;
+       }
 
-        /* len+1 positions to add a new entry, also prevents division by 0 */
-        offset = cfs_rand() % (len + 1);
-        cfs_list_for_each (e, &rnet->lrn_routes) {
-                if (offset == 0)
-                        break;
-                offset--;
-        }
-        cfs_list_add(&route->lr_list, e);
-       cfs_list_add(&route->lr_gwlist, &route->lr_gateway->lp_routes);
+       /* len+1 positions to add a new entry, also prevents division by 0 */
+       offset = cfs_rand() % (len + 1);
+       list_for_each(e, &rnet->lrn_routes) {
+               if (offset == 0)
+                       break;
+               offset--;
+       }
+       list_add(&route->lr_list, e);
+       list_add(&route->lr_gwlist, &route->lr_gateway->lp_routes);
 
        the_lnet.ln_remote_nets_version++;
        lnet_rtr_addref_locked(route->lr_gateway);
 }
 
 int
-lnet_add_route (__u32 net, unsigned int hops, lnet_nid_t gateway)
+lnet_add_route(__u32 net, unsigned int hops, lnet_nid_t gateway,
+              unsigned int priority)
 {
-        cfs_list_t          *e;
-        lnet_remotenet_t    *rnet;
-        lnet_remotenet_t    *rnet2;
-        lnet_route_t        *route;
-        lnet_ni_t           *ni;
-        int                  add_route;
-        int                  rc;
-
-        CDEBUG(D_NET, "Add route: net %s hops %u gw %s\n",
-               libcfs_net2str(net), hops, libcfs_nid2str(gateway));
-
-        if (gateway == LNET_NID_ANY ||
-            LNET_NETTYP(LNET_NIDNET(gateway)) == LOLND ||
-            net == LNET_NIDNET(LNET_NID_ANY) ||
-            LNET_NETTYP(net) == LOLND ||
-            LNET_NIDNET(gateway) == net ||
-            hops < 1 || hops > 255)
-                return (-EINVAL);
-
-        if (lnet_islocalnet(net))               /* it's a local network */
-                return 0;                       /* ignore the route entry */
-
-        /* Assume net, route, all new */
-        LIBCFS_ALLOC(route, sizeof(*route));
-        LIBCFS_ALLOC(rnet, sizeof(*rnet));
-        if (route == NULL || rnet == NULL) {
-                CERROR("Out of memory creating route %s %d %s\n",
-                       libcfs_net2str(net), hops, libcfs_nid2str(gateway));
-                if (route != NULL)
-                        LIBCFS_FREE(route, sizeof(*route));
-                if (rnet != NULL)
-                        LIBCFS_FREE(rnet, sizeof(*rnet));
-                return -ENOMEM;
-        }
+       struct list_head        *e;
+       lnet_remotenet_t        *rnet;
+       lnet_remotenet_t        *rnet2;
+       lnet_route_t            *route;
+       lnet_ni_t               *ni;
+       int                     add_route;
+       int                     rc;
 
-        CFS_INIT_LIST_HEAD(&rnet->lrn_routes);
-        rnet->lrn_net = net;
-        route->lr_hops = hops;
+       CDEBUG(D_NET, "Add route: net %s hops %u priority %u gw %s\n",
+              libcfs_net2str(net), hops, priority, libcfs_nid2str(gateway));
+
+       if (gateway == LNET_NID_ANY ||
+           LNET_NETTYP(LNET_NIDNET(gateway)) == LOLND ||
+           net == LNET_NIDNET(LNET_NID_ANY) ||
+           LNET_NETTYP(net) == LOLND ||
+           LNET_NIDNET(gateway) == net ||
+           hops < 1 || hops > 255)
+               return -EINVAL;
+
+       if (lnet_islocalnet(net))       /* it's a local network */
+               return 0;               /* ignore the route entry */
+
+       /* Assume net, route, all new */
+       LIBCFS_ALLOC(route, sizeof(*route));
+       LIBCFS_ALLOC(rnet, sizeof(*rnet));
+       if (route == NULL || rnet == NULL) {
+               CERROR("Out of memory creating route %s %d %s\n",
+                      libcfs_net2str(net), hops, libcfs_nid2str(gateway));
+               if (route != NULL)
+                       LIBCFS_FREE(route, sizeof(*route));
+               if (rnet != NULL)
+                       LIBCFS_FREE(rnet, sizeof(*rnet));
+               return -ENOMEM;
+       }
+
+       INIT_LIST_HEAD(&rnet->lrn_routes);
+       rnet->lrn_net = net;
+       route->lr_hops = hops;
        route->lr_net = net;
+       route->lr_priority = priority;
 
        lnet_net_lock(LNET_LOCK_EX);
 
@@ -350,40 +357,38 @@ lnet_add_route (__u32 net, unsigned int hops, lnet_nid_t gateway)
                LIBCFS_FREE(route, sizeof(*route));
                LIBCFS_FREE(rnet, sizeof(*rnet));
 
-               if (rc == -EHOSTUNREACH) { /* gateway is not on a local net */
-                       return 0;       /* ignore the route entry */
-               } else {
-                       CERROR("Error %d creating route %s %d %s\n", rc,
-                              libcfs_net2str(net), hops,
-                              libcfs_nid2str(gateway));
-               }
-                return rc;
-        }
+               if (rc == -EHOSTUNREACH) /* gateway is not on a local net. */
+                       return 0;        /* ignore the route entry */
+               CERROR("Error %d creating route %s %d %s\n", rc,
+                       libcfs_net2str(net), hops,
+                       libcfs_nid2str(gateway));
+               return rc;
+       }
 
-        LASSERT (!the_lnet.ln_shutdown);
+       LASSERT(!the_lnet.ln_shutdown);
 
-        rnet2 = lnet_find_net_locked(net);
-        if (rnet2 == NULL) {
-                /* new network */
-                cfs_list_add_tail(&rnet->lrn_list, &the_lnet.ln_remote_nets);
-                rnet2 = rnet;
-        }
+       rnet2 = lnet_find_net_locked(net);
+       if (rnet2 == NULL) {
+               /* new network */
+               list_add_tail(&rnet->lrn_list, lnet_net2rnethash(net));
+               rnet2 = rnet;
+       }
 
-        /* Search for a duplicate route (it's a NOOP if it is) */
-        add_route = 1;
-        cfs_list_for_each (e, &rnet2->lrn_routes) {
-                lnet_route_t *route2 = cfs_list_entry(e, lnet_route_t, lr_list);
+       /* Search for a duplicate route (it's a NOOP if it is) */
+       add_route = 1;
+       list_for_each(e, &rnet2->lrn_routes) {
+               lnet_route_t *route2 = list_entry(e, lnet_route_t, lr_list);
 
-                if (route2->lr_gateway == route->lr_gateway) {
-                        add_route = 0;
-                        break;
-                }
+               if (route2->lr_gateway == route->lr_gateway) {
+                       add_route = 0;
+                       break;
+               }
 
-                /* our lookups must be true */
-                LASSERT (route2->lr_gateway->lp_nid != gateway);
-        }
+               /* our lookups must be true */
+               LASSERT(route2->lr_gateway->lp_nid != gateway);
+       }
 
-        if (add_route) {
+       if (add_route) {
                lnet_peer_addref_locked(route->lr_gateway); /* +1 for notify */
                lnet_add_route_to_rnet(rnet2, route);
 
@@ -413,45 +418,53 @@ lnet_add_route (__u32 net, unsigned int hops, lnet_nid_t gateway)
 int
 lnet_check_routes(void)
 {
-       lnet_remotenet_t        *rnet;
-       lnet_route_t            *route;
-       lnet_route_t            *route2;
-       cfs_list_t              *e1;
-       cfs_list_t              *e2;
-       int                     cpt;
+       lnet_remotenet_t *rnet;
+       lnet_route_t     *route;
+       lnet_route_t     *route2;
+       struct list_head *e1;
+       struct list_head *e2;
+       int               cpt;
+       struct list_head *rn_list;
+       int               i;
 
        cpt = lnet_net_lock_current();
 
-       cfs_list_for_each(e1, &the_lnet.ln_remote_nets) {
-               rnet = cfs_list_entry(e1, lnet_remotenet_t, lrn_list);
+       for (i = 0; i < LNET_REMOTE_NETS_HASH_SIZE; i++) {
+               rn_list = &the_lnet.ln_remote_nets_hash[i];
+               list_for_each(e1, rn_list) {
+                       rnet = list_entry(e1, lnet_remotenet_t, lrn_list);
 
-               route2 = NULL;
-               cfs_list_for_each(e2, &rnet->lrn_routes) {
-                       lnet_nid_t      nid1;
-                       lnet_nid_t      nid2;
-                       int             net;
+                       route2 = NULL;
+                       list_for_each(e2, &rnet->lrn_routes) {
+                               lnet_nid_t      nid1;
+                               lnet_nid_t      nid2;
+                               int             net;
 
-                       route = cfs_list_entry(e2, lnet_route_t, lr_list);
+                               route = list_entry(e2, lnet_route_t,
+                                                  lr_list);
 
-                       if (route2 == NULL) {
-                               route2 = route;
-                               continue;
-                       }
+                               if (route2 == NULL) {
+                                       route2 = route;
+                                       continue;
+                               }
 
-                       if (route->lr_gateway->lp_ni ==
-                           route2->lr_gateway->lp_ni)
-                               continue;
+                               if (route->lr_gateway->lp_ni ==
+                                   route2->lr_gateway->lp_ni)
+                                       continue;
 
-                       nid1 = route->lr_gateway->lp_nid;
-                       nid2 = route2->lr_gateway->lp_nid;
-                       net = rnet->lrn_net;
+                               nid1 = route->lr_gateway->lp_nid;
+                               nid2 = route2->lr_gateway->lp_nid;
+                               net = rnet->lrn_net;
 
-                       lnet_net_unlock(cpt);
+                               lnet_net_unlock(cpt);
 
-                       CERROR("Routes to %s via %s and %s not supported\n",
-                              libcfs_net2str(net), libcfs_nid2str(nid1),
-                              libcfs_nid2str(nid2));
-                       return -EINVAL;
+                               CERROR("Routes to %s via %s and %s not "
+                                      "supported\n",
+                                      libcfs_net2str(net),
+                                      libcfs_nid2str(nid1),
+                                      libcfs_nid2str(nid2));
+                               return -EINVAL;
+                       }
                }
        }
 
@@ -463,61 +476,74 @@ int
 lnet_del_route(__u32 net, lnet_nid_t gw_nid)
 {
        struct lnet_peer        *gateway;
-        lnet_remotenet_t    *rnet;
-        lnet_route_t        *route;
-        cfs_list_t          *e1;
-        cfs_list_t          *e2;
-        int                  rc = -ENOENT;
+       lnet_remotenet_t        *rnet;
+       lnet_route_t            *route;
+       struct list_head        *e1;
+       struct list_head        *e2;
+       int                     rc = -ENOENT;
+       struct list_head        *rn_list;
+       int                     idx = 0;
 
-        CDEBUG(D_NET, "Del route: net %s : gw %s\n",
-               libcfs_net2str(net), libcfs_nid2str(gw_nid));
+       CDEBUG(D_NET, "Del route: net %s : gw %s\n",
+              libcfs_net2str(net), libcfs_nid2str(gw_nid));
 
-        /* NB Caller may specify either all routes via the given gateway
-         * or a specific route entry actual NIDs) */
+       /* NB Caller may specify either all routes via the given gateway
+        * or a specific route entry actual NIDs) */
 
- again:
        lnet_net_lock(LNET_LOCK_EX);
+       if (net == LNET_NIDNET(LNET_NID_ANY))
+               rn_list = &the_lnet.ln_remote_nets_hash[0];
+       else
+               rn_list = lnet_net2rnethash(net);
 
-        cfs_list_for_each (e1, &the_lnet.ln_remote_nets) {
-                rnet = cfs_list_entry(e1, lnet_remotenet_t, lrn_list);
+again:
+       list_for_each(e1, rn_list) {
+               rnet = list_entry(e1, lnet_remotenet_t, lrn_list);
 
-                if (!(net == LNET_NIDNET(LNET_NID_ANY) ||
-                      net == rnet->lrn_net))
-                        continue;
+               if (!(net == LNET_NIDNET(LNET_NID_ANY) ||
+                       net == rnet->lrn_net))
+                       continue;
 
-                cfs_list_for_each (e2, &rnet->lrn_routes) {
-                        route = cfs_list_entry(e2, lnet_route_t, lr_list);
+               list_for_each(e2, &rnet->lrn_routes) {
+                       route = list_entry(e2, lnet_route_t, lr_list);
 
                        gateway = route->lr_gateway;
                        if (!(gw_nid == LNET_NID_ANY ||
                              gw_nid == gateway->lp_nid))
                                continue;
 
-                       cfs_list_del(&route->lr_list);
-                       cfs_list_del(&route->lr_gwlist);
-                        the_lnet.ln_remote_nets_version++;
+                       list_del(&route->lr_list);
+                       list_del(&route->lr_gwlist);
+                       the_lnet.ln_remote_nets_version++;
 
-                        if (cfs_list_empty(&rnet->lrn_routes))
-                                cfs_list_del(&rnet->lrn_list);
-                        else
-                                rnet = NULL;
+                       if (list_empty(&rnet->lrn_routes))
+                               list_del(&rnet->lrn_list);
+                       else
+                               rnet = NULL;
 
                        lnet_rtr_decref_locked(gateway);
                        lnet_peer_decref_locked(gateway);
 
                        lnet_net_unlock(LNET_LOCK_EX);
 
-                        LIBCFS_FREE(route, sizeof (*route));
+                       LIBCFS_FREE(route, sizeof(*route));
 
-                        if (rnet != NULL)
-                                LIBCFS_FREE(rnet, sizeof(*rnet));
+                       if (rnet != NULL)
+                               LIBCFS_FREE(rnet, sizeof(*rnet));
 
-                        rc = 0;
-                        goto again;
-                }
-        }
+                       rc = 0;
+                       lnet_net_lock(LNET_LOCK_EX);
+                       goto again;
+               }
+       }
 
+       if (net == LNET_NIDNET(LNET_NID_ANY) &&
+           ++idx < LNET_REMOTE_NETS_HASH_SIZE) {
+               rn_list = &the_lnet.ln_remote_nets_hash[idx];
+               goto again;
+       }
        lnet_net_unlock(LNET_LOCK_EX);
+
        return rc;
 }
 
@@ -527,31 +553,76 @@ lnet_destroy_routes (void)
         lnet_del_route(LNET_NIDNET(LNET_NID_ANY), LNET_NID_ANY);
 }
 
+int lnet_get_rtr_pool_cfg(int idx, struct lnet_ioctl_pool_cfg *pool_cfg)
+{
+       int i, rc = -ENOENT, lidx, j;
+
+       if (the_lnet.ln_rtrpools == NULL)
+               return rc;
+
+       for (i = 0; i < LNET_NRBPOOLS; i++) {
+               lnet_rtrbufpool_t *rbp;
+
+               lnet_net_lock(LNET_LOCK_EX);
+               lidx = idx;
+               cfs_percpt_for_each(rbp, j, the_lnet.ln_rtrpools) {
+                       if (lidx-- == 0) {
+                               rc = 0;
+                               pool_cfg->pl_pools[i].pl_npages =
+                                       rbp[i].rbp_npages;
+                               pool_cfg->pl_pools[i].pl_nbuffers =
+                                       rbp[i].rbp_nbuffers;
+                               pool_cfg->pl_pools[i].pl_credits =
+                                       rbp[i].rbp_credits;
+                               pool_cfg->pl_pools[i].pl_mincredits =
+                                       rbp[i].rbp_mincredits;
+                               break;
+                       }
+               }
+               lnet_net_unlock(LNET_LOCK_EX);
+       }
+
+       lnet_net_lock(LNET_LOCK_EX);
+       pool_cfg->pl_routing = the_lnet.ln_routing;
+       lnet_net_unlock(LNET_LOCK_EX);
+
+       return rc;
+}
+
 int
 lnet_get_route(int idx, __u32 *net, __u32 *hops,
-              lnet_nid_t *gateway, __u32 *alive)
+              lnet_nid_t *gateway, __u32 *alive, __u32 *priority)
 {
-       cfs_list_t              *e1;
-       cfs_list_t              *e2;
-       lnet_remotenet_t        *rnet;
-       lnet_route_t            *route;
-       int                     cpt;
+       struct list_head *e1;
+       struct list_head *e2;
+       lnet_remotenet_t *rnet;
+       lnet_route_t     *route;
+       int               cpt;
+       int               i;
+       struct list_head *rn_list;
 
        cpt = lnet_net_lock_current();
 
-        cfs_list_for_each (e1, &the_lnet.ln_remote_nets) {
-                rnet = cfs_list_entry(e1, lnet_remotenet_t, lrn_list);
-
-                cfs_list_for_each (e2, &rnet->lrn_routes) {
-                        route = cfs_list_entry(e2, lnet_route_t, lr_list);
-
-                        if (idx-- == 0) {
-                                *net     = rnet->lrn_net;
-                                *hops    = route->lr_hops;
-                                *gateway = route->lr_gateway->lp_nid;
-                                *alive   = route->lr_gateway->lp_alive;
-                               lnet_net_unlock(cpt);
-                               return 0;
+       for (i = 0; i < LNET_REMOTE_NETS_HASH_SIZE; i++) {
+               rn_list = &the_lnet.ln_remote_nets_hash[i];
+               list_for_each(e1, rn_list) {
+                       rnet = list_entry(e1, lnet_remotenet_t, lrn_list);
+
+                       list_for_each(e2, &rnet->lrn_routes) {
+                               route = list_entry(e2, lnet_route_t,
+                                                  lr_list);
+
+                               if (idx-- == 0) {
+                                       *net      = rnet->lrn_net;
+                                       *hops     = route->lr_hops;
+                                       *priority = route->lr_priority;
+                                       *gateway  = route->lr_gateway->lp_nid;
+                                       *alive    =
+                                               route->lr_gateway->lp_alive &&
+                                                       !route->lr_downis;
+                                       lnet_net_unlock(cpt);
+                                       return 0;
+                               }
                        }
                }
        }
@@ -568,14 +639,14 @@ lnet_swap_pinginfo(lnet_ping_info_t *info)
 
        __swab32s(&info->pi_magic);
        __swab32s(&info->pi_features);
-        __swab32s(&info->pi_pid);
-        __swab32s(&info->pi_nnis);
-        for (i = 0; i < info->pi_nnis && i < LNET_MAX_RTR_NIS; i++) {
-                stat = &info->pi_ni[i];
-                __swab64s(&stat->ns_nid);
-                __swab32s(&stat->ns_status);
-        }
-        return;
+       __swab32s(&info->pi_pid);
+       __swab32s(&info->pi_nnis);
+       for (i = 0; i < info->pi_nnis && i < LNET_MAX_RTR_NIS; i++) {
+               stat = &info->pi_ni[i];
+               __swab64s(&stat->ns_nid);
+               __swab32s(&stat->ns_status);
+       }
+       return;
 }
 
 /**
@@ -587,7 +658,7 @@ lnet_parse_rc_info(lnet_rc_data_t *rcd)
 {
        lnet_ping_info_t        *info = rcd->rcd_pinginfo;
        struct lnet_peer        *gw   = rcd->rcd_gateway;
-       lnet_route_t            *rtr;
+       lnet_route_t            *rte;
 
        if (!gw->lp_alive)
                return;
@@ -613,12 +684,16 @@ lnet_parse_rc_info(lnet_rc_data_t *rcd)
        if ((gw->lp_ping_feats & LNET_PING_FEAT_NI_STATUS) == 0)
                return; /* can't carry NI status info */
 
-       cfs_list_for_each_entry(rtr, &gw->lp_routes, lr_gwlist) {
-               int     ptl_status = LNET_NI_STATUS_INVALID;
+       list_for_each_entry(rte, &gw->lp_routes, lr_gwlist) {
                int     down = 0;
                int     up = 0;
                int     i;
 
+               if ((gw->lp_ping_feats & LNET_PING_FEAT_RTE_DISABLED) != 0) {
+                       rte->lr_downis = 1;
+                       continue;
+               }
+
                for (i = 0; i < info->pi_nnis && i < LNET_MAX_RTR_NIS; i++) {
                        lnet_ni_status_t *stat = &info->pi_ni[i];
                        lnet_nid_t       nid = stat->ns_nid;
@@ -634,22 +709,15 @@ lnet_parse_rc_info(lnet_rc_data_t *rcd)
                                continue;
 
                        if (stat->ns_status == LNET_NI_STATUS_DOWN) {
-                               if (LNET_NETTYP(LNET_NIDNET(nid)) != PTLLND)
-                                       down++;
-                               else if (ptl_status != LNET_NI_STATUS_UP)
-                                       ptl_status = LNET_NI_STATUS_DOWN;
+                               down++;
                                continue;
                        }
 
                        if (stat->ns_status == LNET_NI_STATUS_UP) {
-                               if (LNET_NIDNET(nid) == rtr->lr_net) {
+                               if (LNET_NIDNET(nid) == rte->lr_net) {
                                        up = 1;
                                        break;
                                }
-                               /* ptl NIs are considered down only when
-                                * they're all down */
-                               if (LNET_NETTYP(LNET_NIDNET(nid)) == PTLLND)
-                                       ptl_status = LNET_NI_STATUS_UP;
                                continue;
                        }
 
@@ -660,10 +728,10 @@ lnet_parse_rc_info(lnet_rc_data_t *rcd)
                }
 
                if (up) { /* ignore downed NIs if NI for dest network is up */
-                       rtr->lr_downis = 0;
+                       rte->lr_downis = 0;
                        continue;
                }
-               rtr->lr_downis = down + (ptl_status == LNET_NI_STATUS_DOWN);
+               rte->lr_downis = down;
        }
 }
 
@@ -723,28 +791,28 @@ lnet_router_checker_event(lnet_event_t *event)
 void
 lnet_wait_known_routerstate(void)
 {
-        lnet_peer_t         *rtr;
-        cfs_list_t          *entry;
-        int                  all_known;
+       lnet_peer_t      *rtr;
+       struct list_head *entry;
+       int               all_known;
 
-        LASSERT (the_lnet.ln_rc_state == LNET_RC_STATE_RUNNING);
+       LASSERT(the_lnet.ln_rc_state == LNET_RC_STATE_RUNNING);
 
-        for (;;) {
-               int     cpt = lnet_net_lock_current();
+       for (;;) {
+               int cpt = lnet_net_lock_current();
 
-                all_known = 1;
-                cfs_list_for_each (entry, &the_lnet.ln_routers) {
-                        rtr = cfs_list_entry(entry, lnet_peer_t, lp_rtr_list);
+               all_known = 1;
+               list_for_each(entry, &the_lnet.ln_routers) {
+                       rtr = list_entry(entry, lnet_peer_t, lp_rtr_list);
 
-                        if (rtr->lp_alive_count == 0) {
-                                all_known = 0;
-                                break;
-                        }
-                }
+                       if (rtr->lp_alive_count == 0) {
+                               all_known = 0;
+                               break;
+                       }
+               }
 
                lnet_net_unlock(cpt);
 
-                if (all_known)
+               if (all_known)
                         return;
 
 #ifndef __KERNEL__
@@ -755,6 +823,21 @@ lnet_wait_known_routerstate(void)
 }
 
 void
+lnet_router_ni_update_locked(lnet_peer_t *gw, __u32 net)
+{
+       lnet_route_t *rte;
+
+       if ((gw->lp_ping_feats & LNET_PING_FEAT_NI_STATUS) != 0) {
+               list_for_each_entry(rte, &gw->lp_routes, lr_gwlist) {
+                       if (rte->lr_net == net) {
+                               rte->lr_downis = 0;
+                               break;
+                       }
+               }
+       }
+}
+
+void
 lnet_update_ni_status_locked(void)
 {
        lnet_ni_t       *ni;
@@ -767,7 +850,7 @@ lnet_update_ni_status_locked(void)
                  MAX(live_router_check_interval, dead_router_check_interval);
 
        now = cfs_time_current_sec();
-       cfs_list_for_each_entry(ni, &the_lnet.ln_nis, ni_list) {
+       list_for_each_entry(ni, &the_lnet.ln_nis, ni_list) {
                if (ni->ni_lnd->lnd_type == LOLND)
                        continue;
 
@@ -797,7 +880,7 @@ lnet_update_ni_status_locked(void)
 void
 lnet_destroy_rc_data(lnet_rc_data_t *rcd)
 {
-       LASSERT(cfs_list_empty(&rcd->rcd_list));
+       LASSERT(list_empty(&rcd->rcd_list));
        /* detached from network */
        LASSERT(LNetHandleIsInvalid(rcd->rcd_mdh));
 
@@ -830,13 +913,12 @@ lnet_create_rc_data_locked(lnet_peer_t *gateway)
                goto out;
 
        LNetInvalidateHandle(&rcd->rcd_mdh);
-       CFS_INIT_LIST_HEAD(&rcd->rcd_list);
+       INIT_LIST_HEAD(&rcd->rcd_list);
 
        LIBCFS_ALLOC(pi, LNET_PINGINFO_SIZE);
        if (pi == NULL)
                goto out;
 
-        memset(pi, 0, LNET_PINGINFO_SIZE);
         for (i = 0; i < LNET_MAX_RTR_NIS; i++) {
                 pi->pi_ni[i].ns_nid = LNET_NID_ANY;
                 pi->pi_ni[i].ns_status = LNET_NI_STATUS_INVALID;
@@ -944,7 +1026,7 @@ lnet_ping_router_locked (lnet_peer_t *rtr)
                 lnet_handle_md_t  mdh;
 
                 id.nid = rtr->lp_nid;
-                id.pid = LUSTRE_SRV_LNET_PID;
+               id.pid = LNET_PID_LUSTRE;
                 CDEBUG(D_NET, "Check: %s\n", libcfs_id2str(id));
 
                 rtr->lp_ping_notsent   = 1;
@@ -974,13 +1056,15 @@ lnet_ping_router_locked (lnet_peer_t *rtr)
 int
 lnet_router_checker_start(void)
 {
-        int          rc;
-        int          eqsz;
-#ifndef __KERNEL__
-        lnet_peer_t *rtr;
-        __u64        version;
-        int          nrtr = 0;
-        int          router_checker_max_eqsize = 10240;
+       int                     rc;
+       int                     eqsz;
+#ifdef __KERNEL__
+       struct task_struct     *task;
+#else /* __KERNEL__ */
+       lnet_peer_t            *rtr;
+       __u64                   version;
+       int                     nrtr = 0;
+       int                     router_checker_max_eqsize = 10240;
 
         LASSERT (check_routers_before_use);
         LASSERT (dead_router_check_interval > 0);
@@ -991,7 +1075,7 @@ lnet_router_checker_start(void)
          * outstanding events as it is allowed outstanding sends */
         eqsz = 0;
         version = the_lnet.ln_routers_version;
-        cfs_list_for_each_entry(rtr, &the_lnet.ln_routers, lp_rtr_list) {
+       list_for_each_entry(rtr, &the_lnet.ln_routers, lp_rtr_list) {
                 lnet_ni_t         *ni = rtr->lp_ni;
                 lnet_process_id_t  id;
 
@@ -1000,7 +1084,7 @@ lnet_router_checker_start(void)
 
                 /* one async ping reply per router */
                 id.nid = rtr->lp_nid;
-                id.pid = LUSTRE_SRV_LNET_PID;
+               id.pid = LNET_PID_LUSTRE;
 
                lnet_net_unlock(0);
 
@@ -1066,16 +1150,17 @@ lnet_router_checker_start(void)
 
         the_lnet.ln_rc_state = LNET_RC_STATE_RUNNING;
 #ifdef __KERNEL__
-        rc = cfs_create_thread(lnet_router_checker, NULL, 0);
-        if (rc < 0) {
-                CERROR("Can't start router checker thread: %d\n", rc);
-                /* block until event callback signals exit */
+       task = kthread_run(lnet_router_checker, NULL, "router_checker");
+       if (IS_ERR(task)) {
+               rc = PTR_ERR(task);
+               CERROR("Can't start router checker thread: %d\n", rc);
+               /* block until event callback signals exit */
                down(&the_lnet.ln_rc_signal);
-                rc = LNetEQFree(the_lnet.ln_rc_eqh);
-                LASSERT (rc == 0);
-                the_lnet.ln_rc_state = LNET_RC_STATE_SHUTDOWN;
-                return -ENOMEM;
-        }
+               rc = LNetEQFree(the_lnet.ln_rc_eqh);
+               LASSERT(rc == 0);
+               the_lnet.ln_rc_state = LNET_RC_STATE_SHUTDOWN;
+               return -ENOMEM;
+       }
 #endif
 
         if (check_routers_before_use) {
@@ -1118,63 +1203,63 @@ lnet_prune_rc_data(int wait_unlink)
        lnet_rc_data_t          *rcd;
        lnet_rc_data_t          *tmp;
        lnet_peer_t             *lp;
-       cfs_list_t              head;
-       int                     i = 2;
+       struct list_head         head;
+       int                      i = 2;
 
        if (likely(the_lnet.ln_rc_state == LNET_RC_STATE_RUNNING &&
-                  cfs_list_empty(&the_lnet.ln_rcd_deathrow) &&
-                  cfs_list_empty(&the_lnet.ln_rcd_zombie)))
+                  list_empty(&the_lnet.ln_rcd_deathrow) &&
+                  list_empty(&the_lnet.ln_rcd_zombie)))
                return;
 
-       CFS_INIT_LIST_HEAD(&head);
+       INIT_LIST_HEAD(&head);
 
        lnet_net_lock(LNET_LOCK_EX);
 
        if (the_lnet.ln_rc_state != LNET_RC_STATE_RUNNING) {
                /* router checker is stopping, prune all */
-               cfs_list_for_each_entry(lp, &the_lnet.ln_routers,
-                                       lp_rtr_list) {
+               list_for_each_entry(lp, &the_lnet.ln_routers,
+                                   lp_rtr_list) {
                        if (lp->lp_rcd == NULL)
                                continue;
 
-                       LASSERT(cfs_list_empty(&lp->lp_rcd->rcd_list));
-                       cfs_list_add(&lp->lp_rcd->rcd_list,
-                                    &the_lnet.ln_rcd_deathrow);
+                       LASSERT(list_empty(&lp->lp_rcd->rcd_list));
+                       list_add(&lp->lp_rcd->rcd_list,
+                                &the_lnet.ln_rcd_deathrow);
                        lp->lp_rcd = NULL;
                }
        }
 
        /* unlink all RCDs on deathrow list */
-       cfs_list_splice_init(&the_lnet.ln_rcd_deathrow, &head);
+       list_splice_init(&the_lnet.ln_rcd_deathrow, &head);
 
-       if (!cfs_list_empty(&head)) {
+       if (!list_empty(&head)) {
                lnet_net_unlock(LNET_LOCK_EX);
 
-               cfs_list_for_each_entry(rcd, &head, rcd_list)
+               list_for_each_entry(rcd, &head, rcd_list)
                        LNetMDUnlink(rcd->rcd_mdh);
 
                lnet_net_lock(LNET_LOCK_EX);
        }
 
-       cfs_list_splice_init(&head, &the_lnet.ln_rcd_zombie);
+       list_splice_init(&head, &the_lnet.ln_rcd_zombie);
 
        /* release all zombie RCDs */
-       while (!cfs_list_empty(&the_lnet.ln_rcd_zombie)) {
-               cfs_list_for_each_entry_safe(rcd, tmp, &the_lnet.ln_rcd_zombie,
-                                            rcd_list) {
+       while (!list_empty(&the_lnet.ln_rcd_zombie)) {
+               list_for_each_entry_safe(rcd, tmp, &the_lnet.ln_rcd_zombie,
+                                        rcd_list) {
                        if (LNetHandleIsInvalid(rcd->rcd_mdh))
-                               cfs_list_move(&rcd->rcd_list, &head);
+                               list_move(&rcd->rcd_list, &head);
                }
 
                wait_unlink = wait_unlink &&
-                             !cfs_list_empty(&the_lnet.ln_rcd_zombie);
+                             !list_empty(&the_lnet.ln_rcd_zombie);
 
                lnet_net_unlock(LNET_LOCK_EX);
 
-               while (!cfs_list_empty(&head)) {
-                       rcd = cfs_list_entry(head.next,
-                                            lnet_rc_data_t, rcd_list);
-                       cfs_list_del_init(&rcd->rcd_list);
+               while (!list_empty(&head)) {
+                       rcd = list_entry(head.next,
+                                        lnet_rc_data_t, rcd_list);
+                       list_del_init(&rcd->rcd_list);
                        lnet_destroy_rc_data(rcd);
                }
 
@@ -1199,9 +1284,8 @@ static int
 lnet_router_checker(void *arg)
 {
         lnet_peer_t       *rtr;
-        cfs_list_t        *entry;
+       struct list_head  *entry;
 
-        cfs_daemonize("router_checker");
         cfs_block_allsigs();
 
         LASSERT (the_lnet.ln_rc_state == LNET_RC_STATE_RUNNING);
@@ -1215,8 +1299,8 @@ lnet_router_checker(void *arg)
 rescan:
                version = the_lnet.ln_routers_version;
 
-               cfs_list_for_each(entry, &the_lnet.ln_routers) {
-                       rtr = cfs_list_entry(entry, lnet_peer_t, lp_rtr_list);
+               list_for_each(entry, &the_lnet.ln_routers) {
+                       rtr = list_entry(entry, lnet_peer_t, lp_rtr_list);
 
                        cpt2 = lnet_cpt_of_nid_locked(rtr->lp_nid);
                        if (cpt != cpt2) {
@@ -1244,12 +1328,12 @@ rescan:
 
                lnet_prune_rc_data(0); /* don't wait for UNLINK */
 
-                /* Call cfs_pause() here always adds 1 to load average 
-                 * because kernel counts # active tasks as nr_running 
-                 * + nr_uninterruptible. */
-                cfs_schedule_timeout_and_set_state(CFS_TASK_INTERRUPTIBLE,
-                                                   cfs_time_seconds(1));
-        }
+               /* Call cfs_pause() here always adds 1 to load average
+                * because kernel counts # active tasks as nr_running
+                * + nr_uninterruptible. */
+               schedule_timeout_and_set_state(TASK_INTERRUPTIBLE,
+                                                  cfs_time_seconds(1));
+       }
 
        LASSERT(the_lnet.ln_rc_state == LNET_RC_STATE_STOPPING);
 
@@ -1267,7 +1351,7 @@ lnet_destroy_rtrbuf(lnet_rtrbuf_t *rb, int npages)
         int sz = offsetof(lnet_rtrbuf_t, rb_kiov[npages]);
 
         while (--npages >= 0)
-                cfs_free_page(rb->rb_kiov[npages].kiov_page);
+               __free_page(rb->rb_kiov[npages].kiov_page);
 
         LIBCFS_FREE(rb, sz);
 }
@@ -1275,11 +1359,11 @@ lnet_destroy_rtrbuf(lnet_rtrbuf_t *rb, int npages)
 lnet_rtrbuf_t *
 lnet_new_rtrbuf(lnet_rtrbufpool_t *rbp, int cpt)
 {
-        int            npages = rbp->rbp_npages;
-        int            sz = offsetof(lnet_rtrbuf_t, rb_kiov[npages]);
-        struct page   *page;
-        lnet_rtrbuf_t *rb;
-        int            i;
+       int            npages = rbp->rbp_npages;
+       int            sz = offsetof(lnet_rtrbuf_t, rb_kiov[npages]);
+       struct page   *page;
+       lnet_rtrbuf_t *rb;
+       int            i;
 
        LIBCFS_CPT_ALLOC(rb, lnet_cpt_table(), cpt, sz);
        if (rb == NULL)
@@ -1289,16 +1373,16 @@ lnet_new_rtrbuf(lnet_rtrbufpool_t *rbp, int cpt)
 
        for (i = 0; i < npages; i++) {
                page = cfs_page_cpt_alloc(lnet_cpt_table(), cpt,
-                                         CFS_ALLOC_ZERO | CFS_ALLOC_STD);
+                                         __GFP_ZERO | GFP_IOFS);
                 if (page == NULL) {
                         while (--i >= 0)
-                                cfs_free_page(rb->rb_kiov[i].kiov_page);
+                               __free_page(rb->rb_kiov[i].kiov_page);
 
                         LIBCFS_FREE(rb, sz);
                         return NULL;
                 }
 
-                rb->rb_kiov[i].kiov_len = CFS_PAGE_SIZE;
+               rb->rb_kiov[i].kiov_len = PAGE_CACHE_SIZE;
                 rb->rb_kiov[i].kiov_offset = 0;
                 rb->rb_kiov[i].kiov_page = page;
         }
@@ -1307,73 +1391,103 @@ lnet_new_rtrbuf(lnet_rtrbufpool_t *rbp, int cpt)
 }
 
 void
-lnet_rtrpool_free_bufs(lnet_rtrbufpool_t *rbp)
+lnet_rtrpool_free_bufs(lnet_rtrbufpool_t *rbp, int cpt)
 {
-       int             npages = rbp->rbp_npages;
-       int             nbuffers = 0;
-       lnet_rtrbuf_t   *rb;
+       int              npages = rbp->rbp_npages;
+       lnet_rtrbuf_t    *rb;
+       struct list_head tmp;
 
        if (rbp->rbp_nbuffers == 0) /* not initialized or already freed */
                return;
 
-        LASSERT (cfs_list_empty(&rbp->rbp_msgs));
-        LASSERT (rbp->rbp_credits == rbp->rbp_nbuffers);
-
-        while (!cfs_list_empty(&rbp->rbp_bufs)) {
-                LASSERT (rbp->rbp_credits > 0);
+       INIT_LIST_HEAD(&tmp);
 
-                rb = cfs_list_entry(rbp->rbp_bufs.next,
-                                    lnet_rtrbuf_t, rb_list);
-                cfs_list_del(&rb->rb_list);
-                lnet_destroy_rtrbuf(rb, npages);
-                nbuffers++;
-        }
-
-        LASSERT (rbp->rbp_nbuffers == nbuffers);
-        LASSERT (rbp->rbp_credits == nbuffers);
+       lnet_net_lock(cpt);
+       lnet_drop_routed_msgs_locked(&rbp->rbp_msgs, cpt);
+       list_splice_init(&rbp->rbp_bufs, &tmp);
+       rbp->rbp_nbuffers = rbp->rbp_credits = 0;
+       rbp->rbp_mincredits = 0;
+       lnet_net_unlock(cpt);
 
-        rbp->rbp_nbuffers = rbp->rbp_credits = 0;
+       /* Free buffers on the free list. */
+       while (!list_empty(&tmp)) {
+               rb = list_entry(tmp.next, lnet_rtrbuf_t, rb_list);
+               list_del(&rb->rb_list);
+               lnet_destroy_rtrbuf(rb, npages);
+       }
 }
 
-int
-lnet_rtrpool_alloc_bufs(lnet_rtrbufpool_t *rbp, int nbufs, int cpt)
+static int
+lnet_rtrpool_adjust_bufs(lnet_rtrbufpool_t *rbp, int nbufs, int cpt)
 {
-        lnet_rtrbuf_t *rb;
-        int            i;
+       struct list_head rb_list;
+       lnet_rtrbuf_t   *rb;
+       int             num_rb;
+       int             num_buffers = 0;
+       int             npages = rbp->rbp_npages;
 
-        if (rbp->rbp_nbuffers != 0) {
-                LASSERT (rbp->rbp_nbuffers == nbufs);
-                return 0;
-        }
+       /* If we are called for less buffers than already in the pool, we
+        * just lower the nbuffers number and excess buffers will be
+        * thrown away as they are returned to the free list.  Credits
+        * then get adjusted as well. */
+       if (nbufs <= rbp->rbp_nbuffers) {
+               lnet_net_lock(cpt);
+               rbp->rbp_nbuffers = nbufs;
+               lnet_net_unlock(cpt);
+               return 0;
+       }
+
+       INIT_LIST_HEAD(&rb_list);
+
+       /* allocate the buffers on a local list first.  If all buffers are
+        * allocated successfully then join this list to the rbp buffer
+        * list.  If not then free all allocated buffers. */
+       num_rb = rbp->rbp_nbuffers;
 
-        for (i = 0; i < nbufs; i++) {
+       while (num_rb < nbufs) {
                rb = lnet_new_rtrbuf(rbp, cpt);
+               if (rb == NULL) {
+                       CERROR("Failed to allocate %d route bufs of %d pages\n",
+                              nbufs, npages);
+                       goto failed;
+               }
 
-                if (rb == NULL) {
-                        CERROR("Failed to allocate %d router bufs of %d pages\n",
-                               nbufs, rbp->rbp_npages);
-                        return -ENOMEM;
-                }
+               list_add(&rb->rb_list, &rb_list);
+               num_buffers++;
+               num_rb++;
+       }
 
-                rbp->rbp_nbuffers++;
-                rbp->rbp_credits++;
-                rbp->rbp_mincredits++;
-                cfs_list_add(&rb->rb_list, &rbp->rbp_bufs);
+       lnet_net_lock(cpt);
 
-                /* No allocation "under fire" */
-                /* Otherwise we'd need code to schedule blocked msgs etc */
-                LASSERT (!the_lnet.ln_routing);
-        }
+       list_splice_tail(&rb_list, &rbp->rbp_bufs);
+       rbp->rbp_nbuffers += num_buffers;
+       rbp->rbp_credits += num_buffers;
+       rbp->rbp_mincredits = rbp->rbp_credits;
+       /* We need to schedule blocked msg using the newly
+        * added buffers. */
+       while (!list_empty(&rbp->rbp_bufs) &&
+              !list_empty(&rbp->rbp_msgs))
+               lnet_schedule_blocked_locked(rbp);
 
-        LASSERT (rbp->rbp_credits == nbufs);
-        return 0;
+       lnet_net_unlock(cpt);
+
+       return 0;
+
+failed:
+       while (!list_empty(&rb_list)) {
+               rb = list_entry(rb_list.next, lnet_rtrbuf_t, rb_list);
+               list_del(&rb->rb_list);
+               lnet_destroy_rtrbuf(rb, npages);
+       }
+
+       return -ENOMEM;
 }
 
 void
 lnet_rtrpool_init(lnet_rtrbufpool_t *rbp, int npages)
 {
-        CFS_INIT_LIST_HEAD(&rbp->rbp_msgs);
-        CFS_INIT_LIST_HEAD(&rbp->rbp_bufs);
+       INIT_LIST_HEAD(&rbp->rbp_msgs);
+       INIT_LIST_HEAD(&rbp->rbp_bufs);
 
         rbp->rbp_npages = npages;
         rbp->rbp_credits = 0;
@@ -1381,7 +1495,7 @@ lnet_rtrpool_init(lnet_rtrbufpool_t *rbp, int npages)
 }
 
 void
-lnet_rtrpools_free(void)
+lnet_rtrpools_free(int keep_pools)
 {
        lnet_rtrbufpool_t *rtrp;
        int               i;
@@ -1390,17 +1504,19 @@ lnet_rtrpools_free(void)
                return;
 
        cfs_percpt_for_each(rtrp, i, the_lnet.ln_rtrpools) {
-               lnet_rtrpool_free_bufs(&rtrp[0]);
-               lnet_rtrpool_free_bufs(&rtrp[1]);
-               lnet_rtrpool_free_bufs(&rtrp[2]);
+               lnet_rtrpool_free_bufs(&rtrp[LNET_TINY_BUF_IDX], i);
+               lnet_rtrpool_free_bufs(&rtrp[LNET_SMALL_BUF_IDX], i);
+               lnet_rtrpool_free_bufs(&rtrp[LNET_LARGE_BUF_IDX], i);
        }
 
-       cfs_percpt_free(the_lnet.ln_rtrpools);
-       the_lnet.ln_rtrpools = NULL;
+       if (!keep_pools) {
+               cfs_percpt_free(the_lnet.ln_rtrpools);
+               the_lnet.ln_rtrpools = NULL;
+       }
 }
 
 static int
-lnet_nrb_tiny_calculate(int npages)
+lnet_nrb_tiny_calculate(void)
 {
        int     nrbs = LNET_NRB_TINY;
 
@@ -1419,7 +1535,7 @@ lnet_nrb_tiny_calculate(int npages)
 }
 
 static int
-lnet_nrb_small_calculate(int npages)
+lnet_nrb_small_calculate(void)
 {
        int     nrbs = LNET_NRB_SMALL;
 
@@ -1438,7 +1554,7 @@ lnet_nrb_small_calculate(int npages)
 }
 
 static int
-lnet_nrb_large_calculate(int npages)
+lnet_nrb_large_calculate(void)
 {
        int     nrbs = LNET_NRB_LARGE;
 
@@ -1460,38 +1576,36 @@ int
 lnet_rtrpools_alloc(int im_a_router)
 {
        lnet_rtrbufpool_t *rtrp;
-       int     large_pages = (LNET_MTU + CFS_PAGE_SIZE - 1) >> CFS_PAGE_SHIFT;
-       int     small_pages = 1;
        int     nrb_tiny;
        int     nrb_small;
        int     nrb_large;
        int     rc;
        int     i;
 
-        if (!strcmp(forwarding, "")) {
-                /* not set either way */
-                if (!im_a_router)
-                        return 0;
-        } else if (!strcmp(forwarding, "disabled")) {
-                /* explicitly disabled */
-                return 0;
-        } else if (!strcmp(forwarding, "enabled")) {
-                /* explicitly enabled */
-        } else {
-                LCONSOLE_ERROR_MSG(0x10b, "'forwarding' not set to either "
-                                   "'enabled' or 'disabled'\n");
-                return -EINVAL;
-        }
+       if (!strcmp(forwarding, "")) {
+               /* not set either way */
+               if (!im_a_router)
+                       return 0;
+       } else if (!strcmp(forwarding, "disabled")) {
+               /* explicitly disabled */
+               return 0;
+       } else if (!strcmp(forwarding, "enabled")) {
+               /* explicitly enabled */
+       } else {
+               LCONSOLE_ERROR_MSG(0x10b, "'forwarding' not set to either "
+                                  "'enabled' or 'disabled'\n");
+               return -EINVAL;
+       }
 
-       nrb_tiny = lnet_nrb_tiny_calculate(0);
+       nrb_tiny = lnet_nrb_tiny_calculate();
        if (nrb_tiny < 0)
                return -EINVAL;
 
-       nrb_small = lnet_nrb_small_calculate(small_pages);
+       nrb_small = lnet_nrb_small_calculate();
        if (nrb_small < 0)
                return -EINVAL;
 
-       nrb_large = lnet_nrb_large_calculate(large_pages);
+       nrb_large = lnet_nrb_large_calculate();
        if (nrb_large < 0)
                return -EINVAL;
 
@@ -1505,18 +1619,23 @@ lnet_rtrpools_alloc(int im_a_router)
        }
 
        cfs_percpt_for_each(rtrp, i, the_lnet.ln_rtrpools) {
-               lnet_rtrpool_init(&rtrp[0], 0);
-               rc = lnet_rtrpool_alloc_bufs(&rtrp[0], nrb_tiny, i);
+               lnet_rtrpool_init(&rtrp[LNET_TINY_BUF_IDX], 0);
+               rc = lnet_rtrpool_adjust_bufs(&rtrp[LNET_TINY_BUF_IDX],
+                                             nrb_tiny, i);
                if (rc != 0)
                        goto failed;
 
-               lnet_rtrpool_init(&rtrp[1], small_pages);
-               rc = lnet_rtrpool_alloc_bufs(&rtrp[1], nrb_small, i);
+               lnet_rtrpool_init(&rtrp[LNET_SMALL_BUF_IDX],
+                                 LNET_NRB_SMALL_PAGES);
+               rc = lnet_rtrpool_adjust_bufs(&rtrp[LNET_SMALL_BUF_IDX],
+                                             nrb_small, i);
                if (rc != 0)
                        goto failed;
 
-               lnet_rtrpool_init(&rtrp[2], large_pages);
-               rc = lnet_rtrpool_alloc_bufs(&rtrp[2], nrb_large, i);
+               lnet_rtrpool_init(&rtrp[LNET_LARGE_BUF_IDX],
+                                 LNET_NRB_LARGE_PAGES);
+               rc = lnet_rtrpool_adjust_bufs(&rtrp[LNET_LARGE_BUF_IDX],
+                                             nrb_large, i);
                if (rc != 0)
                        goto failed;
        }
@@ -1524,14 +1643,116 @@ lnet_rtrpools_alloc(int im_a_router)
        lnet_net_lock(LNET_LOCK_EX);
        the_lnet.ln_routing = 1;
        lnet_net_unlock(LNET_LOCK_EX);
-
        return 0;
 
  failed:
-       lnet_rtrpools_free();
+       lnet_rtrpools_free(0);
        return rc;
 }
 
+static int
+lnet_rtrpools_adjust_helper(int tiny, int small, int large)
+{
+       int nrb = 0;
+       int rc = 0;
+       int i;
+       lnet_rtrbufpool_t *rtrp;
+
+       /* If the provided values for each buffer pool are different than the
+        * configured values, we need to take action. */
+       if (tiny >= 0) {
+               tiny_router_buffers = tiny;
+               nrb = lnet_nrb_tiny_calculate();
+               cfs_percpt_for_each(rtrp, i, the_lnet.ln_rtrpools) {
+                       rc = lnet_rtrpool_adjust_bufs(&rtrp[LNET_TINY_BUF_IDX],
+                                                     nrb, i);
+                       if (rc != 0)
+                               return rc;
+               }
+       }
+       if (small >= 0) {
+               small_router_buffers = small;
+               nrb = lnet_nrb_small_calculate();
+               cfs_percpt_for_each(rtrp, i, the_lnet.ln_rtrpools) {
+                       rc = lnet_rtrpool_adjust_bufs(&rtrp[LNET_SMALL_BUF_IDX],
+                                                     nrb, i);
+                       if (rc != 0)
+                               return rc;
+               }
+       }
+       if (large >= 0) {
+               large_router_buffers = large;
+               nrb = lnet_nrb_large_calculate();
+               cfs_percpt_for_each(rtrp, i, the_lnet.ln_rtrpools) {
+                       rc = lnet_rtrpool_adjust_bufs(&rtrp[LNET_LARGE_BUF_IDX],
+                                                     nrb, i);
+                       if (rc != 0)
+                               return rc;
+               }
+       }
+
+       return 0;
+}
+
+int
+lnet_rtrpools_adjust(int tiny, int small, int large)
+{
+       /* this function doesn't revert the changes if adding new buffers
+        * failed.  It's up to the user space caller to revert the
+        * changes. */
+
+       if (!the_lnet.ln_routing)
+               return 0;
+
+       return lnet_rtrpools_adjust_helper(tiny, small, large);
+}
+
+int
+lnet_rtrpools_enable(void)
+{
+       int rc;
+
+       if (the_lnet.ln_routing)
+               return 0;
+
+       if (the_lnet.ln_rtrpools == NULL)
+               /* If routing is turned off, and we have never
+                * initialized the pools before, just call the
+                * standard buffer pool allocation routine as
+                * if we are just configuring this for the first
+                * time. */
+               return lnet_rtrpools_alloc(1);
+
+       rc = lnet_rtrpools_adjust_helper(0, 0, 0);
+       if (rc != 0)
+               return rc;
+
+       lnet_net_lock(LNET_LOCK_EX);
+       the_lnet.ln_routing = 1;
+
+       the_lnet.ln_ping_info->pi_features &= ~LNET_PING_FEAT_RTE_DISABLED;
+       lnet_net_unlock(LNET_LOCK_EX);
+
+       return 0;
+}
+
+void
+lnet_rtrpools_disable(void)
+{
+       if (!the_lnet.ln_routing)
+               return;
+
+       lnet_net_lock(LNET_LOCK_EX);
+       the_lnet.ln_routing = 0;
+       the_lnet.ln_ping_info->pi_features |= LNET_PING_FEAT_RTE_DISABLED;
+
+       tiny_router_buffers = 0;
+       small_router_buffers = 0;
+       large_router_buffers = 0;
+       lnet_net_unlock(LNET_LOCK_EX);
+       lnet_rtrpools_free(1);
+}
+
 int
 lnet_notify(lnet_ni_t *ni, lnet_nid_t nid, int alive, cfs_time_t when)
 {
@@ -1539,12 +1760,12 @@ lnet_notify(lnet_ni_t *ni, lnet_nid_t nid, int alive, cfs_time_t when)
        cfs_time_t              now = cfs_time_current();
        int                     cpt = lnet_cpt_of_nid(nid);
 
-        LASSERT (!cfs_in_interrupt ());
+       LASSERT (!in_interrupt ());
 
-        CDEBUG (D_NET, "%s notifying %s: %s\n",
-                (ni == NULL) ? "userspace" : libcfs_nid2str(ni->ni_nid),
-                libcfs_nid2str(nid),
-                alive ? "up" : "down");
+       CDEBUG (D_NET, "%s notifying %s: %s\n",
+               (ni == NULL) ? "userspace" : libcfs_nid2str(ni->ni_nid),
+               libcfs_nid2str(nid),
+               alive ? "up" : "down");
 
         if (ni != NULL &&
             LNET_NIDNET(ni->ni_nid) != LNET_NIDNET(nid)) {
@@ -1594,7 +1815,8 @@ lnet_notify(lnet_ni_t *ni, lnet_nid_t nid, int alive, cfs_time_t when)
 
         lnet_notify_locked(lp, ni == NULL, alive, when);
 
-       lnet_ni_notify_locked(ni, lp);
+       if (ni != NULL)
+               lnet_ni_notify_locked(ni, lp);
 
        lnet_peer_decref_locked(lp);
 
@@ -1686,11 +1908,11 @@ lnet_router_checker (void)
 
        lnet_net_lock(0);
 
-        version = the_lnet.ln_routers_version;
-        cfs_list_for_each_entry (rtr, &the_lnet.ln_routers, lp_rtr_list) {
-                lnet_ping_router_locked(rtr);
-                LASSERT (version == the_lnet.ln_routers_version);
-        }
+       version = the_lnet.ln_routers_version;
+       list_for_each_entry(rtr, &the_lnet.ln_routers, lp_rtr_list) {
+               lnet_ping_router_locked(rtr);
+               LASSERT(version == the_lnet.ln_routers_version);
+       }
 
        lnet_net_unlock(0);
 
@@ -1721,7 +1943,7 @@ lnet_get_tunables (void)
 }
 
 void
-lnet_rtrpools_free(void)
+lnet_rtrpools_free(int keep_pools)
 {
 }