X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lnet%2Fklnds%2Fsocklnd%2Fsocklnd.c;h=d0e073ca5ae4895577fc752e7224643d17fa8959;hp=3c50e5cd6ec90cced7e46460266ca80a9f86f4e7;hb=61aa09e1ed8463ccda1f5d83d2c5aff8080a6116;hpb=2728c9c104246d4b2811f230f8711f7544187a75 diff --git a/lnet/klnds/socklnd/socklnd.c b/lnet/klnds/socklnd/socklnd.c index 3c50e5c..d0e073c 100644 --- a/lnet/klnds/socklnd/socklnd.c +++ b/lnet/klnds/socklnd/socklnd.c @@ -15,11 +15,7 @@ * * You should have received a copy of the GNU General Public License * version 2 along with this program; If not, see - * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf - * - * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, - * CA 95054 USA or visit www.sun.com if you need additional information or - * have any questions. + * http://www.gnu.org/licenses/gpl-2.0.html * * GPL HEADER END */ @@ -41,13 +37,14 @@ * Author: Eric Barton */ +#include #include "socklnd.h" -static lnd_t the_ksocklnd; +static struct lnet_lnd the_ksocklnd; ksock_nal_data_t ksocknal_data; static ksock_interface_t * -ksocknal_ip2iface(lnet_ni_t *ni, __u32 ip) +ksocknal_ip2iface(struct lnet_ni *ni, __u32 ip) { ksock_net_t *net = ni->ni_data; int i; @@ -100,42 +97,43 @@ ksocknal_destroy_route (ksock_route_t *route) } static int -ksocknal_create_peer(ksock_peer_t **peerp, lnet_ni_t *ni, lnet_process_id_t id) +ksocknal_create_peer(ksock_peer_ni_t **peerp, struct lnet_ni *ni, + struct lnet_process_id id) { - int cpt = lnet_cpt_of_nid(id.nid); + int cpt = lnet_cpt_of_nid(id.nid, ni); ksock_net_t *net = ni->ni_data; - ksock_peer_t *peer; + ksock_peer_ni_t *peer_ni; LASSERT(id.nid != LNET_NID_ANY); LASSERT(id.pid != LNET_PID_ANY); LASSERT(!in_interrupt()); - LIBCFS_CPT_ALLOC(peer, lnet_cpt_table(), cpt, sizeof(*peer)); - if (peer == NULL) + LIBCFS_CPT_ALLOC(peer_ni, lnet_cpt_table(), cpt, sizeof(*peer_ni)); + if (peer_ni == NULL) 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); - LIBCFS_FREE(peer, sizeof(*peer)); - CERROR("Can't create peer: network shutdown\n"); + LIBCFS_FREE(peer_ni, sizeof(*peer_ni)); + CERROR("Can't create peer_ni: network shutdown\n"); return -ESHUTDOWN; } @@ -143,114 +141,114 @@ ksocknal_create_peer(ksock_peer_t **peerp, lnet_ni_t *ni, lnet_process_id_t id) spin_unlock_bh(&net->ksnn_lock); - *peerp = peer; + *peerp = peer_ni; return 0; } void -ksocknal_destroy_peer (ksock_peer_t *peer) +ksocknal_destroy_peer (ksock_peer_ni_t *peer_ni) { - ksock_net_t *net = peer->ksnp_ni->ni_data; + ksock_net_t *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) == 0); - LASSERT(peer->ksnp_accepting == 0); - 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) == 0); + LASSERT(peer_ni->ksnp_accepting == 0); + 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)); - LIBCFS_FREE(peer, sizeof(*peer)); + LIBCFS_FREE(peer_ni, sizeof(*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_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 + * do with this peer_ni has been cleaned up when its refcount drops to * zero. */ spin_lock_bh(&net->ksnn_lock); net->ksnn_npeers--; spin_unlock_bh(&net->ksnn_lock); } -ksock_peer_t * -ksocknal_find_peer_locked (lnet_ni_t *ni, lnet_process_id_t id) +ksock_peer_ni_t * +ksocknal_find_peer_locked(struct lnet_ni *ni, struct lnet_process_id id) { struct list_head *peer_list = ksocknal_nid2peerlist(id.nid); struct list_head *tmp; - ksock_peer_t *peer; + ksock_peer_ni_t *peer_ni; list_for_each(tmp, peer_list) { - peer = list_entry(tmp, ksock_peer_t, ksnp_list); + peer_ni = list_entry(tmp, ksock_peer_ni_t, ksnp_list); - LASSERT(!peer->ksnp_closing); + 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; } -ksock_peer_t * -ksocknal_find_peer (lnet_ni_t *ni, lnet_process_id_t id) +ksock_peer_ni_t * +ksocknal_find_peer(struct lnet_ni *ni, struct lnet_process_id id) { - ksock_peer_t *peer; + ksock_peer_ni_t *peer_ni; read_lock(&ksocknal_data.ksnd_global_lock); - peer = ksocknal_find_peer_locked(ni, id); - if (peer != NULL) /* +1 ref for caller? */ - ksocknal_peer_addref(peer); + peer_ni = ksocknal_find_peer_locked(ni, id); + if (peer_ni != NULL) /* +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 (ksock_peer_t *peer) +ksocknal_unlink_peer_locked (ksock_peer_ni_t *peer_ni) { int i; __u32 ip; ksock_interface_t *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); - /* All IPs in peer->ksnp_passive_ips[] come from the + iface = ksocknal_ip2iface(peer_ni->ksnp_ni, ip); + /* All IPs in peer_ni->ksnp_passive_ips[] come from the * interface list, therefore the call must succeed. */ LASSERT (iface != NULL); - 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 -ksocknal_get_peer_info (lnet_ni_t *ni, int index, - lnet_process_id_t *id, __u32 *myip, __u32 *peer_ip, - int *port, int *conn_count, int *share_count) +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) { - ksock_peer_t *peer; + ksock_peer_ni_t *peer_ni; struct list_head *ptmp; ksock_route_t *route; struct list_head *rtmp; @@ -262,17 +260,17 @@ ksocknal_get_peer_info (lnet_ni_t *ni, int index, for (i = 0; i < ksocknal_data.ksnd_peer_hash_size; i++) { list_for_each(ptmp, &ksocknal_data.ksnd_peers[i]) { - peer = list_entry(ptmp, ksock_peer_t, ksnp_list); + peer_ni = list_entry(ptmp, ksock_peer_ni_t, ksnp_list); - if (peer->ksnp_ni != ni) + if (peer_ni->ksnp_ni != ni) continue; - if (peer->ksnp_n_passive_ips == 0 && - list_empty(&peer->ksnp_routes)) { + if (peer_ni->ksnp_n_passive_ips == 0 && + 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; @@ -282,12 +280,12 @@ ksocknal_get_peer_info (lnet_ni_t *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; @@ -296,14 +294,14 @@ ksocknal_get_peer_info (lnet_ni_t *ni, int index, goto out; } - list_for_each(rtmp, &peer->ksnp_routes) { + list_for_each(rtmp, &peer_ni->ksnp_routes) { if (index-- > 0) continue; route = list_entry(rtmp, ksock_route_t, ksnr_list); - *id = peer->ksnp_id; + *id = peer_ni->ksnp_id; *myip = route->ksnr_myipaddr; *peer_ip = route->ksnr_ipaddr; *port = route->ksnr_port; @@ -322,7 +320,7 @@ out: static void ksocknal_associate_route_conn_locked(ksock_route_t *route, ksock_conn_t *conn) { - ksock_peer_t *peer = route->ksnr_peer; + ksock_peer_ni_t *peer_ni = route->ksnr_peer; int type = conn->ksnc_type; ksock_interface_t *iface; @@ -333,12 +331,12 @@ ksocknal_associate_route_conn_locked(ksock_route_t *route, ksock_conn_t *conn) if (route->ksnr_myipaddr == 0) { /* 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), + "to %pI4h\n", libcfs_id2str(peer_ni->ksnp_id), &route->ksnr_ipaddr, &route->ksnr_myipaddr, &conn->ksnc_myipaddr); @@ -364,36 +362,36 @@ ksocknal_associate_route_conn_locked(ksock_route_t *route, ksock_conn_t *conn) } static void -ksocknal_add_route_locked (ksock_peer_t *peer, ksock_route_t *route) +ksocknal_add_route_locked (ksock_peer_ni_t *peer_ni, ksock_route_t *route) { struct list_head *tmp; ksock_conn_t *conn; ksock_route_t *route2; - LASSERT(!peer->ksnp_closing); + LASSERT(!peer_ni->ksnp_closing); LASSERT(route->ksnr_peer == NULL); LASSERT(!route->ksnr_scheduled); LASSERT(!route->ksnr_connecting); LASSERT(route->ksnr_connected == 0); /* LASSERT(unique) */ - list_for_each(tmp, &peer->ksnp_routes) { + list_for_each(tmp, &peer_ni->ksnp_routes) { route2 = list_entry(tmp, ksock_route_t, 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(tmp, &peer->ksnp_conns) { + list_for_each(tmp, &peer_ni->ksnp_conns) { conn = list_entry(tmp, ksock_conn_t, ksnc_list); if (conn->ksnc_ipaddr != route->ksnr_ipaddr) @@ -407,7 +405,7 @@ ksocknal_add_route_locked (ksock_peer_t *peer, ksock_route_t *route) static void ksocknal_del_route_locked (ksock_route_t *route) { - ksock_peer_t *peer = route->ksnr_peer; + ksock_peer_ni_t *peer_ni = route->ksnr_peer; ksock_interface_t *iface; ksock_conn_t *conn; struct list_head *ctmp; @@ -416,7 +414,7 @@ ksocknal_del_route_locked (ksock_route_t *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, ksock_conn_t, ksnc_list); if (conn->ksnc_route != route) @@ -434,22 +432,23 @@ ksocknal_del_route_locked (ksock_route_t *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)) { - /* I've just removed the last route to a peer with no active + if (list_empty(&peer_ni->ksnp_routes) && + list_empty(&peer_ni->ksnp_conns)) { + /* 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); } } int -ksocknal_add_peer(lnet_ni_t *ni, lnet_process_id_t id, __u32 ipaddr, int port) +ksocknal_add_peer(struct lnet_ni *ni, struct lnet_process_id id, __u32 ipaddr, + int port) { struct list_head *tmp; - ksock_peer_t *peer; - ksock_peer_t *peer2; + ksock_peer_ni_t *peer_ni; + ksock_peer_ni_t *peer2; ksock_route_t *route; ksock_route_t *route2; int rc; @@ -458,14 +457,14 @@ ksocknal_add_peer(lnet_ni_t *ni, lnet_process_id_t id, __u32 ipaddr, int port) 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 != 0) return rc; route = ksocknal_create_route (ipaddr, port); if (route == NULL) { - ksocknal_peer_decref(peer); + ksocknal_peer_decref(peer_ni); return (-ENOMEM); } @@ -476,16 +475,16 @@ ksocknal_add_peer(lnet_ni_t *ni, lnet_process_id_t id, __u32 ipaddr, int port) peer2 = ksocknal_find_peer_locked(ni, id); if (peer2 != NULL) { - 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)); } route2 = NULL; - list_for_each(tmp, &peer->ksnp_routes) { + list_for_each(tmp, &peer_ni->ksnp_routes) { route2 = list_entry(tmp, ksock_route_t, ksnr_list); if (route2->ksnr_ipaddr == ipaddr) @@ -494,7 +493,7 @@ ksocknal_add_peer(lnet_ni_t *ni, lnet_process_id_t id, __u32 ipaddr, int port) route2 = NULL; } if (route2 == NULL) { - ksocknal_add_route_locked(peer, route); + ksocknal_add_route_locked(peer_ni, route); route->ksnr_share_count++; } else { ksocknal_route_decref(route); @@ -507,7 +506,7 @@ ksocknal_add_peer(lnet_ni_t *ni, lnet_process_id_t id, __u32 ipaddr, int port) } static void -ksocknal_del_peer_locked (ksock_peer_t *peer, __u32 ip) +ksocknal_del_peer_locked (ksock_peer_ni_t *peer_ni, __u32 ip) { ksock_conn_t *conn; ksock_route_t *route; @@ -515,12 +514,12 @@ ksocknal_del_peer_locked (ksock_peer_t *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, ksock_route_t, ksnr_list); /* no match */ @@ -533,7 +532,7 @@ ksocknal_del_peer_locked (ksock_peer_t *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, ksock_route_t, ksnr_list); nshared += route->ksnr_share_count; } @@ -542,7 +541,7 @@ ksocknal_del_peer_locked (ksock_peer_t *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, ksock_route_t, ksnr_list); /* we should only be removing auto-entries */ @@ -550,24 +549,24 @@ ksocknal_del_peer_locked (ksock_peer_t *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, ksock_conn_t, 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 (lnet_ni_t *ni, lnet_process_id_t id, __u32 ip) +ksocknal_del_peer(struct lnet_ni *ni, struct lnet_process_id id, __u32 ip) { struct list_head zombies = LIST_HEAD_INIT(zombies); struct list_head *ptmp; struct list_head *pnxt; - ksock_peer_t *peer; + ksock_peer_ni_t *peer_ni; int lo; int hi; int i; @@ -587,31 +586,31 @@ ksocknal_del_peer (lnet_ni_t *ni, lnet_process_id_t id, __u32 ip) for (i = lo; i <= hi; i++) { list_for_each_safe(ptmp, pnxt, &ksocknal_data.ksnd_peers[i]) { - peer = list_entry(ptmp, ksock_peer_t, ksnp_list); + peer_ni = list_entry(ptmp, ksock_peer_ni_t, ksnp_list); - if (peer->ksnp_ni != ni) + if (peer_ni->ksnp_ni != ni) continue; if (!((id.nid == LNET_NID_ANY || - peer->ksnp_id.nid == id.nid) && + peer_ni->ksnp_id.nid == id.nid) && (id.pid == LNET_PID_ANY || - peer->ksnp_id.pid == id.pid))) + 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! */ } @@ -619,15 +618,15 @@ ksocknal_del_peer (lnet_ni_t *ni, lnet_process_id_t id, __u32 ip) write_unlock_bh(&ksocknal_data.ksnd_global_lock); - ksocknal_txlist_done(ni, &zombies, 1); + ksocknal_txlist_done(ni, &zombies, -ENETDOWN); return rc; } static ksock_conn_t * -ksocknal_get_conn_by_idx (lnet_ni_t *ni, int index) +ksocknal_get_conn_by_idx(struct lnet_ni *ni, int index) { - ksock_peer_t *peer; + ksock_peer_ni_t *peer_ni; struct list_head *ptmp; ksock_conn_t *conn; struct list_head *ctmp; @@ -637,14 +636,14 @@ ksocknal_get_conn_by_idx (lnet_ni_t *ni, int index) for (i = 0; i < ksocknal_data.ksnd_peer_hash_size; i++) { list_for_each(ptmp, &ksocknal_data.ksnd_peers[i]) { - peer = list_entry(ptmp, ksock_peer_t, ksnp_list); + peer_ni = list_entry(ptmp, ksock_peer_ni_t, ksnp_list); - LASSERT(!peer->ksnp_closing); + LASSERT(!peer_ni->ksnp_closing); - if (peer->ksnp_ni != ni) + if (peer_ni->ksnp_ni != ni) continue; - list_for_each(ctmp, &peer->ksnp_conns) { + list_for_each(ctmp, &peer_ni->ksnp_conns) { if (index-- > 0) continue; @@ -686,7 +685,7 @@ ksocknal_choose_scheduler_locked(unsigned int cpt) } static int -ksocknal_local_ipvec (lnet_ni_t *ni, __u32 *ipaddrs) +ksocknal_local_ipvec(struct lnet_ni *ni, __u32 *ipaddrs) { ksock_net_t *net = ni->ni_data; int i; @@ -746,10 +745,10 @@ ksocknal_match_peerip (ksock_interface_t *iface, __u32 *ips, int nips) } static int -ksocknal_select_ips(ksock_peer_t *peer, __u32 *peerips, int n_peerips) +ksocknal_select_ips(ksock_peer_ni_t *peer_ni, __u32 *peerips, int n_peerips) { rwlock_t *global_lock = &ksocknal_data.ksnd_global_lock; - ksock_net_t *net = peer->ksnp_ni->ni_data; + ksock_net_t *net = peer_ni->ksnp_ni->ni_data; ksock_interface_t *iface; ksock_interface_t *best_iface; int n_ips; @@ -780,25 +779,25 @@ ksocknal_select_ips(ksock_peer_t *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 != NULL); } 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; @@ -808,11 +807,11 @@ ksocknal_select_ips(ksock_peer_t *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, n_peerips); @@ -834,17 +833,17 @@ ksocknal_select_ips(ksock_peer_t *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); @@ -852,12 +851,12 @@ ksocknal_select_ips(ksock_peer_t *peer, __u32 *peerips, int n_peerips) } static void -ksocknal_create_routes(ksock_peer_t *peer, int port, +ksocknal_create_routes(ksock_peer_ni_t *peer_ni, int port, __u32 *peer_ipaddrs, int npeer_ipaddrs) { ksock_route_t *newroute = NULL; rwlock_t *global_lock = &ksocknal_data.ksnd_global_lock; - lnet_ni_t *ni = peer->ksnp_ni; + struct lnet_ni *ni = peer_ni->ksnp_ni; ksock_net_t *net = ni->ni_data; struct list_head *rtmp; ksock_route_t *route; @@ -898,14 +897,14 @@ ksocknal_create_routes(ksock_peer_t *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? */ route = NULL; - list_for_each(rtmp, &peer->ksnp_routes) { + list_for_each(rtmp, &peer_ni->ksnp_routes) { route = list_entry(rtmp, ksock_route_t, ksnr_list); if (route->ksnr_ipaddr == newroute->ksnr_ipaddr) @@ -927,7 +926,7 @@ ksocknal_create_routes(ksock_peer_t *peer, int port, iface = &net->ksnn_interfaces[j]; /* Using this interface already? */ - list_for_each(rtmp, &peer->ksnp_routes) { + list_for_each(rtmp, &peer_ni->ksnp_routes) { route = list_entry(rtmp, ksock_route_t, ksnr_list); @@ -960,7 +959,7 @@ ksocknal_create_routes(ksock_peer_t *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; } @@ -970,7 +969,7 @@ ksocknal_create_routes(ksock_peer_t *peer, int port, } int -ksocknal_accept(lnet_ni_t *ni, struct socket *sock) +ksocknal_accept(struct lnet_ni *ni, struct socket *sock) { ksock_connreq_t *cr; int rc; @@ -1001,11 +1000,11 @@ ksocknal_accept(lnet_ni_t *ni, struct socket *sock) } static int -ksocknal_connecting (ksock_peer_t *peer, __u32 ipaddr) +ksocknal_connecting (ksock_peer_ni_t *peer_ni, __u32 ipaddr) { ksock_route_t *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; } @@ -1013,24 +1012,25 @@ ksocknal_connecting (ksock_peer_t *peer, __u32 ipaddr) } int -ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *route, +ksocknal_create_conn(struct lnet_ni *ni, ksock_route_t *route, struct socket *sock, int type) { rwlock_t *global_lock = &ksocknal_data.ksnd_global_lock; struct list_head zombies = LIST_HEAD_INIT(zombies); - lnet_process_id_t peerid; + struct lnet_process_id peerid; struct list_head *tmp; __u64 incarnation; ksock_conn_t *conn; ksock_conn_t *conn2; - ksock_peer_t *peer = NULL; - ksock_peer_t *peer2; + ksock_peer_ni_t *peer_ni = NULL; + ksock_peer_ni_t *peer2; ksock_sched_t *sched; - ksock_hello_msg_t *hello; + struct ksock_hello_msg *hello; int cpt; ksock_tx_t *tx; ksock_tx_t *txtmp; int rc; + int rc2; int active; char *warn = NULL; @@ -1063,7 +1063,7 @@ ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *route, conn->ksnc_tx_carrier = NULL; atomic_set (&conn->ksnc_tx_nob, 0); - LIBCFS_ALLOC(hello, offsetof(ksock_hello_msg_t, + LIBCFS_ALLOC(hello, offsetof(struct ksock_hello_msg, kshm_ips[LNET_MAX_INTERFACES])); if (hello == NULL) { rc = -ENOMEM; @@ -1075,21 +1075,21 @@ ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *route, if (rc != 0) 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 == NULL) { @@ -1109,7 +1109,7 @@ ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *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; } @@ -1121,13 +1121,13 @@ ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *route, LASSERT (conn->ksnc_proto != NULL); LASSERT (peerid.nid != LNET_NID_ANY); - cpt = lnet_cpt_of_nid(peerid.nid); + 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 != 0) goto failed_1; @@ -1138,57 +1138,57 @@ ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *route, peer2 = ksocknal_find_peer_locked(ni, peerid); if (peer2 == NULL) { - /* NB this puts an "empty" peer in the peer + /* NB this puts an "empty" peer_ni in the peer_ni * 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 == NULL) { + if (peer_ni->ksnp_proto == NULL) { /* Never connected before. - * NB recv_hello may have returned EPROTO to signal my peer + * NB recv_hello may have returned EPROTO to signal my peer_ni * 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; } @@ -1209,7 +1209,7 @@ ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *route, /* Refuse to duplicate an existing connection, unless this is a * loopback connection */ if (conn->ksnc_ipaddr != conn->ksnc_myipaddr) { - list_for_each(tmp, &peer->ksnp_conns) { + list_for_each(tmp, &peer_ni->ksnp_conns) { conn2 = list_entry(tmp, ksock_conn_t, ksnc_list); if (conn2->ksnc_ipaddr != conn->ksnc_ipaddr || @@ -1217,7 +1217,7 @@ ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *route, conn2->ksnc_type != conn->ksnc_type) continue; - /* Reply on a passive connection attempt so the peer + /* Reply on a passive connection attempt so the peer_ni * realises we're connected. */ LASSERT (rc == 0); if (!active) @@ -1234,16 +1234,16 @@ ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *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); } /* 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(tmp, &peer->ksnp_routes) { + list_for_each(tmp, &peer_ni->ksnp_routes) { route = list_entry(tmp, ksock_route_t, ksnr_list); if (route->ksnr_ipaddr != conn->ksnc_ipaddr) @@ -1253,22 +1253,22 @@ ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *route, break; } - conn->ksnc_peer = peer; /* conn takes my ref on peer */ - peer->ksnp_last_alive = cfs_time_current(); - 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_real_seconds(); + peer_ni->ksnp_send_keepalive = 0; + peer_ni->ksnp_error = 0; sched = ksocknal_choose_scheduler_locked(cpt); sched->kss_nconns++; conn->ksnc_scheduler = sched; - conn->ksnc_tx_last_post = cfs_time_current(); + conn->ksnc_tx_last_post = ktime_get_real_seconds(); /* Set the deadline for the outgoing HELLO to drain */ conn->ksnc_tx_bufnob = sock->sk->sk_wmem_queued; conn->ksnc_tx_deadline = cfs_time_shift(*ksocknal_tunables.ksnd_timeout); - smp_mb(); /* order with adding to peer's conn list */ + smp_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); @@ -1276,7 +1276,7 @@ ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *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) { if (conn->ksnc_proto->pro_match_tx(conn, tx, tx->tx_nonblk) == SOCKNAL_MATCH_NO) continue; @@ -1304,15 +1304,15 @@ ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *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); } - LIBCFS_FREE(hello, offsetof(ksock_hello_msg_t, + LIBCFS_FREE(hello, offsetof(struct ksock_hello_msg, kshm_ips[LNET_MAX_INTERFACES])); /* setup the socket AFTER I've received hello (it disables @@ -1329,7 +1329,7 @@ ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *route, ksocknal_lib_set_callback(sock, conn); if (!active) - peer->ksnp_accepting--; + peer_ni->ksnp_accepting--; write_unlock_bh(global_lock); @@ -1352,12 +1352,12 @@ ksocknal_create_conn(lnet_ni_t *ni, ksock_route_t *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); @@ -1381,17 +1381,23 @@ failed_2: } 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); + /* + * If we get here without an error code, just use -EALREADY. + * Depending on how we got here, the error may be positive + * or negative. Normalize the value for ksocknal_txlist_done(). + */ + rc2 = (rc == 0 ? -EALREADY : (rc > 0 ? -rc : rc)); + ksocknal_txlist_done(ni, &zombies, rc2); + ksocknal_peer_decref(peer_ni); - failed_1: - if (hello != NULL) - LIBCFS_FREE(hello, offsetof(ksock_hello_msg_t, - kshm_ips[LNET_MAX_INTERFACES])); +failed_1: + if (hello != NULL) + LIBCFS_FREE(hello, offsetof(struct ksock_hello_msg, + kshm_ips[LNET_MAX_INTERFACES])); LIBCFS_FREE(conn, sizeof(*conn)); @@ -1406,16 +1412,16 @@ ksocknal_close_conn_locked (ksock_conn_t *conn, int error) /* This just does the immmediate housekeeping, and queues the * connection for the reaper to terminate. * Caller holds ksnd_global_lock exclusively in irq context */ - ksock_peer_t *peer = conn->ksnc_peer; + ksock_peer_ni_t *peer_ni = conn->ksnc_peer; ksock_route_t *route; ksock_conn_t *conn2; struct list_head *tmp; - LASSERT(peer->ksnp_error == 0); + LASSERT(peer_ni->ksnp_error == 0); 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; @@ -1425,7 +1431,7 @@ ksocknal_close_conn_locked (ksock_conn_t *conn, int error) LASSERT((route->ksnr_connected & (1 << conn->ksnc_type)) != 0); conn2 = NULL; - list_for_each(tmp, &peer->ksnp_conns) { + list_for_each(tmp, &peer_ni->ksnp_conns) { conn2 = list_entry(tmp, ksock_conn_t, ksnc_list); if (conn2->ksnc_route == route && @@ -1439,43 +1445,38 @@ ksocknal_close_conn_locked (ksock_conn_t *conn, int error) conn->ksnc_route = NULL; -#if 0 /* irrelevent with only eager routes */ - /* make route least favourite */ - list_del(&route->ksnr_list); - list_add_tail(&route->ksnr_list, &peer->ksnp_routes); -#endif 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)) { ksock_tx_t *tx; LASSERT(conn->ksnc_proto == &ksocknal_protocol_v3x); /* 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); } /* renegotiate protocol version */ - peer->ksnp_proto = NULL; + peer_ni->ksnp_proto = NULL; /* stash last conn close reason */ - peer->ksnp_error = error; + peer_ni->ksnp_error = error; - 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 */ - ksocknal_unlink_peer_locked(peer); + * peer_ni with no routes to it */ + ksocknal_unlink_peer_locked(peer_ni); } } @@ -1489,36 +1490,36 @@ ksocknal_close_conn_locked (ksock_conn_t *conn, int error) } void -ksocknal_peer_failed (ksock_peer_t *peer) +ksocknal_peer_failed (ksock_peer_ni_t *peer_ni) { int notify = 0; cfs_time_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) == 0 && - list_empty(&peer->ksnp_conns) && - peer->ksnp_accepting == 0 && - ksocknal_find_connecting_route_locked(peer) == NULL) { + if ((peer_ni->ksnp_id.pid & LNET_PID_USERFLAG) == 0 && + list_empty(&peer_ni->ksnp_conns) && + peer_ni->ksnp_accepting == 0 && + ksocknal_find_connecting_route_locked(peer_ni) == NULL) { 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(ksock_conn_t *conn) { - ksock_peer_t *peer = conn->ksnc_peer; + ksock_peer_ni_t *peer_ni = conn->ksnc_peer; ksock_tx_t *tx; ksock_tx_t *tmp; struct list_head zlist = LIST_HEAD_INIT(zlist); @@ -1527,9 +1528,9 @@ ksocknal_finalize_zcreq(ksock_conn_t *conn) * abort all buffered data */ LASSERT(conn->ksnc_sock == NULL); - 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; @@ -1541,7 +1542,7 @@ ksocknal_finalize_zcreq(ksock_conn_t *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, ksock_tx_t, tx_zc_list); @@ -1558,7 +1559,7 @@ ksocknal_terminate_conn(ksock_conn_t *conn) * disengage the socket from its callbacks and close it. * ksnc_refcount will eventually hit zero, and then the reaper will * destroy it. */ - ksock_peer_t *peer = conn->ksnc_peer; + ksock_peer_ni_t *peer_ni = conn->ksnc_peer; ksock_sched_t *sched = conn->ksnc_scheduler; int failed = 0; @@ -1592,17 +1593,17 @@ ksocknal_terminate_conn(ksock_conn_t *conn) * scheduler yet, but it _has_ committed to terminate... */ conn->ksnc_scheduler->kss_nconns--; - if (peer->ksnp_error != 0) { - /* peer's last conn closed in error */ - LASSERT(list_empty(&peer->ksnp_conns)); + if (peer_ni->ksnp_error != 0) { + /* 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 * ksocknal_{send,recv}msg(). Since we set up the linger2 option @@ -1653,11 +1654,10 @@ ksocknal_destroy_conn (ksock_conn_t *conn) libcfs_id2str(conn->ksnc_peer->ksnp_id), conn->ksnc_type, &conn->ksnc_ipaddr, conn->ksnc_port, conn->ksnc_rx_nob_wanted, conn->ksnc_rx_nob_left, - cfs_duration_sec(cfs_time_sub(cfs_time_current(), + cfs_duration_sec(cfs_time_sub(ktime_get_real_seconds(), last_rcv))); - lnet_finalize (conn->ksnc_peer->ksnp_ni, - conn->ksnc_cookie, -EIO); - break; + lnet_finalize(conn->ksnc_cookie, -EIO); + break; case SOCKNAL_RX_LNET_HEADER: if (conn->ksnc_rx_started) CERROR("Incomplete receive of lnet header from %s, " @@ -1692,14 +1692,14 @@ ksocknal_destroy_conn (ksock_conn_t *conn) } int -ksocknal_close_peer_conns_locked (ksock_peer_t *peer, __u32 ipaddr, int why) +ksocknal_close_peer_conns_locked (ksock_peer_ni_t *peer_ni, __u32 ipaddr, int why) { ksock_conn_t *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, ksock_conn_t, ksnc_list); if (ipaddr == 0 || @@ -1715,13 +1715,13 @@ ksocknal_close_peer_conns_locked (ksock_peer_t *peer, __u32 ipaddr, int why) int ksocknal_close_conn_and_siblings (ksock_conn_t *conn, int why) { - ksock_peer_t *peer = conn->ksnc_peer; + ksock_peer_ni_t *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); @@ -1729,9 +1729,9 @@ ksocknal_close_conn_and_siblings (ksock_conn_t *conn, int why) } int -ksocknal_close_matching_conns (lnet_process_id_t id, __u32 ipaddr) +ksocknal_close_matching_conns(struct lnet_process_id id, __u32 ipaddr) { - ksock_peer_t *peer; + ksock_peer_ni_t *peer_ni; struct list_head *ptmp; struct list_head *pnxt; int lo; @@ -1751,13 +1751,13 @@ ksocknal_close_matching_conns (lnet_process_id_t id, __u32 ipaddr) for (i = lo; i <= hi; i++) { list_for_each_safe(ptmp, pnxt, &ksocknal_data.ksnd_peers[i]) { - peer = list_entry(ptmp, ksock_peer_t, ksnp_list); + peer_ni = list_entry(ptmp, ksock_peer_ni_t, 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))) + 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); } } @@ -1771,14 +1771,15 @@ ksocknal_close_matching_conns (lnet_process_id_t id, __u32 ipaddr) } void -ksocknal_notify (lnet_ni_t *ni, lnet_nid_t gw_nid, int alive) +ksocknal_notify(struct lnet_ni *ni, lnet_nid_t gw_nid, int alive) { - /* The router is telling me she's been notified of a change in - * gateway state.... */ - lnet_process_id_t id = {0}; - - id.nid = gw_nid; - id.pid = LNET_PID_ANY; + /* The router is telling me she's been notified of a change in + * gateway state.... + */ + struct lnet_process_id id = { + .nid = gw_nid, + .pid = LNET_PID_ANY, + }; CDEBUG (D_NET, "gw %s %s\n", libcfs_nid2str(gw_nid), alive ? "up" : "down"); @@ -1794,27 +1795,27 @@ ksocknal_notify (lnet_ni_t *ni, lnet_nid_t gw_nid, int alive) } void -ksocknal_query (lnet_ni_t *ni, lnet_nid_t nid, cfs_time_t *when) +ksocknal_query(struct lnet_ni *ni, lnet_nid_t nid, cfs_time_t *when) { - int connect = 1; - cfs_time_t last_alive = 0; - cfs_time_t now = cfs_time_current(); - ksock_peer_t *peer = NULL; - rwlock_t *glock = &ksocknal_data.ksnd_global_lock; - lnet_process_id_t id = { + int connect = 1; + time64_t last_alive = 0; + time64_t now = ktime_get_real_seconds(); + ksock_peer_ni_t *peer_ni = NULL; + rwlock_t *glock = &ksocknal_data.ksnd_global_lock; + struct lnet_process_id id = { .nid = nid, .pid = LNET_PID_LUSTRE, }; read_lock(glock); - peer = ksocknal_find_peer_locked(ni, id); - if (peer != NULL) { + peer_ni = ksocknal_find_peer_locked(ni, id); + if (peer_ni != NULL) { struct list_head *tmp; ksock_conn_t *conn; int bufnob; - list_for_each(tmp, &peer->ksnp_conns) { + list_for_each(tmp, &peer_ni->ksnp_conns) { conn = list_entry(tmp, ksock_conn_t, ksnc_list); bufnob = conn->ksnc_sock->sk->sk_wmem_queued; @@ -1822,13 +1823,13 @@ ksocknal_query (lnet_ni_t *ni, lnet_nid_t nid, cfs_time_t *when) /* something got ACKed */ conn->ksnc_tx_deadline = cfs_time_shift(*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) == NULL) + last_alive = peer_ni->ksnp_last_alive; + if (ksocknal_find_connectable_route_locked(peer_ni) == NULL) connect = 0; } @@ -1837,8 +1838,8 @@ ksocknal_query (lnet_ni_t *ni, lnet_nid_t nid, cfs_time_t *when) if (last_alive != 0) *when = last_alive; - CDEBUG(D_NET, "Peer %s %p, alive %ld secs ago, connect %d\n", - libcfs_nid2str(nid), peer, + CDEBUG(D_NET, "peer_ni %s %p, alive %ld secs ago, connect %d\n", + libcfs_nid2str(nid), peer_ni, last_alive ? cfs_duration_sec(now - last_alive) : -1, connect); @@ -1849,16 +1850,16 @@ ksocknal_query (lnet_ni_t *ni, lnet_nid_t nid, cfs_time_t *when) write_lock_bh(glock); - peer = ksocknal_find_peer_locked(ni, id); - if (peer != NULL) - ksocknal_launch_all_connections_locked(peer); + peer_ni = ksocknal_find_peer_locked(ni, id); + if (peer_ni != NULL) + ksocknal_launch_all_connections_locked(peer_ni); write_unlock_bh(glock); return; } static void -ksocknal_push_peer (ksock_peer_t *peer) +ksocknal_push_peer (ksock_peer_ni_t *peer_ni) { int index; int i; @@ -1871,7 +1872,7 @@ ksocknal_push_peer (ksock_peer_t *peer) i = 0; conn = NULL; - list_for_each(tmp, &peer->ksnp_conns) { + list_for_each(tmp, &peer_ni->ksnp_conns) { if (i++ == index) { conn = list_entry(tmp, ksock_conn_t, ksnc_list); @@ -1891,7 +1892,7 @@ ksocknal_push_peer (ksock_peer_t *peer) } static int -ksocknal_push (lnet_ni_t *ni, lnet_process_id_t id) +ksocknal_push(struct lnet_ni *ni, struct lnet_process_id id) { struct list_head *start; struct list_head *end; @@ -1907,22 +1908,22 @@ ksocknal_push (lnet_ni_t *ni, lnet_process_id_t 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++) { - ksock_peer_t *peer; + ksock_peer_ni_t *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; } } @@ -1932,15 +1933,15 @@ ksocknal_push (lnet_ni_t *ni, lnet_process_id_t id) break; rc = 0; - ksocknal_push_peer(peer); - ksocknal_peer_decref(peer); + ksocknal_push_peer(peer_ni); + ksocknal_peer_decref(peer_ni); } } return rc; } static int -ksocknal_add_interface(lnet_ni_t *ni, __u32 ipaddress, __u32 netmask) +ksocknal_add_interface(struct lnet_ni *ni, __u32 ipaddress, __u32 netmask) { ksock_net_t *net = ni->ni_data; ksock_interface_t *iface; @@ -1948,7 +1949,7 @@ ksocknal_add_interface(lnet_ni_t *ni, __u32 ipaddress, __u32 netmask) int i; int j; struct list_head *ptmp; - ksock_peer_t *peer; + ksock_peer_ni_t *peer_ni; struct list_head *rtmp; ksock_route_t *route; @@ -1974,14 +1975,14 @@ ksocknal_add_interface(lnet_ni_t *ni, __u32 ipaddress, __u32 netmask) for (i = 0; i < ksocknal_data.ksnd_peer_hash_size; i++) { list_for_each(ptmp, &ksocknal_data.ksnd_peers[i]) { - peer = list_entry(ptmp, ksock_peer_t, + peer_ni = list_entry(ptmp, ksock_peer_ni_t, 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(rtmp, &peer->ksnp_routes) { + list_for_each(rtmp, &peer_ni->ksnp_routes) { route = list_entry(rtmp, ksock_route_t, ksnr_list); @@ -2002,7 +2003,7 @@ ksocknal_add_interface(lnet_ni_t *ni, __u32 ipaddress, __u32 netmask) } static void -ksocknal_peer_del_interface_locked(ksock_peer_t *peer, __u32 ipaddr) +ksocknal_peer_del_interface_locked(ksock_peer_ni_t *peer_ni, __u32 ipaddr) { struct list_head *tmp; struct list_head *nxt; @@ -2011,16 +2012,16 @@ ksocknal_peer_del_interface_locked(ksock_peer_t *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, ksock_route_t, ksnr_list); if (route->ksnr_myipaddr != ipaddr) @@ -2034,7 +2035,7 @@ ksocknal_peer_del_interface_locked(ksock_peer_t *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, ksock_conn_t, ksnc_list); if (conn->ksnc_myipaddr == ipaddr) @@ -2043,13 +2044,13 @@ ksocknal_peer_del_interface_locked(ksock_peer_t *peer, __u32 ipaddr) } static int -ksocknal_del_interface(lnet_ni_t *ni, __u32 ipaddress) +ksocknal_del_interface(struct lnet_ni *ni, __u32 ipaddress) { ksock_net_t *net = ni->ni_data; int rc = -ENOENT; struct list_head *tmp; struct list_head *nxt; - ksock_peer_t *peer; + ksock_peer_ni_t *peer_ni; __u32 this_ip; int i; int j; @@ -2074,13 +2075,13 @@ ksocknal_del_interface(lnet_ni_t *ni, __u32 ipaddress) 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, ksock_peer_t, + peer_ni = list_entry(tmp, ksock_peer_ni_t, ksnp_list); - if (peer->ksnp_ni != ni) + if (peer_ni->ksnp_ni != ni) continue; - ksocknal_peer_del_interface_locked(peer, this_ip); + ksocknal_peer_del_interface_locked(peer_ni, this_ip); } } } @@ -2091,9 +2092,9 @@ ksocknal_del_interface(lnet_ni_t *ni, __u32 ipaddress) } int -ksocknal_ctl(lnet_ni_t *ni, unsigned int cmd, void *arg) +ksocknal_ctl(struct lnet_ni *ni, unsigned int cmd, void *arg) { - lnet_process_id_t id = {0}; + struct lnet_process_id id = {0}; struct libcfs_ioctl_data *data = arg; int rc; @@ -2354,20 +2355,6 @@ ksocknal_base_shutdown(void) module_put(THIS_MODULE); } -static __u64 ksocknal_new_incarnation(void) -{ - struct timeval tv; - - /* The incarnation number is the time this module loaded and it - * identifies this particular instance of the socknal. Hopefully - * we won't be able to reboot more frequently than 1MHz for the - * forseeable future :) */ - - do_gettimeofday(&tv); - - return (((__u64)tv.tv_sec) * 1000000) + tv.tv_usec; -} - static int ksocknal_base_startup(void) { @@ -2453,7 +2440,7 @@ ksocknal_base_startup(void) ksocknal_data.ksnd_connd_starting = 0; ksocknal_data.ksnd_connd_failed_stamp = 0; - ksocknal_data.ksnd_connd_starting_stamp = cfs_time_current_sec(); + ksocknal_data.ksnd_connd_starting_stamp = ktime_get_real_seconds(); /* must have at least 2 connds to remain responsive to accepts while * connecting */ if (*ksocknal_tunables.ksnd_nconnds < SOCKNAL_CONND_RESV + 1) @@ -2474,7 +2461,7 @@ ksocknal_base_startup(void) snprintf(name, sizeof(name), "socknal_cd%02d", i); rc = ksocknal_thread_start(ksocknal_connd, - (void *)((ulong_ptr_t)i), name); + (void *)((uintptr_t)i), name); if (rc != 0) { spin_lock_bh(&ksocknal_data.ksnd_connd_lock); ksocknal_data.ksnd_connd_starting--; @@ -2501,9 +2488,9 @@ ksocknal_base_startup(void) } static void -ksocknal_debug_peerhash (lnet_ni_t *ni) +ksocknal_debug_peerhash(struct lnet_ni *ni) { - ksock_peer_t *peer = NULL; + ksock_peer_ni_t *peer_ni = NULL; struct list_head *tmp; int i; @@ -2511,29 +2498,29 @@ ksocknal_debug_peerhash (lnet_ni_t *ni) for (i = 0; i < ksocknal_data.ksnd_peer_hash_size; i++) { list_for_each(tmp, &ksocknal_data.ksnd_peers[i]) { - peer = list_entry(tmp, ksock_peer_t, ksnp_list); + peer_ni = list_entry(tmp, ksock_peer_ni_t, ksnp_list); - if (peer->ksnp_ni == ni) break; + if (peer_ni->ksnp_ni == ni) break; - peer = NULL; + peer_ni = NULL; } } - if (peer != NULL) { + if (peer_ni != NULL) { ksock_route_t *route; ksock_conn_t *conn; - CWARN ("Active peer on shutdown: %s, ref %d, scnt %d, " - "closing %d, accepting %d, err %d, zcookie "LPU64", " - "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)); - - list_for_each(tmp, &peer->ksnp_routes) { + 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(tmp, &peer_ni->ksnp_routes) { route = list_entry(tmp, ksock_route_t, ksnr_list); CWARN ("Route: ref %d, schd %d, conn %d, cnted %d, " "del %d\n", atomic_read(&route->ksnr_refcount), @@ -2541,7 +2528,7 @@ ksocknal_debug_peerhash (lnet_ni_t *ni) route->ksnr_connected, route->ksnr_deleted); } - list_for_each(tmp, &peer->ksnp_conns) { + list_for_each(tmp, &peer_ni->ksnp_conns) { conn = list_entry(tmp, ksock_conn_t, ksnc_list); CWARN ("Conn: ref %d, sref %d, t %d, c %d\n", atomic_read(&conn->ksnc_conn_refcount), @@ -2555,14 +2542,14 @@ ksocknal_debug_peerhash (lnet_ni_t *ni) } void -ksocknal_shutdown (lnet_ni_t *ni) +ksocknal_shutdown(struct lnet_ni *ni) { - ksock_net_t *net = ni->ni_data; - int i; - lnet_process_id_t anyid = {0}; - - anyid.nid = LNET_NID_ANY; - anyid.pid = LNET_PID_ANY; + ksock_net_t *net = ni->ni_data; + struct lnet_process_id anyid = { + .nid = LNET_NID_ANY, + .pid = LNET_PID_ANY, + }; + int i; LASSERT(ksocknal_data.ksnd_init == SOCKNAL_INIT_ALL); LASSERT(ksocknal_data.ksnd_nnets > 0); @@ -2574,7 +2561,7 @@ ksocknal_shutdown (lnet_ni_t *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 != 0) { @@ -2758,7 +2745,8 @@ ksocknal_net_start_threads(ksock_net_t *net, __u32 *cpts, int ncpts) int rc; int i; - LASSERT(ncpts > 0 && ncpts <= cfs_cpt_number(lnet_cpt_table())); + if (ncpts > 0 && ncpts > cfs_cpt_number(lnet_cpt_table())) + return -EINVAL; for (i = 0; i < ncpts; i++) { struct ksock_sched_info *info; @@ -2778,13 +2766,15 @@ ksocknal_net_start_threads(ksock_net_t *net, __u32 *cpts, int ncpts) } int -ksocknal_startup (lnet_ni_t *ni) +ksocknal_startup(struct lnet_ni *ni) { - ksock_net_t *net; - int rc; - int i; + ksock_net_t *net; + int rc; + int i; + struct net_device *net_dev; + int node_id; - LASSERT (ni->ni_lnd == &the_ksocklnd); + LASSERT (ni->ni_net->net_lnd == &the_ksocklnd); if (ksocknal_data.ksnd_init == SOCKNAL_INIT_NOTHING) { rc = ksocknal_base_startup(); @@ -2797,12 +2787,20 @@ ksocknal_startup (lnet_ni_t *ni) goto fail_0; spin_lock_init(&net->ksnn_lock); - net->ksnn_incarnation = ksocknal_new_incarnation(); - ni->ni_data = net; - ni->ni_peertimeout = *ksocknal_tunables.ksnd_peertimeout; - ni->ni_maxtxcredits = *ksocknal_tunables.ksnd_credits; - ni->ni_peertxcredits = *ksocknal_tunables.ksnd_peertxcredits; - ni->ni_peerrtrcredits = *ksocknal_tunables.ksnd_peerrtrcredits; + net->ksnn_incarnation = ktime_get_real_ns(); + ni->ni_data = net; + if (!ni->ni_net->net_tunables_set) { + ni->ni_net->net_tunables.lct_peer_timeout = + *ksocknal_tunables.ksnd_peertimeout; + ni->ni_net->net_tunables.lct_max_tx_credits = + *ksocknal_tunables.ksnd_credits; + ni->ni_net->net_tunables.lct_peer_tx_credits = + *ksocknal_tunables.ksnd_peertxcredits; + ni->ni_net->net_tunables.lct_peer_rtr_credits = + *ksocknal_tunables.ksnd_peerrtrcredits; + ni->ni_net->net_tunables_set = true; + } + if (ni->ni_interfaces[0] == NULL) { rc = ksocknal_enumerate_interfaces(net); @@ -2836,10 +2834,21 @@ ksocknal_startup (lnet_ni_t *ni) strlcpy(net->ksnn_interfaces[i].ksni_name, ni->ni_interfaces[i], sizeof(net->ksnn_interfaces[i].ksni_name)); + } net->ksnn_ninterfaces = i; } + net_dev = dev_get_by_name(&init_net, + net->ksnn_interfaces[0].ksni_name); + if (net_dev != NULL) { + node_id = dev_to_node(&net_dev->dev); + ni->ni_dev_cpt = cfs_cpt_of_node(lnet_cpt_table(), node_id); + dev_put(net_dev); + } else { + ni->ni_dev_cpt = CFS_CPT_ANY; + } + /* call it before add it to ksocknal_data.ksnd_nets */ rc = ksocknal_net_start_threads(net, ni->ni_cpts, ni->ni_ncpts); if (rc != 0) @@ -2866,7 +2875,6 @@ ksocknal_startup (lnet_ni_t *ni) static void __exit ksocklnd_exit(void) { lnet_unregister_lnd(&the_ksocklnd); - ksocknal_tunables_fini(); } static int __init ksocklnd_init(void)