xnu-4903.221.2.tar.gz

[apple/xnu.git] / osfmk / ipc / mach_msg.c

diff --git a/osfmk/ipc/mach_msg.c b/osfmk/ipc/mach_msg.c
index 98282d7304f4506838bf4c791ccc550f35a26607..d17cb24c3fc82b66a2a56a4e4186f05816fbbfa4 100644 (file)
--- a/osfmk/ipc/mach_msg.c
+++ b/osfmk/ipc/mach_msg.c
@@ -91,9 +91,11 @@
 #include <kern/kalloc.h>
 #include <kern/processor.h>
 #include <kern/syscall_subr.h>
 #include <kern/kalloc.h>
 #include <kern/processor.h>
 #include <kern/syscall_subr.h>

+#include <kern/policy_internal.h>

 
 #include <vm/vm_map.h>
 
 
 #include <vm/vm_map.h>
 

+#include <ipc/port.h>

 #include <ipc/ipc_types.h>
 #include <ipc/ipc_kmsg.h>
 #include <ipc/ipc_mqueue.h>
 #include <ipc/ipc_types.h>
 #include <ipc/ipc_kmsg.h>
 #include <ipc/ipc_mqueue.h>


@@ -104,6 +106,7 @@
 #include <ipc/ipc_space.h>
 #include <ipc/ipc_entry.h>
 #include <ipc/ipc_importance.h>
 #include <ipc/ipc_space.h>
 #include <ipc/ipc_entry.h>
 #include <ipc/ipc_importance.h>

+#include <ipc/ipc_voucher.h>

 
 #include <machine/machine_routines.h>
 #include <security/mac_mach_internal.h>
 
 #include <machine/machine_routines.h>
 #include <security/mac_mach_internal.h>


@@ -137,10 +140,20 @@ mach_msg_return_t mach_msg_receive(
 
 mach_msg_return_t msg_receive_error(
        ipc_kmsg_t              kmsg,
 
 mach_msg_return_t msg_receive_error(
        ipc_kmsg_t              kmsg,

-       mach_vm_address_t       msg_addr,

        mach_msg_option_t       option,
        mach_msg_option_t       option,

+       mach_vm_address_t       rcv_addr,
+       mach_msg_size_t         rcv_size,

        mach_port_seqno_t       seqno,
        mach_port_seqno_t       seqno,

-       ipc_space_t             space);
+       ipc_space_t             space,
+       mach_msg_size_t         *out_size);
+
+static mach_msg_return_t
+mach_msg_rcv_link_special_reply_port(
+       ipc_port_t special_reply_port,
+       mach_port_name_t dest_name_port);
+
+void
+mach_msg_receive_results_complete(ipc_object_t object);

 
 security_token_t KERNEL_SECURITY_TOKEN = KERNEL_SECURITY_TOKEN_VALUE;
 audit_token_t KERNEL_AUDIT_TOKEN = KERNEL_AUDIT_TOKEN_VALUE;
 
 security_token_t KERNEL_SECURITY_TOKEN = KERNEL_SECURITY_TOKEN_VALUE;
 audit_token_t KERNEL_AUDIT_TOKEN = KERNEL_AUDIT_TOKEN_VALUE;


@@ -184,7 +197,7 @@ mach_msg_send(
        mach_msg_option_t       option,
        mach_msg_size_t         send_size,
        mach_msg_timeout_t      send_timeout,
        mach_msg_option_t       option,
        mach_msg_size_t         send_size,
        mach_msg_timeout_t      send_timeout,

-       __unused mach_port_name_t       notify)
+       mach_msg_priority_t     override)

 {
        ipc_space_t space = current_space();
        vm_map_t map = current_map();
 {
        ipc_space_t space = current_space();
        vm_map_t map = current_map();


@@ -193,19 +206,32 @@ mach_msg_send(
        mach_msg_size_t msg_and_trailer_size;
        mach_msg_max_trailer_t  *trailer;
 
        mach_msg_size_t msg_and_trailer_size;
        mach_msg_max_trailer_t  *trailer;
 

-       if ((send_size < sizeof(mach_msg_header_t)) || (send_size & 3))
+       option |= MACH_SEND_KERNEL;
+
+       if ((send_size & 3) ||
+           send_size < sizeof(mach_msg_header_t) ||
+           (send_size < sizeof(mach_msg_base_t) && (msg->msgh_bits & MACH_MSGH_BITS_COMPLEX)))

                return MACH_SEND_MSG_TOO_SMALL;
 
        if (send_size > MACH_MSG_SIZE_MAX - MAX_TRAILER_SIZE)
                return MACH_SEND_TOO_LARGE;
        
                return MACH_SEND_MSG_TOO_SMALL;
 
        if (send_size > MACH_MSG_SIZE_MAX - MAX_TRAILER_SIZE)
                return MACH_SEND_TOO_LARGE;
        

+       KDBG(MACHDBG_CODE(DBG_MACH_IPC,MACH_IPC_KMSG_INFO) | DBG_FUNC_START);
+

        msg_and_trailer_size = send_size + MAX_TRAILER_SIZE;
 
        kmsg = ipc_kmsg_alloc(msg_and_trailer_size);
 
        msg_and_trailer_size = send_size + MAX_TRAILER_SIZE;
 
        kmsg = ipc_kmsg_alloc(msg_and_trailer_size);
 

-       if (kmsg == IKM_NULL)
+       if (kmsg == IKM_NULL) {
+               KDBG(MACHDBG_CODE(DBG_MACH_IPC,MACH_IPC_KMSG_INFO) | DBG_FUNC_END, MACH_SEND_NO_BUFFER);

                return MACH_SEND_NO_BUFFER;
                return MACH_SEND_NO_BUFFER;

+       }

 
 

+       KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_IPC,MACH_IPC_KMSG_LINK) | DBG_FUNC_NONE,
+                             (uintptr_t)0, /* this should only be called from the kernel! */
+                             VM_KERNEL_ADDRPERM((uintptr_t)kmsg),
+                             0, 0,
+                             0);

        (void) memcpy((void *) kmsg->ikm_header, (const void *) msg, send_size);
 
        kmsg->ikm_header->msgh_size = send_size;
        (void) memcpy((void *) kmsg->ikm_header, (const void *) msg, send_size);
 
        kmsg->ikm_header->msgh_size = send_size;


@@ -222,10 +248,11 @@ mach_msg_send(
        trailer->msgh_trailer_type = MACH_MSG_TRAILER_FORMAT_0;
        trailer->msgh_trailer_size = MACH_MSG_TRAILER_MINIMUM_SIZE;
 
        trailer->msgh_trailer_type = MACH_MSG_TRAILER_FORMAT_0;
        trailer->msgh_trailer_size = MACH_MSG_TRAILER_MINIMUM_SIZE;
 

-       mr = ipc_kmsg_copyin(kmsg, space, map, &option);
+       mr = ipc_kmsg_copyin(kmsg, space, map, override, &option);

 
        if (mr != MACH_MSG_SUCCESS) {
                ipc_kmsg_free(kmsg);
 
        if (mr != MACH_MSG_SUCCESS) {
                ipc_kmsg_free(kmsg);

+               KDBG(MACHDBG_CODE(DBG_MACH_IPC,MACH_IPC_KMSG_INFO) | DBG_FUNC_END, mr);

                return mr;
        }
 
                return mr;
        }
 


@@ -236,6 +263,7 @@ mach_msg_send(
            (void) memcpy((void *) msg, (const void *) kmsg->ikm_header, 
                          kmsg->ikm_header->msgh_size);
            ipc_kmsg_free(kmsg);
            (void) memcpy((void *) msg, (const void *) kmsg->ikm_header, 
                          kmsg->ikm_header->msgh_size);
            ipc_kmsg_free(kmsg);

+           KDBG(MACHDBG_CODE(DBG_MACH_IPC,MACH_IPC_KMSG_INFO) | DBG_FUNC_END, mr);

        }
 
        return mr;
        }
 
        return mr;


@@ -277,7 +305,8 @@ typedef     struct
  */
 
 mach_msg_return_t
  */
 
 mach_msg_return_t

-mach_msg_receive_results(void)
+mach_msg_receive_results(
+       mach_msg_size_t *sizep)

 {
        thread_t          self = current_thread();
        ipc_space_t       space = current_space();
 {
        thread_t          self = current_thread();
        ipc_space_t       space = current_space();


@@ -285,47 +314,73 @@ mach_msg_receive_results(void)
 
        ipc_object_t      object = self->ith_object;
        mach_msg_return_t mr = self->ith_state;
 
        ipc_object_t      object = self->ith_object;
        mach_msg_return_t mr = self->ith_state;

-       mach_vm_address_t msg_addr = self->ith_msg_addr;
+       mach_vm_address_t rcv_addr = self->ith_msg_addr;
+       mach_msg_size_t   rcv_size = self->ith_rsize;

        mach_msg_option_t option = self->ith_option;
        ipc_kmsg_t        kmsg = self->ith_kmsg;
        mach_port_seqno_t seqno = self->ith_seqno;
        mach_msg_option_t option = self->ith_option;
        ipc_kmsg_t        kmsg = self->ith_kmsg;
        mach_port_seqno_t seqno = self->ith_seqno;

+

        mach_msg_trailer_size_t trailer_size;
        mach_msg_trailer_size_t trailer_size;

+       mach_msg_size_t   size = 0;

 
 

+       /*
+        * unlink the special_reply_port before releasing reference to object.
+        * get the thread's turnstile, if the thread donated it's turnstile to the port
+        */
+       mach_msg_receive_results_complete(object);

        io_release(object);
 
        if (mr != MACH_MSG_SUCCESS) {
 
        io_release(object);
 
        if (mr != MACH_MSG_SUCCESS) {
 

-         if (mr == MACH_RCV_TOO_LARGE ) {
-           if (option & MACH_RCV_LARGE) {
-             /*
-              * We need to inform the user-level code that it needs more
-              * space.  The value for how much space was returned in the
-              * msize save area instead of the message (which was left on
-              * the queue).
-              */
-             if (option & MACH_RCV_LARGE_IDENTITY) {
-                     if (copyout((char *) &self->ith_receiver_name,
-                                 msg_addr + offsetof(mach_msg_user_header_t, msgh_local_port),
-                                 sizeof(mach_port_name_t)))
-                             mr = MACH_RCV_INVALID_DATA;
-             }
-             if (copyout((char *) &self->ith_msize,
-                         msg_addr + offsetof(mach_msg_user_header_t, msgh_size),
-                         sizeof(mach_msg_size_t)))
-               mr = MACH_RCV_INVALID_DATA;
-           } else {
-
-               /* discard importance in message */
-               ipc_importance_clean(kmsg);
-
-               if (msg_receive_error(kmsg, msg_addr, option, seqno, space)
-                   == MACH_RCV_INVALID_DATA)
-                   mr = MACH_RCV_INVALID_DATA;
-           }
-         }
-         return mr;
+               if (mr == MACH_RCV_TOO_LARGE) {
+
+                       /*
+                        * If the receive operation occurs with MACH_RCV_LARGE set
+                        * then no message was extracted from the queue, and the size
+                        * and (optionally) receiver names were the only thing captured.
+                        * Just copyout the size (and optional port name) in a fake
+                        * header.
+                        */
+                       if (option & MACH_RCV_LARGE) {
+
+                               if ((option & MACH_RCV_STACK) == 0 &&
+                                   rcv_size >= offsetof(mach_msg_user_header_t, msgh_reserved)) {
+
+                                       /*
+                                        * We need to inform the user-level code that it needs more
+                                        * space.  The value for how much space was returned in the
+                                        * msize save area instead of the message (which was left on
+                                        * the queue).
+                                        */
+                                       if (option & MACH_RCV_LARGE_IDENTITY) {
+                                               if (copyout((char *) &self->ith_receiver_name,
+                                                           rcv_addr + offsetof(mach_msg_user_header_t, msgh_local_port),
+                                                           sizeof(mach_port_name_t)))
+                                                       mr = MACH_RCV_INVALID_DATA;
+                                       }
+                                       if (copyout((char *) &self->ith_msize,
+                                                   rcv_addr + offsetof(mach_msg_user_header_t, msgh_size),
+                                                   sizeof(mach_msg_size_t)))
+                                               mr = MACH_RCV_INVALID_DATA;
+                               }
+                       } else {
+
+                               /* discard importance in message */
+                               ipc_importance_clean(kmsg);
+
+                               if (msg_receive_error(kmsg, option, rcv_addr, rcv_size, seqno, space, &size)
+                                   == MACH_RCV_INVALID_DATA)
+                                       mr = MACH_RCV_INVALID_DATA;
+                       }
+               }
+
+               if (sizep)
+                       *sizep = size;
+               return mr;

        }
 
        }
 

+       /* MACH_MSG_SUCCESS */
+

 #if IMPORTANCE_INHERITANCE
 
        /* adopt/transform any importance attributes carried in the message */
 #if IMPORTANCE_INHERITANCE
 
        /* adopt/transform any importance attributes carried in the message */


@@ -333,31 +388,37 @@ mach_msg_receive_results(void)
 
 #endif  /* IMPORTANCE_INHERITANCE */
 
 
 #endif  /* IMPORTANCE_INHERITANCE */
 

+       /* auto redeem the voucher in the message */
+       ipc_voucher_receive_postprocessing(kmsg, option);
+

        trailer_size = ipc_kmsg_add_trailer(kmsg, space, option, self, seqno, FALSE, 
                        kmsg->ikm_header->msgh_remote_port->ip_context);
        trailer_size = ipc_kmsg_add_trailer(kmsg, space, option, self, seqno, FALSE, 
                        kmsg->ikm_header->msgh_remote_port->ip_context);

+       

        mr = ipc_kmsg_copyout(kmsg, space, map, MACH_MSG_BODY_NULL, option);
 
        if (mr != MACH_MSG_SUCCESS) {
        mr = ipc_kmsg_copyout(kmsg, space, map, MACH_MSG_BODY_NULL, option);
 
        if (mr != MACH_MSG_SUCCESS) {

+

                /* already received importance, so have to undo that here */
                ipc_importance_unreceive(kmsg, option);
 
                /* already received importance, so have to undo that here */
                ipc_importance_unreceive(kmsg, option);
 

+               /* if we had a body error copyout what we have, otherwise a simple header/trailer */

                if ((mr &~ MACH_MSG_MASK) == MACH_RCV_BODY_ERROR) {
                if ((mr &~ MACH_MSG_MASK) == MACH_RCV_BODY_ERROR) {

-                       if (ipc_kmsg_put(msg_addr, kmsg, kmsg->ikm_header->msgh_size +
-                          trailer_size) == MACH_RCV_INVALID_DATA)
+                       if (ipc_kmsg_put(kmsg, option, rcv_addr, rcv_size, trailer_size, &size) == MACH_RCV_INVALID_DATA)

                                mr = MACH_RCV_INVALID_DATA;
                                mr = MACH_RCV_INVALID_DATA;

-               } 
-               else {
-                       if (msg_receive_error(kmsg, msg_addr, option, seqno, space) 
+               } else {
+                       if (msg_receive_error(kmsg, option, rcv_addr, rcv_size, seqno, space, &size) 

                                                == MACH_RCV_INVALID_DATA)
                                mr = MACH_RCV_INVALID_DATA;
                }
        } else {
                                                == MACH_RCV_INVALID_DATA)
                                mr = MACH_RCV_INVALID_DATA;
                }
        } else {

-               mr = ipc_kmsg_put(msg_addr,
-                                 kmsg,
-                                 kmsg->ikm_header->msgh_size + 
-                                 trailer_size);
+               /* capture ksmg QoS values to the thread continuation state */
+               self->ith_qos = kmsg->ikm_qos;
+               self->ith_qos_override = kmsg->ikm_qos_override;
+               mr = ipc_kmsg_put(kmsg, option, rcv_addr, rcv_size, trailer_size, &size);

        }
 
        }
 

+       if (sizep)
+               *sizep = size;

        return mr;
 }
 
        return mr;
 }
 


@@ -369,7 +430,7 @@ mach_msg_receive_results(void)
  *             Unlike being dispatched to by ipc_kobject_server() or the
  *             reply part of mach_msg_rpc_from_kernel(), this routine
  *             looks up the receive port name in the kernel's port
  *             Unlike being dispatched to by ipc_kobject_server() or the
  *             reply part of mach_msg_rpc_from_kernel(), this routine
  *             looks up the receive port name in the kernel's port

- *             namespace and copies out received port rights to that namespace
+ *             namespace and copies out received port rights to that namespace

  *             as well.  Out-of-line memory is copied out the kernel's
  *             address space (rather than just providing the vm_map_copy_t).
  *     Conditions:
  *             as well.  Out-of-line memory is copied out the kernel's
  *             address space (rather than just providing the vm_map_copy_t).
  *     Conditions:


@@ -402,22 +463,29 @@ mach_msg_receive(
 
        self->ith_msg_addr = CAST_DOWN(mach_vm_address_t, msg);
        self->ith_object = object;
 
        self->ith_msg_addr = CAST_DOWN(mach_vm_address_t, msg);
        self->ith_object = object;

-       self->ith_msize = rcv_size;
+       self->ith_rsize = rcv_size;
+       self->ith_msize = 0;

        self->ith_option = option;
        self->ith_continuation = continuation;
        self->ith_option = option;
        self->ith_continuation = continuation;

+       self->ith_knote = ITH_KNOTE_NULL;

 
        ipc_mqueue_receive(mqueue, option, rcv_size, rcv_timeout, THREAD_ABORTSAFE);
        if ((option & MACH_RCV_TIMEOUT) && rcv_timeout == 0)
                thread_poll_yield(self);
 
        ipc_mqueue_receive(mqueue, option, rcv_size, rcv_timeout, THREAD_ABORTSAFE);
        if ((option & MACH_RCV_TIMEOUT) && rcv_timeout == 0)
                thread_poll_yield(self);

-       return mach_msg_receive_results();
+       return mach_msg_receive_results(NULL);

 }
 
 void
 mach_msg_receive_continue(void)
 {
 }
 
 void
 mach_msg_receive_continue(void)
 {

+       mach_msg_return_t mr;

        thread_t self = current_thread();
 
        thread_t self = current_thread();
 

-       (*self->ith_continuation)(mach_msg_receive_results());
+       if (self->ith_state == MACH_PEEK_READY)
+               mr = MACH_PEEK_READY;
+       else
+               mr = mach_msg_receive_results(NULL);
+       (*self->ith_continuation)(mr);

 }
 
 
 }
 
 


@@ -441,7 +509,7 @@ mach_msg_overwrite_trap(
        mach_msg_size_t         rcv_size = args->rcv_size;
        mach_port_name_t        rcv_name = args->rcv_name;
        mach_msg_timeout_t      msg_timeout = args->timeout;
        mach_msg_size_t         rcv_size = args->rcv_size;
        mach_port_name_t        rcv_name = args->rcv_name;
        mach_msg_timeout_t      msg_timeout = args->timeout;

-       __unused mach_port_name_t notify = args->notify;
+       mach_msg_priority_t override = args->override;

        mach_vm_address_t       rcv_msg_addr = args->rcv_msg;
        __unused mach_port_seqno_t temp_seqno = 0;
 
        mach_vm_address_t       rcv_msg_addr = args->rcv_msg;
        __unused mach_port_seqno_t temp_seqno = 0;
 


@@ -455,15 +523,26 @@ mach_msg_overwrite_trap(
                ipc_space_t space = current_space();
                ipc_kmsg_t kmsg;
 
                ipc_space_t space = current_space();
                ipc_kmsg_t kmsg;
 

+               KDBG(MACHDBG_CODE(DBG_MACH_IPC,MACH_IPC_KMSG_INFO) | DBG_FUNC_START);
+

                mr = ipc_kmsg_get(msg_addr, send_size, &kmsg);
 
                mr = ipc_kmsg_get(msg_addr, send_size, &kmsg);
 

-               if (mr != MACH_MSG_SUCCESS)
+               if (mr != MACH_MSG_SUCCESS) {
+                       KDBG(MACHDBG_CODE(DBG_MACH_IPC,MACH_IPC_KMSG_INFO) | DBG_FUNC_END, mr);

                        return mr;
                        return mr;

+               }

 
 

-               mr = ipc_kmsg_copyin(kmsg, space, map, &option);
+               KERNEL_DEBUG_CONSTANT(MACHDBG_CODE(DBG_MACH_IPC,MACH_IPC_KMSG_LINK) | DBG_FUNC_NONE,
+                                     (uintptr_t)msg_addr,
+                                     VM_KERNEL_ADDRPERM((uintptr_t)kmsg),
+                                     0, 0,
+                                     0);
+
+               mr = ipc_kmsg_copyin(kmsg, space, map, override, &option);

 
                if (mr != MACH_MSG_SUCCESS) {
                        ipc_kmsg_free(kmsg);
 
                if (mr != MACH_MSG_SUCCESS) {
                        ipc_kmsg_free(kmsg);

+                       KDBG(MACHDBG_CODE(DBG_MACH_IPC,MACH_IPC_KMSG_INFO) | DBG_FUNC_END, mr);

                        return mr;
                }
 
                        return mr;
                }
 


@@ -471,7 +550,8 @@ mach_msg_overwrite_trap(
 
                if (mr != MACH_MSG_SUCCESS) {
                        mr |= ipc_kmsg_copyout_pseudo(kmsg, space, map, MACH_MSG_BODY_NULL);
 
                if (mr != MACH_MSG_SUCCESS) {
                        mr |= ipc_kmsg_copyout_pseudo(kmsg, space, map, MACH_MSG_BODY_NULL);

-                       (void) ipc_kmsg_put(msg_addr, kmsg, kmsg->ikm_header->msgh_size);
+                       (void) ipc_kmsg_put(kmsg, option, msg_addr, send_size, 0, NULL);
+                       KDBG(MACHDBG_CODE(DBG_MACH_IPC,MACH_IPC_KMSG_INFO) | DBG_FUNC_END, mr);

                        return mr;
                }
 
                        return mr;
                }
 


@@ -485,29 +565,133 @@ mach_msg_overwrite_trap(
 
                mr = ipc_mqueue_copyin(space, rcv_name, &mqueue, &object);
                if (mr != MACH_MSG_SUCCESS) {
 
                mr = ipc_mqueue_copyin(space, rcv_name, &mqueue, &object);
                if (mr != MACH_MSG_SUCCESS) {

+                       mach_port_guard_exception(rcv_name, 0, 0, kGUARD_EXC_RCV_INVALID_NAME);

                        return mr;
                }
                /* hold ref for object */
 
                        return mr;
                }
                /* hold ref for object */
 

+               if ((option & MACH_RCV_SYNC_WAIT) && !(option & MACH_SEND_SYNC_OVERRIDE)) {
+                       ipc_port_t special_reply_port;
+                       __IGNORE_WCASTALIGN(special_reply_port = (ipc_port_t) object);
+                       /* link the special reply port to the destination */
+                       mr = mach_msg_rcv_link_special_reply_port(special_reply_port,
+                                       (mach_port_name_t)override);
+                       if (mr != MACH_MSG_SUCCESS) {
+                               io_release(object);
+                               return mr;
+                       }
+               }
+

                if (rcv_msg_addr != (mach_vm_address_t)0)
                        self->ith_msg_addr = rcv_msg_addr;
                else
                        self->ith_msg_addr = msg_addr;
                self->ith_object = object;
                if (rcv_msg_addr != (mach_vm_address_t)0)
                        self->ith_msg_addr = rcv_msg_addr;
                else
                        self->ith_msg_addr = msg_addr;
                self->ith_object = object;

-               self->ith_msize = rcv_size;
+               self->ith_rsize = rcv_size;
+               self->ith_msize = 0;

                self->ith_option = option;
                self->ith_receiver_name = MACH_PORT_NULL;
                self->ith_continuation = thread_syscall_return;
                self->ith_option = option;
                self->ith_receiver_name = MACH_PORT_NULL;
                self->ith_continuation = thread_syscall_return;

+               self->ith_knote = ITH_KNOTE_NULL;

 
                ipc_mqueue_receive(mqueue, option, rcv_size, msg_timeout, THREAD_ABORTSAFE);
                if ((option & MACH_RCV_TIMEOUT) && msg_timeout == 0)
                        thread_poll_yield(self);
 
                ipc_mqueue_receive(mqueue, option, rcv_size, msg_timeout, THREAD_ABORTSAFE);
                if ((option & MACH_RCV_TIMEOUT) && msg_timeout == 0)
                        thread_poll_yield(self);

-               return mach_msg_receive_results();
+               return mach_msg_receive_results(NULL);
+       }
+
+       return MACH_MSG_SUCCESS;
+}
+
+/*
+ *     Routine:        mach_msg_rcv_link_special_reply_port
+ *     Purpose:
+ *             Link the special reply port(rcv right) to the
+ *             other end of the sync ipc channel.
+ *     Conditions:
+ *             Nothing locked.
+ *     Returns:
+ *             None.
+ */
+static mach_msg_return_t
+mach_msg_rcv_link_special_reply_port(
+       ipc_port_t special_reply_port,
+       mach_port_name_t dest_name_port)
+{
+       ipc_port_t dest_port = IP_NULL;
+       kern_return_t kr;
+
+       if (current_thread()->ith_special_reply_port != special_reply_port) {
+               return MACH_RCV_INVALID_NOTIFY;

        }
 
        }
 

+       /* Copyin the destination port */
+       if (!MACH_PORT_VALID(dest_name_port)) {
+               return MACH_RCV_INVALID_NOTIFY;
+       }
+
+       kr = ipc_object_copyin(current_space(),
+                              dest_name_port, MACH_MSG_TYPE_COPY_SEND,
+                              (ipc_object_t *) &dest_port);
+
+       /*
+        * The receive right of dest port might have gone away,
+        * do not fail the receive in that case.
+        */
+       if (kr == KERN_SUCCESS && IP_VALID(dest_port)) {
+               ipc_port_link_special_reply_port(special_reply_port,
+                       dest_port);
+
+               /* release the send right */
+               ipc_port_release_send(dest_port);
+       }

        return MACH_MSG_SUCCESS;
 }
 
        return MACH_MSG_SUCCESS;
 }
 

+/*
+ *     Routine:        mach_msg_receive_results_complete
+ *     Purpose:
+ *             Get thread's turnstile back from the object and
+ *              if object is a special reply port then reset its
+ *             linkage.
+ *     Condition:
+ *             Nothing locked.
+ *     Returns:
+ *             None.
+ */
+void
+mach_msg_receive_results_complete(ipc_object_t object)
+{
+       thread_t self = current_thread();
+       ipc_port_t port = IPC_PORT_NULL;
+       boolean_t get_turnstile = self->turnstile ? FALSE : TRUE;
+
+       if (io_otype(object) == IOT_PORT) {
+               __IGNORE_WCASTALIGN(port = (ipc_port_t) object);
+       } else {
+               assert(self->turnstile != TURNSTILE_NULL);
+               return;
+       }
+
+       uint8_t flags = IPC_PORT_ADJUST_SR_ALLOW_SYNC_LINKAGE;
+
+       /*
+        * Don't clear the ip_srp_msg_sent bit if...
+        */
+       if (!((self->ith_state == MACH_RCV_TOO_LARGE && self->ith_option & MACH_RCV_LARGE) || //msg was too large and the next receive will get it
+               self->ith_state == MACH_RCV_INTERRUPTED ||
+               self->ith_state == MACH_RCV_TIMED_OUT ||
+               self->ith_state == MACH_RCV_PORT_CHANGED ||
+               self->ith_state == MACH_PEEK_READY)) {
+
+               flags |= IPC_PORT_ADJUST_SR_RECEIVED_MSG;
+       }
+
+       ipc_port_adjust_special_reply_port(port,
+               flags, get_turnstile);
+       /* thread now has a turnstile */
+}
+

 /*
  *     Routine:        mach_msg_trap [mach trap]
  *     Purpose:
 /*
  *     Routine:        mach_msg_trap [mach trap]
  *     Purpose:


@@ -538,6 +722,8 @@ mach_msg_trap(
  *             MACH_RCV_TOO_LARGE or MACH_RCV_BODY_ERROR error.
  *     Conditions:
  *             Nothing locked.
  *             MACH_RCV_TOO_LARGE or MACH_RCV_BODY_ERROR error.
  *     Conditions:
  *             Nothing locked.

+ *             size - maximum buffer size on input,
+ *                    actual copied-out size on output

  *     Returns:
  *             MACH_MSG_SUCCESS        minimal header/trailer copied
  *             MACH_RCV_INVALID_DATA   copyout to user buffer failed
  *     Returns:
  *             MACH_MSG_SUCCESS        minimal header/trailer copied
  *             MACH_RCV_INVALID_DATA   copyout to user buffer failed


@@ -546,10 +732,12 @@ mach_msg_trap(
 mach_msg_return_t
 msg_receive_error(
        ipc_kmsg_t              kmsg,
 mach_msg_return_t
 msg_receive_error(
        ipc_kmsg_t              kmsg,

-       mach_vm_address_t       msg_addr,

        mach_msg_option_t       option,
        mach_msg_option_t       option,

+       mach_vm_address_t       rcv_addr,
+       mach_msg_size_t         rcv_size,

        mach_port_seqno_t       seqno,
        mach_port_seqno_t       seqno,

-       ipc_space_t             space)
+       ipc_space_t             space,
+       mach_msg_size_t         *sizep)

 {
        mach_vm_address_t       context;
        mach_msg_trailer_size_t trailer_size;
 {
        mach_vm_address_t       context;
        mach_msg_trailer_size_t trailer_size;


@@ -579,10 +767,11 @@ msg_receive_error(
                        TRUE, context);
 
        /*
                        TRUE, context);
 
        /*

-        * Copy the message to user space
+        * Copy the message to user space and return the size
+        * (note that ipc_kmsg_put may also adjust the actual
+        * size copied out to user-space).

         */
         */

-       if (ipc_kmsg_put(msg_addr, kmsg, kmsg->ikm_header->msgh_size +
-                       trailer_size) == MACH_RCV_INVALID_DATA)
+       if (ipc_kmsg_put(kmsg, option, rcv_addr, rcv_size, trailer_size, sizep) == MACH_RCV_INVALID_DATA)

                return(MACH_RCV_INVALID_DATA);
        else 
                return(MACH_MSG_SUCCESS);
                return(MACH_RCV_INVALID_DATA);
        else 
                return(MACH_MSG_SUCCESS);