* Make full use of the 8 bytes available in mach_msg_type_t by moving
into the unused 4 bytes. This allows us to use 32bits for
mach_msg_type_number_t whether we use the longform or not.
* Make mach_msg_type_long_t exactly the same as mach_msg_type_t.
Updating MiG is strongly encouraged since it will generate better code
to handle this new format.
After this change, any compatibility with compiled binaries for Hurd x86_64
will break since the message format is different. However, the new
schema simplifies the overall ABI, without having "holes" and also
avoids the need to have a 16 byte mach_msg_type_long_t.
Was able to boot a basic system up to a bash shell.
---
include/mach/message.h | 52 ++++++++++++++++++++++---
ipc/ipc_kmsg.c | 4 ++
x86_64/copy_user.c | 88 ++++++++++++++++++++++++++++++++++--------
3 files changed, 123 insertions(+), 21 deletions(-)
diff --git a/include/mach/message.h b/include/mach/message.h
index 0eab9d41..2177343a 100644
--- a/include/mach/message.h
+++ b/include/mach/message.h
@@ -222,6 +222,30 @@ typedef unsigned int mach_msg_type_size_t;
typedef natural_t mach_msg_type_number_t;
typedef struct {
+#ifdef __x86_64__
+ /*
+ * For 64 bits, this struct is 8 bytes long so we
+ * can pack the same amount of information as mach_msg_type_long_t.
+ * Note that for 64 bit userland, msgt_size only needs to be 8 bits long
+ * but for kernel compatibility with 32 bit userland we allow it to be
+ * 16 bits long.
+ *
+ * Effectively, we don't need mach_msg_type_long_t but we are keeping it
+ * for a while to make the code similar between 32 and 64 bits.
+ *
+ * We also keep the msgt_longform bit around simply because it makes it
+ * very easy to convert messages from a 32 bit userland into a 64 bit
+ * kernel. Otherwise, we would have to replicate some of the MiG logic
+ * internally in the kernel.
+ */
+ unsigned int msgt_inline : 1,
+ msgt_longform : 1,
+ msgt_deallocate : 1,
+ msgt_name : 8,
+ msgt_size : 16,
+ msgt_unused : 5;
+ mach_msg_type_number_t msgt_number;
+#else
unsigned int msgt_name : 8,
msgt_size : 8,
msgt_number : 12,
@@ -229,20 +253,38 @@ typedef struct {
msgt_longform : 1,
msgt_deallocate : 1,
msgt_unused : 1;
-#ifdef __x86_64__
- /* TODO: We want to eventually use this in favor of mach_msg_type_long_t
- * as it makes the mach_msg protocol require only mach_msg_type_t. */
- mach_msg_type_number_t unused_msgtl_number;
#endif
} __attribute__ ((aligned (__alignof__ (uintptr_t)))) mach_msg_type_t;
-typedef struct {
+typedef struct {
+#ifdef __x86_64__
+ union {
+ /* On x86_64 this is equivalent to mach_msg_type_t so use
+ * union to overlay with the old field names. */
+ mach_msg_type_t msgtl_header;
+ struct {
+ unsigned int msgtl_inline : 1,
+ msgtl_longform : 1,
+ msgtl_deallocate : 1,
+ msgtl_name : 8,
+ msgtl_size : 16,
+ msgtl_unused : 5;
+ mach_msg_type_number_t msgtl_number;
+ };
+ };
+#else
mach_msg_type_t msgtl_header;
unsigned short msgtl_name;
unsigned short msgtl_size;
natural_t msgtl_number;
+#endif
} __attribute__ ((aligned (__alignof__ (uintptr_t)))) mach_msg_type_long_t;
+#ifdef __x86_64__
+_Static_assert (sizeof (mach_msg_type_t) == sizeof (mach_msg_type_long_t),
+ "mach_msg_type_t and mach_msg_type_long_t need to have the
same size.");
+#endif
+
/*
* Known values for the msgt_name field.
*
diff --git a/ipc/ipc_kmsg.c b/ipc/ipc_kmsg.c
index 1988da45..d1c4675c 100644
--- a/ipc/ipc_kmsg.c
+++ b/ipc/ipc_kmsg.c
@@ -1343,9 +1343,11 @@ ipc_kmsg_copyin_body(
is_port = MACH_MSG_TYPE_PORT_ANY(name);
if ((is_port && (size != PORT_T_SIZE_IN_BITS)) ||
+#ifndef __x86_64__
(longform && ((type->msgtl_header.msgt_name != 0) ||
(type->msgtl_header.msgt_size != 0) ||
(type->msgtl_header.msgt_number != 0))) ||
+#endif
(((mach_msg_type_t*)type)->msgt_unused != 0) ||
(dealloc && is_inline)) {
ipc_kmsg_clean_partial(kmsg, taddr, FALSE, 0);
@@ -2833,9 +2835,11 @@ ipc_msg_print(mach_msg_header_t *msgh)
is_port = MACH_MSG_TYPE_PORT_ANY(name);
if ((is_port && (size != PORT_T_SIZE_IN_BITS)) ||
+#ifndef __x86_64__
(longform && ((type->msgtl_header.msgt_name != 0) ||
(type->msgtl_header.msgt_size != 0) ||
(type->msgtl_header.msgt_number != 0))) ||
+#endif
(((mach_msg_type_t*)type)->msgt_unused != 0) ||
(dealloc && is_inline)) {
db_printf("*** invalid type\n");
diff --git a/x86_64/copy_user.c b/x86_64/copy_user.c
index 6ff50e12..548d9d7d 100644
--- a/x86_64/copy_user.c
+++ b/x86_64/copy_user.c
@@ -87,12 +87,74 @@ static inline void unpack_msg_type(vm_offset_t addr,
}
}
+#ifdef USER32
+static inline void mach_msg_user_type_to_kernel(const mach_msg_user_type_t *u,
+ mach_msg_type_t* k) {
+ k->msgt_name = u->msgt_name;
+ k->msgt_size = u->msgt_size;
+ k->msgt_number = u->msgt_number;
+ k->msgt_inline = u->msgt_inline;
+ k->msgt_longform = u->msgt_longform;
+ k->msgt_deallocate = u->msgt_deallocate;
+ k->msgt_unused = 0;
+}
+
+static inline void mach_msg_user_type_to_kernel_long(const
mach_msg_user_type_long_t *u,
+ mach_msg_type_long_t* k) {
+ const mach_msg_type_long_t kernel = {
+ .msgtl_header = {
+ .msgt_name = u->msgtl_name,
+ .msgt_size = u->msgtl_size,
+ .msgt_number = u->msgtl_number,
+ .msgt_inline = u->msgtl_header.msgt_inline,
+ .msgt_longform = u->msgtl_header.msgt_longform,
+ .msgt_deallocate = u->msgtl_header.msgt_deallocate,
+ .msgt_unused = 0
+ }
+ };
+ *k = kernel;
+}
+
+static inline void mach_msg_kernel_type_to_user(const mach_msg_type_t *k,
+ mach_msg_user_type_t *u) {
+ u->msgt_name = k->msgt_name;
+ u->msgt_size = k->msgt_size;
+ u->msgt_number = k->msgt_number;
+ u->msgt_inline = k->msgt_inline;
+ u->msgt_longform = k->msgt_longform;
+ u->msgt_deallocate = k->msgt_deallocate;
+ u->msgt_unused = 0;
+}
+
+static inline void mach_msg_kernel_type_to_user_long(const
mach_msg_type_long_t *k,
+ mach_msg_user_type_long_t *u) {
+ const mach_msg_user_type_long_t user = {
+ .msgtl_header = {
+ .msgt_name = 0,
+ .msgt_size = 0,
+ .msgt_number = 0,
+ .msgt_inline = k->msgtl_header.msgt_inline,
+ .msgt_longform = k->msgtl_header.msgt_longform,
+ .msgt_deallocate = k->msgtl_header.msgt_deallocate,
+ .msgt_unused = 0
+ },
+ .msgtl_name = k->msgtl_header.msgt_name,
+ .msgtl_size = k->msgtl_header.msgt_size,
+ .msgtl_number = k->msgtl_header.msgt_number
+ };
+ *u = user;
+}
+#endif
+
static inline int copyin_mach_msg_type(const rpc_vm_offset_t *uaddr,
mach_msg_type_t *kaddr) {
#ifdef USER32
- int ret;
- ret = copyin(uaddr, kaddr, sizeof(mach_msg_user_type_t));
- kaddr->unused_msgtl_number = 0;
- return ret;
+ mach_msg_user_type_t user;
+ int ret = copyin(uaddr, &user, sizeof(mach_msg_user_type_t));
+ if (ret) {
+ return ret;
+ }
+ mach_msg_user_type_to_kernel(&user, kaddr);
+ return 0;
#else
return copyin(uaddr, kaddr, sizeof(mach_msg_type_t));
#endif
@@ -100,7 +162,9 @@ static inline int copyin_mach_msg_type(const
rpc_vm_offset_t *uaddr, mach_msg_ty
static inline int copyout_mach_msg_type(const mach_msg_type_t *kaddr,
rpc_vm_offset_t *uaddr) {
#ifdef USER32
- return copyout(kaddr, uaddr, sizeof(mach_msg_user_type_t));
+ mach_msg_user_type_t user;
+ mach_msg_kernel_type_to_user(kaddr, &user);
+ return copyout(&user, uaddr, sizeof(mach_msg_user_type_t));
#else
return copyout(kaddr, uaddr, sizeof(mach_msg_type_t));
#endif
@@ -109,15 +173,10 @@ static inline int copyout_mach_msg_type(const
mach_msg_type_t *kaddr, rpc_vm_off
static inline int copyin_mach_msg_type_long(const rpc_vm_offset_t *uaddr,
mach_msg_type_long_t *kaddr) {
#ifdef USER32
mach_msg_user_type_long_t user;
- int ret;
- ret = copyin(uaddr, &user, sizeof(mach_msg_user_type_long_t));
+ int ret = copyin(uaddr, &user, sizeof(mach_msg_user_type_long_t));
if (ret)
return ret;
- /* The first 4 bytes are laid out in the same way. */
- memcpy(&kaddr->msgtl_header, &user.msgtl_header,
sizeof(mach_msg_user_type_t));
- kaddr->msgtl_name = user.msgtl_name;
- kaddr->msgtl_size = user.msgtl_size;
- kaddr->msgtl_number = user.msgtl_number;
+ mach_msg_user_type_to_kernel_long(&user, kaddr);
return 0;
#else
return copyin(uaddr, kaddr, sizeof(mach_msg_type_long_t));
@@ -127,10 +186,7 @@ static inline int copyin_mach_msg_type_long(const
rpc_vm_offset_t *uaddr, mach_m
static inline int copyout_mach_msg_type_long(const mach_msg_type_long_t
*kaddr, rpc_vm_offset_t *uaddr) {
#ifdef USER32
mach_msg_user_type_long_t user;
- memcpy(&user.msgtl_header, &kaddr->msgtl_header,
sizeof(mach_msg_user_type_t));
- user.msgtl_name = kaddr->msgtl_name;
- user.msgtl_size = kaddr->msgtl_size;
- user.msgtl_number = kaddr->msgtl_number;
+ mach_msg_kernel_type_to_user_long(kaddr, &user);
return copyout(&user, uaddr, sizeof(mach_msg_user_type_long_t));
#else
return copyout(kaddr, uaddr, sizeof(mach_msg_type_long_t));
--
2.39.2
