module_param(local_nid_dist_zero, int, 0444);
MODULE_PARM_DESC(local_nid_dist_zero, "Reserved");
+static inline struct lnet_comm_count *
+get_stats_counts(struct lnet_element_stats *stats,
+ enum lnet_stats_type stats_type)
+{
+ switch (stats_type) {
+ case LNET_STATS_TYPE_SEND:
+ return &stats->el_send_stats;
+ case LNET_STATS_TYPE_RECV:
+ return &stats->el_recv_stats;
+ case LNET_STATS_TYPE_DROP:
+ return &stats->el_drop_stats;
+ default:
+ CERROR("Unknown stats type\n");
+ }
+
+ return NULL;
+}
+
+void lnet_incr_stats(struct lnet_element_stats *stats, lnet_msg_type_t msg_type,
+ enum lnet_stats_type stats_type)
+{
+ struct lnet_comm_count *counts = get_stats_counts(stats, stats_type);
+ if (!counts)
+ return;
+
+ switch (msg_type) {
+ case LNET_MSG_ACK:
+ atomic_inc(&counts->co_ack_count);
+ break;
+ case LNET_MSG_PUT:
+ atomic_inc(&counts->co_put_count);
+ break;
+ case LNET_MSG_GET:
+ atomic_inc(&counts->co_get_count);
+ break;
+ case LNET_MSG_REPLY:
+ atomic_inc(&counts->co_reply_count);
+ break;
+ case LNET_MSG_HELLO:
+ atomic_inc(&counts->co_hello_count);
+ break;
+ default:
+ CERROR("There is a BUG in the code. Unknown message type\n");
+ break;
+ }
+}
+
+__u32 lnet_sum_stats(struct lnet_element_stats *stats,
+ enum lnet_stats_type stats_type)
+{
+ struct lnet_comm_count *counts = get_stats_counts(stats, stats_type);
+ if (!counts)
+ return 0;
+
+ return (atomic_read(&counts->co_ack_count) +
+ atomic_read(&counts->co_put_count) +
+ atomic_read(&counts->co_get_count) +
+ atomic_read(&counts->co_reply_count) +
+ atomic_read(&counts->co_hello_count));
+}
+
+static inline void assign_stats(struct lnet_ioctl_comm_count *msg_stats,
+ struct lnet_comm_count *counts)
+{
+ msg_stats->ico_get_count = atomic_read(&counts->co_get_count);
+ msg_stats->ico_put_count = atomic_read(&counts->co_put_count);
+ msg_stats->ico_reply_count = atomic_read(&counts->co_reply_count);
+ msg_stats->ico_ack_count = atomic_read(&counts->co_ack_count);
+ msg_stats->ico_hello_count = atomic_read(&counts->co_hello_count);
+}
+
+void lnet_usr_translate_stats(struct lnet_ioctl_element_msg_stats *msg_stats,
+ struct lnet_element_stats *stats)
+{
+ struct lnet_comm_count *counts;
+
+ LASSERT(msg_stats);
+ LASSERT(stats);
+
+ counts = get_stats_counts(stats, LNET_STATS_TYPE_SEND);
+ if (!counts)
+ return;
+ assign_stats(&msg_stats->im_send_stats, counts);
+
+ counts = get_stats_counts(stats, LNET_STATS_TYPE_RECV);
+ if (!counts)
+ return;
+ assign_stats(&msg_stats->im_recv_stats, counts);
+
+ counts = get_stats_counts(stats, LNET_STATS_TYPE_DROP);
+ if (!counts)
+ return;
+ assign_stats(&msg_stats->im_drop_stats, counts);
+}
+
int
lnet_fail_nid(lnet_nid_t nid, unsigned int threshold)
{
- lnet_test_peer_t *tp;
+ struct lnet_test_peer *tp;
struct list_head *el;
struct list_head *next;
struct list_head cull;
lnet_net_lock(0);
list_for_each_safe(el, next, &the_lnet.ln_test_peers) {
- tp = list_entry(el, lnet_test_peer_t, tp_list);
+ 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 */
lnet_net_unlock(0);
while (!list_empty(&cull)) {
- tp = list_entry(cull.next, lnet_test_peer_t, tp_list);
+ tp = list_entry(cull.next, struct lnet_test_peer, tp_list);
list_del(&tp->tp_list);
LIBCFS_FREE(tp, sizeof(*tp));
static int
fail_peer (lnet_nid_t nid, int outgoing)
{
- lnet_test_peer_t *tp;
+ struct lnet_test_peer *tp;
struct list_head *el;
struct list_head *next;
struct list_head cull;
lnet_net_lock(0);
list_for_each_safe(el, next, &the_lnet.ln_test_peers) {
- tp = list_entry(el, lnet_test_peer_t, tp_list);
+ tp = list_entry(el, struct lnet_test_peer, tp_list);
if (tp->tp_threshold == 0) {
/* zombie entry */
lnet_net_unlock(0);
while (!list_empty(&cull)) {
- tp = list_entry(cull.next, lnet_test_peer_t, tp_list);
+ tp = list_entry(cull.next, struct lnet_test_peer, tp_list);
list_del(&tp->tp_list);
LIBCFS_FREE(tp, sizeof(*tp));
EXPORT_SYMBOL(lnet_extract_kiov);
void
-lnet_ni_recv(lnet_ni_t *ni, void *private, lnet_msg_t *msg, int delayed,
- unsigned int offset, unsigned int mlen, unsigned int rlen)
+lnet_ni_recv(struct lnet_ni *ni, void *private, struct lnet_msg *msg,
+ int delayed, unsigned int offset, unsigned int mlen,
+ unsigned int rlen)
{
unsigned int niov = 0;
struct kvec *iov = NULL;
niov, iov, kiov, offset, mlen,
rlen);
if (rc < 0)
- lnet_finalize(ni, msg, rc);
+ lnet_finalize(msg, rc);
}
static void
-lnet_setpayloadbuffer(lnet_msg_t *msg)
+lnet_setpayloadbuffer(struct lnet_msg *msg)
{
- lnet_libmd_t *md = msg->msg_md;
+ struct lnet_libmd *md = msg->msg_md;
LASSERT(msg->msg_len > 0);
LASSERT(!msg->msg_routing);
}
void
-lnet_prep_send(lnet_msg_t *msg, int type, lnet_process_id_t target,
+lnet_prep_send(struct lnet_msg *msg, int type, struct lnet_process_id target,
unsigned int offset, unsigned int len)
{
msg->msg_type = type;
memset (&msg->msg_hdr, 0, sizeof (msg->msg_hdr));
msg->msg_hdr.type = cpu_to_le32(type);
+ /* dest_nid will be overwritten by lnet_select_pathway() */
+ msg->msg_hdr.dest_nid = cpu_to_le64(target.nid);
msg->msg_hdr.dest_pid = cpu_to_le32(target.pid);
/* src_nid will be set later */
msg->msg_hdr.src_pid = cpu_to_le32(the_lnet.ln_pid);
}
static void
-lnet_ni_send(lnet_ni_t *ni, lnet_msg_t *msg)
+lnet_ni_send(struct lnet_ni *ni, struct lnet_msg *msg)
{
void *priv = msg->msg_private;
int rc;
rc = (ni->ni_net->net_lnd->lnd_send)(ni, priv, msg);
if (rc < 0)
- lnet_finalize(ni, msg, rc);
+ lnet_finalize(msg, rc);
}
static int
-lnet_ni_eager_recv(lnet_ni_t *ni, lnet_msg_t *msg)
+lnet_ni_eager_recv(struct lnet_ni *ni, struct lnet_msg *msg)
{
int rc;
* lock before calling lnd_query()
*/
static void
-lnet_ni_query_locked(lnet_ni_t *ni, struct lnet_peer_ni *lp)
+lnet_ni_query_locked(struct lnet_ni *ni, struct lnet_peer_ni *lp)
{
cfs_time_t last_alive = 0;
int cpt = lnet_cpt_of_nid_locked(lp->lpni_nid, ni);
* \retval -ECANCELED If the MD of the message has been unlinked.
*/
static int
-lnet_post_send_locked(lnet_msg_t *msg, int do_send)
+lnet_post_send_locked(struct lnet_msg *msg, int do_send)
{
struct lnet_peer_ni *lp = msg->msg_txpeer;
struct lnet_ni *ni = msg->msg_txni;
the_lnet.ln_counters[cpt]->drop_length += msg->msg_len;
lnet_net_unlock(cpt);
if (msg->msg_txpeer)
- atomic_inc(&msg->msg_txpeer->lpni_stats.drop_count);
+ lnet_incr_stats(&msg->msg_txpeer->lpni_stats,
+ msg->msg_type,
+ LNET_STATS_TYPE_DROP);
if (msg->msg_txni)
- atomic_inc(&msg->msg_txni->ni_stats.drop_count);
+ lnet_incr_stats(&msg->msg_txni->ni_stats,
+ msg->msg_type,
+ LNET_STATS_TYPE_DROP);
CNETERR("Dropping message for %s: peer not alive\n",
libcfs_id2str(msg->msg_target));
if (do_send)
- lnet_finalize(ni, msg, -EHOSTUNREACH);
+ lnet_finalize(msg, -EHOSTUNREACH);
lnet_net_lock(cpt);
return -EHOSTUNREACH;
"called on the MD/ME.\n",
libcfs_id2str(msg->msg_target));
if (do_send)
- lnet_finalize(ni, msg, -ECANCELED);
+ lnet_finalize(msg, -ECANCELED);
lnet_net_lock(cpt);
return -ECANCELED;
!list_empty(&lp->lpni_txq));
msg->msg_peertxcredit = 1;
- lp->lpni_txqnob += msg->msg_len + sizeof(lnet_hdr_t);
+ lp->lpni_txqnob += msg->msg_len + sizeof(struct lnet_hdr);
lp->lpni_txcredits--;
if (lp->lpni_txcredits < lp->lpni_mintxcredits)
}
-static lnet_rtrbufpool_t *
-lnet_msg2bufpool(lnet_msg_t *msg)
+static struct lnet_rtrbufpool *
+lnet_msg2bufpool(struct lnet_msg *msg)
{
- lnet_rtrbufpool_t *rbp;
+ struct lnet_rtrbufpool *rbp;
int cpt;
LASSERT(msg->msg_rx_committed);
}
static int
-lnet_post_routed_recv_locked (lnet_msg_t *msg, int do_recv)
+lnet_post_routed_recv_locked(struct lnet_msg *msg, int do_recv)
{
/* lnet_parse is going to lnet_net_unlock immediately after this, so it
* sets do_recv FALSE and I don't do the unlock/send/lock bit.
* I return LNET_CREDIT_WAIT if msg blocked and LNET_CREDIT_OK if
* received or OK to receive */
struct lnet_peer_ni *lp = msg->msg_rxpeer;
- lnet_rtrbufpool_t *rbp;
- lnet_rtrbuf_t *rb;
+ struct lnet_rtrbufpool *rbp;
+ struct lnet_rtrbuf *rb;
LASSERT (msg->msg_iov == NULL);
LASSERT (msg->msg_kiov == NULL);
}
LASSERT(!list_empty(&rbp->rbp_bufs));
- rb = list_entry(rbp->rbp_bufs.next, lnet_rtrbuf_t, rb_list);
+ rb = list_entry(rbp->rbp_bufs.next, struct lnet_rtrbuf, rb_list);
list_del(&rb->rb_list);
msg->msg_niov = rbp->rbp_npages;
}
void
-lnet_return_tx_credits_locked(lnet_msg_t *msg)
+lnet_return_tx_credits_locked(struct lnet_msg *msg)
{
struct lnet_peer_ni *txpeer = msg->msg_txpeer;
struct lnet_ni *txni = msg->msg_txni;
- lnet_msg_t *msg2;
+ struct lnet_msg *msg2;
if (msg->msg_txcredit) {
struct lnet_ni *ni = msg->msg_txni;
atomic_inc(&ni->ni_tx_credits);
if (tq->tq_credits <= 0) {
msg2 = list_entry(tq->tq_delayed.next,
- lnet_msg_t, msg_list);
+ struct lnet_msg, msg_list);
list_del(&msg2->msg_list);
LASSERT(msg2->msg_txni == ni);
LASSERT((txpeer->lpni_txcredits < 0) ==
!list_empty(&txpeer->lpni_txq));
- txpeer->lpni_txqnob -= msg->msg_len + sizeof(lnet_hdr_t);
+ txpeer->lpni_txqnob -= msg->msg_len + sizeof(struct lnet_hdr);
LASSERT(txpeer->lpni_txqnob >= 0);
txpeer->lpni_txcredits++;
if (txpeer->lpni_txcredits <= 0) {
+ int msg2_cpt;
+
msg2 = list_entry(txpeer->lpni_txq.next,
- lnet_msg_t, msg_list);
+ struct lnet_msg, msg_list);
list_del(&msg2->msg_list);
spin_unlock(&txpeer->lpni_lock);
LASSERT(msg2->msg_txpeer == txpeer);
LASSERT(msg2->msg_tx_delayed);
- if (msg2->msg_tx_cpt != msg->msg_tx_cpt) {
+ msg2_cpt = msg2->msg_tx_cpt;
+
+ /*
+ * The msg_cpt can be different from the msg2_cpt
+ * so we need to make sure we lock the correct cpt
+ * for msg2.
+ * Once we call lnet_post_send_locked() it is no
+ * longer safe to access msg2, since it could've
+ * been freed by lnet_finalize(), but we still
+ * need to relock the correct cpt, so we cache the
+ * msg2_cpt for the purpose of the check that
+ * follows the call to lnet_pose_send_locked().
+ */
+ if (msg2_cpt != msg->msg_tx_cpt) {
lnet_net_unlock(msg->msg_tx_cpt);
- lnet_net_lock(msg2->msg_tx_cpt);
+ lnet_net_lock(msg2_cpt);
}
(void) lnet_post_send_locked(msg2, 1);
- if (msg2->msg_tx_cpt != msg->msg_tx_cpt) {
- lnet_net_unlock(msg2->msg_tx_cpt);
+ if (msg2_cpt != msg->msg_tx_cpt) {
+ lnet_net_unlock(msg2_cpt);
lnet_net_lock(msg->msg_tx_cpt);
}
} else {
}
void
-lnet_schedule_blocked_locked(lnet_rtrbufpool_t *rbp)
+lnet_schedule_blocked_locked(struct lnet_rtrbufpool *rbp)
{
- lnet_msg_t *msg;
+ struct lnet_msg *msg;
if (list_empty(&rbp->rbp_msgs))
return;
msg = list_entry(rbp->rbp_msgs.next,
- lnet_msg_t, msg_list);
+ struct lnet_msg, msg_list);
list_del(&msg->msg_list);
(void)lnet_post_routed_recv_locked(msg, 1);
void
lnet_drop_routed_msgs_locked(struct list_head *list, int cpt)
{
- lnet_msg_t *msg;
- lnet_msg_t *tmp;
+ struct lnet_msg *msg;
+ struct lnet_msg *tmp;
lnet_net_unlock(cpt);
lnet_ni_recv(msg->msg_rxni, msg->msg_private, NULL,
0, 0, 0, msg->msg_hdr.payload_length);
list_del_init(&msg->msg_list);
- lnet_finalize(NULL, msg, -ECANCELED);
+ lnet_finalize(msg, -ECANCELED);
}
lnet_net_lock(cpt);
}
void
-lnet_return_rx_credits_locked(lnet_msg_t *msg)
+lnet_return_rx_credits_locked(struct lnet_msg *msg)
{
- struct lnet_peer_ni *rxpeer = msg->msg_rxpeer;
- struct lnet_ni *rxni = msg->msg_rxni;
- lnet_msg_t *msg2;
+ struct lnet_peer_ni *rxpeer = msg->msg_rxpeer;
+ struct lnet_ni *rxni = msg->msg_rxni;
+ struct lnet_msg *msg2;
if (msg->msg_rtrcredit) {
/* give back global router credits */
- lnet_rtrbuf_t *rb;
- lnet_rtrbufpool_t *rbp;
+ struct lnet_rtrbuf *rb;
+ struct lnet_rtrbufpool *rbp;
/* NB If a msg ever blocks for a buffer in rbp_msgs, it stays
* there until it gets one allocated, or aborts the wait
* itself */
LASSERT(msg->msg_kiov != NULL);
- rb = list_entry(msg->msg_kiov, lnet_rtrbuf_t, rb_kiov[0]);
+ rb = list_entry(msg->msg_kiov, struct lnet_rtrbuf, rb_kiov[0]);
rbp = rb->rb_pool;
msg->msg_kiov = NULL;
lnet_drop_routed_msgs_locked(&drop, msg->msg_rx_cpt);
} else if (rxpeer->lpni_rtrcredits <= 0) {
msg2 = list_entry(rxpeer->lpni_rtrq.next,
- lnet_msg_t, msg_list);
+ struct lnet_msg, msg_list);
list_del(&msg2->msg_list);
spin_unlock(&rxpeer->lpni_lock);
(void) lnet_post_routed_recv_locked(msg2, 1);
}
static int
-lnet_compare_routes(lnet_route_t *r1, lnet_route_t *r2)
+lnet_compare_routes(struct lnet_route *r1, struct lnet_route *r2)
{
struct lnet_peer_ni *p1 = r1->lr_gateway;
struct lnet_peer_ni *p2 = r2->lr_gateway;
lnet_find_route_locked(struct lnet_net *net, lnet_nid_t target,
lnet_nid_t rtr_nid)
{
- lnet_remotenet_t *rnet;
- lnet_route_t *route;
- lnet_route_t *best_route;
- lnet_route_t *last_route;
+ struct lnet_remotenet *rnet;
+ struct lnet_route *route;
+ struct lnet_route *best_route;
+ struct lnet_route *last_route;
struct lnet_peer_ni *lpni_best;
struct lnet_peer_ni *lp;
int rc;
return best_ni;
}
+/*
+ * Traffic to the LNET_RESERVED_PORTAL may not trigger peer discovery,
+ * because such traffic is required to perform discovery. We therefore
+ * exclude all GET and PUT on that portal. We also exclude all ACK and
+ * REPLY traffic, but that is because the portal is not tracked in the
+ * message structure for these message types. We could restrict this
+ * further by also checking for LNET_PROTO_PING_MATCHBITS.
+ */
+static bool
+lnet_msg_discovery(struct lnet_msg *msg)
+{
+ if (msg->msg_type == LNET_MSG_PUT) {
+ if (msg->msg_hdr.msg.put.ptl_index != LNET_RESERVED_PORTAL)
+ return true;
+ } else if (msg->msg_type == LNET_MSG_GET) {
+ if (msg->msg_hdr.msg.get.ptl_index != LNET_RESERVED_PORTAL)
+ return true;
+ }
+ return false;
+}
+
static int
lnet_select_pathway(lnet_nid_t src_nid, lnet_nid_t dst_nid,
struct lnet_msg *msg, lnet_nid_t rtr_nid)
struct lnet_peer *peer;
struct lnet_peer_net *peer_net;
struct lnet_net *local_net;
- __u32 seq;
int cpt, cpt2, rc;
bool routing;
bool routing2;
*/
cpt = lnet_net_lock_current();
- md_cpt = lnet_cpt_of_md(msg->msg_md);
+ md_cpt = lnet_cpt_of_md(msg->msg_md, msg->msg_offset);
if (md_cpt == CFS_CPT_ANY)
md_cpt = cpt;
routing2 = false;
local_found = false;
- seq = lnet_get_dlc_seq_locked();
-
- if (the_lnet.ln_shutdown) {
+ /*
+ * lnet_nid2peerni_locked() is the path that will find an
+ * existing peer_ni, or create one and mark it as having been
+ * created due to network traffic.
+ */
+ lpni = lnet_nid2peerni_locked(dst_nid, LNET_NID_ANY, cpt);
+ if (IS_ERR(lpni)) {
lnet_net_unlock(cpt);
- return -ESHUTDOWN;
+ return PTR_ERR(lpni);
}
-
- peer = lnet_find_or_create_peer_locked(dst_nid, cpt);
- if (IS_ERR(peer)) {
+ /*
+ * Now that we have a peer_ni, check if we want to discover
+ * the peer. Traffic to the LNET_RESERVED_PORTAL should not
+ * trigger discovery.
+ */
+ peer = lpni->lpni_peer_net->lpn_peer;
+ if (lnet_msg_discovery(msg) && !lnet_peer_is_uptodate(peer)) {
+ rc = lnet_discover_peer_locked(lpni, cpt, false);
+ if (rc) {
+ lnet_peer_ni_decref_locked(lpni);
+ lnet_net_unlock(cpt);
+ return rc;
+ }
+ /* The peer may have changed. */
+ peer = lpni->lpni_peer_net->lpn_peer;
+ /* queue message and return */
+ msg->msg_src_nid_param = src_nid;
+ msg->msg_rtr_nid_param = rtr_nid;
+ msg->msg_sending = 0;
+ list_add_tail(&msg->msg_list, &peer->lp_dc_pendq);
+ lnet_peer_ni_decref_locked(lpni);
lnet_net_unlock(cpt);
- return PTR_ERR(peer);
+
+ CDEBUG(D_NET, "%s pending discovery\n",
+ libcfs_nid2str(peer->lp_primary_nid));
+
+ return LNET_DC_WAIT;
}
+ lnet_peer_ni_decref_locked(lpni);
/* If peer is not healthy then can not send anything to it */
if (!lnet_is_peer_healthy_locked(peer)) {
return -EHOSTUNREACH;
}
- if (!peer->lp_multi_rail && lnet_get_num_peer_nis(peer) > 1) {
- CERROR("peer %s is declared to be non MR capable, "
- "yet configured with more than one NID\n",
- libcfs_nid2str(dst_nid));
- return -EINVAL;
- }
-
/*
* STEP 1: first jab at determining best_ni
* if src_nid is explicitly specified, then best_ni is already
if (msg->msg_type == LNET_MSG_REPLY ||
msg->msg_type == LNET_MSG_ACK ||
- !peer->lp_multi_rail ||
+ !lnet_peer_is_multi_rail(peer) ||
best_ni) {
/*
* for replies we want to respond on the same peer_ni we
* if the router is not multi-rail then use the best_gw
* found to send the message to
*/
- if (!peer->lp_multi_rail)
+ if (!lnet_peer_is_multi_rail(peer))
best_lpni = best_gw;
else
best_lpni = NULL;
}
/*
- * if the peer is not MR capable, then we should always send to it
- * using the first NI in the NET we determined.
+ * We must use a consistent source address when sending to a
+ * non-MR peer. However, a non-MR peer can have multiple NIDs
+ * on multiple networks, and we may even need to talk to this
+ * peer on multiple networks -- certain types of
+ * load-balancing configuration do this.
+ *
+ * So we need to pick the NI the peer prefers for this
+ * particular network.
*/
- if (!peer->lp_multi_rail) {
+ if (!lnet_peer_is_multi_rail(peer)) {
if (!best_lpni) {
lnet_net_unlock(cpt);
CERROR("no route to %s\n",
return -EHOSTUNREACH;
}
- /* best ni could be set because src_nid was provided */
+ /* best ni is already set if src_nid was provided */
if (!best_ni) {
- best_ni = lnet_net2ni_locked(best_lpni->lpni_net->net_id, cpt);
+ /* Get the target peer_ni */
+ peer_net = lnet_peer_get_net_locked(peer,
+ LNET_NIDNET(best_lpni->lpni_nid));
+ LASSERT(peer_net != NULL);
+ list_for_each_entry(lpni, &peer_net->lpn_peer_nis,
+ lpni_peer_nis) {
+ if (lpni->lpni_pref_nnids == 0)
+ continue;
+ LASSERT(lpni->lpni_pref_nnids == 1);
+ best_ni = lnet_nid2ni_locked(
+ lpni->lpni_pref.nid, cpt);
+ break;
+ }
+ }
+ /* if best_ni is still not set just pick one */
+ if (!best_ni) {
+ best_ni = lnet_net2ni_locked(
+ best_lpni->lpni_net->net_id, cpt);
+ /* If there is no best_ni we don't have a route */
if (!best_ni) {
lnet_net_unlock(cpt);
CERROR("no path to %s from net %s\n",
- libcfs_nid2str(best_lpni->lpni_nid),
- libcfs_net2str(best_lpni->lpni_net->net_id));
+ libcfs_nid2str(best_lpni->lpni_nid),
+ libcfs_net2str(best_lpni->lpni_net->net_id));
return -EHOSTUNREACH;
}
+ lpni = list_entry(peer_net->lpn_peer_nis.next,
+ struct lnet_peer_ni,
+ lpni_peer_nis);
}
- }
-
- if (best_ni == the_lnet.ln_loni) {
- /* No send credit hassles with LOLND */
- lnet_ni_addref_locked(best_ni, cpt);
- msg->msg_hdr.dest_nid = cpu_to_le64(best_ni->ni_nid);
- if (!msg->msg_routing)
- msg->msg_hdr.src_nid = cpu_to_le64(best_ni->ni_nid);
- msg->msg_target.nid = best_ni->ni_nid;
- lnet_msg_commit(msg, cpt);
- msg->msg_txni = best_ni;
- lnet_net_unlock(cpt);
-
- return LNET_CREDIT_OK;
+ /* Set preferred NI if necessary. */
+ if (lpni->lpni_pref_nnids == 0)
+ lnet_peer_ni_set_non_mr_pref_nid(lpni, best_ni->ni_nid);
}
/*
* then the best route is chosen. If all routes are equal then
* they are used in round robin.
*/
- list_for_each_entry(peer_net, &peer->lp_peer_nets, lpn_on_peer_list) {
+ list_for_each_entry(peer_net, &peer->lp_peer_nets, lpn_peer_nets) {
if (!lnet_is_peer_net_healthy_locked(peer_net))
continue;
lpni = list_entry(peer_net->lpn_peer_nis.next,
struct lnet_peer_ni,
- lpni_on_peer_net_list);
+ lpni_peer_nis);
net_gw = lnet_find_route_locked(NULL,
lpni->lpni_nid,
*/
if (!lnet_is_peer_ni_healthy_locked(lpni))
continue;
- ni_is_pref = lnet_peer_is_ni_pref_locked(lpni, best_ni);
+ ni_is_pref = lnet_peer_is_pref_nid_locked(lpni,
+ best_ni->ni_nid);
/* if this is a preferred peer use it */
if (!preferred && ni_is_pref) {
send:
+ /* Shortcut for loopback. */
+ if (best_ni == the_lnet.ln_loni) {
+ /* No send credit hassles with LOLND */
+ lnet_ni_addref_locked(best_ni, cpt);
+ msg->msg_hdr.dest_nid = cpu_to_le64(best_ni->ni_nid);
+ if (!msg->msg_routing)
+ msg->msg_hdr.src_nid = cpu_to_le64(best_ni->ni_nid);
+ msg->msg_target.nid = best_ni->ni_nid;
+ lnet_msg_commit(msg, cpt);
+ msg->msg_txni = best_ni;
+ lnet_net_unlock(cpt);
+
+ return LNET_CREDIT_OK;
+ }
+
routing = routing || routing2;
/*
*/
cpt2 = lnet_cpt_of_nid_locked(best_lpni->lpni_nid, best_ni);
if (cpt != cpt2) {
+ __u32 seq = lnet_get_dlc_seq_locked();
lnet_net_unlock(cpt);
cpt = cpt2;
lnet_net_lock(cpt);
rc = lnet_post_send_locked(msg, 0);
+ if (!rc)
+ CDEBUG(D_NET, "TRACE: %s(%s:%s) -> %s(%s:%s) : %s\n",
+ libcfs_nid2str(msg->msg_hdr.src_nid),
+ libcfs_nid2str(msg->msg_txni->ni_nid),
+ libcfs_nid2str(src_nid),
+ libcfs_nid2str(msg->msg_hdr.dest_nid),
+ libcfs_nid2str(dst_nid),
+ libcfs_nid2str(msg->msg_txpeer->lpni_nid),
+ lnet_msgtyp2str(msg->msg_type));
+
lnet_net_unlock(cpt);
return rc;
}
int
-lnet_send(lnet_nid_t src_nid, lnet_msg_t *msg, lnet_nid_t rtr_nid)
+lnet_send(lnet_nid_t src_nid, struct lnet_msg *msg, lnet_nid_t rtr_nid)
{
lnet_nid_t dst_nid = msg->msg_target.nid;
int rc;
if (rc == LNET_CREDIT_OK)
lnet_ni_send(msg->msg_txni, msg);
- /* rc == LNET_CREDIT_OK or LNET_CREDIT_WAIT */
+ /* rc == LNET_CREDIT_OK or LNET_CREDIT_WAIT or LNET_DC_WAIT */
return 0;
}
void
-lnet_drop_message(lnet_ni_t *ni, int cpt, void *private, unsigned int nob)
+lnet_drop_message(struct lnet_ni *ni, int cpt, void *private, unsigned int nob,
+ __u32 msg_type)
{
lnet_net_lock(cpt);
+ lnet_incr_stats(&ni->ni_stats, msg_type, LNET_STATS_TYPE_DROP);
the_lnet.ln_counters[cpt]->drop_count++;
the_lnet.ln_counters[cpt]->drop_length += nob;
lnet_net_unlock(cpt);
}
static void
-lnet_recv_put(lnet_ni_t *ni, lnet_msg_t *msg)
+lnet_recv_put(struct lnet_ni *ni, struct lnet_msg *msg)
{
- lnet_hdr_t *hdr = &msg->msg_hdr;
+ struct lnet_hdr *hdr = &msg->msg_hdr;
if (msg->msg_wanted != 0)
lnet_setpayloadbuffer(msg);
}
static int
-lnet_parse_put(lnet_ni_t *ni, lnet_msg_t *msg)
+lnet_parse_put(struct lnet_ni *ni, struct lnet_msg *msg)
{
- lnet_hdr_t *hdr = &msg->msg_hdr;
+ struct lnet_hdr *hdr = &msg->msg_hdr;
struct lnet_match_info info;
int rc;
bool ready_delay;
}
static int
-lnet_parse_get(lnet_ni_t *ni, lnet_msg_t *msg, int rdma_get)
+lnet_parse_get(struct lnet_ni *ni, struct lnet_msg *msg, int rdma_get)
{
- struct lnet_match_info info;
- lnet_hdr_t *hdr = &msg->msg_hdr;
- lnet_process_id_t source_id;
+ struct lnet_match_info info;
+ struct lnet_hdr *hdr = &msg->msg_hdr;
+ struct lnet_process_id source_id;
struct lnet_handle_wire reply_wmd;
- int rc;
+ int rc;
/* Convert get fields to host byte order */
hdr->msg.get.match_bits = le64_to_cpu(hdr->msg.get.match_bits);
libcfs_nid2str(ni->ni_nid),
libcfs_id2str(info.mi_id), rc);
- lnet_finalize(ni, msg, rc);
+ lnet_finalize(msg, rc);
}
return 0;
}
static int
-lnet_parse_reply(lnet_ni_t *ni, lnet_msg_t *msg)
+lnet_parse_reply(struct lnet_ni *ni, struct lnet_msg *msg)
{
void *private = msg->msg_private;
- lnet_hdr_t *hdr = &msg->msg_hdr;
- lnet_process_id_t src = {0};
- lnet_libmd_t *md;
+ struct lnet_hdr *hdr = &msg->msg_hdr;
+ struct lnet_process_id src = {0};
+ struct lnet_libmd *md;
int rlength;
int mlength;
int cpt;
}
static int
-lnet_parse_ack(lnet_ni_t *ni, lnet_msg_t *msg)
+lnet_parse_ack(struct lnet_ni *ni, struct lnet_msg *msg)
{
- lnet_hdr_t *hdr = &msg->msg_hdr;
- lnet_process_id_t src = {0};
- lnet_libmd_t *md;
+ struct lnet_hdr *hdr = &msg->msg_hdr;
+ struct lnet_process_id src = {0};
+ struct lnet_libmd *md;
int cpt;
src.nid = hdr->src_nid;
* \retval -ve error code
*/
int
-lnet_parse_forward_locked(lnet_ni_t *ni, lnet_msg_t *msg)
+lnet_parse_forward_locked(struct lnet_ni *ni, struct lnet_msg *msg)
{
int rc = 0;
}
int
-lnet_parse_local(lnet_ni_t *ni, lnet_msg_t *msg)
+lnet_parse_local(struct lnet_ni *ni, struct lnet_msg *msg)
{
int rc;
}
void
-lnet_print_hdr(lnet_hdr_t * hdr)
+lnet_print_hdr(struct lnet_hdr *hdr)
{
- lnet_process_id_t src = {0};
- lnet_process_id_t dst = {0};
+ 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);
- src.nid = hdr->src_nid;
- src.pid = hdr->src_pid;
-
- dst.nid = hdr->dest_nid;
- dst.pid = hdr->dest_pid;
-
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));
}
int
-lnet_parse(lnet_ni_t *ni, lnet_hdr_t *hdr, lnet_nid_t from_nid,
+lnet_parse(struct lnet_ni *ni, struct lnet_hdr *hdr, lnet_nid_t from_nid,
void *private, int rdma_req)
{
int rc = 0;
for_me = (ni->ni_nid == dest_nid);
cpt = lnet_cpt_of_nid(from_nid, ni);
+ CDEBUG(D_NET, "TRACE: %s(%s) <- %s : %s - %s\n",
+ libcfs_nid2str(dest_nid),
+ libcfs_nid2str(ni->ni_nid),
+ libcfs_nid2str(src_nid),
+ lnet_msgtyp2str(type),
+ (for_me) ? "for me" : "routed");
+
switch (type) {
case LNET_MSG_ACK:
case LNET_MSG_GET:
msg->msg_hdr.dest_pid = dest_pid;
msg->msg_hdr.payload_length = payload_length;
}
- /* Multi-Rail: Primary NID of source. */
- msg->msg_initiator = lnet_peer_primary_nid(src_nid);
lnet_net_lock(cpt);
- lpni = lnet_nid2peerni_locked(from_nid, cpt);
+ lpni = lnet_nid2peerni_locked(from_nid, ni->ni_nid, cpt);
if (IS_ERR(lpni)) {
lnet_net_unlock(cpt);
CERROR("%s, src %s: Dropping %s "
msg->msg_rxpeer = lpni;
msg->msg_rxni = ni;
lnet_ni_addref_locked(ni, cpt);
+ /* Multi-Rail: Primary NID of source. */
+ msg->msg_initiator = lnet_peer_primary_nid_locked(src_nid);
if (lnet_isrouter(msg->msg_rxpeer)) {
lnet_peer_set_alive(msg->msg_rxpeer);
free_drop:
LASSERT(msg->msg_md == NULL);
- lnet_finalize(ni, msg, rc);
+ lnet_finalize(msg, rc);
drop:
- lnet_drop_message(ni, cpt, private, payload_length);
+ lnet_drop_message(ni, cpt, private, payload_length, type);
return 0;
}
EXPORT_SYMBOL(lnet_parse);
lnet_drop_delayed_msg_list(struct list_head *head, char *reason)
{
while (!list_empty(head)) {
- lnet_process_id_t id = {0};
- lnet_msg_t *msg;
+ struct lnet_process_id id = {0};
+ struct lnet_msg *msg;
- msg = list_entry(head->next, lnet_msg_t, msg_list);
+ msg = list_entry(head->next, struct lnet_msg, msg_list);
list_del(&msg->msg_list);
id.nid = msg->msg_hdr.src_nid;
* until that's done */
lnet_drop_message(msg->msg_rxni, msg->msg_rx_cpt,
- msg->msg_private, msg->msg_len);
+ msg->msg_private, msg->msg_len,
+ msg->msg_type);
/*
* NB: message will not generate event because w/o attached MD,
* but we still should give error code so lnet_msg_decommit()
* can skip counters operations and other checks.
*/
- lnet_finalize(msg->msg_rxni, msg, -ENOENT);
+ lnet_finalize(msg, -ENOENT);
}
}
lnet_recv_delayed_msg_list(struct list_head *head)
{
while (!list_empty(head)) {
- lnet_msg_t *msg;
- lnet_process_id_t id;
+ struct lnet_msg *msg;
+ struct lnet_process_id id;
- msg = list_entry(head->next, lnet_msg_t, msg_list);
+ msg = list_entry(head->next, struct lnet_msg, msg_list);
list_del(&msg->msg_list);
/* md won't disappear under me, since each msg
* \retval -ENOMEM Memory allocation failure.
* \retval -ENOENT Invalid MD object.
*
- * \see lnet_event_t::hdr_data and lnet_event_kind_t.
+ * \see struct lnet_event::hdr_data and lnet_event_kind_t.
*/
int
-LNetPut(lnet_nid_t self, lnet_handle_md_t mdh, lnet_ack_req_t ack,
- lnet_process_id_t target, unsigned int portal,
+LNetPut(lnet_nid_t self, struct lnet_handle_md mdh, enum lnet_ack_req ack,
+ struct lnet_process_id target, unsigned int portal,
__u64 match_bits, unsigned int offset,
__u64 hdr_data)
{
msg = lnet_msg_alloc();
if (msg == NULL) {
- CERROR("Dropping PUT to %s: ENOMEM on lnet_msg_t\n",
+ CERROR("Dropping PUT to %s: ENOMEM on struct lnet_msg\n",
libcfs_id2str(target));
return -ENOMEM;
}
if (rc != 0) {
CNETERR("Error sending PUT to %s: %d\n",
libcfs_id2str(target), rc);
- lnet_finalize(NULL, msg, rc);
+ lnet_finalize(msg, rc);
}
/* completion will be signalled by an event */
}
EXPORT_SYMBOL(LNetPut);
-lnet_msg_t *
-lnet_create_reply_msg (lnet_ni_t *ni, lnet_msg_t *getmsg)
+/*
+ * The LND can DMA direct to the GET md (i.e. no REPLY msg). This
+ * returns a msg for the LND to pass to lnet_finalize() when the sink
+ * data has been received.
+ *
+ * CAVEAT EMPTOR: 'getmsg' is the original GET, which is freed when
+ * lnet_finalize() is called on it, so the LND must call this first
+ */
+struct lnet_msg *
+lnet_create_reply_msg(struct lnet_ni *ni, struct lnet_msg *getmsg)
{
- /* The LND can DMA direct to the GET md (i.e. no REPLY msg). This
- * returns a msg for the LND to pass to lnet_finalize() when the sink
- * data has been received.
- *
- * CAVEAT EMPTOR: 'getmsg' is the original GET, which is freed when
- * lnet_finalize() is called on it, so the LND must call this first */
-
- struct lnet_msg *msg = lnet_msg_alloc();
- struct lnet_libmd *getmd = getmsg->msg_md;
- lnet_process_id_t peer_id = getmsg->msg_target;
- int cpt;
+ struct lnet_msg *msg = lnet_msg_alloc();
+ struct lnet_libmd *getmd = getmsg->msg_md;
+ struct lnet_process_id peer_id = getmsg->msg_target;
+ int cpt;
LASSERT(!getmsg->msg_target_is_router);
LASSERT(!getmsg->msg_routing);
libcfs_nid2str(ni->ni_nid), libcfs_id2str(peer_id), getmd);
/* setup information for lnet_build_msg_event */
- msg->msg_initiator = lnet_peer_primary_nid(peer_id.nid);
- /* Cheaper: msg->msg_initiator = getmsg->msg_txpeer->lp_nid; */
+ msg->msg_initiator = 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;
cpt = lnet_cpt_of_nid(peer_id.nid, ni);
lnet_net_lock(cpt);
+ lnet_incr_stats(&ni->ni_stats, LNET_MSG_GET, LNET_STATS_TYPE_DROP);
the_lnet.ln_counters[cpt]->drop_count++;
the_lnet.ln_counters[cpt]->drop_length += getmd->md_length;
lnet_net_unlock(cpt);
EXPORT_SYMBOL(lnet_create_reply_msg);
void
-lnet_set_reply_msg_len(lnet_ni_t *ni, lnet_msg_t *reply, unsigned int len)
+lnet_set_reply_msg_len(struct lnet_ni *ni, struct lnet_msg *reply,
+ unsigned int len)
{
/* Set the REPLY length, now the RDMA that elides the REPLY message has
* completed and I know it. */
* \retval -ENOENT Invalid MD object.
*/
int
-LNetGet(lnet_nid_t self, lnet_handle_md_t mdh,
- lnet_process_id_t target, unsigned int portal,
+LNetGet(lnet_nid_t self, struct lnet_handle_md mdh,
+ struct lnet_process_id target, unsigned int portal,
__u64 match_bits, unsigned int offset)
{
struct lnet_msg *msg;
msg = lnet_msg_alloc();
if (msg == NULL) {
- CERROR("Dropping GET to %s: ENOMEM on lnet_msg_t\n",
+ CERROR("Dropping GET to %s: ENOMEM on struct lnet_msg\n",
libcfs_id2str(target));
return -ENOMEM;
}
if (rc < 0) {
CNETERR("Error sending GET to %s: %d\n",
libcfs_id2str(target), rc);
- lnet_finalize(NULL, msg, rc);
+ lnet_finalize(msg, rc);
}
/* completion will be signalled by an event */
LNetDist(lnet_nid_t dstnid, lnet_nid_t *srcnidp, __u32 *orderp)
{
struct list_head *e;
- struct lnet_ni *ni = NULL;
- lnet_remotenet_t *rnet;
+ struct lnet_ni *ni = NULL;
+ struct lnet_remotenet *rnet;
__u32 dstnet = LNET_NIDNET(dstnid);
int hops;
int cpt;
rn_list = lnet_net2rnethash(dstnet);
list_for_each(e, rn_list) {
- rnet = list_entry(e, lnet_remotenet_t, lrn_list);
+ rnet = list_entry(e, struct lnet_remotenet, lrn_list);
if (rnet->lrn_net == dstnet) {
- lnet_route_t *route;
- lnet_route_t *shortest = NULL;
+ struct lnet_route *route;
+ struct lnet_route *shortest = NULL;
__u32 shortest_hops = LNET_UNDEFINED_HOPS;
__u32 route_hops;