X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;ds=sidebyside;f=lnet%2Fklnds%2Fo2iblnd%2Fo2iblnd_cb.c;h=8f61006828f8b932589675c27761095d626c17f7;hb=592e3d2ff84899cfe70d06d4ae2217a8659c0f8a;hp=3cc7985a44632f94cccdcd6578cc6db55d6dc4de;hpb=a5b6ed491a5fcbe593f0fb8162b7be11d07ba4de;p=fs%2Flustre-release.git diff --git a/lnet/klnds/o2iblnd/o2iblnd_cb.c b/lnet/klnds/o2iblnd/o2iblnd_cb.c index 3cc7985..8f61006 100644 --- a/lnet/klnds/o2iblnd/o2iblnd_cb.c +++ b/lnet/klnds/o2iblnd/o2iblnd_cb.c @@ -27,7 +27,7 @@ * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2012, Intel Corporation. + * Copyright (c) 2012, 2014, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -40,70 +40,81 @@ #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_unmap_tx(lnet_ni_t *ni, kib_tx_t *tx); + +static void kiblnd_tx_done (lnet_ni_t *ni, kib_tx_t *tx) { - lnet_msg_t *lntmsg[2]; - kib_net_t *net = ni->ni_data; - int rc; - int i; + lnet_msg_t *lntmsg[2]; + kib_net_t *net = ni->ni_data; + int rc; + int i; - LASSERT (net != NULL); - LASSERT (!cfs_in_interrupt()); - LASSERT (!tx->tx_queued); /* mustn't be queued for sending */ - LASSERT (tx->tx_sending == 0); /* mustn't be awaiting sent callback */ - LASSERT (!tx->tx_waiting); /* mustn't be awaiting peer response */ - LASSERT (tx->tx_pool != NULL); + LASSERT (net != NULL); + LASSERT (!in_interrupt()); + LASSERT (!tx->tx_queued); /* mustn't be queued for sending */ + LASSERT (tx->tx_sending == 0); /* mustn't be awaiting sent callback */ + LASSERT (!tx->tx_waiting); /* mustn't be awaiting peer response */ + LASSERT (tx->tx_pool != NULL); - kiblnd_unmap_tx(ni, tx); + kiblnd_unmap_tx(ni, tx); - /* tx may have up to 2 lnet msgs to finalise */ - lntmsg[0] = tx->tx_lntmsg[0]; tx->tx_lntmsg[0] = NULL; - lntmsg[1] = tx->tx_lntmsg[1]; tx->tx_lntmsg[1] = NULL; - rc = tx->tx_status; + /* tx may have up to 2 lnet msgs to finalise */ + lntmsg[0] = tx->tx_lntmsg[0]; tx->tx_lntmsg[0] = NULL; + lntmsg[1] = tx->tx_lntmsg[1]; tx->tx_lntmsg[1] = NULL; + rc = tx->tx_status; - if (tx->tx_conn != NULL) { - LASSERT (ni == tx->tx_conn->ibc_peer->ibp_ni); + if (tx->tx_conn != NULL) { + LASSERT (ni == tx->tx_conn->ibc_peer->ibp_ni); - kiblnd_conn_decref(tx->tx_conn); - tx->tx_conn = NULL; - } + kiblnd_conn_decref(tx->tx_conn); + tx->tx_conn = NULL; + } - tx->tx_nwrq = 0; - tx->tx_status = 0; + tx->tx_nwrq = 0; + tx->tx_status = 0; - kiblnd_pool_free_node(&tx->tx_pool->tpo_pool, &tx->tx_list); + kiblnd_pool_free_node(&tx->tx_pool->tpo_pool, &tx->tx_list); - /* delay finalize until my descs have been freed */ - for (i = 0; i < 2; i++) { - if (lntmsg[i] == NULL) - continue; + /* delay finalize until my descs have been freed */ + for (i = 0; i < 2; i++) { + if (lntmsg[i] == NULL) + continue; - lnet_finalize(ni, lntmsg[i], rc); - } + lnet_finalize(ni, lntmsg[i], rc); + } } 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 +138,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; @@ -145,20 +156,20 @@ kiblnd_drop_rx(kib_rx_t *rx) int kiblnd_post_rx (kib_rx_t *rx, int credit) { - kib_conn_t *conn = rx->rx_conn; - kib_net_t *net = conn->ibc_peer->ibp_ni->ni_data; - struct ib_recv_wr *bad_wrq = NULL; - struct ib_mr *mr; - int rc; + kib_conn_t *conn = rx->rx_conn; + kib_net_t *net = conn->ibc_peer->ibp_ni->ni_data; + struct ib_recv_wr *bad_wrq = NULL; + struct ib_mr *mr; + int rc; - LASSERT (net != NULL); - LASSERT (!cfs_in_interrupt()); - LASSERT (credit == IBLND_POSTRX_NO_CREDIT || - credit == IBLND_POSTRX_PEER_CREDIT || - credit == IBLND_POSTRX_RSRVD_CREDIT); + LASSERT (net != NULL); + LASSERT (!in_interrupt()); + LASSERT (credit == IBLND_POSTRX_NO_CREDIT || + credit == IBLND_POSTRX_PEER_CREDIT || + credit == IBLND_POSTRX_RSRVD_CREDIT); - mr = kiblnd_find_dma_mr(conn->ibc_hdev, rx->rx_msgaddr, IBLND_MSG_SIZE); - LASSERT (mr != NULL); + mr = kiblnd_find_dma_mr(conn->ibc_hdev, rx->rx_msgaddr, IBLND_MSG_SIZE); + LASSERT (mr != NULL); rx->rx_sge.lkey = mr->lkey; rx->rx_sge.addr = rx->rx_msgaddr; @@ -179,24 +190,28 @@ kiblnd_post_rx (kib_rx_t *rx, int credit) rx->rx_nob = -1; /* flag posted */ - rc = ib_post_recv(conn->ibc_cmid->qp, &rx->rx_wrq, &bad_wrq); - if (rc != 0) { - CERROR("Can't post rx for %s: %d, bad_wrq: %p\n", - libcfs_nid2str(conn->ibc_peer->ibp_nid), rc, bad_wrq); - rx->rx_nob = 0; - } + /* NB: need an extra reference after ib_post_recv because we don't + * own this rx (and rx::rx_conn) anymore, LU-5678. + */ + kiblnd_conn_addref(conn); + rc = ib_post_recv(conn->ibc_cmid->qp, &rx->rx_wrq, &bad_wrq); + if (unlikely(rc != 0)) { + CERROR("Can't post rx for %s: %d, bad_wrq: %p\n", + libcfs_nid2str(conn->ibc_peer->ibp_nid), rc, bad_wrq); + rx->rx_nob = 0; + } - if (conn->ibc_state < IBLND_CONN_ESTABLISHED) /* Initial post */ - return rc; + if (conn->ibc_state < IBLND_CONN_ESTABLISHED) /* Initial post */ + goto out; - if (rc != 0) { - kiblnd_close_conn(conn, rc); - kiblnd_drop_rx(rx); /* No more posts for this rx */ - return rc; - } + if (unlikely(rc != 0)) { + kiblnd_close_conn(conn, rc); + kiblnd_drop_rx(rx); /* No more posts for this rx */ + goto out; + } - if (credit == IBLND_POSTRX_NO_CREDIT) - return 0; + if (credit == IBLND_POSTRX_NO_CREDIT) + goto out; spin_lock(&conn->ibc_lock); if (credit == IBLND_POSTRX_PEER_CREDIT) @@ -206,35 +221,37 @@ kiblnd_post_rx (kib_rx_t *rx, int credit) spin_unlock(&conn->ibc_lock); kiblnd_check_sends(conn); - return 0; +out: + kiblnd_conn_decref(conn); + return rc; } -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 +282,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 +290,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 +309,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 +409,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 +470,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 +525,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 +541,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; @@ -629,7 +645,7 @@ kiblnd_pmr_map_tx(kib_net_t *net, kib_tx_t *tx, kib_rdma_desc_t *rd, int nob) return 0; } -void +static void kiblnd_unmap_tx(lnet_ni_t *ni, kib_tx_t *tx) { kib_net_t *net = ni->ni_data; @@ -652,24 +668,22 @@ kiblnd_unmap_tx(lnet_ni_t *ni, kib_tx_t *tx) } } -int -kiblnd_map_tx(lnet_ni_t *ni, kib_tx_t *tx, - kib_rdma_desc_t *rd, int nfrags) +static int +kiblnd_map_tx(lnet_ni_t *ni, kib_tx_t *tx, kib_rdma_desc_t *rd, int nfrags) { - kib_hca_dev_t *hdev = tx->tx_pool->tpo_hdev; - kib_net_t *net = ni->ni_data; - struct ib_mr *mr = NULL; - __u32 nob; - int i; + kib_hca_dev_t *hdev = tx->tx_pool->tpo_hdev; + kib_net_t *net = ni->ni_data; + struct ib_mr *mr = NULL; + __u32 nob; + int i; /* If rd is not tx_rd, it's going to get sent to a peer and I'm the * RDMA sink */ tx->tx_dmadir = (rd != tx->tx_rd) ? DMA_FROM_DEVICE : DMA_TO_DEVICE; - tx->tx_nfrags = nfrags; + tx->tx_nfrags = nfrags; - rd->rd_nfrags = - kiblnd_dma_map_sg(hdev->ibh_ibdev, - tx->tx_frags, tx->tx_nfrags, tx->tx_dmadir); + rd->rd_nfrags = kiblnd_dma_map_sg(hdev->ibh_ibdev, tx->tx_frags, + tx->tx_nfrags, tx->tx_dmadir); for (i = 0, nob = 0; i < rd->rd_nfrags; i++) { rd->rd_frags[i].rf_nob = kiblnd_sg_dma_len( @@ -696,7 +710,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 +763,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,8 +803,9 @@ 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) +__must_hold(&conn->ibc_lock) { kib_msg_t *msg = tx->tx_msg; kib_peer_t *peer = conn->ibc_peer; @@ -832,7 +847,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 +882,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 +915,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 +936,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 +958,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 +983,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 +1008,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 +1049,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 +1063,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,25 +1097,25 @@ 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; - struct ib_sge *sge = &tx->tx_sge[0]; - struct ib_send_wr *wrq = &tx->tx_wrq[0]; - int rc = resid; - int srcidx; - int dstidx; - int wrknob; - - LASSERT (!cfs_in_interrupt()); - LASSERT (tx->tx_nwrq == 0); - LASSERT (type == IBLND_MSG_GET_DONE || - type == IBLND_MSG_PUT_DONE); - - srcidx = dstidx = 0; + kib_msg_t *ibmsg = tx->tx_msg; + kib_rdma_desc_t *srcrd = tx->tx_rd; + struct ib_sge *sge = &tx->tx_sge[0]; + struct ib_send_wr *wrq = &tx->tx_wrq[0]; + int rc = resid; + int srcidx; + int dstidx; + int wrknob; + + LASSERT (!in_interrupt()); + LASSERT (tx->tx_nwrq == 0); + LASSERT (type == IBLND_MSG_GET_DONE || + type == IBLND_MSG_PUT_DONE); + + srcidx = dstidx = 0; while (resid > 0) { if (srcidx >= srcrd->rd_nfrags) { @@ -1167,17 +1182,19 @@ 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 * CFS_HZ); + tx->tx_queued = 1; + tx->tx_deadline = jiffies + + msecs_to_jiffies(*kiblnd_tunables.kib_timeout * + MSEC_PER_SEC); if (tx->tx_conn == NULL) { kiblnd_conn_addref(conn); @@ -1217,10 +1234,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 +1289,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; @@ -1324,9 +1341,9 @@ kiblnd_connect_peer (kib_peer_t *peer) } LASSERT (cmid->device != NULL); - CDEBUG(D_NET, "%s: connection bound to %s:%u.%u.%u.%u:%s\n", + CDEBUG(D_NET, "%s: connection bound to %s:%pI4h:%s\n", libcfs_nid2str(peer->ibp_nid), dev->ibd_ifname, - HIPQUAD(dev->ibd_ifip), cmid->device->name); + &dev->ibd_ifip, cmid->device->name); return; @@ -1358,7 +1375,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 +1394,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 +1433,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 +1464,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); @@ -1462,37 +1479,38 @@ int kiblnd_send (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg) { lnet_hdr_t *hdr = &lntmsg->msg_hdr; - int type = lntmsg->msg_type; - lnet_process_id_t target = lntmsg->msg_target; - int target_is_router = lntmsg->msg_target_is_router; - int routing = lntmsg->msg_routing; - unsigned int payload_niov = lntmsg->msg_niov; - struct iovec *payload_iov = lntmsg->msg_iov; - lnet_kiov_t *payload_kiov = lntmsg->msg_kiov; - unsigned int payload_offset = lntmsg->msg_offset; - unsigned int payload_nob = lntmsg->msg_len; - kib_msg_t *ibmsg; - kib_tx_t *tx; - int nob; - int rc; + int type = lntmsg->msg_type; + lnet_process_id_t target = lntmsg->msg_target; + int target_is_router = lntmsg->msg_target_is_router; + int routing = lntmsg->msg_routing; + unsigned int payload_niov = lntmsg->msg_niov; + struct iovec *payload_iov = lntmsg->msg_iov; + lnet_kiov_t *payload_kiov = lntmsg->msg_kiov; + unsigned int payload_offset = lntmsg->msg_offset; + unsigned int payload_nob = lntmsg->msg_len; + kib_msg_t *ibmsg; + kib_rdma_desc_t *rd; + kib_tx_t *tx; + int nob; + int rc; /* NB 'private' is different depending on what we're sending.... */ CDEBUG(D_NET, "sending %d bytes in %d frags to %s\n", payload_nob, payload_niov, libcfs_id2str(target)); - LASSERT (payload_nob == 0 || payload_niov > 0); - LASSERT (payload_niov <= LNET_MAX_IOV); + LASSERT (payload_nob == 0 || payload_niov > 0); + LASSERT (payload_niov <= LNET_MAX_IOV); - /* Thread context */ - LASSERT (!cfs_in_interrupt()); - /* payload is either all vaddrs or all pages */ - LASSERT (!(payload_kiov != NULL && payload_iov != NULL)); + /* Thread context */ + LASSERT (!in_interrupt()); + /* payload is either all vaddrs or all pages */ + LASSERT (!(payload_kiov != NULL && payload_iov != NULL)); - switch (type) { - default: - LBUG(); - return (-EIO); + switch (type) { + default: + LBUG(); + return (-EIO); case LNET_MSG_ACK: LASSERT (payload_nob == 0); @@ -1514,30 +1532,28 @@ kiblnd_send (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg) return -ENOMEM; } - ibmsg = tx->tx_msg; - - if ((lntmsg->msg_md->md_options & LNET_MD_KIOV) == 0) - rc = kiblnd_setup_rd_iov(ni, tx, - &ibmsg->ibm_u.get.ibgm_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, - &ibmsg->ibm_u.get.ibgm_rd, - lntmsg->msg_md->md_niov, - lntmsg->msg_md->md_iov.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); - kiblnd_tx_done(ni, tx); - return -EIO; - } + 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); + if (rc != 0) { + CERROR("Can't setup GET sink for %s: %d\n", + libcfs_nid2str(target.nid), rc); + kiblnd_tx_done(ni, tx); + return -EIO; + } - nob = offsetof(kib_get_msg_t, ibgm_rd.rd_frags[tx->tx_nfrags]); - ibmsg->ibm_u.get.ibgm_cookie = tx->tx_cookie; - ibmsg->ibm_u.get.ibgm_hdr = *hdr; + nob = offsetof(kib_get_msg_t, ibgm_rd.rd_frags[rd->rd_nfrags]); + ibmsg->ibm_u.get.ibgm_cookie = tx->tx_cookie; + ibmsg->ibm_u.get.ibgm_hdr = *hdr; kiblnd_init_tx_msg(ni, tx, IBLND_MSG_GET_REQ, nob); @@ -1629,7 +1645,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; @@ -1700,19 +1716,18 @@ kiblnd_recv (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg, int delayed, kib_msg_t *rxmsg = rx->rx_msg; kib_conn_t *conn = rx->rx_conn; kib_tx_t *tx; - kib_msg_t *txmsg; - int nob; - int post_credit = IBLND_POSTRX_PEER_CREDIT; - int rc = 0; + int nob; + int post_credit = IBLND_POSTRX_PEER_CREDIT; + int rc = 0; - LASSERT (mlen <= rlen); - LASSERT (!cfs_in_interrupt()); - /* Either all pages or all vaddrs */ - LASSERT (!(kiov != NULL && iov != NULL)); + LASSERT (mlen <= rlen); + LASSERT (!in_interrupt()); + /* Either all pages or all vaddrs */ + LASSERT (!(kiov != NULL && iov != NULL)); - switch (rxmsg->ibm_type) { - default: - LBUG(); + switch (rxmsg->ibm_type) { + default: + LBUG(); case IBLND_MSG_IMMEDIATE: nob = offsetof(kib_msg_t, ibm_u.immediate.ibim_payload[rlen]); @@ -1737,7 +1752,10 @@ kiblnd_recv (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg, int delayed, lnet_finalize (ni, lntmsg, 0); break; - case IBLND_MSG_PUT_REQ: + case IBLND_MSG_PUT_REQ: { + kib_msg_t *txmsg; + kib_rdma_desc_t *rd; + if (mlen == 0) { lnet_finalize(ni, lntmsg, 0); kiblnd_send_completion(rx->rx_conn, IBLND_MSG_PUT_NAK, 0, @@ -1754,28 +1772,27 @@ kiblnd_recv (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg, int delayed, break; } - txmsg = tx->tx_msg; - if (kiov == NULL) - rc = kiblnd_setup_rd_iov(ni, tx, - &txmsg->ibm_u.putack.ibpam_rd, - niov, iov, offset, mlen); - else - rc = kiblnd_setup_rd_kiov(ni, tx, - &txmsg->ibm_u.putack.ibpam_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); - kiblnd_tx_done(ni, tx); - /* tell peer it's over */ - kiblnd_send_completion(rx->rx_conn, IBLND_MSG_PUT_NAK, rc, - rxmsg->ibm_u.putreq.ibprm_cookie); - break; - } + 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); + if (rc != 0) { + CERROR("Can't setup PUT sink for %s: %d\n", + libcfs_nid2str(conn->ibc_peer->ibp_nid), rc); + kiblnd_tx_done(ni, tx); + /* tell peer it's over */ + kiblnd_send_completion(rx->rx_conn, IBLND_MSG_PUT_NAK, rc, + rxmsg->ibm_u.putreq.ibprm_cookie); + break; + } - nob = offsetof(kib_putack_msg_t, ibpam_rd.rd_frags[tx->tx_nfrags]); - txmsg->ibm_u.putack.ibpam_src_cookie = rxmsg->ibm_u.putreq.ibprm_cookie; - txmsg->ibm_u.putack.ibpam_dst_cookie = tx->tx_cookie; + nob = offsetof(kib_putack_msg_t, ibpam_rd.rd_frags[rd->rd_nfrags]); + txmsg->ibm_u.putack.ibpam_src_cookie = rxmsg->ibm_u.putreq.ibprm_cookie; + txmsg->ibm_u.putack.ibpam_dst_cookie = tx->tx_cookie; kiblnd_init_tx_msg(ni, tx, IBLND_MSG_PUT_ACK, nob); @@ -1786,6 +1803,7 @@ kiblnd_recv (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg, int delayed, /* reposted buffer reserved for PUT_DONE */ post_credit = IBLND_POSTRX_NO_CREDIT; break; + } case IBLND_MSG_GET_REQ: if (lntmsg != NULL) { @@ -1805,32 +1823,32 @@ kiblnd_recv (lnet_ni_t *ni, void *private, lnet_msg_t *lntmsg, int delayed, } int -kiblnd_thread_start (int (*fn)(void *arg), void *arg) +kiblnd_thread_start(int (*fn)(void *arg), void *arg, char *name) { - long pid = cfs_create_thread (fn, arg, 0); + struct task_struct *task = kthread_run(fn, arg, name); - if (pid < 0) - return ((int)pid); + if (IS_ERR(task)) + return PTR_ERR(task); - cfs_atomic_inc (&kiblnd_data.kib_nthreads); - return (0); + 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() */ - peer->ibp_last_alive = cfs_time_current(); - cfs_mb(); + /* This is racy, but everyone's only writing cfs_time_current() */ + peer->ibp_last_alive = cfs_time_current(); + smp_mb(); } -void +static void kiblnd_peer_notify (kib_peer_t *peer) { int error = 0; @@ -1839,7 +1857,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 +1896,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); @@ -1909,17 +1929,17 @@ kiblnd_close_conn_locked (kib_conn_t *conn, int error) kiblnd_set_conn_state(conn, IBLND_CONN_CLOSING); - if (error != 0 && - kiblnd_dev_can_failover(dev)) { - cfs_list_add_tail(&dev->ibd_fail_list, - &kiblnd_data.kib_failed_devs); - cfs_waitq_signal(&kiblnd_data.kib_failover_waitq); - } + if (error != 0 && + kiblnd_dev_can_failover(dev)) { + 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); - cfs_waitq_signal(&kiblnd_data.kib_connd_waitq); + 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,164 +1956,164 @@ 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; kib_rx_t *rx; - LASSERT(!cfs_in_interrupt()); + LASSERT(!in_interrupt()); 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); write_lock_irqsave(&kiblnd_data.kib_global_lock, flags); - } + } 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 (!cfs_in_interrupt()); - LASSERT (conn->ibc_state > IBLND_CONN_INIT); + LASSERT (!in_interrupt()); + LASSERT (conn->ibc_state > IBLND_CONN_INIT); - kiblnd_set_conn_state(conn, IBLND_CONN_DISCONNECTED); + kiblnd_set_conn_state(conn, IBLND_CONN_DISCONNECTED); - /* abort_receives moves QP state to IB_QPS_ERR. This is only required - * for connections that didn't get as far as being connected, because - * rdma_disconnect() does this for free. */ - kiblnd_abort_receives(conn); + /* abort_receives moves QP state to IB_QPS_ERR. This is only required + * for connections that didn't get as far as being connected, because + * rdma_disconnect() does this for free. */ + kiblnd_abort_receives(conn); - /* Complete all tx descs not waiting for sends to complete. - * NB we should be safe from RDMA now that the QP has changed state */ + /* Complete all tx descs not waiting for sends to complete. + * NB we should be safe from RDMA now that the QP has changed state */ - kiblnd_abort_txs(conn, &conn->ibc_tx_noops); - kiblnd_abort_txs(conn, &conn->ibc_tx_queue); - kiblnd_abort_txs(conn, &conn->ibc_tx_queue_rsrvd); - kiblnd_abort_txs(conn, &conn->ibc_tx_queue_nocred); - kiblnd_abort_txs(conn, &conn->ibc_active_txs); + kiblnd_abort_txs(conn, &conn->ibc_tx_noops); + kiblnd_abort_txs(conn, &conn->ibc_tx_queue); + kiblnd_abort_txs(conn, &conn->ibc_tx_queue_rsrvd); + kiblnd_abort_txs(conn, &conn->ibc_tx_queue_nocred); + kiblnd_abort_txs(conn, &conn->ibc_active_txs); - kiblnd_handle_early_rxs(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 (!cfs_in_interrupt()); + LASSERT (error != 0); + LASSERT (!in_interrupt()); write_lock_irqsave(&kiblnd_data.kib_global_lock, flags); - if (active) { - LASSERT (peer->ibp_connecting > 0); - peer->ibp_connecting--; - } else { - LASSERT (peer->ibp_accepting > 0); - peer->ibp_accepting--; - } + if (active) { + LASSERT (peer->ibp_connecting > 0); + peer->ibp_connecting--; + } else { + LASSERT (peer->ibp_accepting > 0); + peer->ibp_accepting--; + } - if (peer->ibp_connecting != 0 || - peer->ibp_accepting != 0) { - /* another connection attempt under way... */ + if (peer->ibp_connecting != 0 || + 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); - CDEBUG(D_NET,"%s: active(%d), version(%x), status(%d)\n", - libcfs_nid2str(peer->ibp_nid), active, - conn->ibc_version, status); + CDEBUG(D_NET,"%s: active(%d), version(%x), status(%d)\n", + libcfs_nid2str(peer->ibp_nid), active, + conn->ibc_version, status); - LASSERT (!cfs_in_interrupt()); - LASSERT ((conn->ibc_state == IBLND_CONN_ACTIVE_CONNECT && - peer->ibp_connecting > 0) || - (conn->ibc_state == IBLND_CONN_PASSIVE_WAIT && - peer->ibp_accepting > 0)); + LASSERT (!in_interrupt()); + LASSERT ((conn->ibc_state == IBLND_CONN_ACTIVE_CONNECT && + peer->ibp_connecting > 0) || + (conn->ibc_state == IBLND_CONN_PASSIVE_WAIT && + peer->ibp_accepting > 0)); LIBCFS_FREE(conn->ibc_connvars, sizeof(*conn->ibc_connvars)); conn->ibc_connvars = NULL; @@ -2112,14 +2132,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 +2154,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 +2175,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 +2189,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,8 +2200,8 @@ kiblnd_reject(struct rdma_cm_id *cmid, kib_rej_t *rej) CWARN("Error %d sending reject\n", rc); } -int -kiblnd_passive_connect (struct rdma_cm_id *cmid, void *priv, int priv_nob) +static int +kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob) { rwlock_t *g_lock = &kiblnd_data.kib_global_lock; kib_msg_t *reqmsg = priv; @@ -2195,15 +2215,15 @@ kiblnd_passive_connect (struct rdma_cm_id *cmid, void *priv, int priv_nob) lnet_nid_t nid; struct rdma_conn_param cp; kib_rej_t rej; - int version = IBLND_MSG_VERSION; - unsigned long flags; - int rc; - struct sockaddr_in *peer_addr; - LASSERT (!cfs_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 = (kib_dev_t *)cmid->context; - LASSERT (ibdev != NULL); + /* cmid inherits 'context' from the corresponding listener id */ + ibdev = (kib_dev_t *)cmid->context; + LASSERT (ibdev != NULL); memset(&rej, 0, sizeof(rej)); rej.ibr_magic = IBLND_MSG_MAGIC; @@ -2213,9 +2233,9 @@ kiblnd_passive_connect (struct rdma_cm_id *cmid, void *priv, int priv_nob) 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's port (%u.%u.%u.%u:%hu) is not privileged\n", - HIPQUAD(ip), ntohs(peer_addr->sin_port)); + __u32 ip = ntohl(peer_addr->sin_addr.s_addr); + CERROR("Peer's port (%pI4h:%hu) is not privileged\n", + &ip, ntohs(peer_addr->sin_port)); goto failed; } @@ -2259,11 +2279,11 @@ kiblnd_passive_connect (struct rdma_cm_id *cmid, void *priv, int priv_nob) 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 %s on %s (%s:%d:%u.%u.%u.%u): " + CERROR("Can't accept %s on %s (%s:%d:%pI4h): " "bad dst nid %s\n", libcfs_nid2str(nid), ni == NULL ? "NA" : libcfs_nid2str(ni->ni_nid), ibdev->ibd_ifname, ibdev->ibd_nnets, - HIPQUAD(ibdev->ibd_ifip), + &ibdev->ibd_ifip, libcfs_nid2str(reqmsg->ibm_dstnid)); goto failed; @@ -2384,7 +2404,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 +2474,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 +2493,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,19 +2538,19 @@ 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; + kib_peer_t *peer = conn->ibc_peer; - LASSERT (!cfs_in_interrupt()); - LASSERT (conn->ibc_state == IBLND_CONN_ACTIVE_CONNECT); + LASSERT (!in_interrupt()); + LASSERT (conn->ibc_state == IBLND_CONN_ACTIVE_CONNECT); - switch (reason) { - case IB_CM_REJ_STALE_CONN: - kiblnd_reconnect(conn, IBLND_MSG_VERSION, 0, - IBLND_REJECT_CONN_STALE, NULL); - break; + switch (reason) { + case IB_CM_REJ_STALE_CONN: + kiblnd_reconnect(conn, IBLND_MSG_VERSION, 0, + IBLND_REJECT_CONN_STALE, NULL); + break; case IB_CM_REJ_INVALID_SERVICE_ID: CNETERR("%s rejected: no listener at %d\n", @@ -2615,14 +2635,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 +2677,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 +2776,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 +3015,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 +3051,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 +3085,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,59 +3110,58 @@ 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 (!cfs_in_interrupt()); - LASSERT (current == kiblnd_data.kib_connd); - LASSERT (conn->ibc_state == IBLND_CONN_CLOSING); + LASSERT (!in_interrupt()); + LASSERT (current == kiblnd_data.kib_connd); + LASSERT (conn->ibc_state == IBLND_CONN_CLOSING); - rdma_disconnect(conn->ibc_cmid); - kiblnd_finalise_conn(conn); + rdma_disconnect(conn->ibc_cmid); + kiblnd_finalise_conn(conn); - kiblnd_peer_notify(conn->ibc_peer); + kiblnd_peer_notify(conn->ibc_peer); } int kiblnd_connd (void *arg) { - cfs_waitlink_t wait; - unsigned long flags; - kib_conn_t *conn; - int timeout; - int i; - int dropped_lock; - int peer_index = 0; - unsigned long deadline = jiffies; + wait_queue_t wait; + unsigned long flags; + kib_conn_t *conn; + int timeout; + int i; + int dropped_lock; + int peer_index = 0; + unsigned long deadline = jiffies; - cfs_daemonize ("kiblnd_connd"); - cfs_block_allsigs (); + cfs_block_allsigs(); - cfs_waitlink_init (&wait); - kiblnd_data.kib_connd = current; + init_waitqueue_entry(&wait, current); + kiblnd_data.kib_connd = current; spin_lock_irqsave(&kiblnd_data.kib_connd_lock, flags); @@ -3147,11 +3169,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); @@ -3162,10 +3184,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); @@ -3201,13 +3223,13 @@ kiblnd_connd (void *arg) if (chunk == 0) chunk = 1; - for (i = 0; i < chunk; i++) { - kiblnd_check_conns(peer_index); - peer_index = (peer_index + 1) % - kiblnd_data.kib_peer_hash_size; - } + for (i = 0; i < chunk; i++) { + kiblnd_check_conns(peer_index); + peer_index = (peer_index + 1) % + kiblnd_data.kib_peer_hash_size; + } - deadline += p * CFS_HZ; + deadline += msecs_to_jiffies(p * MSEC_PER_SEC); spin_lock_irqsave(&kiblnd_data.kib_connd_lock, flags); } @@ -3215,14 +3237,14 @@ kiblnd_connd (void *arg) continue; /* Nothing to do for 'timeout' */ - cfs_set_current_state(CFS_TASK_INTERRUPTIBLE); - cfs_waitq_add(&kiblnd_data.kib_connd_waitq, &wait); + set_current_state(TASK_INTERRUPTIBLE); + add_wait_queue(&kiblnd_data.kib_connd_waitq, &wait); spin_unlock_irqrestore(&kiblnd_data.kib_connd_lock, flags); - cfs_waitq_timedwait(&wait, CFS_TASK_INTERRUPTIBLE, timeout); + schedule_timeout(timeout); - cfs_set_current_state(CFS_TASK_RUNNING); - cfs_waitq_del(&kiblnd_data.kib_connd_waitq, &wait); + set_current_state(TASK_RUNNING); + remove_wait_queue(&kiblnd_data.kib_connd_waitq, &wait); spin_lock_irqsave(&kiblnd_data.kib_connd_lock, flags); } @@ -3250,7 +3272,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)) { @@ -3302,10 +3324,10 @@ 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 (cfs_waitq_active(&sched->ibs_waitq)) - cfs_waitq_signal(&sched->ibs_waitq); + if (waitqueue_active(&sched->ibs_waitq)) + wake_up(&sched->ibs_waitq); } spin_unlock_irqrestore(&sched->ibs_lock, flags); @@ -3326,30 +3348,25 @@ kiblnd_scheduler(void *arg) long id = (long)arg; struct kib_sched_info *sched; kib_conn_t *conn; - cfs_waitlink_t wait; + wait_queue_t wait; unsigned long flags; struct ib_wc wc; - char name[20]; int did_something; int busy_loops = 0; int rc; - snprintf(name, sizeof(name), "kiblnd_sd_%02ld_%02ld", - KIB_THREAD_CPT(id), KIB_THREAD_TID(id)); - - cfs_daemonize(name); cfs_block_allsigs(); - cfs_waitlink_init(&wait); + init_waitqueue_entry(&wait, current); sched = kiblnd_data.kib_scheds[KIB_THREAD_CPT(id)]; rc = cfs_cpt_bind(lnet_cpt_table(), sched->ibs_cpt); if (rc != 0) { - CWARN("Failed to bind %s on CPT %d, please verify whether " + CWARN("Failed to bind on CPT %d, please verify whether " "all CPUs are healthy and reload modules if necessary, " "otherwise your system might under risk of low " - "performance\n", name, sched->ibs_cpt); + "performance\n", sched->ibs_cpt); } spin_lock_irqsave(&sched->ibs_lock, flags); @@ -3358,7 +3375,7 @@ kiblnd_scheduler(void *arg) if (busy_loops++ >= IBLND_RESCHED) { spin_unlock_irqrestore(&sched->ibs_lock, flags); - cfs_cond_resched(); + cond_resched(); busy_loops = 0; spin_lock_irqsave(&sched->ibs_lock, flags); @@ -3366,12 +3383,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); @@ -3413,10 +3430,10 @@ 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 (cfs_waitq_active(&sched->ibs_waitq)) - cfs_waitq_signal(&sched->ibs_waitq); + if (waitqueue_active(&sched->ibs_waitq)) + wake_up(&sched->ibs_waitq); } else { conn->ibc_scheduled = 0; } @@ -3435,15 +3452,15 @@ kiblnd_scheduler(void *arg) if (did_something) continue; - cfs_set_current_state(CFS_TASK_INTERRUPTIBLE); - cfs_waitq_add_exclusive(&sched->ibs_waitq, &wait); + set_current_state(TASK_INTERRUPTIBLE); + add_wait_queue_exclusive(&sched->ibs_waitq, &wait); spin_unlock_irqrestore(&sched->ibs_lock, flags); - cfs_waitq_wait(&wait, CFS_TASK_INTERRUPTIBLE); + schedule(); busy_loops = 0; - cfs_waitq_del(&sched->ibs_waitq, &wait); - cfs_set_current_state(CFS_TASK_RUNNING); + remove_wait_queue(&sched->ibs_waitq, &wait); + set_current_state(TASK_RUNNING); spin_lock_irqsave(&sched->ibs_lock, flags); } @@ -3457,24 +3474,23 @@ int kiblnd_failover_thread(void *arg) { rwlock_t *glock = &kiblnd_data.kib_global_lock; - kib_dev_t *dev; - cfs_waitlink_t wait; - unsigned long flags; - int rc; + kib_dev_t *dev; + wait_queue_t wait; + unsigned long flags; + int rc; - LASSERT (*kiblnd_tunables.kib_dev_failover != 0); + LASSERT(*kiblnd_tunables.kib_dev_failover != 0); - cfs_daemonize ("kiblnd_failover"); - cfs_block_allsigs (); + cfs_block_allsigs(); - cfs_waitlink_init(&wait); + init_waitqueue_entry(&wait, current); write_lock_irqsave(glock, flags); while (!kiblnd_data.kib_shutdown) { 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)) @@ -3484,7 +3500,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); @@ -3503,7 +3519,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); } @@ -3511,16 +3527,16 @@ 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); - cfs_set_current_state(CFS_TASK_INTERRUPTIBLE); - cfs_waitq_add(&kiblnd_data.kib_failover_waitq, &wait); + set_current_state(TASK_INTERRUPTIBLE); + add_wait_queue(&kiblnd_data.kib_failover_waitq, &wait); write_unlock_irqrestore(glock, flags); rc = schedule_timeout(long_sleep ? cfs_time_seconds(10) : cfs_time_seconds(1)); - cfs_set_current_state(CFS_TASK_RUNNING); - cfs_waitq_del(&kiblnd_data.kib_failover_waitq, &wait); + set_current_state(TASK_RUNNING); + remove_wait_queue(&kiblnd_data.kib_failover_waitq, &wait); write_lock_irqsave(glock, flags); if (!long_sleep || rc != 0) @@ -3530,9 +3546,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); } }