__u64 lcc_drop_length;
} __attribute__((packed));
-
#define LNET_NI_STATUS_UP 0x15aac0de
#define LNET_NI_STATUS_DOWN 0xdeadface
#define LNET_NI_STATUS_INVALID 0x00000000
struct lnet_ni_status {
lnet_nid_t ns_nid;
__u32 ns_status;
- __u32 ns_unused;
+ __u32 ns_msg_size; /* represents ping buffer size if message
+ * contains large NID addresses.
+ */
} __attribute__((packed));
-/*
- * NB: value of these features equal to LNET_PROTO_PING_VERSION_x
+/* When this appears in lnet_ping_info, it will be large
+ * enough to hold whatever nid is present, rounded up
+ * to a multiple of 4 bytes.
+ * NOTE: all users MUST check ns_nid.nid_size is usable.
+ */
+struct lnet_ni_large_status {
+ __u32 ns_status;
+ struct lnet_nid ns_nid;
+} __attribute__((packed));
+
+/* NB: value of these features equal to LNET_PROTO_PING_VERSION_x
* of old LNet, so there shouldn't be any compatibility issue
*/
#define LNET_PING_FEAT_INVAL (0) /* no feature */
#define LNET_PING_FEAT_BASE (1 << 0) /* just a ping */
#define LNET_PING_FEAT_NI_STATUS (1 << 1) /* return NI status */
-#define LNET_PING_FEAT_RTE_DISABLED (1 << 2) /* Routing enabled */
-#define LNET_PING_FEAT_MULTI_RAIL (1 << 3) /* Multi-Rail aware */
+#define LNET_PING_FEAT_RTE_DISABLED (1 << 2) /* Routing enabled */
+#define LNET_PING_FEAT_MULTI_RAIL (1 << 3) /* Multi-Rail aware */
#define LNET_PING_FEAT_DISCOVERY (1 << 4) /* Supports Discovery */
+#define LNET_PING_FEAT_LARGE_ADDR (1 << 5) /* Large addr nids present */
+#define LNET_PING_FEAT_PRIMARY_LARGE (1 << 6) /* Primary is first Large addr */
/*
* All ping feature bits fit to hit the wire.
* New feature bits can be added, just be aware that this does change the
* over-the-wire protocol.
*/
-#define LNET_PING_FEAT_BITS (LNET_PING_FEAT_BASE | \
- LNET_PING_FEAT_NI_STATUS | \
- LNET_PING_FEAT_RTE_DISABLED | \
- LNET_PING_FEAT_MULTI_RAIL | \
- LNET_PING_FEAT_DISCOVERY)
-
+#define LNET_PING_FEAT_BITS (LNET_PING_FEAT_BASE | \
+ LNET_PING_FEAT_NI_STATUS | \
+ LNET_PING_FEAT_RTE_DISABLED | \
+ LNET_PING_FEAT_MULTI_RAIL | \
+ LNET_PING_FEAT_DISCOVERY | \
+ LNET_PING_FEAT_LARGE_ADDR | \
+ LNET_PING_FEAT_PRIMARY_LARGE)
+
+/* NOTE:
+ * The first address in pi_ni *must* be the loop-back nid: LNET_NID_LO_0
+ * The second address must be the primary nid for the host unless
+ * LNET_PING_FEAT_PRIMARY_LARGE is set, then the first large address
+ * is the preferred primary. However nodes that do not recognise that
+ * flag will quietly ignore it.
+ */
struct lnet_ping_info {
__u32 pi_magic;
__u32 pi_features;
lnet_pid_t pi_pid;
- __u32 pi_nnis;
+ __u32 pi_nnis; /* number of nid4 entries */
struct lnet_ni_status pi_ni[0];
} __attribute__((packed));
offsetof(struct lnet_ping_info, pi_ni[LNET_INTERFACES_MIN])
#define LNET_PING_INFO_LONI(PINFO) ((PINFO)->pi_ni[0].ns_nid)
#define LNET_PING_INFO_SEQNO(PINFO) ((PINFO)->pi_ni[0].ns_status)
-#define lnet_ping_info_size(pinfo) \
- offsetof(struct lnet_ping_info, pi_ni[(pinfo)->pi_nnis])
+/* If LNET_PING_FEAT_LARGE_ADDR set, pi_nnis is the number of nid4 entries
+ * and pi_ni[0].ns_msg_size is the total number of bytes, including header and
+ * lnet_ni_large_status entries which follow the lnet_ni_status entries.
+ * This must be a multiple of 4.
+ */
+#define lnet_ping_info_size(pinfo) \
+ (((pinfo)->pi_features & LNET_PING_FEAT_LARGE_ADDR) \
+ ? ((pinfo)->pi_ni[0].ns_msg_size & ~3) \
+ : offsetof(struct lnet_ping_info, pi_ni[(pinfo)->pi_nnis]))
#endif
BUILD_BUG_ON((int)sizeof(((struct lnet_ni_status *)0)->ns_nid) != 8);
BUILD_BUG_ON((int)offsetof(struct lnet_ni_status, ns_status) != 8);
BUILD_BUG_ON((int)sizeof(((struct lnet_ni_status *)0)->ns_status) != 4);
- BUILD_BUG_ON((int)offsetof(struct lnet_ni_status, ns_unused) != 12);
- BUILD_BUG_ON((int)sizeof(((struct lnet_ni_status *)0)->ns_unused) != 4);
+ BUILD_BUG_ON((int)offsetof(struct lnet_ni_status, ns_msg_size) != 12);
+ BUILD_BUG_ON((int)sizeof(((struct lnet_ni_status *)0)->ns_msg_size) != 4);
+
+ /* Checks for struct lnet_ni_large_status */
+ BUILD_BUG_ON((int)sizeof(struct lnet_ni_large_status) != 24);
+ BUILD_BUG_ON((int)offsetof(struct lnet_ni_large_status, ns_status) != 0);
+ BUILD_BUG_ON((int)sizeof(((struct lnet_ni_large_status *)0)->ns_status) != 4);
+ BUILD_BUG_ON((int)offsetof(struct lnet_ni_large_status, ns_nid) != 4);
+ BUILD_BUG_ON((int)sizeof(((struct lnet_ni_large_status *)0)->ns_nid) != 20);
/* Checks for struct lnet_ping_info and related constants */
BUILD_BUG_ON(LNET_PROTO_PING_MAGIC != 0x70696E67);
BUILD_BUG_ON(LNET_PING_FEAT_RTE_DISABLED != 4);
BUILD_BUG_ON(LNET_PING_FEAT_MULTI_RAIL != 8);
BUILD_BUG_ON(LNET_PING_FEAT_DISCOVERY != 16);
- BUILD_BUG_ON(LNET_PING_FEAT_BITS != 31);
+ BUILD_BUG_ON(LNET_PING_FEAT_LARGE_ADDR != 32);
+ BUILD_BUG_ON(LNET_PING_FEAT_PRIMARY_LARGE != 64);
+ BUILD_BUG_ON(LNET_PING_FEAT_BITS != 127);
/* Checks for struct lnet_ping_info */
BUILD_BUG_ON((int)sizeof(struct lnet_ping_info) != 16);
int bytes = 0;
list_for_each_entry(ni, &net->net_ni_list, ni_netlist)
- if (nid_is_nid4(&ni->ni_nid))
- bytes += sizeof(struct lnet_ni_status);
-
- return bytes;
-}
-
-static inline int
-lnet_get_net_ni_bytes_pre(struct lnet_net *net)
-{
- struct lnet_ni *ni;
- int bytes = 0;
-
- list_for_each_entry(ni, &net->net_ni_added, ni_netlist)
- if (nid_is_nid4(&ni->ni_nid))
- bytes += sizeof(struct lnet_ni_status);
+ bytes += lnet_ping_sts_size(&ni->ni_nid);
return bytes;
}
list_for_each_entry(net, &the_lnet.ln_nets, net_list) {
list_for_each_entry(ni, &net->net_ni_list, ni_netlist)
- if (nid_is_nid4(&ni->ni_nid))
- bytes += sizeof(struct lnet_ni_status);
+ bytes += lnet_ping_sts_size(&ni->ni_nid);
}
lnet_net_unlock(0);
void
lnet_swap_pinginfo(struct lnet_ping_buffer *pbuf)
{
+ struct lnet_ni_large_status *lstat, *lend;
struct lnet_ni_status *stat, *end;
int nnis;
int i;
for (i = 0; i < nnis && stat + 1 <= end; i++, stat++) {
__swab64s(&stat->ns_nid);
__swab32s(&stat->ns_status);
+ if (i == 0)
+ /* Might be total size */
+ __swab32s(&stat->ns_msg_size);
+ }
+ if (!(pbuf->pb_info.pi_features & LNET_PING_FEAT_LARGE_ADDR))
+ return;
+
+ lstat = (struct lnet_ni_large_status *)stat;
+ lend = (void *)end;
+ while (lstat + 1 <= lend) {
+ __swab32s(&lstat->ns_status);
+ /* struct lnet_nid never needs to be swabed */
+ lstat = lnet_ping_sts_next(lstat);
}
}
struct lnet_ni *ni;
struct lnet_net *net;
struct lnet_ni_status *ns, *end;
+ struct lnet_ni_large_status *lns, *lend;
int rc;
pbuf->pb_info.pi_nnis = 0;
end = (void *)&pbuf->pb_info + pbuf->pb_nbytes;
list_for_each_entry(net, &the_lnet.ln_nets, net_list) {
list_for_each_entry(ni, &net->net_ni_list, ni_netlist) {
- if (!nid_is_nid4(&ni->ni_nid))
+ if (!nid_is_nid4(&ni->ni_nid)) {
+ if (ns == &pbuf->pb_info.pi_ni[1]) {
+ /* This is primary, and it is long */
+ pbuf->pb_info.pi_features |=
+ LNET_PING_FEAT_PRIMARY_LARGE;
+ }
continue;
+ }
LASSERT(ns + 1 <= end);
ns->ns_nid = lnet_nid_to_nid4(&ni->ni_nid);
}
}
+ lns = (void *)ns;
+ lend = (void *)end;
+ list_for_each_entry(net, &the_lnet.ln_nets, net_list) {
+ list_for_each_entry(ni, &net->net_ni_list, ni_netlist) {
+ if (nid_is_nid4(&ni->ni_nid))
+ continue;
+ LASSERT(lns + 1 <= lend);
+
+ lns->ns_nid = ni->ni_nid;
+
+ lnet_ni_lock(ni);
+ ns->ns_status = lnet_ni_get_status_locked(ni);
+ ni->ni_status = &lns->ns_status;
+ lnet_ni_unlock(ni);
+
+ lns = lnet_ping_sts_next(lns);
+ }
+ }
+ if ((void *)lns > (void *)ns) {
+ /* Record total info size */
+ pbuf->pb_info.pi_ni[0].ns_msg_size =
+ (void *)lns - (void *)&pbuf->pb_info;
+ pbuf->pb_info.pi_features |= LNET_PING_FEAT_LARGE_ADDR;
+ }
+
/* We (ab)use the ns_status of the loopback interface to
* transmit the sequence number. The first interface listed
* must be the loopback interface.
struct lnet_ping_buffer *pbuf;
struct lnet_remotenet *rnet;
struct lnet_ni *ni;
- int net_ni_bytes;
- __u32 net_id;
+ u32 net_id;
int rc;
lnet_net_lock(LNET_LOCK_EX);
return -EUSERS;
}
- /*
- * make sure you calculate the correct number of slots in the ping
- * buffer. Since the ping info is a flattened list of all the NIs,
- * we should allocate enough slots to accomodate the number of NIs
- * which will be added.
- *
- * since ni hasn't been configured yet, use
- * lnet_get_net_ni_bytes_pre() which checks the net_ni_added list
- */
- net_ni_bytes = lnet_get_net_ni_bytes_pre(net);
-
- rc = lnet_ping_target_setup(&pbuf, &ping_mdh,
- LNET_PING_INFO_HDR_SIZE +
- net_ni_bytes + lnet_get_ni_bytes(),
- false);
- if (rc < 0) {
- lnet_net_free(net);
- return rc;
- }
-
if (tun)
memcpy(&net->net_tunables,
&tun->lt_cmn, sizeof(net->net_tunables));
rc = lnet_startup_lndnet(net,
(tun) ? &tun->lt_tun : NULL);
if (rc < 0)
- goto failed;
+ return rc;
+
+ /* make sure you calculate the correct number of slots in the ping
+ * buffer. Since the ping info is a flattened list of all the NIs,
+ * we should allocate enough slots to accomodate the number of NIs
+ * which will be added.
+ */
+ rc = lnet_ping_target_setup(&pbuf, &ping_mdh,
+ LNET_PING_INFO_HDR_SIZE +
+ lnet_get_ni_bytes(),
+ false);
+ if (rc < 0) {
+ lnet_shutdown_lndnet(net);
+ return rc;
+ }
lnet_net_lock(LNET_LOCK_EX);
net = lnet_get_net_locked(net_id);
rc = lnet_ping_target_setup(&pbuf, &ping_mdh,
(LNET_PING_INFO_HDR_SIZE +
lnet_get_ni_bytes() -
- sizeof(pbuf->pb_info.pi_ni[0])),
+ lnet_ping_sts_size(&ni->ni_nid)),
false);
if (rc != 0)
goto unlock_api_mutex;
goto fail_ping_buffer_decref;
}
- /* Test if smaller than lnet_pinginfo with no pi_ni status info */
- if (nob < LNET_PING_INFO_HDR_SIZE) {
+ /* Test if smaller than lnet_pinginfo with just one pi_ni status info.
+ * That one might contain size when large nids are used.
+ */
+ if (nob < LNET_PING_INFO_SIZE(1)) {
CERROR("%s: Short reply %d(%lu min)\n",
- libcfs_idstr(&id), nob, LNET_PING_INFO_HDR_SIZE);
+ libcfs_idstr(&id), nob, LNET_PING_INFO_SIZE(1));
goto fail_ping_buffer_decref;
}
git://git.whamcloud.com / fs / lustre-release.git / commitdiff