- landing of b_hd_cleanup_merge to HEAD.

[fs/lustre-release.git] / lustre / portals / unals / connection.c

diff --git a/lustre/portals/unals/connection.c b/lustre/portals/unals/connection.c
index 3448460..ed8dc08 100644 (file)
--- a/lustre/portals/unals/connection.c
+++ b/lustre/portals/unals/connection.c
@@ -201,35 +201,30 @@ static int new_connection(void *z)
     return(1);
 }
 
-/* FIXME assuming little endian, cleanup!! */
-#define __cpu_to_le64(x) ((__u64)(x))
-#define __le64_to_cpu(x) ((__u64)(x))
-#define __cpu_to_le32(x) ((__u32)(x))
-#define __le32_to_cpu(x) ((__u32)(x))
-#define __cpu_to_le16(x) ((__u16)(x))
-#define __le16_to_cpu(x) ((__u16)(x))
-
 extern ptl_nid_t tcpnal_mynid;
 
 int
 tcpnal_hello (int sockfd, ptl_nid_t *nid, int type, __u64 incarnation)
 {
         int                 rc;
+        int                 nob;
         ptl_hdr_t           hdr;
         ptl_magicversion_t *hmv = (ptl_magicversion_t *)&hdr.dest_nid;
 
         LASSERT (sizeof (*hmv) == sizeof (hdr.dest_nid));
 
         memset (&hdr, 0, sizeof (hdr));
-        hmv->magic         = __cpu_to_le32 (PORTALS_PROTO_MAGIC);
-        hmv->version_major = __cpu_to_le32 (PORTALS_PROTO_VERSION_MAJOR);
-        hmv->version_minor = __cpu_to_le32 (PORTALS_PROTO_VERSION_MINOR);
+        hmv->magic         = cpu_to_le32(PORTALS_PROTO_MAGIC);
+        hmv->version_major = cpu_to_le32(PORTALS_PROTO_VERSION_MAJOR);
+        hmv->version_minor = cpu_to_le32(PORTALS_PROTO_VERSION_MINOR);
         
-        hdr.src_nid = __cpu_to_le64 (tcpnal_mynid);
-        hdr.type    = __cpu_to_le32 (PTL_MSG_HELLO);
+        hdr.src_nid = cpu_to_le64(tcpnal_mynid);
+        hdr.type    = cpu_to_le32(PTL_MSG_HELLO);
+
+        hdr.msg.hello.type = cpu_to_le32(type);
+        hdr.msg.hello.incarnation = cpu_to_le64(incarnation);
 
-        hdr.msg.hello.type = __cpu_to_le32 (type);
-        hdr.msg.hello.incarnation = __cpu_to_le64(incarnation);
+        /* I don't send any interface info */
 
         /* Assume sufficient socket buffering for this message */
         rc = syscall(SYS_write, sockfd, &hdr, sizeof(hdr));
@@ -244,28 +239,28 @@ tcpnal_hello (int sockfd, ptl_nid_t *nid, int type, __u64 incarnation)
                 return (rc);
         }
         
-        if (hmv->magic != __le32_to_cpu (PORTALS_PROTO_MAGIC)) {
+        if (hmv->magic != le32_to_cpu(PORTALS_PROTO_MAGIC)) {
                 CERROR ("Bad magic %#08x (%#08x expected) from "LPX64"\n",
-                        __cpu_to_le32 (hmv->magic), PORTALS_PROTO_MAGIC, *nid);
+                        cpu_to_le32(hmv->magic), PORTALS_PROTO_MAGIC, *nid);
                 return (-EPROTO);
         }
 
-        if (hmv->version_major != __cpu_to_le16 (PORTALS_PROTO_VERSION_MAJOR) ||
-            hmv->version_minor != __cpu_to_le16 (PORTALS_PROTO_VERSION_MINOR)) {
+        if (hmv->version_major != cpu_to_le16 (PORTALS_PROTO_VERSION_MAJOR) ||
+            hmv->version_minor != cpu_to_le16 (PORTALS_PROTO_VERSION_MINOR)) {
                 CERROR ("Incompatible protocol version %d.%d (%d.%d expected)"
                         " from "LPX64"\n",
-                        __le16_to_cpu (hmv->version_major),
-                        __le16_to_cpu (hmv->version_minor),
+                        le16_to_cpu (hmv->version_major),
+                        le16_to_cpu (hmv->version_minor),
                         PORTALS_PROTO_VERSION_MAJOR,
                         PORTALS_PROTO_VERSION_MINOR,
                         *nid);
                 return (-EPROTO);
         }
 
-#if (PORTALS_PROTO_VERSION_MAJOR != 0)
-# error "This code only understands protocol version 0.x"
+#if (PORTALS_PROTO_VERSION_MAJOR != 1)
+# error "This code only understands protocol version 1.x"
 #endif
-        /* version 0 sends magic/version as the dest_nid of a 'hello' header,
+        /* version 1 sends magic/version as the dest_nid of a 'hello' header,
          * so read the rest of it in now... */
 
         rc = syscall(SYS_read, sockfd, hmv + 1, sizeof(hdr) - sizeof(*hmv));
@@ -276,27 +271,49 @@ tcpnal_hello (int sockfd, ptl_nid_t *nid, int type, __u64 incarnation)
         }
 
         /* ...and check we got what we expected */
-        if (hdr.type != __cpu_to_le32 (PTL_MSG_HELLO) ||
-            hdr.payload_length != __cpu_to_le32 (0)) {
-                CERROR ("Expecting a HELLO hdr with 0 payload,"
+        if (hdr.type != cpu_to_le32 (PTL_MSG_HELLO)) {
+                CERROR ("Expecting a HELLO hdr "
                         " but got type %d with %d payload from "LPX64"\n",
-                        __le32_to_cpu (hdr.type),
-                        __le32_to_cpu (hdr.payload_length), *nid);
+                        le32_to_cpu (hdr.type),
+                        le32_to_cpu (hdr.payload_length), *nid);
                 return (-EPROTO);
         }
 
-        if (__le64_to_cpu(hdr.src_nid) == PTL_NID_ANY) {
+        if (le64_to_cpu(hdr.src_nid) == PTL_NID_ANY) {
                 CERROR("Expecting a HELLO hdr with a NID, but got PTL_NID_ANY\n");
                 return (-EPROTO);
         }
 
         if (*nid == PTL_NID_ANY) {              /* don't know peer's nid yet */
-                *nid = __le64_to_cpu(hdr.src_nid);
-        } else if (*nid != __le64_to_cpu (hdr.src_nid)) {
+                *nid = le64_to_cpu(hdr.src_nid);
+        } else if (*nid != le64_to_cpu (hdr.src_nid)) {
                 CERROR ("Connected to nid "LPX64", but expecting "LPX64"\n",
-                        __le64_to_cpu (hdr.src_nid), *nid);
+                        le64_to_cpu (hdr.src_nid), *nid);
+                return (-EPROTO);
+        }
+
+        /* Ignore any interface info in the payload */
+        nob = le32_to_cpu(hdr.payload_length);
+        if (nob > getpagesize()) {
+                CERROR("Unexpected HELLO payload %d from "LPX64"\n",
+                       nob, *nid);
                 return (-EPROTO);
         }
+        if (nob > 0) {
+                char *space = (char *)malloc(nob);
+                
+                if (space == NULL) {
+                        CERROR("Can't allocate scratch buffer %d\n", nob);
+                        return (-ENOMEM);
+                }
+                
+                rc = syscall(SYS_read, sockfd, space, nob);
+                if (rc <= 0) {
+                        CERROR("Error %d skipping HELLO payload from "
+                               LPX64"\n", rc, *nid);
+                        return (rc);
+                }
+        }
 
         return (0);
 }