Whamcloud - gitweb
LU-14008 o2iblnd: cleanup
[fs/lustre-release.git] / lnet / klnds / o2iblnd / o2iblnd_cb.c
index d842943..932e06a 100644 (file)
@@ -27,7 +27,6 @@
  */
 /*
  * This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
  *
  * lnet/klnds/o2iblnd/o2iblnd_cb.c
  *
@@ -100,9 +99,9 @@ kiblnd_txlist_done(struct list_head *txlist, int status,
 {
        struct kib_tx *tx;
 
-       while (!list_empty(txlist)) {
-               tx = list_entry(txlist->next, struct kib_tx, tx_list);
-
+       while ((tx = list_first_entry_or_null(txlist,
+                                             struct kib_tx,
+                                             tx_list)) != NULL) {
                list_del(&tx->tx_list);
                /* complete now */
                tx->tx_waiting = 0;
@@ -243,11 +242,9 @@ out:
 static struct kib_tx *
 kiblnd_find_waiting_tx_locked(struct kib_conn *conn, int txtype, u64 cookie)
 {
-       struct list_head *tmp;
-
-       list_for_each(tmp, &conn->ibc_active_txs) {
-               struct kib_tx *tx = list_entry(tmp, struct kib_tx, tx_list);
+       struct kib_tx *tx;
 
+       list_for_each_entry(tx, &conn->ibc_active_txs, tx_list) {
                LASSERT(!tx->tx_queued);
                LASSERT(tx->tx_sending != 0 || tx->tx_waiting);
 
@@ -495,45 +492,45 @@ kiblnd_rx_complete(struct kib_rx *rx, int status, int nob)
        int rc;
        int err = -EIO;
 
-        LASSERT (net != NULL);
-        LASSERT (rx->rx_nob < 0);               /* was posted */
-        rx->rx_nob = 0;                         /* isn't now */
+       LASSERT(net);
+       LASSERT(rx->rx_nob < 0);        /* was posted */
+       rx->rx_nob = 0;                 /* isn't now */
 
-        if (conn->ibc_state > IBLND_CONN_ESTABLISHED)
-                goto ignore;
+       if (conn->ibc_state > IBLND_CONN_ESTABLISHED)
+               goto ignore;
 
-        if (status != IB_WC_SUCCESS) {
-                CNETERR("Rx from %s failed: %d\n",
-                        libcfs_nid2str(conn->ibc_peer->ibp_nid), status);
-                goto failed;
-        }
+       if (status != IB_WC_SUCCESS) {
+               CNETERR("Rx from %s failed: %d\n",
+                       libcfs_nid2str(conn->ibc_peer->ibp_nid), status);
+               goto failed;
+       }
 
-        LASSERT (nob >= 0);
-        rx->rx_nob = nob;
+       LASSERT(nob >= 0);
+       rx->rx_nob = nob;
 
-        rc = kiblnd_unpack_msg(msg, rx->rx_nob);
-        if (rc != 0) {
-                CERROR ("Error %d unpacking rx from %s\n",
-                        rc, libcfs_nid2str(conn->ibc_peer->ibp_nid));
-                goto failed;
-        }
+       rc = kiblnd_unpack_msg(msg, rx->rx_nob);
+       if (rc != 0) {
+               CERROR("Error %d unpacking rx from %s\n",
+                      rc, libcfs_nid2str(conn->ibc_peer->ibp_nid));
+               goto failed;
+       }
 
-        if (msg->ibm_srcnid != conn->ibc_peer->ibp_nid ||
-            msg->ibm_dstnid != ni->ni_nid ||
-            msg->ibm_srcstamp != conn->ibc_incarnation ||
-            msg->ibm_dststamp != net->ibn_incarnation) {
-                CERROR ("Stale rx from %s\n",
-                        libcfs_nid2str(conn->ibc_peer->ibp_nid));
-                err = -ESTALE;
-                goto failed;
-        }
+       if (msg->ibm_srcnid != conn->ibc_peer->ibp_nid ||
+           msg->ibm_dstnid != lnet_nid_to_nid4(&ni->ni_nid) ||
+           msg->ibm_srcstamp != conn->ibc_incarnation ||
+           msg->ibm_dststamp != net->ibn_incarnation) {
+               CERROR("Stale rx from %s\n",
+                      libcfs_nid2str(conn->ibc_peer->ibp_nid));
+               err = -ESTALE;
+               goto failed;
+       }
 
-        /* set time last known alive */
-        kiblnd_peer_alive(conn->ibc_peer);
+       /* set time last known alive */
+       kiblnd_peer_alive(conn->ibc_peer);
 
-        /* racing with connection establishment/teardown! */
+       /* racing with connection establishment/teardown! */
 
-        if (conn->ibc_state < IBLND_CONN_ESTABLISHED) {
+       if (conn->ibc_state < IBLND_CONN_ESTABLISHED) {
                rwlock_t  *g_lock = &kiblnd_data.kib_global_lock;
                unsigned long  flags;
 
@@ -545,15 +542,15 @@ kiblnd_rx_complete(struct kib_rx *rx, int status, int nob)
                        return;
                }
                write_unlock_irqrestore(g_lock, flags);
-        }
-        kiblnd_handle_rx(rx);
-        return;
+       }
+       kiblnd_handle_rx(rx);
+       return;
 
- failed:
-        CDEBUG(D_NET, "rx %p conn %p\n", rx, conn);
-        kiblnd_close_conn(conn, err);
- ignore:
-        kiblnd_drop_rx(rx);                     /* Don't re-post rx. */
+failed:
+       CDEBUG(D_NET, "rx %p conn %p\n", rx, conn);
+       kiblnd_close_conn(conn, err);
+ignore:
+       kiblnd_drop_rx(rx);                     /* Don't re-post rx. */
 }
 
 static int
@@ -588,6 +585,7 @@ kiblnd_fmr_map_tx(struct kib_net *net, struct kib_tx *tx,
                return -EPROTONOSUPPORT;
        }
 
+#ifdef HAVE_FMR_POOL_API
        /*
         * FMR does not support gaps but the tx has gaps then
         * we should make sure that the number of fragments we'll be sending
@@ -606,11 +604,13 @@ kiblnd_fmr_map_tx(struct kib_net *net, struct kib_tx *tx,
                        return -EFBIG;
                }
        }
+#endif
 
        fps = net->ibn_fmr_ps[cpt];
        rc = kiblnd_fmr_pool_map(fps, tx, rd, nob, 0, &tx->tx_fmr);
        if (rc != 0) {
-               CERROR("Can't map %u pages: %d\n", nob, rc);
+               CERROR("Can't map %u bytes (%u/%u)s: %d\n", nob,
+                      tx->tx_nfrags, rd->rd_nfrags, rc);
                return rc;
        }
 
@@ -623,11 +623,17 @@ kiblnd_fmr_map_tx(struct kib_net *net, struct kib_tx *tx,
         * for FastReg or FMR with no gaps we can accumulate all
         * the fragments in one FastReg or FMR fragment.
         */
-       if (((dev->ibd_dev_caps & IBLND_DEV_CAPS_FMR_ENABLED) && !tx->tx_gaps) ||
+       if (
+#ifdef HAVE_FMR_POOL_API
+           ((dev->ibd_dev_caps & IBLND_DEV_CAPS_FMR_ENABLED)
+            && !tx->tx_gaps) ||
+#endif
            (dev->ibd_dev_caps & IBLND_DEV_CAPS_FASTREG_ENABLED)) {
                /* FMR requires zero based address */
+#ifdef HAVE_FMR_POOL_API
                if (dev->ibd_dev_caps & IBLND_DEV_CAPS_FMR_ENABLED)
                        rd->rd_frags[0].rf_addr &= ~hdev->ibh_page_mask;
+#endif
                rd->rd_frags[0].rf_nob = nob;
                rd->rd_nfrags = 1;
        } else {
@@ -648,11 +654,15 @@ kiblnd_fmr_map_tx(struct kib_net *net, struct kib_tx *tx,
 static void
 kiblnd_unmap_tx(struct kib_tx *tx)
 {
-       if (tx->tx_fmr.fmr_pfmr || tx->tx_fmr.fmr_frd)
+       if (
+#ifdef HAVE_FMR_POOL_API
+               tx->tx_fmr.fmr_pfmr ||
+#endif
+               tx->tx_fmr.fmr_frd)
                kiblnd_fmr_pool_unmap(&tx->tx_fmr, tx->tx_status);
 
        if (tx->tx_nfrags != 0) {
-               kiblnd_dma_unmap_sg(tx->tx_pool->tpo_hdev->ibh_ibdev,
+               kiblnd_dma_unmap_sg(tx->tx_pool->tpo_hdev,
                                    tx->tx_frags, tx->tx_nfrags, tx->tx_dmadir);
                tx->tx_nfrags = 0;
        }
@@ -675,8 +685,11 @@ kiblnd_find_rd_dma_mr(struct lnet_ni *ni, struct kib_rdma_desc *rd)
         * dead in the water and fail the operation.
         */
        if (tunables->lnd_map_on_demand &&
-           (net->ibn_dev->ibd_dev_caps & IBLND_DEV_CAPS_FASTREG_ENABLED ||
-            net->ibn_dev->ibd_dev_caps & IBLND_DEV_CAPS_FMR_ENABLED))
+           (net->ibn_dev->ibd_dev_caps & IBLND_DEV_CAPS_FASTREG_ENABLED
+#ifdef HAVE_FMR_POOL_API
+            || net->ibn_dev->ibd_dev_caps & IBLND_DEV_CAPS_FMR_ENABLED
+#endif
+       ))
                return NULL;
 
        /*
@@ -704,7 +717,7 @@ static int kiblnd_map_tx(struct lnet_ni *ni, struct kib_tx *tx,
         tx->tx_dmadir = (rd != tx->tx_rd) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
        tx->tx_nfrags = nfrags;
 
-       rd->rd_nfrags = kiblnd_dma_map_sg(hdev->ibh_ibdev, tx->tx_frags,
+       rd->rd_nfrags = kiblnd_dma_map_sg(hdev, tx->tx_frags,
                                          tx->tx_nfrags, tx->tx_dmadir);
 
         for (i = 0, nob = 0; i < rd->rd_nfrags; i++) {
@@ -730,88 +743,15 @@ static int kiblnd_map_tx(struct lnet_ni *ni, struct kib_tx *tx,
        return -EINVAL;
 }
 
-static int kiblnd_setup_rd_iov(struct lnet_ni *ni, struct kib_tx *tx,
-                              struct kib_rdma_desc *rd, unsigned int niov,
-                              struct kvec *iov, int offset, int nob)
-{
-       struct kib_net *net = ni->ni_data;
-       struct page *page;
-        struct scatterlist *sg;
-        unsigned long       vaddr;
-        int                 fragnob;
-        int                 page_offset;
-       unsigned int        max_niov;
-
-        LASSERT (nob > 0);
-        LASSERT (niov > 0);
-        LASSERT (net != NULL);
-
-        while (offset >= iov->iov_len) {
-                offset -= iov->iov_len;
-                niov--;
-                iov++;
-                LASSERT (niov > 0);
-        }
-
-       max_niov = niov;
-
-       sg = tx->tx_frags;
-       do {
-               LASSERT(niov > 0);
-
-               vaddr = ((unsigned long)iov->iov_base) + offset;
-               page_offset = vaddr & (PAGE_SIZE - 1);
-               page = lnet_kvaddr_to_page(vaddr);
-               if (page == NULL) {
-                       CERROR("Can't find page\n");
-                       return -EFAULT;
-               }
-
-               fragnob = min((int)(iov->iov_len - offset), nob);
-               fragnob = min(fragnob, (int)PAGE_SIZE - page_offset);
-
-               /*
-                * We're allowed to start at a non-aligned page offset in
-                * the first fragment and end at a non-aligned page offset
-                * in the last fragment.
-                */
-               if ((fragnob < (int)PAGE_SIZE - page_offset) &&
-                   (niov < max_niov) && nob > fragnob) {
-                       CDEBUG(D_NET, "fragnob %d < available page %d: with"
-                                     " remaining %d iovs with %d nob left\n",
-                              fragnob, (int)PAGE_SIZE - page_offset, niov,
-                              nob);
-                       tx->tx_gaps = true;
-               }
-
-               sg_set_page(sg, page, fragnob, page_offset);
-               sg = sg_next(sg);
-               if (!sg) {
-                       CERROR("lacking enough sg entries to map tx\n");
-                       return -EFAULT;
-               }
-
-                if (offset + fragnob < iov->iov_len) {
-                        offset += fragnob;
-                } else {
-                        offset = 0;
-                        iov++;
-                        niov--;
-                }
-                nob -= fragnob;
-        } while (nob > 0);
-
-        return kiblnd_map_tx(ni, tx, rd, sg - tx->tx_frags);
-}
-
 static int kiblnd_setup_rd_kiov(struct lnet_ni *ni, struct kib_tx *tx,
                                struct kib_rdma_desc *rd, int nkiov,
-                               lnet_kiov_t *kiov, int offset, int nob)
+                               struct bio_vec *kiov, int offset, int nob)
 {
        struct kib_net *net = ni->ni_data;
        struct scatterlist *sg;
-       int                 fragnob;
-       int                 max_nkiov;
+       int fragnob;
+       int max_nkiov;
+       int sg_count = 0;
 
        CDEBUG(D_NET, "niov %d offset %d nob %d\n", nkiov, offset, nob);
 
@@ -819,8 +759,8 @@ static int kiblnd_setup_rd_kiov(struct lnet_ni *ni, struct kib_tx *tx,
        LASSERT(nkiov > 0);
        LASSERT(net != NULL);
 
-       while (offset >= kiov->kiov_len) {
-               offset -= kiov->kiov_len;
+       while (offset >= kiov->bv_len) {
+               offset -= kiov->bv_len;
                nkiov--;
                kiov++;
                LASSERT(nkiov > 0);
@@ -832,29 +772,31 @@ static int kiblnd_setup_rd_kiov(struct lnet_ni *ni, struct kib_tx *tx,
        do {
                LASSERT(nkiov > 0);
 
-               fragnob = min((int)(kiov->kiov_len - offset), nob);
+               if (!sg) {
+                       CERROR("lacking enough sg entries to map tx\n");
+                       return -EFAULT;
+               }
+               sg_count++;
+
+               fragnob = min((int)(kiov->bv_len - offset), nob);
 
                /*
                 * We're allowed to start at a non-aligned page offset in
                 * the first fragment and end at a non-aligned page offset
                 * in the last fragment.
                 */
-               if ((fragnob < (int)(kiov->kiov_len - offset)) &&
+               if ((fragnob < (int)(kiov->bv_len - offset)) &&
                    nkiov < max_nkiov && nob > fragnob) {
                        CDEBUG(D_NET, "fragnob %d < available page %d: with"
                                      " remaining %d kiovs with %d nob left\n",
-                              fragnob, (int)(kiov->kiov_len - offset),
+                              fragnob, (int)(kiov->bv_len - offset),
                               nkiov, nob);
                        tx->tx_gaps = true;
                }
 
-               sg_set_page(sg, kiov->kiov_page, fragnob,
-                           kiov->kiov_offset + offset);
+               sg_set_page(sg, kiov->bv_page, fragnob,
+                           kiov->bv_offset + offset);
                sg = sg_next(sg);
-               if (!sg) {
-                       CERROR("lacking enough sg entries to map tx\n");
-                       return -EFAULT;
-               }
 
                offset = 0;
                kiov++;
@@ -862,7 +804,7 @@ static int kiblnd_setup_rd_kiov(struct lnet_ni *ni, struct kib_tx *tx,
                nob -= fragnob;
        } while (nob > 0);
 
-       return kiblnd_map_tx(ni, tx, rd, sg - tx->tx_frags);
+       return kiblnd_map_tx(ni, tx, rd, sg_count);
 }
 
 static int
@@ -872,6 +814,7 @@ __must_hold(&conn->ibc_lock)
        struct kib_msg *msg = tx->tx_msg;
        struct kib_peer_ni *peer_ni = conn->ibc_peer;
        struct lnet_ni *ni = peer_ni->ibp_ni;
+       struct kib_fast_reg_descriptor *frd = tx->tx_fmr.fmr_frd;
        int ver = conn->ibc_version;
        int rc;
        int done;
@@ -956,11 +899,10 @@ __must_hold(&conn->ibc_lock)
                 /* close_conn will launch failover */
                 rc = -ENETDOWN;
         } else {
-               struct kib_fast_reg_descriptor *frd = tx->tx_fmr.fmr_frd;
                struct ib_send_wr *bad = &tx->tx_wrq[tx->tx_nwrq - 1].wr;
                struct ib_send_wr *wr  = &tx->tx_wrq[0].wr;
 
-               if (frd != NULL) {
+               if (frd != NULL && !frd->frd_posted) {
                        if (!frd->frd_valid) {
                                wr = &frd->frd_inv_wr.wr;
                                wr->next = &frd->frd_fastreg_wr.wr;
@@ -989,8 +931,11 @@ __must_hold(&conn->ibc_lock)
 
        conn->ibc_last_send = ktime_get();
 
-        if (rc == 0)
-                return 0;
+       if (rc == 0) {
+               if (frd != NULL)
+                       frd->frd_posted = true;
+               return 0;
+       }
 
         /* NB credits are transferred in the actual
          * message, which can only be the last work item */
@@ -1048,9 +993,8 @@ kiblnd_check_sends_locked(struct kib_conn *conn)
         LASSERT (conn->ibc_reserved_credits >= 0);
 
         while (conn->ibc_reserved_credits > 0 &&
-              !list_empty(&conn->ibc_tx_queue_rsrvd)) {
-               tx = list_entry(conn->ibc_tx_queue_rsrvd.next,
-                               struct kib_tx, tx_list);
+              (tx = list_first_entry_or_null(&conn->ibc_tx_queue_rsrvd,
+                                             struct kib_tx, tx_list)) != NULL) {
                list_move_tail(&tx->tx_list, &conn->ibc_tx_queue);
                 conn->ibc_reserved_credits--;
         }
@@ -1072,17 +1016,17 @@ kiblnd_check_sends_locked(struct kib_conn *conn)
 
                if (!list_empty(&conn->ibc_tx_queue_nocred)) {
                         credit = 0;
-                       tx = list_entry(conn->ibc_tx_queue_nocred.next,
-                                       struct kib_tx, tx_list);
+                       tx = list_first_entry(&conn->ibc_tx_queue_nocred,
+                                             struct kib_tx, tx_list);
                } else if (!list_empty(&conn->ibc_tx_noops)) {
                         LASSERT (!IBLND_OOB_CAPABLE(ver));
                         credit = 1;
-                       tx = list_entry(conn->ibc_tx_noops.next,
-                                       struct kib_tx, tx_list);
+                       tx = list_first_entry(&conn->ibc_tx_noops,
+                                             struct kib_tx, tx_list);
                } else if (!list_empty(&conn->ibc_tx_queue)) {
                         credit = 1;
-                       tx = list_entry(conn->ibc_tx_queue.next,
-                                       struct kib_tx, tx_list);
+                       tx = list_first_entry(&conn->ibc_tx_queue,
+                                             struct kib_tx, tx_list);
                 } else
                         break;
 
@@ -1094,24 +1038,28 @@ kiblnd_check_sends_locked(struct kib_conn *conn)
 static void
 kiblnd_tx_complete(struct kib_tx *tx, int status)
 {
-        int           failed = (status != IB_WC_SUCCESS);
+       int           failed = (status != IB_WC_SUCCESS);
        struct kib_conn   *conn = tx->tx_conn;
-        int           idle;
+       int           idle;
 
-        LASSERT (tx->tx_sending > 0);
+       if (tx->tx_sending <= 0) {
+               CERROR("Received an event on a freed tx: %p status %d\n",
+                      tx, tx->tx_status);
+               return;
+       }
 
-        if (failed) {
-                if (conn->ibc_state == IBLND_CONN_ESTABLISHED)
+       if (failed) {
+               if (conn->ibc_state == IBLND_CONN_ESTABLISHED)
                        CNETERR("Tx -> %s cookie %#llx"
-                                " sending %d waiting %d: failed %d\n",
-                                libcfs_nid2str(conn->ibc_peer->ibp_nid),
-                                tx->tx_cookie, tx->tx_sending, tx->tx_waiting,
-                                status);
+                               " sending %d waiting %d: failed %d\n",
+                               libcfs_nid2str(conn->ibc_peer->ibp_nid),
+                               tx->tx_cookie, tx->tx_sending, tx->tx_waiting,
+                               status);
 
-                kiblnd_close_conn(conn, -EIO);
-        } else {
-                kiblnd_peer_alive(conn->ibc_peer);
-        }
+               kiblnd_close_conn(conn, -EIO);
+       } else {
+               kiblnd_peer_alive(conn->ibc_peer);
+       }
 
        spin_lock(&conn->ibc_lock);
 
@@ -1155,7 +1103,7 @@ kiblnd_init_tx_msg(struct lnet_ni *ni, struct kib_tx *tx, int type,
 #endif
 
        LASSERT(tx->tx_nwrq >= 0);
-       LASSERT(tx->tx_nwrq < IBLND_MAX_RDMA_FRAGS + 1);
+       LASSERT(tx->tx_nwrq <= IBLND_MAX_RDMA_FRAGS);
        LASSERT(nob <= IBLND_MSG_SIZE);
 #ifdef HAVE_IB_GET_DMA_MR
        LASSERT(mr != NULL);
@@ -1229,8 +1177,9 @@ kiblnd_init_rdma(struct kib_conn *conn, struct kib_tx *tx, int type,
                        break;
                }
 
-               sge_nob = MIN(MIN(kiblnd_rd_frag_size(srcrd, srcidx),
-                                 kiblnd_rd_frag_size(dstrd, dstidx)), resid);
+               sge_nob = min3(kiblnd_rd_frag_size(srcrd, srcidx),
+                              kiblnd_rd_frag_size(dstrd, dstidx),
+                              resid);
 
                sge = &tx->tx_sge[tx->tx_nsge];
                sge->addr   = kiblnd_rd_frag_addr(srcrd, srcidx);
@@ -1307,7 +1256,7 @@ kiblnd_queue_tx_locked(struct kib_tx *tx, struct kib_conn *conn)
                return;
        }
 
-       timeout_ns = lnet_get_lnd_timeout() * NSEC_PER_SEC;
+       timeout_ns = kiblnd_timeout() * NSEC_PER_SEC;
        tx->tx_queued = 1;
        tx->tx_deadline = ktime_add_ns(ktime_get(), timeout_ns);
 
@@ -1361,10 +1310,11 @@ kiblnd_queue_tx(struct kib_tx *tx, struct kib_conn *conn)
        spin_unlock(&conn->ibc_lock);
 }
 
-static int kiblnd_resolve_addr(struct rdma_cm_id *cmid,
-                               struct sockaddr_in *srcaddr,
-                               struct sockaddr_in *dstaddr,
-                               int timeout_ms)
+static int
+kiblnd_resolve_addr_cap(struct rdma_cm_id *cmid,
+                       struct sockaddr_in *srcaddr,
+                       struct sockaddr_in *dstaddr,
+                       int timeout_ms)
 {
         unsigned short port;
         int rc;
@@ -1394,8 +1344,36 @@ static int kiblnd_resolve_addr(struct rdma_cm_id *cmid,
                 }
         }
 
-        CERROR("Failed to bind to a free privileged port\n");
-        return rc;
+       CERROR("cannot bind to a free privileged port: rc = %d\n", rc);
+
+       return rc;
+}
+
+static int
+kiblnd_resolve_addr(struct rdma_cm_id *cmid,
+                   struct sockaddr_in *srcaddr,
+                   struct sockaddr_in *dstaddr,
+                   int timeout_ms)
+{
+       const struct cred *old_creds = NULL;
+       struct cred *new_creds;
+       int rc;
+
+       if (!capable(CAP_NET_BIND_SERVICE)) {
+               new_creds = prepare_kernel_cred(NULL);
+               if (!new_creds)
+                       return -ENOMEM;
+
+               cap_raise(new_creds->cap_effective, CAP_NET_BIND_SERVICE);
+               old_creds = override_creds(new_creds);
+       }
+
+       rc = kiblnd_resolve_addr_cap(cmid, srcaddr, dstaddr, timeout_ms);
+
+       if (old_creds)
+               revert_creds(old_creds);
+
+       return rc;
 }
 
 static void
@@ -1436,12 +1414,12 @@ kiblnd_connect_peer(struct kib_peer_ni *peer_ni)
 
        if (*kiblnd_tunables.kib_use_priv_port) {
                rc = kiblnd_resolve_addr(cmid, &srcaddr, &dstaddr,
-                                        lnet_get_lnd_timeout() * 1000);
+                                        kiblnd_timeout() * 1000);
        } else {
                rc = rdma_resolve_addr(cmid,
                                       (struct sockaddr *)&srcaddr,
                                       (struct sockaddr *)&dstaddr,
-                                      lnet_get_lnd_timeout() * 1000);
+                                      kiblnd_timeout() * 1000);
        }
        if (rc != 0) {
                /* Can't initiate address resolution:  */
@@ -1518,47 +1496,49 @@ kiblnd_launch_tx(struct lnet_ni *ni, struct kib_tx *tx, lnet_nid_t nid)
        struct kib_peer_ni *peer2;
        struct kib_conn *conn;
        rwlock_t *g_lock = &kiblnd_data.kib_global_lock;
-        unsigned long      flags;
-        int                rc;
-       int                i;
+       unsigned long flags;
+       int rc;
+       int i;
        struct lnet_ioctl_config_o2iblnd_tunables *tunables;
 
-        /* If I get here, I've committed to send, so I complete the tx with
-         * failure on any problems */
+       /* If I get here, I've committed to send, so I complete the tx with
+        * failure on any problems
+        */
 
-        LASSERT (tx == NULL || tx->tx_conn == NULL); /* only set when assigned a conn */
-        LASSERT (tx == NULL || tx->tx_nwrq > 0);     /* work items have been set up */
+       LASSERT(!tx || !tx->tx_conn);     /* only set when assigned a conn */
+       LASSERT(!tx || tx->tx_nwrq > 0);  /* work items have been set up */
 
-        /* First time, just use a read lock since I expect to find my peer_ni
-         * connected */
+       /* First time, just use a read lock since I expect to find my peer_ni
+        * connected
+        */
        read_lock_irqsave(g_lock, flags);
 
-        peer_ni = kiblnd_find_peer_locked(ni, nid);
+       peer_ni = kiblnd_find_peer_locked(ni, nid);
        if (peer_ni != NULL && !list_empty(&peer_ni->ibp_conns)) {
-                /* Found a peer_ni with an established connection */
-                conn = kiblnd_get_conn_locked(peer_ni);
-                kiblnd_conn_addref(conn); /* 1 ref for me... */
+               /* Found a peer_ni with an established connection */
+               conn = kiblnd_get_conn_locked(peer_ni);
+               kiblnd_conn_addref(conn); /* 1 ref for me... */
 
                read_unlock_irqrestore(g_lock, flags);
 
-                if (tx != NULL)
-                        kiblnd_queue_tx(tx, conn);
-                kiblnd_conn_decref(conn); /* ...to here */
-                return;
-        }
+               if (tx != NULL)
+                       kiblnd_queue_tx(tx, conn);
+               kiblnd_conn_decref(conn); /* ...to here */
+               return;
+       }
 
        read_unlock(g_lock);
        /* Re-try with a write lock */
        write_lock(g_lock);
 
-        peer_ni = kiblnd_find_peer_locked(ni, nid);
-        if (peer_ni != NULL) {
+       peer_ni = kiblnd_find_peer_locked(ni, nid);
+       if (peer_ni != NULL) {
                if (list_empty(&peer_ni->ibp_conns)) {
-                        /* found a peer_ni, but it's still connecting... */
+                       /* found a peer_ni, but it's still connecting... */
                        LASSERT(kiblnd_peer_connecting(peer_ni));
-                        if (tx != NULL)
+                       if (tx != NULL)
                                list_add_tail(&tx->tx_list,
-                                                  &peer_ni->ibp_tx_queue);
+                                             &peer_ni->ibp_tx_queue);
                        write_unlock_irqrestore(g_lock, flags);
                } else {
                        conn = kiblnd_get_conn_locked(peer_ni);
@@ -1566,12 +1546,12 @@ kiblnd_launch_tx(struct lnet_ni *ni, struct kib_tx *tx, lnet_nid_t nid)
 
                        write_unlock_irqrestore(g_lock, flags);
 
-                        if (tx != NULL)
-                                kiblnd_queue_tx(tx, conn);
-                        kiblnd_conn_decref(conn); /* ...to here */
-                }
-                return;
-        }
+                       if (tx != NULL)
+                               kiblnd_queue_tx(tx, conn);
+                       kiblnd_conn_decref(conn); /* ...to here */
+               }
+               return;
+       }
 
        write_unlock_irqrestore(g_lock, flags);
 
@@ -1590,14 +1570,14 @@ kiblnd_launch_tx(struct lnet_ni *ni, struct kib_tx *tx, lnet_nid_t nid)
 
        write_lock_irqsave(g_lock, flags);
 
-        peer2 = kiblnd_find_peer_locked(ni, nid);
-        if (peer2 != NULL) {
+       peer2 = kiblnd_find_peer_locked(ni, nid);
+       if (peer2 != NULL) {
                if (list_empty(&peer2->ibp_conns)) {
-                        /* found a peer_ni, but it's still connecting... */
+                       /* found a peer_ni, but it's still connecting... */
                        LASSERT(kiblnd_peer_connecting(peer2));
-                        if (tx != NULL)
+                       if (tx != NULL)
                                list_add_tail(&tx->tx_list,
-                                                  &peer2->ibp_tx_queue);
+                                             &peer2->ibp_tx_queue);
                        write_unlock_irqrestore(g_lock, flags);
                } else {
                        conn = kiblnd_get_conn_locked(peer2);
@@ -1605,14 +1585,14 @@ kiblnd_launch_tx(struct lnet_ni *ni, struct kib_tx *tx, lnet_nid_t nid)
 
                        write_unlock_irqrestore(g_lock, flags);
 
-                        if (tx != NULL)
-                                kiblnd_queue_tx(tx, conn);
-                        kiblnd_conn_decref(conn); /* ...to here */
-                }
+                       if (tx != NULL)
+                               kiblnd_queue_tx(tx, conn);
+                       kiblnd_conn_decref(conn); /* ...to here */
+               }
 
-                kiblnd_peer_decref(peer_ni);
-                return;
-        }
+               kiblnd_peer_decref(peer_ni);
+               return;
+       }
 
        /* Brand new peer_ni */
        LASSERT(peer_ni->ibp_connecting == 0);
@@ -1625,14 +1605,14 @@ kiblnd_launch_tx(struct lnet_ni *ni, struct kib_tx *tx, lnet_nid_t nid)
        if (tx != NULL)
                list_add_tail(&tx->tx_list, &peer_ni->ibp_tx_queue);
 
-        kiblnd_peer_addref(peer_ni);
-       list_add_tail(&peer_ni->ibp_list, kiblnd_nid2peerlist(nid));
+       kiblnd_peer_addref(peer_ni);
+       hash_add(kiblnd_data.kib_peers, &peer_ni->ibp_list, nid);
 
        write_unlock_irqrestore(g_lock, flags);
 
        for (i = 0; i < tunables->lnd_conns_per_peer; i++)
                kiblnd_connect_peer(peer_ni);
-        kiblnd_peer_decref(peer_ni);
+       kiblnd_peer_decref(peer_ni);
 }
 
 int
@@ -1644,8 +1624,7 @@ kiblnd_send(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg)
        int               target_is_router = lntmsg->msg_target_is_router;
        int               routing = lntmsg->msg_routing;
        unsigned int      payload_niov = lntmsg->msg_niov;
-       struct kvec      *payload_iov = lntmsg->msg_iov;
-       lnet_kiov_t      *payload_kiov = lntmsg->msg_kiov;
+       struct bio_vec   *payload_kiov = lntmsg->msg_kiov;
        unsigned int      payload_offset = lntmsg->msg_offset;
        unsigned int      payload_nob = lntmsg->msg_len;
        struct kib_msg *ibmsg;
@@ -1664,8 +1643,15 @@ kiblnd_send(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg)
 
        /* Thread context */
        LASSERT (!in_interrupt());
-       /* payload is either all vaddrs or all pages */
-       LASSERT (!(payload_kiov != NULL && payload_iov != NULL));
+
+       tx = kiblnd_get_idle_tx(ni, target.nid);
+       if (tx == NULL) {
+               CERROR("Can't allocate %s txd for %s\n",
+                       lnet_msgtyp2str(type),
+                       libcfs_nid2str(target.nid));
+               return -ENOMEM;
+       }
+       ibmsg = tx->tx_msg;
 
        switch (type) {
        default:
@@ -1682,28 +1668,14 @@ kiblnd_send(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg)
 
                 /* is the REPLY message too small for RDMA? */
                nob = offsetof(struct kib_msg, ibm_u.immediate.ibim_payload[lntmsg->msg_md->md_length]);
-                if (nob <= IBLND_MSG_SIZE)
-                        break;                  /* send IMMEDIATE */
+               if (nob <= IBLND_MSG_SIZE && !lntmsg->msg_rdma_force)
+                       break;                  /* send IMMEDIATE */
 
-               tx = kiblnd_get_idle_tx(ni, target.nid);
-               if (tx == NULL) {
-                       CERROR("Can't allocate txd for GET to %s\n",
-                              libcfs_nid2str(target.nid));
-                       return -ENOMEM;
-               }
-
-               ibmsg = tx->tx_msg;
                rd = &ibmsg->ibm_u.get.ibgm_rd;
-               if ((lntmsg->msg_md->md_options & LNET_MD_KIOV) == 0)
-                       rc = kiblnd_setup_rd_iov(ni, tx, rd,
-                                                lntmsg->msg_md->md_niov,
-                                                lntmsg->msg_md->md_iov.iov,
-                                                0, lntmsg->msg_md->md_length);
-               else
-                       rc = kiblnd_setup_rd_kiov(ni, tx, rd,
-                                                 lntmsg->msg_md->md_niov,
-                                                 lntmsg->msg_md->md_iov.kiov,
-                                                 0, lntmsg->msg_md->md_length);
+               rc = kiblnd_setup_rd_kiov(ni, tx, rd,
+                                         lntmsg->msg_md->md_niov,
+                                         lntmsg->msg_md->md_kiov,
+                                         0, lntmsg->msg_md->md_length);
                if (rc != 0) {
                        CERROR("Can't setup GET sink for %s: %d\n",
                               libcfs_nid2str(target.nid), rc);
@@ -1726,34 +1698,22 @@ kiblnd_send(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg)
                        return -EIO;
                }
 
-                tx->tx_lntmsg[0] = lntmsg;      /* finalise lntmsg[0,1] on completion */
-                tx->tx_waiting = 1;             /* waiting for GET_DONE */
-                kiblnd_launch_tx(ni, tx, target.nid);
-                return 0;
+               /* finalise lntmsg[0,1] on completion */
+               tx->tx_lntmsg[0] = lntmsg;
+               tx->tx_waiting = 1;             /* waiting for GET_DONE */
+               kiblnd_launch_tx(ni, tx, target.nid);
+               return 0;
 
-        case LNET_MSG_REPLY:
-        case LNET_MSG_PUT:
-                /* Is the payload small enough not to need RDMA? */
+       case LNET_MSG_REPLY:
+       case LNET_MSG_PUT:
+               /* Is the payload small enough not to need RDMA? */
                nob = offsetof(struct kib_msg, ibm_u.immediate.ibim_payload[payload_nob]);
-                if (nob <= IBLND_MSG_SIZE)
-                        break;                  /* send IMMEDIATE */
-
-               tx = kiblnd_get_idle_tx(ni, target.nid);
-                if (tx == NULL) {
-                        CERROR("Can't allocate %s txd for %s\n",
-                               type == LNET_MSG_PUT ? "PUT" : "REPLY",
-                               libcfs_nid2str(target.nid));
-                        return -ENOMEM;
-                }
+               if (nob <= IBLND_MSG_SIZE && !lntmsg->msg_rdma_force)
+                       break;                  /* send IMMEDIATE */
 
-                if (payload_kiov == NULL)
-                        rc = kiblnd_setup_rd_iov(ni, tx, tx->tx_rd,
-                                                 payload_niov, payload_iov,
-                                                 payload_offset, payload_nob);
-                else
-                        rc = kiblnd_setup_rd_kiov(ni, tx, tx->tx_rd,
-                                                  payload_niov, payload_kiov,
-                                                  payload_offset, payload_nob);
+               rc = kiblnd_setup_rd_kiov(ni, tx, tx->tx_rd,
+                                         payload_niov, payload_kiov,
+                                         payload_offset, payload_nob);
                if (rc != 0) {
                        CERROR("Can't setup PUT src for %s: %d\n",
                               libcfs_nid2str(target.nid), rc);
@@ -1761,62 +1721,52 @@ kiblnd_send(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg)
                        return -EIO;
                }
 
-                ibmsg = tx->tx_msg;
-                ibmsg->ibm_u.putreq.ibprm_hdr = *hdr;
-                ibmsg->ibm_u.putreq.ibprm_cookie = tx->tx_cookie;
+               ibmsg->ibm_u.putreq.ibprm_hdr = *hdr;
+               ibmsg->ibm_u.putreq.ibprm_cookie = tx->tx_cookie;
                kiblnd_init_tx_msg(ni, tx, IBLND_MSG_PUT_REQ,
                                   sizeof(struct kib_putreq_msg));
 
-                tx->tx_lntmsg[0] = lntmsg;      /* finalise lntmsg on completion */
-                tx->tx_waiting = 1;             /* waiting for PUT_{ACK,NAK} */
-                kiblnd_launch_tx(ni, tx, target.nid);
-                return 0;
-        }
+               /* finalise lntmsg[0,1] on completion */
+               tx->tx_lntmsg[0] = lntmsg;
+               tx->tx_waiting = 1;             /* waiting for PUT_{ACK,NAK} */
+               kiblnd_launch_tx(ni, tx, target.nid);
+               return 0;
+       }
 
        /* send IMMEDIATE */
        LASSERT(offsetof(struct kib_msg, ibm_u.immediate.ibim_payload[payload_nob])
                <= IBLND_MSG_SIZE);
 
-       tx = kiblnd_get_idle_tx(ni, target.nid);
-        if (tx == NULL) {
-                CERROR ("Can't send %d to %s: tx descs exhausted\n",
-                        type, libcfs_nid2str(target.nid));
-                return -ENOMEM;
-        }
-
-        ibmsg = tx->tx_msg;
-        ibmsg->ibm_u.immediate.ibim_hdr = *hdr;
+       ibmsg = tx->tx_msg;
+       ibmsg->ibm_u.immediate.ibim_hdr = *hdr;
 
-        if (payload_kiov != NULL)
-                lnet_copy_kiov2flat(IBLND_MSG_SIZE, ibmsg,
-                                   offsetof(struct kib_msg, ibm_u.immediate.ibim_payload),
-                                    payload_niov, payload_kiov,
-                                    payload_offset, payload_nob);
-        else
-                lnet_copy_iov2flat(IBLND_MSG_SIZE, ibmsg,
-                                  offsetof(struct kib_msg, ibm_u.immediate.ibim_payload),
-                                   payload_niov, payload_iov,
-                                   payload_offset, payload_nob);
+       lnet_copy_kiov2flat(IBLND_MSG_SIZE, ibmsg,
+                           offsetof(struct kib_msg,
+                                    ibm_u.immediate.ibim_payload),
+                           payload_niov, payload_kiov,
+                           payload_offset, payload_nob);
 
        nob = offsetof(struct kib_immediate_msg, ibim_payload[payload_nob]);
-        kiblnd_init_tx_msg(ni, tx, IBLND_MSG_IMMEDIATE, nob);
 
-        tx->tx_lntmsg[0] = lntmsg;              /* finalise lntmsg on completion */
-        kiblnd_launch_tx(ni, tx, target.nid);
-        return 0;
+       kiblnd_init_tx_msg(ni, tx, IBLND_MSG_IMMEDIATE, nob);
+
+       /* finalise lntmsg on completion */
+       tx->tx_lntmsg[0] = lntmsg;
+
+       kiblnd_launch_tx(ni, tx, target.nid);
+       return 0;
 }
 
 static void
 kiblnd_reply(struct lnet_ni *ni, struct kib_rx *rx, struct lnet_msg *lntmsg)
 {
        struct lnet_process_id target = lntmsg->msg_target;
-        unsigned int      niov = lntmsg->msg_niov;
-       struct kvec      *iov = lntmsg->msg_iov;
-        lnet_kiov_t      *kiov = lntmsg->msg_kiov;
-        unsigned int      offset = lntmsg->msg_offset;
-        unsigned int      nob = lntmsg->msg_len;
+       unsigned int niov = lntmsg->msg_niov;
+       struct bio_vec *kiov = lntmsg->msg_kiov;
+       unsigned int offset = lntmsg->msg_offset;
+       unsigned int nob = lntmsg->msg_len;
        struct kib_tx *tx;
-        int               rc;
+       int rc;
 
        tx = kiblnd_get_idle_tx(ni, rx->rx_conn->ibc_peer->ibp_nid);
         if (tx == NULL) {
@@ -1827,9 +1777,6 @@ kiblnd_reply(struct lnet_ni *ni, struct kib_rx *rx, struct lnet_msg *lntmsg)
 
         if (nob == 0)
                 rc = 0;
-        else if (kiov == NULL)
-                rc = kiblnd_setup_rd_iov(ni, tx, tx->tx_rd,
-                                         niov, iov, offset, nob);
         else
                 rc = kiblnd_setup_rd_kiov(ni, tx, tx->tx_rd,
                                           niov, kiov, offset, nob);
@@ -1870,9 +1817,22 @@ failed_0:
        lnet_finalize(lntmsg, -EIO);
 }
 
+unsigned int
+kiblnd_get_dev_prio(struct lnet_ni *ni, unsigned int dev_idx)
+{
+       struct kib_net *net = ni->ni_data;
+       struct device *dev = NULL;
+
+       if (net)
+               dev = net->ibn_dev->ibd_hdev->ibh_ibdev->dma_device;
+
+       return lnet_get_dev_prio(dev, dev_idx);
+
+}
+
 int
 kiblnd_recv(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg,
-           int delayed, unsigned int niov, struct kvec *iov, lnet_kiov_t *kiov,
+           int delayed, unsigned int niov, struct bio_vec *kiov,
            unsigned int offset, unsigned int mlen, unsigned int rlen)
 {
        struct kib_rx *rx = private;
@@ -1886,8 +1846,6 @@ kiblnd_recv(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg,
 
        LASSERT (mlen <= rlen);
        LASSERT (!in_interrupt());
-       /* Either all pages or all vaddrs */
-       LASSERT (!(kiov != NULL && iov != NULL));
 
        switch (rxmsg->ibm_type) {
        default:
@@ -1903,16 +1861,11 @@ kiblnd_recv(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg,
                         break;
                 }
 
-                if (kiov != NULL)
-                        lnet_copy_flat2kiov(niov, kiov, offset,
-                                            IBLND_MSG_SIZE, rxmsg,
-                                           offsetof(struct kib_msg, ibm_u.immediate.ibim_payload),
-                                            mlen);
-                else
-                        lnet_copy_flat2iov(niov, iov, offset,
-                                           IBLND_MSG_SIZE, rxmsg,
-                                          offsetof(struct kib_msg, ibm_u.immediate.ibim_payload),
-                                           mlen);
+               lnet_copy_flat2kiov(niov, kiov, offset,
+                                   IBLND_MSG_SIZE, rxmsg,
+                                   offsetof(struct kib_msg,
+                                            ibm_u.immediate.ibim_payload),
+                                   mlen);
                lnet_finalize(lntmsg, 0);
                break;
 
@@ -1939,12 +1892,8 @@ kiblnd_recv(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg,
 
                txmsg = tx->tx_msg;
                rd = &txmsg->ibm_u.putack.ibpam_rd;
-               if (kiov == NULL)
-                       rc = kiblnd_setup_rd_iov(ni, tx, rd,
-                                                niov, iov, offset, mlen);
-               else
-                       rc = kiblnd_setup_rd_kiov(ni, tx, rd,
-                                                 niov, kiov, offset, mlen);
+               rc = kiblnd_setup_rd_kiov(ni, tx, rd,
+                                         niov, kiov, offset, mlen);
                if (rc != 0) {
                        CERROR("Can't setup PUT sink for %s: %d\n",
                               libcfs_nid2str(conn->ibc_peer->ibp_nid), rc);
@@ -1988,18 +1937,6 @@ kiblnd_recv(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg,
         return rc;
 }
 
-int
-kiblnd_thread_start(int (*fn)(void *arg), void *arg, char *name)
-{
-       struct task_struct *task = kthread_run(fn, arg, name);
-
-       if (IS_ERR(task))
-               return PTR_ERR(task);
-
-       atomic_inc(&kiblnd_data.kib_nthreads);
-       return 0;
-}
-
 static void
 kiblnd_thread_fini (void)
 {
@@ -2132,9 +2069,9 @@ kiblnd_handle_early_rxs(struct kib_conn *conn)
        LASSERT(conn->ibc_state >= IBLND_CONN_ESTABLISHED);
 
        write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
-       while (!list_empty(&conn->ibc_early_rxs)) {
-               rx = list_entry(conn->ibc_early_rxs.next,
-                               struct kib_rx, rx_list);
+       while ((rx = list_first_entry_or_null(&conn->ibc_early_rxs,
+                                             struct kib_rx,
+                                             rx_list)) != NULL) {
                list_del(&rx->rx_list);
                write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags);
 
@@ -2149,15 +2086,12 @@ void
 kiblnd_abort_txs(struct kib_conn *conn, struct list_head *txs)
 {
        LIST_HEAD(zombies);
-       struct list_head        *tmp;
-       struct list_head        *nxt;
+       struct kib_tx *nxt;
        struct kib_tx *tx;
 
        spin_lock(&conn->ibc_lock);
 
-       list_for_each_safe(tmp, nxt, txs) {
-               tx = list_entry(tmp, struct kib_tx, tx_list);
-
+       list_for_each_entry_safe(tx, nxt, txs, tx_list) {
                if (txs == &conn->ibc_active_txs) {
                        LASSERT(!tx->tx_queued);
                        LASSERT(tx->tx_waiting ||
@@ -2194,6 +2128,10 @@ kiblnd_abort_txs(struct kib_conn *conn, struct list_head *txs)
                if (tx->tx_sending == 0) {
                        tx->tx_queued = 0;
                        list_move(&tx->tx_list, &zombies);
+               } else {
+                       /* keep tx until cq destroy */
+                       list_move(&tx->tx_list, &conn->ibc_zombie_txs);
+                       conn->ibc_waits ++;
                }
        }
 
@@ -2208,6 +2146,31 @@ kiblnd_abort_txs(struct kib_conn *conn, struct list_head *txs)
        kiblnd_txlist_done(&zombies, -ECONNABORTED, LNET_MSG_STATUS_OK);
 }
 
+static bool
+kiblnd_tx_may_discard(struct kib_conn *conn)
+{
+       bool rc = false;
+       struct kib_tx *nxt;
+       struct kib_tx *tx;
+
+       spin_lock(&conn->ibc_lock);
+
+       list_for_each_entry_safe(tx, nxt, &conn->ibc_zombie_txs, tx_list) {
+               if (tx->tx_sending > 0 && tx->tx_lntmsg[0] &&
+                   lnet_md_discarded(tx->tx_lntmsg[0]->msg_md)) {
+                       tx->tx_sending --;
+                       if (tx->tx_sending == 0) {
+                               kiblnd_conn_decref(tx->tx_conn);
+                               tx->tx_conn = NULL;
+                               rc = true;
+                       }
+               }
+       }
+
+       spin_unlock(&conn->ibc_lock);
+       return rc;
+}
+
 static void
 kiblnd_finalise_conn(struct kib_conn *conn)
 {
@@ -2238,10 +2201,11 @@ kiblnd_peer_connect_failed(struct kib_peer_ni *peer_ni, int active,
                           int error)
 {
        LIST_HEAD(zombies);
-       unsigned long   flags;
+       unsigned long flags;
+       enum lnet_msg_hstatus hstatus;
 
-       LASSERT (error != 0);
-       LASSERT (!in_interrupt());
+       LASSERT(error != 0);
+       LASSERT(!in_interrupt());
 
        write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
 
@@ -2284,8 +2248,20 @@ kiblnd_peer_connect_failed(struct kib_peer_ni *peer_ni, int active,
        CNETERR("Deleting messages for %s: connection failed\n",
                libcfs_nid2str(peer_ni->ibp_nid));
 
-       kiblnd_txlist_done(&zombies, error,
-                          LNET_MSG_STATUS_LOCAL_DROPPED);
+       switch (error) {
+       case -EHOSTUNREACH:
+       case -ETIMEDOUT:
+               hstatus = LNET_MSG_STATUS_NETWORK_TIMEOUT;
+               break;
+       case -ECONNREFUSED:
+               hstatus = LNET_MSG_STATUS_REMOTE_DROPPED;
+               break;
+       default:
+               hstatus = LNET_MSG_STATUS_LOCAL_DROPPED;
+               break;
+       }
+
+       kiblnd_txlist_done(&zombies, error, hstatus);
 }
 
 static void
@@ -2309,22 +2285,22 @@ kiblnd_connreq_done(struct kib_conn *conn, int status)
                 (conn->ibc_state == IBLND_CONN_PASSIVE_WAIT &&
                  peer_ni->ibp_accepting > 0));
 
-        LIBCFS_FREE(conn->ibc_connvars, sizeof(*conn->ibc_connvars));
-        conn->ibc_connvars = NULL;
+       LIBCFS_FREE(conn->ibc_connvars, sizeof(*conn->ibc_connvars));
+       conn->ibc_connvars = NULL;
 
-        if (status != 0) {
-                /* failed to establish connection */
-                kiblnd_peer_connect_failed(peer_ni, active, status);
-                kiblnd_finalise_conn(conn);
-                return;
-        }
+       if (status != 0) {
+               /* failed to establish connection */
+               kiblnd_peer_connect_failed(peer_ni, active, status);
+               kiblnd_finalise_conn(conn);
+               return;
+       }
 
-        /* connection established */
+       /* connection established */
        write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
 
        conn->ibc_last_send = ktime_get();
-        kiblnd_set_conn_state(conn, IBLND_CONN_ESTABLISHED);
-        kiblnd_peer_alive(peer_ni);
+       kiblnd_set_conn_state(conn, IBLND_CONN_ESTABLISHED);
+       kiblnd_peer_alive(peer_ni);
 
        /* Add conn to peer_ni's list and nuke any dangling conns from a different
         * peer_ni instance... */
@@ -2379,8 +2355,8 @@ kiblnd_connreq_done(struct kib_conn *conn, int status)
         * scheduled.  We won't be using round robin on this first batch.
         */
        spin_lock(&conn->ibc_lock);
-       while (!list_empty(&txs)) {
-               tx = list_entry(txs.next, struct kib_tx, tx_list);
+       while ((tx = list_first_entry_or_null(&txs, struct kib_tx,
+                                             tx_list)) != NULL) {
                list_del(&tx->tx_list);
 
                kiblnd_queue_tx_locked(tx, conn);
@@ -2398,7 +2374,11 @@ kiblnd_reject(struct rdma_cm_id *cmid, struct kib_rej *rej)
 {
         int          rc;
 
+#ifdef HAVE_RDMA_REJECT_4ARGS
+       rc = rdma_reject(cmid, rej, sizeof(*rej), IB_CM_REJ_CONSUMER_DEFINED);
+#else
         rc = rdma_reject(cmid, rej, sizeof(*rej));
+#endif
 
         if (rc != 0)
                 CWARN("Error %d sending reject\n", rc);
@@ -2407,7 +2387,7 @@ kiblnd_reject(struct rdma_cm_id *cmid, struct kib_rej *rej)
 static int
 kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob)
 {
-       rwlock_t                *g_lock = &kiblnd_data.kib_global_lock;
+       rwlock_t *g_lock = &kiblnd_data.kib_global_lock;
        struct kib_msg *reqmsg = priv;
        struct kib_msg *ackmsg;
        struct kib_dev *ibdev;
@@ -2416,27 +2396,27 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob)
        struct kib_conn *conn;
        struct lnet_ni *ni = NULL;
        struct kib_net *net = NULL;
-        lnet_nid_t             nid;
-        struct rdma_conn_param cp;
+       lnet_nid_t nid;
+       struct rdma_conn_param cp;
        struct kib_rej rej;
-       int                    version = IBLND_MSG_VERSION;
-       unsigned long          flags;
-       int                    rc;
-       struct sockaddr_in    *peer_addr;
-       LASSERT (!in_interrupt());
+       int version = IBLND_MSG_VERSION;
+       unsigned long flags;
+       int rc;
+       struct sockaddr_in *peer_addr;
 
+       LASSERT(!in_interrupt());
        /* cmid inherits 'context' from the corresponding listener id */
        ibdev = cmid->context;
        LASSERT(ibdev);
 
-        memset(&rej, 0, sizeof(rej));
-        rej.ibr_magic                = IBLND_MSG_MAGIC;
-        rej.ibr_why                  = IBLND_REJECT_FATAL;
-        rej.ibr_cp.ibcp_max_msg_size = IBLND_MSG_SIZE;
+       memset(&rej, 0, sizeof(rej));
+       rej.ibr_magic                = IBLND_MSG_MAGIC;
+       rej.ibr_why                  = IBLND_REJECT_FATAL;
+       rej.ibr_cp.ibcp_max_msg_size = IBLND_MSG_SIZE;
 
-        peer_addr = (struct sockaddr_in *)&(cmid->route.addr.dst_addr);
-        if (*kiblnd_tunables.kib_require_priv_port &&
-            ntohs(peer_addr->sin_port) >= PROT_SOCK) {
+       peer_addr = (struct sockaddr_in *)&(cmid->route.addr.dst_addr);
+       if (*kiblnd_tunables.kib_require_priv_port &&
+           ntohs(peer_addr->sin_port) >= PROT_SOCK) {
                __u32 ip = ntohl(peer_addr->sin_addr.s_addr);
                CERROR("peer_ni's port (%pI4h:%hu) is not privileged\n",
                       &ip, ntohs(peer_addr->sin_port));
@@ -2480,20 +2460,20 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob)
                rej.ibr_incarnation = net->ibn_incarnation;
        }
 
-       if (ni == NULL ||                         /* no matching net */
-           ni->ni_nid != reqmsg->ibm_dstnid ||   /* right NET, wrong NID! */
-           net->ibn_dev != ibdev) {              /* wrong device */
-               CERROR("Can't accept conn from %s on %s (%s:%d:%pI4h): "
-                      "bad dst nid %s\n", libcfs_nid2str(nid),
-                      ni == NULL ? "NA" : libcfs_nid2str(ni->ni_nid),
+       if (ni == NULL ||                       /* no matching net */
+           lnet_nid_to_nid4(&ni->ni_nid) !=
+           reqmsg->ibm_dstnid ||               /* right NET, wrong NID! */
+           net->ibn_dev != ibdev) {            /* wrong device */
+               CERROR("Can't accept conn from %s on %s (%s:%d:%pI4h): bad dst nid %s\n", libcfs_nid2str(nid),
+                      ni ? libcfs_nidstr(&ni->ni_nid) : "NA",
                       ibdev->ibd_ifname, ibdev->ibd_nnets,
-                       &ibdev->ibd_ifip,
+                      &ibdev->ibd_ifip,
                       libcfs_nid2str(reqmsg->ibm_dstnid));
 
                goto failed;
        }
 
-       /* check time stamp as soon as possible */
+       /* check time stamp as soon as possible */
        if (reqmsg->ibm_dststamp != 0 &&
            reqmsg->ibm_dststamp != net->ibn_incarnation) {
                CWARN("Stale connection request\n");
@@ -2512,8 +2492,7 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob)
 
        if (reqmsg->ibm_u.connparams.ibcp_queue_depth >
            kiblnd_msg_queue_size(version, ni)) {
-               CERROR("Can't accept conn from %s, queue depth too large: "
-                      " %d (<=%d wanted)\n",
+               CERROR("Can't accept conn from %s, queue depth too large:  %d (<=%d wanted)\n",
                       libcfs_nid2str(nid),
                       reqmsg->ibm_u.connparams.ibcp_queue_depth,
                       kiblnd_msg_queue_size(version, ni));
@@ -2526,8 +2505,7 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob)
 
        if (reqmsg->ibm_u.connparams.ibcp_max_frags >
            IBLND_MAX_RDMA_FRAGS) {
-               CWARN("Can't accept conn from %s (version %x): "
-                     "max_frags %d too large (%d wanted)\n",
+               CWARN("Can't accept conn from %s (version %x): max_frags %d too large (%d wanted)\n",
                      libcfs_nid2str(nid), version,
                      reqmsg->ibm_u.connparams.ibcp_max_frags,
                      IBLND_MAX_RDMA_FRAGS);
@@ -2539,9 +2517,7 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob)
        } else if (reqmsg->ibm_u.connparams.ibcp_max_frags <
                   IBLND_MAX_RDMA_FRAGS &&
                   net->ibn_fmr_ps == NULL) {
-               CWARN("Can't accept conn from %s (version %x): "
-                     "max_frags %d incompatible without FMR pool "
-                     "(%d wanted)\n",
+               CWARN("Can't accept conn from %s (version %x): max_frags %d incompatible without FMR pool (%d wanted)\n",
                      libcfs_nid2str(nid), version,
                      reqmsg->ibm_u.connparams.ibcp_max_frags,
                      IBLND_MAX_RDMA_FRAGS);
@@ -2552,13 +2528,13 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob)
                goto failed;
        }
 
-        if (reqmsg->ibm_u.connparams.ibcp_max_msg_size > IBLND_MSG_SIZE) {
-                CERROR("Can't accept %s: message size %d too big (%d max)\n",
-                       libcfs_nid2str(nid),
-                       reqmsg->ibm_u.connparams.ibcp_max_msg_size,
-                       IBLND_MSG_SIZE);
-                goto failed;
-        }
+       if (reqmsg->ibm_u.connparams.ibcp_max_msg_size > IBLND_MSG_SIZE) {
+               CERROR("Can't accept %s: message size %d too big (%d max)\n",
+                      libcfs_nid2str(nid),
+                      reqmsg->ibm_u.connparams.ibcp_max_msg_size,
+                      IBLND_MSG_SIZE);
+               goto failed;
+       }
 
        /* assume 'nid' is a new peer_ni; create  */
        rc = kiblnd_create_peer(ni, &peer_ni, nid);
@@ -2574,16 +2550,16 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob)
 
        write_lock_irqsave(g_lock, flags);
 
-        peer2 = kiblnd_find_peer_locked(ni, nid);
-        if (peer2 != NULL) {
-                if (peer2->ibp_version == 0) {
-                        peer2->ibp_version     = version;
-                        peer2->ibp_incarnation = reqmsg->ibm_srcstamp;
-                }
+       peer2 = kiblnd_find_peer_locked(ni, nid);
+       if (peer2 != NULL) {
+               if (peer2->ibp_version == 0) {
+                       peer2->ibp_version     = version;
+                       peer2->ibp_incarnation = reqmsg->ibm_srcstamp;
+               }
 
-                /* not the guy I've talked with */
-                if (peer2->ibp_incarnation != reqmsg->ibm_srcstamp ||
-                    peer2->ibp_version     != version) {
+               /* not the guy I've talked with */
+               if (peer2->ibp_incarnation != reqmsg->ibm_srcstamp ||
+                   peer2->ibp_version     != version) {
                        kiblnd_close_peer_conns_locked(peer2, -ESTALE);
 
                        if (kiblnd_peer_active(peer2)) {
@@ -2596,10 +2572,10 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob)
                              libcfs_nid2str(nid), peer2->ibp_version, version,
                              peer2->ibp_incarnation, reqmsg->ibm_srcstamp);
 
-                        kiblnd_peer_decref(peer_ni);
-                        rej.ibr_why = IBLND_REJECT_CONN_STALE;
-                        goto failed;
-                }
+                       kiblnd_peer_decref(peer_ni);
+                       rej.ibr_why = IBLND_REJECT_CONN_STALE;
+                       goto failed;
+               }
 
                /* Tie-break connection race in favour of the higher NID.
                 * If we keep running into a race condition multiple times,
@@ -2609,8 +2585,8 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob)
                 * the lower NID connection win so we can move forward.
                 */
                if (peer2->ibp_connecting != 0 &&
-                   nid < ni->ni_nid && peer2->ibp_races <
-                   MAX_CONN_RACES_BEFORE_ABORT) {
+                   nid < lnet_nid_to_nid4(&ni->ni_nid) &&
+                   peer2->ibp_races < MAX_CONN_RACES_BEFORE_ABORT) {
                        peer2->ibp_races++;
                        write_unlock_irqrestore(g_lock, flags);
 
@@ -2641,78 +2617,80 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob)
                peer2->ibp_queue_depth = peer_ni->ibp_queue_depth;
 
                write_unlock_irqrestore(g_lock, flags);
-                kiblnd_peer_decref(peer_ni);
-                peer_ni = peer2;
-        } else {
-                /* Brand new peer_ni */
-                LASSERT (peer_ni->ibp_accepting == 0);
-                LASSERT (peer_ni->ibp_version == 0 &&
-                         peer_ni->ibp_incarnation == 0);
+               kiblnd_peer_decref(peer_ni);
+               peer_ni = peer2;
+       } else {
+               /* Brand new peer_ni */
+               LASSERT(peer_ni->ibp_accepting == 0);
+               LASSERT(peer_ni->ibp_version == 0 &&
+                       peer_ni->ibp_incarnation == 0);
 
-                peer_ni->ibp_accepting   = 1;
-                peer_ni->ibp_version     = version;
-                peer_ni->ibp_incarnation = reqmsg->ibm_srcstamp;
+               peer_ni->ibp_accepting   = 1;
+               peer_ni->ibp_version     = version;
+               peer_ni->ibp_incarnation = reqmsg->ibm_srcstamp;
 
-                /* I have a ref on ni that prevents it being shutdown */
-                LASSERT (net->ibn_shutdown == 0);
+               /* I have a ref on ni that prevents it being shutdown */
+               LASSERT(net->ibn_shutdown == 0);
 
-                kiblnd_peer_addref(peer_ni);
-               list_add_tail(&peer_ni->ibp_list, kiblnd_nid2peerlist(nid));
+               kiblnd_peer_addref(peer_ni);
+               hash_add(kiblnd_data.kib_peers, &peer_ni->ibp_list, nid);
 
                write_unlock_irqrestore(g_lock, flags);
-        }
+       }
 
-       conn = kiblnd_create_conn(peer_ni, cmid, IBLND_CONN_PASSIVE_WAIT, version);
-        if (conn == NULL) {
-                kiblnd_peer_connect_failed(peer_ni, 0, -ENOMEM);
-                kiblnd_peer_decref(peer_ni);
-                rej.ibr_why = IBLND_REJECT_NO_RESOURCES;
-                goto failed;
-        }
+       conn = kiblnd_create_conn(peer_ni, cmid, IBLND_CONN_PASSIVE_WAIT,
+                                 version);
+       if (!conn) {
+               kiblnd_peer_connect_failed(peer_ni, 0, -ENOMEM);
+               kiblnd_peer_decref(peer_ni);
+               rej.ibr_why = IBLND_REJECT_NO_RESOURCES;
+               goto failed;
+       }
 
-        /* conn now "owns" cmid, so I return success from here on to ensure the
-         * CM callback doesn't destroy cmid. */
+       /* conn now "owns" cmid, so I return success from here on to ensure the
+        * CM callback doesn't destroy cmid.
+        */
        conn->ibc_incarnation      = reqmsg->ibm_srcstamp;
        conn->ibc_credits          = conn->ibc_queue_depth;
        conn->ibc_reserved_credits = conn->ibc_queue_depth;
        LASSERT(conn->ibc_credits + conn->ibc_reserved_credits +
                IBLND_OOB_MSGS(version) <= IBLND_RX_MSGS(conn));
 
-        ackmsg = &conn->ibc_connvars->cv_msg;
-        memset(ackmsg, 0, sizeof(*ackmsg));
+       ackmsg = &conn->ibc_connvars->cv_msg;
+       memset(ackmsg, 0, sizeof(*ackmsg));
 
-        kiblnd_init_msg(ackmsg, IBLND_MSG_CONNACK,
-                        sizeof(ackmsg->ibm_u.connparams));
+       kiblnd_init_msg(ackmsg, IBLND_MSG_CONNACK,
+                       sizeof(ackmsg->ibm_u.connparams));
        ackmsg->ibm_u.connparams.ibcp_queue_depth  = conn->ibc_queue_depth;
        ackmsg->ibm_u.connparams.ibcp_max_frags    = conn->ibc_max_frags;
        ackmsg->ibm_u.connparams.ibcp_max_msg_size = IBLND_MSG_SIZE;
 
-        kiblnd_pack_msg(ni, ackmsg, version, 0, nid, reqmsg->ibm_srcstamp);
+       kiblnd_pack_msg(ni, ackmsg, version, 0, nid, reqmsg->ibm_srcstamp);
 
-        memset(&cp, 0, sizeof(cp));
-        cp.private_data        = ackmsg;
-        cp.private_data_len    = ackmsg->ibm_nob;
-        cp.responder_resources = 0;             /* No atomic ops or RDMA reads */
-        cp.initiator_depth     = 0;
-        cp.flow_control        = 1;
-        cp.retry_count         = *kiblnd_tunables.kib_retry_count;
-        cp.rnr_retry_count     = *kiblnd_tunables.kib_rnr_retry_count;
+       memset(&cp, 0, sizeof(cp));
+       cp.private_data        = ackmsg;
+       cp.private_data_len    = ackmsg->ibm_nob;
+       cp.responder_resources = 0;            /* No atomic ops or RDMA reads */
+       cp.initiator_depth     = 0;
+       cp.flow_control        = 1;
+       cp.retry_count         = *kiblnd_tunables.kib_retry_count;
+       cp.rnr_retry_count     = *kiblnd_tunables.kib_rnr_retry_count;
 
-        CDEBUG(D_NET, "Accept %s\n", libcfs_nid2str(nid));
+       CDEBUG(D_NET, "Accept %s\n", libcfs_nid2str(nid));
 
-        rc = rdma_accept(cmid, &cp);
-        if (rc != 0) {
-                CERROR("Can't accept %s: %d\n", libcfs_nid2str(nid), rc);
-                rej.ibr_version = version;
-                rej.ibr_why     = IBLND_REJECT_FATAL;
+       rc = rdma_accept(cmid, &cp);
+       if (rc != 0) {
+               CERROR("Can't accept %s: %d\n", libcfs_nid2str(nid), rc);
+               rej.ibr_version = version;
+               rej.ibr_why     = IBLND_REJECT_FATAL;
 
-                kiblnd_reject(cmid, &rej);
-                kiblnd_connreq_done(conn, rc);
-                kiblnd_conn_decref(conn);
-        }
+               kiblnd_reject(cmid, &rej);
+               kiblnd_connreq_done(conn, rc);
+               kiblnd_conn_decref(conn);
+       }
 
-        lnet_ni_decref(ni);
-        return 0;
+       lnet_ni_decref(ni);
+       return 0;
 
  failed:
        if (ni != NULL) {
@@ -2751,11 +2729,12 @@ kiblnd_check_reconnect(struct kib_conn *conn, int version,
        }
 
        write_lock_irqsave(glock, flags);
-        /* retry connection if it's still needed and no other connection
-         * attempts (active or passive) are in progress
-         * NB: reconnect is still needed even when ibp_tx_queue is
-         * empty if ibp_version != version because reconnect may be
-         * initiated by kiblnd_query() */
+       /* retry connection if it's still needed and no other connection
+        * attempts (active or passive) are in progress
+        * NB: reconnect is still needed even when ibp_tx_queue is
+        * empty if ibp_version != version because reconnect may be
+        * initiated.
+        */
        reconnect = (!list_empty(&peer_ni->ibp_tx_queue) ||
                     peer_ni->ibp_version != version) &&
                    peer_ni->ibp_connecting &&
@@ -2765,29 +2744,17 @@ kiblnd_check_reconnect(struct kib_conn *conn, int version,
                goto out;
        }
 
-        switch (why) {
-        default:
-                reason = "Unknown";
-                break;
+       switch (why) {
+       default:
+               reason = "Unknown";
+               break;
 
        case IBLND_REJECT_RDMA_FRAGS: {
-               struct lnet_ioctl_config_o2iblnd_tunables *tunables;
-
                if (!cp) {
                        reason = "can't negotiate max frags";
                        goto out;
                }
-               tunables = &peer_ni->ibp_ni->ni_lnd_tunables.lnd_tun_u.lnd_o2ib;
-#ifdef HAVE_IB_GET_DMA_MR
-               /*
-                * This check only makes sense if the kernel supports global
-                * memory registration. Otherwise, map_on_demand will never == 0
-                */
-               if (!tunables->lnd_map_on_demand) {
-                       reason = "map_on_demand must be enabled";
-                       goto out;
-               }
-#endif
+
                if (conn->ibc_max_frags <= frag_num) {
                        reason = "unsupported max frags";
                        goto out;
@@ -2822,10 +2789,6 @@ kiblnd_check_reconnect(struct kib_conn *conn, int version,
         case IBLND_REJECT_CONN_UNCOMPAT:
                 reason = "version negotiation";
                 break;
-
-       case IBLND_REJECT_INVALID_SRV_ID:
-               reason = "invalid service id";
-               break;
         }
 
        conn->ibc_reconnect = 1;
@@ -2852,6 +2815,7 @@ static void
 kiblnd_rejected(struct kib_conn *conn, int reason, void *priv, int priv_nob)
 {
        struct kib_peer_ni *peer_ni = conn->ibc_peer;
+       int status = -ECONNREFUSED;
 
        LASSERT (!in_interrupt());
        LASSERT (conn->ibc_state == IBLND_CONN_ACTIVE_CONNECT);
@@ -2862,117 +2826,119 @@ kiblnd_rejected(struct kib_conn *conn, int reason, void *priv, int priv_nob)
                                       IBLND_REJECT_CONN_STALE, NULL);
                break;
 
-        case IB_CM_REJ_INVALID_SERVICE_ID:
-               kiblnd_check_reconnect(conn, IBLND_MSG_VERSION, 0,
-                                      IBLND_REJECT_INVALID_SRV_ID, NULL);
-                CNETERR("%s rejected: no listener at %d\n",
-                        libcfs_nid2str(peer_ni->ibp_nid),
-                        *kiblnd_tunables.kib_service);
-                break;
+       case IB_CM_REJ_INVALID_SERVICE_ID:
+               status = -EHOSTUNREACH;
+               CNETERR("%s rejected: no listener at %d\n",
+                       libcfs_nid2str(peer_ni->ibp_nid),
+                       *kiblnd_tunables.kib_service);
+               break;
 
-        case IB_CM_REJ_CONSUMER_DEFINED:
+       case IB_CM_REJ_CONSUMER_DEFINED:
                if (priv_nob >= offsetof(struct kib_rej, ibr_padding)) {
                        struct kib_rej *rej = priv;
                        struct kib_connparams *cp = NULL;
-                        int               flip        = 0;
-                        __u64             incarnation = -1;
-
-                        /* NB. default incarnation is -1 because:
-                         * a) V1 will ignore dst incarnation in connreq.
-                         * b) V2 will provide incarnation while rejecting me,
-                         *    -1 will be overwrote.
-                         *
-                         * if I try to connect to a V1 peer_ni with V2 protocol,
-                         * it rejected me then upgrade to V2, I have no idea
-                         * about the upgrading and try to reconnect with V1,
-                         * in this case upgraded V2 can find out I'm trying to
-                         * talk to the old guy and reject me(incarnation is -1). 
-                         */
-
-                        if (rej->ibr_magic == __swab32(IBLND_MSG_MAGIC) ||
-                            rej->ibr_magic == __swab32(LNET_PROTO_MAGIC)) {
-                                __swab32s(&rej->ibr_magic);
-                                __swab16s(&rej->ibr_version);
-                                flip = 1;
-                        }
+                       bool flip = false;
+                       __u64 incarnation = -1;
+
+                       /* NB. default incarnation is -1 because:
+                        * a) V1 will ignore dst incarnation in connreq.
+                        * b) V2 will provide incarnation while rejecting me,
+                        *    -1 will be overwrote.
+                        *
+                        * if I try to connect to a V1 peer_ni with V2 protocol,
+                        * it rejected me then upgrade to V2, I have no idea
+                        * about the upgrading and try to reconnect with V1,
+                        * in this case upgraded V2 can find out I'm trying to
+                        * talk to the old guy and reject me(incarnation is -1).
+                        */
+
+                       if (rej->ibr_magic == __swab32(IBLND_MSG_MAGIC) ||
+                           rej->ibr_magic == __swab32(LNET_PROTO_MAGIC)) {
+                               __swab32s(&rej->ibr_magic);
+                               __swab16s(&rej->ibr_version);
+                               flip = true;
+                       }
 
                        if (priv_nob >= sizeof(struct kib_rej) &&
-                            rej->ibr_version > IBLND_MSG_VERSION_1) {
-                                /* priv_nob is always 148 in current version
-                                 * of OFED, so we still need to check version.
-                                 * (define of IB_CM_REJ_PRIVATE_DATA_SIZE) */
-                                cp = &rej->ibr_cp;
-
-                                if (flip) {
-                                        __swab64s(&rej->ibr_incarnation);
-                                        __swab16s(&cp->ibcp_queue_depth);
-                                        __swab16s(&cp->ibcp_max_frags);
-                                        __swab32s(&cp->ibcp_max_msg_size);
-                                }
-
-                                incarnation = rej->ibr_incarnation;
-                        }
-
-                        if (rej->ibr_magic != IBLND_MSG_MAGIC &&
-                            rej->ibr_magic != LNET_PROTO_MAGIC) {
-                                CERROR("%s rejected: consumer defined fatal error\n",
-                                       libcfs_nid2str(peer_ni->ibp_nid));
-                                break;
-                        }
-
-                        if (rej->ibr_version != IBLND_MSG_VERSION &&
-                            rej->ibr_version != IBLND_MSG_VERSION_1) {
-                                CERROR("%s rejected: o2iblnd version %x error\n",
-                                       libcfs_nid2str(peer_ni->ibp_nid),
-                                       rej->ibr_version);
-                                break;
-                        }
-
-                        if (rej->ibr_why     == IBLND_REJECT_FATAL &&
-                            rej->ibr_version == IBLND_MSG_VERSION_1) {
-                                CDEBUG(D_NET, "rejected by old version peer_ni %s: %x\n",
-                                       libcfs_nid2str(peer_ni->ibp_nid), rej->ibr_version);
-
-                                if (conn->ibc_version != IBLND_MSG_VERSION_1)
-                                        rej->ibr_why = IBLND_REJECT_CONN_UNCOMPAT;
-                        }
-
-                        switch (rej->ibr_why) {
-                        case IBLND_REJECT_CONN_RACE:
-                        case IBLND_REJECT_CONN_STALE:
-                        case IBLND_REJECT_CONN_UNCOMPAT:
+                           rej->ibr_version > IBLND_MSG_VERSION_1) {
+                               /* priv_nob is always 148 in current version
+                                * of OFED, so we still need to check version.
+                                * (define of IB_CM_REJ_PRIVATE_DATA_SIZE)
+                                */
+                               cp = &rej->ibr_cp;
+
+                               if (flip) {
+                                       __swab64s(&rej->ibr_incarnation);
+                                       __swab16s(&cp->ibcp_queue_depth);
+                                       __swab16s(&cp->ibcp_max_frags);
+                                       __swab32s(&cp->ibcp_max_msg_size);
+                               }
+
+                               incarnation = rej->ibr_incarnation;
+                       }
+
+                       if (rej->ibr_magic != IBLND_MSG_MAGIC &&
+                           rej->ibr_magic != LNET_PROTO_MAGIC) {
+                               CERROR("%s rejected: consumer defined fatal error\n",
+                                      libcfs_nid2str(peer_ni->ibp_nid));
+                               break;
+                       }
+
+                       if (rej->ibr_version != IBLND_MSG_VERSION &&
+                           rej->ibr_version != IBLND_MSG_VERSION_1) {
+                               CERROR("%s rejected: o2iblnd version %x error\n",
+                                      libcfs_nid2str(peer_ni->ibp_nid),
+                                      rej->ibr_version);
+                               break;
+                       }
+
+                       if (rej->ibr_why     == IBLND_REJECT_FATAL &&
+                           rej->ibr_version == IBLND_MSG_VERSION_1) {
+                               CDEBUG(D_NET, "rejected by old version peer_ni %s: %x\n",
+                                      libcfs_nid2str(peer_ni->ibp_nid),
+                                      rej->ibr_version);
+
+                               if (conn->ibc_version != IBLND_MSG_VERSION_1)
+                                       rej->ibr_why = IBLND_REJECT_CONN_UNCOMPAT;
+                       }
+
+                       switch (rej->ibr_why) {
+                       case IBLND_REJECT_CONN_RACE:
+                       case IBLND_REJECT_CONN_STALE:
+                       case IBLND_REJECT_CONN_UNCOMPAT:
                        case IBLND_REJECT_MSG_QUEUE_SIZE:
                        case IBLND_REJECT_RDMA_FRAGS:
                                kiblnd_check_reconnect(conn, rej->ibr_version,
-                                               incarnation, rej->ibr_why, cp);
-                                break;
-
-                        case IBLND_REJECT_NO_RESOURCES:
-                                CERROR("%s rejected: o2iblnd no resources\n",
-                                       libcfs_nid2str(peer_ni->ibp_nid));
-                                break;
-
-                        case IBLND_REJECT_FATAL:
-                                CERROR("%s rejected: o2iblnd fatal error\n",
-                                       libcfs_nid2str(peer_ni->ibp_nid));
-                                break;
-
-                        default:
-                                CERROR("%s rejected: o2iblnd reason %d\n",
-                                       libcfs_nid2str(peer_ni->ibp_nid),
-                                       rej->ibr_why);
-                                break;
-                        }
-                        break;
-                }
-                /* fall through */
-        default:
-                CNETERR("%s rejected: reason %d, size %d\n",
-                        libcfs_nid2str(peer_ni->ibp_nid), reason, priv_nob);
-                break;
-        }
+                                                      incarnation,
+                                                      rej->ibr_why, cp);
+                               break;
+
+                       case IBLND_REJECT_NO_RESOURCES:
+                               CERROR("%s rejected: o2iblnd no resources\n",
+                                      libcfs_nid2str(peer_ni->ibp_nid));
+                               break;
+
+                       case IBLND_REJECT_FATAL:
+                               CERROR("%s rejected: o2iblnd fatal error\n",
+                                      libcfs_nid2str(peer_ni->ibp_nid));
+                               break;
+
+                       default:
+                               CERROR("%s rejected: o2iblnd reason %d\n",
+                                      libcfs_nid2str(peer_ni->ibp_nid),
+                                      rej->ibr_why);
+                               break;
+                       }
+                       break;
+               }
+               /* fall through */
+       default:
+               CNETERR("%s rejected: reason %d, size %d\n",
+                       libcfs_nid2str(peer_ni->ibp_nid), reason, priv_nob);
+               break;
+       }
 
-        kiblnd_connreq_done(conn, -ECONNREFUSED);
+       kiblnd_connreq_done(conn, status);
 }
 
 static void
@@ -3039,7 +3005,7 @@ kiblnd_check_connreply(struct kib_conn *conn, void *priv, int priv_nob)
         }
 
        read_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
-       if (msg->ibm_dstnid == ni->ni_nid &&
+       if (msg->ibm_dstnid == lnet_nid_to_nid4(&ni->ni_nid) &&
            msg->ibm_dststamp == net->ibn_incarnation)
                rc = 0;
        else
@@ -3130,8 +3096,7 @@ kiblnd_active_connect(struct rdma_cm_id *cmid)
 
         LASSERT(cmid->context == (void *)conn);
         LASSERT(conn->ibc_cmid == cmid);
-
-        rc = rdma_connect(cmid, &cp);
+       rc = rdma_connect_locked(cmid, &cp);
         if (rc != 0) {
                 CERROR("Can't connect to %s: %d\n",
                        libcfs_nid2str(peer_ni->ibp_nid), rc);
@@ -3183,7 +3148,7 @@ kiblnd_cm_callback(struct rdma_cm_id *cmid, struct rdma_cm_event *event)
                         rc = event->status;
                } else {
                        rc = rdma_resolve_route(
-                               cmid, lnet_get_lnd_timeout() * 1000);
+                               cmid, kiblnd_timeout() * 1000);
                        if (rc == 0) {
                                struct kib_net *net = peer_ni->ibp_ni->ni_data;
                                struct kib_dev *dev = net->ibn_dev;
@@ -3327,11 +3292,8 @@ static int
 kiblnd_check_txs_locked(struct kib_conn *conn, struct list_head *txs)
 {
        struct kib_tx *tx;
-       struct list_head *ttmp;
-
-       list_for_each(ttmp, txs) {
-               tx = list_entry(ttmp, struct kib_tx, tx_list);
 
+       list_for_each_entry(tx, txs, tx_list) {
                if (txs != &conn->ibc_active_txs) {
                        LASSERT(tx->tx_queued);
                } else {
@@ -3340,8 +3302,10 @@ kiblnd_check_txs_locked(struct kib_conn *conn, struct list_head *txs)
                }
 
                if (ktime_compare(ktime_get(), tx->tx_deadline) >= 0) {
-                       CERROR("Timed out tx: %s, %lld seconds\n",
+                       CERROR("Timed out tx: %s(WSQ:%d%d%d), %lld seconds\n",
                               kiblnd_queue2str(conn, txs),
+                              tx->tx_waiting, tx->tx_sending, tx->tx_queued,
+                              kiblnd_timeout() +
                               ktime_ms_delta(ktime_get(),
                                              tx->tx_deadline) / MSEC_PER_SEC);
                        return 1;
@@ -3367,22 +3331,19 @@ kiblnd_check_conns (int idx)
        LIST_HEAD(closes);
        LIST_HEAD(checksends);
        LIST_HEAD(timedout_txs);
-       struct list_head *peers = &kiblnd_data.kib_peers[idx];
-       struct list_head *ptmp;
+       struct hlist_head *peers = &kiblnd_data.kib_peers[idx];
        struct kib_peer_ni *peer_ni;
-       struct kib_conn *conn;
+       struct kib_conn *conn;
        struct kib_tx *tx, *tx_tmp;
-       struct list_head *ctmp;
-       unsigned long     flags;
+       unsigned long flags;
 
        /* NB. We expect to have a look at all the peers and not find any
         * RDMAs to time out, so we just use a shared lock while we
-        * take a look... */
+        * take a look...
+        */
        write_lock_irqsave(&kiblnd_data.kib_global_lock, flags);
 
-       list_for_each(ptmp, peers) {
-               peer_ni = list_entry(ptmp, struct kib_peer_ni, ibp_list);
-
+       hlist_for_each_entry(peer_ni, peers, ibp_list) {
                /* Check tx_deadline */
                list_for_each_entry_safe(tx, tx_tmp, &peer_ni->ibp_tx_queue, tx_list) {
                        if (ktime_compare(ktime_get(), tx->tx_deadline) >= 0) {
@@ -3394,12 +3355,10 @@ kiblnd_check_conns (int idx)
                        }
                }
 
-               list_for_each(ctmp, &peer_ni->ibp_conns) {
+               list_for_each_entry(conn, &peer_ni->ibp_conns, ibc_list) {
                        int timedout;
                        int sendnoop;
 
-                       conn = list_entry(ctmp, struct kib_conn, ibc_list);
-
                        LASSERT(conn->ibc_state == IBLND_CONN_ESTABLISHED);
 
                        spin_lock(&conn->ibc_lock);
@@ -3412,10 +3371,10 @@ kiblnd_check_conns (int idx)
                        }
 
                        if (timedout) {
-                               CERROR("Timed out RDMA with %s (%lld): "
-                                      "c: %u, oc: %u, rc: %u\n",
+                               CERROR("Timed out RDMA with %s (%lld): c: %u, oc: %u, rc: %u\n",
                                       libcfs_nid2str(peer_ni->ibp_nid),
-                                      ktime_get_seconds() - peer_ni->ibp_last_alive,
+                                      ktime_get_seconds()
+                                      - peer_ni->ibp_last_alive,
                                       conn->ibc_credits,
                                       conn->ibc_outstanding_credits,
                                       conn->ibc_reserved_credits);
@@ -3434,14 +3393,15 @@ kiblnd_check_conns (int idx)
 
        if (!list_empty(&timedout_txs))
                kiblnd_txlist_done(&timedout_txs, -ETIMEDOUT,
-                                  LNET_MSG_STATUS_LOCAL_TIMEOUT);
+                                  LNET_MSG_STATUS_NETWORK_TIMEOUT);
 
        /* Handle timeout by closing the whole
         * connection. We can only be sure RDMA activity
-        * has ceased once the QP has been modified. */
-       while (!list_empty(&closes)) {
-               conn = list_entry(closes.next,
-                                 struct kib_conn, ibc_connd_list);
+        * has ceased once the QP has been modified.
+        */
+       while ((conn = list_first_entry_or_null(&closes,
+                                               struct kib_conn,
+                                               ibc_connd_list)) != NULL) {
                list_del(&conn->ibc_connd_list);
                kiblnd_close_conn(conn, -ETIMEDOUT);
                kiblnd_conn_decref(conn);
@@ -3449,10 +3409,11 @@ kiblnd_check_conns (int idx)
 
        /* In case we have enough credits to return via a
         * NOOP, but there were no non-blocking tx descs
-        * free to do it last time... */
-       while (!list_empty(&checksends)) {
-               conn = list_entry(checksends.next,
-                                 struct kib_conn, ibc_connd_list);
+        * free to do it last time...
+        */
+       while ((conn = list_first_entry_or_null(&checksends,
+                                               struct kib_conn,
+                                               ibc_connd_list)) != NULL) {
                list_del(&conn->ibc_connd_list);
 
                spin_lock(&conn->ibc_lock);
@@ -3490,19 +3451,17 @@ kiblnd_disconnect_conn(struct kib_conn *conn)
 int
 kiblnd_connd (void *arg)
 {
-       spinlock_t        *lock= &kiblnd_data.kib_connd_lock;
+       spinlock_t *lock = &kiblnd_data.kib_connd_lock;
        wait_queue_entry_t wait;
-       unsigned long      flags;
+       unsigned long flags;
        struct kib_conn *conn;
-       int                timeout;
-       int                i;
-       int                dropped_lock;
-       int                peer_index = 0;
-       unsigned long      deadline = jiffies;
-
-       cfs_block_allsigs();
+       int timeout;
+       int i;
+       bool dropped_lock;
+       int peer_index = 0;
+       unsigned long deadline = jiffies;
 
-       init_waitqueue_entry(&wait, current);
+       init_wait(&wait);
        kiblnd_data.kib_connd = current;
 
        spin_lock_irqsave(lock, flags);
@@ -3510,13 +3469,13 @@ kiblnd_connd (void *arg)
        while (!kiblnd_data.kib_shutdown) {
                int reconn = 0;
 
-                dropped_lock = 0;
+               dropped_lock = false;
 
-               if (!list_empty(&kiblnd_data.kib_connd_zombies)) {
+               conn = list_first_entry_or_null(&kiblnd_data.kib_connd_zombies,
+                                               struct kib_conn, ibc_list);
+               if (conn) {
                        struct kib_peer_ni *peer_ni = NULL;
 
-                       conn = list_entry(kiblnd_data.kib_connd_zombies.next,
-                                         struct kib_conn, ibc_list);
                        list_del(&conn->ibc_list);
                        if (conn->ibc_reconnect) {
                                peer_ni = conn->ibc_peer;
@@ -3524,7 +3483,7 @@ kiblnd_connd (void *arg)
                        }
 
                        spin_unlock_irqrestore(lock, flags);
-                       dropped_lock = 1;
+                       dropped_lock = true;
 
                        kiblnd_destroy_conn(conn);
 
@@ -3543,19 +3502,27 @@ kiblnd_connd (void *arg)
                                              &kiblnd_data.kib_reconn_wait);
                }
 
-               if (!list_empty(&kiblnd_data.kib_connd_conns)) {
-                       conn = list_entry(kiblnd_data.kib_connd_conns.next,
-                                         struct kib_conn, ibc_list);
+               conn = list_first_entry_or_null(&kiblnd_data.kib_connd_conns,
+                                               struct kib_conn, ibc_list);
+               if (conn) {
+                       int wait;
+
                        list_del(&conn->ibc_list);
 
                        spin_unlock_irqrestore(lock, flags);
-                       dropped_lock = 1;
+                       dropped_lock = true;
 
                        kiblnd_disconnect_conn(conn);
-                       kiblnd_conn_decref(conn);
+                       wait = conn->ibc_waits;
+                       if (wait == 0) /* keep ref for connd_wait, see below */
+                               kiblnd_conn_decref(conn);
 
                        spin_lock_irqsave(lock, flags);
-                }
+
+                       if (wait)
+                               list_add_tail(&conn->ibc_list,
+                                             &kiblnd_data.kib_connd_waits);
+               }
 
                while (reconn < KIB_RECONN_BREAK) {
                        if (kiblnd_data.kib_reconn_sec !=
@@ -3565,15 +3532,15 @@ kiblnd_connd (void *arg)
                                                 &kiblnd_data.kib_reconn_list);
                        }
 
-                       if (list_empty(&kiblnd_data.kib_reconn_list))
+                       conn = list_first_entry_or_null(&kiblnd_data.kib_reconn_list,
+                                                       struct kib_conn, ibc_list);
+                       if (!conn)
                                break;
 
-                       conn = list_entry(kiblnd_data.kib_reconn_list.next,
-                                         struct kib_conn, ibc_list);
                        list_del(&conn->ibc_list);
 
                        spin_unlock_irqrestore(lock, flags);
-                       dropped_lock = 1;
+                       dropped_lock = true;
 
                        reconn += kiblnd_reconnect_peer(conn->ibc_peer);
                        kiblnd_peer_decref(conn->ibc_peer);
@@ -3582,26 +3549,43 @@ kiblnd_connd (void *arg)
                        spin_lock_irqsave(lock, flags);
                }
 
-                /* careful with the jiffy wrap... */
-                timeout = (int)(deadline - jiffies);
-                if (timeout <= 0) {
-                        const int n = 4;
-                        const int p = 1;
-                        int       chunk = kiblnd_data.kib_peer_hash_size;
-                       unsigned int lnd_timeout;
-
+               conn = list_first_entry_or_null(&kiblnd_data.kib_connd_waits,
+                                               struct kib_conn, ibc_list);
+               if (conn) {
+                       list_del(&conn->ibc_list);
                        spin_unlock_irqrestore(lock, flags);
-                        dropped_lock = 1;
 
-                        /* Time to check for RDMA timeouts on a few more
-                         * peers: I do checks every 'p' seconds on a
-                         * proportion of the peer_ni table and I need to check
-                         * every connection 'n' times within a timeout
-                         * interval, to ensure I detect a timeout on any
-                         * connection within (n+1)/n times the timeout
-                         * interval. */
+                       dropped_lock = kiblnd_tx_may_discard(conn);
+                       if (dropped_lock)
+                               kiblnd_conn_decref(conn);
+
+                       spin_lock_irqsave(lock, flags);
+                       if (!dropped_lock)
+                               list_add_tail(&conn->ibc_list,
+                                             &kiblnd_data.kib_connd_waits);
+               }
+
+               /* careful with the jiffy wrap... */
+               timeout = (int)(deadline - jiffies);
+               if (timeout <= 0) {
+                       const int n = 4;
+                       const int p = 1;
+                       int chunk = HASH_SIZE(kiblnd_data.kib_peers);
+                       unsigned int lnd_timeout;
 
-                       lnd_timeout = lnet_get_lnd_timeout();
+                       spin_unlock_irqrestore(lock, flags);
+                       dropped_lock = true;
+
+                       /* Time to check for RDMA timeouts on a few more
+                        * peers: I do checks every 'p' seconds on a
+                        * proportion of the peer_ni table and I need to check
+                        * every connection 'n' times within a timeout
+                        * interval, to ensure I detect a timeout on any
+                        * connection within (n+1)/n times the timeout
+                        * interval.
+                        */
+
+                       lnd_timeout = kiblnd_timeout();
                        if (lnd_timeout > n * p)
                                chunk = (chunk * n * p) / lnd_timeout;
                        if (chunk == 0)
@@ -3610,7 +3594,7 @@ kiblnd_connd (void *arg)
                        for (i = 0; i < chunk; i++) {
                                kiblnd_check_conns(peer_index);
                                peer_index = (peer_index + 1) %
-                                            kiblnd_data.kib_peer_hash_size;
+                                       HASH_SIZE(kiblnd_data.kib_peers);
                        }
 
                        deadline += cfs_time_seconds(p);
@@ -3627,7 +3611,6 @@ kiblnd_connd (void *arg)
 
                schedule_timeout(timeout);
 
-               set_current_state(TASK_RUNNING);
                remove_wait_queue(&kiblnd_data.kib_connd_waitq, &wait);
                spin_lock_irqsave(lock, flags);
        }
@@ -3656,13 +3639,13 @@ kiblnd_qp_event(struct ib_event *event, void *arg)
        case IB_EVENT_PORT_ERR:
        case IB_EVENT_DEVICE_FATAL:
                CERROR("Fatal device error for NI %s\n",
-                      libcfs_nid2str(conn->ibc_peer->ibp_ni->ni_nid));
+                      libcfs_nidstr(&conn->ibc_peer->ibp_ni->ni_nid));
                atomic_set(&conn->ibc_peer->ibp_ni->ni_fatal_error_on, 1);
                return;
 
        case IB_EVENT_PORT_ACTIVE:
                CERROR("Port reactivated for NI %s\n",
-                      libcfs_nid2str(conn->ibc_peer->ibp_ni->ni_nid));
+                      libcfs_nidstr(&conn->ibc_peer->ibp_ni->ni_nid));
                atomic_set(&conn->ibc_peer->ibp_ni->ni_fatal_error_on, 0);
                return;
 
@@ -3752,47 +3735,41 @@ kiblnd_cq_event(struct ib_event *event, void *arg)
 int
 kiblnd_scheduler(void *arg)
 {
-       long                    id = (long)arg;
-       struct kib_sched_info   *sched;
+       long id = (long)arg;
+       struct kib_sched_info *sched;
        struct kib_conn *conn;
-       wait_queue_entry_t      wait;
-       unsigned long           flags;
-       struct ib_wc            wc;
-       int                     did_something;
-       int                     busy_loops = 0;
-       int                     rc;
-
-       cfs_block_allsigs();
+       wait_queue_entry_t wait;
+       unsigned long flags;
+       struct ib_wc wc;
+       bool did_something;
+       int rc;
 
-       init_waitqueue_entry(&wait, current);
+       init_wait(&wait);
 
        sched = kiblnd_data.kib_scheds[KIB_THREAD_CPT(id)];
 
        rc = cfs_cpt_bind(lnet_cpt_table(), sched->ibs_cpt);
        if (rc != 0) {
-               CWARN("Unable to bind on CPU partition %d, please verify "
-                     "whether all CPUs are healthy and reload modules if "
-                     "necessary, otherwise your system might under risk of "
-                     "low performance\n", sched->ibs_cpt);
+               CWARN("Unable to bind on CPU partition %d, please verify whether all CPUs are healthy and reload modules if necessary, otherwise your system might under risk of low performance\n", sched->ibs_cpt);
        }
 
        spin_lock_irqsave(&sched->ibs_lock, flags);
 
        while (!kiblnd_data.kib_shutdown) {
-               if (busy_loops++ >= IBLND_RESCHED) {
+               if (need_resched()) {
                        spin_unlock_irqrestore(&sched->ibs_lock, flags);
 
                        cond_resched();
-                       busy_loops = 0;
 
                        spin_lock_irqsave(&sched->ibs_lock, flags);
                }
 
-               did_something = 0;
+               did_something = false;
 
-               if (!list_empty(&sched->ibs_conns)) {
-                       conn = list_entry(sched->ibs_conns.next,
-                                         struct kib_conn, ibc_sched_list);
+               conn = list_first_entry_or_null(&sched->ibs_conns,
+                                               struct kib_conn,
+                                               ibc_sched_list);
+               if (conn) {
                        /* take over kib_sched_conns' ref on conn... */
                        LASSERT(conn->ibc_scheduled);
                        list_del(&conn->ibc_sched_list);
@@ -3802,18 +3779,17 @@ kiblnd_scheduler(void *arg)
 
                        wc.wr_id = IBLND_WID_INVAL;
 
-                        rc = ib_poll_cq(conn->ibc_cq, 1, &wc);
-                        if (rc == 0) {
-                                rc = ib_req_notify_cq(conn->ibc_cq,
-                                                      IB_CQ_NEXT_COMP);
-                                if (rc < 0) {
-                                        CWARN("%s: ib_req_notify_cq failed: %d, "
-                                              "closing connection\n",
-                                              libcfs_nid2str(conn->ibc_peer->ibp_nid), rc);
-                                        kiblnd_close_conn(conn, -EIO);
-                                        kiblnd_conn_decref(conn);
+                       rc = ib_poll_cq(conn->ibc_cq, 1, &wc);
+                       if (rc == 0) {
+                               rc = ib_req_notify_cq(conn->ibc_cq,
+                                                     IB_CQ_NEXT_COMP);
+                               if (rc < 0) {
+                                       CWARN("%s: ib_req_notify_cq failed: %d, closing connection\n",
+                                             libcfs_nid2str(conn->ibc_peer->ibp_nid), rc);
+                                       kiblnd_close_conn(conn, -EIO);
+                                       kiblnd_conn_decref(conn);
                                        spin_lock_irqsave(&sched->ibs_lock,
-                                                             flags);
+                                                         flags);
                                        continue;
                                }
 
@@ -3834,8 +3810,7 @@ kiblnd_scheduler(void *arg)
                        }
 
                        if (rc < 0) {
-                               CWARN("%s: ib_poll_cq failed: %d, "
-                                     "closing connection\n",
+                               CWARN("%s: ib_poll_cq failed: %d, closing connection\n",
                                      libcfs_nid2str(conn->ibc_peer->ibp_nid),
                                      rc);
                                kiblnd_close_conn(conn, -EIO);
@@ -3853,7 +3828,7 @@ kiblnd_scheduler(void *arg)
                                /* +1 ref for sched_conns */
                                kiblnd_conn_addref(conn);
                                list_add_tail(&conn->ibc_sched_list,
-                                                 &sched->ibs_conns);
+                                             &sched->ibs_conns);
                                if (waitqueue_active(&sched->ibs_waitq))
                                        wake_up(&sched->ibs_waitq);
                        } else {
@@ -3865,21 +3840,20 @@ kiblnd_scheduler(void *arg)
                                kiblnd_complete(&wc);
 
                                spin_lock_irqsave(&sched->ibs_lock, flags);
-                        }
+                       }
 
-                        kiblnd_conn_decref(conn); /* ...drop my ref from above */
-                        did_something = 1;
-                }
+                       kiblnd_conn_decref(conn); /* ..drop my ref from above */
+                       did_something = true;
+               }
 
-                if (did_something)
-                        continue;
+               if (did_something)
+                       continue;
 
                set_current_state(TASK_INTERRUPTIBLE);
                add_wait_queue_exclusive(&sched->ibs_waitq, &wait);
                spin_unlock_irqrestore(&sched->ibs_lock, flags);
 
                schedule();
-               busy_loops = 0;
 
                remove_wait_queue(&sched->ibs_waitq, &wait);
                set_current_state(TASK_RUNNING);
@@ -3895,60 +3869,58 @@ kiblnd_scheduler(void *arg)
 int
 kiblnd_failover_thread(void *arg)
 {
-       rwlock_t        *glock = &kiblnd_data.kib_global_lock;
+       rwlock_t *glock = &kiblnd_data.kib_global_lock;
        struct kib_dev *dev;
        struct net *ns = arg;
        wait_queue_entry_t wait;
-       unsigned long    flags;
-       int              rc;
+       unsigned long flags;
+       int rc;
 
        LASSERT(*kiblnd_tunables.kib_dev_failover != 0);
 
-       cfs_block_allsigs();
-
-       init_waitqueue_entry(&wait, current);
+       init_wait(&wait);
        write_lock_irqsave(glock, flags);
 
-        while (!kiblnd_data.kib_shutdown) {
-                int     do_failover = 0;
-                int     long_sleep;
+       while (!kiblnd_data.kib_shutdown) {
+               bool do_failover = false;
+               int long_sleep;
 
                list_for_each_entry(dev, &kiblnd_data.kib_failed_devs,
-                                    ibd_fail_list) {
+                                   ibd_fail_list) {
                        if (ktime_get_seconds() < dev->ibd_next_failover)
-                                continue;
-                        do_failover = 1;
-                        break;
-                }
+                               continue;
+                       do_failover = true;
+                       break;
+               }
 
-                if (do_failover) {
+               if (do_failover) {
                        list_del_init(&dev->ibd_fail_list);
-                        dev->ibd_failover = 1;
+                       dev->ibd_failover = 1;
                        write_unlock_irqrestore(glock, flags);
 
                        rc = kiblnd_dev_failover(dev, ns);
 
                        write_lock_irqsave(glock, flags);
 
-                        LASSERT (dev->ibd_failover);
-                        dev->ibd_failover = 0;
-                        if (rc >= 0) { /* Device is OK or failover succeed */
+                       LASSERT(dev->ibd_failover);
+                       dev->ibd_failover = 0;
+                       if (rc >= 0) { /* Device is OK or failover succeed */
                                dev->ibd_next_failover = ktime_get_seconds() + 3;
-                                continue;
-                        }
+                               continue;
+                       }
 
-                        /* failed to failover, retry later */
+                       /* failed to failover, retry later */
                        dev->ibd_next_failover = ktime_get_seconds() +
-                                                min(dev->ibd_failed_failover, 10);
-                        if (kiblnd_dev_can_failover(dev)) {
+                               min(dev->ibd_failed_failover, 10);
+                       if (kiblnd_dev_can_failover(dev)) {
                                list_add_tail(&dev->ibd_fail_list,
-                                              &kiblnd_data.kib_failed_devs);
-                        }
+                                             &kiblnd_data.kib_failed_devs);
+                       }
 
-                        continue;
-                }
+                       continue;
+               }
 
-                /* long sleep if no more pending failover */
+               /* long sleep if no more pending failover */
                long_sleep = list_empty(&kiblnd_data.kib_failed_devs);
 
                set_current_state(TASK_INTERRUPTIBLE);
@@ -3956,28 +3928,29 @@ kiblnd_failover_thread(void *arg)
                write_unlock_irqrestore(glock, flags);
 
                rc = schedule_timeout(long_sleep ? cfs_time_seconds(10) :
-                                                  cfs_time_seconds(1));
+                                     cfs_time_seconds(1));
                set_current_state(TASK_RUNNING);
                remove_wait_queue(&kiblnd_data.kib_failover_waitq, &wait);
                write_lock_irqsave(glock, flags);
 
-                if (!long_sleep || rc != 0)
-                        continue;
+               if (!long_sleep || rc != 0)
+                       continue;
 
-                /* have a long sleep, routine check all active devices,
-                 * we need checking like this because if there is not active
-                 * connection on the dev and no SEND from local, we may listen
-                 * on wrong HCA for ever while there is a bonding failover */
+               /* have a long sleep, routine check all active devices,
+                * we need checking like this because if there is not active
+                * connection on the dev and no SEND from local, we may listen
+                * on wrong HCA for ever while there is a bonding failover
+                */
                list_for_each_entry(dev, &kiblnd_data.kib_devs, ibd_list) {
-                        if (kiblnd_dev_can_failover(dev)) {
+                       if (kiblnd_dev_can_failover(dev)) {
                                list_add_tail(&dev->ibd_fail_list,
-                                              &kiblnd_data.kib_failed_devs);
-                        }
-                }
-        }
+                                             &kiblnd_data.kib_failed_devs);
+                       }
+               }
+       }
 
        write_unlock_irqrestore(glock, flags);
 
-        kiblnd_thread_fini();
-        return 0;
+       kiblnd_thread_fini();
+       return 0;
 }