}
int
-lnet_fail_nid(lnet_nid_t nid, unsigned int threshold)
+lnet_fail_nid(lnet_nid_t nid4, unsigned int threshold)
{
struct lnet_test_peer *tp;
struct list_head *el;
struct list_head *next;
+ struct lnet_nid nid;
LIST_HEAD(cull);
+ lnet_nid4_to_nid(nid4, &nid);
/* NB: use lnet_net_lock(0) to serialize operations on test peers */
if (threshold != 0) {
/* Adding a new entry */
tp = list_entry(el, struct lnet_test_peer, tp_list);
if (tp->tp_threshold == 0 || /* needs culling anyway */
- nid == LNET_NID_ANY || /* removing all entries */
- tp->tp_nid == nid) { /* matched this one */
+ LNET_NID_IS_ANY(&nid) || /* removing all entries */
+ nid_same(&tp->tp_nid, &nid)) { /* matched this one */
list_move(&tp->tp_list, &cull);
}
}
}
static int
-fail_peer (lnet_nid_t nid, int outgoing)
+fail_peer(lnet_nid_t nid4, int outgoing)
{
struct lnet_test_peer *tp;
struct list_head *el;
struct list_head *next;
+ struct lnet_nid nid;
LIST_HEAD(cull);
int fail = 0;
+ lnet_nid4_to_nid(nid4, &nid);
/* NB: use lnet_net_lock(0) to serialize operations on test peers */
lnet_net_lock(0);
continue;
}
- if (tp->tp_nid == LNET_NID_ANY || /* fail every peer */
- nid == tp->tp_nid) { /* fail this peer */
+ if (LNET_NID_IS_ANY(&tp->tp_nid) || /* fail every peer */
+ nid_same(&nid, &tp->tp_nid)) { /* fail this peer */
fail = 1;
if (tp->tp_threshold != LNET_MD_THRESH_INF) {
if (rc != 0) {
CERROR("recv from %s / send to %s aborted: "
"eager_recv failed %d\n",
- libcfs_nid2str(msg->msg_rxpeer->lpni_nid),
+ libcfs_nidstr(&msg->msg_rxpeer->lpni_nid),
libcfs_id2str(msg->msg_target), rc);
LASSERT(rc < 0); /* required by my callers */
}
/* can't get here if we're sending to the loopback interface */
if (the_lnet.ln_loni)
- LASSERT(lp->lpni_nid !=
- lnet_nid_to_nid4(&the_lnet.ln_loni->ni_nid));
+ LASSERT(!nid_same(&lp->lpni_nid, &the_lnet.ln_loni->ni_nid));
/* NB 'lp' is always the next hop */
if ((msg->msg_target.pid & LNET_PID_USERFLAG) == 0 &&
* preferred, then let's use it
*/
if (best_ni) {
- /* FIXME need to handle large-addr nid */
lpni_is_preferred = lnet_peer_is_pref_nid_locked(
- lpni, lnet_nid_to_nid4(&best_ni->ni_nid));
+ lpni, &best_ni->ni_nid);
CDEBUG(D_NET, "%s lpni_is_preferred = %d\n",
libcfs_nidstr(&best_ni->ni_nid),
lpni_is_preferred);
if (best_lpni)
CDEBUG(D_NET, "n:[%s, %s] h:[%d, %d] p:[%d, %d] c:[%d, %d] s:[%d, %d]\n",
- libcfs_nid2str(lpni->lpni_nid),
- libcfs_nid2str(best_lpni->lpni_nid),
+ libcfs_nidstr(&lpni->lpni_nid),
+ libcfs_nidstr(&best_lpni->lpni_nid),
lpni_healthv, best_lpni_healthv,
lpni_sel_prio, best_sel_prio,
lpni->lpni_txcredits, best_lpni_credits,
}
CDEBUG(D_NET, "sd_best_lpni = %s\n",
- libcfs_nid2str(best_lpni->lpni_nid));
+ libcfs_nidstr(&best_lpni->lpni_nid));
return best_lpni;
}
struct lnet_route *route;
int rc;
bool best_rte_is_preferred = false;
- lnet_nid_t gw_pnid;
+ struct lnet_nid *gw_pnid;
CDEBUG(D_NET, "Looking up a route to %s, from %s\n",
libcfs_net2str(rnet->lrn_net), libcfs_net2str(src_net));
list_for_each_entry(route, &rnet->lrn_routes, lr_list) {
if (!lnet_is_route_alive(route))
continue;
- gw_pnid = route->lr_gateway->lp_primary_nid;
+ gw_pnid = &route->lr_gateway->lp_primary_nid;
/* no protection on below fields, but it's harmless */
if (last_route && (last_route->lr_seq - route->lr_seq < 0))
if (!lpni) {
CDEBUG(D_NET,
"Gateway %s does not have a peer NI on net %s\n",
- libcfs_nid2str(gw_pnid),
+ libcfs_nidstr(gw_pnid),
libcfs_net2str(src_net));
continue;
}
best_gw_ni = lpni;
best_rte_is_preferred = true;
CDEBUG(D_NET, "preferred gw = %s\n",
- libcfs_nid2str(gw_pnid));
+ libcfs_nidstr(gw_pnid));
continue;
} else if ((!rc) && best_rte_is_preferred)
/* The best route we found so far is in the preferred
if (!lpni) {
CDEBUG(D_NET,
"Gateway %s does not have a peer NI on net %s\n",
- libcfs_nid2str(gw_pnid),
+ libcfs_nidstr(gw_pnid),
libcfs_net2str(src_net));
continue;
}
* local ni and local net so that we pick the next ones
* in Round Robin.
*/
- best_lpni->lpni_seq++;
best_lpni->lpni_peer_net->lpn_seq++;
- best_ni->ni_seq++;
+ best_lpni->lpni_seq = best_lpni->lpni_peer_net->lpn_seq;
best_ni->ni_net->net_seq++;
+ best_ni->ni_seq = best_ni->ni_net->net_seq;
CDEBUG(D_NET, "%s NI seq info: [%d:%d:%d:%u] %s LPNI seq info [%d:%d:%d:%u]\n",
libcfs_nidstr(&best_ni->ni_nid),
best_ni->ni_seq, best_ni->ni_net->net_seq,
atomic_read(&best_ni->ni_tx_credits),
best_ni->ni_sel_priority,
- libcfs_nid2str(best_lpni->lpni_nid),
+ libcfs_nidstr(&best_lpni->lpni_nid),
best_lpni->lpni_seq, best_lpni->lpni_peer_net->lpn_seq,
best_lpni->lpni_txcredits,
best_lpni->lpni_sel_priority);
* the configuration has changed. We don't have a hold on the best_ni
* yet, and it may have vanished.
*/
- cpt2 = lnet_cpt_of_nid_locked(best_lpni->lpni_nid, best_ni);
+ cpt2 = lnet_cpt_of_nid_locked(&best_lpni->lpni_nid, best_ni);
if (sd->sd_cpt != cpt2) {
__u32 seq = lnet_get_dlc_seq_locked();
lnet_net_unlock(sd->sd_cpt);
* what was originally set in the target or it will be the NID of
* a router if this message should be routed
*/
- msg->msg_target.nid = msg->msg_txpeer->lpni_nid;
+ /* FIXME handle large-addr nids */
+ msg->msg_target.nid = lnet_nid_to_nid4(&msg->msg_txpeer->lpni_nid);
/*
* lnet_msg_commit assigns the correct cpt to the message, which
* lnet_select_pathway() function and is never changed.
* It's safe to use it here.
*/
- msg->msg_hdr.dest_nid = cpu_to_le64(final_dst_lpni->lpni_nid);
+ /* FIXME handle large-addr nid */
+ msg->msg_hdr.dest_nid =
+ cpu_to_le64(lnet_nid_to_nid4(&final_dst_lpni->lpni_nid));
} else {
/*
* if we're not routing set the dest_nid to the best peer
* ni NID that we picked earlier in the algorithm.
*/
- msg->msg_hdr.dest_nid = cpu_to_le64(msg->msg_txpeer->lpni_nid);
+ msg->msg_hdr.dest_nid =
+ cpu_to_le64(lnet_nid_to_nid4(&msg->msg_txpeer->lpni_nid));
}
/*
if (msg->msg_md) {
rspt = msg->msg_md->md_rspt_ptr;
if (rspt) {
- rspt->rspt_next_hop_nid = msg->msg_txpeer->lpni_nid;
+ rspt->rspt_next_hop_nid =
+ msg->msg_txpeer->lpni_nid;
CDEBUG(D_NET, "rspt_next_hop_nid = %s\n",
- libcfs_nid2str(rspt->rspt_next_hop_nid));
+ libcfs_nidstr(&rspt->rspt_next_hop_nid));
}
}
libcfs_nid2str(sd->sd_src_nid),
libcfs_nid2str(msg->msg_hdr.dest_nid),
libcfs_nid2str(sd->sd_dst_nid),
- libcfs_nid2str(msg->msg_txpeer->lpni_nid),
+ libcfs_nidstr(&msg->msg_txpeer->lpni_nid),
libcfs_nid2str(sd->sd_rtr_nid),
lnet_msgtyp2str(msg->msg_type), msg->msg_retry_count);
!lnet_msg_is_response(msg) && lpni->lpni_pref_nnids == 0) {
CDEBUG(D_NET, "Setting preferred local NID %s on NMR peer %s\n",
libcfs_nidstr(&lni->ni_nid),
- libcfs_nid2str(lpni->lpni_nid));
- lnet_peer_ni_set_non_mr_pref_nid(
- lpni, lnet_nid_to_nid4(&lni->ni_nid));
+ libcfs_nidstr(&lpni->lpni_nid));
+ lnet_peer_ni_set_non_mr_pref_nid(lpni, &lni->ni_nid);
}
}
}
if (sd->sd_best_lpni &&
- sd->sd_best_lpni->lpni_nid ==
- lnet_nid_to_nid4(&the_lnet.ln_loni->ni_nid))
+ nid_same(&sd->sd_best_lpni->lpni_nid,
+ &the_lnet.ln_loni->ni_nid))
return lnet_handle_lo_send(sd);
else if (sd->sd_best_lpni)
return lnet_handle_send(sd);
return rc;
}
- new_lpni = lnet_find_peer_ni_locked(lpni->lpni_nid);
+ new_lpni = lnet_find_peer_ni_locked(lnet_nid_to_nid4(&lpni->lpni_nid));
if (!new_lpni) {
lnet_peer_ni_decref_locked(lpni);
return -ENOENT;
lnet_peer_ni_decref_locked(new_lpni);
CDEBUG(D_NET, "msg %p delayed. %s pending discovery\n",
- msg, libcfs_nid2str(peer->lp_primary_nid));
+ msg, libcfs_nidstr(&peer->lp_primary_nid));
return LNET_DC_WAIT;
}
if (lpni_entry->lpni_pref_nnids == 0)
continue;
LASSERT(lpni_entry->lpni_pref_nnids == 1);
- best_ni = lnet_nid2ni_locked(lpni_entry->lpni_pref.nid, cpt);
+ best_ni = lnet_nid_to_ni_locked(&lpni_entry->lpni_pref.nid,
+ cpt);
break;
}
/* If there is no best_ni we don't have a route */
if (!best_ni) {
CERROR("no path to %s from net %s\n",
- libcfs_nid2str(best_lpni->lpni_nid),
+ libcfs_nidstr(&best_lpni->lpni_nid),
libcfs_net2str(best_lpni->lpni_net->net_id));
return -EHOSTUNREACH;
}
* network
*/
if (sd->sd_best_lpni &&
- sd->sd_best_lpni->lpni_nid ==
- lnet_nid_to_nid4(&the_lnet.ln_loni->ni_nid)) {
+ nid_same(&sd->sd_best_lpni->lpni_nid,
+ &the_lnet.ln_loni->ni_nid)) {
/*
* in case we initially started with a routed
* destination, let's reset to local
if (ktime_compare(now, rspt->rspt_deadline) >= 0 ||
the_lnet.ln_mt_state == LNET_MT_STATE_SHUTDOWN) {
struct lnet_peer_ni *lpni;
- lnet_nid_t nid;
+ struct lnet_nid nid;
md = lnet_handle2md(&rspt->rspt_mdh);
if (!md) {
CDEBUG(D_NET,
"Response timeout: md = %p: nid = %s\n",
- md, libcfs_nid2str(nid));
+ md, libcfs_nidstr(&nid));
/*
* If there is a timeout on the response
* value so that we don't use it
*/
lnet_net_lock(0);
- lpni = lnet_find_peer_ni_locked(nid);
+ lpni = lnet_peer_ni_find_locked(&nid);
if (lpni) {
lnet_handle_remote_failure_locked(lpni);
lnet_peer_ni_decref_locked(lpni);
LIBCFS_ALLOC(ev_info, sizeof(*ev_info));
if (!ev_info) {
CERROR("out of memory. Can't recover %s\n",
- libcfs_nid2str(lpni->lpni_nid));
+ libcfs_nidstr(&lpni->lpni_nid));
spin_lock(&lpni->lpni_lock);
lpni->lpni_state &= ~LNET_PEER_NI_RECOVERY_PENDING;
spin_unlock(&lpni->lpni_lock);
/* look at the comments in lnet_recover_local_nis() */
mdh = lpni->lpni_recovery_ping_mdh;
LNetInvalidateMDHandle(&lpni->lpni_recovery_ping_mdh);
- nid = lpni->lpni_nid;
+ /* FIXME handle large-addr nid */
+ nid = lnet_nid_to_nid4(&lpni->lpni_nid);
lnet_net_lock(0);
list_del_init(&lpni->lpni_recovery);
lnet_peer_ni_decref_locked(lpni);
hdr->msg.put.offset = le32_to_cpu(hdr->msg.put.offset);
/* Primary peer NID. */
- info.mi_id.nid = msg->msg_initiator;
+ lnet_nid4_to_nid(msg->msg_initiator, &info.mi_id.nid);
info.mi_id.pid = hdr->src_pid;
info.mi_opc = LNET_MD_OP_PUT;
info.mi_portal = hdr->msg.put.ptl_index;
case LNET_MATCHMD_DROP:
CNETERR("Dropping PUT from %s portal %d match %llu"
" offset %d length %d: %d\n",
- libcfs_id2str(info.mi_id), info.mi_portal,
+ libcfs_idstr(&info.mi_id), info.mi_portal,
info.mi_mbits, info.mi_roffset, info.mi_rlength, rc);
return -ENOENT; /* -ve: OK but no match */
source_id.nid = hdr->src_nid;
source_id.pid = hdr->src_pid;
/* Primary peer NID */
- info.mi_id.nid = msg->msg_initiator;
+ lnet_nid4_to_nid(msg->msg_initiator, &info.mi_id.nid);
info.mi_id.pid = hdr->src_pid;
info.mi_opc = LNET_MD_OP_GET;
info.mi_portal = hdr->msg.get.ptl_index;
if (rc == LNET_MATCHMD_DROP) {
CNETERR("Dropping GET from %s portal %d match %llu"
" offset %d length %d\n",
- libcfs_id2str(info.mi_id), info.mi_portal,
+ libcfs_idstr(&info.mi_id), info.mi_portal,
info.mi_mbits, info.mi_roffset, info.mi_rlength);
return -ENOENT; /* -ve: OK but no match */
}
/* didn't get as far as lnet_ni_send() */
CERROR("%s: Unable to send REPLY for GET from %s: %d\n",
libcfs_nidstr(&ni->ni_nid),
- libcfs_id2str(info.mi_id), rc);
+ libcfs_idstr(&info.mi_id), rc);
lnet_finalize(msg, rc);
}
}
int
-lnet_parse(struct lnet_ni *ni, struct lnet_hdr *hdr, lnet_nid_t from_nid,
+lnet_parse(struct lnet_ni *ni, struct lnet_hdr *hdr, lnet_nid_t from_nid4,
void *private, int rdma_req)
{
struct lnet_peer_ni *lpni;
lnet_pid_t dest_pid;
lnet_nid_t dest_nid;
lnet_nid_t src_nid;
+ struct lnet_nid from_nid;
bool push = false;
int for_me;
__u32 type;
LASSERT (!in_interrupt ());
+ lnet_nid4_to_nid(from_nid4, &from_nid);
+
type = le32_to_cpu(hdr->type);
src_nid = le64_to_cpu(hdr->src_nid);
dest_nid = le64_to_cpu(hdr->dest_nid);
/* FIXME handle large-addr nids */
for_me = (lnet_nid_to_nid4(&ni->ni_nid) == dest_nid);
- cpt = lnet_cpt_of_nid(from_nid, ni);
+ cpt = lnet_cpt_of_nid(from_nid4, ni);
CDEBUG(D_NET, "TRACE: %s(%s) <- %s : %s - %s\n",
libcfs_nid2str(dest_nid),
case LNET_MSG_GET:
if (payload_length > 0) {
CERROR("%s, src %s: bad %s payload %d (0 expected)\n",
- libcfs_nid2str(from_nid),
+ libcfs_nid2str(from_nid4),
libcfs_nid2str(src_nid),
lnet_msgtyp2str(type), payload_length);
return -EPROTO;
(__u32)(for_me ? LNET_MAX_PAYLOAD : LNET_MTU)) {
CERROR("%s, src %s: bad %s payload %d "
"(%d max expected)\n",
- libcfs_nid2str(from_nid),
+ libcfs_nid2str(from_nid4),
libcfs_nid2str(src_nid),
lnet_msgtyp2str(type),
payload_length,
default:
CERROR("%s, src %s: Bad message type 0x%x\n",
- libcfs_nid2str(from_nid),
+ libcfs_nid2str(from_nid4),
libcfs_nid2str(src_nid), type);
return -EPROTO;
}
/* should have gone direct */
CERROR("%s, src %s: Bad dest nid %s "
"(should have been sent direct)\n",
- libcfs_nid2str(from_nid),
+ libcfs_nid2str(from_nid4),
libcfs_nid2str(src_nid),
libcfs_nid2str(dest_nid));
return -EPROTO;
}
- if (lnet_islocalnid(dest_nid)) {
+ if (lnet_islocalnid4(dest_nid)) {
/* dest is another local NI; sender should have used
* this node's NID on its own network */
CERROR("%s, src %s: Bad dest nid %s "
"(it's my nid but on a different network)\n",
- libcfs_nid2str(from_nid),
+ libcfs_nid2str(from_nid4),
libcfs_nid2str(src_nid),
libcfs_nid2str(dest_nid));
return -EPROTO;
if (rdma_req && type == LNET_MSG_GET) {
CERROR("%s, src %s: Bad optimized GET for %s "
"(final destination must be me)\n",
- libcfs_nid2str(from_nid),
+ libcfs_nid2str(from_nid4),
libcfs_nid2str(src_nid),
libcfs_nid2str(dest_nid));
return -EPROTO;
if (!the_lnet.ln_routing) {
CERROR("%s, src %s: Dropping message for %s "
"(routing not enabled)\n",
- libcfs_nid2str(from_nid),
+ libcfs_nid2str(from_nid4),
libcfs_nid2str(src_nid),
libcfs_nid2str(dest_nid));
goto drop;
if (!list_empty(&the_lnet.ln_test_peers) && /* normally we don't */
fail_peer(src_nid, 0)) { /* shall we now? */
CERROR("%s, src %s: Dropping %s to simulate failure\n",
- libcfs_nid2str(from_nid), libcfs_nid2str(src_nid),
+ libcfs_nid2str(from_nid4), libcfs_nid2str(src_nid),
lnet_msgtyp2str(type));
goto drop;
}
lnet_drop_rule_match(hdr, lnet_nid_to_nid4(&ni->ni_nid), NULL)) {
CDEBUG(D_NET,
"%s, src %s, dst %s: Dropping %s to simulate silent message loss\n",
- libcfs_nid2str(from_nid), libcfs_nid2str(src_nid),
+ libcfs_nid2str(from_nid4), libcfs_nid2str(src_nid),
libcfs_nid2str(dest_nid), lnet_msgtyp2str(type));
goto drop;
}
msg = lnet_msg_alloc();
if (msg == NULL) {
CERROR("%s, src %s: Dropping %s (out of memory)\n",
- libcfs_nid2str(from_nid), libcfs_nid2str(src_nid),
+ libcfs_nid2str(from_nid4), libcfs_nid2str(src_nid),
lnet_msgtyp2str(type));
goto drop;
}
msg->msg_offset = 0;
msg->msg_hdr = *hdr;
/* for building message event */
- msg->msg_from = from_nid;
+ msg->msg_from = from_nid4;
if (!for_me) {
msg->msg_target.pid = dest_pid;
msg->msg_target.nid = dest_nid;
}
lnet_net_lock(cpt);
- /* FIXME support large-addr nid */
- lpni = lnet_nid2peerni_locked(from_nid, lnet_nid_to_nid4(&ni->ni_nid),
- cpt);
+ lpni = lnet_peerni_by_nid_locked(&from_nid, &ni->ni_nid, cpt);
if (IS_ERR(lpni)) {
lnet_net_unlock(cpt);
- CERROR("%s, src %s: Dropping %s "
- "(error %ld looking up sender)\n",
- libcfs_nid2str(from_nid), libcfs_nid2str(src_nid),
- lnet_msgtyp2str(type), PTR_ERR(lpni));
+ rc = PTR_ERR(lpni);
+ CERROR("%s, src %s: Dropping %s (error %d looking up sender)\n",
+ libcfs_nid2str(from_nid4), libcfs_nid2str(src_nid),
+ lnet_msgtyp2str(type), rc);
lnet_msg_free(msg);
if (rc == -ESHUTDOWN)
/* We are shutting down. Don't do anything more */
*/
if (((lnet_drop_asym_route && for_me) ||
!lpni->lpni_peer_net->lpn_peer->lp_alive) &&
- LNET_NIDNET(src_nid) != LNET_NIDNET(from_nid)) {
+ LNET_NIDNET(src_nid) != LNET_NIDNET(from_nid4)) {
__u32 src_net_id = LNET_NIDNET(src_nid);
struct lnet_peer *gw = lpni->lpni_peer_net->lpn_peer;
struct lnet_route *route;
}
}
if (lnet_drop_asym_route && for_me && !found) {
+ /* Drop ref taken by lnet_nid2peerni_locked() */
+ lnet_peer_ni_decref_locked(lpni);
lnet_net_unlock(cpt);
/* we would not use from_nid to route a message to
* src_nid
* => asymmetric routing detected but forbidden
*/
CERROR("%s, src %s: Dropping asymmetrical route %s\n",
- libcfs_nid2str(from_nid),
+ libcfs_nid2str(from_nid4),
libcfs_nid2str(src_nid), lnet_msgtyp2str(type));
lnet_msg_free(msg);
goto drop;
libcfs_nidstr(&ni->ni_nid), libcfs_id2str(peer_id), getmd);
/* setup information for lnet_build_msg_event */
- msg->msg_initiator = getmsg->msg_txpeer->lpni_peer_net->lpn_peer->lp_primary_nid;
+ msg->msg_initiator =
+ lnet_nid_to_nid4(&getmsg->msg_txpeer->lpni_peer_net->lpn_peer->lp_primary_nid);
msg->msg_from = peer_id.nid;
msg->msg_type = LNET_MSG_GET; /* flag this msg as an "optimized" GET */
msg->msg_hdr.src_nid = peer_id.nid;