return msg->msg_type == LNET_MSG_ACK || msg->msg_type == LNET_MSG_REPLY;
}
+static inline bool
+lnet_response_tracking_enabled(__u32 msg_type, unsigned int md_options)
+{
+ if (md_options & LNET_MD_NO_TRACK_RESPONSE)
+ /* Explicitly disabled in MD options */
+ return false;
+
+ if (md_options & LNET_MD_TRACK_RESPONSE)
+ /* Explicity enabled in MD options */
+ return true;
+
+ if (lnet_response_tracking == 3)
+ /* Enabled for all message types */
+ return true;
+
+ if (msg_type == LNET_MSG_PUT)
+ return lnet_response_tracking == 2;
+
+ if (msg_type == LNET_MSG_GET)
+ return lnet_response_tracking == 1;
+
+ return false;
+}
+
static inline struct lnet_comm_count *
get_stats_counts(struct lnet_element_stats *stats,
enum lnet_stats_type stats_type)
}
EXPORT_SYMBOL(lnet_copy_iov2iov);
-int
-lnet_extract_iov(int dst_niov, struct kvec *dst,
- int src_niov, struct kvec *src,
- unsigned int offset, unsigned int len)
-{
- /* Initialise 'dst' to the subset of 'src' starting at 'offset',
- * for exactly 'len' bytes, and return the number of entries.
- * NB not destructive to 'src' */
- unsigned int frag_len;
- unsigned int niov;
-
- if (len == 0) /* no data => */
- return (0); /* no frags */
-
- LASSERT(src_niov > 0);
- while (offset >= src->iov_len) { /* skip initial frags */
- offset -= src->iov_len;
- src_niov--;
- src++;
- LASSERT(src_niov > 0);
- }
-
- niov = 1;
- for (;;) {
- LASSERT(src_niov > 0);
- LASSERT((int)niov <= dst_niov);
-
- frag_len = src->iov_len - offset;
- dst->iov_base = ((char *)src->iov_base) + offset;
-
- if (len <= frag_len) {
- dst->iov_len = len;
- return (niov);
- }
-
- dst->iov_len = frag_len;
-
- len -= frag_len;
- dst++;
- src++;
- niov++;
- src_niov--;
- offset = 0;
- }
-}
-EXPORT_SYMBOL(lnet_extract_iov);
-
-
unsigned int
lnet_kiov_nob(unsigned int niov, struct bio_vec *kiov)
{
}
}
-static int
-lnet_compare_gw_lpnis(struct lnet_peer_ni *p1, struct lnet_peer_ni *p2)
-{
- if (p1->lpni_txqnob < p2->lpni_txqnob)
- return 1;
-
- if (p1->lpni_txqnob > p2->lpni_txqnob)
- return -1;
-
- if (p1->lpni_txcredits > p2->lpni_txcredits)
- return 1;
-
- if (p1->lpni_txcredits < p2->lpni_txcredits)
- return -1;
-
- return 0;
-}
-
static struct lnet_peer_ni *
lnet_select_peer_ni(struct lnet_ni *best_ni, lnet_nid_t dst_nid,
struct lnet_peer *peer,
+ struct lnet_peer_ni *best_lpni,
struct lnet_peer_net *peer_net)
{
/*
* credits are equal, we round-robin over the peer_ni.
*/
struct lnet_peer_ni *lpni = NULL;
- struct lnet_peer_ni *best_lpni = NULL;
- int best_lpni_credits = INT_MIN;
- bool preferred = false;
- bool ni_is_pref;
- int best_lpni_healthv = 0;
+ int best_lpni_credits = (best_lpni) ? best_lpni->lpni_txcredits :
+ INT_MIN;
+ int best_lpni_healthv = (best_lpni) ?
+ atomic_read(&best_lpni->lpni_healthv) : 0;
+ bool best_lpni_is_preferred = false;
+ bool lpni_is_preferred;
int lpni_healthv;
+ __u32 lpni_sel_prio;
+ __u32 best_sel_prio = LNET_MAX_SELECTION_PRIORITY;
while ((lpni = lnet_get_next_peer_ni_locked(peer, peer_net, lpni))) {
/*
* preferred, then let's use it
*/
if (best_ni) {
- ni_is_pref = lnet_peer_is_pref_nid_locked(lpni,
+ lpni_is_preferred = lnet_peer_is_pref_nid_locked(lpni,
best_ni->ni_nid);
- CDEBUG(D_NET, "%s ni_is_pref = %d\n",
- libcfs_nid2str(best_ni->ni_nid), ni_is_pref);
+ CDEBUG(D_NET, "%s lpni_is_preferred = %d\n",
+ libcfs_nid2str(best_ni->ni_nid),
+ lpni_is_preferred);
} else {
- ni_is_pref = false;
+ lpni_is_preferred = false;
}
lpni_healthv = atomic_read(&lpni->lpni_healthv);
+ lpni_sel_prio = lpni->lpni_sel_priority;
if (best_lpni)
- CDEBUG(D_NET, "%s c:[%d, %d], s:[%d, %d]\n",
+ 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),
+ lpni_healthv, best_lpni_healthv,
+ lpni_sel_prio, best_sel_prio,
lpni->lpni_txcredits, best_lpni_credits,
lpni->lpni_seq, best_lpni->lpni_seq);
+ else
+ goto select_lpni;
/* pick the healthiest peer ni */
- if (lpni_healthv < best_lpni_healthv) {
+ if (lpni_healthv < best_lpni_healthv)
continue;
- } else if (lpni_healthv > best_lpni_healthv) {
- best_lpni_healthv = lpni_healthv;
+ else if (lpni_healthv > best_lpni_healthv) {
+ if (best_lpni_is_preferred)
+ best_lpni_is_preferred = false;
+ goto select_lpni;
+ }
+
+ if (lpni_sel_prio > best_sel_prio)
+ continue;
+ else if (lpni_sel_prio < best_sel_prio) {
+ if (best_lpni_is_preferred)
+ best_lpni_is_preferred = false;
+ goto select_lpni;
+ }
+
/* if this is a preferred peer use it */
- } else if (!preferred && ni_is_pref) {
- preferred = true;
- } else if (preferred && !ni_is_pref) {
- /*
- * this is not the preferred peer so let's ignore
+ if (!best_lpni_is_preferred && lpni_is_preferred) {
+ best_lpni_is_preferred = true;
+ goto select_lpni;
+ } else if (best_lpni_is_preferred && !lpni_is_preferred) {
+ /* this is not the preferred peer so let's ignore
* it.
*/
continue;
- } else if (lpni->lpni_txcredits < best_lpni_credits) {
- /*
- * We already have a peer that has more credits
+ }
+
+ if (lpni->lpni_txcredits < best_lpni_credits)
+ /* We already have a peer that has more credits
* available than this one. No need to consider
* this peer further.
*/
continue;
- } else if (lpni->lpni_txcredits == best_lpni_credits) {
- /*
- * The best peer found so far and the current peer
- * have the same number of available credits let's
- * make sure to select between them using Round
- * Robin
- */
- if (best_lpni) {
- if (best_lpni->lpni_seq <= lpni->lpni_seq)
- continue;
- }
- }
+ else if (lpni->lpni_txcredits > best_lpni_credits)
+ goto select_lpni;
+ /* The best peer found so far and the current peer
+ * have the same number of available credits let's
+ * make sure to select between them using Round Robin
+ */
+ if (best_lpni && (best_lpni->lpni_seq <= lpni->lpni_seq))
+ continue;
+select_lpni:
+ best_lpni_is_preferred = lpni_is_preferred;
+ best_lpni_healthv = lpni_healthv;
+ best_sel_prio = lpni_sel_prio;
best_lpni = lpni;
best_lpni_credits = lpni->lpni_txcredits;
}
/*
* Prerequisite: the best_ni should already be set in the sd
+ * Find the best lpni.
+ * If the net id is provided then restrict lpni selection on
+ * that particular net.
+ * Otherwise find any reachable lpni. When dealing with an MR
+ * gateway and it has multiple lpnis which we can use
+ * we want to select the best one from the list of reachable
+ * ones.
*/
static inline struct lnet_peer_ni *
-lnet_find_best_lpni_on_net(struct lnet_ni *lni, lnet_nid_t dst_nid,
- struct lnet_peer *peer, __u32 net_id)
+lnet_find_best_lpni(struct lnet_ni *lni, lnet_nid_t dst_nid,
+ struct lnet_peer *peer, __u32 net_id)
{
struct lnet_peer_net *peer_net;
- /*
- * The gateway is Multi-Rail capable so now we must select the
- * proper peer_ni
- */
+ /* find the best_lpni on any local network */
+ if (net_id == LNET_NET_ANY) {
+ struct lnet_peer_ni *best_lpni = NULL;
+ struct lnet_peer_net *lpn;
+ list_for_each_entry(lpn, &peer->lp_peer_nets, lpn_peer_nets) {
+ /* no net specified find any reachable peer ni */
+ if (!lnet_islocalnet_locked(lpn->lpn_net_id))
+ continue;
+ best_lpni = lnet_select_peer_ni(lni, dst_nid, peer,
+ best_lpni, lpn);
+ }
+
+ return best_lpni;
+ }
+ /* restrict on the specified net */
peer_net = lnet_peer_get_net_locked(peer, net_id);
+ if (peer_net)
+ return lnet_select_peer_ni(lni, dst_nid, peer, NULL, peer_net);
- return lnet_select_peer_ni(lni, dst_nid, peer, peer_net);
+ return NULL;
+}
+
+static int
+lnet_compare_gw_lpnis(struct lnet_peer_ni *lpni1, struct lnet_peer_ni *lpni2)
+{
+ if (lpni1->lpni_txqnob < lpni2->lpni_txqnob)
+ return 1;
+
+ if (lpni1->lpni_txqnob > lpni2->lpni_txqnob)
+ return -1;
+
+ if (lpni1->lpni_txcredits > lpni2->lpni_txcredits)
+ return 1;
+
+ if (lpni1->lpni_txcredits < lpni2->lpni_txcredits)
+ return -1;
+
+ return 0;
}
/* Compare route priorities and hop counts */
static struct lnet_route *
lnet_find_route_locked(struct lnet_remotenet *rnet, __u32 src_net,
+ struct lnet_peer_ni *remote_lpni,
struct lnet_route **prev_route,
struct lnet_peer_ni **gwni)
{
struct lnet_route *last_route;
struct lnet_route *route;
int rc;
+ bool best_rte_is_preferred = false;
+ lnet_nid_t gw_pnid;
+
+ CDEBUG(D_NET, "Looking up a route to %s, from %s\n",
+ libcfs_net2str(rnet->lrn_net), libcfs_net2str(src_net));
best_route = last_route = NULL;
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;
- /*
- * Restrict the selection of the router NI on the src_net
- * provided. If the src_net is LNET_NID_ANY, then select
- * the best interface available.
+ /* no protection on below fields, but it's harmless */
+ if (last_route && (last_route->lr_seq - route->lr_seq < 0))
+ last_route = route;
+
+ /* if the best route found is in the preferred list then
+ * tag it as preferred and use it later on. But if we
+ * didn't find any routes which are on the preferred list
+ * then just use the best route possible.
*/
- if (!best_route) {
- lpni = lnet_find_best_lpni_on_net(NULL, LNET_NID_ANY,
- route->lr_gateway,
- src_net);
- if (lpni) {
- best_route = last_route = route;
- best_gw_ni = lpni;
- } else
- CERROR("Gateway %s does not have a peer NI on net %s\n",
- libcfs_nid2str(route->lr_gateway->lp_primary_nid),
+ rc = lnet_peer_is_pref_rtr_locked(remote_lpni, gw_pnid);
+
+ if (!best_route || (rc && !best_rte_is_preferred)) {
+ /* Restrict the selection of the router NI on the
+ * src_net provided. If the src_net is LNET_NID_ANY,
+ * then select the best interface available.
+ */
+ lpni = lnet_find_best_lpni(NULL, LNET_NID_ANY,
+ route->lr_gateway,
+ src_net);
+ if (!lpni) {
+ CDEBUG(D_NET,
+ "Gateway %s does not have a peer NI on net %s\n",
+ libcfs_nid2str(gw_pnid),
libcfs_net2str(src_net));
+ continue;
+ }
+ }
+ if (rc && !best_rte_is_preferred) {
+ /* This is the first preferred route we found,
+ * so it beats any route found previously
+ */
+ best_route = route;
+ if (!last_route)
+ last_route = route;
+ best_gw_ni = lpni;
+ best_rte_is_preferred = true;
+ CDEBUG(D_NET, "preferred gw = %s\n",
+ libcfs_nid2str(gw_pnid));
+ continue;
+ } else if ((!rc) && best_rte_is_preferred)
+ /* The best route we found so far is in the preferred
+ * list, so it beats any non-preferred route
+ */
continue;
- }
- /* no protection on below fields, but it's harmless */
- if (last_route->lr_seq - route->lr_seq < 0)
- last_route = route;
+ if (!best_route) {
+ best_route = last_route = route;
+ best_gw_ni = lpni;
+ continue;
+ }
rc = lnet_compare_routes(route, best_route);
if (rc == -1)
continue;
- lpni = lnet_find_best_lpni_on_net(NULL, LNET_NID_ANY,
- route->lr_gateway,
- src_net);
+ /* Restrict the selection of the router NI on the
+ * src_net provided. If the src_net is LNET_NID_ANY,
+ * then select the best interface available.
+ */
+ lpni = lnet_find_best_lpni(NULL, LNET_NID_ANY,
+ route->lr_gateway,
+ src_net);
if (!lpni) {
- CERROR("Gateway %s does not have a peer NI on net %s\n",
- libcfs_nid2str(route->lr_gateway->lp_primary_nid),
+ CDEBUG(D_NET,
+ "Gateway %s does not have a peer NI on net %s\n",
+ libcfs_nid2str(gw_pnid),
libcfs_net2str(src_net));
continue;
}
unsigned int shortest_distance;
int best_credits;
int best_healthv;
+ __u32 best_sel_prio;
/*
* If there is no peer_ni that we can send to on this network,
return best_ni;
if (best_ni == NULL) {
+ best_sel_prio = LNET_MAX_SELECTION_PRIORITY;
shortest_distance = UINT_MAX;
best_credits = INT_MIN;
best_healthv = 0;
best_ni->ni_dev_cpt);
best_credits = atomic_read(&best_ni->ni_tx_credits);
best_healthv = atomic_read(&best_ni->ni_healthv);
+ best_sel_prio = best_ni->ni_sel_priority;
}
while ((ni = lnet_get_next_ni_locked(local_net, ni))) {
int ni_credits;
int ni_healthv;
int ni_fatal;
+ __u32 ni_sel_prio;
ni_credits = atomic_read(&ni->ni_tx_credits);
ni_healthv = atomic_read(&ni->ni_healthv);
ni_fatal = atomic_read(&ni->ni_fatal_error_on);
+ ni_sel_prio = ni->ni_sel_priority;
/*
* calculate the distance from the CPT on which
md_cpt,
ni->ni_dev_cpt);
- CDEBUG(D_NET, "compare ni %s [c:%d, d:%d, s:%d] with best_ni %s [c:%d, d:%d, s:%d]\n",
- libcfs_nid2str(ni->ni_nid), ni_credits, distance,
- ni->ni_seq, (best_ni) ? libcfs_nid2str(best_ni->ni_nid)
- : "not seleced", best_credits, shortest_distance,
- (best_ni) ? best_ni->ni_seq : 0);
-
/*
* All distances smaller than the NUMA range
* are treated equally.
* Select on health, shorter distance, available
* credits, then round-robin.
*/
- if (ni_fatal) {
+ if (ni_fatal)
continue;
- } else if (ni_healthv < best_healthv) {
+
+ if (best_ni)
+ CDEBUG(D_NET, "compare ni %s [c:%d, d:%d, s:%d, p:%u] with best_ni %s [c:%d, d:%d, s:%d, p:%u]\n",
+ libcfs_nid2str(ni->ni_nid), ni_credits, distance,
+ ni->ni_seq, ni_sel_prio,
+ (best_ni) ? libcfs_nid2str(best_ni->ni_nid)
+ : "not selected", best_credits, shortest_distance,
+ (best_ni) ? best_ni->ni_seq : 0,
+ best_sel_prio);
+ else
+ goto select_ni;
+
+ if (ni_healthv < best_healthv)
continue;
- } else if (ni_healthv > best_healthv) {
- best_healthv = ni_healthv;
- /*
- * If we're going to prefer this ni because it's
- * the healthiest, then we should set the
- * shortest_distance in the algorithm in case
- * there are multiple NIs with the same health but
- * different distances.
- */
- if (distance < shortest_distance)
- shortest_distance = distance;
- } else if (distance > shortest_distance) {
+ else if (ni_healthv > best_healthv)
+ goto select_ni;
+
+ if (ni_sel_prio > best_sel_prio)
continue;
- } else if (distance < shortest_distance) {
- shortest_distance = distance;
- } else if (ni_credits < best_credits) {
+ else if (ni_sel_prio < best_sel_prio)
+ goto select_ni;
+
+ if (distance > shortest_distance)
continue;
- } else if (ni_credits == best_credits) {
- if (best_ni && best_ni->ni_seq <= ni->ni_seq)
- continue;
- }
+ else if (distance < shortest_distance)
+ goto select_ni;
+
+ if (ni_credits < best_credits)
+ continue;
+ else if (ni_credits > best_credits)
+ goto select_ni;
+
+ if (best_ni && best_ni->ni_seq <= ni->ni_seq)
+ continue;
+
+select_ni:
+ best_sel_prio = ni_sel_prio;
+ shortest_distance = distance;
+ best_healthv = ni_healthv;
best_ni = ni;
best_credits = ni_credits;
}
lnet_set_non_mr_pref_nid(struct lnet_peer_ni *lpni, struct lnet_ni *lni,
struct lnet_msg *msg)
{
- if (!lnet_msg_is_response(msg) && lpni->lpni_pref_nnids == 0) {
+ if (!lnet_peer_is_multi_rail(lpni->lpni_peer_net->lpn_peer) &&
+ !lnet_msg_is_response(msg) && lpni->lpni_pref_nnids == 0) {
CDEBUG(D_NET, "Setting preferred local NID %s on NMR peer %s\n",
libcfs_nid2str(lni->ni_nid),
libcfs_nid2str(lpni->lpni_nid));
struct lnet_route *last_route = NULL;
struct lnet_peer_ni *lpni = NULL;
struct lnet_peer_ni *gwni = NULL;
- lnet_nid_t src_nid = sd->sd_src_nid;
+ bool route_found = false;
+ lnet_nid_t src_nid = (sd->sd_src_nid != LNET_NID_ANY) ? sd->sd_src_nid :
+ (sd->sd_best_ni != NULL) ? sd->sd_best_ni->ni_nid :
+ LNET_NID_ANY;
+ int best_lpn_healthv = 0;
+ __u32 best_lpn_sel_prio = LNET_MAX_SELECTION_PRIORITY;
+
+ CDEBUG(D_NET, "using src nid %s for route restriction\n",
+ libcfs_nid2str(src_nid));
/* If a router nid was specified then we are replying to a GET or
* sending an ACK. In this case we use the gateway associated with the
*/
if (sd->sd_rtr_nid != LNET_NID_ANY) {
gwni = lnet_find_peer_ni_locked(sd->sd_rtr_nid);
- if (!gwni) {
- CERROR("No peer NI for gateway %s\n",
+ if (gwni) {
+ gw = gwni->lpni_peer_net->lpn_peer;
+ lnet_peer_ni_decref_locked(gwni);
+ if (gw->lp_rtr_refcount) {
+ local_lnet = LNET_NIDNET(sd->sd_rtr_nid);
+ route_found = true;
+ }
+ } else {
+ CWARN("No peer NI for gateway %s. Attempting to find an alternative route.\n",
libcfs_nid2str(sd->sd_rtr_nid));
- return -EHOSTUNREACH;
}
- gw = gwni->lpni_peer_net->lpn_peer;
- lnet_peer_ni_decref_locked(gwni);
- local_lnet = LNET_NIDNET(sd->sd_rtr_nid);
- } else {
- /* we've already looked up the initial lpni using dst_nid */
- lpni = sd->sd_best_lpni;
- /* the peer tree must be in existence */
- LASSERT(lpni && lpni->lpni_peer_net &&
- lpni->lpni_peer_net->lpn_peer);
- lp = lpni->lpni_peer_net->lpn_peer;
-
- list_for_each_entry(lpn, &lp->lp_peer_nets, lpn_peer_nets) {
- /* is this remote network reachable? */
- rnet = lnet_find_rnet_locked(lpn->lpn_net_id);
- if (!rnet)
- continue;
+ }
- if (!best_lpn) {
+ if (!route_found) {
+ if (sd->sd_msg->msg_routing) {
+ /* If I'm routing this message then I need to find the
+ * next hop based on the destination NID
+ */
+ best_rnet = lnet_find_rnet_locked(LNET_NIDNET(sd->sd_dst_nid));
+ if (!best_rnet) {
+ CERROR("Unable to route message to %s - Route table may be misconfigured\n",
+ libcfs_nid2str(sd->sd_dst_nid));
+ return -EHOSTUNREACH;
+ }
+ } else {
+ /* we've already looked up the initial lpni using
+ * dst_nid
+ */
+ lpni = sd->sd_best_lpni;
+ /* the peer tree must be in existence */
+ LASSERT(lpni && lpni->lpni_peer_net &&
+ lpni->lpni_peer_net->lpn_peer);
+ lp = lpni->lpni_peer_net->lpn_peer;
+
+ list_for_each_entry(lpn, &lp->lp_peer_nets, lpn_peer_nets) {
+ /* is this remote network reachable? */
+ rnet = lnet_find_rnet_locked(lpn->lpn_net_id);
+ if (!rnet)
+ continue;
+
+ if (!best_lpn) {
+ best_lpn = lpn;
+ best_rnet = rnet;
+ }
+
+ /* select the preferred peer net */
+ if (best_lpn_healthv > lpn->lpn_healthv)
+ continue;
+ else if (best_lpn_healthv < lpn->lpn_healthv)
+ goto use_lpn;
+
+ if (best_lpn_sel_prio < lpn->lpn_sel_priority)
+ continue;
+ else if (best_lpn_sel_prio > lpn->lpn_sel_priority)
+ goto use_lpn;
+
+ if (best_lpn->lpn_seq <= lpn->lpn_seq)
+ continue;
+use_lpn:
+ best_lpn_healthv = lpn->lpn_healthv;
+ best_lpn_sel_prio = lpn->lpn_sel_priority;
best_lpn = lpn;
best_rnet = rnet;
}
- if (best_lpn->lpn_seq <= lpn->lpn_seq)
- continue;
+ if (!best_lpn) {
+ CERROR("peer %s has no available nets\n",
+ libcfs_nid2str(sd->sd_dst_nid));
+ return -EHOSTUNREACH;
+ }
- best_lpn = lpn;
- best_rnet = rnet;
- }
+ sd->sd_best_lpni = lnet_find_best_lpni(sd->sd_best_ni,
+ sd->sd_dst_nid,
+ lp,
+ best_lpn->lpn_net_id);
+ if (!sd->sd_best_lpni) {
+ CERROR("peer %s is unreachable\n",
+ libcfs_nid2str(sd->sd_dst_nid));
+ return -EHOSTUNREACH;
+ }
- if (!best_lpn) {
- CERROR("peer %s has no available nets\n",
- libcfs_nid2str(sd->sd_dst_nid));
- return -EHOSTUNREACH;
- }
+ /* We're attempting to round robin over the remote peer
+ * NI's so update the final destination we selected
+ */
+ sd->sd_final_dst_lpni = sd->sd_best_lpni;
- sd->sd_best_lpni = lnet_find_best_lpni_on_net(sd->sd_best_ni,
- sd->sd_dst_nid,
- lp,
- best_lpn->lpn_net_id);
- if (!sd->sd_best_lpni) {
- CERROR("peer %s down\n",
- libcfs_nid2str(sd->sd_dst_nid));
- return -EHOSTUNREACH;
+ /* Increment the sequence number of the remote lpni so
+ * we can round robin over the different interfaces of
+ * the remote lpni
+ */
+ sd->sd_best_lpni->lpni_seq++;
}
/*
- * We're attempting to round robin over the remote peer
- * NI's so update the final destination we selected
- */
- sd->sd_final_dst_lpni = sd->sd_best_lpni;
-
- /*
* find the best route. Restrict the selection on the net of the
* local NI if we've already picked the local NI to send from.
* Otherwise, let's pick any route we can find and then find
- * a local NI we can reach the route's gateway on. Any route we select
- * will be reachable by virtue of the restriction we have when
- * adding a route.
+ * a local NI we can reach the route's gateway on. Any route we
+ * select will be reachable by virtue of the restriction we have
+ * when adding a route.
*/
best_route = lnet_find_route_locked(best_rnet,
LNET_NIDNET(src_nid),
+ sd->sd_best_lpni,
&last_route, &gwni);
if (!best_route) {
gw = best_route->lr_gateway;
LASSERT(gw == gwni->lpni_peer_net->lpn_peer);
local_lnet = best_route->lr_lnet;
-
- /*
- * Increment the sequence number of the remote lpni so we
- * can round robin over the different interfaces of the
- * remote lpni
- */
- sd->sd_best_lpni->lpni_seq++;
}
/*
if (sd->sd_rtr_nid == LNET_NID_ANY) {
LASSERT(best_route && last_route);
best_route->lr_seq = last_route->lr_seq + 1;
- best_lpn->lpn_seq++;
+ if (best_lpn)
+ best_lpn->lpn_seq++;
}
return 0;
static int
lnet_handle_any_local_nmr_dst(struct lnet_send_data *sd)
{
- int rc;
+ int rc = 0;
/* sd->sd_best_lpni is already set to the final destination */
return -EFAULT;
}
- rc = lnet_select_preferred_best_ni(sd);
+ if (sd->sd_msg->msg_routing) {
+ /* If I'm forwarding this message then I can choose any NI
+ * on the destination peer net
+ */
+ sd->sd_best_ni = lnet_find_best_ni_on_spec_net(NULL,
+ sd->sd_peer,
+ sd->sd_best_lpni->lpni_peer_net,
+ sd->sd_md_cpt,
+ true);
+ if (!sd->sd_best_ni) {
+ CERROR("Unable to forward message to %s. No local NI available\n",
+ libcfs_nid2str(sd->sd_dst_nid));
+ rc = -EHOSTUNREACH;
+ }
+ } else
+ rc = lnet_select_preferred_best_ni(sd);
+
if (!rc)
rc = lnet_handle_send(sd);
lnet_msg_discovery(sd->sd_msg));
if (sd->sd_best_ni) {
sd->sd_best_lpni =
- lnet_find_best_lpni_on_net(sd->sd_best_ni, sd->sd_dst_nid,
- sd->sd_peer,
- sd->sd_best_ni->ni_net->net_id);
+ lnet_find_best_lpni(sd->sd_best_ni, sd->sd_dst_nid,
+ sd->sd_peer,
+ sd->sd_best_ni->ni_net->net_id);
/*
* if we're successful in selecting a peer_ni on the local
int cpt, rc;
int md_cpt;
__u32 send_case = 0;
+ bool final_hop;
+ bool mr_forwarding_allowed;
memset(&send_data, 0, sizeof(send_data));
else
send_case |= REMOTE_DST;
+ final_hop = false;
+ if (msg->msg_routing && (send_case & LOCAL_DST))
+ final_hop = true;
+
+ /* Determine whether to allow MR forwarding for this message.
+ * NB: MR forwarding is allowed if the message originator and the
+ * destination are both MR capable, and the destination lpni that was
+ * originally chosen by the originator is unhealthy or down.
+ * We check the MR capability of the destination further below
+ */
+ mr_forwarding_allowed = false;
+ if (final_hop) {
+ struct lnet_peer *src_lp;
+ struct lnet_peer_ni *src_lpni;
+
+ src_lpni = lnet_nid2peerni_locked(msg->msg_hdr.src_nid,
+ LNET_NID_ANY, cpt);
+ /* We don't fail the send if we hit any errors here. We'll just
+ * try to send it via non-multi-rail criteria
+ */
+ if (!IS_ERR(src_lpni)) {
+ /* Drop ref taken by lnet_nid2peerni_locked() */
+ lnet_peer_ni_decref_locked(src_lpni);
+ src_lp = lpni->lpni_peer_net->lpn_peer;
+ if (lnet_peer_is_multi_rail(src_lp) &&
+ !lnet_is_peer_ni_alive(lpni))
+ mr_forwarding_allowed = true;
+
+ }
+ CDEBUG(D_NET, "msg %p MR forwarding %s\n", msg,
+ mr_forwarding_allowed ? "allowed" : "not allowed");
+ }
+
/*
* Deal with the peer as NMR in the following cases:
* 1. the peer is NMR
* 2. We're trying to recover a specific peer NI
- * 3. I'm a router sending to the final destination
+ * 3. I'm a router sending to the final destination and MR forwarding is
+ * not allowed for this message (as determined above).
* In this case the source of the message would've
* already selected the final destination so my job
* is to honor the selection.
*/
if (!lnet_peer_is_multi_rail(peer) || msg->msg_recovery ||
- (msg->msg_routing && (send_case & LOCAL_DST)))
+ (final_hop && !mr_forwarding_allowed))
send_case |= NMR_DST;
else
send_case |= MR_DST;
md.length = LNET_PING_INFO_SIZE(nnis);
md.threshold = 2; /* GET/REPLY */
md.max_size = 0;
- md.options = LNET_MD_TRUNCATE;
+ md.options = LNET_MD_TRUNCATE | LNET_MD_TRACK_RESPONSE;
md.user_ptr = user_data;
md.handler = handler;
- rc = LNetMDBind(md, LNET_UNLINK, mdh);
+ rc = LNetMDBind(&md, LNET_UNLINK, mdh);
if (rc) {
lnet_ping_buffer_decref(pbuf);
CERROR("Can't bind MD: %d\n", rc);
}
}
-void
-lnet_print_hdr(struct lnet_hdr *hdr)
-{
- struct lnet_process_id src = {
- .nid = hdr->src_nid,
- .pid = hdr->src_pid,
- };
- struct lnet_process_id dst = {
- .nid = hdr->dest_nid,
- .pid = hdr->dest_pid,
- };
- char *type_str = lnet_msgtyp2str(hdr->type);
-
- CWARN("P3 Header at %p of type %s\n", hdr, type_str);
- CWARN(" From %s\n", libcfs_id2str(src));
- CWARN(" To %s\n", libcfs_id2str(dst));
-
- switch (hdr->type) {
- default:
- break;
-
- case LNET_MSG_PUT:
- CWARN(" Ptl index %d, ack md %#llx.%#llx, "
- "match bits %llu\n",
- hdr->msg.put.ptl_index,
- hdr->msg.put.ack_wmd.wh_interface_cookie,
- hdr->msg.put.ack_wmd.wh_object_cookie,
- hdr->msg.put.match_bits);
- CWARN(" Length %d, offset %d, hdr data %#llx\n",
- hdr->payload_length, hdr->msg.put.offset,
- hdr->msg.put.hdr_data);
- break;
-
- case LNET_MSG_GET:
- CWARN(" Ptl index %d, return md %#llx.%#llx, "
- "match bits %llu\n", hdr->msg.get.ptl_index,
- hdr->msg.get.return_wmd.wh_interface_cookie,
- hdr->msg.get.return_wmd.wh_object_cookie,
- hdr->msg.get.match_bits);
- CWARN(" Length %d, src offset %d\n",
- hdr->msg.get.sink_length,
- hdr->msg.get.src_offset);
- break;
-
- case LNET_MSG_ACK:
- CWARN(" dst md %#llx.%#llx, "
- "manipulated length %d\n",
- hdr->msg.ack.dst_wmd.wh_interface_cookie,
- hdr->msg.ack.dst_wmd.wh_object_cookie,
- hdr->msg.ack.mlength);
- break;
-
- case LNET_MSG_REPLY:
- CWARN(" dst md %#llx.%#llx, "
- "length %d\n",
- hdr->msg.reply.dst_wmd.wh_interface_cookie,
- hdr->msg.reply.dst_wmd.wh_object_cookie,
- hdr->payload_length);
- }
-
-}
-
int
lnet_parse(struct lnet_ni *ni, struct lnet_hdr *hdr, lnet_nid_t from_nid,
void *private, int rdma_req)
spin_lock(&ni->ni_net->net_lock);
ni->ni_net->net_last_alive = ktime_get_real_seconds();
spin_unlock(&ni->ni_net->net_lock);
- if (ni->ni_status != NULL &&
- ni->ni_status->ns_status == LNET_NI_STATUS_DOWN) {
- ni->ni_status->ns_status = LNET_NI_STATUS_UP;
- push = true;
- }
+ push = lnet_ni_set_status_locked(ni, LNET_NI_STATUS_UP);
lnet_ni_unlock(ni);
}
md->md_me->me_portal);
lnet_res_unlock(cpt);
- lnet_rspt_free(rspt, cpt);
+ if (rspt)
+ lnet_rspt_free(rspt, cpt);
+
lnet_msg_free(msg);
return -ENOENT;
}
lnet_build_msg_event(msg, LNET_EVENT_SEND);
- if (ack == LNET_ACK_REQ)
+ if (rspt && lnet_response_tracking_enabled(LNET_MSG_PUT,
+ md->md_options))
lnet_attach_rsp_tracker(rspt, cpt, md, mdh);
+ else if (rspt)
+ lnet_rspt_free(rspt, cpt);
if (CFS_FAIL_CHECK_ORSET(CFS_FAIL_PTLRPC_OST_BULK_CB2,
CFS_FAIL_ONCE))
lnet_build_msg_event(msg, LNET_EVENT_SEND);
- lnet_attach_rsp_tracker(rspt, cpt, md, mdh);
+ if (lnet_response_tracking_enabled(LNET_MSG_GET, md->md_options))
+ lnet_attach_rsp_tracker(rspt, cpt, md, mdh);
+ else
+ lnet_rspt_free(rspt, cpt);
rc = lnet_send(self, msg, LNET_NID_ANY);
if (rc < 0) {
git://git.whamcloud.com / fs / lustre-release.git / blobdiff