]> git.saurik.com Git - apple/xnu.git/blobdiff - osfmk/ipc/ipc_port.c
xnu-3789.70.16.tar.gz
[apple/xnu.git] / osfmk / ipc / ipc_port.c
index 0ece0705ce6bd1dad68cd14a22a2c60eb0fe0113..b2f6d8641085d2ff2ac034a72b106c4a50466b0a 100644 (file)
  *     Functions to manipulate IPC ports.
  */
 
  *     Functions to manipulate IPC ports.
  */
 
-#include <norma_vm.h>
-#include <mach_kdb.h>
 #include <zone_debug.h>
 #include <mach_assert.h>
 
 #include <mach/port.h>
 #include <mach/kern_return.h>
 #include <zone_debug.h>
 #include <mach_assert.h>
 
 #include <mach/port.h>
 #include <mach/kern_return.h>
-#include <kern/lock.h>
 #include <kern/ipc_kobject.h>
 #include <kern/thread.h>
 #include <kern/misc_protos.h>
 #include <kern/ipc_kobject.h>
 #include <kern/thread.h>
 #include <kern/misc_protos.h>
-#include <kern/wait_queue.h>
+#include <kern/waitq.h>
+#include <kern/policy_internal.h>
+#include <kern/debug.h>
+#include <kern/kcdata.h>
 #include <ipc/ipc_entry.h>
 #include <ipc/ipc_space.h>
 #include <ipc/ipc_object.h>
 #include <ipc/ipc_entry.h>
 #include <ipc/ipc_space.h>
 #include <ipc/ipc_object.h>
 #include <ipc/ipc_kmsg.h>
 #include <ipc/ipc_mqueue.h>
 #include <ipc/ipc_notify.h>
 #include <ipc/ipc_kmsg.h>
 #include <ipc/ipc_mqueue.h>
 #include <ipc/ipc_notify.h>
-#include <ipc/ipc_print.h>
 #include <ipc/ipc_table.h>
 #include <ipc/ipc_table.h>
+#include <ipc/ipc_importance.h>
 
 #include <security/mac_mach_internal.h>
 
 
 #include <security/mac_mach_internal.h>
 
-#if    MACH_KDB
-#include <machine/db_machdep.h>
-#include <ddb/db_command.h>
-#include <ddb/db_expr.h>
-#endif /* MACH_KDB */
-
 #include <string.h>
 
 #include <string.h>
 
-decl_lck_mtx_data(,    ipc_port_multiple_lock_data)
-decl_lck_mtx_data(,    ipc_port_timestamp_lock_data)
-lck_mtx_ext_t  ipc_port_multiple_lock_data_ext;
-lck_mtx_ext_t  ipc_port_timestamp_lock_data_ext;
+decl_lck_spin_data(,   ipc_port_multiple_lock_data)
 ipc_port_timestamp_t   ipc_port_timestamp_data;
 int ipc_portbt;
 
 #if    MACH_ASSERT
 void   ipc_port_init_debug(
 ipc_port_timestamp_t   ipc_port_timestamp_data;
 int ipc_portbt;
 
 #if    MACH_ASSERT
 void   ipc_port_init_debug(
-               ipc_port_t      port);
+               ipc_port_t      port,
+               uintptr_t       *callstack,
+               unsigned int    callstack_max);
+
+void   ipc_port_callstack_init_debug(
+               uintptr_t       *callstack,
+               unsigned int    callstack_max);
+       
 #endif /* MACH_ASSERT */
 
 #endif /* MACH_ASSERT */
 
-#if    MACH_KDB && ZONE_DEBUG
-/* Forwards */
-void   print_type_ports(unsigned, unsigned);
-void   print_ports(void);
-#endif /* MACH_KDB && ZONE_DEBUG */
+void kdp_mqueue_send_find_owner(struct waitq * waitq, event64_t event, thread_waitinfo_t *waitinfo);
+void kdp_mqueue_recv_find_owner(struct waitq * waitq, event64_t event, thread_waitinfo_t *waitinfo);
+
+void
+ipc_port_release(ipc_port_t port)
+{
+       ip_release(port);
+}
+
+void
+ipc_port_reference(ipc_port_t port)
+{
+       ip_reference(port);
+}
 
 /*
  *     Routine:        ipc_port_timestamp
 
 /*
  *     Routine:        ipc_port_timestamp
@@ -129,13 +136,7 @@ void       print_ports(void);
 ipc_port_timestamp_t
 ipc_port_timestamp(void)
 {
 ipc_port_timestamp_t
 ipc_port_timestamp(void)
 {
-       ipc_port_timestamp_t timestamp;
-
-       ipc_port_timestamp_lock();
-       timestamp = ipc_port_timestamp_data++;
-       ipc_port_timestamp_unlock();
-
-       return timestamp;
+       return OSIncrementAtomic(&ipc_port_timestamp_data);
 }
 
 /*
 }
 
 /*
@@ -151,6 +152,17 @@ ipc_port_timestamp(void)
  *             KERN_NO_SPACE           No index allocated.
  */
 
  *             KERN_NO_SPACE           No index allocated.
  */
 
+#if IMPORTANCE_INHERITANCE
+kern_return_t
+ipc_port_request_alloc(
+       ipc_port_t                      port,
+       mach_port_name_t                name,
+       ipc_port_t                      soright,
+       boolean_t                       send_possible,
+       boolean_t                       immediate,
+       ipc_port_request_index_t        *indexp,
+       boolean_t                       *importantp)
+#else
 kern_return_t
 ipc_port_request_alloc(
        ipc_port_t                      port,
 kern_return_t
 ipc_port_request_alloc(
        ipc_port_t                      port,
@@ -159,11 +171,16 @@ ipc_port_request_alloc(
        boolean_t                       send_possible,
        boolean_t                       immediate,
        ipc_port_request_index_t        *indexp)
        boolean_t                       send_possible,
        boolean_t                       immediate,
        ipc_port_request_index_t        *indexp)
+#endif /* IMPORTANCE_INHERITANCE */
 {
        ipc_port_request_t ipr, table;
        ipc_port_request_index_t index;
        uintptr_t mask = 0;
 
 {
        ipc_port_request_t ipr, table;
        ipc_port_request_index_t index;
        uintptr_t mask = 0;
 
+#if IMPORTANCE_INHERITANCE
+       *importantp = FALSE;
+#endif /* IMPORTANCE_INHERITANCE */
+
        assert(ip_active(port));
        assert(name != MACH_PORT_NULL);
        assert(soright != IP_NULL);
        assert(ip_active(port));
        assert(name != MACH_PORT_NULL);
        assert(soright != IP_NULL);
@@ -187,7 +204,17 @@ ipc_port_request_alloc(
                mask |= IPR_SOR_SPREQ_MASK;
                if (immediate) {
                        mask |= IPR_SOR_SPARM_MASK;
                mask |= IPR_SOR_SPREQ_MASK;
                if (immediate) {
                        mask |= IPR_SOR_SPARM_MASK;
-                       port->ip_sprequests = TRUE;
+                       if (port->ip_sprequests == 0) {
+                               port->ip_sprequests = 1;
+#if IMPORTANCE_INHERITANCE
+                               /* TODO: Live importance support in send-possible */
+                               if (port->ip_impdonation != 0 &&
+                                   port->ip_spimportant == 0 &&
+                                   (task_is_importance_donor(current_task()))) {
+                                       *importantp = TRUE;
+                               }
+#endif /* IMPORTANCE_INHERTANCE */
+                       }
                }
        }
        ipr->ipr_soright = IPR_SOR_MAKE(soright, mask);
                }
        }
        ipr->ipr_soright = IPR_SOR_MAKE(soright, mask);
@@ -249,12 +276,11 @@ ipc_port_request_grow(
 
        if ((its->its_size == 0) ||
            ((ntable = it_requests_alloc(its)) == IPR_NULL)) {
 
        if ((its->its_size == 0) ||
            ((ntable = it_requests_alloc(its)) == IPR_NULL)) {
-               ipc_port_release(port);
+               ip_release(port);
                return KERN_RESOURCE_SHORTAGE;
        }
 
        ip_lock(port);
                return KERN_RESOURCE_SHORTAGE;
        }
 
        ip_lock(port);
-       ip_release(port);
 
        /*
         *      Check that port is still active and that nobody else
 
        /*
         *      Check that port is still active and that nobody else
@@ -302,12 +328,14 @@ ipc_port_request_grow(
                ntable->ipr_size = its;
                port->ip_requests = ntable;
                ip_unlock(port);
                ntable->ipr_size = its;
                port->ip_requests = ntable;
                ip_unlock(port);
+               ip_release(port);
 
                if (otable != IPR_NULL) {
                        it_requests_free(oits, otable);
                }
        } else {
 
                if (otable != IPR_NULL) {
                        it_requests_free(oits, otable);
                }
        } else {
-               ip_check_unlock(port);
+               ip_unlock(port);
+               ip_release(port);
                it_requests_free(its, ntable);
        }
 
                it_requests_free(its, ntable);
        }
 
@@ -320,13 +348,18 @@ ipc_port_request_grow(
  *             Arm delayed send-possible request.
  *     Conditions:
  *             The port must be locked and active.
  *             Arm delayed send-possible request.
  *     Conditions:
  *             The port must be locked and active.
+ *
+ *             Returns TRUE if the request was armed
+ *             (or armed with importance in that version).
  */
 
  */
 
-void
+boolean_t
 ipc_port_request_sparm(
        ipc_port_t                      port,
        __assert_only mach_port_name_t  name,
 ipc_port_request_sparm(
        ipc_port_t                      port,
        __assert_only mach_port_name_t  name,
-       ipc_port_request_index_t        index)
+       ipc_port_request_index_t        index,
+       mach_msg_option_t       option,
+       mach_msg_priority_t override)
 {
        if (index != IE_REQ_NONE) {
                ipc_port_request_t ipr, table;
 {
        if (index != IE_REQ_NONE) {
                ipc_port_request_t ipr, table;
@@ -339,11 +372,30 @@ ipc_port_request_sparm(
                ipr = &table[index];
                assert(ipr->ipr_name == name);
 
                ipr = &table[index];
                assert(ipr->ipr_name == name);
 
+               /* Is there a valid destination? */
                if (IPR_SOR_SPREQ(ipr->ipr_soright)) {
                        ipr->ipr_soright = IPR_SOR_MAKE(ipr->ipr_soright, IPR_SOR_SPARM_MASK);
                if (IPR_SOR_SPREQ(ipr->ipr_soright)) {
                        ipr->ipr_soright = IPR_SOR_MAKE(ipr->ipr_soright, IPR_SOR_SPARM_MASK);
-                       port->ip_sprequests = TRUE;
-               }
+                       port->ip_sprequests = 1;
+
+                       if (option & MACH_SEND_OVERRIDE) {
+                               /* apply override to message queue */
+                               ipc_mqueue_override_send(&port->ip_messages, override);
+                       }
+
+#if IMPORTANCE_INHERITANCE
+                       if (((option & MACH_SEND_NOIMPORTANCE) == 0) &&
+                           (port->ip_impdonation != 0) &&
+                           (port->ip_spimportant == 0) &&
+                           (((option & MACH_SEND_IMPORTANCE) != 0) ||
+                            (task_is_importance_donor(current_task())))) {
+                               return TRUE;
+                       }
+#else
+                       return TRUE;
+#endif /* IMPORTANCE_INHERITANCE */
+               } 
        }
        }
+       return FALSE;
 }
 
 /*
 }
 
 /*
@@ -378,8 +430,6 @@ ipc_port_request_type(
 
                        if (!IPR_SOR_SPARMED(ipr->ipr_soright)) {
                                type |= MACH_PORT_TYPE_SPREQUEST_DELAYED;
 
                        if (!IPR_SOR_SPARMED(ipr->ipr_soright)) {
                                type |= MACH_PORT_TYPE_SPREQUEST_DELAYED;
-                       } else {
-                               assert(port->ip_sprequests == TRUE);
                        }
                }
        }
                        }
                }
        }
@@ -494,38 +544,61 @@ ipc_port_nsrequest(
 /*
  *     Routine:        ipc_port_clear_receiver
  *     Purpose:
 /*
  *     Routine:        ipc_port_clear_receiver
  *     Purpose:
- *             Prepares a receive right for transmission/destruction.
+ *             Prepares a receive right for transmission/destruction,
+ *             optionally performs mqueue destruction (with port lock held)
+ *
  *     Conditions:
  *             The port is locked and active.
  *     Conditions:
  *             The port is locked and active.
+ *     Returns:
+ *             If should_destroy is TRUE, then the return value indicates
+ *             whether the caller needs to reap kmsg structures that should
+ *             be destroyed (by calling ipc_kmsg_reap_delayed)
+ *
+ *             If should_destroy is FALSE, this always returns FALSE
  */
 
  */
 
-void
+boolean_t
 ipc_port_clear_receiver(
 ipc_port_clear_receiver(
-       ipc_port_t      port)
+       ipc_port_t      port,
+       boolean_t       should_destroy)
 {
 {
-       spl_t           s;
-
-       assert(ip_active(port));
+       ipc_mqueue_t    mqueue = &port->ip_messages;
+       boolean_t       reap_messages = FALSE;
 
        /*
 
        /*
-        * pull ourselves from any sets.
+        * Pull ourselves out of any sets to which we belong.
+        * We hold the port locked, so even though this acquires and releases
+        * the mqueue lock, we know we won't be added to any other sets.
         */
         */
-       if (port->ip_pset_count != 0) {
+       if (port->ip_in_pset != 0) {
                ipc_pset_remove_from_all(port);
                ipc_pset_remove_from_all(port);
-               assert(port->ip_pset_count == 0);
+               assert(port->ip_in_pset == 0);
        }
 
        /*
         * Send anyone waiting on the port's queue directly away.
         * Also clear the mscount and seqno.
         */
        }
 
        /*
         * Send anyone waiting on the port's queue directly away.
         * Also clear the mscount and seqno.
         */
-       s = splsched();
-       imq_lock(&port->ip_messages);
-       ipc_mqueue_changed(&port->ip_messages);
-       ipc_port_set_mscount(port, 0);
-       port->ip_messages.imq_seqno = 0;
+       imq_lock(mqueue);
+       ipc_mqueue_changed(mqueue);
+       port->ip_mscount = 0;
+       mqueue->imq_seqno = 0;
+       port->ip_context = port->ip_guarded = port->ip_strict_guard = 0;
+
+       if (should_destroy) {
+               /*
+                * Mark the mqueue invalid, preventing further send/receive
+                * operations from succeeding. It's important for this to be
+                * done under the same lock hold as the ipc_mqueue_changed
+                * call to avoid additional threads blocking on an mqueue
+                * that's being destroyed.
+                */
+               reap_messages = ipc_mqueue_destroy_locked(mqueue);
+       }
+
        imq_unlock(&port->ip_messages);
        imq_unlock(&port->ip_messages);
-       splx(s);
+
+       return reap_messages;
 }
 
 /*
 }
 
 /*
@@ -554,15 +627,22 @@ ipc_port_init(
        port->ip_pdrequest = IP_NULL;
        port->ip_requests = IPR_NULL;
 
        port->ip_pdrequest = IP_NULL;
        port->ip_requests = IPR_NULL;
 
-       port->ip_pset_count = 0;
        port->ip_premsg = IKM_NULL;
        port->ip_context = 0;
 
        port->ip_premsg = IKM_NULL;
        port->ip_context = 0;
 
-#if    MACH_ASSERT
-       ipc_port_init_debug(port);
-#endif /* MACH_ASSERT */
+       port->ip_sprequests  = 0;
+       port->ip_spimportant = 0;
+       port->ip_impdonation = 0;
+       port->ip_tempowner   = 0;
+
+       port->ip_guarded      = 0;
+       port->ip_strict_guard = 0;
+       port->ip_impcount    = 0;
 
 
-       ipc_mqueue_init(&port->ip_messages, FALSE /* set */);
+       port->ip_reserved    = 0;
+
+       ipc_mqueue_init(&port->ip_messages,
+                       FALSE /* !set */, NULL /* no reserved link */);
 }
 
 /*
 }
 
 /*
@@ -589,23 +669,26 @@ ipc_port_alloc(
        mach_port_name_t name;
        kern_return_t kr;
 
        mach_port_name_t name;
        kern_return_t kr;
 
+#if     MACH_ASSERT
+       uintptr_t buf[IP_CALLSTACK_MAX];
+       ipc_port_callstack_init_debug(&buf[0], IP_CALLSTACK_MAX);
+#endif /* MACH_ASSERT */
+           
        kr = ipc_object_alloc(space, IOT_PORT,
                              MACH_PORT_TYPE_RECEIVE, 0,
                              &name, (ipc_object_t *) &port);
        if (kr != KERN_SUCCESS)
                return kr;
 
        kr = ipc_object_alloc(space, IOT_PORT,
                              MACH_PORT_TYPE_RECEIVE, 0,
                              &name, (ipc_object_t *) &port);
        if (kr != KERN_SUCCESS)
                return kr;
 
-       /* port is locked */
-
+       /* port and space are locked */
        ipc_port_init(port, space, name);
 
        ipc_port_init(port, space, name);
 
-#if CONFIG_MACF_MACH
-       task_t issuer = current_task();
-       tasklabel_lock2 (issuer, space->is_task);
-       mac_port_label_associate(&issuer->maclabel, &space->is_task->maclabel,
-                        &port->ip_label);
-       tasklabel_unlock2 (issuer, space->is_task);
-#endif
+#if     MACH_ASSERT
+       ipc_port_init_debug(port, &buf[0], IP_CALLSTACK_MAX);
+#endif  /* MACH_ASSERT */
+
+       /* unlock space after init */
+       is_write_unlock(space);
 
        *namep = name;
        *portp = port;
 
        *namep = name;
        *portp = port;
@@ -636,6 +719,11 @@ ipc_port_alloc_name(
        ipc_port_t port;
        kern_return_t kr;
 
        ipc_port_t port;
        kern_return_t kr;
 
+#if     MACH_ASSERT
+       uintptr_t buf[IP_CALLSTACK_MAX];
+       ipc_port_callstack_init_debug(&buf[0], IP_CALLSTACK_MAX);
+#endif /* MACH_ASSERT */       
+
        kr = ipc_object_alloc_name(space, IOT_PORT,
                                   MACH_PORT_TYPE_RECEIVE, 0,
                                   name, (ipc_object_t *) &port);
        kr = ipc_object_alloc_name(space, IOT_PORT,
                                   MACH_PORT_TYPE_RECEIVE, 0,
                                   name, (ipc_object_t *) &port);
@@ -646,13 +734,9 @@ ipc_port_alloc_name(
 
        ipc_port_init(port, space, name);
 
 
        ipc_port_init(port, space, name);
 
-#if CONFIG_MACF_MACH
-       task_t issuer = current_task();
-       tasklabel_lock2 (issuer, space->is_task);
-       mac_port_label_associate(&issuer->maclabel, &space->is_task->maclabel,
-                        &port->ip_label);
-       tasklabel_unlock2 (issuer, space->is_task);
-#endif
+#if     MACH_ASSERT
+       ipc_port_init_debug(port, &buf[0], IP_CALLSTACK_MAX);
+#endif  /* MACH_ASSERT */      
 
        *portp = port;
 
 
        *portp = port;
 
@@ -677,17 +761,27 @@ ipc_port_spnotify(
         * If the port has no send-possible request
         * armed, don't bother to lock the port.
         */
         * If the port has no send-possible request
         * armed, don't bother to lock the port.
         */
-       if (!port->ip_sprequests)
+       if (port->ip_sprequests == 0)
                return;
 
        ip_lock(port);
                return;
 
        ip_lock(port);
-       if (!port->ip_sprequests) {
+       
+#if IMPORTANCE_INHERITANCE
+       if (port->ip_spimportant != 0) {
+               port->ip_spimportant = 0;
+               if (ipc_port_importance_delta(port, IPID_OPTION_NORMAL, -1) == TRUE) {
+                       ip_lock(port);
+               }
+       }
+#endif /* IMPORTANCE_INHERITANCE */
+
+       if (port->ip_sprequests == 0) {
                ip_unlock(port);
                return;
        }
                ip_unlock(port);
                return;
        }
-       port->ip_sprequests = FALSE;
+       port->ip_sprequests = 0;
 
 
- revalidate:
+revalidate:
        if (ip_active(port)) {
                ipc_port_request_t requests;
 
        if (ip_active(port)) {
                ipc_port_request_t requests;
 
@@ -722,6 +816,7 @@ ipc_port_spnotify(
                }
        }
        ip_unlock(port);
                }
        }
        ip_unlock(port);
+       return;
 }
 
 /*
 }
 
 /*
@@ -773,23 +868,53 @@ ipc_port_dnnotify(
  */
 
 void
  */
 
 void
-ipc_port_destroy(
-       ipc_port_t      port)
+ipc_port_destroy(ipc_port_t port)
 {
        ipc_port_t pdrequest, nsrequest;
        ipc_mqueue_t mqueue;
        ipc_kmsg_t kmsg;
 
 {
        ipc_port_t pdrequest, nsrequest;
        ipc_mqueue_t mqueue;
        ipc_kmsg_t kmsg;
 
+#if IMPORTANCE_INHERITANCE
+       ipc_importance_task_t release_imp_task = IIT_NULL;
+       thread_t self = current_thread();
+       boolean_t top = (self->ith_assertions == 0);
+       natural_t assertcnt = 0;
+#endif /* IMPORTANCE_INHERITANCE */
+
        assert(ip_active(port));
        /* port->ip_receiver_name is garbage */
        /* port->ip_receiver/port->ip_destination is garbage */
        assert(ip_active(port));
        /* port->ip_receiver_name is garbage */
        /* port->ip_receiver/port->ip_destination is garbage */
-       assert(port->ip_pset_count == 0);
-       assert(port->ip_mscount == 0);
-
-       /* first check for a backup port */
 
 
+       /* check for a backup port */
        pdrequest = port->ip_pdrequest;
        pdrequest = port->ip_pdrequest;
+
+#if IMPORTANCE_INHERITANCE
+       /* determine how many assertions to drop and from whom */
+       if (port->ip_tempowner != 0) {
+               assert(top);
+               release_imp_task = port->ip_imp_task;
+               if (IIT_NULL != release_imp_task) {
+                       port->ip_imp_task = IIT_NULL;
+                       assertcnt = port->ip_impcount;
+               }
+               /* Otherwise, nothing to drop */
+       } else {
+               assertcnt = port->ip_impcount;
+               if (pdrequest != IP_NULL)
+                       /* mark in limbo for the journey */
+                       port->ip_tempowner = 1;
+       }
+
+       if (top)
+               self->ith_assertions = assertcnt;
+#endif /* IMPORTANCE_INHERITANCE */
+
        if (pdrequest != IP_NULL) {
        if (pdrequest != IP_NULL) {
+               /* clear receiver, don't destroy the port */
+               (void)ipc_port_clear_receiver(port, FALSE);
+               assert(port->ip_in_pset == 0);
+               assert(port->ip_mscount == 0);
+
                /* we assume the ref for pdrequest */
                port->ip_pdrequest = IP_NULL;
 
                /* we assume the ref for pdrequest */
                port->ip_pdrequest = IP_NULL;
 
@@ -800,44 +925,98 @@ ipc_port_destroy(
 
                /* consumes our refs for port and pdrequest */
                ipc_notify_port_destroyed(pdrequest, port);
 
                /* consumes our refs for port and pdrequest */
                ipc_notify_port_destroyed(pdrequest, port);
-               return;
-       }
 
 
-       /* once port is dead, we don't need to keep it locked */
+               goto drop_assertions;
+       }
 
        port->ip_object.io_bits &= ~IO_BITS_ACTIVE;
        port->ip_timestamp = ipc_port_timestamp();
 
        port->ip_object.io_bits &= ~IO_BITS_ACTIVE;
        port->ip_timestamp = ipc_port_timestamp();
+       nsrequest = port->ip_nsrequest;
+
+       /*
+        * The mach_msg_* paths don't hold a port lock, they only hold a
+        * reference to the port object. If a thread raced us and is now
+        * blocked waiting for message reception on this mqueue (or waiting
+        * for ipc_mqueue_full), it will never be woken up. We call
+        * ipc_port_clear_receiver() here, _after_ the port has been marked
+        * inactive, to wakeup any threads which may be blocked and ensure
+        * that no other thread can get lost waiting for a wake up on a
+        * port/mqueue that's been destroyed.
+        */
+       boolean_t reap_msgs = FALSE;
+       reap_msgs = ipc_port_clear_receiver(port, TRUE); /* marks mqueue inactive */
+       assert(port->ip_in_pset == 0);
+       assert(port->ip_mscount == 0);
 
        /*
         * If the port has a preallocated message buffer and that buffer
         * is not inuse, free it.  If it has an inuse one, then the kmsg
         * free will detect that we freed the association and it can free it
         * like a normal buffer.
 
        /*
         * If the port has a preallocated message buffer and that buffer
         * is not inuse, free it.  If it has an inuse one, then the kmsg
         * free will detect that we freed the association and it can free it
         * like a normal buffer.
+        *
+        * Once the port is marked inactive we don't need to keep it locked.
         */
        if (IP_PREALLOC(port)) {
         */
        if (IP_PREALLOC(port)) {
+               ipc_port_t inuse_port;
+
                kmsg = port->ip_premsg;
                assert(kmsg != IKM_NULL);
                kmsg = port->ip_premsg;
                assert(kmsg != IKM_NULL);
+               inuse_port = ikm_prealloc_inuse_port(kmsg);
                IP_CLEAR_PREALLOC(port, kmsg);
                IP_CLEAR_PREALLOC(port, kmsg);
-               if (!ikm_prealloc_inuse(kmsg))
+               ip_unlock(port);
+               if (inuse_port != IP_NULL) {
+                       assert(inuse_port == port);
+               } else {
                        ipc_kmsg_free(kmsg);
                        ipc_kmsg_free(kmsg);
+               }
+       } else {
+               ip_unlock(port);
        }
        }
-       ip_unlock(port);
 
        /* throw away no-senders request */
 
        /* throw away no-senders request */
-       nsrequest = port->ip_nsrequest;
        if (nsrequest != IP_NULL)
                ipc_notify_send_once(nsrequest); /* consumes ref */
 
        if (nsrequest != IP_NULL)
                ipc_notify_send_once(nsrequest); /* consumes ref */
 
-       /* destroy any queued messages */
+       /*
+        * Reap any kmsg objects waiting to be destroyed.
+        * This must be done after we've released the port lock.
+        */
+       if (reap_msgs)
+               ipc_kmsg_reap_delayed();
+
        mqueue = &port->ip_messages;
        mqueue = &port->ip_messages;
-       ipc_mqueue_destroy(mqueue);
+
+       /* cleanup waitq related resources */
+       ipc_mqueue_deinit(mqueue);
 
        /* generate dead-name notifications */
        ipc_port_dnnotify(port);
 
        ipc_kobject_destroy(port);
 
 
        /* generate dead-name notifications */
        ipc_port_dnnotify(port);
 
        ipc_kobject_destroy(port);
 
-       ipc_port_release(port); /* consume caller's ref */
+       ip_release(port); /* consume caller's ref */
+
+ drop_assertions:
+#if IMPORTANCE_INHERITANCE
+       if (release_imp_task != IIT_NULL) {
+               if (assertcnt > 0) {
+                       assert(top);
+                       self->ith_assertions = 0;
+                       assert(ipc_importance_task_is_any_receiver_type(release_imp_task));
+                       ipc_importance_task_drop_internal_assertion(release_imp_task, assertcnt);
+               }
+               ipc_importance_task_release(release_imp_task);
+
+       } else if (assertcnt > 0) {
+               if (top) {
+                       self->ith_assertions = 0;
+                       release_imp_task = current_task()->task_imp_base;
+                       if (ipc_importance_task_is_any_receiver_type(release_imp_task)) {
+                               ipc_importance_task_drop_internal_assertion(release_imp_task, assertcnt);
+                       }
+               }
+       }
+#endif /* IMPORTANCE_INHERITANCE */
 }
 
 /*
 }
 
 /*
@@ -852,6 +1031,7 @@ ipc_port_destroy(
  *             That is, we want to set port->ip_destination == dest,
  *             but guaranteeing that this doesn't create a circle
  *             port->ip_destination->ip_destination->... == port
  *             That is, we want to set port->ip_destination == dest,
  *             but guaranteeing that this doesn't create a circle
  *             port->ip_destination->ip_destination->... == port
+ *
  *     Conditions:
  *             No ports locked.  References held for "port" and "dest".
  */
  *     Conditions:
  *             No ports locked.  References held for "port" and "dest".
  */
@@ -861,6 +1041,10 @@ ipc_port_check_circularity(
        ipc_port_t      port,
        ipc_port_t      dest)
 {
        ipc_port_t      port,
        ipc_port_t      dest)
 {
+#if IMPORTANCE_INHERITANCE
+       /* adjust importance counts at the same time */
+       return ipc_importance_check_circularity(port, dest);
+#else
        ipc_port_t base;
 
        assert(port != IP_NULL);
        ipc_port_t base;
 
        assert(port != IP_NULL);
@@ -874,7 +1058,6 @@ ipc_port_check_circularity(
         *      First try a quick check that can run in parallel.
         *      No circularity if dest is not in transit.
         */
         *      First try a quick check that can run in parallel.
         *      No circularity if dest is not in transit.
         */
-
        ip_lock(port);
        if (ip_lock_try(dest)) {
                if (!ip_active(dest) ||
        ip_lock(port);
        if (ip_lock_try(dest)) {
                if (!ip_active(dest) ||
@@ -957,30 +1140,293 @@ ipc_port_check_circularity(
 
        /* now unlock chain */
 
 
        /* now unlock chain */
 
-       while (port != base) {
-               ipc_port_t next;
+       ip_unlock(port);
+
+       for (;;) {
+               if (dest == base)
+                       break;
 
                /* port is in transit */
 
 
                /* port is in transit */
 
-               assert(ip_active(port));
-               assert(port->ip_receiver_name == MACH_PORT_NULL);
-               assert(port->ip_destination != IP_NULL);
+               assert(ip_active(dest));
+               assert(dest->ip_receiver_name == MACH_PORT_NULL);
+               assert(dest->ip_destination != IP_NULL);
 
 
-               next = port->ip_destination;
-               ip_unlock(port);
-               port = next;
+               port = dest->ip_destination;
+               ip_unlock(dest);
+               dest = port;
        }
 
        /* base is not in transit */
        }
 
        /* base is not in transit */
-
        assert(!ip_active(base) ||
               (base->ip_receiver_name != MACH_PORT_NULL) ||
               (base->ip_destination == IP_NULL));
        assert(!ip_active(base) ||
               (base->ip_receiver_name != MACH_PORT_NULL) ||
               (base->ip_destination == IP_NULL));
+
        ip_unlock(base);
 
        return FALSE;
        ip_unlock(base);
 
        return FALSE;
+#endif /* !IMPORTANCE_INHERITANCE */
 }
 
 }
 
+/*
+ *     Routine:        ipc_port_impcount_delta
+ *     Purpose:
+ *             Adjust only the importance count associated with a port.
+ *             If there are any adjustments to be made to receiver task,
+ *             those are handled elsewhere.
+ *
+ *             For now, be defensive during deductions to make sure the
+ *             impcount for the port doesn't underflow zero.  This will
+ *             go away when the port boost addition is made atomic (see
+ *             note in ipc_port_importance_delta()).
+ *     Conditions:
+ *             The port is referenced and locked.
+ *             Nothing else is locked.
+ */
+mach_port_delta_t
+ipc_port_impcount_delta(
+       ipc_port_t        port,
+       mach_port_delta_t delta,
+       ipc_port_t        __unused base)
+{
+       mach_port_delta_t absdelta; 
+
+       if (!ip_active(port)) {
+               return 0;
+       }
+
+       /* adding/doing nothing is easy */
+       if (delta >= 0) {
+               port->ip_impcount += delta;
+               return delta;
+       }
+
+       absdelta = 0 - delta;           
+       if (port->ip_impcount >= absdelta) {
+               port->ip_impcount -= absdelta;
+               return delta;
+       }
+
+#if (DEVELOPMENT || DEBUG)
+       if (port->ip_receiver_name != MACH_PORT_NULL) {
+               task_t target_task = port->ip_receiver->is_task;
+               ipc_importance_task_t target_imp = target_task->task_imp_base;
+               const char *target_procname;
+               int target_pid;
+
+               if (target_imp != IIT_NULL) {
+                       target_procname = target_imp->iit_procname;
+                       target_pid = target_imp->iit_bsd_pid;
+               } else {
+                       target_procname = "unknown";
+                       target_pid = -1;
+               }
+               printf("Over-release of importance assertions for port 0x%x receiver pid %d (%s), "
+                      "dropping %d assertion(s) but port only has %d remaining.\n",
+                      port->ip_receiver_name, 
+                      target_pid, target_procname,
+                      absdelta, port->ip_impcount);
+
+       } else if (base != IP_NULL) {
+               task_t target_task = base->ip_receiver->is_task;
+               ipc_importance_task_t target_imp = target_task->task_imp_base;
+               const char *target_procname;
+               int target_pid;
+
+               if (target_imp != IIT_NULL) {
+                       target_procname = target_imp->iit_procname;
+                       target_pid = target_imp->iit_bsd_pid;
+               } else {
+                       target_procname = "unknown";
+                       target_pid = -1;
+               }
+               printf("Over-release of importance assertions for port 0x%lx "
+                      "enqueued on port 0x%x with receiver pid %d (%s), "
+                      "dropping %d assertion(s) but port only has %d remaining.\n",
+                      (unsigned long)VM_KERNEL_UNSLIDE_OR_PERM((uintptr_t)port),
+                      base->ip_receiver_name,
+                      target_pid, target_procname,
+                      absdelta, port->ip_impcount);
+       }
+#endif
+
+       delta = 0 - port->ip_impcount;
+       port->ip_impcount = 0;
+       return delta;
+}
+
+/*
+ *     Routine:        ipc_port_importance_delta_internal
+ *     Purpose:
+ *             Adjust the importance count through the given port.
+ *             If the port is in transit, apply the delta throughout
+ *             the chain. Determine if the there is a task at the
+ *             base of the chain that wants/needs to be adjusted,
+ *             and if so, apply the delta.
+ *     Conditions:
+ *             The port is referenced and locked on entry.
+ *             Importance may be locked.
+ *             Nothing else is locked.
+ *             The lock may be dropped on exit.
+ *             Returns TRUE if lock was dropped.
+ */
+#if IMPORTANCE_INHERITANCE
+
+boolean_t
+ipc_port_importance_delta_internal(
+       ipc_port_t              port,
+       natural_t               options,
+       mach_port_delta_t       *deltap,
+       ipc_importance_task_t   *imp_task)
+{
+       ipc_port_t next, base;
+       boolean_t dropped = FALSE;
+
+       *imp_task = IIT_NULL;
+
+       if (*deltap == 0)
+               return FALSE;
+
+       assert(options == IPID_OPTION_NORMAL || options == IPID_OPTION_SENDPOSSIBLE);
+
+       base = port;
+
+       /* if port is in transit, have to search for end of chain */
+       if (ip_active(port) &&
+           port->ip_destination != IP_NULL &&
+           port->ip_receiver_name == MACH_PORT_NULL) {
+
+               dropped = TRUE;
+
+               ip_unlock(port);
+               ipc_port_multiple_lock(); /* massive serialization */
+               ip_lock(base);
+
+               while(ip_active(base) &&
+                     base->ip_destination != IP_NULL &&
+                     base->ip_receiver_name == MACH_PORT_NULL) {
+
+                       base = base->ip_destination;
+                       ip_lock(base);
+               }
+               ipc_port_multiple_unlock();
+       }
+
+       /*
+        * If the port lock is dropped b/c the port is in transit, there is a
+        * race window where another thread can drain messages and/or fire a
+        * send possible notification before we get here.
+        *
+        * We solve this race by checking to see if our caller armed the send
+        * possible notification, whether or not it's been fired yet, and
+        * whether or not we've already set the port's ip_spimportant bit. If
+        * we don't need a send-possible boost, then we'll just apply a
+        * harmless 0-boost to the port.
+        */
+       if (options & IPID_OPTION_SENDPOSSIBLE) {
+               assert(*deltap == 1);
+               if (port->ip_sprequests && port->ip_spimportant == 0)
+                       port->ip_spimportant = 1;
+               else
+                       *deltap = 0;
+       }
+
+       /* unlock down to the base, adjusting boost(s) at each level */
+       for (;;) {
+               *deltap = ipc_port_impcount_delta(port, *deltap, base);
+
+               if (port == base) {
+                       break;
+               }
+
+               /* port is in transit */
+               assert(port->ip_tempowner == 0);
+               next = port->ip_destination;
+               ip_unlock(port);
+               port = next;
+       }
+
+       /* find the task (if any) to boost according to the base */
+       if (ip_active(base)) {
+               if (base->ip_tempowner != 0) {
+                       if (IIT_NULL != base->ip_imp_task)
+                               *imp_task = base->ip_imp_task;
+                       /* otherwise don't boost */
+
+               } else if (base->ip_receiver_name != MACH_PORT_NULL) {
+                       ipc_space_t space = base->ip_receiver;
+
+                       /* only spaces with boost-accepting tasks */
+                       if (space->is_task != TASK_NULL &&
+                           ipc_importance_task_is_any_receiver_type(space->is_task->task_imp_base)) {
+                               *imp_task = space->is_task->task_imp_base;
+                       }
+               }
+       }
+
+       /*
+        * Only the base is locked.  If we have to hold or drop task
+        * importance assertions, we'll have to drop that lock as well.
+        */
+       if (*imp_task != IIT_NULL) {
+               /* take a reference before unlocking base */
+               ipc_importance_task_reference(*imp_task);
+       }
+
+       if (dropped == TRUE) {
+               ip_unlock(base);
+       }
+
+       return dropped;
+}
+#endif /* IMPORTANCE_INHERITANCE */
+
+/*
+ *     Routine:        ipc_port_importance_delta
+ *     Purpose:
+ *             Adjust the importance count through the given port.
+ *             If the port is in transit, apply the delta throughout
+ *             the chain.
+ *
+ *             If there is a task at the base of the chain that wants/needs
+ *             to be adjusted, apply the delta.
+ *     Conditions:
+ *             The port is referenced and locked on entry.
+ *             Nothing else is locked.
+ *             The lock may be dropped on exit.
+ *             Returns TRUE if lock was dropped.
+ */
+#if IMPORTANCE_INHERITANCE
+
+boolean_t
+ipc_port_importance_delta(
+       ipc_port_t              port,
+       natural_t               options,
+       mach_port_delta_t       delta)
+{
+       ipc_importance_task_t imp_task = IIT_NULL;
+       boolean_t dropped;
+
+       dropped = ipc_port_importance_delta_internal(port, options, &delta, &imp_task);
+
+       if (IIT_NULL == imp_task || delta == 0)
+               return dropped;
+
+       if (!dropped)
+               ip_unlock(port);
+
+       assert(ipc_importance_task_is_any_receiver_type(imp_task));
+
+       if (delta > 0)
+               ipc_importance_task_hold_internal_assertion(imp_task, delta);
+       else
+               ipc_importance_task_drop_internal_assertion(imp_task, -delta);
+
+       ipc_importance_task_release(imp_task);
+       return TRUE;
+}
+#endif /* IMPORTANCE_INHERITANCE */
+
 /*
  *     Routine:        ipc_port_lookup_notify
  *     Purpose:
 /*
  *     Routine:        ipc_port_lookup_notify
  *     Purpose:
@@ -1001,7 +1447,7 @@ ipc_port_lookup_notify(
        ipc_port_t port;
        ipc_entry_t entry;
 
        ipc_port_t port;
        ipc_entry_t entry;
 
-       assert(space->is_active);
+       assert(is_active(space));
 
        entry = ipc_entry_lookup(space, name);
        if (entry == IE_NULL)
 
        entry = ipc_entry_lookup(space, name);
        if (entry == IE_NULL)
@@ -1009,7 +1455,7 @@ ipc_port_lookup_notify(
        if ((entry->ie_bits & MACH_PORT_TYPE_RECEIVE) == 0)
                return IP_NULL;
 
        if ((entry->ie_bits & MACH_PORT_TYPE_RECEIVE) == 0)
                return IP_NULL;
 
-       port = (ipc_port_t) entry->ie_object;
+       __IGNORE_WCASTALIGN(port = (ipc_port_t) entry->ie_object);
        assert(port != IP_NULL);
 
        ip_lock(port);
        assert(port != IP_NULL);
 
        ip_lock(port);
@@ -1040,7 +1486,6 @@ ipc_port_make_send_locked(
        port->ip_mscount++;
        port->ip_srights++;
        ip_reference(port);
        port->ip_mscount++;
        port->ip_srights++;
        ip_reference(port);
-       ip_unlock(port);
        return port;
 }
 
        return port;
 }
 
@@ -1160,24 +1605,46 @@ ipc_port_release_send(
                return;
 
        ip_lock(port);
                return;
 
        ip_lock(port);
-       ip_release(port);
+
+       assert(port->ip_srights > 0);
+       port->ip_srights--;
 
        if (!ip_active(port)) {
 
        if (!ip_active(port)) {
-               ip_check_unlock(port);
+               ip_unlock(port);
+               ip_release(port);
                return;
        }
 
                return;
        }
 
-       assert(port->ip_srights > 0);
-
-       if (--port->ip_srights == 0 &&
+       if (port->ip_srights == 0 &&
            port->ip_nsrequest != IP_NULL) {
                nsrequest = port->ip_nsrequest;
                port->ip_nsrequest = IP_NULL;
                mscount = port->ip_mscount;
                ip_unlock(port);
            port->ip_nsrequest != IP_NULL) {
                nsrequest = port->ip_nsrequest;
                port->ip_nsrequest = IP_NULL;
                mscount = port->ip_mscount;
                ip_unlock(port);
+               ip_release(port);
                ipc_notify_no_senders(nsrequest, mscount);
                ipc_notify_no_senders(nsrequest, mscount);
-       } else
+       } else {
                ip_unlock(port);
                ip_unlock(port);
+               ip_release(port);
+       }
+}
+
+/*
+ *     Routine:        ipc_port_make_sonce_locked
+ *     Purpose:
+ *             Make a naked send-once right from a receive right.
+ *     Conditions:
+ *             The port is locked and active.
+ */
+
+ipc_port_t
+ipc_port_make_sonce_locked(
+       ipc_port_t      port)
+{
+       assert(ip_active(port));
+       port->ip_sorights++;
+       ip_reference(port);
+       return port;
 }
 
 /*
 }
 
 /*
@@ -1185,7 +1652,7 @@ ipc_port_release_send(
  *     Purpose:
  *             Make a naked send-once right from a receive right.
  *     Conditions:
  *     Purpose:
  *             Make a naked send-once right from a receive right.
  *     Conditions:
- *             The port is not locked but it is active.
+ *             The port is not locked.
  */
 
 ipc_port_t
  */
 
 ipc_port_t
@@ -1196,12 +1663,14 @@ ipc_port_make_sonce(
                return port;
 
        ip_lock(port);
                return port;
 
        ip_lock(port);
-       assert(ip_active(port));
-       port->ip_sorights++;
-       ip_reference(port);
+       if (ip_active(port)) {
+               port->ip_sorights++;
+               ip_reference(port);
+               ip_unlock(port);
+               return port;
+       }
        ip_unlock(port);
        ip_unlock(port);
-
-       return port;
+       return IP_DEAD;
 }
 
 /*
 }
 
 /*
@@ -1231,14 +1700,8 @@ ipc_port_release_sonce(
 
        port->ip_sorights--;
 
 
        port->ip_sorights--;
 
-       ip_release(port);
-
-       if (!ip_active(port)) {
-               ip_check_unlock(port);
-               return;
-       }
-
        ip_unlock(port);
        ip_unlock(port);
+       ip_release(port);
 }
 
 /*
 }
 
 /*
@@ -1267,7 +1730,7 @@ ipc_port_release_receive(
        ipc_port_destroy(port); /* consumes ref, unlocks */
 
        if (dest != IP_NULL)
        ipc_port_destroy(port); /* consumes ref, unlocks */
 
        if (dest != IP_NULL)
-               ipc_port_release(dest);
+               ip_release(dest);
 }
 
 /*
 }
 
 /*
@@ -1286,10 +1749,15 @@ ipc_port_alloc_special(
 {
        ipc_port_t port;
 
 {
        ipc_port_t port;
 
-       port = (ipc_port_t) io_alloc(IOT_PORT);
+       __IGNORE_WCASTALIGN(port = (ipc_port_t) io_alloc(IOT_PORT));
        if (port == IP_NULL)
                return IP_NULL;
 
        if (port == IP_NULL)
                return IP_NULL;
 
+#if     MACH_ASSERT
+       uintptr_t buf[IP_CALLSTACK_MAX];
+       ipc_port_callstack_init_debug(&buf[0], IP_CALLSTACK_MAX);
+#endif /* MACH_ASSERT */       
+
        bzero((char *)port, sizeof(*port));
        io_lock_init(&port->ip_object);
        port->ip_references = 1;
        bzero((char *)port, sizeof(*port));
        io_lock_init(&port->ip_object);
        port->ip_references = 1;
@@ -1297,17 +1765,9 @@ ipc_port_alloc_special(
 
        ipc_port_init(port, space, 1);
 
 
        ipc_port_init(port, space, 1);
 
-#if CONFIG_MACF_MACH
-       /* Currently, ipc_port_alloc_special is used for two things:
-        * - Reply ports for messages from the kernel
-        * - Ports for communication with the kernel (e.g. task ports)
-        * Since both of these would typically be labelled as kernel objects,
-        * we will use a new entry point for this purpose, as current_task()
-        * is often wrong (i.e. not kernel_task) or null.
-        */
-       mac_port_label_init(&port->ip_label);
-       mac_port_label_associate_kernel(&port->ip_label, space == ipc_space_reply);
-#endif
+#if     MACH_ASSERT
+       ipc_port_init_debug(port, &buf[0], IP_CALLSTACK_MAX);
+#endif  /* MACH_ASSERT */              
 
        return port;
 }
 
        return port;
 }
@@ -1367,15 +1827,126 @@ ipc_port_finalize(
                it_requests_free(its, requests);
                port->ip_requests = IPR_NULL;
        }
                it_requests_free(its, requests);
                port->ip_requests = IPR_NULL;
        }
+
+       ipc_mqueue_deinit(&port->ip_messages);
        
 #if    MACH_ASSERT
        ipc_port_track_dealloc(port);
 #endif /* MACH_ASSERT */
        
 #if    MACH_ASSERT
        ipc_port_track_dealloc(port);
 #endif /* MACH_ASSERT */
+}
+
+/*
+ *     Routine:        kdp_mqueue_send_find_owner
+ *     Purpose:
+ *             Discover the owner of the ipc_mqueue that contains the input
+ *             waitq object. The thread blocked on the waitq should be
+ *             waiting for an IPC_MQUEUE_FULL event.
+ *     Conditions:
+ *             The 'waitinfo->wait_type' value should already be set to
+ *             kThreadWaitPortSend.
+ *     Note:
+ *             If we find out that the containing port is actually in
+ *             transit, we reset the wait_type field to reflect this.
+ */
+void
+kdp_mqueue_send_find_owner(struct waitq * waitq, __assert_only event64_t event, thread_waitinfo_t * waitinfo)
+{
+       assert(waitinfo->wait_type == kThreadWaitPortSend);
+       assert(event == IPC_MQUEUE_FULL);
+
+       ipc_mqueue_t mqueue = imq_from_waitq(waitq);
+       ipc_port_t port     = ip_from_mq(mqueue); /* we are blocking on send */
+       assert(kdp_is_in_zone(port, "ipc ports"));
+
+       waitinfo->owner = 0;
+       waitinfo->context  = VM_KERNEL_UNSLIDE_OR_PERM(port);
+       if (ip_lock_held_kdp(port)) {
+               /*
+                * someone has the port locked: it may be in an
+                * inconsistent state: bail
+                */
+               waitinfo->owner = STACKSHOT_WAITOWNER_PORT_LOCKED;
+               return;
+       }
 
 
-#if CONFIG_MACF_MACH
-       /* Port label should have been initialized after creation. */
-       mac_port_label_destroy(&port->ip_label);
-#endif   
+       if (ip_active(port)) {
+               if (port->ip_tempowner) {
+                       if (port->ip_imp_task != IIT_NULL) {
+                               /* port is held by a tempowner */
+                               waitinfo->owner = pid_from_task(port->ip_imp_task->iit_task);
+                       } else {
+                               waitinfo->owner = STACKSHOT_WAITOWNER_INTRANSIT;
+                       }
+               } else if (port->ip_receiver_name) {
+                       /* port in a space */
+                       if (port->ip_receiver == ipc_space_kernel) {
+                               /*
+                                * The kernel pid is 0, make this
+                                * distinguishable from no-owner and
+                                * inconsistent port state.
+                                */
+                               waitinfo->owner = STACKSHOT_WAITOWNER_KERNEL;
+                       } else {
+                               waitinfo->owner = pid_from_task(port->ip_receiver->is_task);
+                       }
+               } else if (port->ip_destination != IP_NULL) {
+                       /* port in transit */
+                       waitinfo->wait_type = kThreadWaitPortSendInTransit;
+                       waitinfo->owner     = VM_KERNEL_UNSLIDE_OR_PERM(port->ip_destination);
+               }
+       }
+}
+
+/*
+ *     Routine:        kdp_mqueue_recv_find_owner
+ *     Purpose:
+ *             Discover the "owner" of the ipc_mqueue that contains the input
+ *             waitq object. The thread blocked on the waitq is trying to
+ *             receive on the mqueue.
+ *     Conditions:
+ *             The 'waitinfo->wait_type' value should already be set to
+ *             kThreadWaitPortReceive.
+ *     Note:
+ *             If we find that we are actualy waiting on a port set, we reset
+ *             the wait_type field to reflect this.
+ */
+void
+kdp_mqueue_recv_find_owner(struct waitq * waitq, __assert_only event64_t event, thread_waitinfo_t * waitinfo)
+{
+       assert(waitinfo->wait_type == kThreadWaitPortReceive);
+       assert(event == IPC_MQUEUE_RECEIVE);
+
+       ipc_mqueue_t mqueue = imq_from_waitq(waitq);
+       waitinfo->owner     = 0;
+       if (imq_is_set(mqueue)) { /* we are waiting on a port set */
+               ipc_pset_t set = ips_from_mq(mqueue);
+               assert(kdp_is_in_zone(set, "ipc port sets"));
+
+               /* Reset wait type to specify waiting on port set receive */
+               waitinfo->wait_type = kThreadWaitPortSetReceive;
+               waitinfo->context   = VM_KERNEL_UNSLIDE_OR_PERM(set);
+               if (ips_lock_held_kdp(set)) {
+                       waitinfo->owner = STACKSHOT_WAITOWNER_PSET_LOCKED;
+               }
+               /* There is no specific owner "at the other end" of a port set, so leave unset. */
+       } else {
+               ipc_port_t port   = ip_from_mq(mqueue);
+               assert(kdp_is_in_zone(port, "ipc ports"));
+
+               waitinfo->context = VM_KERNEL_UNSLIDE_OR_PERM(port);
+               if (ip_lock_held_kdp(port)) {
+                       waitinfo->owner = STACKSHOT_WAITOWNER_PORT_LOCKED;
+                       return;
+               }
+
+               if (ip_active(port)) {
+                       if (port->ip_receiver_name != MACH_PORT_NULL) {
+                               waitinfo->owner = port->ip_receiver_name;
+                       } else {
+                               waitinfo->owner = STACKSHOT_WAITOWNER_INTRANSIT;
+                       }
+               }
+       }
 }
 
 #if    MACH_ASSERT
 }
 
 #if    MACH_ASSERT
@@ -1386,9 +1957,10 @@ ipc_port_finalize(
  *     Allocation is intercepted via ipc_port_init;
  *     deallocation is intercepted via io_free.
  */
  *     Allocation is intercepted via ipc_port_init;
  *     deallocation is intercepted via io_free.
  */
+#if 0
 queue_head_t   port_alloc_queue;
 queue_head_t   port_alloc_queue;
-decl_lck_mtx_data(,port_alloc_queue_lock)
-lck_mtx_ext_t  port_alloc_queue_lock_ext;
+lck_spin_t     port_alloc_queue_lock;
+#endif
 
 unsigned long  port_count = 0;
 unsigned long  port_count_warning = 20000;
 
 unsigned long  port_count = 0;
 unsigned long  port_count_warning = 20000;
@@ -1411,8 +1983,10 @@ int              db_port_walk(
 void
 ipc_port_debug_init(void)
 {
 void
 ipc_port_debug_init(void)
 {
+#if 0
        queue_init(&port_alloc_queue);
        queue_init(&port_alloc_queue);
-       lck_mtx_init_ext(&port_alloc_queue_lock, &port_alloc_queue_lock_ext, &ipc_lck_grp, &ipc_lck_attr);
+       lck_spin_init(&port_alloc_queue_lock, &ipc_lck_grp, &ipc_lck_attr);
+#endif
 
        if (!PE_parse_boot_argn("ipc_portbt", &ipc_portbt, sizeof (ipc_portbt)))
                ipc_portbt = 0;
 
        if (!PE_parse_boot_argn("ipc_portbt", &ipc_portbt, sizeof (ipc_portbt)))
                ipc_portbt = 0;
@@ -1428,16 +2002,18 @@ extern int proc_pid(struct proc*);
  */
 void
 ipc_port_init_debug(
  */
 void
 ipc_port_init_debug(
-       ipc_port_t      port)
+       ipc_port_t      port,
+       uintptr_t       *callstack,
+       unsigned int    callstack_max)
 {
        unsigned int    i;
 
        port->ip_thread = current_thread();
        port->ip_timetrack = port_timestamp++;
 {
        unsigned int    i;
 
        port->ip_thread = current_thread();
        port->ip_timetrack = port_timestamp++;
-       for (i = 0; i < IP_CALLSTACK_MAX; ++i)
-               port->ip_callstack[i] = 0;
+       for (i = 0; i < callstack_max; ++i)
+               port->ip_callstack[i] = callstack[i];   
        for (i = 0; i < IP_NSPARES; ++i)
        for (i = 0; i < IP_NSPARES; ++i)
-               port->ip_spares[i] = 0;
+               port->ip_spares[i] = 0; 
 
 #ifdef MACH_BSD
        task_t task = current_task();
 
 #ifdef MACH_BSD
        task_t task = current_task();
@@ -1448,24 +2024,39 @@ ipc_port_init_debug(
        }
 #endif /* MACH_BSD */
 
        }
 #endif /* MACH_BSD */
 
-       /*
-        *      Machine-dependent routine to fill in an
-        *      array with up to IP_CALLSTACK_MAX levels
-        *      of return pc information.
-        */
-       if (ipc_portbt)
-               machine_callstack(&port->ip_callstack[0], IP_CALLSTACK_MAX);
-
 #if 0
 #if 0
-       lck_mtx_lock(&port_alloc_queue_lock);
+       lck_spin_lock(&port_alloc_queue_lock);
        ++port_count;
        if (port_count_warning > 0 && port_count >= port_count_warning)
                assert(port_count < port_count_warning);
        queue_enter(&port_alloc_queue, port, ipc_port_t, ip_port_links);
        ++port_count;
        if (port_count_warning > 0 && port_count >= port_count_warning)
                assert(port_count < port_count_warning);
        queue_enter(&port_alloc_queue, port, ipc_port_t, ip_port_links);
-       lck_mtx_unlock(&port_alloc_queue_lock);
+       lck_spin_unlock(&port_alloc_queue_lock);
 #endif
 }
 
 #endif
 }
 
+/*
+ *     Routine:        ipc_port_callstack_init_debug
+ *     Purpose:
+ *             Calls the machine-dependent routine to
+ *             fill in an array with up to IP_CALLSTACK_MAX
+ *             levels of return pc information
+ *     Conditions:
+ *             May block (via copyin)
+ */
+void
+ipc_port_callstack_init_debug(
+       uintptr_t       *callstack,
+       unsigned int    callstack_max)
+{
+       unsigned int    i;
+
+       /* guarantee the callstack is initialized */
+       for (i=0; i < callstack_max; i++)
+               callstack[i] = 0;       
+
+       if (ipc_portbt)
+               machine_callstack(callstack, callstack_max);
+}
 
 /*
  *     Remove a port from the queue of allocated ports.
 
 /*
  *     Remove a port from the queue of allocated ports.
@@ -1483,672 +2074,13 @@ void
 ipc_port_track_dealloc(
        ipc_port_t              port)
 {
 ipc_port_track_dealloc(
        ipc_port_t              port)
 {
-       lck_mtx_lock(&port_alloc_queue_lock);
+       lck_spin_lock(&port_alloc_queue_lock);
        assert(port_count > 0);
        --port_count;
        queue_remove(&port_alloc_queue, port, ipc_port_t, ip_port_links);
        assert(port_count > 0);
        --port_count;
        queue_remove(&port_alloc_queue, port, ipc_port_t, ip_port_links);
-       lck_mtx_unlock(&port_alloc_queue_lock);
+       lck_spin_unlock(&port_alloc_queue_lock);
 }
 #endif
 
 
 #endif /* MACH_ASSERT */
 }
 #endif
 
 
 #endif /* MACH_ASSERT */
-
-
-#if    MACH_KDB
-
-#include <ddb/db_output.h>
-#include <ddb/db_print.h>
-
-#define        printf  kdbprintf
-
-int
-db_port_queue_print(
-       ipc_port_t      port);
-
-/*
- *     Routine:        ipc_port_print
- *     Purpose:
- *             Pretty-print a port for kdb.
- */
-int    ipc_port_print_long = 0;        /* set for more detail */
-
-void
-ipc_port_print(
-       ipc_port_t              port,
-       __unused boolean_t      have_addr,
-       __unused db_expr_t      count,
-       char                    *modif)
-{
-       db_addr_t       task;
-       int             task_id;
-       int             nmsgs;
-       int             verbose = 0;
-#if    MACH_ASSERT
-       int             i, needs_db_indent, items_printed;
-#endif /* MACH_ASSERT */
-       
-       if (db_option(modif, 'l') || db_option(modif, 'v'))
-               ++verbose;
-
-       printf("port 0x%x\n", port);
-
-       db_indent += 2;
-
-       ipc_object_print(&port->ip_object);
-
-       if (ipc_port_print_long) {
-               printf("\n");
-       }
-
-       if (!ip_active(port)) {
-               iprintf("timestamp=0x%x", port->ip_timestamp);
-       } else if (port->ip_receiver_name == MACH_PORT_NULL) {
-               iprintf("destination=0x%x (", port->ip_destination);
-               if (port->ip_destination != MACH_PORT_NULL &&
-                   (task = db_task_from_space(port->ip_destination->
-                                              ip_receiver, &task_id)))
-                       printf("task%d at 0x%x", task_id, task);
-               else
-                       printf("unknown");
-               printf(")");
-       } else {
-               iprintf("receiver=0x%x (", port->ip_receiver);
-               if (port->ip_receiver == ipc_space_kernel)
-                       printf("kernel");
-               else if (port->ip_receiver == ipc_space_reply)
-                       printf("reply");
-               else if (port->ip_receiver == default_pager_space)
-                       printf("default_pager");
-               else if ((task = db_task_from_space(port->ip_receiver, &task_id)) != (db_addr_t)0)
-                       printf("task%d at 0x%x", task_id, task);
-               else
-                       printf("unknown");
-               printf(")");
-       }
-       printf(", receiver_name=0x%x\n", port->ip_receiver_name);
-
-       iprintf("mscount=%d", port->ip_mscount);
-       printf(", srights=%d", port->ip_srights);
-       printf(", sorights=%d\n", port->ip_sorights);
-
-       iprintf("nsrequest=0x%x", port->ip_nsrequest);
-       printf(", pdrequest=0x%x", port->ip_pdrequest);
-       printf(", requests=0x%x\n", port->ip_requests);
-
-       iprintf("pset_count=0x%x", port->ip_pset_count);
-       printf(", seqno=%d", port->ip_messages.imq_seqno);
-       printf(", msgcount=%d", port->ip_messages.imq_msgcount);
-       printf(", qlimit=%d\n", port->ip_messages.imq_qlimit);
-
-       iprintf("kmsgs=0x%x", port->ip_messages.imq_messages.ikmq_base);
-       printf(", rcvrs queue=0x%x", port->ip_messages.imq_wait_queue);
-       printf(", kobj=0x%x\n", port->ip_kobject);
-
-       iprintf("premsg=0x%x", port->ip_premsg);
-
-#if    MACH_ASSERT
-       /* don't bother printing callstack or queue links */
-       iprintf("ip_thread=0x%x, ip_timetrack=0x%x\n",
-               port->ip_thread, port->ip_timetrack);
-       items_printed = 0;
-       needs_db_indent = 1;
-       for (i = 0; i < IP_NSPARES; ++i) {
-               if (port->ip_spares[i] != 0) {
-                       if (needs_db_indent) {
-                               iprintf("");
-                               needs_db_indent = 0;
-                       }
-                       printf("%sip_spares[%d] = %d",
-                              items_printed ? ", " : "", i, 
-                              port->ip_spares[i]);
-                       if (++items_printed >= 4) {
-                               needs_db_indent = 1;
-                               printf("\n");
-                               items_printed = 0;
-                       }
-               }
-       }
-#endif /* MACH_ASSERT */
-
-       if (verbose) {
-               iprintf("kmsg queue contents:\n");
-               db_indent += 2;
-               nmsgs = db_port_queue_print(port);
-               db_indent -= 2;
-               iprintf("...total kmsgs:  %d\n", nmsgs);
-       }
-
-       db_indent -=2;
-}
-
-ipc_port_t
-ipc_name_to_data(
-       task_t                  task,
-       mach_port_name_t        name)
-{
-       ipc_space_t     space;
-       ipc_entry_t     entry;
-
-       if (task == TASK_NULL) {
-               db_printf("port_name_to_data: task is null\n");
-               return (0);
-       }
-       if ((space = task->itk_space) == 0) {
-               db_printf("port_name_to_data: task->itk_space is null\n");
-               return (0);
-       }
-       if (!space->is_active) {
-               db_printf("port_name_to_data: task->itk_space not active\n");
-               return (0);
-       }
-       if ((entry = ipc_entry_lookup(space, name)) == 0) {
-               db_printf("port_name_to_data: lookup yields zero\n");
-               return (0);
-       }
-       return ((ipc_port_t)entry->ie_object);
-}
-
-#if    ZONE_DEBUG
-void
-print_type_ports(type, dead)
-       unsigned type;
-       unsigned dead;
-{
-       ipc_port_t port;
-       int n;
-
-       n = 0;
-       for (port = (ipc_port_t)first_element(ipc_object_zones[IOT_PORT]);
-            port;
-            port = (ipc_port_t)next_element(ipc_object_zones[IOT_PORT], 
-                                            port))
-               if (ip_kotype(port) == type &&
-                   (!dead || !ip_active(port))) {
-                       if (++n % 5)
-                               printf("0x%x\t", port);
-                       else
-                               printf("0x%x\n", port);
-               }
-       if (n % 5)
-               printf("\n");
-}
-
-void
-print_ports(void)
-{
-       ipc_port_t port;
-       int total_port_count;
-       int space_null_count;
-       int space_kernel_count;
-       int space_reply_count;
-       int space_pager_count;
-       int space_other_count;
-
-       struct {
-               int total_count;
-               int dead_count;
-       } port_types[IKOT_MAX_TYPE];
-
-       total_port_count = 0;
-
-       bzero((char *)&port_types[0], sizeof(port_types));
-       space_null_count = 0;
-       space_kernel_count = 0;
-       space_reply_count = 0;
-       space_pager_count = 0;
-       space_other_count = 0;
-
-       for (port = (ipc_port_t)first_element(ipc_object_zones[IOT_PORT]);
-            port;
-            port = (ipc_port_t)next_element(ipc_object_zones[IOT_PORT], 
-                                            port)) {
-               total_port_count++;
-               if (ip_kotype(port) >= IKOT_MAX_TYPE) {
-                       port_types[IKOT_UNKNOWN].total_count++;
-                       if (!io_active(&port->ip_object))
-                               port_types[IKOT_UNKNOWN].dead_count++;
-               } else {
-                       port_types[ip_kotype(port)].total_count++;
-                       if (!io_active(&port->ip_object))
-                               port_types[ip_kotype(port)].dead_count++;
-               }
-
-               if (!port->ip_receiver)
-                       space_null_count++;
-               else if (port->ip_receiver == ipc_space_kernel)
-                       space_kernel_count++;
-               else if (port->ip_receiver == ipc_space_reply)
-                       space_reply_count++;
-               else if (port->ip_receiver == default_pager_space)
-                       space_pager_count++;
-               else
-                       space_other_count++;
-       }
-       printf("\n%7d   total ports\n\n", total_port_count);
-
-#define PRINT_ONE_PORT_TYPE(name) \
-       printf("%7d     %s", port_types[IKOT_##name].total_count, # name); \
-       if (port_types[IKOT_##name].dead_count) \
-            printf(" (%d dead ports)", port_types[IKOT_##name].dead_count);\
-       printf("\n");
-
-       PRINT_ONE_PORT_TYPE(NONE);
-       PRINT_ONE_PORT_TYPE(THREAD);
-       PRINT_ONE_PORT_TYPE(TASK);
-       PRINT_ONE_PORT_TYPE(HOST);
-       PRINT_ONE_PORT_TYPE(HOST_PRIV);
-       PRINT_ONE_PORT_TYPE(PROCESSOR);
-       PRINT_ONE_PORT_TYPE(PSET);
-       PRINT_ONE_PORT_TYPE(PSET_NAME);
-       PRINT_ONE_PORT_TYPE(TIMER);
-       PRINT_ONE_PORT_TYPE(PAGING_REQUEST);
-       PRINT_ONE_PORT_TYPE(MIG);
-       PRINT_ONE_PORT_TYPE(MEMORY_OBJECT);
-       PRINT_ONE_PORT_TYPE(XMM_PAGER);
-       PRINT_ONE_PORT_TYPE(XMM_KERNEL);
-       PRINT_ONE_PORT_TYPE(XMM_REPLY);
-       PRINT_ONE_PORT_TYPE(UND_REPLY);
-       PRINT_ONE_PORT_TYPE(HOST_NOTIFY);
-       PRINT_ONE_PORT_TYPE(HOST_SECURITY);
-       PRINT_ONE_PORT_TYPE(LEDGER);
-       PRINT_ONE_PORT_TYPE(MASTER_DEVICE);
-       PRINT_ONE_PORT_TYPE(TASK_NAME);
-       PRINT_ONE_PORT_TYPE(SUBSYSTEM);
-       PRINT_ONE_PORT_TYPE(IO_DONE_QUEUE);
-       PRINT_ONE_PORT_TYPE(SEMAPHORE);
-       PRINT_ONE_PORT_TYPE(LOCK_SET);
-       PRINT_ONE_PORT_TYPE(CLOCK);
-       PRINT_ONE_PORT_TYPE(CLOCK_CTRL);
-       PRINT_ONE_PORT_TYPE(IOKIT_SPARE);
-       PRINT_ONE_PORT_TYPE(NAMED_ENTRY);
-       PRINT_ONE_PORT_TYPE(IOKIT_CONNECT);
-       PRINT_ONE_PORT_TYPE(IOKIT_OBJECT);
-       PRINT_ONE_PORT_TYPE(UPL);
-       PRINT_ONE_PORT_TYPE(MEM_OBJ_CONTROL);
-
-       PRINT_ONE_PORT_TYPE(UNKNOWN);
-       printf("\nipc_space:\n\n");
-       printf("NULL    KERNEL  REPLY   PAGER   OTHER\n");
-       printf("%d      %d      %d      %d      %d\n",
-              space_null_count,
-              space_kernel_count,
-              space_reply_count,
-              space_pager_count,
-              space_other_count
-       );
-}
-
-#endif /* ZONE_DEBUG */
-
-
-/*
- *     Print out all the kmsgs in a queue.  Aggregate kmsgs with
- *     identical message ids into a single entry.  Count up the
- *     amount of inline and out-of-line data consumed by each
- *     and every kmsg.
- *
- */
-
-#define        KMSG_MATCH_FIELD(kmsg)  (kmsg->ikm_header->msgh_id)
-#define        DKQP_LONG(kmsg) FALSE
-const char     *dkqp_long_format = "(%3d) <%10d> 0x%x   %10d %10d\n";
-const char     *dkqp_format = "(%3d) <%10d> 0x%x   %10d %10d\n";
-
-int
-db_kmsg_queue_print(
-       ipc_kmsg_t      kmsg);
-int
-db_kmsg_queue_print(
-       ipc_kmsg_t      kmsg)
-{
-       ipc_kmsg_t      ikmsg, first_kmsg;
-       register int    icount;
-       mach_msg_id_t   cur_id;
-       unsigned int    inline_total, ool_total;
-       int             nmsgs;
-
-       iprintf("Count      msgh_id  kmsg addr inline bytes   ool bytes\n");
-       inline_total = ool_total = (vm_size_t) 0;
-       cur_id = KMSG_MATCH_FIELD(kmsg);
-       for (icount = 0, nmsgs = 0, first_kmsg = ikmsg = kmsg;
-            kmsg != IKM_NULL && (kmsg != first_kmsg || nmsgs == 0);
-            kmsg = kmsg->ikm_next) {
-               ++nmsgs;
-               if (!(KMSG_MATCH_FIELD(kmsg) == cur_id)) {
-                       iprintf(DKQP_LONG(kmsg) ? dkqp_long_format:dkqp_format,
-                               icount, cur_id, ikmsg, inline_total,ool_total);
-                       cur_id = KMSG_MATCH_FIELD(kmsg);
-                       icount = 1;
-                       ikmsg = kmsg;
-                       inline_total = ool_total = 0;
-               } else {
-                       icount++;
-               }
-               if (DKQP_LONG(kmsg))
-                       inline_total += kmsg->ikm_size;
-               else
-                       inline_total += kmsg->ikm_header->msgh_size;
-       }
-       iprintf(DKQP_LONG(kmsg) ? dkqp_long_format : dkqp_format,
-               icount, cur_id, ikmsg, inline_total, ool_total);
-       return nmsgs;
-}
-
-
-/*
- *     Process all of the messages on a port - prints out the
- *     number of occurences of each message type, and the first
- *     kmsg with a particular msgh_id.
- */
-int
-db_port_queue_print(
-       ipc_port_t      port)
-{
-       ipc_kmsg_t      kmsg;
-
-       if (ipc_kmsg_queue_empty(&port->ip_messages.imq_messages))
-               return 0;
-       kmsg = ipc_kmsg_queue_first(&port->ip_messages.imq_messages);
-       return db_kmsg_queue_print(kmsg);
-}
-
-
-#if    MACH_ASSERT
-#include <ddb/db_sym.h>
-#include <ddb/db_access.h>
-
-#define        FUNC_NULL       ((void (*)) 0)
-#define        MAX_REFS        5               /* bins for tracking ref counts */
-
-/*
- *     Translate port's cache of call stack pointers
- *     into symbolic names.
- */
-void
-db_port_stack_trace(
-       ipc_port_t      port)
-{
-       unsigned int    i;
-
-       for (i = 0; i < IP_CALLSTACK_MAX; ++i) {
-               iprintf("[%d] 0x%x\t", i, port->ip_callstack[i]);
-               if (port->ip_callstack[i] != 0 &&
-                   DB_VALID_KERN_ADDR(port->ip_callstack[i]))
-                       db_printsym(port->ip_callstack[i], DB_STGY_PROC);
-               printf("\n");
-       }
-}
-
-
-typedef struct port_item {
-       unsigned long   item;
-       unsigned long   count;
-} port_item;
-
-
-#define        ITEM_MAX        400
-typedef struct port_track {
-       const char      *name;
-       unsigned long   max;
-       unsigned long   warning;
-       port_item       items[ITEM_MAX];
-} port_track;
-
-port_track     port_callers;           /* match against calling addresses */
-port_track     port_threads;           /* match against allocating threads */
-port_track     port_spaces;            /* match against ipc spaces */
-
-void           port_track_init(
-                       port_track      *trackp,
-                       const char      *name);
-void           port_item_add(
-                       port_track      *trackp,
-                       unsigned long   item);
-void           port_track_sort(
-                       port_track      *trackp);
-void           port_track_print(
-                       port_track      *trackp,
-                       void            (*func)(port_item *));
-void           port_callers_print(
-                       port_item       *p);
-
-void
-port_track_init(
-       port_track      *trackp,
-       const char      *name)
-{
-       port_item       *i;
-
-       trackp->max = trackp->warning = 0;
-       trackp->name = name;
-       for (i = trackp->items; i < trackp->items + ITEM_MAX; ++i)
-               i->item = i->count = 0;
-}
-
-
-void
-port_item_add(
-       port_track      *trackp,
-       unsigned long   item)
-{
-       port_item       *limit, *i;
-
-       limit = trackp->items + trackp->max;
-       for (i = trackp->items; i < limit; ++i)
-               if (i->item == item) {
-                       i->count++;
-                       return;
-               }
-       if (trackp->max >= ITEM_MAX) {
-               if (trackp->warning++ == 0)
-                       iprintf("%s:  no room\n", trackp->name);
-               return;
-       }
-       i->item = item;
-       i->count = 1;
-       trackp->max++;
-}
-
-
-/*
- *     Simple (and slow) bubble sort.
- */
-void
-port_track_sort(
-       port_track      *trackp)
-{
-       port_item       *limit, *p;
-       port_item       temp;
-       boolean_t       unsorted;
-
-       limit = trackp->items + trackp->max - 1;
-       do {
-               unsorted = FALSE;
-               for (p = trackp->items; p < limit - 1; ++p) {
-                       if (p->count < (p+1)->count) {
-                               temp = *p;
-                               *p = *(p+1);
-                               *(p+1) = temp;
-                               unsorted = TRUE;
-                       }
-               }
-       } while (unsorted == TRUE);
-}
-
-
-void
-port_track_print(
-       port_track      *trackp,
-       void            (*func)(port_item *))
-{
-       port_item       *limit, *p;
-
-       limit = trackp->items + trackp->max;
-       iprintf("%s:\n", trackp->name);
-       for (p = trackp->items; p < limit; ++p) {
-               if (func != FUNC_NULL)
-                       (*func)(p);
-               else
-                       iprintf("0x%x\t%8d\n", p->item, p->count);
-       }
-}
-
-
-void
-port_callers_print(
-       port_item       *p)
-{
-       iprintf("0x%x\t%8d\t", p->item, p->count);
-       db_printsym(p->item, DB_STGY_PROC);
-       printf("\n");
-}
-
-
-/*
- *     Show all ports with a given reference count.
- */
-void
-db_ref(
-       int             refs)
-{
-       db_port_walk(1, 1, 1, refs);
-}
-
-
-/*
- *     Examine all currently allocated ports.
- *     Options:
- *             verbose         display suspicious ports
- *             display         print out each port encountered
- *             ref_search      restrict examination to ports with
- *                             a specified reference count
- *             ref_target      reference count for ref_search
- */
-int
-db_port_walk(
-       unsigned int    verbose,
-       unsigned int    display,
-       unsigned int    ref_search,
-       unsigned int    ref_target)
-{
-       ipc_port_t      port;
-       unsigned int    ref_overflow, refs, i, ref_inactive_overflow;
-       unsigned int    no_receiver, no_match;
-       unsigned int    ref_counts[MAX_REFS];
-       unsigned int    inactive[MAX_REFS];
-       unsigned int    ipc_ports = 0;
-
-       iprintf("Allocated port count is %d\n", port_count);
-       no_receiver = no_match = ref_overflow = 0;
-       ref_inactive_overflow = 0;
-       for (i = 0; i < MAX_REFS; ++i) {
-               ref_counts[i] = 0;
-               inactive[i] = 0;
-       }
-       port_track_init(&port_callers, "port callers");
-       port_track_init(&port_threads, "port threads");
-       port_track_init(&port_spaces, "port spaces");
-       if (ref_search)
-               iprintf("Walking ports of ref_count=%d.\n", ref_target);
-       else
-               iprintf("Walking all ports.\n");
-
-       queue_iterate(&port_alloc_queue, port, ipc_port_t, ip_port_links) {
-               const char *port_type;
-
-               port_type = " IPC port";
-               if (ip_active(port))
-                 ipc_ports++;
-
-               refs = port->ip_references;
-               if (ref_search && refs != ref_target)
-                       continue;
-
-               if (refs >= MAX_REFS) {
-                       if (ip_active(port))
-                               ++ref_overflow;
-                       else
-                               ++ref_inactive_overflow;
-               } else {
-                       if (refs == 0 && verbose)
-                               iprintf("%s 0x%x has ref count of zero!\n",
-                                       port_type, port);
-                       if (ip_active(port))
-                               ref_counts[refs]++;
-                       else
-                               inactive[refs]++;
-               }
-               port_item_add(&port_threads, (unsigned long) port->ip_thread);
-               for (i = 0; i < IP_CALLSTACK_MAX; ++i) {
-                       if (port->ip_callstack[i] != 0 &&
-                           DB_VALID_KERN_ADDR(port->ip_callstack[i]))
-                               port_item_add(&port_callers,
-                                             port->ip_callstack[i]);
-               }
-               if (!ip_active(port)) {
-                       if (verbose)
-                               iprintf("%s 0x%x, inactive, refcnt %d\n",
-                                       port_type, port, refs);
-                       continue;
-               }
-
-               if (port->ip_receiver_name == MACH_PORT_NULL) {
-                       iprintf("%s  0x%x, no receiver, refcnt %d\n",
-                               port, refs);
-                       ++no_receiver;
-                       continue;
-               }
-               if (port->ip_receiver == ipc_space_kernel ||
-                   port->ip_receiver == ipc_space_reply ||
-                   ipc_entry_lookup(port->ip_receiver,
-                                       port->ip_receiver_name) 
-                                       != IE_NULL) {
-                       port_item_add(&port_spaces,
-                                     (unsigned long)port->ip_receiver);
-                       if (display) {
-                               iprintf( "%s 0x%x time 0x%x ref_cnt %d\n",
-                                               port_type, port,
-                                               port->ip_timetrack, refs);
-                       }
-                       continue;
-               }
-               iprintf("%s 0x%x, rcvr 0x%x, name 0x%x, ref %d, no match\n",
-                               port_type, port, port->ip_receiver,
-                               port->ip_receiver_name, refs);
-               ++no_match;
-       }
-       iprintf("Active port type summary:\n");
-       iprintf("\tlocal  IPC %6d\n", ipc_ports);
-       iprintf("summary:\tcallers %d threads %d spaces %d\n",
-               port_callers.max, port_threads.max, port_spaces.max);
-
-       iprintf("\tref_counts:\n");
-       for (i = 0; i < MAX_REFS; ++i)
-               iprintf("\t  ref_counts[%d] = %d\n", i, ref_counts[i]);
-
-       iprintf("\t%d ports w/o receivers, %d w/o matches\n",
-               no_receiver, no_match);
-
-       iprintf("\tinactives:");
-       if ( ref_inactive_overflow || inactive[0] || inactive[1] ||
-            inactive[2] || inactive[3] || inactive[4] )
-               printf(" [0]=%d [1]=%d [2]=%d [3]=%d [4]=%d [5+]=%d\n",
-                       inactive[0], inactive[1], inactive[2],
-                       inactive[3], inactive[4], ref_inactive_overflow);
-       else
-               printf(" No inactive ports.\n");
-
-       port_track_sort(&port_spaces);
-       port_track_print(&port_spaces, FUNC_NULL);
-       port_track_sort(&port_threads);
-       port_track_print(&port_threads, FUNC_NULL);
-       port_track_sort(&port_callers);
-       port_track_print(&port_callers, port_callers_print);
-       return 0;
-}
-
-
-#endif /* MACH_ASSERT */
-
-#endif /* MACH_KDB */