X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lnet%2Fklnds%2Fo2iblnd%2Fo2iblnd_cb.c;h=c52ff41c8d021032c05a8998e618ca79f60edd30;hb=07bd49670282fcd75f1a937b621aa3c11db88407;hp=e4f2d331fffbabb84497cb834e73dc034207bffc;hpb=580c1e0017296ea7a25f6f5f8aa8022f713ae762;p=fs%2Flustre-release.git diff --git a/lnet/klnds/o2iblnd/o2iblnd_cb.c b/lnet/klnds/o2iblnd/o2iblnd_cb.c index e4f2d33..c52ff41 100644 --- a/lnet/klnds/o2iblnd/o2iblnd_cb.c +++ b/lnet/klnds/o2iblnd/o2iblnd_cb.c @@ -40,7 +40,17 @@ #include "o2iblnd.h" -void +static void kiblnd_peer_alive(kib_peer_t *peer); +static void kiblnd_peer_connect_failed(kib_peer_t *peer, int active, int error); +static void kiblnd_check_sends(kib_conn_t *conn); +static void kiblnd_init_tx_msg(lnet_ni_t *ni, kib_tx_t *tx, + int type, int body_nob); +static int kiblnd_init_rdma(kib_conn_t *conn, kib_tx_t *tx, int type, + int resid, kib_rdma_desc_t *dstrd, __u64 dstcookie); +static void kiblnd_queue_tx_locked(kib_tx_t *tx, kib_conn_t *conn); +static void kiblnd_queue_tx(kib_tx_t *tx, kib_conn_t *conn); + +static void kiblnd_tx_done (lnet_ni_t *ni, kib_tx_t *tx) { lnet_msg_t *lntmsg[2]; @@ -84,26 +94,26 @@ kiblnd_tx_done (lnet_ni_t *ni, kib_tx_t *tx) } void -kiblnd_txlist_done (lnet_ni_t *ni, cfs_list_t *txlist, int status) +kiblnd_txlist_done(lnet_ni_t *ni, struct list_head *txlist, int status) { - kib_tx_t *tx; + kib_tx_t *tx; - while (!cfs_list_empty (txlist)) { - tx = cfs_list_entry (txlist->next, kib_tx_t, tx_list); + while (!list_empty(txlist)) { + tx = list_entry(txlist->next, kib_tx_t, tx_list); - cfs_list_del(&tx->tx_list); - /* complete now */ - tx->tx_waiting = 0; - tx->tx_status = status; - kiblnd_tx_done(ni, tx); - } + list_del(&tx->tx_list); + /* complete now */ + tx->tx_waiting = 0; + tx->tx_status = status; + kiblnd_tx_done(ni, tx); + } } -kib_tx_t * +static kib_tx_t * kiblnd_get_idle_tx(lnet_ni_t *ni, lnet_nid_t target) { kib_net_t *net = (kib_net_t *)ni->ni_data; - cfs_list_t *node; + struct list_head *node; kib_tx_t *tx; kib_tx_poolset_t *tps; @@ -127,7 +137,7 @@ kiblnd_get_idle_tx(lnet_ni_t *ni, lnet_nid_t target) return tx; } -void +static void kiblnd_drop_rx(kib_rx_t *rx) { kib_conn_t *conn = rx->rx_conn; @@ -209,32 +219,32 @@ kiblnd_post_rx (kib_rx_t *rx, int credit) return 0; } -kib_tx_t * +static kib_tx_t * kiblnd_find_waiting_tx_locked(kib_conn_t *conn, int txtype, __u64 cookie) { - cfs_list_t *tmp; + struct list_head *tmp; - cfs_list_for_each(tmp, &conn->ibc_active_txs) { - kib_tx_t *tx = cfs_list_entry(tmp, kib_tx_t, tx_list); + list_for_each(tmp, &conn->ibc_active_txs) { + kib_tx_t *tx = list_entry(tmp, kib_tx_t, tx_list); - LASSERT (!tx->tx_queued); - LASSERT (tx->tx_sending != 0 || tx->tx_waiting); + LASSERT(!tx->tx_queued); + LASSERT(tx->tx_sending != 0 || tx->tx_waiting); - if (tx->tx_cookie != cookie) - continue; + if (tx->tx_cookie != cookie) + continue; - if (tx->tx_waiting && - tx->tx_msg->ibm_type == txtype) - return tx; + if (tx->tx_waiting && + tx->tx_msg->ibm_type == txtype) + return tx; - CWARN("Bad completion: %swaiting, type %x (wanted %x)\n", - tx->tx_waiting ? "" : "NOT ", - tx->tx_msg->ibm_type, txtype); - } - return NULL; + CWARN("Bad completion: %swaiting, type %x (wanted %x)\n", + tx->tx_waiting ? "" : "NOT ", + tx->tx_msg->ibm_type, txtype); + } + return NULL; } -void +static void kiblnd_handle_completion(kib_conn_t *conn, int txtype, int status, __u64 cookie) { kib_tx_t *tx; @@ -265,7 +275,7 @@ kiblnd_handle_completion(kib_conn_t *conn, int txtype, int status, __u64 cookie) idle = !tx->tx_queued && (tx->tx_sending == 0); if (idle) - cfs_list_del(&tx->tx_list); + list_del(&tx->tx_list); spin_unlock(&conn->ibc_lock); @@ -273,7 +283,7 @@ kiblnd_handle_completion(kib_conn_t *conn, int txtype, int status, __u64 cookie) kiblnd_tx_done(ni, tx); } -void +static void kiblnd_send_completion(kib_conn_t *conn, int type, int status, __u64 cookie) { lnet_ni_t *ni = conn->ibc_peer->ibp_ni; @@ -292,7 +302,7 @@ kiblnd_send_completion(kib_conn_t *conn, int type, int status, __u64 cookie) kiblnd_queue_tx(tx, conn); } -void +static void kiblnd_handle_rx (kib_rx_t *rx) { kib_msg_t *msg = rx->rx_msg; @@ -392,7 +402,7 @@ kiblnd_handle_rx (kib_rx_t *rx) tx = kiblnd_find_waiting_tx_locked(conn, IBLND_MSG_PUT_REQ, msg->ibm_u.putack.ibpam_src_cookie); if (tx != NULL) - cfs_list_del(&tx->tx_list); + list_del(&tx->tx_list); spin_unlock(&conn->ibc_lock); if (tx == NULL) { @@ -453,7 +463,7 @@ kiblnd_handle_rx (kib_rx_t *rx) kiblnd_post_rx(rx, post_credit); } -void +static void kiblnd_rx_complete (kib_rx_t *rx, int status, int nob) { kib_msg_t *msg = rx->rx_msg; @@ -508,7 +518,7 @@ kiblnd_rx_complete (kib_rx_t *rx, int status, int nob) write_lock_irqsave(g_lock, flags); /* must check holding global lock to eliminate race */ if (conn->ibc_state < IBLND_CONN_ESTABLISHED) { - cfs_list_add_tail(&rx->rx_list, &conn->ibc_early_rxs); + list_add_tail(&rx->rx_list, &conn->ibc_early_rxs); write_unlock_irqrestore(g_lock, flags); return; } @@ -524,13 +534,12 @@ kiblnd_rx_complete (kib_rx_t *rx, int status, int nob) kiblnd_drop_rx(rx); /* Don't re-post rx. */ } -struct page * +static struct page * kiblnd_kvaddr_to_page (unsigned long vaddr) { struct page *page; - if (vaddr >= VMALLOC_START && - vaddr < VMALLOC_END) { + if (is_vmalloc_addr((void *)vaddr)) { page = vmalloc_to_page ((void *)vaddr); LASSERT (page != NULL); return page; @@ -696,7 +705,7 @@ kiblnd_map_tx(lnet_ni_t *ni, kib_tx_t *tx, } -int +static int kiblnd_setup_rd_iov(lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd, unsigned int niov, struct iovec *iov, int offset, int nob) { @@ -749,7 +758,7 @@ kiblnd_setup_rd_iov(lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd, return kiblnd_map_tx(ni, tx, rd, sg - tx->tx_frags); } -int +static int kiblnd_setup_rd_kiov (lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd, int nkiov, lnet_kiov_t *kiov, int offset, int nob) { @@ -789,7 +798,7 @@ kiblnd_setup_rd_kiov (lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd, return kiblnd_map_tx(ni, tx, rd, sg - tx->tx_frags); } -int +static int kiblnd_post_tx_locked (kib_conn_t *conn, kib_tx_t *tx, int credit) { kib_msg_t *msg = tx->tx_msg; @@ -832,7 +841,7 @@ kiblnd_post_tx_locked (kib_conn_t *conn, kib_tx_t *tx, int credit) } /* NB don't drop ibc_lock before bumping tx_sending */ - cfs_list_del(&tx->tx_list); + list_del(&tx->tx_list); tx->tx_queued = 0; if (msg->ibm_type == IBLND_MSG_NOOP && @@ -867,7 +876,7 @@ kiblnd_post_tx_locked (kib_conn_t *conn, kib_tx_t *tx, int credit) * tx_sending is non-zero if we've not done the tx_complete() * from the first send; hence the ++ rather than = below. */ tx->tx_sending++; - cfs_list_add(&tx->tx_list, &conn->ibc_active_txs); + list_add(&tx->tx_list, &conn->ibc_active_txs); /* I'm still holding ibc_lock! */ if (conn->ibc_state != IBLND_CONN_ESTABLISHED) { @@ -900,7 +909,7 @@ kiblnd_post_tx_locked (kib_conn_t *conn, kib_tx_t *tx, int credit) done = (tx->tx_sending == 0); if (done) - cfs_list_del(&tx->tx_list); + list_del(&tx->tx_list); spin_unlock(&conn->ibc_lock); @@ -921,7 +930,7 @@ kiblnd_post_tx_locked (kib_conn_t *conn, kib_tx_t *tx, int credit) return -EIO; } -void +static void kiblnd_check_sends (kib_conn_t *conn) { int ver = conn->ibc_version; @@ -943,11 +952,11 @@ kiblnd_check_sends (kib_conn_t *conn) LASSERT (conn->ibc_reserved_credits >= 0); while (conn->ibc_reserved_credits > 0 && - !cfs_list_empty(&conn->ibc_tx_queue_rsrvd)) { - tx = cfs_list_entry(conn->ibc_tx_queue_rsrvd.next, + !list_empty(&conn->ibc_tx_queue_rsrvd)) { + tx = list_entry(conn->ibc_tx_queue_rsrvd.next, kib_tx_t, tx_list); - cfs_list_del(&tx->tx_list); - cfs_list_add_tail(&tx->tx_list, &conn->ibc_tx_queue); + list_del(&tx->tx_list); + list_add_tail(&tx->tx_list, &conn->ibc_tx_queue); conn->ibc_reserved_credits--; } @@ -968,18 +977,18 @@ kiblnd_check_sends (kib_conn_t *conn) for (;;) { int credit; - if (!cfs_list_empty(&conn->ibc_tx_queue_nocred)) { + if (!list_empty(&conn->ibc_tx_queue_nocred)) { credit = 0; - tx = cfs_list_entry(conn->ibc_tx_queue_nocred.next, + tx = list_entry(conn->ibc_tx_queue_nocred.next, kib_tx_t, tx_list); - } else if (!cfs_list_empty(&conn->ibc_tx_noops)) { + } else if (!list_empty(&conn->ibc_tx_noops)) { LASSERT (!IBLND_OOB_CAPABLE(ver)); credit = 1; - tx = cfs_list_entry(conn->ibc_tx_noops.next, + tx = list_entry(conn->ibc_tx_noops.next, kib_tx_t, tx_list); - } else if (!cfs_list_empty(&conn->ibc_tx_queue)) { + } else if (!list_empty(&conn->ibc_tx_queue)) { credit = 1; - tx = cfs_list_entry(conn->ibc_tx_queue.next, + tx = list_entry(conn->ibc_tx_queue.next, kib_tx_t, tx_list); } else break; @@ -993,7 +1002,7 @@ kiblnd_check_sends (kib_conn_t *conn) kiblnd_conn_decref(conn); /* ...until here */ } -void +static void kiblnd_tx_complete (kib_tx_t *tx, int status) { int failed = (status != IB_WC_SUCCESS); @@ -1034,7 +1043,7 @@ kiblnd_tx_complete (kib_tx_t *tx, int status) !tx->tx_waiting && /* Not waiting for peer */ !tx->tx_queued; /* Not re-queued (PUT_DONE) */ if (idle) - cfs_list_del(&tx->tx_list); + list_del(&tx->tx_list); kiblnd_conn_addref(conn); /* 1 ref for me.... */ @@ -1048,7 +1057,7 @@ kiblnd_tx_complete (kib_tx_t *tx, int status) kiblnd_conn_decref(conn); /* ...until here */ } -void +static void kiblnd_init_tx_msg (lnet_ni_t *ni, kib_tx_t *tx, int type, int body_nob) { kib_hca_dev_t *hdev = tx->tx_pool->tpo_hdev; @@ -1082,9 +1091,9 @@ kiblnd_init_tx_msg (lnet_ni_t *ni, kib_tx_t *tx, int type, int body_nob) tx->tx_nwrq++; } -int -kiblnd_init_rdma (kib_conn_t *conn, kib_tx_t *tx, int type, - int resid, kib_rdma_desc_t *dstrd, __u64 dstcookie) +static int +kiblnd_init_rdma(kib_conn_t *conn, kib_tx_t *tx, int type, + int resid, kib_rdma_desc_t *dstrd, __u64 dstcookie) { kib_msg_t *ibmsg = tx->tx_msg; kib_rdma_desc_t *srcrd = tx->tx_rd; @@ -1167,14 +1176,14 @@ kiblnd_init_rdma (kib_conn_t *conn, kib_tx_t *tx, int type, return rc; } -void -kiblnd_queue_tx_locked (kib_tx_t *tx, kib_conn_t *conn) +static void +kiblnd_queue_tx_locked(kib_tx_t *tx, kib_conn_t *conn) { - cfs_list_t *q; + struct list_head *q; - LASSERT (tx->tx_nwrq > 0); /* work items set up */ - LASSERT (!tx->tx_queued); /* not queued for sending already */ - LASSERT (conn->ibc_state >= IBLND_CONN_ESTABLISHED); + LASSERT(tx->tx_nwrq > 0); /* work items set up */ + LASSERT(!tx->tx_queued); /* not queued for sending already */ + LASSERT(conn->ibc_state >= IBLND_CONN_ESTABLISHED); tx->tx_queued = 1; tx->tx_deadline = jiffies + (*kiblnd_tunables.kib_timeout * HZ); @@ -1217,10 +1226,10 @@ kiblnd_queue_tx_locked (kib_tx_t *tx, kib_conn_t *conn) break; } - cfs_list_add_tail(&tx->tx_list, q); + list_add_tail(&tx->tx_list, q); } -void +static void kiblnd_queue_tx (kib_tx_t *tx, kib_conn_t *conn) { spin_lock(&conn->ibc_lock); @@ -1272,7 +1281,7 @@ static int kiblnd_resolve_addr(struct rdma_cm_id *cmid, return rc; } -void +static void kiblnd_connect_peer (kib_peer_t *peer) { struct rdma_cm_id *cmid; @@ -1358,7 +1367,7 @@ kiblnd_launch_tx (lnet_ni_t *ni, kib_tx_t *tx, lnet_nid_t nid) read_lock_irqsave(g_lock, flags); peer = kiblnd_find_peer_locked(nid); - if (peer != NULL && !cfs_list_empty(&peer->ibp_conns)) { + if (peer != NULL && !list_empty(&peer->ibp_conns)) { /* Found a peer with an established connection */ conn = kiblnd_get_conn_locked(peer); kiblnd_conn_addref(conn); /* 1 ref for me... */ @@ -1377,12 +1386,12 @@ kiblnd_launch_tx (lnet_ni_t *ni, kib_tx_t *tx, lnet_nid_t nid) peer = kiblnd_find_peer_locked(nid); if (peer != NULL) { - if (cfs_list_empty(&peer->ibp_conns)) { + if (list_empty(&peer->ibp_conns)) { /* found a peer, but it's still connecting... */ LASSERT (peer->ibp_connecting != 0 || peer->ibp_accepting != 0); if (tx != NULL) - cfs_list_add_tail(&tx->tx_list, + list_add_tail(&tx->tx_list, &peer->ibp_tx_queue); write_unlock_irqrestore(g_lock, flags); } else { @@ -1416,12 +1425,12 @@ kiblnd_launch_tx (lnet_ni_t *ni, kib_tx_t *tx, lnet_nid_t nid) peer2 = kiblnd_find_peer_locked(nid); if (peer2 != NULL) { - if (cfs_list_empty(&peer2->ibp_conns)) { + if (list_empty(&peer2->ibp_conns)) { /* found a peer, but it's still connecting... */ LASSERT (peer2->ibp_connecting != 0 || peer2->ibp_accepting != 0); if (tx != NULL) - cfs_list_add_tail(&tx->tx_list, + list_add_tail(&tx->tx_list, &peer2->ibp_tx_queue); write_unlock_irqrestore(g_lock, flags); } else { @@ -1447,10 +1456,10 @@ kiblnd_launch_tx (lnet_ni_t *ni, kib_tx_t *tx, lnet_nid_t nid) LASSERT (((kib_net_t *)ni->ni_data)->ibn_shutdown == 0); if (tx != NULL) - cfs_list_add_tail(&tx->tx_list, &peer->ibp_tx_queue); + list_add_tail(&tx->tx_list, &peer->ibp_tx_queue); kiblnd_peer_addref(peer); - cfs_list_add_tail(&peer->ibp_list, kiblnd_nid2peerlist(nid)); + list_add_tail(&peer->ibp_list, kiblnd_nid2peerlist(nid)); write_unlock_irqrestore(g_lock, flags); @@ -1629,7 +1638,7 @@ kiblnd_send (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg) return 0; } -void +static void kiblnd_reply (lnet_ni_t *ni, kib_rx_t *rx, lnet_msg_t *lntmsg) { lnet_process_id_t target = lntmsg->msg_target; @@ -1812,17 +1821,17 @@ kiblnd_thread_start(int (*fn)(void *arg), void *arg, char *name) if (IS_ERR(task)) return PTR_ERR(task); - cfs_atomic_inc(&kiblnd_data.kib_nthreads); + atomic_inc(&kiblnd_data.kib_nthreads); return 0; } -void +static void kiblnd_thread_fini (void) { - cfs_atomic_dec (&kiblnd_data.kib_nthreads); + atomic_dec (&kiblnd_data.kib_nthreads); } -void +static void kiblnd_peer_alive (kib_peer_t *peer) { /* This is racy, but everyone's only writing cfs_time_current() */ @@ -1830,7 +1839,7 @@ kiblnd_peer_alive (kib_peer_t *peer) smp_mb(); } -void +static void kiblnd_peer_notify (kib_peer_t *peer) { int error = 0; @@ -1839,7 +1848,7 @@ kiblnd_peer_notify (kib_peer_t *peer) read_lock_irqsave(&kiblnd_data.kib_global_lock, flags); - if (cfs_list_empty(&peer->ibp_conns) && + if (list_empty(&peer->ibp_conns) && peer->ibp_accepting == 0 && peer->ibp_connecting == 0 && peer->ibp_error != 0) { @@ -1878,28 +1887,30 @@ kiblnd_close_conn_locked (kib_conn_t *conn, int error) return; /* already being handled */ if (error == 0 && - cfs_list_empty(&conn->ibc_tx_noops) && - cfs_list_empty(&conn->ibc_tx_queue) && - cfs_list_empty(&conn->ibc_tx_queue_rsrvd) && - cfs_list_empty(&conn->ibc_tx_queue_nocred) && - cfs_list_empty(&conn->ibc_active_txs)) { + list_empty(&conn->ibc_tx_noops) && + list_empty(&conn->ibc_tx_queue) && + list_empty(&conn->ibc_tx_queue_rsrvd) && + list_empty(&conn->ibc_tx_queue_nocred) && + list_empty(&conn->ibc_active_txs)) { CDEBUG(D_NET, "closing conn to %s\n", libcfs_nid2str(peer->ibp_nid)); } else { CNETERR("Closing conn to %s: error %d%s%s%s%s%s\n", libcfs_nid2str(peer->ibp_nid), error, - cfs_list_empty(&conn->ibc_tx_queue) ? "" : "(sending)", - cfs_list_empty(&conn->ibc_tx_noops) ? "" : "(sending_noops)", - cfs_list_empty(&conn->ibc_tx_queue_rsrvd) ? "" : "(sending_rsrvd)", - cfs_list_empty(&conn->ibc_tx_queue_nocred) ? "" : "(sending_nocred)", - cfs_list_empty(&conn->ibc_active_txs) ? "" : "(waiting)"); + list_empty(&conn->ibc_tx_queue) ? "" : "(sending)", + list_empty(&conn->ibc_tx_noops) ? "" : "(sending_noops)", + list_empty(&conn->ibc_tx_queue_rsrvd) ? + "" : "(sending_rsrvd)", + list_empty(&conn->ibc_tx_queue_nocred) ? + "" : "(sending_nocred)", + list_empty(&conn->ibc_active_txs) ? "" : "(waiting)"); } dev = ((kib_net_t *)peer->ibp_ni->ni_data)->ibn_dev; - cfs_list_del(&conn->ibc_list); + list_del(&conn->ibc_list); /* connd (see below) takes over ibc_list's ref */ - if (cfs_list_empty (&peer->ibp_conns) && /* no more conns */ + if (list_empty(&peer->ibp_conns) && /* no more conns */ kiblnd_peer_active(peer)) { /* still in peer table */ kiblnd_unlink_peer_locked(peer); @@ -1911,14 +1922,14 @@ kiblnd_close_conn_locked (kib_conn_t *conn, int error) if (error != 0 && kiblnd_dev_can_failover(dev)) { - cfs_list_add_tail(&dev->ibd_fail_list, + list_add_tail(&dev->ibd_fail_list, &kiblnd_data.kib_failed_devs); wake_up(&kiblnd_data.kib_failover_waitq); } spin_lock_irqsave(&kiblnd_data.kib_connd_lock, flags); - cfs_list_add_tail(&conn->ibc_list, &kiblnd_data.kib_connd_conns); + list_add_tail(&conn->ibc_list, &kiblnd_data.kib_connd_conns); wake_up(&kiblnd_data.kib_connd_waitq); spin_unlock_irqrestore(&kiblnd_data.kib_connd_lock, flags); @@ -1936,7 +1947,7 @@ kiblnd_close_conn(kib_conn_t *conn, int error) write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags); } -void +static void kiblnd_handle_early_rxs(kib_conn_t *conn) { unsigned long flags; @@ -1946,10 +1957,10 @@ kiblnd_handle_early_rxs(kib_conn_t *conn) LASSERT(conn->ibc_state >= IBLND_CONN_ESTABLISHED); write_lock_irqsave(&kiblnd_data.kib_global_lock, flags); - while (!cfs_list_empty(&conn->ibc_early_rxs)) { - rx = cfs_list_entry(conn->ibc_early_rxs.next, + while (!list_empty(&conn->ibc_early_rxs)) { + rx = list_entry(conn->ibc_early_rxs.next, kib_rx_t, rx_list); - cfs_list_del(&rx->rx_list); + list_del(&rx->rx_list); write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags); kiblnd_handle_rx(rx); @@ -1959,43 +1970,43 @@ kiblnd_handle_early_rxs(kib_conn_t *conn) write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags); } -void -kiblnd_abort_txs(kib_conn_t *conn, cfs_list_t *txs) +static void +kiblnd_abort_txs(kib_conn_t *conn, struct list_head *txs) { - CFS_LIST_HEAD (zombies); - cfs_list_t *tmp; - cfs_list_t *nxt; - kib_tx_t *tx; + struct list_head zombies = LIST_HEAD_INIT(zombies); + struct list_head *tmp; + struct list_head *nxt; + kib_tx_t *tx; spin_lock(&conn->ibc_lock); - cfs_list_for_each_safe (tmp, nxt, txs) { - tx = cfs_list_entry (tmp, kib_tx_t, tx_list); + list_for_each_safe(tmp, nxt, txs) { + tx = list_entry(tmp, kib_tx_t, tx_list); - if (txs == &conn->ibc_active_txs) { - LASSERT (!tx->tx_queued); - LASSERT (tx->tx_waiting || - tx->tx_sending != 0); - } else { - LASSERT (tx->tx_queued); - } + if (txs == &conn->ibc_active_txs) { + LASSERT(!tx->tx_queued); + LASSERT(tx->tx_waiting || + tx->tx_sending != 0); + } else { + LASSERT(tx->tx_queued); + } - tx->tx_status = -ECONNABORTED; - tx->tx_waiting = 0; + tx->tx_status = -ECONNABORTED; + tx->tx_waiting = 0; - if (tx->tx_sending == 0) { - tx->tx_queued = 0; - cfs_list_del (&tx->tx_list); - cfs_list_add (&tx->tx_list, &zombies); - } - } + if (tx->tx_sending == 0) { + tx->tx_queued = 0; + list_del(&tx->tx_list); + list_add(&tx->tx_list, &zombies); + } + } spin_unlock(&conn->ibc_lock); kiblnd_txlist_done(conn->ibc_peer->ibp_ni, &zombies, -ECONNABORTED); } -void +static void kiblnd_finalise_conn (kib_conn_t *conn) { LASSERT (!in_interrupt()); @@ -2020,11 +2031,11 @@ kiblnd_finalise_conn (kib_conn_t *conn) kiblnd_handle_early_rxs(conn); } -void -kiblnd_peer_connect_failed (kib_peer_t *peer, int active, int error) +static void +kiblnd_peer_connect_failed(kib_peer_t *peer, int active, int error) { - CFS_LIST_HEAD (zombies); - unsigned long flags; + struct list_head zombies = LIST_HEAD_INIT(zombies); + unsigned long flags; LASSERT (error != 0); LASSERT (!in_interrupt()); @@ -2040,48 +2051,48 @@ kiblnd_peer_connect_failed (kib_peer_t *peer, int active, int error) } if (peer->ibp_connecting != 0 || - peer->ibp_accepting != 0) { - /* another connection attempt under way... */ + peer->ibp_accepting != 0) { + /* another connection attempt under way... */ write_unlock_irqrestore(&kiblnd_data.kib_global_lock, - flags); - return; - } + flags); + return; + } - if (cfs_list_empty(&peer->ibp_conns)) { - /* Take peer's blocked transmits to complete with error */ - cfs_list_add(&zombies, &peer->ibp_tx_queue); - cfs_list_del_init(&peer->ibp_tx_queue); + if (list_empty(&peer->ibp_conns)) { + /* Take peer's blocked transmits to complete with error */ + list_add(&zombies, &peer->ibp_tx_queue); + list_del_init(&peer->ibp_tx_queue); - if (kiblnd_peer_active(peer)) - kiblnd_unlink_peer_locked(peer); + if (kiblnd_peer_active(peer)) + kiblnd_unlink_peer_locked(peer); - peer->ibp_error = error; - } else { - /* Can't have blocked transmits if there are connections */ - LASSERT (cfs_list_empty(&peer->ibp_tx_queue)); - } + peer->ibp_error = error; + } else { + /* Can't have blocked transmits if there are connections */ + LASSERT(list_empty(&peer->ibp_tx_queue)); + } write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags); - kiblnd_peer_notify(peer); + kiblnd_peer_notify(peer); - if (cfs_list_empty (&zombies)) - return; + if (list_empty(&zombies)) + return; - CNETERR("Deleting messages for %s: connection failed\n", - libcfs_nid2str(peer->ibp_nid)); + CNETERR("Deleting messages for %s: connection failed\n", + libcfs_nid2str(peer->ibp_nid)); - kiblnd_txlist_done(peer->ibp_ni, &zombies, -EHOSTUNREACH); + kiblnd_txlist_done(peer->ibp_ni, &zombies, -EHOSTUNREACH); } -void +static void kiblnd_connreq_done(kib_conn_t *conn, int status) { - kib_peer_t *peer = conn->ibc_peer; - kib_tx_t *tx; - cfs_list_t txs; - unsigned long flags; - int active; + kib_peer_t *peer = conn->ibc_peer; + kib_tx_t *tx; + struct list_head txs; + unsigned long flags; + int active; active = (conn->ibc_state == IBLND_CONN_ACTIVE_CONNECT); @@ -2112,14 +2123,14 @@ kiblnd_connreq_done(kib_conn_t *conn, int status) kiblnd_set_conn_state(conn, IBLND_CONN_ESTABLISHED); kiblnd_peer_alive(peer); - /* Add conn to peer's list and nuke any dangling conns from a different - * peer instance... */ - kiblnd_conn_addref(conn); /* +1 ref for ibc_list */ - cfs_list_add(&conn->ibc_list, &peer->ibp_conns); - if (active) - peer->ibp_connecting--; - else - peer->ibp_accepting--; + /* Add conn to peer's list and nuke any dangling conns from a different + * peer instance... */ + kiblnd_conn_addref(conn); /* +1 ref for ibc_list */ + list_add(&conn->ibc_list, &peer->ibp_conns); + if (active) + peer->ibp_connecting--; + else + peer->ibp_accepting--; if (peer->ibp_version == 0) { peer->ibp_version = conn->ibc_version; @@ -2134,9 +2145,9 @@ kiblnd_connreq_done(kib_conn_t *conn, int status) peer->ibp_incarnation = conn->ibc_incarnation; } - /* grab pending txs while I have the lock */ - cfs_list_add(&txs, &peer->ibp_tx_queue); - cfs_list_del_init(&peer->ibp_tx_queue); + /* grab pending txs while I have the lock */ + list_add(&txs, &peer->ibp_tx_queue); + list_del_init(&peer->ibp_tx_queue); if (!kiblnd_peer_active(peer) || /* peer has been deleted */ conn->ibc_comms_error != 0) { /* error has happened already */ @@ -2155,9 +2166,9 @@ kiblnd_connreq_done(kib_conn_t *conn, int status) /* Schedule blocked txs */ spin_lock(&conn->ibc_lock); - while (!cfs_list_empty(&txs)) { - tx = cfs_list_entry(txs.next, kib_tx_t, tx_list); - cfs_list_del(&tx->tx_list); + while (!list_empty(&txs)) { + tx = list_entry(txs.next, kib_tx_t, tx_list); + list_del(&tx->tx_list); kiblnd_queue_tx_locked(tx, conn); } @@ -2169,7 +2180,7 @@ kiblnd_connreq_done(kib_conn_t *conn, int status) kiblnd_handle_early_rxs(conn); } -void +static void kiblnd_reject(struct rdma_cm_id *cmid, kib_rej_t *rej) { int rc; @@ -2180,7 +2191,7 @@ kiblnd_reject(struct rdma_cm_id *cmid, kib_rej_t *rej) CWARN("Error %d sending reject\n", rc); } -int +static int kiblnd_passive_connect (struct rdma_cm_id *cmid, void *priv, int priv_nob) { rwlock_t *g_lock = &kiblnd_data.kib_global_lock; @@ -2384,7 +2395,7 @@ kiblnd_passive_connect (struct rdma_cm_id *cmid, void *priv, int priv_nob) LASSERT (net->ibn_shutdown == 0); kiblnd_peer_addref(peer); - cfs_list_add_tail(&peer->ibp_list, kiblnd_nid2peerlist(nid)); + list_add_tail(&peer->ibp_list, kiblnd_nid2peerlist(nid)); write_unlock_irqrestore(g_lock, flags); } @@ -2454,7 +2465,7 @@ kiblnd_passive_connect (struct rdma_cm_id *cmid, void *priv, int priv_nob) return -ECONNREFUSED; } -void +static void kiblnd_reconnect (kib_conn_t *conn, int version, __u64 incarnation, int why, kib_connparams_t *cp) { @@ -2473,7 +2484,7 @@ kiblnd_reconnect (kib_conn_t *conn, int version, * NB: reconnect is still needed even when ibp_tx_queue is * empty if ibp_version != version because reconnect may be * initiated by kiblnd_query() */ - if ((!cfs_list_empty(&peer->ibp_tx_queue) || + if ((!list_empty(&peer->ibp_tx_queue) || peer->ibp_version != version) && peer->ibp_connecting == 1 && peer->ibp_accepting == 0) { @@ -2518,7 +2529,7 @@ kiblnd_reconnect (kib_conn_t *conn, int version, kiblnd_connect_peer(peer); } -void +static void kiblnd_rejected (kib_conn_t *conn, int reason, void *priv, int priv_nob) { kib_peer_t *peer = conn->ibc_peer; @@ -2615,14 +2626,18 @@ kiblnd_rejected (kib_conn_t *conn, int reason, void *priv, int priv_nob) case IBLND_REJECT_MSG_QUEUE_SIZE: CERROR("%s rejected: incompatible message queue depth %d, %d\n", - libcfs_nid2str(peer->ibp_nid), cp->ibcp_queue_depth, - IBLND_MSG_QUEUE_SIZE(conn->ibc_version)); + libcfs_nid2str(peer->ibp_nid), + cp != NULL ? cp->ibcp_queue_depth : + IBLND_MSG_QUEUE_SIZE(rej->ibr_version), + IBLND_MSG_QUEUE_SIZE(conn->ibc_version)); break; case IBLND_REJECT_RDMA_FRAGS: CERROR("%s rejected: incompatible # of RDMA fragments %d, %d\n", - libcfs_nid2str(peer->ibp_nid), cp->ibcp_max_frags, - IBLND_RDMA_FRAGS(conn->ibc_version)); + libcfs_nid2str(peer->ibp_nid), + cp != NULL ? cp->ibcp_max_frags : + IBLND_RDMA_FRAGS(rej->ibr_version), + IBLND_RDMA_FRAGS(conn->ibc_version)); break; case IBLND_REJECT_NO_RESOURCES: @@ -2653,7 +2668,7 @@ kiblnd_rejected (kib_conn_t *conn, int reason, void *priv, int priv_nob) kiblnd_connreq_done(conn, -ECONNREFUSED); } -void +static void kiblnd_check_connreply (kib_conn_t *conn, void *priv, int priv_nob) { kib_peer_t *peer = conn->ibc_peer; @@ -2752,7 +2767,7 @@ kiblnd_check_connreply (kib_conn_t *conn, void *priv, int priv_nob) kiblnd_connreq_done(conn, 0); } -int +static int kiblnd_active_connect (struct rdma_cm_id *cmid) { kib_peer_t *peer = (kib_peer_t *)cmid->context; @@ -2991,30 +3006,30 @@ kiblnd_cm_callback(struct rdma_cm_id *cmid, struct rdma_cm_event *event) } static int -kiblnd_check_txs_locked(kib_conn_t *conn, cfs_list_t *txs) +kiblnd_check_txs_locked(kib_conn_t *conn, struct list_head *txs) { - kib_tx_t *tx; - cfs_list_t *ttmp; + kib_tx_t *tx; + struct list_head *ttmp; - cfs_list_for_each (ttmp, txs) { - tx = cfs_list_entry (ttmp, kib_tx_t, tx_list); + list_for_each(ttmp, txs) { + tx = list_entry(ttmp, kib_tx_t, tx_list); - if (txs != &conn->ibc_active_txs) { - LASSERT (tx->tx_queued); - } else { - LASSERT (!tx->tx_queued); - LASSERT (tx->tx_waiting || tx->tx_sending != 0); - } + if (txs != &conn->ibc_active_txs) { + LASSERT(tx->tx_queued); + } else { + LASSERT(!tx->tx_queued); + LASSERT(tx->tx_waiting || tx->tx_sending != 0); + } - if (cfs_time_aftereq (jiffies, tx->tx_deadline)) { - CERROR("Timed out tx: %s, %lu seconds\n", - kiblnd_queue2str(conn, txs), - cfs_duration_sec(jiffies - tx->tx_deadline)); - return 1; - } - } + if (cfs_time_aftereq(jiffies, tx->tx_deadline)) { + CERROR("Timed out tx: %s, %lu seconds\n", + kiblnd_queue2str(conn, txs), + cfs_duration_sec(jiffies - tx->tx_deadline)); + return 1; + } + } - return 0; + return 0; } static int @@ -3027,33 +3042,33 @@ kiblnd_conn_timed_out_locked(kib_conn_t *conn) kiblnd_check_txs_locked(conn, &conn->ibc_active_txs); } -void +static void kiblnd_check_conns (int idx) { - CFS_LIST_HEAD (closes); - CFS_LIST_HEAD (checksends); - cfs_list_t *peers = &kiblnd_data.kib_peers[idx]; - cfs_list_t *ptmp; - kib_peer_t *peer; - kib_conn_t *conn; - cfs_list_t *ctmp; - unsigned long flags; + struct list_head closes = LIST_HEAD_INIT(closes); + struct list_head checksends = LIST_HEAD_INIT(checksends); + struct list_head *peers = &kiblnd_data.kib_peers[idx]; + struct list_head *ptmp; + kib_peer_t *peer; + kib_conn_t *conn; + struct list_head *ctmp; + 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... */ read_lock_irqsave(&kiblnd_data.kib_global_lock, flags); - cfs_list_for_each (ptmp, peers) { - peer = cfs_list_entry (ptmp, kib_peer_t, ibp_list); + list_for_each(ptmp, peers) { + peer = list_entry(ptmp, kib_peer_t, ibp_list); - cfs_list_for_each (ctmp, &peer->ibp_conns) { - int timedout; - int sendnoop; + list_for_each(ctmp, &peer->ibp_conns) { + int timedout; + int sendnoop; - conn = cfs_list_entry(ctmp, kib_conn_t, ibc_list); + conn = list_entry(ctmp, kib_conn_t, ibc_list); - LASSERT (conn->ibc_state == IBLND_CONN_ESTABLISHED); + LASSERT(conn->ibc_state == IBLND_CONN_ESTABLISHED); spin_lock(&conn->ibc_lock); @@ -3061,25 +3076,24 @@ kiblnd_check_conns (int idx) timedout = kiblnd_conn_timed_out_locked(conn); if (!sendnoop && !timedout) { spin_unlock(&conn->ibc_lock); - continue; - } + continue; + } - if (timedout) { - CERROR("Timed out RDMA with %s (%lu): " - "c: %u, oc: %u, rc: %u\n", - libcfs_nid2str(peer->ibp_nid), - cfs_duration_sec(cfs_time_current() - - peer->ibp_last_alive), - conn->ibc_credits, - conn->ibc_outstanding_credits, - conn->ibc_reserved_credits); - cfs_list_add(&conn->ibc_connd_list, &closes); - } else { - cfs_list_add(&conn->ibc_connd_list, - &checksends); - } - /* +ref for 'closes' or 'checksends' */ - kiblnd_conn_addref(conn); + if (timedout) { + CERROR("Timed out RDMA with %s (%lu): " + "c: %u, oc: %u, rc: %u\n", + libcfs_nid2str(peer->ibp_nid), + cfs_duration_sec(cfs_time_current() - + peer->ibp_last_alive), + conn->ibc_credits, + conn->ibc_outstanding_credits, + conn->ibc_reserved_credits); + list_add(&conn->ibc_connd_list, &closes); + } else { + list_add(&conn->ibc_connd_list, &checksends); + } + /* +ref for 'closes' or 'checksends' */ + kiblnd_conn_addref(conn); spin_unlock(&conn->ibc_lock); } @@ -3087,30 +3101,30 @@ kiblnd_check_conns (int idx) read_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags); - /* Handle timeout by closing the whole - * connection. We can only be sure RDMA activity - * has ceased once the QP has been modified. */ - while (!cfs_list_empty(&closes)) { - conn = cfs_list_entry(closes.next, - kib_conn_t, ibc_connd_list); - cfs_list_del(&conn->ibc_connd_list); - kiblnd_close_conn(conn, -ETIMEDOUT); - kiblnd_conn_decref(conn); - } + /* 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, + kib_conn_t, ibc_connd_list); + list_del(&conn->ibc_connd_list); + kiblnd_close_conn(conn, -ETIMEDOUT); + kiblnd_conn_decref(conn); + } - /* 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 (!cfs_list_empty(&checksends)) { - conn = cfs_list_entry(checksends.next, - kib_conn_t, ibc_connd_list); - cfs_list_del(&conn->ibc_connd_list); - kiblnd_check_sends(conn); - kiblnd_conn_decref(conn); - } + /* 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, + kib_conn_t, ibc_connd_list); + list_del(&conn->ibc_connd_list); + kiblnd_check_sends(conn); + kiblnd_conn_decref(conn); + } } -void +static void kiblnd_disconnect_conn (kib_conn_t *conn) { LASSERT (!in_interrupt()); @@ -3146,11 +3160,11 @@ kiblnd_connd (void *arg) dropped_lock = 0; - if (!cfs_list_empty (&kiblnd_data.kib_connd_zombies)) { - conn = cfs_list_entry(kiblnd_data. \ + if (!list_empty(&kiblnd_data.kib_connd_zombies)) { + conn = list_entry(kiblnd_data. \ kib_connd_zombies.next, kib_conn_t, ibc_list); - cfs_list_del(&conn->ibc_list); + list_del(&conn->ibc_list); spin_unlock_irqrestore(&kiblnd_data.kib_connd_lock, flags); @@ -3161,10 +3175,10 @@ kiblnd_connd (void *arg) spin_lock_irqsave(&kiblnd_data.kib_connd_lock, flags); } - if (!cfs_list_empty(&kiblnd_data.kib_connd_conns)) { - conn = cfs_list_entry(kiblnd_data.kib_connd_conns.next, + if (!list_empty(&kiblnd_data.kib_connd_conns)) { + conn = list_entry(kiblnd_data.kib_connd_conns.next, kib_conn_t, ibc_list); - cfs_list_del(&conn->ibc_list); + list_del(&conn->ibc_list); spin_unlock_irqrestore(&kiblnd_data.kib_connd_lock, flags); @@ -3249,7 +3263,7 @@ kiblnd_qp_event(struct ib_event *event, void *arg) } } -void +static void kiblnd_complete (struct ib_wc *wc) { switch (kiblnd_wreqid2type(wc->wr_id)) { @@ -3301,7 +3315,7 @@ kiblnd_cq_completion(struct ib_cq *cq, void *arg) conn->ibc_nsends_posted > 0)) { kiblnd_conn_addref(conn); /* +1 ref for sched_conns */ conn->ibc_scheduled = 1; - cfs_list_add_tail(&conn->ibc_sched_list, &sched->ibs_conns); + list_add_tail(&conn->ibc_sched_list, &sched->ibs_conns); if (waitqueue_active(&sched->ibs_waitq)) wake_up(&sched->ibs_waitq); @@ -3360,12 +3374,12 @@ kiblnd_scheduler(void *arg) did_something = 0; - if (!cfs_list_empty(&sched->ibs_conns)) { - conn = cfs_list_entry(sched->ibs_conns.next, + if (!list_empty(&sched->ibs_conns)) { + conn = list_entry(sched->ibs_conns.next, kib_conn_t, ibc_sched_list); /* take over kib_sched_conns' ref on conn... */ LASSERT(conn->ibc_scheduled); - cfs_list_del(&conn->ibc_sched_list); + list_del(&conn->ibc_sched_list); conn->ibc_ready = 0; spin_unlock_irqrestore(&sched->ibs_lock, flags); @@ -3407,7 +3421,7 @@ kiblnd_scheduler(void *arg) * this one... */ /* +1 ref for sched_conns */ kiblnd_conn_addref(conn); - cfs_list_add_tail(&conn->ibc_sched_list, + list_add_tail(&conn->ibc_sched_list, &sched->ibs_conns); if (waitqueue_active(&sched->ibs_waitq)) wake_up(&sched->ibs_waitq); @@ -3467,7 +3481,7 @@ kiblnd_failover_thread(void *arg) int do_failover = 0; int long_sleep; - cfs_list_for_each_entry(dev, &kiblnd_data.kib_failed_devs, + list_for_each_entry(dev, &kiblnd_data.kib_failed_devs, ibd_fail_list) { if (cfs_time_before(cfs_time_current(), dev->ibd_next_failover)) @@ -3477,7 +3491,7 @@ kiblnd_failover_thread(void *arg) } if (do_failover) { - cfs_list_del_init(&dev->ibd_fail_list); + list_del_init(&dev->ibd_fail_list); dev->ibd_failover = 1; write_unlock_irqrestore(glock, flags); @@ -3496,7 +3510,7 @@ kiblnd_failover_thread(void *arg) dev->ibd_next_failover = cfs_time_shift(min(dev->ibd_failed_failover, 10)); if (kiblnd_dev_can_failover(dev)) { - cfs_list_add_tail(&dev->ibd_fail_list, + list_add_tail(&dev->ibd_fail_list, &kiblnd_data.kib_failed_devs); } @@ -3504,7 +3518,7 @@ kiblnd_failover_thread(void *arg) } /* long sleep if no more pending failover */ - long_sleep = cfs_list_empty(&kiblnd_data.kib_failed_devs); + long_sleep = list_empty(&kiblnd_data.kib_failed_devs); set_current_state(TASK_INTERRUPTIBLE); add_wait_queue(&kiblnd_data.kib_failover_waitq, &wait); @@ -3523,9 +3537,9 @@ kiblnd_failover_thread(void *arg) * 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 */ - cfs_list_for_each_entry(dev, &kiblnd_data.kib_devs, ibd_list) { + list_for_each_entry(dev, &kiblnd_data.kib_devs, ibd_list) { if (kiblnd_dev_can_failover(dev)) { - cfs_list_add_tail(&dev->ibd_fail_list, + list_add_tail(&dev->ibd_fail_list, &kiblnd_data.kib_failed_devs); } }