xnu-2050.22.13.tar.gz

[apple/xnu.git] / osfmk / kern / ipc_mig.c

diff --git a/osfmk/kern/ipc_mig.c b/osfmk/kern/ipc_mig.c
index c031c089d3d3183999d7bd3fae5543c5289236a6..5120736756816c260d8a0cd024bfe06e44ae4d68 100644 (file)
--- a/osfmk/kern/ipc_mig.c
+++ b/osfmk/kern/ipc_mig.c
@@ -1,23 +1,29 @@
 /*
  * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
  *
 /*
  * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
  *

- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

  * 
  * 

- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.

  * 
  * 

- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER

  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.

  * 
  * 

- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 /*
  * @OSF_COPYRIGHT@
  */
 /*
  * @OSF_COPYRIGHT@


@@ -73,8 +79,11 @@
 #include <ipc/ipc_space.h>
 #include <ipc/ipc_port.h>
 #include <ipc/ipc_pset.h>
 #include <ipc/ipc_space.h>
 #include <ipc/ipc_port.h>
 #include <ipc/ipc_pset.h>

+#include <ipc/ipc_notify.h>

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

+#include <libkern/OSAtomic.h>
+

 /*
  *     Routine:        mach_msg_send_from_kernel
  *     Purpose:
 /*
  *     Routine:        mach_msg_send_from_kernel
  *     Purpose:


@@ -87,10 +96,18 @@
  *             Nothing locked.
  *     Returns:
  *             MACH_MSG_SUCCESS        Sent the message.
  *             Nothing locked.
  *     Returns:
  *             MACH_MSG_SUCCESS        Sent the message.

- *             MACH_MSG_SEND_NO_BUFFER Destination port had inuse fixed bufer

  *             MACH_SEND_INVALID_DEST  Bad destination port.
  *             MACH_SEND_INVALID_DEST  Bad destination port.

+ *             MACH_MSG_SEND_NO_BUFFER Destination port had inuse fixed bufer
+ *                                     or destination is above kernel limit

  */
 
  */
 

+#if IKM_SUPPORT_LEGACY
+
+#undef mach_msg_send_from_kernel
+mach_msg_return_t mach_msg_send_from_kernel(
+       mach_msg_header_t       *msg,
+       mach_msg_size_t         send_size);
+

 mach_msg_return_t
 mach_msg_send_from_kernel(
        mach_msg_header_t       *msg,
 mach_msg_return_t
 mach_msg_send_from_kernel(
        mach_msg_header_t       *msg,


@@ -99,19 +116,84 @@ mach_msg_send_from_kernel(
        ipc_kmsg_t kmsg;
        mach_msg_return_t mr;
 
        ipc_kmsg_t kmsg;
        mach_msg_return_t mr;
 

-       if (!MACH_PORT_VALID((mach_port_name_t)msg->msgh_remote_port))
-               return MACH_SEND_INVALID_DEST;
+       mr = ipc_kmsg_get_from_kernel(msg, send_size, &kmsg);
+       if (mr != MACH_MSG_SUCCESS)
+               return mr;
+
+       mr = ipc_kmsg_copyin_from_kernel_legacy(kmsg);
+       if (mr != MACH_MSG_SUCCESS) {
+               ipc_kmsg_free(kmsg);
+               return mr;
+       }               
+
+       mr = ipc_kmsg_send_always(kmsg);
+       if (mr != MACH_MSG_SUCCESS) {
+               ipc_kmsg_destroy(kmsg);
+       }
+
+       return mr;
+}
+
+#endif /* IKM_SUPPORT_LEGACY */
+
+mach_msg_return_t
+mach_msg_send_from_kernel_proper(
+       mach_msg_header_t       *msg,
+       mach_msg_size_t         send_size)
+{
+       ipc_kmsg_t kmsg;
+       mach_msg_return_t mr;

 
        mr = ipc_kmsg_get_from_kernel(msg, send_size, &kmsg);
        if (mr != MACH_MSG_SUCCESS)
                return mr;
 
 
        mr = ipc_kmsg_get_from_kernel(msg, send_size, &kmsg);
        if (mr != MACH_MSG_SUCCESS)
                return mr;
 

-       ipc_kmsg_copyin_from_kernel(kmsg);
-       ipc_kmsg_send_always(kmsg);
+       mr = ipc_kmsg_copyin_from_kernel(kmsg);
+       if (mr != MACH_MSG_SUCCESS) {
+               ipc_kmsg_free(kmsg);
+               return mr;
+       }

 
 

-       return MACH_MSG_SUCCESS;
+       mr = ipc_kmsg_send_always(kmsg);
+       if (mr != MACH_MSG_SUCCESS) {
+               ipc_kmsg_destroy(kmsg);
+       }
+
+       return mr;

 }
 
 }
 

+#if IKM_SUPPORT_LEGACY
+
+mach_msg_return_t
+mach_msg_send_from_kernel_with_options(
+       mach_msg_header_t       *msg,
+       mach_msg_size_t         send_size,
+       mach_msg_option_t       option,
+       mach_msg_timeout_t      timeout_val)
+{
+       ipc_kmsg_t kmsg;
+       mach_msg_return_t mr;
+
+       mr = ipc_kmsg_get_from_kernel(msg, send_size, &kmsg);
+       if (mr != MACH_MSG_SUCCESS)
+               return mr;
+
+       mr = ipc_kmsg_copyin_from_kernel_legacy(kmsg);
+       if (mr != MACH_MSG_SUCCESS) {
+               ipc_kmsg_free(kmsg);
+               return mr;
+       }
+               
+       mr = ipc_kmsg_send(kmsg, option, timeout_val);
+       if (mr != MACH_MSG_SUCCESS) {
+               ipc_kmsg_destroy(kmsg);
+       }
+       
+       return mr;
+}
+
+#endif /* IKM_SUPPORT_LEGACY */
+

 /*
  *     Routine:        mach_msg_rpc_from_kernel
  *     Purpose:
 /*
  *     Routine:        mach_msg_rpc_from_kernel
  *     Purpose:


@@ -127,11 +209,47 @@ mach_msg_send_from_kernel(
  *             MACH_RCV_PORT_DIED      The reply port was deallocated.
  */
 
  *             MACH_RCV_PORT_DIED      The reply port was deallocated.
  */
 

+mach_msg_return_t mach_msg_rpc_from_kernel_body(mach_msg_header_t *msg, 
+        mach_msg_size_t send_size, mach_msg_size_t rcv_size, boolean_t legacy);
+
+#if IKM_SUPPORT_LEGACY
+
+#undef mach_msg_rpc_from_kernel
+mach_msg_return_t
+mach_msg_rpc_from_kernel(
+       mach_msg_header_t       *msg,
+       mach_msg_size_t         send_size,
+       mach_msg_size_t         rcv_size);
+

 mach_msg_return_t
 mach_msg_rpc_from_kernel(
        mach_msg_header_t       *msg,
        mach_msg_size_t         send_size,
        mach_msg_size_t         rcv_size)
 mach_msg_return_t
 mach_msg_rpc_from_kernel(
        mach_msg_header_t       *msg,
        mach_msg_size_t         send_size,
        mach_msg_size_t         rcv_size)

+{
+    return mach_msg_rpc_from_kernel_body(msg, send_size, rcv_size, TRUE);
+}
+
+#endif /* IKM_SUPPORT_LEGACY */
+
+mach_msg_return_t
+mach_msg_rpc_from_kernel_proper(
+       mach_msg_header_t       *msg,
+       mach_msg_size_t         send_size,
+       mach_msg_size_t         rcv_size)
+{
+    return mach_msg_rpc_from_kernel_body(msg, send_size, rcv_size, FALSE);
+}
+
+mach_msg_return_t
+mach_msg_rpc_from_kernel_body(
+       mach_msg_header_t       *msg,
+       mach_msg_size_t         send_size,
+       mach_msg_size_t         rcv_size,
+#if !IKM_SUPPORT_LEGACY
+       __unused
+#endif
+    boolean_t           legacy)

 {
        thread_t self = current_thread();
        ipc_port_t reply;
 {
        thread_t self = current_thread();
        ipc_port_t reply;


@@ -139,7 +257,6 @@ mach_msg_rpc_from_kernel(
        mach_port_seqno_t seqno;
        mach_msg_return_t mr;
 
        mach_port_seqno_t seqno;
        mach_msg_return_t mr;
 

-       assert(MACH_PORT_VALID((mach_port_name_t)msg->msgh_remote_port));

        assert(msg->msgh_local_port == MACH_PORT_NULL);
 
        mr = ipc_kmsg_get_from_kernel(msg, send_size, &kmsg);
        assert(msg->msgh_local_port == MACH_PORT_NULL);
 
        mr = ipc_kmsg_get_from_kernel(msg, send_size, &kmsg);


@@ -160,11 +277,25 @@ mach_msg_rpc_from_kernel(
        kmsg->ikm_header->msgh_bits |=
                MACH_MSGH_BITS(0, MACH_MSG_TYPE_MAKE_SEND_ONCE);
 
        kmsg->ikm_header->msgh_bits |=
                MACH_MSGH_BITS(0, MACH_MSG_TYPE_MAKE_SEND_ONCE);
 

-       ipc_port_reference(reply);
-
-       ipc_kmsg_copyin_from_kernel(kmsg);
-
-       ipc_kmsg_send_always(kmsg);
+       ip_reference(reply);
+
+#if IKM_SUPPORT_LEGACY
+    if(legacy)
+        mr = ipc_kmsg_copyin_from_kernel_legacy(kmsg);
+    else
+        mr = ipc_kmsg_copyin_from_kernel(kmsg);
+#else
+    mr = ipc_kmsg_copyin_from_kernel(kmsg);
+#endif
+    if (mr != MACH_MSG_SUCCESS) {
+           ipc_kmsg_free(kmsg);
+           return mr;
+    }
+       mr = ipc_kmsg_send_always(kmsg);
+       if (mr != MACH_MSG_SUCCESS) {
+               ipc_kmsg_destroy(kmsg);
+               return mr;
+       }

 
        for (;;) {
                ipc_mqueue_t mqueue;
 
        for (;;) {
                ipc_mqueue_t mqueue;


@@ -172,12 +303,12 @@ mach_msg_rpc_from_kernel(
                ip_lock(reply);
                if ( !ip_active(reply)) {
                        ip_unlock(reply);
                ip_lock(reply);
                if ( !ip_active(reply)) {
                        ip_unlock(reply);

-                       ipc_port_release(reply);
+                       ip_release(reply);

                        return MACH_RCV_PORT_DIED;
                }
                if (!self->active) {
                        ip_unlock(reply);
                        return MACH_RCV_PORT_DIED;
                }
                if (!self->active) {
                        ip_unlock(reply);

-                       ipc_port_release(reply);
+                       ip_release(reply);

                        return MACH_RCV_INTERRUPTED;
                }
 
                        return MACH_RCV_INTERRUPTED;
                }
 


@@ -205,38 +336,53 @@ mach_msg_rpc_from_kernel(
                assert(mr == MACH_RCV_INTERRUPTED);
 
                if (self->handlers) {
                assert(mr == MACH_RCV_INTERRUPTED);
 
                if (self->handlers) {

-                       ipc_port_release(reply);
+                       ip_release(reply);

                        return(mr);
                }
        }
                        return(mr);
                }
        }

-       ipc_port_release(reply);
+       ip_release(reply);

 
 

-       /*
-        * XXXXX  Set manually for now ...
-        *      No, why even bother, since the effort is wasted?
-        *
-       { mach_msg_format_0_trailer_t *trailer = (mach_msg_format_0_trailer_t *)
-               ((vm_offset_t)&kmsg->ikm_header + kmsg->ikm_header.msgh_size);
-       trailer->msgh_trailer_type = MACH_MSG_TRAILER_FORMAT_0;
-       trailer->msgh_trailer_size = MACH_MSG_TRAILER_MINIMUM_SIZE;
+       /* 
+        * Check to see how much of the message/trailer can be received.
+        * We chose the maximum trailer that will fit, since we don't
+        * have options telling us which trailer elements the caller needed.
+        */
+       if (rcv_size >= kmsg->ikm_header->msgh_size) {
+               mach_msg_format_0_trailer_t *trailer =  (mach_msg_format_0_trailer_t *)
+                       ((vm_offset_t)kmsg->ikm_header + kmsg->ikm_header->msgh_size);
+
+               if (rcv_size >= kmsg->ikm_header->msgh_size + MAX_TRAILER_SIZE) {
+                       /* Enough room for a maximum trailer */
+                       trailer->msgh_trailer_size = MAX_TRAILER_SIZE;
+               } 
+               else if (rcv_size < kmsg->ikm_header->msgh_size + 
+                          trailer->msgh_trailer_size) {
+                       /* no room for even the basic (default) trailer */
+                       trailer->msgh_trailer_size = 0;
+               }
+               assert(trailer->msgh_trailer_type == MACH_MSG_TRAILER_FORMAT_0);
+               rcv_size = kmsg->ikm_header->msgh_size + trailer->msgh_trailer_size;
+               mr = MACH_MSG_SUCCESS;
+       } else {
+               mr = MACH_RCV_TOO_LARGE;

        }
        }

-        *****/

 
 

-       if (rcv_size < kmsg->ikm_header->msgh_size) {
-               ipc_kmsg_copyout_dest(kmsg, ipc_space_reply);
-               ipc_kmsg_put_to_kernel(msg, kmsg, kmsg->ikm_header->msgh_size);
-               return MACH_RCV_TOO_LARGE;
-       }

 
        /*
         *      We want to preserve rights and memory in reply!
         *      We don't have to put them anywhere; just leave them
         *      as they are.
         */
 
        /*
         *      We want to preserve rights and memory in reply!
         *      We don't have to put them anywhere; just leave them
         *      as they are.
         */

-
-       ipc_kmsg_copyout_to_kernel(kmsg, ipc_space_reply);
-       ipc_kmsg_put_to_kernel(msg, kmsg, kmsg->ikm_header->msgh_size);
-       return MACH_MSG_SUCCESS;
+#if IKM_SUPPORT_LEGACY
+    if(legacy)
+        ipc_kmsg_copyout_to_kernel_legacy(kmsg, ipc_space_reply);
+    else
+        ipc_kmsg_copyout_to_kernel(kmsg, ipc_space_reply);
+#else
+    ipc_kmsg_copyout_to_kernel(kmsg, ipc_space_reply);
+#endif
+       ipc_kmsg_put_to_kernel(msg, kmsg, rcv_size);
+       return mr;

 }
 
 
 }
 
 


@@ -273,7 +419,7 @@ mach_msg_overwrite(
        ipc_kmsg_t kmsg;
        mach_port_seqno_t seqno;
        mach_msg_return_t mr;
        ipc_kmsg_t kmsg;
        mach_port_seqno_t seqno;
        mach_msg_return_t mr;

-       mach_msg_format_0_trailer_t *trailer;
+       mach_msg_trailer_size_t trailer_size;

 
        if (option & MACH_SEND_MSG) {
                mach_msg_size_t msg_and_trailer_size;
 
        if (option & MACH_SEND_MSG) {
                mach_msg_size_t msg_and_trailer_size;


@@ -282,8 +428,10 @@ mach_msg_overwrite(
                if ((send_size < sizeof(mach_msg_header_t)) || (send_size & 3))
                        return MACH_SEND_MSG_TOO_SMALL;
 
                if ((send_size < sizeof(mach_msg_header_t)) || (send_size & 3))
                        return MACH_SEND_MSG_TOO_SMALL;
 

-               msg_and_trailer_size = send_size + MAX_TRAILER_SIZE;
+               if (send_size > MACH_MSG_SIZE_MAX - MAX_TRAILER_SIZE)
+                       return MACH_SEND_TOO_LARGE;

 
 

+               msg_and_trailer_size = send_size + MAX_TRAILER_SIZE;

                kmsg = ipc_kmsg_alloc(msg_and_trailer_size);
 
                if (kmsg == IKM_NULL)
                kmsg = ipc_kmsg_alloc(msg_and_trailer_size);
 
                if (kmsg == IKM_NULL)


@@ -305,7 +453,7 @@ mach_msg_overwrite(
                max_trailer->msgh_trailer_type = MACH_MSG_TRAILER_FORMAT_0;
                max_trailer->msgh_trailer_size = MACH_MSG_TRAILER_MINIMUM_SIZE;
        
                max_trailer->msgh_trailer_type = MACH_MSG_TRAILER_FORMAT_0;
                max_trailer->msgh_trailer_size = MACH_MSG_TRAILER_MINIMUM_SIZE;
        

-               mr = ipc_kmsg_copyin(kmsg, space, map, MACH_PORT_NULL);
+               mr = ipc_kmsg_copyin(kmsg, space, map, FALSE);

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


@@ -341,32 +489,28 @@ mach_msg_overwrite(
                        kmsg = self->ith_kmsg;
                        seqno = self->ith_seqno;
 
                        kmsg = self->ith_kmsg;
                        seqno = self->ith_seqno;
 

-                       ipc_object_release(object);
+                       io_release(object);

 
                } while (mr == MACH_RCV_INTERRUPTED);
                if (mr != MACH_MSG_SUCCESS)
                        return mr;
 
 
                } while (mr == MACH_RCV_INTERRUPTED);
                if (mr != MACH_MSG_SUCCESS)
                        return mr;
 

-               trailer = (mach_msg_format_0_trailer_t *) 
-                   ((vm_offset_t)kmsg->ikm_header + kmsg->ikm_header->msgh_size);
-               if (option & MACH_RCV_TRAILER_MASK) {
-                       trailer->msgh_seqno = seqno;
-                       trailer->msgh_trailer_size = REQUESTED_TRAILER_SIZE(option);
-               }

 
 

-               if (rcv_size < (kmsg->ikm_header->msgh_size + trailer->msgh_trailer_size)) {
+               trailer_size = ipc_kmsg_add_trailer(kmsg, space, option, current_thread(), seqno, TRUE,
+                               kmsg->ikm_header->msgh_remote_port->ip_context);
+
+               if (rcv_size < (kmsg->ikm_header->msgh_size + trailer_size)) {

                        ipc_kmsg_copyout_dest(kmsg, space);
                        (void) memcpy((void *) msg, (const void *) kmsg->ikm_header, sizeof *msg);
                        ipc_kmsg_free(kmsg);
                        return MACH_RCV_TOO_LARGE;
                }
 
                        ipc_kmsg_copyout_dest(kmsg, space);
                        (void) memcpy((void *) msg, (const void *) kmsg->ikm_header, sizeof *msg);
                        ipc_kmsg_free(kmsg);
                        return MACH_RCV_TOO_LARGE;
                }
 

-               mr = ipc_kmsg_copyout(kmsg, space, map, MACH_PORT_NULL,
-                                     MACH_MSG_BODY_NULL);
+               mr = ipc_kmsg_copyout(kmsg, space, map, MACH_MSG_BODY_NULL);

                if (mr != MACH_MSG_SUCCESS) {
                        if ((mr &~ MACH_MSG_MASK) == MACH_RCV_BODY_ERROR) {
                                ipc_kmsg_put_to_kernel(msg, kmsg,
                if (mr != MACH_MSG_SUCCESS) {
                        if ((mr &~ MACH_MSG_MASK) == MACH_RCV_BODY_ERROR) {
                                ipc_kmsg_put_to_kernel(msg, kmsg,

-                                               kmsg->ikm_header->msgh_size + trailer->msgh_trailer_size);
+                                               kmsg->ikm_header->msgh_size + trailer_size);

                        } else {
                                ipc_kmsg_copyout_dest(kmsg, space);
                                (void) memcpy((void *) msg, (const void *) kmsg->ikm_header, sizeof *msg);
                        } else {
                                ipc_kmsg_copyout_dest(kmsg, space);
                                (void) memcpy((void *) msg, (const void *) kmsg->ikm_header, sizeof *msg);


@@ -377,7 +521,7 @@ mach_msg_overwrite(
                }
 
                (void) memcpy((void *) msg, (const void *) kmsg->ikm_header,
                }
 
                (void) memcpy((void *) msg, (const void *) kmsg->ikm_header,

-                             kmsg->ikm_header->msgh_size + trailer->msgh_trailer_size);
+                             kmsg->ikm_header->msgh_size + trailer_size);

                ipc_kmsg_free(kmsg);
        }
 
                ipc_kmsg_free(kmsg);
        }
 


@@ -406,7 +550,6 @@ void
 mig_dealloc_reply_port(
        __unused mach_port_t reply_port)
 {
 mig_dealloc_reply_port(
        __unused mach_port_t reply_port)
 {

-       panic("mig_dealloc_reply_port");

 }
 
 /*
 }
 
 /*


@@ -591,8 +734,8 @@ convert_mig_object_to_port(
 
                assert(previous == IP_NULL);
 
 
                assert(previous == IP_NULL);
 

-               if (hw_compare_and_store((uint32_t)IP_NULL, (uint32_t)port,
-                                                                                       (uint32_t *)&mig_object->port)) {
+               if (OSCompareAndSwapPtr((void *)IP_NULL, (void *)port,
+                                                                                       (void * volatile *)&mig_object->port)) {

                        deallocate = FALSE;
                } else {
                        ipc_port_dealloc_kernel(port);
                        deallocate = FALSE;
                } else {
                        ipc_port_dealloc_kernel(port);