From patchwork Tue Sep 25 01:07:15 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: NeilBrown X-Patchwork-Id: 10614203 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 5E544913 for ; Tue, 25 Sep 2018 15:22:44 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 38A232A725 for ; Tue, 25 Sep 2018 15:22:44 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 2A4972A789; Tue, 25 Sep 2018 15:22:44 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-2.9 required=2.0 tests=BAYES_00,MAILING_LIST_MULTI, RCVD_IN_DNSWL_NONE autolearn=ham version=3.3.1 Received: from pdx1-mailman02.dreamhost.com (pdx1-mailman02.dreamhost.com [64.90.62.194]) (using TLSv1.2 with cipher DHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id 730792A725 for ; Tue, 25 Sep 2018 15:22:37 +0000 (UTC) Received: from pdx1-mailman02.dreamhost.com (localhost [IPv6:::1]) by pdx1-mailman02.dreamhost.com (Postfix) with ESMTP id E862921F78F; Tue, 25 Sep 2018 08:22:36 -0700 (PDT) X-Original-To: lustre-devel@lists.lustre.org Delivered-To: lustre-devel-lustre.org@pdx1-mailman02.dreamhost.com Received: from mx1.suse.de (mx2.suse.de [195.135.220.15]) by pdx1-mailman02.dreamhost.com (Postfix) with ESMTP id EA7794C41BB for ; Mon, 24 Sep 2018 18:11:36 -0700 (PDT) X-Virus-Scanned: by amavisd-new at test-mx.suse.de Received: from relay2.suse.de (unknown [195.135.220.254]) by mx1.suse.de (Postfix) with ESMTP id F4056B032; Tue, 25 Sep 2018 01:11:35 +0000 (UTC) From: NeilBrown To: Oleg Drokin , Doug Oucharek , James Simmons , Andreas Dilger Date: Tue, 25 Sep 2018 11:07:15 +1000 Message-ID: <153783763547.32103.18087278859321916658.stgit@noble> In-Reply-To: <153783752960.32103.8394391715843917125.stgit@noble> References: <153783752960.32103.8394391715843917125.stgit@noble> User-Agent: StGit/0.17.1-dirty MIME-Version: 1.0 X-Mailman-Approved-At: Tue, 25 Sep 2018 08:22:34 -0700 Subject: [lustre-devel] [PATCH 16/34] LU-7734 lnet: rename LND peer to peer_ni X-BeenThere: lustre-devel@lists.lustre.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: "For discussing Lustre software development." List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Lustre Development List Errors-To: lustre-devel-bounces@lists.lustre.org Sender: "lustre-devel" X-Virus-Scanned: ClamAV using ClamSMTP From: Amir Shehata Patch to rename LND peers to peer_ni to reflect the fact that these constructs reflect an actual connection between a local NI and remote peer NI. Signed-off-by: Amir Shehata Change-Id: I1c25a12eae61d8822a8c4ada2e077a5b2011ba22 Reviewed-on: http://review.whamcloud.com/19307 Reviewed-by: Doug Oucharek Tested-by: Doug Oucharek Signed-off-by: NeilBrown --- .../staging/lustre/lnet/klnds/o2iblnd/o2iblnd.c | 232 ++++--- .../staging/lustre/lnet/klnds/o2iblnd/o2iblnd.h | 118 ++-- .../staging/lustre/lnet/klnds/o2iblnd/o2iblnd_cb.c | 512 ++++++++------- .../staging/lustre/lnet/klnds/socklnd/socklnd.c | 662 ++++++++++---------- .../staging/lustre/lnet/klnds/socklnd/socklnd.h | 66 +- .../staging/lustre/lnet/klnds/socklnd/socklnd_cb.c | 207 +++--- .../lustre/lnet/klnds/socklnd/socklnd_lib.c | 4 .../lustre/lnet/klnds/socklnd/socklnd_proto.c | 14 8 files changed, 928 insertions(+), 887 deletions(-) diff --git a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.c b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.c index 64df49146413..71256500f245 100644 --- a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.c +++ b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.c @@ -258,7 +258,7 @@ int kiblnd_unpack_msg(struct kib_msg *msg, int nob) msg->ibm_cksum = msg_cksum; if (flip) { - /* leave magic unflipped as a clue to peer endianness */ + /* leave magic unflipped as a clue to peer_ni endianness */ msg->ibm_version = version; BUILD_BUG_ON(sizeof(msg->ibm_type) != 1); BUILD_BUG_ON(sizeof(msg->ibm_credits) != 1); @@ -315,10 +315,10 @@ int kiblnd_unpack_msg(struct kib_msg *msg, int nob) return 0; } -int kiblnd_create_peer(struct lnet_ni *ni, struct kib_peer **peerp, +int kiblnd_create_peer(struct lnet_ni *ni, struct kib_peer_ni **peerp, lnet_nid_t nid) { - struct kib_peer *peer; + struct kib_peer_ni *peer_ni; struct kib_net *net = ni->ni_data; int cpt = lnet_cpt_of_nid(nid, ni); unsigned long flags; @@ -326,23 +326,23 @@ int kiblnd_create_peer(struct lnet_ni *ni, struct kib_peer **peerp, LASSERT(net); LASSERT(nid != LNET_NID_ANY); - peer = kzalloc_cpt(sizeof(*peer), GFP_NOFS, cpt); - if (!peer) { - CERROR("Cannot allocate peer\n"); + peer_ni = kzalloc_cpt(sizeof(*peer_ni), GFP_NOFS, cpt); + if (!peer_ni) { + CERROR("Cannot allocate peer_ni\n"); return -ENOMEM; } - peer->ibp_ni = ni; - peer->ibp_nid = nid; - peer->ibp_error = 0; - peer->ibp_last_alive = 0; - peer->ibp_max_frags = kiblnd_cfg_rdma_frags(peer->ibp_ni); - peer->ibp_queue_depth = ni->ni_net->net_tunables.lct_peer_tx_credits; - atomic_set(&peer->ibp_refcount, 1); /* 1 ref for caller */ + peer_ni->ibp_ni = ni; + peer_ni->ibp_nid = nid; + peer_ni->ibp_error = 0; + peer_ni->ibp_last_alive = 0; + peer_ni->ibp_max_frags = kiblnd_cfg_rdma_frags(peer_ni->ibp_ni); + peer_ni->ibp_queue_depth = ni->ni_net->net_tunables.lct_peer_tx_credits; + atomic_set(&peer_ni->ibp_refcount, 1); /* 1 ref for caller */ - INIT_LIST_HEAD(&peer->ibp_list); /* not in the peer table yet */ - INIT_LIST_HEAD(&peer->ibp_conns); - INIT_LIST_HEAD(&peer->ibp_tx_queue); + INIT_LIST_HEAD(&peer_ni->ibp_list); + INIT_LIST_HEAD(&peer_ni->ibp_conns); + INIT_LIST_HEAD(&peer_ni->ibp_tx_queue); write_lock_irqsave(&kiblnd_data.kib_global_lock, flags); @@ -354,93 +354,94 @@ int kiblnd_create_peer(struct lnet_ni *ni, struct kib_peer **peerp, write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags); - *peerp = peer; + *peerp = peer_ni; return 0; } -void kiblnd_destroy_peer(struct kib_peer *peer) +void kiblnd_destroy_peer(struct kib_peer_ni *peer_ni) { - struct kib_net *net = peer->ibp_ni->ni_data; + struct kib_net *net = peer_ni->ibp_ni->ni_data; LASSERT(net); - LASSERT(!atomic_read(&peer->ibp_refcount)); - LASSERT(!kiblnd_peer_active(peer)); - LASSERT(kiblnd_peer_idle(peer)); - LASSERT(list_empty(&peer->ibp_tx_queue)); + LASSERT(!atomic_read(&peer_ni->ibp_refcount)); + LASSERT(!kiblnd_peer_active(peer_ni)); + LASSERT(kiblnd_peer_idle(peer_ni)); + LASSERT(list_empty(&peer_ni->ibp_tx_queue)); - kfree(peer); + kfree(peer_ni); /* - * NB a peer's connections keep a reference on their peer until + * NB a peer_ni's connections keep a reference on their peer_ni until * they are destroyed, so we can be assured that _all_ state to do - * with this peer has been cleaned up when its refcount drops to + * with this peer_ni has been cleaned up when its refcount drops to * zero. */ atomic_dec(&net->ibn_npeers); } -struct kib_peer *kiblnd_find_peer_locked(struct lnet_ni *ni, lnet_nid_t nid) +struct kib_peer_ni *kiblnd_find_peer_locked(struct lnet_ni *ni, lnet_nid_t nid) { /* * the caller is responsible for accounting the additional reference * that this creates */ struct list_head *peer_list = kiblnd_nid2peerlist(nid); - struct kib_peer *peer; + struct kib_peer_ni *peer_ni; - list_for_each_entry(peer, peer_list, ibp_list) { - LASSERT(!kiblnd_peer_idle(peer)); + list_for_each_entry(peer_ni, peer_list, ibp_list) { + LASSERT(!kiblnd_peer_idle(peer_ni)); /* - * Match a peer if its NID and the NID of the local NI it + * Match a peer_ni if its NID and the NID of the local NI it * communicates over are the same. Otherwise don't match - * the peer, which will result in a new lnd peer being + * the peer_ni, which will result in a new lnd peer_ni being * created. */ - if (peer->ibp_nid != nid || - peer->ibp_ni->ni_nid != ni->ni_nid) + if (peer_ni->ibp_nid != nid || + peer_ni->ibp_ni->ni_nid != ni->ni_nid) continue; - CDEBUG(D_NET, "got peer [%p] -> %s (%d) version: %x\n", - peer, libcfs_nid2str(nid), - atomic_read(&peer->ibp_refcount), - peer->ibp_version); - return peer; + CDEBUG(D_NET, "got peer_ni [%p] -> %s (%d) version: %x\n", + peer_ni, libcfs_nid2str(nid), + atomic_read(&peer_ni->ibp_refcount), + peer_ni->ibp_version); + return peer_ni; } return NULL; } -void kiblnd_unlink_peer_locked(struct kib_peer *peer) +void kiblnd_unlink_peer_locked(struct kib_peer_ni *peer_ni) { - LASSERT(list_empty(&peer->ibp_conns)); + LASSERT(list_empty(&peer_ni->ibp_conns)); - LASSERT(kiblnd_peer_active(peer)); - list_del_init(&peer->ibp_list); + LASSERT(kiblnd_peer_active(peer_ni)); + list_del_init(&peer_ni->ibp_list); /* lose peerlist's ref */ - kiblnd_peer_decref(peer); + kiblnd_peer_decref(peer_ni); } static int kiblnd_get_peer_info(struct lnet_ni *ni, int index, lnet_nid_t *nidp, int *count) { - struct kib_peer *peer; + struct kib_peer_ni *peer_ni; int i; unsigned long flags; read_lock_irqsave(&kiblnd_data.kib_global_lock, flags); for (i = 0; i < kiblnd_data.kib_peer_hash_size; i++) { - list_for_each_entry(peer, &kiblnd_data.kib_peers[i], ibp_list) { - LASSERT(!kiblnd_peer_idle(peer)); + list_for_each_entry(peer_ni, &kiblnd_data.kib_peers[i], + ibp_list) { + LASSERT(!kiblnd_peer_idle(peer_ni)); - if (peer->ibp_ni != ni) + if (peer_ni->ibp_ni != ni) continue; if (index-- > 0) continue; - *nidp = peer->ibp_nid; - *count = atomic_read(&peer->ibp_refcount); + *nidp = peer_ni->ibp_nid; + *count = atomic_read(&peer_ni->ibp_refcount); read_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags); @@ -452,34 +453,33 @@ static int kiblnd_get_peer_info(struct lnet_ni *ni, int index, return -ENOENT; } -static void kiblnd_del_peer_locked(struct kib_peer *peer) +static void kiblnd_del_peer_locked(struct kib_peer_ni *peer_ni) { struct list_head *ctmp; struct list_head *cnxt; struct kib_conn *conn; - if (list_empty(&peer->ibp_conns)) { - kiblnd_unlink_peer_locked(peer); + if (list_empty(&peer_ni->ibp_conns)) { + kiblnd_unlink_peer_locked(peer_ni); } else { - list_for_each_safe(ctmp, cnxt, &peer->ibp_conns) { + list_for_each_safe(ctmp, cnxt, &peer_ni->ibp_conns) { conn = list_entry(ctmp, struct kib_conn, ibc_list); kiblnd_close_conn_locked(conn, 0); } - /* NB closing peer's last conn unlinked it. */ + /* NB closing peer_ni's last conn unlinked it. */ } /* - * NB peer now unlinked; might even be freed if the peer table had the - * last ref on it. + * NB peer_ni now unlinked; might even be freed if the peer_ni + * table had the last ref on it. */ } static int kiblnd_del_peer(struct lnet_ni *ni, lnet_nid_t nid) { LIST_HEAD(zombies); - struct list_head *ptmp; - struct list_head *pnxt; - struct kib_peer *peer; + struct kib_peer_ni *pnxt; + struct kib_peer_ni *peer_ni; int lo; int hi; int i; @@ -497,24 +497,24 @@ static int kiblnd_del_peer(struct lnet_ni *ni, lnet_nid_t nid) } for (i = lo; i <= hi; i++) { - list_for_each_safe(ptmp, pnxt, &kiblnd_data.kib_peers[i]) { - peer = list_entry(ptmp, struct kib_peer, ibp_list); - LASSERT(!kiblnd_peer_idle(peer)); + list_for_each_entry_safe(peer_ni, pnxt, + &kiblnd_data.kib_peers[i], ibp_list) { + LASSERT(!kiblnd_peer_idle(peer_ni)); - if (peer->ibp_ni != ni) + if (peer_ni->ibp_ni != ni) continue; - if (!(nid == LNET_NID_ANY || peer->ibp_nid == nid)) + if (!(nid == LNET_NID_ANY || peer_ni->ibp_nid == nid)) continue; - if (!list_empty(&peer->ibp_tx_queue)) { - LASSERT(list_empty(&peer->ibp_conns)); + if (!list_empty(&peer_ni->ibp_tx_queue)) { + LASSERT(list_empty(&peer_ni->ibp_conns)); - list_splice_init(&peer->ibp_tx_queue, + list_splice_init(&peer_ni->ibp_tx_queue, &zombies); } - kiblnd_del_peer_locked(peer); + kiblnd_del_peer_locked(peer_ni); rc = 0; /* matched something */ } } @@ -528,7 +528,7 @@ static int kiblnd_del_peer(struct lnet_ni *ni, lnet_nid_t nid) static struct kib_conn *kiblnd_get_conn_by_idx(struct lnet_ni *ni, int index) { - struct kib_peer *peer; + struct kib_peer_ni *peer_ni; struct kib_conn *conn; int i; unsigned long flags; @@ -536,13 +536,15 @@ static struct kib_conn *kiblnd_get_conn_by_idx(struct lnet_ni *ni, int index) read_lock_irqsave(&kiblnd_data.kib_global_lock, flags); for (i = 0; i < kiblnd_data.kib_peer_hash_size; i++) { - list_for_each_entry(peer, &kiblnd_data.kib_peers[i], ibp_list) { - LASSERT(!kiblnd_peer_idle(peer)); + list_for_each_entry(peer_ni, &kiblnd_data.kib_peers[i], + ibp_list) { + LASSERT(!kiblnd_peer_idle(peer_ni)); - if (peer->ibp_ni != ni) + if (peer_ni->ibp_ni != ni) continue; - list_for_each_entry(conn, &peer->ibp_conns, ibc_list) { + list_for_each_entry(conn, &peer_ni->ibp_conns, + ibc_list) { if (index-- > 0) continue; @@ -620,20 +622,23 @@ static int kiblnd_get_completion_vector(struct kib_conn *conn, int cpt) return 1; } -struct kib_conn *kiblnd_create_conn(struct kib_peer *peer, struct rdma_cm_id *cmid, +struct kib_conn *kiblnd_create_conn(struct kib_peer_ni *peer_ni, + struct rdma_cm_id *cmid, int state, int version) { /* * CAVEAT EMPTOR: - * If the new conn is created successfully it takes over the caller's - * ref on 'peer'. It also "owns" 'cmid' and destroys it when it itself - * is destroyed. On failure, the caller's ref on 'peer' remains and - * she must dispose of 'cmid'. (Actually I'd block forever if I tried - * to destroy 'cmid' here since I'm called from the CM which still has + * + * If the new conn is created successfully it takes over the + * caller's ref on 'peer_ni'. It also "owns" 'cmid' and + * destroys it when it itself is destroyed. On failure, the + * caller's ref on 'peer_ni' remains and she must dispose of + * 'cmid'. (Actually I'd block forever if I tried to destroy + * 'cmid' here since I'm called from the CM which still has * its ref on 'cmid'). */ rwlock_t *glock = &kiblnd_data.kib_global_lock; - struct kib_net *net = peer->ibp_ni->ni_data; + struct kib_net *net = peer_ni->ibp_ni->ni_data; struct kib_dev *dev; struct ib_qp_init_attr *init_qp_attr; struct kib_sched_info *sched; @@ -650,7 +655,7 @@ struct kib_conn *kiblnd_create_conn(struct kib_peer *peer, struct rdma_cm_id *cm dev = net->ibn_dev; - cpt = lnet_cpt_of_nid(peer->ibp_nid, peer->ibp_ni); + cpt = lnet_cpt_of_nid(peer_ni->ibp_nid, peer_ni->ibp_ni); sched = kiblnd_data.kib_scheds[cpt]; LASSERT(sched->ibs_nthreads > 0); @@ -658,24 +663,24 @@ struct kib_conn *kiblnd_create_conn(struct kib_peer *peer, struct rdma_cm_id *cm init_qp_attr = kzalloc_cpt(sizeof(*init_qp_attr), GFP_NOFS, cpt); if (!init_qp_attr) { CERROR("Can't allocate qp_attr for %s\n", - libcfs_nid2str(peer->ibp_nid)); + libcfs_nid2str(peer_ni->ibp_nid)); goto failed_0; } conn = kzalloc_cpt(sizeof(*conn), GFP_NOFS, cpt); if (!conn) { CERROR("Can't allocate connection for %s\n", - libcfs_nid2str(peer->ibp_nid)); + libcfs_nid2str(peer_ni->ibp_nid)); goto failed_1; } conn->ibc_state = IBLND_CONN_INIT; conn->ibc_version = version; - conn->ibc_peer = peer; /* I take the caller's ref */ + conn->ibc_peer = peer_ni; /* I take the caller's ref */ cmid->context = conn; /* for future CM callbacks */ conn->ibc_cmid = cmid; - conn->ibc_max_frags = peer->ibp_max_frags; - conn->ibc_queue_depth = peer->ibp_queue_depth; + conn->ibc_max_frags = peer_ni->ibp_max_frags; + conn->ibc_queue_depth = peer_ni->ibp_queue_depth; INIT_LIST_HEAD(&conn->ibc_early_rxs); INIT_LIST_HEAD(&conn->ibc_tx_noops); @@ -834,7 +839,7 @@ struct kib_conn *kiblnd_create_conn(struct kib_peer *peer, struct rdma_cm_id *cm void kiblnd_destroy_conn(struct kib_conn *conn) { struct rdma_cm_id *cmid = conn->ibc_cmid; - struct kib_peer *peer = conn->ibc_peer; + struct kib_peer_ni *peer_ni = conn->ibc_peer; int rc; LASSERT(!in_interrupt()); @@ -883,26 +888,26 @@ void kiblnd_destroy_conn(struct kib_conn *conn) /* See CAVEAT EMPTOR above in kiblnd_create_conn */ if (conn->ibc_state != IBLND_CONN_INIT) { - struct kib_net *net = peer->ibp_ni->ni_data; + struct kib_net *net = peer_ni->ibp_ni->ni_data; - kiblnd_peer_decref(peer); + kiblnd_peer_decref(peer_ni); rdma_destroy_id(cmid); atomic_dec(&net->ibn_nconns); } } -int kiblnd_close_peer_conns_locked(struct kib_peer *peer, int why) +int kiblnd_close_peer_conns_locked(struct kib_peer_ni *peer_ni, int why) { struct kib_conn *conn; struct list_head *ctmp; struct list_head *cnxt; int count = 0; - list_for_each_safe(ctmp, cnxt, &peer->ibp_conns) { + list_for_each_safe(ctmp, cnxt, &peer_ni->ibp_conns) { conn = list_entry(ctmp, struct kib_conn, ibc_list); CDEBUG(D_NET, "Closing conn -> %s, version: %x, reason: %d\n", - libcfs_nid2str(peer->ibp_nid), + libcfs_nid2str(peer_ni->ibp_nid), conn->ibc_version, why); kiblnd_close_conn_locked(conn, why); @@ -912,7 +917,7 @@ int kiblnd_close_peer_conns_locked(struct kib_peer *peer, int why) return count; } -int kiblnd_close_stale_conns_locked(struct kib_peer *peer, +int kiblnd_close_stale_conns_locked(struct kib_peer_ni *peer_ni, int version, __u64 incarnation) { struct kib_conn *conn; @@ -920,7 +925,7 @@ int kiblnd_close_stale_conns_locked(struct kib_peer *peer, struct list_head *cnxt; int count = 0; - list_for_each_safe(ctmp, cnxt, &peer->ibp_conns) { + list_for_each_safe(ctmp, cnxt, &peer_ni->ibp_conns) { conn = list_entry(ctmp, struct kib_conn, ibc_list); if (conn->ibc_version == version && @@ -929,7 +934,7 @@ int kiblnd_close_stale_conns_locked(struct kib_peer *peer, CDEBUG(D_NET, "Closing stale conn -> %s version: %x, incarnation:%#llx(%x, %#llx)\n", - libcfs_nid2str(peer->ibp_nid), + libcfs_nid2str(peer_ni->ibp_nid), conn->ibc_version, conn->ibc_incarnation, version, incarnation); @@ -942,9 +947,8 @@ int kiblnd_close_stale_conns_locked(struct kib_peer *peer, static int kiblnd_close_matching_conns(struct lnet_ni *ni, lnet_nid_t nid) { - struct kib_peer *peer; - struct list_head *ptmp; - struct list_head *pnxt; + struct kib_peer_ni *peer_ni; + struct kib_peer_ni *pnxt; int lo; int hi; int i; @@ -962,17 +966,17 @@ static int kiblnd_close_matching_conns(struct lnet_ni *ni, lnet_nid_t nid) } for (i = lo; i <= hi; i++) { - list_for_each_safe(ptmp, pnxt, &kiblnd_data.kib_peers[i]) { - peer = list_entry(ptmp, struct kib_peer, ibp_list); - LASSERT(!kiblnd_peer_idle(peer)); + list_for_each_entry_safe(peer_ni, pnxt, + &kiblnd_data.kib_peers[i], ibp_list) { + LASSERT(!kiblnd_peer_idle(peer_ni)); - if (peer->ibp_ni != ni) + if (peer_ni->ibp_ni != ni) continue; - if (!(nid == LNET_NID_ANY || nid == peer->ibp_nid)) + if (!(nid == LNET_NID_ANY || nid == peer_ni->ibp_nid)) continue; - count += kiblnd_close_peer_conns_locked(peer, 0); + count += kiblnd_close_peer_conns_locked(peer_ni, 0); } } @@ -1043,14 +1047,14 @@ static void kiblnd_query(struct lnet_ni *ni, lnet_nid_t nid, time64_t *when) time64_t last_alive = 0; time64_t now = ktime_get_seconds(); rwlock_t *glock = &kiblnd_data.kib_global_lock; - struct kib_peer *peer; + struct kib_peer_ni *peer_ni; unsigned long flags; read_lock_irqsave(glock, flags); - peer = kiblnd_find_peer_locked(ni, nid); - if (peer) - last_alive = peer->ibp_last_alive; + peer_ni = kiblnd_find_peer_locked(ni, nid); + if (peer_ni) + last_alive = peer_ni->ibp_last_alive; read_unlock_irqrestore(glock, flags); @@ -1058,14 +1062,14 @@ static void kiblnd_query(struct lnet_ni *ni, lnet_nid_t nid, time64_t *when) *when = last_alive; /* - * peer is not persistent in hash, trigger peer creation + * peer_ni is not persistent in hash, trigger peer_ni creation * and connection establishment with a NULL tx */ - if (!peer) + if (!peer_ni) kiblnd_launch_tx(ni, NULL, nid); - CDEBUG(D_NET, "Peer %s %p, alive %lld secs ago\n", - libcfs_nid2str(nid), peer, + CDEBUG(D_NET, "peer_ni %s %p, alive %lld secs ago\n", + libcfs_nid2str(nid), peer_ni, last_alive ? now - last_alive : -1); } @@ -2595,7 +2599,7 @@ static void kiblnd_shutdown(struct lnet_ni *ni) /* nuke all existing peers within this net */ kiblnd_del_peer(ni, LNET_NID_ANY); - /* Wait for all peer state to clean up */ + /* Wait for all peer_ni state to clean up */ i = 2; while (atomic_read(&net->ibn_npeers)) { i++; diff --git a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.h b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.h index 520f586015f4..b1851b529ef8 100644 --- a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.h +++ b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd.h @@ -66,7 +66,7 @@ #include -#define IBLND_PEER_HASH_SIZE 101 /* # peer lists */ +#define IBLND_PEER_HASH_SIZE 101 /* # peer_ni lists */ /* # scheduler loops before reschedule */ #define IBLND_RESCHED 100 @@ -96,8 +96,9 @@ extern struct kib_tunables kiblnd_tunables; #define IBLND_MSG_QUEUE_SIZE_V1 8 /* V1 only : # messages/RDMAs in-flight */ #define IBLND_CREDIT_HIGHWATER_V1 7 /* V1 only : when eagerly to return credits */ -#define IBLND_CREDITS_DEFAULT 8 /* default # of peer credits */ -#define IBLND_CREDITS_MAX ((typeof(((struct kib_msg *)0)->ibm_credits)) - 1) /* Max # of peer credits */ +#define IBLND_CREDITS_DEFAULT 8 /* default # of peer_ni credits */ +/* Max # of peer_ni credits */ +#define IBLND_CREDITS_MAX ((typeof(((struct kib_msg *)0)->ibm_credits)) - 1) /* when eagerly to return credits */ #define IBLND_CREDITS_HIGHWATER(t, v) ((v) == IBLND_MSG_VERSION_1 ? \ @@ -324,7 +325,7 @@ struct kib_data { struct list_head kib_failed_devs; /* list head of failed devices */ wait_queue_head_t kib_failover_waitq; /* schedulers sleep here */ atomic_t kib_nthreads; /* # live threads */ - rwlock_t kib_global_lock; /* stabilize net/dev/peer/conn ops */ + rwlock_t kib_global_lock; /* stabilize net/dev/peer_ni/conn ops */ struct list_head *kib_peers; /* hash table of all my known peers */ int kib_peer_hash_size; /* size of kib_peers */ void *kib_connd; /* the connd task (serialisation assertions) */ @@ -445,7 +446,7 @@ struct kib_rej { __u16 ibr_version; /* sender's version */ __u8 ibr_why; /* reject reason */ __u8 ibr_padding; /* padding */ - __u64 ibr_incarnation; /* incarnation of peer */ + __u64 ibr_incarnation; /* incarnation of peer_ni */ struct kib_connparams ibr_cp; /* connection parameters */ } __packed; @@ -453,11 +454,11 @@ struct kib_rej { #define IBLND_REJECT_CONN_RACE 1 /* You lost connection race */ #define IBLND_REJECT_NO_RESOURCES 2 /* Out of memory/conns etc */ #define IBLND_REJECT_FATAL 3 /* Anything else */ -#define IBLND_REJECT_CONN_UNCOMPAT 4 /* incompatible version peer */ -#define IBLND_REJECT_CONN_STALE 5 /* stale peer */ -/* peer's rdma frags doesn't match mine */ +#define IBLND_REJECT_CONN_UNCOMPAT 4 /* incompatible version peer_ni */ +#define IBLND_REJECT_CONN_STALE 5 /* stale peer_ni */ +/* peer_ni's rdma frags doesn't match mine */ #define IBLND_REJECT_RDMA_FRAGS 6 -/* peer's msg queue size doesn't match mine */ +/* peer_ni's msg queue size doesn't match mine */ #define IBLND_REJECT_MSG_QUEUE_SIZE 7 /***********************************************************************/ @@ -476,7 +477,7 @@ struct kib_rx { /* receive message */ #define IBLND_POSTRX_DONT_POST 0 /* don't post */ #define IBLND_POSTRX_NO_CREDIT 1 /* post: no credits */ -#define IBLND_POSTRX_PEER_CREDIT 2 /* post: give peer back 1 credit */ +#define IBLND_POSTRX_PEER_CREDIT 2 /* post: give peer_ni back 1 credit */ #define IBLND_POSTRX_RSRVD_CREDIT 3 /* post: give self back 1 reserved credit */ struct kib_tx { /* transmit message */ @@ -485,7 +486,7 @@ struct kib_tx { /* transmit message */ struct kib_conn *tx_conn; /* owning conn */ short tx_sending; /* # tx callbacks outstanding */ short tx_queued; /* queued for sending */ - short tx_waiting; /* waiting for peer */ + short tx_waiting; /* waiting for peer_ni */ int tx_status; /* LNET completion status */ ktime_t tx_deadline; /* completion deadline */ __u64 tx_cookie; /* completion cookie */ @@ -510,14 +511,14 @@ struct kib_connvars { struct kib_conn { struct kib_sched_info *ibc_sched; /* scheduler information */ - struct kib_peer *ibc_peer; /* owning peer */ + struct kib_peer_ni *ibc_peer; /* owning peer_ni */ struct kib_hca_dev *ibc_hdev; /* HCA bound on */ - struct list_head ibc_list; /* stash on peer's conn list */ + struct list_head ibc_list; /* stash on peer_ni's conn list */ struct list_head ibc_sched_list; /* schedule for attention */ __u16 ibc_version; /* version of connection */ /* reconnect later */ __u16 ibc_reconnect:1; - __u64 ibc_incarnation; /* which instance of the peer */ + __u64 ibc_incarnation; /* which instance of the peer_ni */ atomic_t ibc_refcount; /* # users */ int ibc_state; /* what's happening */ int ibc_nsends_posted; /* # uncompleted sends */ @@ -562,32 +563,32 @@ struct kib_conn { #define IBLND_CONN_CLOSING 4 /* being closed */ #define IBLND_CONN_DISCONNECTED 5 /* disconnected */ -struct kib_peer { - struct list_head ibp_list; /* stash on global peer list */ +struct kib_peer_ni { + struct list_head ibp_list; /* stash on global peer_ni list */ lnet_nid_t ibp_nid; /* who's on the other end(s) */ struct lnet_ni *ibp_ni; /* LNet interface */ struct list_head ibp_conns; /* all active connections */ struct kib_conn *ibp_next_conn; /* next connection to send on for * round robin */ struct list_head ibp_tx_queue; /* msgs waiting for a conn */ - __u64 ibp_incarnation; /* incarnation of peer */ + __u64 ibp_incarnation; /* incarnation of peer_ni */ /* when (in seconds) I was last alive */ time64_t ibp_last_alive; /* # users */ atomic_t ibp_refcount; - /* version of peer */ + /* version of peer_ni */ __u16 ibp_version; /* current passive connection attempts */ unsigned short ibp_accepting; /* current active connection attempts */ unsigned short ibp_connecting; - /* reconnect this peer later */ + /* reconnect this peer_ni later */ unsigned char ibp_reconnecting; /* counter of how many times we triggered a conn race */ unsigned char ibp_races; - /* # consecutive reconnection attempts to this peer */ + /* # consecutive reconnection attempts to this peer_ni */ unsigned int ibp_reconnected; - /* errno on closing this peer */ + /* errno on closing this peer_ni */ int ibp_error; /* max map_on_demand */ __u16 ibp_max_frags; @@ -694,36 +695,37 @@ do { \ } \ } while (0) -#define kiblnd_peer_addref(peer) \ +#define kiblnd_peer_addref(peer_ni) \ do { \ - CDEBUG(D_NET, "peer[%p] -> %s (%d)++\n", \ - (peer), libcfs_nid2str((peer)->ibp_nid), \ - atomic_read(&(peer)->ibp_refcount)); \ - atomic_inc(&(peer)->ibp_refcount); \ + CDEBUG(D_NET, "peer_ni[%p] -> %s (%d)++\n", \ + (peer_ni), libcfs_nid2str((peer_ni)->ibp_nid), \ + atomic_read(&(peer_ni)->ibp_refcount)); \ + atomic_inc(&(peer_ni)->ibp_refcount); \ } while (0) -#define kiblnd_peer_decref(peer) \ +#define kiblnd_peer_decref(peer_ni) \ do { \ - CDEBUG(D_NET, "peer[%p] -> %s (%d)--\n", \ - (peer), libcfs_nid2str((peer)->ibp_nid), \ - atomic_read(&(peer)->ibp_refcount)); \ - LASSERT_ATOMIC_POS(&(peer)->ibp_refcount); \ - if (atomic_dec_and_test(&(peer)->ibp_refcount)) \ - kiblnd_destroy_peer(peer); \ + CDEBUG(D_NET, "peer_ni[%p] -> %s (%d)--\n", \ + (peer_ni), libcfs_nid2str((peer_ni)->ibp_nid), \ + atomic_read(&(peer_ni)->ibp_refcount)); \ + LASSERT_ATOMIC_POS(&(peer_ni)->ibp_refcount); \ + if (atomic_dec_and_test(&(peer_ni)->ibp_refcount)) \ + kiblnd_destroy_peer(peer_ni); \ } while (0) static inline bool -kiblnd_peer_connecting(struct kib_peer *peer) +kiblnd_peer_connecting(struct kib_peer_ni *peer_ni) { - return peer->ibp_connecting || - peer->ibp_reconnecting || - peer->ibp_accepting; + return peer_ni->ibp_connecting || + peer_ni->ibp_reconnecting || + peer_ni->ibp_accepting; } static inline bool -kiblnd_peer_idle(struct kib_peer *peer) +kiblnd_peer_idle(struct kib_peer_ni *peer_ni) { - return !kiblnd_peer_connecting(peer) && list_empty(&peer->ibp_conns); + return !kiblnd_peer_connecting(peer_ni) && + list_empty(&peer_ni->ibp_conns); } static inline struct list_head * @@ -736,28 +738,28 @@ kiblnd_nid2peerlist(lnet_nid_t nid) } static inline int -kiblnd_peer_active(struct kib_peer *peer) +kiblnd_peer_active(struct kib_peer_ni *peer_ni) { - /* Am I in the peer hash table? */ - return !list_empty(&peer->ibp_list); + /* Am I in the peer_ni hash table? */ + return !list_empty(&peer_ni->ibp_list); } static inline struct kib_conn * -kiblnd_get_conn_locked(struct kib_peer *peer) +kiblnd_get_conn_locked(struct kib_peer_ni *peer_ni) { struct list_head *next; - LASSERT(!list_empty(&peer->ibp_conns)); + LASSERT(!list_empty(&peer_ni->ibp_conns)); /* Advance to next connection, be sure to skip the head node */ - if (!peer->ibp_next_conn || - peer->ibp_next_conn->ibc_list.next == &peer->ibp_conns) - next = peer->ibp_conns.next; + if (!peer_ni->ibp_next_conn || + peer_ni->ibp_next_conn->ibc_list.next == &peer_ni->ibp_conns) + next = peer_ni->ibp_conns.next; else - next = peer->ibp_next_conn->ibc_list.next; - peer->ibp_next_conn = list_entry(next, struct kib_conn, ibc_list); + next = peer_ni->ibp_next_conn->ibc_list.next; + peer_ni->ibp_next_conn = list_entry(next, struct kib_conn, ibc_list); - return peer->ibp_next_conn; + return peer_ni->ibp_next_conn; } static inline int @@ -1013,18 +1015,18 @@ int kiblnd_cm_callback(struct rdma_cm_id *cmid, int kiblnd_translate_mtu(int value); int kiblnd_dev_failover(struct kib_dev *dev); -int kiblnd_create_peer(struct lnet_ni *ni, struct kib_peer **peerp, +int kiblnd_create_peer(struct lnet_ni *ni, struct kib_peer_ni **peerp, lnet_nid_t nid); -void kiblnd_destroy_peer(struct kib_peer *peer); -bool kiblnd_reconnect_peer(struct kib_peer *peer); +void kiblnd_destroy_peer(struct kib_peer_ni *peer_ni); +bool kiblnd_reconnect_peer(struct kib_peer_ni *peer_ni); void kiblnd_destroy_dev(struct kib_dev *dev); -void kiblnd_unlink_peer_locked(struct kib_peer *peer); -struct kib_peer *kiblnd_find_peer_locked(struct lnet_ni *ni, lnet_nid_t nid); -int kiblnd_close_stale_conns_locked(struct kib_peer *peer, +void kiblnd_unlink_peer_locked(struct kib_peer_ni *peer_ni); +struct kib_peer_ni *kiblnd_find_peer_locked(struct lnet_ni *ni, lnet_nid_t nid); +int kiblnd_close_stale_conns_locked(struct kib_peer_ni *peer_ni, int version, __u64 incarnation); -int kiblnd_close_peer_conns_locked(struct kib_peer *peer, int why); +int kiblnd_close_peer_conns_locked(struct kib_peer_ni *peer_ni, int why); -struct kib_conn *kiblnd_create_conn(struct kib_peer *peer, +struct kib_conn *kiblnd_create_conn(struct kib_peer_ni *peer_ni, struct rdma_cm_id *cmid, int state, int version); void kiblnd_destroy_conn(struct kib_conn *conn); diff --git a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_cb.c b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_cb.c index f4b76347e1c6..cb752dcd35d9 100644 --- a/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_cb.c +++ b/drivers/staging/lustre/lnet/klnds/o2iblnd/o2iblnd_cb.c @@ -40,8 +40,9 @@ #define MAX_CONN_RACES_BEFORE_ABORT 20 -static void kiblnd_peer_alive(struct kib_peer *peer); -static void kiblnd_peer_connect_failed(struct kib_peer *peer, int active, int error); +static void kiblnd_peer_alive(struct kib_peer_ni *peer_ni); +static void kiblnd_peer_connect_failed(struct kib_peer_ni *peer_ni, int active, + int error); static void kiblnd_init_tx_msg(struct lnet_ni *ni, struct kib_tx *tx, int type, int body_nob); static int kiblnd_init_rdma(struct kib_conn *conn, struct kib_tx *tx, int type, @@ -62,9 +63,9 @@ kiblnd_tx_done(struct lnet_ni *ni, struct kib_tx *tx) LASSERT(net); LASSERT(!in_interrupt()); - LASSERT(!tx->tx_queued); /* mustn't be queued for sending */ - LASSERT(!tx->tx_sending); /* mustn't be awaiting sent callback */ - LASSERT(!tx->tx_waiting); /* mustn't be awaiting peer response */ + LASSERT(!tx->tx_queued); /* mustn't be queued for sending */ + LASSERT(!tx->tx_sending); /* mustn't be awaiting sent callback */ + LASSERT(!tx->tx_waiting); /* mustn't be awaiting peer_ni response */ LASSERT(tx->tx_pool); kiblnd_unmap_tx(tx); @@ -414,7 +415,7 @@ kiblnd_handle_rx(struct kib_rx *rx) LASSERT(tx->tx_waiting); /* * CAVEAT EMPTOR: I could be racing with tx_complete, but... - * (a) I can overwrite tx_msg since my peer has received it! + * (a) I can overwrite tx_msg since my peer_ni has received it! * (b) tx_waiting set tells tx_complete() it's not done. */ tx->tx_nwrq = 0; /* overwrite PUT_REQ */ @@ -579,8 +580,8 @@ kiblnd_fmr_map_tx(struct kib_net *net, struct kib_tx *tx, struct kib_rdma_desc * } /* - * If rd is not tx_rd, it's going to get sent to a peer, who will need - * the rkey + * If rd is not tx_rd, it's going to get sent to a peer_ni, + * who will need the rkey */ rd->rd_key = tx->fmr.fmr_key; rd->rd_frags[0].rf_addr &= ~hdev->ibh_page_mask; @@ -611,7 +612,7 @@ static int kiblnd_map_tx(struct lnet_ni *ni, struct kib_tx *tx, int i; /* - * If rd is not tx_rd, it's going to get sent to a peer and I'm the + * If rd is not tx_rd, it's going to get sent to a peer_ni and I'm the * RDMA sink */ tx->tx_dmadir = (rd != tx->tx_rd) ? DMA_FROM_DEVICE : DMA_TO_DEVICE; @@ -742,8 +743,8 @@ kiblnd_post_tx_locked(struct kib_conn *conn, struct kib_tx *tx, int credit) __must_hold(&conn->ibc_lock) { struct kib_msg *msg = tx->tx_msg; - struct kib_peer *peer = conn->ibc_peer; - struct lnet_ni *ni = peer->ibp_ni; + struct kib_peer_ni *peer_ni = conn->ibc_peer; + struct lnet_ni *ni = peer_ni->ibp_ni; int ver = conn->ibc_version; int rc; int done; @@ -761,13 +762,13 @@ kiblnd_post_tx_locked(struct kib_conn *conn, struct kib_tx *tx, int credit) if (conn->ibc_nsends_posted == kiblnd_concurrent_sends(ver, ni)) { /* tx completions outstanding... */ CDEBUG(D_NET, "%s: posted enough\n", - libcfs_nid2str(peer->ibp_nid)); + libcfs_nid2str(peer_ni->ibp_nid)); return -EAGAIN; } if (credit && !conn->ibc_credits) { /* no credits */ CDEBUG(D_NET, "%s: no credits\n", - libcfs_nid2str(peer->ibp_nid)); + libcfs_nid2str(peer_ni->ibp_nid)); return -EAGAIN; } @@ -775,7 +776,7 @@ kiblnd_post_tx_locked(struct kib_conn *conn, struct kib_tx *tx, int credit) conn->ibc_credits == 1 && /* last credit reserved */ msg->ibm_type != IBLND_MSG_NOOP) { /* for NOOP */ CDEBUG(D_NET, "%s: not using last credit\n", - libcfs_nid2str(peer->ibp_nid)); + libcfs_nid2str(peer_ni->ibp_nid)); return -EAGAIN; } @@ -793,16 +794,17 @@ kiblnd_post_tx_locked(struct kib_conn *conn, struct kib_tx *tx, int credit) * posted NOOPs complete */ spin_unlock(&conn->ibc_lock); - kiblnd_tx_done(peer->ibp_ni, tx); + kiblnd_tx_done(peer_ni->ibp_ni, tx); spin_lock(&conn->ibc_lock); CDEBUG(D_NET, "%s(%d): redundant or enough NOOP\n", - libcfs_nid2str(peer->ibp_nid), + libcfs_nid2str(peer_ni->ibp_nid), conn->ibc_noops_posted); return 0; } - kiblnd_pack_msg(peer->ibp_ni, msg, ver, conn->ibc_outstanding_credits, - peer->ibp_nid, conn->ibc_incarnation); + kiblnd_pack_msg(peer_ni->ibp_ni, msg, ver, + conn->ibc_outstanding_credits, + peer_ni->ibp_nid, conn->ibc_incarnation); conn->ibc_credits -= credit; conn->ibc_outstanding_credits = 0; @@ -844,7 +846,7 @@ kiblnd_post_tx_locked(struct kib_conn *conn, struct kib_tx *tx, int credit) } LASSERTF(bad->wr_id == kiblnd_ptr2wreqid(tx, IBLND_WID_TX), - "bad wr_id %llx, opc %d, flags %d, peer: %s\n", + "bad wr_id %llx, opc %d, flags %d, peer_ni: %s\n", bad->wr_id, bad->opcode, bad->send_flags, libcfs_nid2str(conn->ibc_peer->ibp_nid)); bad = NULL; @@ -878,15 +880,15 @@ kiblnd_post_tx_locked(struct kib_conn *conn, struct kib_tx *tx, int credit) if (conn->ibc_state == IBLND_CONN_ESTABLISHED) CERROR("Error %d posting transmit to %s\n", - rc, libcfs_nid2str(peer->ibp_nid)); + rc, libcfs_nid2str(peer_ni->ibp_nid)); else CDEBUG(D_NET, "Error %d posting transmit to %s\n", - rc, libcfs_nid2str(peer->ibp_nid)); + rc, libcfs_nid2str(peer_ni->ibp_nid)); kiblnd_close_conn(conn, rc); if (done) - kiblnd_tx_done(peer->ibp_ni, tx); + kiblnd_tx_done(peer_ni->ibp_ni, tx); spin_lock(&conn->ibc_lock); @@ -991,12 +993,12 @@ kiblnd_tx_complete(struct kib_tx *tx, int status) conn->ibc_noops_posted--; if (failed) { - tx->tx_waiting = 0; /* don't wait for peer */ + tx->tx_waiting = 0; /* don't wait for peer_ni */ tx->tx_status = -EIO; } idle = !tx->tx_sending && /* This is the final callback */ - !tx->tx_waiting && /* Not waiting for peer */ + !tx->tx_waiting && /* Not waiting for peer_ni */ !tx->tx_queued; /* Not re-queued (PUT_DONE) */ if (idle) list_del(&tx->tx_list); @@ -1058,7 +1060,7 @@ kiblnd_init_rdma(struct kib_conn *conn, struct kib_tx *tx, int type, type == IBLND_MSG_PUT_DONE); if (kiblnd_rd_size(srcrd) > conn->ibc_max_frags << PAGE_SHIFT) { - CERROR("RDMA is too large for peer %s (%d), src size: %d dst size: %d\n", + CERROR("RDMA is too large for peer_ni %s (%d), src size: %d dst size: %d\n", libcfs_nid2str(conn->ibc_peer->ibp_nid), conn->ibc_max_frags << PAGE_SHIFT, kiblnd_rd_size(srcrd), kiblnd_rd_size(dstrd)); @@ -1080,7 +1082,7 @@ kiblnd_init_rdma(struct kib_conn *conn, struct kib_tx *tx, int type, } if (tx->tx_nwrq >= IBLND_MAX_RDMA_FRAGS) { - CERROR("RDMA has too many fragments for peer %s (%d), src idx/frags: %d/%d dst idx/frags: %d/%d\n", + CERROR("RDMA has too many fragments for peer_ni %s (%d), src idx/frags: %d/%d dst idx/frags: %d/%d\n", libcfs_nid2str(conn->ibc_peer->ibp_nid), IBLND_MAX_RDMA_FRAGS, srcidx, srcrd->rd_nfrags, @@ -1234,24 +1236,24 @@ static int kiblnd_resolve_addr(struct rdma_cm_id *cmid, } static void -kiblnd_connect_peer(struct kib_peer *peer) +kiblnd_connect_peer(struct kib_peer_ni *peer_ni) { struct rdma_cm_id *cmid; struct kib_dev *dev; - struct kib_net *net = peer->ibp_ni->ni_data; + struct kib_net *net = peer_ni->ibp_ni->ni_data; struct sockaddr_in srcaddr; struct sockaddr_in dstaddr; int rc; LASSERT(net); - LASSERT(peer->ibp_connecting > 0); + LASSERT(peer_ni->ibp_connecting > 0); - cmid = kiblnd_rdma_create_id(kiblnd_cm_callback, peer, RDMA_PS_TCP, + cmid = kiblnd_rdma_create_id(kiblnd_cm_callback, peer_ni, RDMA_PS_TCP, IB_QPT_RC); if (IS_ERR(cmid)) { CERROR("Can't create CMID for %s: %ld\n", - libcfs_nid2str(peer->ibp_nid), PTR_ERR(cmid)); + libcfs_nid2str(peer_ni->ibp_nid), PTR_ERR(cmid)); rc = PTR_ERR(cmid); goto failed; } @@ -1264,9 +1266,9 @@ kiblnd_connect_peer(struct kib_peer *peer) memset(&dstaddr, 0, sizeof(dstaddr)); dstaddr.sin_family = AF_INET; dstaddr.sin_port = htons(*kiblnd_tunables.kib_service); - dstaddr.sin_addr.s_addr = htonl(LNET_NIDADDR(peer->ibp_nid)); + dstaddr.sin_addr.s_addr = htonl(LNET_NIDADDR(peer_ni->ibp_nid)); - kiblnd_peer_addref(peer); /* cmid's ref */ + kiblnd_peer_addref(peer_ni); /* cmid's ref */ if (*kiblnd_tunables.kib_use_priv_port) { rc = kiblnd_resolve_addr(cmid, &srcaddr, &dstaddr, @@ -1280,23 +1282,23 @@ kiblnd_connect_peer(struct kib_peer *peer) if (rc) { /* Can't initiate address resolution: */ CERROR("Can't resolve addr for %s: %d\n", - libcfs_nid2str(peer->ibp_nid), rc); + libcfs_nid2str(peer_ni->ibp_nid), rc); goto failed2; } return; failed2: - kiblnd_peer_connect_failed(peer, 1, rc); - kiblnd_peer_decref(peer); /* cmid's ref */ + kiblnd_peer_connect_failed(peer_ni, 1, rc); + kiblnd_peer_decref(peer_ni); /* cmid's ref */ rdma_destroy_id(cmid); return; failed: - kiblnd_peer_connect_failed(peer, 1, rc); + kiblnd_peer_connect_failed(peer_ni, 1, rc); } bool -kiblnd_reconnect_peer(struct kib_peer *peer) +kiblnd_reconnect_peer(struct kib_peer_ni *peer_ni) { rwlock_t *glock = &kiblnd_data.kib_global_lock; char *reason = NULL; @@ -1306,12 +1308,12 @@ kiblnd_reconnect_peer(struct kib_peer *peer) INIT_LIST_HEAD(&txs); write_lock_irqsave(glock, flags); - if (!peer->ibp_reconnecting) { - if (peer->ibp_accepting) + if (!peer_ni->ibp_reconnecting) { + if (peer_ni->ibp_accepting) reason = "accepting"; - else if (peer->ibp_connecting) + else if (peer_ni->ibp_connecting) reason = "connecting"; - else if (!list_empty(&peer->ibp_conns)) + else if (!list_empty(&peer_ni->ibp_conns)) reason = "connected"; else /* connected then closed */ reason = "closed"; @@ -1319,37 +1321,37 @@ kiblnd_reconnect_peer(struct kib_peer *peer) goto no_reconnect; } - LASSERT(!peer->ibp_accepting && !peer->ibp_connecting && - list_empty(&peer->ibp_conns)); - peer->ibp_reconnecting--; + LASSERT(!peer_ni->ibp_accepting && !peer_ni->ibp_connecting && + list_empty(&peer_ni->ibp_conns)); + peer_ni->ibp_reconnecting--; - if (!kiblnd_peer_active(peer)) { - list_splice_init(&peer->ibp_tx_queue, &txs); + if (!kiblnd_peer_active(peer_ni)) { + list_splice_init(&peer_ni->ibp_tx_queue, &txs); reason = "unlinked"; goto no_reconnect; } - peer->ibp_connecting++; - peer->ibp_reconnected++; + peer_ni->ibp_connecting++; + peer_ni->ibp_reconnected++; write_unlock_irqrestore(glock, flags); - kiblnd_connect_peer(peer); + kiblnd_connect_peer(peer_ni); return true; no_reconnect: write_unlock_irqrestore(glock, flags); CWARN("Abort reconnection of %s: %s\n", - libcfs_nid2str(peer->ibp_nid), reason); - kiblnd_txlist_done(peer->ibp_ni, &txs, -ECONNABORTED); + libcfs_nid2str(peer_ni->ibp_nid), reason); + kiblnd_txlist_done(peer_ni->ibp_ni, &txs, -ECONNABORTED); return false; } void kiblnd_launch_tx(struct lnet_ni *ni, struct kib_tx *tx, lnet_nid_t nid) { - struct kib_peer *peer; - struct kib_peer *peer2; + struct kib_peer_ni *peer_ni; + struct kib_peer_ni *peer2; struct kib_conn *conn; rwlock_t *g_lock = &kiblnd_data.kib_global_lock; unsigned long flags; @@ -1370,10 +1372,10 @@ kiblnd_launch_tx(struct lnet_ni *ni, struct kib_tx *tx, lnet_nid_t nid) */ read_lock_irqsave(g_lock, flags); - peer = kiblnd_find_peer_locked(ni, nid); - if (peer && !list_empty(&peer->ibp_conns)) { - /* Found a peer with an established connection */ - conn = kiblnd_get_conn_locked(peer); + peer_ni = kiblnd_find_peer_locked(ni, nid); + if (peer_ni && !list_empty(&peer_ni->ibp_conns)) { + /* Found a peer_ni with an established connection */ + conn = kiblnd_get_conn_locked(peer_ni); kiblnd_conn_addref(conn); /* 1 ref for me... */ read_unlock_irqrestore(g_lock, flags); @@ -1388,17 +1390,17 @@ kiblnd_launch_tx(struct lnet_ni *ni, struct kib_tx *tx, lnet_nid_t nid) /* Re-try with a write lock */ write_lock(g_lock); - peer = kiblnd_find_peer_locked(ni, nid); - if (peer) { - if (list_empty(&peer->ibp_conns)) { - /* found a peer, but it's still connecting... */ - LASSERT(kiblnd_peer_connecting(peer)); + peer_ni = kiblnd_find_peer_locked(ni, nid); + if (peer_ni) { + if (list_empty(&peer_ni->ibp_conns)) { + /* found a peer_ni, but it's still connecting... */ + LASSERT(kiblnd_peer_connecting(peer_ni)); if (tx) list_add_tail(&tx->tx_list, - &peer->ibp_tx_queue); + &peer_ni->ibp_tx_queue); write_unlock_irqrestore(g_lock, flags); } else { - conn = kiblnd_get_conn_locked(peer); + conn = kiblnd_get_conn_locked(peer_ni); kiblnd_conn_addref(conn); /* 1 ref for me... */ write_unlock_irqrestore(g_lock, flags); @@ -1412,10 +1414,10 @@ kiblnd_launch_tx(struct lnet_ni *ni, struct kib_tx *tx, lnet_nid_t nid) write_unlock_irqrestore(g_lock, flags); - /* Allocate a peer ready to add to the peer table and retry */ - rc = kiblnd_create_peer(ni, &peer, nid); + /* Allocate a peer_ni ready to add to the peer_ni table and retry */ + rc = kiblnd_create_peer(ni, &peer_ni, nid); if (rc) { - CERROR("Can't create peer %s\n", libcfs_nid2str(nid)); + CERROR("Can't create peer_ni %s\n", libcfs_nid2str(nid)); if (tx) { tx->tx_status = -EHOSTUNREACH; tx->tx_waiting = 0; @@ -1429,7 +1431,7 @@ kiblnd_launch_tx(struct lnet_ni *ni, struct kib_tx *tx, lnet_nid_t nid) peer2 = kiblnd_find_peer_locked(ni, nid); if (peer2) { if (list_empty(&peer2->ibp_conns)) { - /* found a peer, but it's still connecting... */ + /* found a peer_ni, but it's still connecting... */ LASSERT(kiblnd_peer_connecting(peer2)); if (tx) list_add_tail(&tx->tx_list, @@ -1446,29 +1448,29 @@ kiblnd_launch_tx(struct lnet_ni *ni, struct kib_tx *tx, lnet_nid_t nid) kiblnd_conn_decref(conn); /* ...to here */ } - kiblnd_peer_decref(peer); + kiblnd_peer_decref(peer_ni); return; } - /* Brand new peer */ - LASSERT(!peer->ibp_connecting); - tunables = &peer->ibp_ni->ni_lnd_tunables.lnd_tun_u.lnd_o2ib; - peer->ibp_connecting = tunables->lnd_conns_per_peer; + /* Brand new peer_ni */ + LASSERT(!peer_ni->ibp_connecting); + tunables = &peer_ni->ibp_ni->ni_lnd_tunables.lnd_tun_u.lnd_o2ib; + peer_ni->ibp_connecting = tunables->lnd_conns_per_peer; /* always called with a ref on ni, which prevents ni being shutdown */ LASSERT(!((struct kib_net *)ni->ni_data)->ibn_shutdown); if (tx) - list_add_tail(&tx->tx_list, &peer->ibp_tx_queue); + list_add_tail(&tx->tx_list, &peer_ni->ibp_tx_queue); - kiblnd_peer_addref(peer); - list_add_tail(&peer->ibp_list, kiblnd_nid2peerlist(nid)); + kiblnd_peer_addref(peer_ni); + list_add_tail(&peer_ni->ibp_list, kiblnd_nid2peerlist(nid)); write_unlock_irqrestore(g_lock, flags); for (i = 0; i < tunables->lnd_conns_per_peer; i++) - kiblnd_connect_peer(peer); - kiblnd_peer_decref(peer); + kiblnd_connect_peer(peer_ni); + kiblnd_peer_decref(peer_ni); } int @@ -1787,7 +1789,7 @@ kiblnd_recv(struct lnet_ni *ni, void *private, struct lnet_msg *lntmsg, 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 */ + /* tell peer_ni it's over */ kiblnd_send_completion(rx->rx_conn, IBLND_MSG_PUT_NAK, rc, rxmsg->ibm_u.putreq.ibprm_cookie); break; @@ -1844,15 +1846,15 @@ kiblnd_thread_fini(void) } static void -kiblnd_peer_alive(struct kib_peer *peer) +kiblnd_peer_alive(struct kib_peer_ni *peer_ni) { /* This is racy, but everyone's only writing ktime_get_seconds() */ - peer->ibp_last_alive = ktime_get_seconds(); + peer_ni->ibp_last_alive = ktime_get_seconds(); mb(); } static void -kiblnd_peer_notify(struct kib_peer *peer) +kiblnd_peer_notify(struct kib_peer_ni *peer_ni) { int error = 0; time64_t last_alive = 0; @@ -1860,18 +1862,18 @@ kiblnd_peer_notify(struct kib_peer *peer) read_lock_irqsave(&kiblnd_data.kib_global_lock, flags); - if (kiblnd_peer_idle(peer) && peer->ibp_error) { - error = peer->ibp_error; - peer->ibp_error = 0; + if (kiblnd_peer_idle(peer_ni) && peer_ni->ibp_error) { + error = peer_ni->ibp_error; + peer_ni->ibp_error = 0; - last_alive = peer->ibp_last_alive; + last_alive = peer_ni->ibp_last_alive; } read_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags); if (error) - lnet_notify(peer->ibp_ni, - peer->ibp_nid, 0, last_alive); + lnet_notify(peer_ni->ibp_ni, + peer_ni->ibp_nid, 0, last_alive); } void @@ -1885,7 +1887,7 @@ kiblnd_close_conn_locked(struct kib_conn *conn, int error) * already dealing with it (either to set it up or tear it down). * Caller holds kib_global_lock exclusively in irq context */ - struct kib_peer *peer = conn->ibc_peer; + struct kib_peer_ni *peer_ni = conn->ibc_peer; struct kib_dev *dev; unsigned long flags; @@ -1904,10 +1906,10 @@ kiblnd_close_conn_locked(struct kib_conn *conn, int error) 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)); + libcfs_nid2str(peer_ni->ibp_nid)); } else { CNETERR("Closing conn to %s: error %d%s%s%s%s%s\n", - libcfs_nid2str(peer->ibp_nid), error, + libcfs_nid2str(peer_ni->ibp_nid), error, list_empty(&conn->ibc_tx_queue) ? "" : "(sending)", list_empty(&conn->ibc_tx_noops) ? "" : "(sending_noops)", list_empty(&conn->ibc_tx_queue_rsrvd) ? "" : "(sending_rsrvd)", @@ -1915,19 +1917,19 @@ kiblnd_close_conn_locked(struct kib_conn *conn, int error) list_empty(&conn->ibc_active_txs) ? "" : "(waiting)"); } - dev = ((struct kib_net *)peer->ibp_ni->ni_data)->ibn_dev; - if (peer->ibp_next_conn == conn) + dev = ((struct kib_net *)peer_ni->ibp_ni->ni_data)->ibn_dev; + if (peer_ni->ibp_next_conn == conn) /* clear next_conn so it won't be used */ - peer->ibp_next_conn = NULL; + peer_ni->ibp_next_conn = NULL; list_del(&conn->ibc_list); /* connd (see below) takes over ibc_list's ref */ - if (list_empty(&peer->ibp_conns) && /* no more conns */ - kiblnd_peer_active(peer)) { /* still in peer table */ - kiblnd_unlink_peer_locked(peer); + if (list_empty(&peer_ni->ibp_conns) && /* no more conns */ + kiblnd_peer_active(peer_ni)) { /* still in peer_ni table */ + kiblnd_unlink_peer_locked(peer_ni); /* set/clear error on last conn */ - peer->ibp_error = conn->ibc_comms_error; + peer_ni->ibp_error = conn->ibc_comms_error; } kiblnd_set_conn_state(conn, IBLND_CONN_CLOSING); @@ -2046,7 +2048,7 @@ kiblnd_finalise_conn(struct kib_conn *conn) } static void -kiblnd_peer_connect_failed(struct kib_peer *peer, int active, int error) +kiblnd_peer_connect_failed(struct kib_peer_ni *peer_ni, int active, int error) { LIST_HEAD(zombies); unsigned long flags; @@ -2057,52 +2059,52 @@ kiblnd_peer_connect_failed(struct kib_peer *peer, int active, int error) write_lock_irqsave(&kiblnd_data.kib_global_lock, flags); if (active) { - LASSERT(peer->ibp_connecting > 0); - peer->ibp_connecting--; + LASSERT(peer_ni->ibp_connecting > 0); + peer_ni->ibp_connecting--; } else { - LASSERT(peer->ibp_accepting > 0); - peer->ibp_accepting--; + LASSERT(peer_ni->ibp_accepting > 0); + peer_ni->ibp_accepting--; } - if (kiblnd_peer_connecting(peer)) { + if (kiblnd_peer_connecting(peer_ni)) { /* another connection attempt under way... */ write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags); return; } - peer->ibp_reconnected = 0; - 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); + peer_ni->ibp_reconnected = 0; + if (list_empty(&peer_ni->ibp_conns)) { + /* Take peer_ni's blocked transmits to complete with error */ + list_add(&zombies, &peer_ni->ibp_tx_queue); + list_del_init(&peer_ni->ibp_tx_queue); - if (kiblnd_peer_active(peer)) - kiblnd_unlink_peer_locked(peer); + if (kiblnd_peer_active(peer_ni)) + kiblnd_unlink_peer_locked(peer_ni); - peer->ibp_error = error; + peer_ni->ibp_error = error; } else { /* Can't have blocked transmits if there are connections */ - LASSERT(list_empty(&peer->ibp_tx_queue)); + LASSERT(list_empty(&peer_ni->ibp_tx_queue)); } write_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags); - kiblnd_peer_notify(peer); + kiblnd_peer_notify(peer_ni); if (list_empty(&zombies)) return; CNETERR("Deleting messages for %s: connection failed\n", - libcfs_nid2str(peer->ibp_nid)); + libcfs_nid2str(peer_ni->ibp_nid)); - kiblnd_txlist_done(peer->ibp_ni, &zombies, -EHOSTUNREACH); + kiblnd_txlist_done(peer_ni->ibp_ni, &zombies, -EHOSTUNREACH); } static void kiblnd_connreq_done(struct kib_conn *conn, int status) { - struct kib_peer *peer = conn->ibc_peer; + struct kib_peer_ni *peer_ni = conn->ibc_peer; struct kib_tx *tx; struct list_head txs; unsigned long flags; @@ -2111,21 +2113,21 @@ kiblnd_connreq_done(struct kib_conn *conn, int status) 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, + libcfs_nid2str(peer_ni->ibp_nid), active, conn->ibc_version, status); LASSERT(!in_interrupt()); LASSERT((conn->ibc_state == IBLND_CONN_ACTIVE_CONNECT && - peer->ibp_connecting > 0) || + peer_ni->ibp_connecting > 0) || (conn->ibc_state == IBLND_CONN_PASSIVE_WAIT && - peer->ibp_accepting > 0)); + peer_ni->ibp_accepting > 0)); kfree(conn->ibc_connvars); conn->ibc_connvars = NULL; if (status) { /* failed to establish connection */ - kiblnd_peer_connect_failed(peer, active, status); + kiblnd_peer_connect_failed(peer_ni, active, status); kiblnd_finalise_conn(conn); return; } @@ -2135,40 +2137,40 @@ kiblnd_connreq_done(struct kib_conn *conn, int status) conn->ibc_last_send = ktime_get(); kiblnd_set_conn_state(conn, IBLND_CONN_ESTABLISHED); - kiblnd_peer_alive(peer); + kiblnd_peer_alive(peer_ni); /* - * Add conn to peer's list and nuke any dangling conns from a different - * peer instance... + * Add conn to peer_ni's list and nuke any dangling conns from + * a different peer_ni instance... */ kiblnd_conn_addref(conn); /* +1 ref for ibc_list */ - list_add(&conn->ibc_list, &peer->ibp_conns); - peer->ibp_reconnected = 0; + list_add(&conn->ibc_list, &peer_ni->ibp_conns); + peer_ni->ibp_reconnected = 0; if (active) - peer->ibp_connecting--; + peer_ni->ibp_connecting--; else - peer->ibp_accepting--; + peer_ni->ibp_accepting--; - if (!peer->ibp_version) { - peer->ibp_version = conn->ibc_version; - peer->ibp_incarnation = conn->ibc_incarnation; + if (!peer_ni->ibp_version) { + peer_ni->ibp_version = conn->ibc_version; + peer_ni->ibp_incarnation = conn->ibc_incarnation; } - if (peer->ibp_version != conn->ibc_version || - peer->ibp_incarnation != conn->ibc_incarnation) { - kiblnd_close_stale_conns_locked(peer, conn->ibc_version, + if (peer_ni->ibp_version != conn->ibc_version || + peer_ni->ibp_incarnation != conn->ibc_incarnation) { + kiblnd_close_stale_conns_locked(peer_ni, conn->ibc_version, conn->ibc_incarnation); - peer->ibp_version = conn->ibc_version; - peer->ibp_incarnation = conn->ibc_incarnation; + peer_ni->ibp_version = conn->ibc_version; + peer_ni->ibp_incarnation = conn->ibc_incarnation; } /* grab pending txs while I have the lock */ - list_add(&txs, &peer->ibp_tx_queue); - list_del_init(&peer->ibp_tx_queue); + list_add(&txs, &peer_ni->ibp_tx_queue); + list_del_init(&peer_ni->ibp_tx_queue); - if (!kiblnd_peer_active(peer) || /* peer has been deleted */ + if (!kiblnd_peer_active(peer_ni) || /* peer_ni has been deleted */ conn->ibc_comms_error) { /* error has happened already */ - struct lnet_ni *ni = peer->ibp_ni; + struct lnet_ni *ni = peer_ni->ibp_ni; /* start to shut down connection */ kiblnd_close_conn_locked(conn, -ECONNABORTED); @@ -2181,7 +2183,7 @@ kiblnd_connreq_done(struct kib_conn *conn, int status) /* * +1 ref for myself, this connection is visible to other threads - * now, refcount of peer:ibp_conns can be released by connection + * now, refcount of peer_ni:ibp_conns can be released by connection * close from either a different thread, or the calling of * kiblnd_check_sends_locked() below. See bz21911 for details. */ @@ -2227,8 +2229,8 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob) struct kib_msg *reqmsg = priv; struct kib_msg *ackmsg; struct kib_dev *ibdev; - struct kib_peer *peer; - struct kib_peer *peer2; + struct kib_peer_ni *peer_ni; + struct kib_peer_ni *peer2; struct kib_conn *conn; struct lnet_ni *ni = NULL; struct kib_net *net = NULL; @@ -2257,7 +2259,7 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob) ntohs(peer_addr->sin_port) >= PROT_SOCK) { __u32 ip = ntohl(peer_addr->sin_addr.s_addr); - CERROR("Peer's port (%pI4h:%hu) is not privileged\n", + CERROR("peer_ni's port (%pI4h:%hu) is not privileged\n", &ip, ntohs(peer_addr->sin_port)); goto failed; } @@ -2272,7 +2274,7 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob) * o2iblnd-specific protocol changes, or when LNET unifies * protocols over all LNDs, the initial connection will * negotiate a protocol version. I trap this here to avoid - * console errors; the reject tells the peer which protocol I + * console errors; the reject tells the peer_ni which protocol I * speak. */ if (reqmsg->ibm_magic == LNET_PROTO_MAGIC || @@ -2322,7 +2324,7 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob) goto failed; } - /* I can accept peer's version */ + /* I can accept peer_ni's version */ version = reqmsg->ibm_version; if (reqmsg->ibm_type != IBLND_MSG_CONNREQ) { @@ -2374,17 +2376,17 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob) goto failed; } - /* assume 'nid' is a new peer; create */ - rc = kiblnd_create_peer(ni, &peer, nid); + /* assume 'nid' is a new peer_ni; create */ + rc = kiblnd_create_peer(ni, &peer_ni, nid); if (rc) { - CERROR("Can't create peer for %s\n", libcfs_nid2str(nid)); + CERROR("Can't create peer_ni for %s\n", libcfs_nid2str(nid)); rej.ibr_why = IBLND_REJECT_NO_RESOURCES; goto failed; } - /* We have validated the peer's parameters so use those */ - peer->ibp_max_frags = max_frags; - peer->ibp_queue_depth = reqmsg->ibm_u.connparams.ibcp_queue_depth; + /* We have validated the peer_ni's parameters so use those */ + peer_ni->ibp_max_frags = max_frags; + peer_ni->ibp_queue_depth = reqmsg->ibm_u.connparams.ibcp_queue_depth; write_lock_irqsave(g_lock, flags); @@ -2410,7 +2412,7 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob) libcfs_nid2str(nid), peer2->ibp_version, version, peer2->ibp_incarnation, reqmsg->ibm_srcstamp); - kiblnd_peer_decref(peer); + kiblnd_peer_decref(peer_ni); rej.ibr_why = IBLND_REJECT_CONN_STALE; goto failed; } @@ -2432,7 +2434,7 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob) CDEBUG(D_NET, "Conn race %s\n", libcfs_nid2str(peer2->ibp_nid)); - kiblnd_peer_decref(peer); + kiblnd_peer_decref(peer_ni); rej.ibr_why = IBLND_REJECT_CONN_RACE; goto failed; } @@ -2440,9 +2442,9 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob) CNETERR("Conn race %s: unresolved after %d attempts, letting lower NID win\n", libcfs_nid2str(peer2->ibp_nid), MAX_CONN_RACES_BEFORE_ABORT); - /** - * passive connection is allowed even this peer is waiting for - * reconnection. + /* + * passive connection is allowed even this peer_ni is + * waiting for reconnection. */ peer2->ibp_reconnecting = 0; peer2->ibp_races = 0; @@ -2452,38 +2454,38 @@ kiblnd_passive_connect(struct rdma_cm_id *cmid, void *priv, int priv_nob) /** * Race with kiblnd_launch_tx (active connect) to create peer * so copy validated parameters since we now know what the - * peer's limits are + * peer_ni's limits are */ - peer2->ibp_max_frags = peer->ibp_max_frags; - peer2->ibp_queue_depth = peer->ibp_queue_depth; + peer2->ibp_max_frags = peer_ni->ibp_max_frags; + peer2->ibp_queue_depth = peer_ni->ibp_queue_depth; write_unlock_irqrestore(g_lock, flags); - kiblnd_peer_decref(peer); - peer = peer2; + kiblnd_peer_decref(peer_ni); + peer_ni = peer2; } else { - /* Brand new peer */ - LASSERT(!peer->ibp_accepting); - LASSERT(!peer->ibp_version && - !peer->ibp_incarnation); + /* Brand new peer_ni */ + LASSERT(!peer_ni->ibp_accepting); + LASSERT(!peer_ni->ibp_version && + !peer_ni->ibp_incarnation); - peer->ibp_accepting = 1; - peer->ibp_version = version; - peer->ibp_incarnation = reqmsg->ibm_srcstamp; + peer_ni->ibp_accepting = 1; + peer_ni->ibp_version = version; + peer_ni->ibp_incarnation = reqmsg->ibm_srcstamp; /* I have a ref on ni that prevents it being shutdown */ LASSERT(!net->ibn_shutdown); - kiblnd_peer_addref(peer); - list_add_tail(&peer->ibp_list, kiblnd_nid2peerlist(nid)); + kiblnd_peer_addref(peer_ni); + list_add_tail(&peer_ni->ibp_list, kiblnd_nid2peerlist(nid)); write_unlock_irqrestore(g_lock, flags); } - conn = kiblnd_create_conn(peer, cmid, IBLND_CONN_PASSIVE_WAIT, + conn = kiblnd_create_conn(peer_ni, cmid, IBLND_CONN_PASSIVE_WAIT, version); if (!conn) { - kiblnd_peer_connect_failed(peer, 0, -ENOMEM); - kiblnd_peer_decref(peer); + kiblnd_peer_connect_failed(peer_ni, 0, -ENOMEM); + kiblnd_peer_decref(peer_ni); rej.ibr_why = IBLND_REJECT_NO_RESOURCES; goto failed; } @@ -2552,7 +2554,7 @@ kiblnd_check_reconnect(struct kib_conn *conn, int version, __u64 incarnation, int why, struct kib_connparams *cp) { rwlock_t *glock = &kiblnd_data.kib_global_lock; - struct kib_peer *peer = conn->ibc_peer; + struct kib_peer_ni *peer_ni = conn->ibc_peer; char *reason; int msg_size = IBLND_MSG_SIZE; int frag_num = -1; @@ -2561,7 +2563,7 @@ kiblnd_check_reconnect(struct kib_conn *conn, int version, unsigned long flags; LASSERT(conn->ibc_state == IBLND_CONN_ACTIVE_CONNECT); - LASSERT(peer->ibp_connecting > 0); /* 'conn' at least */ + LASSERT(peer_ni->ibp_connecting > 0); /* 'conn' at least */ if (cp) { msg_size = cp->ibcp_max_msg_size; @@ -2577,10 +2579,10 @@ kiblnd_check_reconnect(struct kib_conn *conn, int version, * empty if ibp_version != version because reconnect may be * initiated by kiblnd_query() */ - reconnect = (!list_empty(&peer->ibp_tx_queue) || - peer->ibp_version != version) && - peer->ibp_connecting && - !peer->ibp_accepting; + reconnect = (!list_empty(&peer_ni->ibp_tx_queue) || + peer_ni->ibp_version != version) && + peer_ni->ibp_connecting && + !peer_ni->ibp_accepting; if (!reconnect) { reason = "no need"; goto out; @@ -2598,7 +2600,7 @@ kiblnd_check_reconnect(struct kib_conn *conn, int version, reason = "can't negotiate max frags"; goto out; } - tunables = &peer->ibp_ni->ni_lnd_tunables.lnd_tun_u.lnd_o2ib; + tunables = &peer_ni->ibp_ni->ni_lnd_tunables.lnd_tun_u.lnd_o2ib; if (!tunables->lnd_map_on_demand) { reason = "map_on_demand must be enabled"; goto out; @@ -2608,7 +2610,7 @@ kiblnd_check_reconnect(struct kib_conn *conn, int version, goto out; } - peer->ibp_max_frags = frag_num; + peer_ni->ibp_max_frags = frag_num; reason = "rdma fragments"; break; } @@ -2622,7 +2624,7 @@ kiblnd_check_reconnect(struct kib_conn *conn, int version, goto out; } - peer->ibp_queue_depth = queue_dep; + peer_ni->ibp_queue_depth = queue_dep; reason = "queue depth"; break; @@ -2640,15 +2642,15 @@ kiblnd_check_reconnect(struct kib_conn *conn, int version, } conn->ibc_reconnect = 1; - peer->ibp_reconnecting++; - peer->ibp_version = version; + peer_ni->ibp_reconnecting++; + peer_ni->ibp_version = version; if (incarnation) - peer->ibp_incarnation = incarnation; + peer_ni->ibp_incarnation = incarnation; out: write_unlock_irqrestore(glock, flags); CNETERR("%s: %s (%s), %x, %x, msg_size: %d, queue_depth: %d/%d, max_frags: %d/%d\n", - libcfs_nid2str(peer->ibp_nid), + libcfs_nid2str(peer_ni->ibp_nid), reconnect ? "reconnect" : "don't reconnect", reason, IBLND_MSG_VERSION, version, msg_size, conn->ibc_queue_depth, queue_dep, @@ -2662,7 +2664,7 @@ kiblnd_check_reconnect(struct kib_conn *conn, int version, static void kiblnd_rejected(struct kib_conn *conn, int reason, void *priv, int priv_nob) { - struct kib_peer *peer = conn->ibc_peer; + struct kib_peer_ni *peer_ni = conn->ibc_peer; LASSERT(!in_interrupt()); LASSERT(conn->ibc_state == IBLND_CONN_ACTIVE_CONNECT); @@ -2675,7 +2677,7 @@ kiblnd_rejected(struct kib_conn *conn, int reason, void *priv, int priv_nob) case IB_CM_REJ_INVALID_SERVICE_ID: CNETERR("%s rejected: no listener at %d\n", - libcfs_nid2str(peer->ibp_nid), + libcfs_nid2str(peer_ni->ibp_nid), *kiblnd_tunables.kib_service); break; @@ -2691,7 +2693,7 @@ kiblnd_rejected(struct kib_conn *conn, int reason, void *priv, int priv_nob) * b) V2 will provide incarnation while rejecting me, * -1 will be overwrote. * - * if I try to connect to a V1 peer with V2 protocol, + * if I try to connect to a V1 peer_ni with V2 protocol, * it rejected me then upgrade to V2, I have no idea * about the upgrading and try to reconnect with V1, * in this case upgraded V2 can find out I'm trying to @@ -2727,22 +2729,24 @@ kiblnd_rejected(struct kib_conn *conn, int reason, void *priv, int priv_nob) if (rej->ibr_magic != IBLND_MSG_MAGIC && rej->ibr_magic != LNET_PROTO_MAGIC) { CERROR("%s rejected: consumer defined fatal error\n", - libcfs_nid2str(peer->ibp_nid)); + libcfs_nid2str(peer_ni->ibp_nid)); break; } if (rej->ibr_version != IBLND_MSG_VERSION && rej->ibr_version != IBLND_MSG_VERSION_1) { CERROR("%s rejected: o2iblnd version %x error\n", - libcfs_nid2str(peer->ibp_nid), + libcfs_nid2str(peer_ni->ibp_nid), rej->ibr_version); break; } if (rej->ibr_why == IBLND_REJECT_FATAL && rej->ibr_version == IBLND_MSG_VERSION_1) { - CDEBUG(D_NET, "rejected by old version peer %s: %x\n", - libcfs_nid2str(peer->ibp_nid), rej->ibr_version); + CDEBUG(D_NET, + "rejected by old version peer_ni %s: %x\n", + libcfs_nid2str(peer_ni->ibp_nid), + rej->ibr_version); if (conn->ibc_version != IBLND_MSG_VERSION_1) rej->ibr_why = IBLND_REJECT_CONN_UNCOMPAT; @@ -2761,17 +2765,17 @@ kiblnd_rejected(struct kib_conn *conn, int reason, void *priv, int priv_nob) case IBLND_REJECT_NO_RESOURCES: CERROR("%s rejected: o2iblnd no resources\n", - libcfs_nid2str(peer->ibp_nid)); + libcfs_nid2str(peer_ni->ibp_nid)); break; case IBLND_REJECT_FATAL: CERROR("%s rejected: o2iblnd fatal error\n", - libcfs_nid2str(peer->ibp_nid)); + libcfs_nid2str(peer_ni->ibp_nid)); break; default: CERROR("%s rejected: o2iblnd reason %d\n", - libcfs_nid2str(peer->ibp_nid), + libcfs_nid2str(peer_ni->ibp_nid), rej->ibr_why); break; } @@ -2780,7 +2784,7 @@ kiblnd_rejected(struct kib_conn *conn, int reason, void *priv, int priv_nob) /* fall through */ default: CNETERR("%s rejected: reason %d, size %d\n", - libcfs_nid2str(peer->ibp_nid), reason, priv_nob); + libcfs_nid2str(peer_ni->ibp_nid), reason, priv_nob); break; } @@ -2790,8 +2794,8 @@ kiblnd_rejected(struct kib_conn *conn, int reason, void *priv, int priv_nob) static void kiblnd_check_connreply(struct kib_conn *conn, void *priv, int priv_nob) { - struct kib_peer *peer = conn->ibc_peer; - struct lnet_ni *ni = peer->ibp_ni; + struct kib_peer_ni *peer_ni = conn->ibc_peer; + struct lnet_ni *ni = peer_ni->ibp_ni; struct kib_net *net = ni->ni_data; struct kib_msg *msg = priv; int ver = conn->ibc_version; @@ -2802,20 +2806,20 @@ kiblnd_check_connreply(struct kib_conn *conn, void *priv, int priv_nob) if (rc) { CERROR("Can't unpack connack from %s: %d\n", - libcfs_nid2str(peer->ibp_nid), rc); + libcfs_nid2str(peer_ni->ibp_nid), rc); goto failed; } if (msg->ibm_type != IBLND_MSG_CONNACK) { CERROR("Unexpected message %d from %s\n", - msg->ibm_type, libcfs_nid2str(peer->ibp_nid)); + msg->ibm_type, libcfs_nid2str(peer_ni->ibp_nid)); rc = -EPROTO; goto failed; } if (ver != msg->ibm_version) { CERROR("%s replied version %x is different with requested version %x\n", - libcfs_nid2str(peer->ibp_nid), msg->ibm_version, ver); + libcfs_nid2str(peer_ni->ibp_nid), msg->ibm_version, ver); rc = -EPROTO; goto failed; } @@ -2823,7 +2827,7 @@ kiblnd_check_connreply(struct kib_conn *conn, void *priv, int priv_nob) if (msg->ibm_u.connparams.ibcp_queue_depth > conn->ibc_queue_depth) { CERROR("%s has incompatible queue depth %d (<=%d wanted)\n", - libcfs_nid2str(peer->ibp_nid), + libcfs_nid2str(peer_ni->ibp_nid), msg->ibm_u.connparams.ibcp_queue_depth, conn->ibc_queue_depth); rc = -EPROTO; @@ -2833,7 +2837,7 @@ kiblnd_check_connreply(struct kib_conn *conn, void *priv, int priv_nob) if ((msg->ibm_u.connparams.ibcp_max_frags >> IBLND_FRAG_SHIFT) > conn->ibc_max_frags) { CERROR("%s has incompatible max_frags %d (<=%d wanted)\n", - libcfs_nid2str(peer->ibp_nid), + libcfs_nid2str(peer_ni->ibp_nid), msg->ibm_u.connparams.ibcp_max_frags >> IBLND_FRAG_SHIFT, conn->ibc_max_frags); rc = -EPROTO; @@ -2842,7 +2846,7 @@ kiblnd_check_connreply(struct kib_conn *conn, void *priv, int priv_nob) if (msg->ibm_u.connparams.ibcp_max_msg_size > IBLND_MSG_SIZE) { CERROR("%s max message size %d too big (%d max)\n", - libcfs_nid2str(peer->ibp_nid), + libcfs_nid2str(peer_ni->ibp_nid), msg->ibm_u.connparams.ibcp_max_msg_size, IBLND_MSG_SIZE); rc = -EPROTO; @@ -2859,7 +2863,7 @@ kiblnd_check_connreply(struct kib_conn *conn, void *priv, int priv_nob) if (rc) { CERROR("Bad connection reply from %s, rc = %d, version: %x max_frags: %d\n", - libcfs_nid2str(peer->ibp_nid), rc, + libcfs_nid2str(peer_ni->ibp_nid), rc, msg->ibm_version, msg->ibm_u.connparams.ibcp_max_frags); goto failed; } @@ -2890,7 +2894,7 @@ kiblnd_check_connreply(struct kib_conn *conn, void *priv, int priv_nob) static int kiblnd_active_connect(struct rdma_cm_id *cmid) { - struct kib_peer *peer = (struct kib_peer *)cmid->context; + struct kib_peer_ni *peer_ni = (struct kib_peer_ni *)cmid->context; struct kib_conn *conn; struct kib_msg *msg; struct rdma_conn_param cp; @@ -2901,17 +2905,17 @@ kiblnd_active_connect(struct rdma_cm_id *cmid) read_lock_irqsave(&kiblnd_data.kib_global_lock, flags); - incarnation = peer->ibp_incarnation; - version = !peer->ibp_version ? IBLND_MSG_VERSION : - peer->ibp_version; + incarnation = peer_ni->ibp_incarnation; + version = !peer_ni->ibp_version ? IBLND_MSG_VERSION : + peer_ni->ibp_version; read_unlock_irqrestore(&kiblnd_data.kib_global_lock, flags); - conn = kiblnd_create_conn(peer, cmid, IBLND_CONN_ACTIVE_CONNECT, + conn = kiblnd_create_conn(peer_ni, cmid, IBLND_CONN_ACTIVE_CONNECT, version); if (!conn) { - kiblnd_peer_connect_failed(peer, 1, -ENOMEM); - kiblnd_peer_decref(peer); /* lose cmid's ref */ + kiblnd_peer_connect_failed(peer_ni, 1, -ENOMEM); + kiblnd_peer_decref(peer_ni); /* lose cmid's ref */ return -ENOMEM; } @@ -2928,8 +2932,8 @@ kiblnd_active_connect(struct rdma_cm_id *cmid) msg->ibm_u.connparams.ibcp_max_frags = conn->ibc_max_frags << IBLND_FRAG_SHIFT; msg->ibm_u.connparams.ibcp_max_msg_size = IBLND_MSG_SIZE; - kiblnd_pack_msg(peer->ibp_ni, msg, version, - 0, peer->ibp_nid, incarnation); + kiblnd_pack_msg(peer_ni->ibp_ni, msg, version, + 0, peer_ni->ibp_nid, incarnation); memset(&cp, 0, sizeof(cp)); cp.private_data = msg; @@ -2946,7 +2950,7 @@ kiblnd_active_connect(struct rdma_cm_id *cmid) rc = rdma_connect(cmid, &cp); if (rc) { CERROR("Can't connect to %s: %d\n", - libcfs_nid2str(peer->ibp_nid), rc); + libcfs_nid2str(peer_ni->ibp_nid), rc); kiblnd_connreq_done(conn, rc); kiblnd_conn_decref(conn); } @@ -2957,7 +2961,7 @@ kiblnd_active_connect(struct rdma_cm_id *cmid) int kiblnd_cm_callback(struct rdma_cm_id *cmid, struct rdma_cm_event *event) { - struct kib_peer *peer; + struct kib_peer_ni *peer_ni; struct kib_conn *conn; int rc; @@ -2976,33 +2980,34 @@ kiblnd_cm_callback(struct rdma_cm_id *cmid, struct rdma_cm_event *event) return rc; case RDMA_CM_EVENT_ADDR_ERROR: - peer = (struct kib_peer *)cmid->context; + peer_ni = (struct kib_peer_ni *)cmid->context; CNETERR("%s: ADDR ERROR %d\n", - libcfs_nid2str(peer->ibp_nid), event->status); - kiblnd_peer_connect_failed(peer, 1, -EHOSTUNREACH); - kiblnd_peer_decref(peer); + libcfs_nid2str(peer_ni->ibp_nid), event->status); + kiblnd_peer_connect_failed(peer_ni, 1, -EHOSTUNREACH); + kiblnd_peer_decref(peer_ni); return -EHOSTUNREACH; /* rc destroys cmid */ case RDMA_CM_EVENT_ADDR_RESOLVED: - peer = (struct kib_peer *)cmid->context; + peer_ni = (struct kib_peer_ni *)cmid->context; CDEBUG(D_NET, "%s Addr resolved: %d\n", - libcfs_nid2str(peer->ibp_nid), event->status); + libcfs_nid2str(peer_ni->ibp_nid), event->status); if (event->status) { CNETERR("Can't resolve address for %s: %d\n", - libcfs_nid2str(peer->ibp_nid), event->status); + libcfs_nid2str(peer_ni->ibp_nid), + event->status); rc = event->status; } else { rc = rdma_resolve_route( cmid, *kiblnd_tunables.kib_timeout * 1000); if (!rc) { - struct kib_net *net = peer->ibp_ni->ni_data; + struct kib_net *net = peer_ni->ibp_ni->ni_data; struct kib_dev *dev = net->ibn_dev; CDEBUG(D_NET, "%s: connection bound to "\ "%s:%pI4h:%s\n", - libcfs_nid2str(peer->ibp_nid), + libcfs_nid2str(peer_ni->ibp_nid), dev->ibd_ifname, &dev->ibd_ifip, cmid->device->name); @@ -3011,32 +3016,32 @@ kiblnd_cm_callback(struct rdma_cm_id *cmid, struct rdma_cm_event *event) /* Can't initiate route resolution */ CERROR("Can't resolve route for %s: %d\n", - libcfs_nid2str(peer->ibp_nid), rc); + libcfs_nid2str(peer_ni->ibp_nid), rc); } - kiblnd_peer_connect_failed(peer, 1, rc); - kiblnd_peer_decref(peer); + kiblnd_peer_connect_failed(peer_ni, 1, rc); + kiblnd_peer_decref(peer_ni); return rc; /* rc destroys cmid */ case RDMA_CM_EVENT_ROUTE_ERROR: - peer = (struct kib_peer *)cmid->context; + peer_ni = (struct kib_peer_ni *)cmid->context; CNETERR("%s: ROUTE ERROR %d\n", - libcfs_nid2str(peer->ibp_nid), event->status); - kiblnd_peer_connect_failed(peer, 1, -EHOSTUNREACH); - kiblnd_peer_decref(peer); + libcfs_nid2str(peer_ni->ibp_nid), event->status); + kiblnd_peer_connect_failed(peer_ni, 1, -EHOSTUNREACH); + kiblnd_peer_decref(peer_ni); return -EHOSTUNREACH; /* rc destroys cmid */ case RDMA_CM_EVENT_ROUTE_RESOLVED: - peer = (struct kib_peer *)cmid->context; + peer_ni = (struct kib_peer_ni *)cmid->context; CDEBUG(D_NET, "%s Route resolved: %d\n", - libcfs_nid2str(peer->ibp_nid), event->status); + libcfs_nid2str(peer_ni->ibp_nid), event->status); if (!event->status) return kiblnd_active_connect(cmid); CNETERR("Can't resolve route for %s: %d\n", - libcfs_nid2str(peer->ibp_nid), event->status); - kiblnd_peer_connect_failed(peer, 1, event->status); - kiblnd_peer_decref(peer); + libcfs_nid2str(peer_ni->ibp_nid), event->status); + kiblnd_peer_connect_failed(peer_ni, 1, event->status); + kiblnd_peer_decref(peer_ni); return event->status; /* rc destroys cmid */ case RDMA_CM_EVENT_UNREACHABLE: @@ -3177,7 +3182,7 @@ kiblnd_check_conns(int idx) LIST_HEAD(closes); LIST_HEAD(checksends); struct list_head *peers = &kiblnd_data.kib_peers[idx]; - struct kib_peer *peer; + struct kib_peer_ni *peer_ni; struct kib_conn *conn; unsigned long flags; @@ -3188,9 +3193,9 @@ kiblnd_check_conns(int idx) */ read_lock_irqsave(&kiblnd_data.kib_global_lock, flags); - list_for_each_entry(peer, peers, ibp_list) { + list_for_each_entry(peer_ni, peers, ibp_list) { - list_for_each_entry(conn, &peer->ibp_conns, ibc_list) { + list_for_each_entry(conn, &peer_ni->ibp_conns, ibc_list) { int timedout; int sendnoop; @@ -3207,8 +3212,9 @@ kiblnd_check_conns(int idx) if (timedout) { CERROR("Timed out RDMA with %s (%lld): c: %u, oc: %u, rc: %u\n", - libcfs_nid2str(peer->ibp_nid), - ktime_get_seconds() - peer->ibp_last_alive, + libcfs_nid2str(peer_ni->ibp_nid), + (ktime_get_seconds() - + peer_ni->ibp_last_alive), conn->ibc_credits, conn->ibc_outstanding_credits, conn->ibc_reserved_credits); @@ -3268,7 +3274,7 @@ kiblnd_disconnect_conn(struct kib_conn *conn) } /** - * High-water for reconnection to the same peer, reconnection attempt should + * High-water for reconnection to the same peer_ni, reconnection attempt should * be delayed after trying more than KIB_RECONN_HIGH_RACE. */ #define KIB_RECONN_HIGH_RACE 10 @@ -3302,14 +3308,14 @@ kiblnd_connd(void *arg) dropped_lock = 0; if (!list_empty(&kiblnd_data.kib_connd_zombies)) { - struct kib_peer *peer = NULL; + struct kib_peer_ni *peer_ni = NULL; conn = list_entry(kiblnd_data.kib_connd_zombies.next, struct kib_conn, ibc_list); list_del(&conn->ibc_list); if (conn->ibc_reconnect) { - peer = conn->ibc_peer; - kiblnd_peer_addref(peer); + peer_ni = conn->ibc_peer; + kiblnd_peer_addref(peer_ni); } spin_unlock_irqrestore(lock, flags); @@ -3318,13 +3324,13 @@ kiblnd_connd(void *arg) kiblnd_destroy_conn(conn); spin_lock_irqsave(lock, flags); - if (!peer) { + if (!peer_ni) { kfree(conn); continue; } - conn->ibc_peer = peer; - if (peer->ibp_reconnected < KIB_RECONN_HIGH_RACE) + conn->ibc_peer = peer_ni; + if (peer_ni->ibp_reconnected < KIB_RECONN_HIGH_RACE) list_add_tail(&conn->ibc_list, &kiblnd_data.kib_reconn_list); else @@ -3384,7 +3390,7 @@ kiblnd_connd(void *arg) /* * Time to check for RDMA timeouts on a few more * peers: I do checks every 'p' seconds on a - * proportion of the peer table and I need to check + * proportion of the peer_ni table and I need to check * every connection 'n' times within a timeout * interval, to ensure I detect a timeout on any * connection within (n+1)/n times the timeout diff --git a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd.c b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd.c index ba1ec35a017a..c14711804d7b 100644 --- a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd.c +++ b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd.c @@ -104,38 +104,38 @@ ksocknal_create_peer(struct ksock_peer **peerp, struct lnet_ni *ni, { int cpt = lnet_cpt_of_nid(id.nid, ni); struct ksock_net *net = ni->ni_data; - struct ksock_peer *peer; + struct ksock_peer *peer_ni; LASSERT(id.nid != LNET_NID_ANY); LASSERT(id.pid != LNET_PID_ANY); LASSERT(!in_interrupt()); - peer = kzalloc_cpt(sizeof(*peer), GFP_NOFS, cpt); - if (!peer) + peer_ni = kzalloc_cpt(sizeof(*peer_ni), GFP_NOFS, cpt); + if (!peer_ni) return -ENOMEM; - peer->ksnp_ni = ni; - peer->ksnp_id = id; - atomic_set(&peer->ksnp_refcount, 1); /* 1 ref for caller */ - peer->ksnp_closing = 0; - peer->ksnp_accepting = 0; - peer->ksnp_proto = NULL; - peer->ksnp_last_alive = 0; - peer->ksnp_zc_next_cookie = SOCKNAL_KEEPALIVE_PING + 1; - - INIT_LIST_HEAD(&peer->ksnp_conns); - INIT_LIST_HEAD(&peer->ksnp_routes); - INIT_LIST_HEAD(&peer->ksnp_tx_queue); - INIT_LIST_HEAD(&peer->ksnp_zc_req_list); - spin_lock_init(&peer->ksnp_lock); + peer_ni->ksnp_ni = ni; + peer_ni->ksnp_id = id; + atomic_set(&peer_ni->ksnp_refcount, 1); /* 1 ref for caller */ + peer_ni->ksnp_closing = 0; + peer_ni->ksnp_accepting = 0; + peer_ni->ksnp_proto = NULL; + peer_ni->ksnp_last_alive = 0; + peer_ni->ksnp_zc_next_cookie = SOCKNAL_KEEPALIVE_PING + 1; + + INIT_LIST_HEAD(&peer_ni->ksnp_conns); + INIT_LIST_HEAD(&peer_ni->ksnp_routes); + INIT_LIST_HEAD(&peer_ni->ksnp_tx_queue); + INIT_LIST_HEAD(&peer_ni->ksnp_zc_req_list); + spin_lock_init(&peer_ni->ksnp_lock); spin_lock_bh(&net->ksnn_lock); if (net->ksnn_shutdown) { spin_unlock_bh(&net->ksnn_lock); - kfree(peer); - CERROR("Can't create peer: network shutdown\n"); + kfree(peer_ni); + CERROR("Can't create peer_ni: network shutdown\n"); return -ESHUTDOWN; } @@ -143,31 +143,31 @@ ksocknal_create_peer(struct ksock_peer **peerp, struct lnet_ni *ni, spin_unlock_bh(&net->ksnn_lock); - *peerp = peer; + *peerp = peer_ni; return 0; } void -ksocknal_destroy_peer(struct ksock_peer *peer) +ksocknal_destroy_peer(struct ksock_peer *peer_ni) { - struct ksock_net *net = peer->ksnp_ni->ni_data; + struct ksock_net *net = peer_ni->ksnp_ni->ni_data; - CDEBUG(D_NET, "peer %s %p deleted\n", - libcfs_id2str(peer->ksnp_id), peer); + CDEBUG(D_NET, "peer_ni %s %p deleted\n", + libcfs_id2str(peer_ni->ksnp_id), peer_ni); - LASSERT(!atomic_read(&peer->ksnp_refcount)); - LASSERT(!peer->ksnp_accepting); - LASSERT(list_empty(&peer->ksnp_conns)); - LASSERT(list_empty(&peer->ksnp_routes)); - LASSERT(list_empty(&peer->ksnp_tx_queue)); - LASSERT(list_empty(&peer->ksnp_zc_req_list)); + LASSERT(!atomic_read(&peer_ni->ksnp_refcount)); + LASSERT(!peer_ni->ksnp_accepting); + LASSERT(list_empty(&peer_ni->ksnp_conns)); + LASSERT(list_empty(&peer_ni->ksnp_routes)); + LASSERT(list_empty(&peer_ni->ksnp_tx_queue)); + LASSERT(list_empty(&peer_ni->ksnp_zc_req_list)); - kfree(peer); + kfree(peer_ni); /* - * NB a peer's connections and routes keep a reference on their peer + * NB a peer_ni's connections and routes keep a reference on their peer * until they are destroyed, so we can be assured that _all_ state to - * do with this peer has been cleaned up when its refcount drops to + * do with this peer_ni has been cleaned up when its refcount drops to * zero. */ spin_lock_bh(&net->ksnn_lock); @@ -179,22 +179,22 @@ struct ksock_peer * ksocknal_find_peer_locked(struct lnet_ni *ni, struct lnet_process_id id) { struct list_head *peer_list = ksocknal_nid2peerlist(id.nid); - struct ksock_peer *peer; + struct ksock_peer *peer_ni; - list_for_each_entry(peer, peer_list, ksnp_list) { - LASSERT(!peer->ksnp_closing); + list_for_each_entry(peer_ni, peer_list, ksnp_list) { + LASSERT(!peer_ni->ksnp_closing); - if (peer->ksnp_ni != ni) + if (peer_ni->ksnp_ni != ni) continue; - if (peer->ksnp_id.nid != id.nid || - peer->ksnp_id.pid != id.pid) + if (peer_ni->ksnp_id.nid != id.nid || + peer_ni->ksnp_id.pid != id.pid) continue; - CDEBUG(D_NET, "got peer [%p] -> %s (%d)\n", - peer, libcfs_id2str(id), - atomic_read(&peer->ksnp_refcount)); - return peer; + CDEBUG(D_NET, "got peer_ni [%p] -> %s (%d)\n", + peer_ni, libcfs_id2str(id), + atomic_read(&peer_ni->ksnp_refcount)); + return peer_ni; } return NULL; } @@ -202,47 +202,47 @@ ksocknal_find_peer_locked(struct lnet_ni *ni, struct lnet_process_id id) struct ksock_peer * ksocknal_find_peer(struct lnet_ni *ni, struct lnet_process_id id) { - struct ksock_peer *peer; + struct ksock_peer *peer_ni; read_lock(&ksocknal_data.ksnd_global_lock); - peer = ksocknal_find_peer_locked(ni, id); - if (peer) /* +1 ref for caller? */ - ksocknal_peer_addref(peer); + peer_ni = ksocknal_find_peer_locked(ni, id); + if (peer_ni) /* +1 ref for caller? */ + ksocknal_peer_addref(peer_ni); read_unlock(&ksocknal_data.ksnd_global_lock); - return peer; + return peer_ni; } static void -ksocknal_unlink_peer_locked(struct ksock_peer *peer) +ksocknal_unlink_peer_locked(struct ksock_peer *peer_ni) { int i; __u32 ip; struct ksock_interface *iface; - for (i = 0; i < peer->ksnp_n_passive_ips; i++) { + for (i = 0; i < peer_ni->ksnp_n_passive_ips; i++) { LASSERT(i < LNET_MAX_INTERFACES); - ip = peer->ksnp_passive_ips[i]; + ip = peer_ni->ksnp_passive_ips[i]; - iface = ksocknal_ip2iface(peer->ksnp_ni, ip); + iface = ksocknal_ip2iface(peer_ni->ksnp_ni, ip); /* - * All IPs in peer->ksnp_passive_ips[] come from the + * All IPs in peer_ni->ksnp_passive_ips[] come from the * interface list, therefore the call must succeed. */ LASSERT(iface); - CDEBUG(D_NET, "peer=%p iface=%p ksni_nroutes=%d\n", - peer, iface, iface->ksni_nroutes); + CDEBUG(D_NET, "peer_ni=%p iface=%p ksni_nroutes=%d\n", + peer_ni, iface, iface->ksni_nroutes); iface->ksni_npeers--; } - LASSERT(list_empty(&peer->ksnp_conns)); - LASSERT(list_empty(&peer->ksnp_routes)); - LASSERT(!peer->ksnp_closing); - peer->ksnp_closing = 1; - list_del(&peer->ksnp_list); + LASSERT(list_empty(&peer_ni->ksnp_conns)); + LASSERT(list_empty(&peer_ni->ksnp_routes)); + LASSERT(!peer_ni->ksnp_closing); + peer_ni->ksnp_closing = 1; + list_del(&peer_ni->ksnp_list); /* lose peerlist's ref */ - ksocknal_peer_decref(peer); + ksocknal_peer_decref(peer_ni); } static int @@ -250,7 +250,7 @@ ksocknal_get_peer_info(struct lnet_ni *ni, int index, struct lnet_process_id *id, __u32 *myip, __u32 *peer_ip, int *port, int *conn_count, int *share_count) { - struct ksock_peer *peer; + struct ksock_peer *peer_ni; struct ksock_route *route; int i; int j; @@ -259,17 +259,17 @@ ksocknal_get_peer_info(struct lnet_ni *ni, int index, read_lock(&ksocknal_data.ksnd_global_lock); for (i = 0; i < ksocknal_data.ksnd_peer_hash_size; i++) { - list_for_each_entry(peer, &ksocknal_data.ksnd_peers[i], ksnp_list) { - - if (peer->ksnp_ni != ni) + list_for_each_entry(peer_ni, &ksocknal_data.ksnd_peers[i], + ksnp_list) { + if (peer_ni->ksnp_ni != ni) continue; - if (!peer->ksnp_n_passive_ips && - list_empty(&peer->ksnp_routes)) { + if (!peer_ni->ksnp_n_passive_ips && + list_empty(&peer_ni->ksnp_routes)) { if (index-- > 0) continue; - *id = peer->ksnp_id; + *id = peer_ni->ksnp_id; *myip = 0; *peer_ip = 0; *port = 0; @@ -279,12 +279,12 @@ ksocknal_get_peer_info(struct lnet_ni *ni, int index, goto out; } - for (j = 0; j < peer->ksnp_n_passive_ips; j++) { + for (j = 0; j < peer_ni->ksnp_n_passive_ips; j++) { if (index-- > 0) continue; - *id = peer->ksnp_id; - *myip = peer->ksnp_passive_ips[j]; + *id = peer_ni->ksnp_id; + *myip = peer_ni->ksnp_passive_ips[j]; *peer_ip = 0; *port = 0; *conn_count = 0; @@ -293,12 +293,12 @@ ksocknal_get_peer_info(struct lnet_ni *ni, int index, goto out; } - list_for_each_entry(route, &peer->ksnp_routes, + list_for_each_entry(route, &peer_ni->ksnp_routes, ksnr_list) { if (index-- > 0) continue; - *id = peer->ksnp_id; + *id = peer_ni->ksnp_id; *myip = route->ksnr_myipaddr; *peer_ip = route->ksnr_ipaddr; *port = route->ksnr_port; @@ -318,7 +318,7 @@ static void ksocknal_associate_route_conn_locked(struct ksock_route *route, struct ksock_conn *conn) { - struct ksock_peer *peer = route->ksnr_peer; + struct ksock_peer *peer_ni = route->ksnr_peer; int type = conn->ksnc_type; struct ksock_interface *iface; @@ -329,12 +329,12 @@ ksocknal_associate_route_conn_locked(struct ksock_route *route, if (!route->ksnr_myipaddr) { /* route wasn't bound locally yet (the initial route) */ CDEBUG(D_NET, "Binding %s %pI4h to %pI4h\n", - libcfs_id2str(peer->ksnp_id), + libcfs_id2str(peer_ni->ksnp_id), &route->ksnr_ipaddr, &conn->ksnc_myipaddr); } else { CDEBUG(D_NET, "Rebinding %s %pI4h from %pI4h to %pI4h\n", - libcfs_id2str(peer->ksnp_id), + libcfs_id2str(peer_ni->ksnp_id), &route->ksnr_ipaddr, &route->ksnr_myipaddr, &conn->ksnc_myipaddr); @@ -362,33 +362,33 @@ ksocknal_associate_route_conn_locked(struct ksock_route *route, } static void -ksocknal_add_route_locked(struct ksock_peer *peer, struct ksock_route *route) +ksocknal_add_route_locked(struct ksock_peer *peer_ni, struct ksock_route *route) { struct ksock_conn *conn; struct ksock_route *route2; - LASSERT(!peer->ksnp_closing); + LASSERT(!peer_ni->ksnp_closing); LASSERT(!route->ksnr_peer); LASSERT(!route->ksnr_scheduled); LASSERT(!route->ksnr_connecting); LASSERT(!route->ksnr_connected); /* LASSERT(unique) */ - list_for_each_entry(route2, &peer->ksnp_routes, ksnr_list) { + list_for_each_entry(route2, &peer_ni->ksnp_routes, ksnr_list) { if (route2->ksnr_ipaddr == route->ksnr_ipaddr) { CERROR("Duplicate route %s %pI4h\n", - libcfs_id2str(peer->ksnp_id), + libcfs_id2str(peer_ni->ksnp_id), &route->ksnr_ipaddr); LBUG(); } } - route->ksnr_peer = peer; - ksocknal_peer_addref(peer); - /* peer's routelist takes over my ref on 'route' */ - list_add_tail(&route->ksnr_list, &peer->ksnp_routes); + route->ksnr_peer = peer_ni; + ksocknal_peer_addref(peer_ni); + /* peer_ni's routelist takes over my ref on 'route' */ + list_add_tail(&route->ksnr_list, &peer_ni->ksnp_routes); - list_for_each_entry(conn, &peer->ksnp_conns, ksnc_list) { + list_for_each_entry(conn, &peer_ni->ksnp_conns, ksnc_list) { if (conn->ksnc_ipaddr != route->ksnr_ipaddr) continue; @@ -400,7 +400,7 @@ ksocknal_add_route_locked(struct ksock_peer *peer, struct ksock_route *route) static void ksocknal_del_route_locked(struct ksock_route *route) { - struct ksock_peer *peer = route->ksnr_peer; + struct ksock_peer *peer_ni = route->ksnr_peer; struct ksock_interface *iface; struct ksock_conn *conn; struct list_head *ctmp; @@ -409,7 +409,7 @@ ksocknal_del_route_locked(struct ksock_route *route) LASSERT(!route->ksnr_deleted); /* Close associated conns */ - list_for_each_safe(ctmp, cnxt, &peer->ksnp_conns) { + list_for_each_safe(ctmp, cnxt, &peer_ni->ksnp_conns) { conn = list_entry(ctmp, struct ksock_conn, ksnc_list); if (conn->ksnc_route != route) @@ -427,15 +427,15 @@ ksocknal_del_route_locked(struct ksock_route *route) route->ksnr_deleted = 1; list_del(&route->ksnr_list); - ksocknal_route_decref(route); /* drop peer's ref */ + ksocknal_route_decref(route); /* drop peer_ni's ref */ - if (list_empty(&peer->ksnp_routes) && - list_empty(&peer->ksnp_conns)) { + if (list_empty(&peer_ni->ksnp_routes) && + list_empty(&peer_ni->ksnp_conns)) { /* - * I've just removed the last route to a peer with no active + * I've just removed the last route to a peer_ni with no active * connections */ - ksocknal_unlink_peer_locked(peer); + ksocknal_unlink_peer_locked(peer_ni); } } @@ -443,7 +443,7 @@ int ksocknal_add_peer(struct lnet_ni *ni, struct lnet_process_id id, __u32 ipaddr, int port) { - struct ksock_peer *peer; + struct ksock_peer *peer_ni; struct ksock_peer *peer2; struct ksock_route *route; struct ksock_route *route2; @@ -453,14 +453,14 @@ ksocknal_add_peer(struct lnet_ni *ni, struct lnet_process_id id, __u32 ipaddr, id.pid == LNET_PID_ANY) return -EINVAL; - /* Have a brand new peer ready... */ - rc = ksocknal_create_peer(&peer, ni, id); + /* Have a brand new peer_ni ready... */ + rc = ksocknal_create_peer(&peer_ni, ni, id); if (rc) return rc; route = ksocknal_create_route(ipaddr, port); if (!route) { - ksocknal_peer_decref(peer); + ksocknal_peer_decref(peer_ni); return -ENOMEM; } @@ -471,15 +471,15 @@ ksocknal_add_peer(struct lnet_ni *ni, struct lnet_process_id id, __u32 ipaddr, peer2 = ksocknal_find_peer_locked(ni, id); if (peer2) { - ksocknal_peer_decref(peer); - peer = peer2; + ksocknal_peer_decref(peer_ni); + peer_ni = peer2; } else { - /* peer table takes my ref on peer */ - list_add_tail(&peer->ksnp_list, + /* peer_ni table takes my ref on peer_ni */ + list_add_tail(&peer_ni->ksnp_list, ksocknal_nid2peerlist(id.nid)); } - list_for_each_entry(route2, &peer->ksnp_routes, ksnr_list) { + list_for_each_entry(route2, &peer_ni->ksnp_routes, ksnr_list) { if (route2->ksnr_ipaddr == ipaddr) { /* Route already exists, use the old one */ ksocknal_route_decref(route); @@ -488,7 +488,7 @@ ksocknal_add_peer(struct lnet_ni *ni, struct lnet_process_id id, __u32 ipaddr, } } /* Route doesn't already exist, add the new one */ - ksocknal_add_route_locked(peer, route); + ksocknal_add_route_locked(peer_ni, route); route->ksnr_share_count++; out: write_unlock_bh(&ksocknal_data.ksnd_global_lock); @@ -497,7 +497,7 @@ ksocknal_add_peer(struct lnet_ni *ni, struct lnet_process_id id, __u32 ipaddr, } static void -ksocknal_del_peer_locked(struct ksock_peer *peer, __u32 ip) +ksocknal_del_peer_locked(struct ksock_peer *peer_ni, __u32 ip) { struct ksock_conn *conn; struct ksock_route *route; @@ -505,12 +505,12 @@ ksocknal_del_peer_locked(struct ksock_peer *peer, __u32 ip) struct list_head *nxt; int nshared; - LASSERT(!peer->ksnp_closing); + LASSERT(!peer_ni->ksnp_closing); - /* Extra ref prevents peer disappearing until I'm done with it */ - ksocknal_peer_addref(peer); + /* Extra ref prevents peer_ni disappearing until I'm done with it */ + ksocknal_peer_addref(peer_ni); - list_for_each_safe(tmp, nxt, &peer->ksnp_routes) { + list_for_each_safe(tmp, nxt, &peer_ni->ksnp_routes) { route = list_entry(tmp, struct ksock_route, ksnr_list); /* no match */ @@ -523,7 +523,7 @@ ksocknal_del_peer_locked(struct ksock_peer *peer, __u32 ip) } nshared = 0; - list_for_each_safe(tmp, nxt, &peer->ksnp_routes) { + list_for_each_safe(tmp, nxt, &peer_ni->ksnp_routes) { route = list_entry(tmp, struct ksock_route, ksnr_list); nshared += route->ksnr_share_count; } @@ -533,7 +533,7 @@ ksocknal_del_peer_locked(struct ksock_peer *peer, __u32 ip) * remove everything else if there are no explicit entries * left */ - list_for_each_safe(tmp, nxt, &peer->ksnp_routes) { + list_for_each_safe(tmp, nxt, &peer_ni->ksnp_routes) { route = list_entry(tmp, struct ksock_route, ksnr_list); /* we should only be removing auto-entries */ @@ -541,24 +541,23 @@ ksocknal_del_peer_locked(struct ksock_peer *peer, __u32 ip) ksocknal_del_route_locked(route); } - list_for_each_safe(tmp, nxt, &peer->ksnp_conns) { + list_for_each_safe(tmp, nxt, &peer_ni->ksnp_conns) { conn = list_entry(tmp, struct ksock_conn, ksnc_list); ksocknal_close_conn_locked(conn, 0); } } - ksocknal_peer_decref(peer); - /* NB peer unlinks itself when last conn/route is removed */ + ksocknal_peer_decref(peer_ni); + /* NB peer_ni unlinks itself when last conn/route is removed */ } static int ksocknal_del_peer(struct lnet_ni *ni, struct lnet_process_id id, __u32 ip) { LIST_HEAD(zombies); - struct list_head *ptmp; - struct list_head *pnxt; - struct ksock_peer *peer; + struct ksock_peer *pnxt; + struct ksock_peer *peer_ni; int lo; int hi; int i; @@ -575,30 +574,32 @@ ksocknal_del_peer(struct lnet_ni *ni, struct lnet_process_id id, __u32 ip) } for (i = lo; i <= hi; i++) { - list_for_each_safe(ptmp, pnxt, &ksocknal_data.ksnd_peers[i]) { - peer = list_entry(ptmp, struct ksock_peer, ksnp_list); - - if (peer->ksnp_ni != ni) + list_for_each_entry_safe(peer_ni, pnxt, + &ksocknal_data.ksnd_peers[i], + ksnp_list) { + if (peer_ni->ksnp_ni != ni) continue; - if (!((id.nid == LNET_NID_ANY || peer->ksnp_id.nid == id.nid) && - (id.pid == LNET_PID_ANY || peer->ksnp_id.pid == id.pid))) + if (!((id.nid == LNET_NID_ANY || + peer_ni->ksnp_id.nid == id.nid) && + (id.pid == LNET_PID_ANY || + peer_ni->ksnp_id.pid == id.pid))) continue; - ksocknal_peer_addref(peer); /* a ref for me... */ + ksocknal_peer_addref(peer_ni); /* a ref for me... */ - ksocknal_del_peer_locked(peer, ip); + ksocknal_del_peer_locked(peer_ni, ip); - if (peer->ksnp_closing && - !list_empty(&peer->ksnp_tx_queue)) { - LASSERT(list_empty(&peer->ksnp_conns)); - LASSERT(list_empty(&peer->ksnp_routes)); + if (peer_ni->ksnp_closing && + !list_empty(&peer_ni->ksnp_tx_queue)) { + LASSERT(list_empty(&peer_ni->ksnp_conns)); + LASSERT(list_empty(&peer_ni->ksnp_routes)); - list_splice_init(&peer->ksnp_tx_queue, + list_splice_init(&peer_ni->ksnp_tx_queue, &zombies); } - ksocknal_peer_decref(peer); /* ...till here */ + ksocknal_peer_decref(peer_ni); /* ...till here */ rc = 0; /* matched! */ } @@ -614,20 +615,22 @@ ksocknal_del_peer(struct lnet_ni *ni, struct lnet_process_id id, __u32 ip) static struct ksock_conn * ksocknal_get_conn_by_idx(struct lnet_ni *ni, int index) { - struct ksock_peer *peer; + struct ksock_peer *peer_ni; struct ksock_conn *conn; int i; read_lock(&ksocknal_data.ksnd_global_lock); for (i = 0; i < ksocknal_data.ksnd_peer_hash_size; i++) { - list_for_each_entry(peer, &ksocknal_data.ksnd_peers[i], ksnp_list) { - LASSERT(!peer->ksnp_closing); + list_for_each_entry(peer_ni, &ksocknal_data.ksnd_peers[i], + ksnp_list) { + LASSERT(!peer_ni->ksnp_closing); - if (peer->ksnp_ni != ni) + if (peer_ni->ksnp_ni != ni) continue; - list_for_each_entry(conn, &peer->ksnp_conns, ksnc_list) { + list_for_each_entry(conn, &peer_ni->ksnp_conns, + ksnc_list) { if (index-- > 0) continue; @@ -728,10 +731,10 @@ ksocknal_match_peerip(struct ksock_interface *iface, __u32 *ips, int nips) } static int -ksocknal_select_ips(struct ksock_peer *peer, __u32 *peerips, int n_peerips) +ksocknal_select_ips(struct ksock_peer *peer_ni, __u32 *peerips, int n_peerips) { rwlock_t *global_lock = &ksocknal_data.ksnd_global_lock; - struct ksock_net *net = peer->ksnp_ni->ni_data; + struct ksock_net *net = peer_ni->ksnp_ni->ni_data; struct ksock_interface *iface; struct ksock_interface *best_iface; int n_ips; @@ -766,26 +769,26 @@ ksocknal_select_ips(struct ksock_peer *peer, __u32 *peerips, int n_peerips) n_ips = (net->ksnn_ninterfaces < 2) ? 0 : min(n_peerips, net->ksnn_ninterfaces); - for (i = 0; peer->ksnp_n_passive_ips < n_ips; i++) { + for (i = 0; peer_ni->ksnp_n_passive_ips < n_ips; i++) { /* ^ yes really... */ /* * If we have any new interfaces, first tick off all the - * peer IPs that match old interfaces, then choose new - * interfaces to match the remaining peer IPS. + * peer_ni IPs that match old interfaces, then choose new + * interfaces to match the remaining peer_ni IPS. * We don't forget interfaces we've stopped using; we might * start using them again... */ - if (i < peer->ksnp_n_passive_ips) { + if (i < peer_ni->ksnp_n_passive_ips) { /* Old interface. */ - ip = peer->ksnp_passive_ips[i]; - best_iface = ksocknal_ip2iface(peer->ksnp_ni, ip); + ip = peer_ni->ksnp_passive_ips[i]; + best_iface = ksocknal_ip2iface(peer_ni->ksnp_ni, ip); - /* peer passive ips are kept up to date */ + /* peer_ni passive ips are kept up to date */ LASSERT(best_iface); } else { /* choose a new interface */ - LASSERT(i == peer->ksnp_n_passive_ips); + LASSERT(i == peer_ni->ksnp_n_passive_ips); best_iface = NULL; best_netmatch = 0; @@ -795,11 +798,14 @@ ksocknal_select_ips(struct ksock_peer *peer, __u32 *peerips, int n_peerips) iface = &net->ksnn_interfaces[j]; ip = iface->ksni_ipaddr; - for (k = 0; k < peer->ksnp_n_passive_ips; k++) - if (peer->ksnp_passive_ips[k] == ip) + for (k = 0; + k < peer_ni->ksnp_n_passive_ips; + k++) + if (peer_ni->ksnp_passive_ips[k] == ip) break; - if (k < peer->ksnp_n_passive_ips) /* using it already */ + if (k < peer_ni->ksnp_n_passive_ips) + /* using it already */ continue; k = ksocknal_match_peerip(iface, peerips, @@ -822,17 +828,17 @@ ksocknal_select_ips(struct ksock_peer *peer, __u32 *peerips, int n_peerips) best_iface->ksni_npeers++; ip = best_iface->ksni_ipaddr; - peer->ksnp_passive_ips[i] = ip; - peer->ksnp_n_passive_ips = i + 1; + peer_ni->ksnp_passive_ips[i] = ip; + peer_ni->ksnp_n_passive_ips = i + 1; } - /* mark the best matching peer IP used */ + /* mark the best matching peer_ni IP used */ j = ksocknal_match_peerip(best_iface, peerips, n_peerips); peerips[j] = 0; } - /* Overwrite input peer IP addresses */ - memcpy(peerips, peer->ksnp_passive_ips, n_ips * sizeof(*peerips)); + /* Overwrite input peer_ni IP addresses */ + memcpy(peerips, peer_ni->ksnp_passive_ips, n_ips * sizeof(*peerips)); write_unlock_bh(global_lock); @@ -840,12 +846,12 @@ ksocknal_select_ips(struct ksock_peer *peer, __u32 *peerips, int n_peerips) } static void -ksocknal_create_routes(struct ksock_peer *peer, int port, +ksocknal_create_routes(struct ksock_peer *peer_ni, int port, __u32 *peer_ipaddrs, int npeer_ipaddrs) { struct ksock_route *newroute = NULL; rwlock_t *global_lock = &ksocknal_data.ksnd_global_lock; - struct lnet_ni *ni = peer->ksnp_ni; + struct lnet_ni *ni = peer_ni->ksnp_ni; struct ksock_net *net = ni->ni_data; struct ksock_route *route; struct ksock_interface *iface; @@ -888,13 +894,13 @@ ksocknal_create_routes(struct ksock_peer *peer, int port, write_lock_bh(global_lock); } - if (peer->ksnp_closing) { - /* peer got closed under me */ + if (peer_ni->ksnp_closing) { + /* peer_ni got closed under me */ break; } /* Already got a route? */ - list_for_each_entry(route, &peer->ksnp_routes, ksnr_list) + list_for_each_entry(route, &peer_ni->ksnp_routes, ksnr_list) if (route->ksnr_ipaddr != newroute->ksnr_ipaddr) goto next_ipaddr; @@ -909,7 +915,8 @@ ksocknal_create_routes(struct ksock_peer *peer, int port, iface = &net->ksnn_interfaces[j]; /* Using this interface already? */ - list_for_each_entry(route, &peer->ksnp_routes, ksnr_list) + list_for_each_entry(route, &peer_ni->ksnp_routes, + ksnr_list) if (route->ksnr_myipaddr == iface->ksni_ipaddr) goto next_iface; @@ -935,7 +942,7 @@ ksocknal_create_routes(struct ksock_peer *peer, int port, newroute->ksnr_myipaddr = best_iface->ksni_ipaddr; best_iface->ksni_nroutes++; - ksocknal_add_route_locked(peer, newroute); + ksocknal_add_route_locked(peer_ni, newroute); newroute = NULL; next_ipaddr:; } @@ -977,11 +984,11 @@ ksocknal_accept(struct lnet_ni *ni, struct socket *sock) } static int -ksocknal_connecting(struct ksock_peer *peer, __u32 ipaddr) +ksocknal_connecting(struct ksock_peer *peer_ni, __u32 ipaddr) { struct ksock_route *route; - list_for_each_entry(route, &peer->ksnp_routes, ksnr_list) { + list_for_each_entry(route, &peer_ni->ksnp_routes, ksnr_list) { if (route->ksnr_ipaddr == ipaddr) return route->ksnr_connecting; } @@ -998,7 +1005,7 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route, __u64 incarnation; struct ksock_conn *conn; struct ksock_conn *conn2; - struct ksock_peer *peer = NULL; + struct ksock_peer *peer_ni = NULL; struct ksock_peer *peer2; struct ksock_sched *sched; struct ksock_hello_msg *hello; @@ -1054,21 +1061,21 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route, goto failed_1; /* - * Find out/confirm peer's NID and connection type and get the + * Find out/confirm peer_ni's NID and connection type and get the * vector of interfaces she's willing to let me connect to. - * Passive connections use the listener timeout since the peer sends + * Passive connections use the listener timeout since the peer_ni sends * eagerly */ if (active) { - peer = route->ksnr_peer; - LASSERT(ni == peer->ksnp_ni); + peer_ni = route->ksnr_peer; + LASSERT(ni == peer_ni->ksnp_ni); /* Active connection sends HELLO eagerly */ hello->kshm_nips = ksocknal_local_ipvec(ni, hello->kshm_ips); - peerid = peer->ksnp_id; + peerid = peer_ni->ksnp_id; write_lock_bh(global_lock); - conn->ksnc_proto = peer->ksnp_proto; + conn->ksnc_proto = peer_ni->ksnp_proto; write_unlock_bh(global_lock); if (!conn->ksnc_proto) { @@ -1088,7 +1095,7 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route, peerid.nid = LNET_NID_ANY; peerid.pid = LNET_PID_ANY; - /* Passive, get protocol from peer */ + /* Passive, get protocol from peer_ni */ conn->ksnc_proto = NULL; } @@ -1103,10 +1110,10 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route, cpt = lnet_cpt_of_nid(peerid.nid, ni); if (active) { - ksocknal_peer_addref(peer); + ksocknal_peer_addref(peer_ni); write_lock_bh(global_lock); } else { - rc = ksocknal_create_peer(&peer, ni, peerid); + rc = ksocknal_create_peer(&peer_ni, ni, peerid); if (rc) goto failed_1; @@ -1118,61 +1125,61 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route, peer2 = ksocknal_find_peer_locked(ni, peerid); if (!peer2) { /* - * NB this puts an "empty" peer in the peer + * NB this puts an "empty" peer_ni in the peer * table (which takes my ref) */ - list_add_tail(&peer->ksnp_list, + list_add_tail(&peer_ni->ksnp_list, ksocknal_nid2peerlist(peerid.nid)); } else { - ksocknal_peer_decref(peer); - peer = peer2; + ksocknal_peer_decref(peer_ni); + peer_ni = peer2; } /* +1 ref for me */ - ksocknal_peer_addref(peer); - peer->ksnp_accepting++; + ksocknal_peer_addref(peer_ni); + peer_ni->ksnp_accepting++; /* * Am I already connecting to this guy? Resolve in * favour of higher NID... */ if (peerid.nid < ni->ni_nid && - ksocknal_connecting(peer, conn->ksnc_ipaddr)) { + ksocknal_connecting(peer_ni, conn->ksnc_ipaddr)) { rc = EALREADY; warn = "connection race resolution"; goto failed_2; } } - if (peer->ksnp_closing || + if (peer_ni->ksnp_closing || (active && route->ksnr_deleted)) { - /* peer/route got closed under me */ + /* peer_ni/route got closed under me */ rc = -ESTALE; - warn = "peer/route removed"; + warn = "peer_ni/route removed"; goto failed_2; } - if (!peer->ksnp_proto) { + if (!peer_ni->ksnp_proto) { /* * Never connected before. * NB recv_hello may have returned EPROTO to signal my peer * wants a different protocol than the one I asked for. */ - LASSERT(list_empty(&peer->ksnp_conns)); + LASSERT(list_empty(&peer_ni->ksnp_conns)); - peer->ksnp_proto = conn->ksnc_proto; - peer->ksnp_incarnation = incarnation; + peer_ni->ksnp_proto = conn->ksnc_proto; + peer_ni->ksnp_incarnation = incarnation; } - if (peer->ksnp_proto != conn->ksnc_proto || - peer->ksnp_incarnation != incarnation) { - /* Peer rebooted or I've got the wrong protocol version */ - ksocknal_close_peer_conns_locked(peer, 0, 0); + if (peer_ni->ksnp_proto != conn->ksnc_proto || + peer_ni->ksnp_incarnation != incarnation) { + /* peer_ni rebooted or I've got the wrong protocol version */ + ksocknal_close_peer_conns_locked(peer_ni, 0, 0); - peer->ksnp_proto = NULL; + peer_ni->ksnp_proto = NULL; rc = ESTALE; - warn = peer->ksnp_incarnation != incarnation ? - "peer rebooted" : + warn = peer_ni->ksnp_incarnation != incarnation ? + "peer_ni rebooted" : "wrong proto version"; goto failed_2; } @@ -1195,7 +1202,7 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route, * loopback connection */ if (conn->ksnc_ipaddr != conn->ksnc_myipaddr) { - list_for_each_entry(conn2, &peer->ksnp_conns, ksnc_list) { + list_for_each_entry(conn2, &peer_ni->ksnp_conns, ksnc_list) { if (conn2->ksnc_ipaddr != conn->ksnc_ipaddr || conn2->ksnc_myipaddr != conn->ksnc_myipaddr || @@ -1223,7 +1230,7 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route, if (active && route->ksnr_ipaddr != conn->ksnc_ipaddr) { CERROR("Route %s %pI4h connected to %pI4h\n", - libcfs_id2str(peer->ksnp_id), + libcfs_id2str(peer_ni->ksnp_id), &route->ksnr_ipaddr, &conn->ksnc_ipaddr); } @@ -1231,10 +1238,10 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route, /* * Search for a route corresponding to the new connection and * create an association. This allows incoming connections created - * by routes in my peer to match my own route entries so I don't + * by routes in my peer_ni to match my own route entries so I don't * continually create duplicate routes. */ - list_for_each_entry(route, &peer->ksnp_routes, ksnr_list) { + list_for_each_entry(route, &peer_ni->ksnp_routes, ksnr_list) { if (route->ksnr_ipaddr != conn->ksnc_ipaddr) continue; @@ -1242,10 +1249,10 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route, break; } - conn->ksnc_peer = peer; /* conn takes my ref on peer */ - peer->ksnp_last_alive = ktime_get_seconds(); - peer->ksnp_send_keepalive = 0; - peer->ksnp_error = 0; + conn->ksnc_peer = peer_ni; /* conn takes my ref on peer_ni */ + peer_ni->ksnp_last_alive = ktime_get_seconds(); + peer_ni->ksnp_send_keepalive = 0; + peer_ni->ksnp_error = 0; sched = ksocknal_choose_scheduler_locked(cpt); sched->kss_nconns++; @@ -1256,9 +1263,9 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route, conn->ksnc_tx_bufnob = sock->sk->sk_wmem_queued; conn->ksnc_tx_deadline = ktime_get_seconds() + *ksocknal_tunables.ksnd_timeout; - mb(); /* order with adding to peer's conn list */ + mb(); /* order with adding to peer_ni's conn list */ - list_add(&conn->ksnc_list, &peer->ksnp_conns); + list_add(&conn->ksnc_list, &peer_ni->ksnp_conns); ksocknal_conn_addref(conn); ksocknal_new_packet(conn, 0); @@ -1266,7 +1273,7 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route, conn->ksnc_zc_capable = ksocknal_lib_zc_capable(conn); /* Take packets blocking for this connection. */ - list_for_each_entry_safe(tx, txtmp, &peer->ksnp_tx_queue, tx_list) { + list_for_each_entry_safe(tx, txtmp, &peer_ni->ksnp_tx_queue, tx_list) { int match = conn->ksnc_proto->pro_match_tx(conn, tx, tx->tx_nonblk); @@ -1295,10 +1302,10 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route, if (active) { /* additional routes after interface exchange? */ - ksocknal_create_routes(peer, conn->ksnc_port, + ksocknal_create_routes(peer_ni, conn->ksnc_port, hello->kshm_ips, hello->kshm_nips); } else { - hello->kshm_nips = ksocknal_select_ips(peer, hello->kshm_ips, + hello->kshm_nips = ksocknal_select_ips(peer_ni, hello->kshm_ips, hello->kshm_nips); rc = ksocknal_send_hello(ni, conn, peerid.nid, hello); } @@ -1321,7 +1328,7 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route, ksocknal_lib_set_callback(sock, conn); if (!active) - peer->ksnp_accepting--; + peer_ni->ksnp_accepting--; write_unlock_bh(global_lock); @@ -1344,12 +1351,12 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route, return rc; failed_2: - if (!peer->ksnp_closing && - list_empty(&peer->ksnp_conns) && - list_empty(&peer->ksnp_routes)) { - list_add(&zombies, &peer->ksnp_tx_queue); - list_del_init(&peer->ksnp_tx_queue); - ksocknal_unlink_peer_locked(peer); + if (!peer_ni->ksnp_closing && + list_empty(&peer_ni->ksnp_conns) && + list_empty(&peer_ni->ksnp_routes)) { + list_add(&zombies, &peer_ni->ksnp_tx_queue); + list_del_init(&peer_ni->ksnp_tx_queue); + ksocknal_unlink_peer_locked(peer_ni); } write_unlock_bh(global_lock); @@ -1375,12 +1382,12 @@ ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route, } write_lock_bh(global_lock); - peer->ksnp_accepting--; + peer_ni->ksnp_accepting--; write_unlock_bh(global_lock); } ksocknal_txlist_done(ni, &zombies, 1); - ksocknal_peer_decref(peer); + ksocknal_peer_decref(peer_ni); failed_1: kvfree(hello); @@ -1400,15 +1407,15 @@ ksocknal_close_conn_locked(struct ksock_conn *conn, int error) * connection for the reaper to terminate. * Caller holds ksnd_global_lock exclusively in irq context */ - struct ksock_peer *peer = conn->ksnc_peer; + struct ksock_peer *peer_ni = conn->ksnc_peer; struct ksock_route *route; struct ksock_conn *conn2; - LASSERT(!peer->ksnp_error); + LASSERT(!peer_ni->ksnp_error); LASSERT(!conn->ksnc_closing); conn->ksnc_closing = 1; - /* ksnd_deathrow_conns takes over peer's ref */ + /* ksnd_deathrow_conns takes over peer_ni's ref */ list_del(&conn->ksnc_list); route = conn->ksnc_route; @@ -1417,7 +1424,7 @@ ksocknal_close_conn_locked(struct ksock_conn *conn, int error) LASSERT(!route->ksnr_deleted); LASSERT(route->ksnr_connected & (1 << conn->ksnc_type)); - list_for_each_entry(conn2, &peer->ksnp_conns, ksnc_list) { + list_for_each_entry(conn2, &peer_ni->ksnp_conns, ksnc_list) { if (conn2->ksnc_route == route && conn2->ksnc_type == conn->ksnc_type) goto conn2_found; @@ -1429,10 +1436,10 @@ ksocknal_close_conn_locked(struct ksock_conn *conn, int error) ksocknal_route_decref(route); /* drop conn's ref on route */ } - if (list_empty(&peer->ksnp_conns)) { - /* No more connections to this peer */ + if (list_empty(&peer_ni->ksnp_conns)) { + /* No more connections to this peer_ni */ - if (!list_empty(&peer->ksnp_tx_queue)) { + if (!list_empty(&peer_ni->ksnp_tx_queue)) { struct ksock_tx *tx; LASSERT(conn->ksnc_proto == &ksocknal_protocol_v3x); @@ -1441,25 +1448,25 @@ ksocknal_close_conn_locked(struct ksock_conn *conn, int error) * throw them to the last connection..., * these TXs will be send to /dev/null by scheduler */ - list_for_each_entry(tx, &peer->ksnp_tx_queue, + list_for_each_entry(tx, &peer_ni->ksnp_tx_queue, tx_list) ksocknal_tx_prep(conn, tx); spin_lock_bh(&conn->ksnc_scheduler->kss_lock); - list_splice_init(&peer->ksnp_tx_queue, + list_splice_init(&peer_ni->ksnp_tx_queue, &conn->ksnc_tx_queue); spin_unlock_bh(&conn->ksnc_scheduler->kss_lock); } - peer->ksnp_proto = NULL; /* renegotiate protocol version */ - peer->ksnp_error = error; /* stash last conn close reason */ + peer_ni->ksnp_proto = NULL; /* renegotiate protocol version */ + peer_ni->ksnp_error = error; /* stash last conn close reason */ - if (list_empty(&peer->ksnp_routes)) { + if (list_empty(&peer_ni->ksnp_routes)) { /* * I've just closed last conn belonging to a - * peer with no routes to it + * peer_ni with no routes to it */ - ksocknal_unlink_peer_locked(peer); + ksocknal_unlink_peer_locked(peer_ni); } } @@ -1473,37 +1480,37 @@ ksocknal_close_conn_locked(struct ksock_conn *conn, int error) } void -ksocknal_peer_failed(struct ksock_peer *peer) +ksocknal_peer_failed(struct ksock_peer *peer_ni) { int notify = 0; time64_t last_alive = 0; /* * There has been a connection failure or comms error; but I'll only - * tell LNET I think the peer is dead if it's to another kernel and + * tell LNET I think the peer_ni is dead if it's to another kernel and * there are no connections or connection attempts in existence. */ read_lock(&ksocknal_data.ksnd_global_lock); - if (!(peer->ksnp_id.pid & LNET_PID_USERFLAG) && - list_empty(&peer->ksnp_conns) && - !peer->ksnp_accepting && - !ksocknal_find_connecting_route_locked(peer)) { + if (!(peer_ni->ksnp_id.pid & LNET_PID_USERFLAG) && + list_empty(&peer_ni->ksnp_conns) && + !peer_ni->ksnp_accepting && + !ksocknal_find_connecting_route_locked(peer_ni)) { notify = 1; - last_alive = peer->ksnp_last_alive; + last_alive = peer_ni->ksnp_last_alive; } read_unlock(&ksocknal_data.ksnd_global_lock); if (notify) - lnet_notify(peer->ksnp_ni, peer->ksnp_id.nid, 0, + lnet_notify(peer_ni->ksnp_ni, peer_ni->ksnp_id.nid, 0, last_alive); } void ksocknal_finalize_zcreq(struct ksock_conn *conn) { - struct ksock_peer *peer = conn->ksnc_peer; + struct ksock_peer *peer_ni = conn->ksnc_peer; struct ksock_tx *tx; struct ksock_tx *tmp; LIST_HEAD(zlist); @@ -1514,9 +1521,10 @@ ksocknal_finalize_zcreq(struct ksock_conn *conn) */ LASSERT(!conn->ksnc_sock); - spin_lock(&peer->ksnp_lock); + spin_lock(&peer_ni->ksnp_lock); - list_for_each_entry_safe(tx, tmp, &peer->ksnp_zc_req_list, tx_zc_list) { + list_for_each_entry_safe(tx, tmp, &peer_ni->ksnp_zc_req_list, + tx_zc_list) { if (tx->tx_conn != conn) continue; @@ -1528,7 +1536,7 @@ ksocknal_finalize_zcreq(struct ksock_conn *conn) list_add(&tx->tx_zc_list, &zlist); } - spin_unlock(&peer->ksnp_lock); + spin_unlock(&peer_ni->ksnp_lock); while (!list_empty(&zlist)) { tx = list_entry(zlist.next, struct ksock_tx, tx_zc_list); @@ -1547,7 +1555,7 @@ ksocknal_terminate_conn(struct ksock_conn *conn) * ksnc_refcount will eventually hit zero, and then the reaper will * destroy it. */ - struct ksock_peer *peer = conn->ksnc_peer; + struct ksock_peer *peer_ni = conn->ksnc_peer; struct ksock_sched *sched = conn->ksnc_scheduler; int failed = 0; @@ -1583,17 +1591,17 @@ ksocknal_terminate_conn(struct ksock_conn *conn) */ conn->ksnc_scheduler->kss_nconns--; - if (peer->ksnp_error) { - /* peer's last conn closed in error */ - LASSERT(list_empty(&peer->ksnp_conns)); + if (peer_ni->ksnp_error) { + /* peer_ni's last conn closed in error */ + LASSERT(list_empty(&peer_ni->ksnp_conns)); failed = 1; - peer->ksnp_error = 0; /* avoid multiple notifications */ + peer_ni->ksnp_error = 0; /* avoid multiple notifications */ } write_unlock_bh(&ksocknal_data.ksnd_global_lock); if (failed) - ksocknal_peer_failed(peer); + ksocknal_peer_failed(peer_ni); /* * The socket is closed on the final put; either here, or in @@ -1679,14 +1687,15 @@ ksocknal_destroy_conn(struct ksock_conn *conn) } int -ksocknal_close_peer_conns_locked(struct ksock_peer *peer, __u32 ipaddr, int why) +ksocknal_close_peer_conns_locked(struct ksock_peer *peer_ni, + __u32 ipaddr, int why) { struct ksock_conn *conn; struct list_head *ctmp; struct list_head *cnxt; int count = 0; - list_for_each_safe(ctmp, cnxt, &peer->ksnp_conns) { + list_for_each_safe(ctmp, cnxt, &peer_ni->ksnp_conns) { conn = list_entry(ctmp, struct ksock_conn, ksnc_list); if (!ipaddr || conn->ksnc_ipaddr == ipaddr) { @@ -1701,13 +1710,13 @@ ksocknal_close_peer_conns_locked(struct ksock_peer *peer, __u32 ipaddr, int why) int ksocknal_close_conn_and_siblings(struct ksock_conn *conn, int why) { - struct ksock_peer *peer = conn->ksnc_peer; + struct ksock_peer *peer_ni = conn->ksnc_peer; __u32 ipaddr = conn->ksnc_ipaddr; int count; write_lock_bh(&ksocknal_data.ksnd_global_lock); - count = ksocknal_close_peer_conns_locked(peer, ipaddr, why); + count = ksocknal_close_peer_conns_locked(peer_ni, ipaddr, why); write_unlock_bh(&ksocknal_data.ksnd_global_lock); @@ -1717,9 +1726,8 @@ ksocknal_close_conn_and_siblings(struct ksock_conn *conn, int why) int ksocknal_close_matching_conns(struct lnet_process_id id, __u32 ipaddr) { - struct ksock_peer *peer; - struct list_head *ptmp; - struct list_head *pnxt; + struct ksock_peer *peer_ni; + struct ksock_peer *pnxt; int lo; int hi; int i; @@ -1736,16 +1744,17 @@ ksocknal_close_matching_conns(struct lnet_process_id id, __u32 ipaddr) } for (i = lo; i <= hi; i++) { - list_for_each_safe(ptmp, pnxt, - &ksocknal_data.ksnd_peers[i]) { - peer = list_entry(ptmp, struct ksock_peer, ksnp_list); - - if (!((id.nid == LNET_NID_ANY || id.nid == peer->ksnp_id.nid) && - (id.pid == LNET_PID_ANY || id.pid == peer->ksnp_id.pid))) + list_for_each_entry_safe(peer_ni, pnxt, + &ksocknal_data.ksnd_peers[i], + ksnp_list) { + if (!((id.nid == LNET_NID_ANY || + id.nid == peer_ni->ksnp_id.nid) && + (id.pid == LNET_PID_ANY || + id.pid == peer_ni->ksnp_id.pid))) continue; - count += ksocknal_close_peer_conns_locked(peer, ipaddr, - 0); + count += ksocknal_close_peer_conns_locked(peer_ni, + ipaddr, 0); } } @@ -1794,7 +1803,7 @@ ksocknal_query(struct lnet_ni *ni, lnet_nid_t nid, time64_t *when) int connect = 1; time64_t last_alive = 0; time64_t now = ktime_get_seconds(); - struct ksock_peer *peer = NULL; + struct ksock_peer *peer_ni = NULL; rwlock_t *glock = &ksocknal_data.ksnd_global_lock; struct lnet_process_id id = { .nid = nid, @@ -1803,25 +1812,25 @@ ksocknal_query(struct lnet_ni *ni, lnet_nid_t nid, time64_t *when) read_lock(glock); - peer = ksocknal_find_peer_locked(ni, id); - if (peer) { + peer_ni = ksocknal_find_peer_locked(ni, id); + if (peer_ni) { struct ksock_conn *conn; int bufnob; - list_for_each_entry(conn, &peer->ksnp_conns, ksnc_list) { + list_for_each_entry(conn, &peer_ni->ksnp_conns, ksnc_list) { bufnob = conn->ksnc_sock->sk->sk_wmem_queued; if (bufnob < conn->ksnc_tx_bufnob) { /* something got ACKed */ conn->ksnc_tx_deadline = ktime_get_seconds() + *ksocknal_tunables.ksnd_timeout; - peer->ksnp_last_alive = now; + peer_ni->ksnp_last_alive = now; conn->ksnc_tx_bufnob = bufnob; } } - last_alive = peer->ksnp_last_alive; - if (!ksocknal_find_connectable_route_locked(peer)) + last_alive = peer_ni->ksnp_last_alive; + if (!ksocknal_find_connectable_route_locked(peer_ni)) connect = 0; } @@ -1830,8 +1839,8 @@ ksocknal_query(struct lnet_ni *ni, lnet_nid_t nid, time64_t *when) if (last_alive) *when = last_alive * HZ; - CDEBUG(D_NET, "Peer %s %p, alive %lld secs ago, connect %d\n", - libcfs_nid2str(nid), peer, + CDEBUG(D_NET, "peer_ni %s %p, alive %lld secs ago, connect %d\n", + libcfs_nid2str(nid), peer_ni, last_alive ? now - last_alive : -1, connect); @@ -1842,15 +1851,15 @@ ksocknal_query(struct lnet_ni *ni, lnet_nid_t nid, time64_t *when) write_lock_bh(glock); - peer = ksocknal_find_peer_locked(ni, id); - if (peer) - ksocknal_launch_all_connections_locked(peer); + peer_ni = ksocknal_find_peer_locked(ni, id); + if (peer_ni) + ksocknal_launch_all_connections_locked(peer_ni); write_unlock_bh(glock); } static void -ksocknal_push_peer(struct ksock_peer *peer) +ksocknal_push_peer(struct ksock_peer *peer_ni) { int index; int i; @@ -1862,7 +1871,7 @@ ksocknal_push_peer(struct ksock_peer *peer) i = 0; conn = NULL; - list_for_each_entry(conn, &peer->ksnp_conns, ksnc_list) { + list_for_each_entry(conn, &peer_ni->ksnp_conns, ksnc_list) { if (i++ == index) { ksocknal_conn_addref(conn); break; @@ -1896,22 +1905,22 @@ static int ksocknal_push(struct lnet_ni *ni, struct lnet_process_id id) } for (tmp = start; tmp <= end; tmp++) { - int peer_off; /* searching offset in peer hash table */ + int peer_off; /* searching offset in peer_ni hash table */ for (peer_off = 0; ; peer_off++) { - struct ksock_peer *peer; + struct ksock_peer *peer_ni; int i = 0; read_lock(&ksocknal_data.ksnd_global_lock); - list_for_each_entry(peer, tmp, ksnp_list) { + list_for_each_entry(peer_ni, tmp, ksnp_list) { if (!((id.nid == LNET_NID_ANY || - id.nid == peer->ksnp_id.nid) && + id.nid == peer_ni->ksnp_id.nid) && (id.pid == LNET_PID_ANY || - id.pid == peer->ksnp_id.pid))) + id.pid == peer_ni->ksnp_id.pid))) continue; if (i++ == peer_off) { - ksocknal_peer_addref(peer); + ksocknal_peer_addref(peer_ni); break; } } @@ -1921,8 +1930,8 @@ static int ksocknal_push(struct lnet_ni *ni, struct lnet_process_id id) break; rc = 0; - ksocknal_push_peer(peer); - ksocknal_peer_decref(peer); + ksocknal_push_peer(peer_ni); + ksocknal_peer_decref(peer_ni); } } return rc; @@ -1936,7 +1945,7 @@ ksocknal_add_interface(struct lnet_ni *ni, __u32 ipaddress, __u32 netmask) int rc; int i; int j; - struct ksock_peer *peer; + struct ksock_peer *peer_ni; struct ksock_route *route; if (!ipaddress || !netmask) @@ -1959,14 +1968,19 @@ ksocknal_add_interface(struct lnet_ni *ni, __u32 ipaddress, __u32 netmask) iface->ksni_npeers = 0; for (i = 0; i < ksocknal_data.ksnd_peer_hash_size; i++) { - list_for_each_entry(peer, &ksocknal_data.ksnd_peers[i], + list_for_each_entry(peer_ni, + &ksocknal_data.ksnd_peers[i], ksnp_list) { - for (j = 0; j < peer->ksnp_n_passive_ips; j++) - if (peer->ksnp_passive_ips[j] == ipaddress) + for (j = 0; + j < peer_ni->ksnp_n_passive_ips; + j++) + if (peer_ni->ksnp_passive_ips[j] == + ipaddress) iface->ksni_npeers++; - list_for_each_entry(route, &peer->ksnp_routes, + list_for_each_entry(route, + &peer_ni->ksnp_routes, ksnr_list) { if (route->ksnr_myipaddr == ipaddress) iface->ksni_nroutes++; @@ -1987,7 +2001,7 @@ ksocknal_add_interface(struct lnet_ni *ni, __u32 ipaddress, __u32 netmask) } static void -ksocknal_peer_del_interface_locked(struct ksock_peer *peer, __u32 ipaddr) +ksocknal_peer_del_interface_locked(struct ksock_peer *peer_ni, __u32 ipaddr) { struct list_head *tmp; struct list_head *nxt; @@ -1996,16 +2010,16 @@ ksocknal_peer_del_interface_locked(struct ksock_peer *peer, __u32 ipaddr) int i; int j; - for (i = 0; i < peer->ksnp_n_passive_ips; i++) - if (peer->ksnp_passive_ips[i] == ipaddr) { - for (j = i + 1; j < peer->ksnp_n_passive_ips; j++) - peer->ksnp_passive_ips[j - 1] = - peer->ksnp_passive_ips[j]; - peer->ksnp_n_passive_ips--; + for (i = 0; i < peer_ni->ksnp_n_passive_ips; i++) + if (peer_ni->ksnp_passive_ips[i] == ipaddr) { + for (j = i + 1; j < peer_ni->ksnp_n_passive_ips; j++) + peer_ni->ksnp_passive_ips[j - 1] = + peer_ni->ksnp_passive_ips[j]; + peer_ni->ksnp_n_passive_ips--; break; } - list_for_each_safe(tmp, nxt, &peer->ksnp_routes) { + list_for_each_safe(tmp, nxt, &peer_ni->ksnp_routes) { route = list_entry(tmp, struct ksock_route, ksnr_list); if (route->ksnr_myipaddr != ipaddr) @@ -2019,7 +2033,7 @@ ksocknal_peer_del_interface_locked(struct ksock_peer *peer, __u32 ipaddr) } } - list_for_each_safe(tmp, nxt, &peer->ksnp_conns) { + list_for_each_safe(tmp, nxt, &peer_ni->ksnp_conns) { conn = list_entry(tmp, struct ksock_conn, ksnc_list); if (conn->ksnc_myipaddr == ipaddr) @@ -2032,9 +2046,8 @@ ksocknal_del_interface(struct lnet_ni *ni, __u32 ipaddress) { struct ksock_net *net = ni->ni_data; int rc = -ENOENT; - struct list_head *tmp; - struct list_head *nxt; - struct ksock_peer *peer; + struct ksock_peer *nxt; + struct ksock_peer *peer_ni; __u32 this_ip; int i; int j; @@ -2056,14 +2069,14 @@ ksocknal_del_interface(struct lnet_ni *ni, __u32 ipaddress) net->ksnn_ninterfaces--; for (j = 0; j < ksocknal_data.ksnd_peer_hash_size; j++) { - list_for_each_safe(tmp, nxt, - &ksocknal_data.ksnd_peers[j]) { - peer = list_entry(tmp, struct ksock_peer, ksnp_list); - - if (peer->ksnp_ni != ni) + list_for_each_entry_safe(peer_ni, nxt, + &ksocknal_data.ksnd_peers[j], + ksnp_list) { + if (peer_ni->ksnp_ni != ni) continue; - ksocknal_peer_del_interface_locked(peer, this_ip); + ksocknal_peer_del_interface_locked(peer_ni, + this_ip); } } } @@ -2461,36 +2474,41 @@ ksocknal_base_startup(void) static void ksocknal_debug_peerhash(struct lnet_ni *ni) { - struct ksock_peer *peer = NULL; + struct ksock_peer *peer_ni = NULL; int i; read_lock(&ksocknal_data.ksnd_global_lock); for (i = 0; i < ksocknal_data.ksnd_peer_hash_size; i++) { - list_for_each_entry(peer, &ksocknal_data.ksnd_peers[i], ksnp_list) { + list_for_each_entry(peer_ni, &ksocknal_data.ksnd_peers[i], + ksnp_list) { struct ksock_route *route; struct ksock_conn *conn; - if (peer->ksnp_ni != ni) + if (peer_ni->ksnp_ni != ni) continue; - CWARN("Active peer on shutdown: %s, ref %d, scnt %d, closing %d, accepting %d, err %d, zcookie %llu, txq %d, zc_req %d\n", - libcfs_id2str(peer->ksnp_id), - atomic_read(&peer->ksnp_refcount), - peer->ksnp_sharecount, peer->ksnp_closing, - peer->ksnp_accepting, peer->ksnp_error, - peer->ksnp_zc_next_cookie, - !list_empty(&peer->ksnp_tx_queue), - !list_empty(&peer->ksnp_zc_req_list)); + CWARN("Active peer_ni on shutdown: %s, ref %d, scnt %d, closing %d, accepting %d, err %d, zcookie %llu, txq %d, zc_req %d\n", + libcfs_id2str(peer_ni->ksnp_id), + atomic_read(&peer_ni->ksnp_refcount), + peer_ni->ksnp_sharecount, peer_ni->ksnp_closing, + peer_ni->ksnp_accepting, peer_ni->ksnp_error, + peer_ni->ksnp_zc_next_cookie, + !list_empty(&peer_ni->ksnp_tx_queue), + !list_empty(&peer_ni->ksnp_zc_req_list)); - list_for_each_entry(route, &peer->ksnp_routes, ksnr_list) { + list_for_each_entry(route, &peer_ni->ksnp_routes, + ksnr_list) { CWARN("Route: ref %d, schd %d, conn %d, cnted %d, del %d\n", atomic_read(&route->ksnr_refcount), - route->ksnr_scheduled, route->ksnr_connecting, - route->ksnr_connected, route->ksnr_deleted); + route->ksnr_scheduled, + route->ksnr_connecting, + route->ksnr_connected, + route->ksnr_deleted); } - list_for_each_entry(conn, &peer->ksnp_conns, ksnc_list) { + list_for_each_entry(conn, &peer_ni->ksnp_conns, + ksnc_list) { CWARN("Conn: ref %d, sref %d, t %d, c %d\n", atomic_read(&conn->ksnc_conn_refcount), atomic_read(&conn->ksnc_sock_refcount), @@ -2523,7 +2541,7 @@ ksocknal_shutdown(struct lnet_ni *ni) /* Delete all peers */ ksocknal_del_peer(ni, anyid, 0); - /* Wait for all peer state to clean up */ + /* Wait for all peer_ni state to clean up */ i = 2; spin_lock_bh(&net->ksnn_lock); while (net->ksnn_npeers) { diff --git a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd.h b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd.h index 2a619291fccc..cc813e4c1422 100644 --- a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd.h +++ b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd.h @@ -54,7 +54,7 @@ #define SOCKNAL_NSCHEDS 3 #define SOCKNAL_NSCHEDS_HIGH (SOCKNAL_NSCHEDS << 1) -#define SOCKNAL_PEER_HASH_SIZE 101 /* # peer lists */ +#define SOCKNAL_PEER_HASH_SIZE 101 /* # peer_ni lists */ #define SOCKNAL_RESCHED 100 /* # scheduler loops before reschedule */ #define SOCKNAL_INSANITY_RECONN 5000 /* connd is trying on reconn infinitely */ #define SOCKNAL_ENOMEM_RETRY 1 /* seconds between retries */ @@ -142,10 +142,11 @@ struct ksock_tunables { int *ksnd_credits; /* # concurrent sends */ int *ksnd_peertxcredits; /* # concurrent sends to 1 peer */ - int *ksnd_peerrtrcredits; /* # per-peer router buffer + int *ksnd_peerrtrcredits; /* # per-peer_ni router buffer * credits */ - int *ksnd_peertimeout; /* seconds to consider peer dead + int *ksnd_peertimeout; /* seconds to consider + * peer_ni dead */ int *ksnd_enable_csum; /* enable check sum */ int *ksnd_inject_csum_error; /* set non-zero to inject @@ -185,8 +186,8 @@ struct ksock_nal_data { */ int ksnd_nnets; /* # networks set up */ struct list_head ksnd_nets; /* list of nets */ - rwlock_t ksnd_global_lock; /* stabilize peer/conn - * ops + rwlock_t ksnd_global_lock; /* stabilize + * peer_ni/conn ops */ struct list_head *ksnd_peers; /* hash table of all my * known peers @@ -270,7 +271,7 @@ struct ksock_proto; /* forward ref */ struct ksock_tx { /* transmit packet */ struct list_head tx_list; /* queue on conn for transmission etc */ - struct list_head tx_zc_list; /* queue on peer for ZC request */ + struct list_head tx_zc_list; /* queue on peer_ni for ZC request */ atomic_t tx_refcount; /* tx reference count */ int tx_nob; /* # packet bytes */ int tx_resid; /* residual bytes */ @@ -311,9 +312,9 @@ struct ksock_tx { /* transmit packet */ #define SOCKNAL_RX_SLOP 6 /* skipping body */ struct ksock_conn { - struct ksock_peer *ksnc_peer; /* owning peer */ + struct ksock_peer *ksnc_peer; /* owning peer_ni */ struct ksock_route *ksnc_route; /* owning route */ - struct list_head ksnc_list; /* stash on peer's conn list */ + struct list_head ksnc_list; /* stash on peer_ni's conn list */ struct socket *ksnc_sock; /* actual socket */ void *ksnc_saved_data_ready; /* socket's original * data_ready() callback @@ -326,8 +327,8 @@ struct ksock_conn { struct ksock_sched *ksnc_scheduler; /* who schedules this connection */ __u32 ksnc_myipaddr; /* my IP */ - __u32 ksnc_ipaddr; /* peer's IP */ - int ksnc_port; /* peer's port */ + __u32 ksnc_ipaddr; /* peer_ni's IP */ + int ksnc_port; /* peer_ni's port */ signed int ksnc_type:3; /* type of connection, should be * signed value */ @@ -382,9 +383,9 @@ struct ksock_conn { }; struct ksock_route { - struct list_head ksnr_list; /* chain on peer route list */ + struct list_head ksnr_list; /* chain on peer_ni route list */ struct list_head ksnr_connd_list; /* chain on ksnr_connd_routes */ - struct ksock_peer *ksnr_peer; /* owning peer */ + struct ksock_peer *ksnr_peer; /* owning peer_ni */ atomic_t ksnr_refcount; /* # users */ time64_t ksnr_timeout; /* when (in secs) reconnection * can happen next @@ -400,7 +401,7 @@ struct ksock_route { unsigned int ksnr_connected:4; /* connections established by * type */ - unsigned int ksnr_deleted:1; /* been removed from peer? */ + unsigned int ksnr_deleted:1; /* been removed from peer_ni? */ unsigned int ksnr_share_count; /* created explicitly? */ int ksnr_conn_count; /* # conns established by this * route @@ -410,7 +411,7 @@ struct ksock_route { #define SOCKNAL_KEEPALIVE_PING 1 /* cookie for keepalive ping */ struct ksock_peer { - struct list_head ksnp_list; /* stash on global peer list */ + struct list_head ksnp_list; /* stash on global peer_ni list */ time64_t ksnp_last_alive; /* when (in seconds) I was last * alive */ @@ -422,9 +423,12 @@ struct ksock_peer { */ int ksnp_error; /* errno on closing last conn */ __u64 ksnp_zc_next_cookie; /* ZC completion cookie */ - __u64 ksnp_incarnation; /* latest known peer incarnation + __u64 ksnp_incarnation; /* latest known peer_ni + * incarnation + */ + struct ksock_proto *ksnp_proto; /* latest known peer_ni + * protocol */ - struct ksock_proto *ksnp_proto; /* latest known peer protocol */ struct list_head ksnp_conns; /* all active connections */ struct list_head ksnp_routes; /* routes */ struct list_head ksnp_tx_queue; /* waiting packets */ @@ -606,20 +610,20 @@ ksocknal_route_decref(struct ksock_route *route) } static inline void -ksocknal_peer_addref(struct ksock_peer *peer) +ksocknal_peer_addref(struct ksock_peer *peer_ni) { - LASSERT(atomic_read(&peer->ksnp_refcount) > 0); - atomic_inc(&peer->ksnp_refcount); + LASSERT(atomic_read(&peer_ni->ksnp_refcount) > 0); + atomic_inc(&peer_ni->ksnp_refcount); } -void ksocknal_destroy_peer(struct ksock_peer *peer); +void ksocknal_destroy_peer(struct ksock_peer *peer_ni); static inline void -ksocknal_peer_decref(struct ksock_peer *peer) +ksocknal_peer_decref(struct ksock_peer *peer_ni) { - LASSERT(atomic_read(&peer->ksnp_refcount) > 0); - if (atomic_dec_and_test(&peer->ksnp_refcount)) - ksocknal_destroy_peer(peer); + LASSERT(atomic_read(&peer_ni->ksnp_refcount) > 0); + if (atomic_dec_and_test(&peer_ni->ksnp_refcount)) + ksocknal_destroy_peer(peer_ni); } int ksocknal_startup(struct lnet_ni *ni); @@ -636,17 +640,17 @@ struct ksock_peer *ksocknal_find_peer_locked(struct lnet_ni *ni, struct lnet_process_id id); struct ksock_peer *ksocknal_find_peer(struct lnet_ni *ni, struct lnet_process_id id); -void ksocknal_peer_failed(struct ksock_peer *peer); +void ksocknal_peer_failed(struct ksock_peer *peer_ni); int ksocknal_create_conn(struct lnet_ni *ni, struct ksock_route *route, struct socket *sock, int type); void ksocknal_close_conn_locked(struct ksock_conn *conn, int why); void ksocknal_terminate_conn(struct ksock_conn *conn); void ksocknal_destroy_conn(struct ksock_conn *conn); -int ksocknal_close_peer_conns_locked(struct ksock_peer *peer, +int ksocknal_close_peer_conns_locked(struct ksock_peer *peer_ni, __u32 ipaddr, int why); int ksocknal_close_conn_and_siblings(struct ksock_conn *conn, int why); int ksocknal_close_matching_conns(struct lnet_process_id id, __u32 ipaddr); -struct ksock_conn *ksocknal_find_conn_locked(struct ksock_peer *peer, +struct ksock_conn *ksocknal_find_conn_locked(struct ksock_peer *peer_ni, struct ksock_tx *tx, int nonblk); int ksocknal_launch_packet(struct lnet_ni *ni, struct ksock_tx *tx, @@ -661,9 +665,11 @@ void ksocknal_notify(struct lnet_ni *ni, lnet_nid_t gw_nid, int alive); void ksocknal_query(struct lnet_ni *ni, lnet_nid_t nid, time64_t *when); int ksocknal_thread_start(int (*fn)(void *arg), void *arg, char *name); void ksocknal_thread_fini(void); -void ksocknal_launch_all_connections_locked(struct ksock_peer *peer); -struct ksock_route *ksocknal_find_connectable_route_locked(struct ksock_peer *peer); -struct ksock_route *ksocknal_find_connecting_route_locked(struct ksock_peer *peer); +void ksocknal_launch_all_connections_locked(struct ksock_peer *peer_ni); +struct ksock_route *ksocknal_find_connectable_route_locked( + struct ksock_peer *peer_ni); +struct ksock_route *ksocknal_find_connecting_route_locked( + struct ksock_peer *peer_ni); int ksocknal_new_packet(struct ksock_conn *conn, int skip); int ksocknal_scheduler(void *arg); int ksocknal_connd(void *arg); diff --git a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_cb.c b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_cb.c index 32b76727f400..1bf0170503ed 100644 --- a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_cb.c +++ b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_cb.c @@ -375,12 +375,12 @@ static void ksocknal_check_zc_req(struct ksock_tx *tx) { struct ksock_conn *conn = tx->tx_conn; - struct ksock_peer *peer = conn->ksnc_peer; + struct ksock_peer *peer_ni = conn->ksnc_peer; /* * Set tx_msg.ksm_zc_cookies[0] to a unique non-zero cookie and add tx * to ksnp_zc_req_list if some fragment of this message should be sent - * zero-copy. Our peer will send an ACK containing this cookie when + * zero-copy. Our peer_ni will send an ACK containing this cookie when * she has received this message to tell us we can signal completion. * tx_msg.ksm_zc_cookies[0] remains non-zero while tx is on * ksnp_zc_req_list. @@ -400,46 +400,46 @@ ksocknal_check_zc_req(struct ksock_tx *tx) */ ksocknal_tx_addref(tx); - spin_lock(&peer->ksnp_lock); + spin_lock(&peer_ni->ksnp_lock); - /* ZC_REQ is going to be pinned to the peer */ + /* ZC_REQ is going to be pinned to the peer_ni */ tx->tx_deadline = ktime_get_seconds() + *ksocknal_tunables.ksnd_timeout; LASSERT(!tx->tx_msg.ksm_zc_cookies[0]); - tx->tx_msg.ksm_zc_cookies[0] = peer->ksnp_zc_next_cookie++; + tx->tx_msg.ksm_zc_cookies[0] = peer_ni->ksnp_zc_next_cookie++; - if (!peer->ksnp_zc_next_cookie) - peer->ksnp_zc_next_cookie = SOCKNAL_KEEPALIVE_PING + 1; + if (!peer_ni->ksnp_zc_next_cookie) + peer_ni->ksnp_zc_next_cookie = SOCKNAL_KEEPALIVE_PING + 1; - list_add_tail(&tx->tx_zc_list, &peer->ksnp_zc_req_list); + list_add_tail(&tx->tx_zc_list, &peer_ni->ksnp_zc_req_list); - spin_unlock(&peer->ksnp_lock); + spin_unlock(&peer_ni->ksnp_lock); } static void ksocknal_uncheck_zc_req(struct ksock_tx *tx) { - struct ksock_peer *peer = tx->tx_conn->ksnc_peer; + struct ksock_peer *peer_ni = tx->tx_conn->ksnc_peer; LASSERT(tx->tx_msg.ksm_type != KSOCK_MSG_NOOP); LASSERT(tx->tx_zc_capable); tx->tx_zc_checked = 0; - spin_lock(&peer->ksnp_lock); + spin_lock(&peer_ni->ksnp_lock); if (!tx->tx_msg.ksm_zc_cookies[0]) { /* Not waiting for an ACK */ - spin_unlock(&peer->ksnp_lock); + spin_unlock(&peer_ni->ksnp_lock); return; } tx->tx_msg.ksm_zc_cookies[0] = 0; list_del(&tx->tx_zc_list); - spin_unlock(&peer->ksnp_lock); + spin_unlock(&peer_ni->ksnp_lock); ksocknal_tx_decref(tx); } @@ -540,14 +540,14 @@ ksocknal_launch_connection_locked(struct ksock_route *route) } void -ksocknal_launch_all_connections_locked(struct ksock_peer *peer) +ksocknal_launch_all_connections_locked(struct ksock_peer *peer_ni) { struct ksock_route *route; /* called holding write lock on ksnd_global_lock */ for (;;) { /* launch any/all connections that need it */ - route = ksocknal_find_connectable_route_locked(peer); + route = ksocknal_find_connectable_route_locked(peer_ni); if (!route) return; @@ -556,7 +556,7 @@ ksocknal_launch_all_connections_locked(struct ksock_peer *peer) } struct ksock_conn * -ksocknal_find_conn_locked(struct ksock_peer *peer, struct ksock_tx *tx, +ksocknal_find_conn_locked(struct ksock_peer *peer_ni, struct ksock_tx *tx, int nonblk) { struct ksock_conn *c; @@ -566,7 +566,7 @@ ksocknal_find_conn_locked(struct ksock_peer *peer, struct ksock_tx *tx, int tnob = 0; int fnob = 0; - list_for_each_entry(c, &peer->ksnp_conns, ksnc_list) { + list_for_each_entry(c, &peer_ni->ksnp_conns, ksnc_list) { int nob, rc; nob = atomic_read(&c->ksnc_tx_nob) + @@ -722,12 +722,12 @@ ksocknal_queue_tx_locked(struct ksock_tx *tx, struct ksock_conn *conn) } struct ksock_route * -ksocknal_find_connectable_route_locked(struct ksock_peer *peer) +ksocknal_find_connectable_route_locked(struct ksock_peer *peer_ni) { time64_t now = ktime_get_seconds(); struct ksock_route *route; - list_for_each_entry(route, &peer->ksnp_routes, ksnr_list) { + list_for_each_entry(route, &peer_ni->ksnp_routes, ksnr_list) { LASSERT(!route->ksnr_connecting || route->ksnr_scheduled); /* connections being established */ @@ -756,11 +756,11 @@ ksocknal_find_connectable_route_locked(struct ksock_peer *peer) } struct ksock_route * -ksocknal_find_connecting_route_locked(struct ksock_peer *peer) +ksocknal_find_connecting_route_locked(struct ksock_peer *peer_ni) { struct ksock_route *route; - list_for_each_entry(route, &peer->ksnp_routes, ksnr_list) { + list_for_each_entry(route, &peer_ni->ksnp_routes, ksnr_list) { LASSERT(!route->ksnr_connecting || route->ksnr_scheduled); @@ -775,7 +775,7 @@ int ksocknal_launch_packet(struct lnet_ni *ni, struct ksock_tx *tx, struct lnet_process_id id) { - struct ksock_peer *peer; + struct ksock_peer *peer_ni; struct ksock_conn *conn; rwlock_t *g_lock; int retry; @@ -787,10 +787,11 @@ ksocknal_launch_packet(struct lnet_ni *ni, struct ksock_tx *tx, for (retry = 0;; retry = 1) { read_lock(g_lock); - peer = ksocknal_find_peer_locked(ni, id); - if (peer) { - if (!ksocknal_find_connectable_route_locked(peer)) { - conn = ksocknal_find_conn_locked(peer, tx, tx->tx_nonblk); + peer_ni = ksocknal_find_peer_locked(ni, id); + if (peer_ni) { + if (!ksocknal_find_connectable_route_locked(peer_ni)) { + conn = ksocknal_find_conn_locked(peer_ni, tx, + tx->tx_nonblk); if (conn) { /* * I've got no routes that need to be @@ -809,8 +810,8 @@ ksocknal_launch_packet(struct lnet_ni *ni, struct ksock_tx *tx, write_lock_bh(g_lock); - peer = ksocknal_find_peer_locked(ni, id); - if (peer) + peer_ni = ksocknal_find_peer_locked(ni, id); + if (peer_ni) break; write_unlock_bh(g_lock); @@ -822,7 +823,7 @@ ksocknal_launch_packet(struct lnet_ni *ni, struct ksock_tx *tx, } if (retry) { - CERROR("Can't find peer %s\n", libcfs_id2str(id)); + CERROR("Can't find peer_ni %s\n", libcfs_id2str(id)); return -EHOSTUNREACH; } @@ -830,15 +831,15 @@ ksocknal_launch_packet(struct lnet_ni *ni, struct ksock_tx *tx, LNET_NIDADDR(id.nid), lnet_acceptor_port()); if (rc) { - CERROR("Can't add peer %s: %d\n", + CERROR("Can't add peer_ni %s: %d\n", libcfs_id2str(id), rc); return rc; } } - ksocknal_launch_all_connections_locked(peer); + ksocknal_launch_all_connections_locked(peer_ni); - conn = ksocknal_find_conn_locked(peer, tx, tx->tx_nonblk); + conn = ksocknal_find_conn_locked(peer_ni, tx, tx->tx_nonblk); if (conn) { /* Connection exists; queue message on it */ ksocknal_queue_tx_locked(tx, conn); @@ -846,14 +847,14 @@ ksocknal_launch_packet(struct lnet_ni *ni, struct ksock_tx *tx, return 0; } - if (peer->ksnp_accepting > 0 || - ksocknal_find_connecting_route_locked(peer)) { - /* the message is going to be pinned to the peer */ + if (peer_ni->ksnp_accepting > 0 || + ksocknal_find_connecting_route_locked(peer_ni)) { + /* the message is going to be pinned to the peer_ni */ tx->tx_deadline = ktime_get_seconds() + *ksocknal_tunables.ksnd_timeout; /* Queue the message until a connection is established */ - list_add_tail(&tx->tx_list, &peer->ksnp_tx_queue); + list_add_tail(&tx->tx_list, &peer_ni->ksnp_tx_queue); write_unlock_bh(g_lock); return 0; } @@ -1167,7 +1168,7 @@ ksocknal_process_receive(struct ksock_conn *conn) conn->ksnc_proto->pro_unpack(&conn->ksnc_msg); if (conn->ksnc_peer->ksnp_id.pid & LNET_PID_USERFLAG) { - /* Userspace peer */ + /* Userspace peer_ni */ lhdr = &conn->ksnc_msg.ksm_u.lnetmsg.ksnm_hdr; id = &conn->ksnc_peer->ksnp_id; @@ -1667,7 +1668,9 @@ ksocknal_recv_hello(struct lnet_ni *ni, struct ksock_conn *conn, proto = ksocknal_parse_proto_version(hello); if (!proto) { if (!active) { - /* unknown protocol from peer, tell peer my protocol */ + /* unknown protocol from peer_ni, + * tell peer_ni my protocol + */ conn->ksnc_proto = &ksocknal_protocol_v3x; #if SOCKNAL_VERSION_DEBUG if (*ksocknal_tunables.ksnd_protocol == 2) @@ -1708,7 +1711,7 @@ ksocknal_recv_hello(struct lnet_ni *ni, struct ksock_conn *conn, if (!active && conn->ksnc_port > LNET_ACCEPTOR_MAX_RESERVED_PORT) { - /* Userspace NAL assigns peer process ID from socket */ + /* Userspace NAL assigns peer_ni process ID from socket */ recv_id.pid = conn->ksnc_port | LNET_PID_USERFLAG; recv_id.nid = LNET_MKNID(LNET_NIDNET(ni->ni_nid), conn->ksnc_ipaddr); @@ -1720,7 +1723,7 @@ ksocknal_recv_hello(struct lnet_ni *ni, struct ksock_conn *conn, if (!active) { *peerid = recv_id; - /* peer determines type */ + /* peer_ni determines type */ conn->ksnc_type = ksocknal_invert_type(hello->kshm_ctype); if (conn->ksnc_type == SOCKLND_CONN_NONE) { CERROR("Unexpected type %d from %s ip %pI4h\n", @@ -1760,7 +1763,7 @@ static int ksocknal_connect(struct ksock_route *route) { LIST_HEAD(zombies); - struct ksock_peer *peer = route->ksnr_peer; + struct ksock_peer *peer_ni = route->ksnr_peer; int type; int wanted; struct socket *sock; @@ -1781,21 +1784,21 @@ ksocknal_connect(struct ksock_route *route) wanted = ksocknal_route_mask() & ~route->ksnr_connected; /* - * stop connecting if peer/route got closed under me, or + * stop connecting if peer_ni/route got closed under me, or * route got connected while queued */ - if (peer->ksnp_closing || route->ksnr_deleted || + if (peer_ni->ksnp_closing || route->ksnr_deleted || !wanted) { retry_later = 0; break; } - /* reschedule if peer is connecting to me */ - if (peer->ksnp_accepting > 0) { + /* reschedule if peer_ni is connecting to me */ + if (peer_ni->ksnp_accepting > 0) { CDEBUG(D_NET, - "peer %s(%d) already connecting to me, retry later.\n", - libcfs_nid2str(peer->ksnp_id.nid), - peer->ksnp_accepting); + "peer_ni %s(%d) already connecting to me, retry later.\n", + libcfs_nid2str(peer_ni->ksnp_id.nid), + peer_ni->ksnp_accepting); retry_later = 1; } @@ -1817,21 +1820,21 @@ ksocknal_connect(struct ksock_route *route) if (ktime_get_seconds() >= deadline) { rc = -ETIMEDOUT; - lnet_connect_console_error(rc, peer->ksnp_id.nid, + lnet_connect_console_error(rc, peer_ni->ksnp_id.nid, route->ksnr_ipaddr, route->ksnr_port); goto failed; } - rc = lnet_connect(&sock, peer->ksnp_id.nid, + rc = lnet_connect(&sock, peer_ni->ksnp_id.nid, route->ksnr_myipaddr, route->ksnr_ipaddr, route->ksnr_port); if (rc) goto failed; - rc = ksocknal_create_conn(peer->ksnp_ni, route, sock, type); + rc = ksocknal_create_conn(peer_ni->ksnp_ni, route, sock, type); if (rc < 0) { - lnet_connect_console_error(rc, peer->ksnp_id.nid, + lnet_connect_console_error(rc, peer_ni->ksnp_id.nid, route->ksnr_ipaddr, route->ksnr_port); goto failed; @@ -1843,8 +1846,8 @@ ksocknal_connect(struct ksock_route *route) */ retry_later = (rc); if (retry_later) - CDEBUG(D_NET, "peer %s: conn race, retry later.\n", - libcfs_nid2str(peer->ksnp_id.nid)); + CDEBUG(D_NET, "peer_ni %s: conn race, retry later.\n", + libcfs_nid2str(peer_ni->ksnp_id.nid)); write_lock_bh(&ksocknal_data.ksnd_global_lock); } @@ -1855,10 +1858,10 @@ ksocknal_connect(struct ksock_route *route) if (retry_later) { /* * re-queue for attention; this frees me up to handle - * the peer's incoming connection request + * the peer_ni's incoming connection request */ if (rc == EALREADY || - (!rc && peer->ksnp_accepting > 0)) { + (!rc && peer_ni->ksnp_accepting > 0)) { /* * We want to introduce a delay before next * attempt to connect if we lost conn race, @@ -1895,17 +1898,17 @@ ksocknal_connect(struct ksock_route *route) LASSERT(route->ksnr_retry_interval); route->ksnr_timeout = ktime_get_seconds() + route->ksnr_retry_interval; - if (!list_empty(&peer->ksnp_tx_queue) && - !peer->ksnp_accepting && - !ksocknal_find_connecting_route_locked(peer)) { + if (!list_empty(&peer_ni->ksnp_tx_queue) && + !peer_ni->ksnp_accepting && + !ksocknal_find_connecting_route_locked(peer_ni)) { struct ksock_conn *conn; /* * ksnp_tx_queue is queued on a conn on successful * connection for V1.x and V2.x */ - if (!list_empty(&peer->ksnp_conns)) { - conn = list_entry(peer->ksnp_conns.next, + if (!list_empty(&peer_ni->ksnp_conns)) { + conn = list_entry(peer_ni->ksnp_conns.next, struct ksock_conn, ksnc_list); LASSERT(conn->ksnc_proto == &ksocknal_protocol_v3x); } @@ -1914,13 +1917,13 @@ ksocknal_connect(struct ksock_route *route) * take all the blocked packets while I've got the lock and * complete below... */ - list_splice_init(&peer->ksnp_tx_queue, &zombies); + list_splice_init(&peer_ni->ksnp_tx_queue, &zombies); } write_unlock_bh(&ksocknal_data.ksnd_global_lock); - ksocknal_peer_failed(peer); - ksocknal_txlist_done(peer->ksnp_ni, &zombies, 1); + ksocknal_peer_failed(peer_ni); + ksocknal_txlist_done(peer_ni->ksnp_ni, &zombies, 1); return 0; } @@ -2167,12 +2170,12 @@ ksocknal_connd(void *arg) } static struct ksock_conn * -ksocknal_find_timed_out_conn(struct ksock_peer *peer) +ksocknal_find_timed_out_conn(struct ksock_peer *peer_ni) { /* We're called with a shared lock on ksnd_global_lock */ struct ksock_conn *conn; - list_for_each_entry(conn, &peer->ksnp_conns, ksnc_list) { + list_for_each_entry(conn, &peer_ni->ksnp_conns, ksnc_list) { int error; /* Don't need the {get,put}connsock dance to deref ksnc_sock */ @@ -2189,20 +2192,20 @@ ksocknal_find_timed_out_conn(struct ksock_peer *peer) switch (error) { case ECONNRESET: CNETERR("A connection with %s (%pI4h:%d) was reset; it may have rebooted.\n", - libcfs_id2str(peer->ksnp_id), + libcfs_id2str(peer_ni->ksnp_id), &conn->ksnc_ipaddr, conn->ksnc_port); break; case ETIMEDOUT: CNETERR("A connection with %s (%pI4h:%d) timed out; the network or node may be down.\n", - libcfs_id2str(peer->ksnp_id), + libcfs_id2str(peer_ni->ksnp_id), &conn->ksnc_ipaddr, conn->ksnc_port); break; default: CNETERR("An unexpected network error %d occurred with %s (%pI4h:%d\n", error, - libcfs_id2str(peer->ksnp_id), + libcfs_id2str(peer_ni->ksnp_id), &conn->ksnc_ipaddr, conn->ksnc_port); break; @@ -2216,7 +2219,7 @@ ksocknal_find_timed_out_conn(struct ksock_peer *peer) /* Timed out incomplete incoming message */ ksocknal_conn_addref(conn); CNETERR("Timeout receiving from %s (%pI4h:%d), state %d wanted %zd left %d\n", - libcfs_id2str(peer->ksnp_id), + libcfs_id2str(peer_ni->ksnp_id), &conn->ksnc_ipaddr, conn->ksnc_port, conn->ksnc_rx_state, @@ -2234,7 +2237,7 @@ ksocknal_find_timed_out_conn(struct ksock_peer *peer) */ ksocknal_conn_addref(conn); CNETERR("Timeout sending data to %s (%pI4h:%d) the network or that node may be down.\n", - libcfs_id2str(peer->ksnp_id), + libcfs_id2str(peer_ni->ksnp_id), &conn->ksnc_ipaddr, conn->ksnc_port); return conn; @@ -2245,15 +2248,16 @@ ksocknal_find_timed_out_conn(struct ksock_peer *peer) } static inline void -ksocknal_flush_stale_txs(struct ksock_peer *peer) +ksocknal_flush_stale_txs(struct ksock_peer *peer_ni) { struct ksock_tx *tx; LIST_HEAD(stale_txs); write_lock_bh(&ksocknal_data.ksnd_global_lock); - while (!list_empty(&peer->ksnp_tx_queue)) { - tx = list_entry(peer->ksnp_tx_queue.next, struct ksock_tx, tx_list); + while (!list_empty(&peer_ni->ksnp_tx_queue)) { + tx = list_entry(peer_ni->ksnp_tx_queue.next, struct ksock_tx, + tx_list); if (ktime_get_seconds() < tx->tx_deadline) break; @@ -2264,11 +2268,11 @@ ksocknal_flush_stale_txs(struct ksock_peer *peer) write_unlock_bh(&ksocknal_data.ksnd_global_lock); - ksocknal_txlist_done(peer->ksnp_ni, &stale_txs, 1); + ksocknal_txlist_done(peer_ni->ksnp_ni, &stale_txs, 1); } static int -ksocknal_send_keepalive_locked(struct ksock_peer *peer) +ksocknal_send_keepalive_locked(struct ksock_peer *peer_ni) __must_hold(&ksocknal_data.ksnd_global_lock) { struct ksock_sched *sched; @@ -2276,27 +2280,27 @@ ksocknal_send_keepalive_locked(struct ksock_peer *peer) struct ksock_tx *tx; /* last_alive will be updated by create_conn */ - if (list_empty(&peer->ksnp_conns)) + if (list_empty(&peer_ni->ksnp_conns)) return 0; - if (peer->ksnp_proto != &ksocknal_protocol_v3x) + if (peer_ni->ksnp_proto != &ksocknal_protocol_v3x) return 0; if (*ksocknal_tunables.ksnd_keepalive <= 0 || - ktime_get_seconds() < peer->ksnp_last_alive + + ktime_get_seconds() < peer_ni->ksnp_last_alive + *ksocknal_tunables.ksnd_keepalive) return 0; - if (ktime_get_seconds() < peer->ksnp_send_keepalive) + if (ktime_get_seconds() < peer_ni->ksnp_send_keepalive) return 0; /* * retry 10 secs later, so we wouldn't put pressure - * on this peer if we failed to send keepalive this time + * on this peer_ni if we failed to send keepalive this time */ - peer->ksnp_send_keepalive = ktime_get_seconds() + 10; + peer_ni->ksnp_send_keepalive = ktime_get_seconds() + 10; - conn = ksocknal_find_conn_locked(peer, NULL, 1); + conn = ksocknal_find_conn_locked(peer_ni, NULL, 1); if (conn) { sched = conn->ksnc_scheduler; @@ -2319,7 +2323,7 @@ ksocknal_send_keepalive_locked(struct ksock_peer *peer) return -ENOMEM; } - if (!ksocknal_launch_packet(peer->ksnp_ni, tx, peer->ksnp_id)) { + if (!ksocknal_launch_packet(peer_ni->ksnp_ni, tx, peer_ni->ksnp_id)) { read_lock(&ksocknal_data.ksnd_global_lock); return 1; } @@ -2334,7 +2338,7 @@ static void ksocknal_check_peer_timeouts(int idx) { struct list_head *peers = &ksocknal_data.ksnd_peers[idx]; - struct ksock_peer *peer; + struct ksock_peer *peer_ni; struct ksock_conn *conn; struct ksock_tx *tx; @@ -2346,18 +2350,18 @@ ksocknal_check_peer_timeouts(int idx) */ read_lock(&ksocknal_data.ksnd_global_lock); - list_for_each_entry(peer, peers, ksnp_list) { + list_for_each_entry(peer_ni, peers, ksnp_list) { struct ksock_tx *tx_stale; time64_t deadline = 0; int resid = 0; int n = 0; - if (ksocknal_send_keepalive_locked(peer)) { + if (ksocknal_send_keepalive_locked(peer_ni)) { read_unlock(&ksocknal_data.ksnd_global_lock); goto again; } - conn = ksocknal_find_timed_out_conn(peer); + conn = ksocknal_find_timed_out_conn(peer_ni); if (conn) { read_unlock(&ksocknal_data.ksnd_global_lock); @@ -2366,7 +2370,7 @@ ksocknal_check_peer_timeouts(int idx) /* * NB we won't find this one again, but we can't - * just proceed with the next peer, since we dropped + * just proceed with the next peer_ni, since we dropped * ksnd_global_lock and it might be dead already! */ ksocknal_conn_decref(conn); @@ -2377,27 +2381,28 @@ ksocknal_check_peer_timeouts(int idx) * we can't process stale txs right here because we're * holding only shared lock */ - if (!list_empty(&peer->ksnp_tx_queue)) { - tx = list_entry(peer->ksnp_tx_queue.next, + if (!list_empty(&peer_ni->ksnp_tx_queue)) { + tx = list_entry(peer_ni->ksnp_tx_queue.next, struct ksock_tx, tx_list); if (ktime_get_seconds() >= tx->tx_deadline) { - ksocknal_peer_addref(peer); + ksocknal_peer_addref(peer_ni); read_unlock(&ksocknal_data.ksnd_global_lock); - ksocknal_flush_stale_txs(peer); + ksocknal_flush_stale_txs(peer_ni); - ksocknal_peer_decref(peer); + ksocknal_peer_decref(peer_ni); goto again; } } - if (list_empty(&peer->ksnp_zc_req_list)) + if (list_empty(&peer_ni->ksnp_zc_req_list)) continue; tx_stale = NULL; - spin_lock(&peer->ksnp_lock); - list_for_each_entry(tx, &peer->ksnp_zc_req_list, tx_zc_list) { + spin_lock(&peer_ni->ksnp_lock); + list_for_each_entry(tx, &peer_ni->ksnp_zc_req_list, + tx_zc_list) { if (ktime_get_seconds() < tx->tx_deadline) break; /* ignore the TX if connection is being closed */ @@ -2409,7 +2414,7 @@ ksocknal_check_peer_timeouts(int idx) } if (!tx_stale) { - spin_unlock(&peer->ksnp_lock); + spin_unlock(&peer_ni->ksnp_lock); continue; } @@ -2418,11 +2423,11 @@ ksocknal_check_peer_timeouts(int idx) conn = tx_stale->tx_conn; ksocknal_conn_addref(conn); - spin_unlock(&peer->ksnp_lock); + spin_unlock(&peer_ni->ksnp_lock); read_unlock(&ksocknal_data.ksnd_global_lock); - CERROR("Total %d stale ZC_REQs for peer %s detected; the oldest(%p) timed out %lld secs ago, resid: %d, wmem: %d\n", - n, libcfs_nid2str(peer->ksnp_id.nid), tx_stale, + CERROR("Total %d stale ZC_REQs for peer_ni %s detected; the oldest(%p) timed out %lld secs ago, resid: %d, wmem: %d\n", + n, libcfs_nid2str(peer_ni->ksnp_id.nid), tx_stale, ktime_get_seconds() - deadline, resid, conn->ksnc_sock->sk->sk_wmem_queued); diff --git a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_lib.c b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_lib.c index 93a02cd6b6b5..33847b9615ed 100644 --- a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_lib.c +++ b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_lib.c @@ -44,7 +44,7 @@ ksocknal_lib_get_conn_addrs(struct ksock_conn *conn) LASSERT(!conn->ksnc_closing); if (rc) { - CERROR("Error %d getting sock peer IP\n", rc); + CERROR("Error %d getting sock peer_ni IP\n", rc); return rc; } @@ -157,7 +157,7 @@ ksocknal_lib_eager_ack(struct ksock_conn *conn) * Remind the socket to ACK eagerly. If I don't, the socket might * think I'm about to send something it could piggy-back the ACK * on, introducing delay in completing zero-copy sends in my - * peer. + * peer_ni. */ kernel_setsockopt(sock, SOL_TCP, TCP_QUICKACK, (char *)&opt, sizeof(opt)); diff --git a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_proto.c b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_proto.c index abfaf5701758..8c10eda382b7 100644 --- a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_proto.c +++ b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_proto.c @@ -367,14 +367,14 @@ ksocknal_match_tx_v3(struct ksock_conn *conn, struct ksock_tx *tx, int nonblk) static int ksocknal_handle_zcreq(struct ksock_conn *c, __u64 cookie, int remote) { - struct ksock_peer *peer = c->ksnc_peer; + struct ksock_peer *peer_ni = c->ksnc_peer; struct ksock_conn *conn; struct ksock_tx *tx; int rc; read_lock(&ksocknal_data.ksnd_global_lock); - conn = ksocknal_find_conn_locked(peer, NULL, !!remote); + conn = ksocknal_find_conn_locked(peer_ni, NULL, !!remote); if (conn) { struct ksock_sched *sched = conn->ksnc_scheduler; @@ -399,7 +399,7 @@ ksocknal_handle_zcreq(struct ksock_conn *c, __u64 cookie, int remote) if (!tx) return -ENOMEM; - rc = ksocknal_launch_packet(peer->ksnp_ni, tx, peer->ksnp_id); + rc = ksocknal_launch_packet(peer_ni->ksnp_ni, tx, peer_ni->ksnp_id); if (!rc) return 0; @@ -411,7 +411,7 @@ ksocknal_handle_zcreq(struct ksock_conn *c, __u64 cookie, int remote) static int ksocknal_handle_zcack(struct ksock_conn *conn, __u64 cookie1, __u64 cookie2) { - struct ksock_peer *peer = conn->ksnc_peer; + struct ksock_peer *peer_ni = conn->ksnc_peer; struct ksock_tx *tx; struct ksock_tx *tmp; LIST_HEAD(zlist); @@ -428,9 +428,9 @@ ksocknal_handle_zcack(struct ksock_conn *conn, __u64 cookie1, __u64 cookie2) return count == 1 ? 0 : -EPROTO; } - spin_lock(&peer->ksnp_lock); + spin_lock(&peer_ni->ksnp_lock); - list_for_each_entry_safe(tx, tmp, &peer->ksnp_zc_req_list, + list_for_each_entry_safe(tx, tmp, &peer_ni->ksnp_zc_req_list, tx_zc_list) { __u64 c = tx->tx_msg.ksm_zc_cookies[0]; @@ -445,7 +445,7 @@ ksocknal_handle_zcack(struct ksock_conn *conn, __u64 cookie1, __u64 cookie2) } } - spin_unlock(&peer->ksnp_lock); + spin_unlock(&peer_ni->ksnp_lock); while (!list_empty(&zlist)) { tx = list_entry(zlist.next, struct ksock_tx, tx_zc_list);