[PATCH glibc] Update sysdeps/mach/hurd/ioctl.c to make it more portable

[Flavio Cruz]

Summary of the changes:
- Update msg_align to use ALIGN_UP like we have done in previous
  patches. Use it below whenever necessary to avoid repeating the same
  alignment logic.
- Define BAD_TYPECHECK to make it easier to do type checking in a few
  places below.
- Update io2mach_type to use designated initializers.
- Make RetCodeType use mach_msg_type_t. mach_msg_type_t is 8 byte for
  x86_64, so this make it portable.
- Also call msg_align for _IOT_COUNT2/_IOT_TYPE2 since it is more
  correct.
---
 sysdeps/mach/hurd/ioctl.c | 47 ++++++++++++++++++++++-----------------
 1 file changed, 27 insertions(+), 20 deletions(-)

diff --git a/sysdeps/mach/hurd/ioctl.c b/sysdeps/mach/hurd/ioctl.c
index ab913a5943..66daaa751e 100644
--- a/sysdeps/mach/hurd/ioctl.c
+++ b/sysdeps/mach/hurd/ioctl.c
@@ -16,6 +16,7 @@
    <https://www.gnu.org/licenses/>.  */
 
 #include <errno.h>
+#include <libc-pointer-arith.h>
 #include <sys/ioctl.h>
 #include <hurd.h>
 #include <hurd/fd.h>
@@ -31,29 +32,40 @@
 
 #include <hurd/ioctls.defs>
 
+#define msg_align(x) ALIGN_UP (x, __alignof__ (uintptr_t))
 #define typesize(type) (1 << (type))
 
+/* Macro used by MIG to cleanly check the type.  */
+#define BAD_TYPECHECK(type, check) __glibc_unlikely (({        \
+  union { mach_msg_type_t t; uint32_t w; } _t, _c;     \
+  _t.t = *(type); _c.t = *(check);_t.w != _c.w; }))
 
 /* Perform the I/O control operation specified by REQUEST on FD.
    The actual type and use of ARG and the return value depend on REQUEST.  */
 int
 __ioctl (int fd, unsigned long int request, ...)
 {
-#ifdef MACH_MSG_TYPE_CHAR
+#ifdef MACH_MSG_TYPE_BIT
   /* Map individual type fields to Mach IPC types.  */
   static const int mach_types[] =
     { MACH_MSG_TYPE_CHAR, MACH_MSG_TYPE_INTEGER_16, MACH_MSG_TYPE_INTEGER_32,
       MACH_MSG_TYPE_INTEGER_64 };
-#define io2mach_type(count, type) \
-  ((mach_msg_type_t) { mach_types[type], typesize (type) * 8, count, 1, 0, 0 })
+#define io2mach_type(count, type)   \
+  ((mach_msg_type_t) {             \
+   .msgt_name = mach_types[type],   \
+   .msgt_size = typesize(type) * 8, \
+   .msgt_number = count,           \
+   .msgt_inline = TRUE,                    \
+   .msgt_longform = FALSE,         \
+   .msgt_deallocate = FALSE,       \
+   .msgt_unused = 0                \
+   })
 #endif
 
   /* Extract the type information encoded in the request.  */
   unsigned int type = _IOC_TYPE (request);
 
   /* Message buffer.  */
-#define msg_align(x) \
-  (((x) + sizeof (mach_msg_type_t) - 1) & ~(sizeof (mach_msg_type_t) - 1))
   struct
   {
 #ifdef MACH_MSG_TYPE_BIT
@@ -63,14 +75,14 @@ __ioctl (int fd, unsigned long int request, ...)
       struct
       {
        mach_msg_header_t       Head;
-       int                     RetCodeType;
+       mach_msg_type_t         RetCodeType;
        kern_return_t           RetCode;
       } header_typecheck;
     };
     char data[3 * sizeof (mach_msg_type_t)
              + msg_align (_IOT_COUNT0 (type) * typesize (_IOT_TYPE0 (type)))
              + msg_align (_IOT_COUNT1 (type) * typesize (_IOT_TYPE1 (type)))
-             + _IOT_COUNT2 (type) * typesize (_IOT_TYPE2 (type))];
+             + msg_align (_IOT_COUNT2 (type) * typesize (_IOT_TYPE2 (type)))];
 #else  /* Untyped Mach IPC format.  */
     mig_reply_error_t header;
     char data[_IOT_COUNT0 (type) * typesize (_IOT_TYPE0 (type))
@@ -128,8 +140,7 @@ __ioctl (int fd, unsigned long int request, ...)
                  void *p = &t[1];
                  *t = io2mach_type (count, type);
                  p = __mempcpy (p, argptr, len);
-                 p = (void *) (((uintptr_t) p + sizeof (*t) - 1)
-                               & ~(sizeof (*t) - 1));
+                 p = (void *) msg_align ((uintptr_t) p);
                  t = p;
 #else
                  p = __mempcpy (p, argptr, len);
@@ -150,7 +161,7 @@ __ioctl (int fd, unsigned long int request, ...)
 #ifdef MACH_MSG_TYPE_BIT
          *t++ = io2mach_type (1, _IOTS (integer_t));
          *(integer_t *) t = (integer_t) (intptr_t) arg;
-         t = (void *) t + sizeof (integer_t);
+         t = (void *) msg_align ((uintptr_t) t + sizeof (integer_t));
 #else
          *(integer_t *) p = (integer_t) (intptr_t) arg;
          p = (void *) p + sizeof (integer_t);
@@ -205,9 +216,8 @@ __ioctl (int fd, unsigned long int request, ...)
        return MIG_TYPE_ERROR;
 
 #ifdef MACH_MSG_TYPE_BIT
-      if (msg.header_typecheck.RetCodeType
-         != ((union { mach_msg_type_t t; int i; })
-           { t: io2mach_type (1, _IOTS (msg.header.RetCode)) }).i)
+      mach_msg_type_t ipctype = io2mach_type(1, _IOTS (msg.header.RetCode));
+      if (BAD_TYPECHECK (&msg.header_typecheck.RetCodeType, &ipctype))
        return MIG_TYPE_ERROR;
 #endif
       return msg.header.RetCode;
@@ -259,8 +269,7 @@ __ioctl (int fd, unsigned long int request, ...)
              /* Add the size of the type and data.  */
              reply_size += sizeof (mach_msg_type_t) + typesize (type) * count;
              /* Align it to word size.  */
-             reply_size += sizeof (mach_msg_type_t) - 1;
-             reply_size &= ~(sizeof (mach_msg_type_t) - 1);
+             reply_size = msg_align (reply_size);
 #else
              reply_size += typesize (type) * count;
 #endif
@@ -299,16 +308,14 @@ __ioctl (int fd, unsigned long int request, ...)
            {
              const size_t len = count * typesize (type);
 #ifdef MACH_MSG_TYPE_BIT
-             union { mach_msg_type_t t; int i; } ipctype;
-             ipctype.t = io2mach_type (count, type);
-             if (*(int *) t != ipctype.i)
+             const mach_msg_type_t ipctype = io2mach_type(count, type);
+             if (BAD_TYPECHECK (t, &ipctype))
                return 1;
              ++t;
              memcpy (store, t, len);
              if (update != NULL)
                *update += len;
-             t = (void *) (((uintptr_t) t + len + sizeof (*t) - 1)
-                           & ~(sizeof (*t) - 1));
+             t = (mach_msg_type_t *) msg_align ((uintptr_t) t + len);
 #else
              memcpy (store, p, len);
              p += len;
-- 
2.39.2