#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 <kern/lock.h>
#include <kern/ipc_kobject.h>
#include <kern/thread.h>
#include <kern/misc_protos.h>
#include <kern/wait_queue.h>
#include <ipc/ipc_entry.h>
#include <ipc/ipc_space.h>
#include <ipc/ipc_object.h>
#include <ipc/ipc_port.h>
#include <ipc/ipc_pset.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>
#if MACH_KDB
#include <machine/db_machdep.h>
#include <ddb/db_command.h>
#include <ddb/db_expr.h>
#endif
#include <string.h>
decl_mutex_data(, ipc_port_multiple_lock_data)
decl_mutex_data(, ipc_port_timestamp_lock_data)
ipc_port_timestamp_t ipc_port_timestamp_data;
#if MACH_ASSERT
void ipc_port_init_debug(
ipc_port_t port);
#endif
#if MACH_KDB && ZONE_DEBUG
void print_type_ports(unsigned, unsigned);
void print_ports(void);
#endif
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;
}
kern_return_t
ipc_port_dnrequest(
ipc_port_t port,
mach_port_name_t name,
ipc_port_t soright,
ipc_port_request_index_t *indexp)
{
ipc_port_request_t ipr, table;
ipc_port_request_index_t index;
assert(ip_active(port));
assert(name != MACH_PORT_NULL);
assert(soright != IP_NULL);
table = port->ip_dnrequests;
if (table == IPR_NULL)
return KERN_NO_SPACE;
index = table->ipr_next;
if (index == 0)
return KERN_NO_SPACE;
ipr = &table[index];
assert(ipr->ipr_name == MACH_PORT_NULL);
table->ipr_next = ipr->ipr_next;
ipr->ipr_name = name;
ipr->ipr_soright = soright;
*indexp = index;
return KERN_SUCCESS;
}
kern_return_t
ipc_port_dngrow(
ipc_port_t port,
int target_size)
{
ipc_table_size_t its;
ipc_port_request_t otable, ntable;
assert(ip_active(port));
otable = port->ip_dnrequests;
if (otable == IPR_NULL)
its = &ipc_table_dnrequests[0];
else
its = otable->ipr_size + 1;
if (target_size != ITS_SIZE_NONE) {
if ((otable != IPR_NULL) &&
(target_size <= otable->ipr_size->its_size)) {
ip_unlock(port);
return KERN_SUCCESS;
}
while ((its->its_size) && (its->its_size < target_size)) {
its++;
}
if (its->its_size == 0) {
ip_unlock(port);
return KERN_NO_SPACE;
}
}
ip_reference(port);
ip_unlock(port);
if ((its->its_size == 0) ||
((ntable = it_dnrequests_alloc(its)) == IPR_NULL)) {
ipc_port_release(port);
return KERN_RESOURCE_SHORTAGE;
}
ip_lock(port);
ip_release(port);
if (ip_active(port) &&
(port->ip_dnrequests == otable) &&
((otable == IPR_NULL) || (otable->ipr_size+1 == its))) {
ipc_table_size_t oits;
ipc_table_elems_t osize, nsize;
ipc_port_request_index_t free, i;
if (otable != IPR_NULL) {
oits = otable->ipr_size;
osize = oits->its_size;
free = otable->ipr_next;
(void) memcpy((void *)(ntable + 1),
(const void *)(otable + 1),
(osize - 1) * sizeof(struct ipc_port_request));
} else {
osize = 1;
free = 0;
}
nsize = its->its_size;
assert(nsize > osize);
for (i = osize; i < nsize; i++) {
ipc_port_request_t ipr = &ntable[i];
ipr->ipr_name = MACH_PORT_NULL;
ipr->ipr_next = free;
free = i;
}
ntable->ipr_next = free;
ntable->ipr_size = its;
port->ip_dnrequests = ntable;
ip_unlock(port);
if (otable != IPR_NULL) {
it_dnrequests_free(oits, otable);
}
} else {
ip_check_unlock(port);
it_dnrequests_free(its, ntable);
}
return KERN_SUCCESS;
}
ipc_port_t
ipc_port_dncancel(
ipc_port_t port,
mach_port_name_t name,
ipc_port_request_index_t index)
{
ipc_port_request_t ipr, table;
ipc_port_t dnrequest;
assert(ip_active(port));
assert(name != MACH_PORT_NULL);
assert(index != 0);
table = port->ip_dnrequests;
assert(table != IPR_NULL);
ipr = &table[index];
dnrequest = ipr->ipr_soright;
assert(ipr->ipr_name == name);
ipr->ipr_name = MACH_PORT_NULL;
ipr->ipr_next = table->ipr_next;
table->ipr_next = index;
return dnrequest;
}
void
ipc_port_pdrequest(
ipc_port_t port,
ipc_port_t notify,
ipc_port_t *previousp)
{
ipc_port_t previous;
assert(ip_active(port));
previous = port->ip_pdrequest;
port->ip_pdrequest = notify;
ip_unlock(port);
*previousp = previous;
}
void
ipc_port_nsrequest(
ipc_port_t port,
mach_port_mscount_t sync,
ipc_port_t notify,
ipc_port_t *previousp)
{
ipc_port_t previous;
mach_port_mscount_t mscount;
assert(ip_active(port));
previous = port->ip_nsrequest;
mscount = port->ip_mscount;
if ((port->ip_srights == 0) && (sync <= mscount) &&
(notify != IP_NULL)) {
port->ip_nsrequest = IP_NULL;
ip_unlock(port);
ipc_notify_no_senders(notify, mscount);
} else {
port->ip_nsrequest = notify;
ip_unlock(port);
}
*previousp = previous;
}
void
ipc_port_clear_receiver(
ipc_port_t port)
{
spl_t s;
assert(ip_active(port));
if (port->ip_pset_count != 0) {
ipc_pset_remove_from_all(port);
assert(port->ip_pset_count == 0);
}
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_unlock(&port->ip_messages);
splx(s);
}
void
ipc_port_init(
ipc_port_t port,
ipc_space_t space,
mach_port_name_t name)
{
port->ip_receiver = space;
port->ip_receiver_name = name;
port->ip_mscount = 0;
port->ip_srights = 0;
port->ip_sorights = 0;
port->ip_nsrequest = IP_NULL;
port->ip_pdrequest = IP_NULL;
port->ip_dnrequests = IPR_NULL;
port->ip_pset_count = 0;
port->ip_premsg = IKM_NULL;
#if MACH_ASSERT
ipc_port_init_debug(port);
#endif
ipc_mqueue_init(&port->ip_messages, FALSE );
}
kern_return_t
ipc_port_alloc(
ipc_space_t space,
mach_port_name_t *namep,
ipc_port_t *portp)
{
ipc_port_t port;
mach_port_name_t name;
kern_return_t kr;
kr = ipc_object_alloc(space, IOT_PORT,
MACH_PORT_TYPE_RECEIVE, 0,
&name, (ipc_object_t *) &port);
if (kr != KERN_SUCCESS)
return kr;
ipc_port_init(port, space, name);
if (task_is_classic(current_task())) {
IP_SET_CLASSIC(port);
}
*namep = name;
*portp = port;
return KERN_SUCCESS;
}
kern_return_t
ipc_port_alloc_name(
ipc_space_t space,
mach_port_name_t name,
ipc_port_t *portp)
{
ipc_port_t port;
kern_return_t kr;
kr = ipc_object_alloc_name(space, IOT_PORT,
MACH_PORT_TYPE_RECEIVE, 0,
name, (ipc_object_t *) &port);
if (kr != KERN_SUCCESS)
return kr;
ipc_port_init(port, space, name);
if (task_is_classic(current_task())) {
IP_SET_CLASSIC(port);
}
*portp = port;
return KERN_SUCCESS;
}
void
ipc_port_dnnotify(
ipc_port_t port,
ipc_port_request_t dnrequests)
{
ipc_table_size_t its = dnrequests->ipr_size;
ipc_table_elems_t size = its->its_size;
ipc_port_request_index_t index;
for (index = 1; index < size; index++) {
ipc_port_request_t ipr = &dnrequests[index];
mach_port_name_t name = ipr->ipr_name;
ipc_port_t soright;
if (name == MACH_PORT_NULL)
continue;
soright = ipr->ipr_soright;
assert(soright != IP_NULL);
ipc_notify_dead_name(soright, name);
}
it_dnrequests_free(its, dnrequests);
}
void
ipc_port_destroy(
ipc_port_t port)
{
ipc_port_t pdrequest, nsrequest;
ipc_mqueue_t mqueue;
ipc_kmsg_queue_t kmqueue;
ipc_kmsg_t kmsg;
ipc_port_request_t dnrequests;
assert(ip_active(port));
assert(port->ip_pset_count == 0);
assert(port->ip_mscount == 0);
pdrequest = port->ip_pdrequest;
if (pdrequest != IP_NULL) {
port->ip_pdrequest = IP_NULL;
port->ip_receiver_name = MACH_PORT_NULL;
port->ip_destination = IP_NULL;
ip_unlock(port);
ipc_notify_port_destroyed(pdrequest, port);
return;
}
port->ip_object.io_bits &= ~IO_BITS_ACTIVE;
port->ip_timestamp = ipc_port_timestamp();
dnrequests = port->ip_dnrequests;
port->ip_dnrequests = IPR_NULL;
if (IP_PREALLOC(port)) {
kmsg = port->ip_premsg;
assert(kmsg != IKM_NULL);
IP_CLEAR_PREALLOC(port, kmsg);
if (!ikm_prealloc_inuse(kmsg))
ipc_kmsg_free(kmsg);
}
ip_unlock(port);
nsrequest = port->ip_nsrequest;
if (nsrequest != IP_NULL)
ipc_notify_send_once(nsrequest);
mqueue = &port->ip_messages;
ipc_mqueue_destroy(mqueue);
if (dnrequests != IPR_NULL) {
ipc_port_dnnotify(port, dnrequests);
}
ipc_kobject_destroy(port);
ipc_port_release(port);
}
boolean_t
ipc_port_check_circularity(
ipc_port_t port,
ipc_port_t dest)
{
ipc_port_t base;
assert(port != IP_NULL);
assert(dest != IP_NULL);
if (port == dest)
return TRUE;
base = dest;
ip_lock(port);
if (ip_lock_try(dest)) {
if (!ip_active(dest) ||
(dest->ip_receiver_name != MACH_PORT_NULL) ||
(dest->ip_destination == IP_NULL))
goto not_circular;
ip_unlock(dest);
}
ip_unlock(port);
ipc_port_multiple_lock();
for (;;) {
ip_lock(base);
if (!ip_active(base) ||
(base->ip_receiver_name != MACH_PORT_NULL) ||
(base->ip_destination == IP_NULL))
break;
base = base->ip_destination;
}
if (port == base) {
ipc_port_multiple_unlock();
assert(ip_active(port));
assert(port->ip_receiver_name == MACH_PORT_NULL);
assert(port->ip_destination == IP_NULL);
while (dest != IP_NULL) {
ipc_port_t next;
assert(ip_active(dest));
assert(dest->ip_receiver_name == MACH_PORT_NULL);
next = dest->ip_destination;
ip_unlock(dest);
dest = next;
}
return TRUE;
}
ip_lock(port);
ipc_port_multiple_unlock();
not_circular:
assert(ip_active(port));
assert(port->ip_receiver_name == MACH_PORT_NULL);
assert(port->ip_destination == IP_NULL);
ip_reference(dest);
port->ip_destination = dest;
while (port != base) {
ipc_port_t next;
assert(ip_active(port));
assert(port->ip_receiver_name == MACH_PORT_NULL);
assert(port->ip_destination != IP_NULL);
next = port->ip_destination;
ip_unlock(port);
port = next;
}
assert(!ip_active(base) ||
(base->ip_receiver_name != MACH_PORT_NULL) ||
(base->ip_destination == IP_NULL));
ip_unlock(base);
return FALSE;
}
ipc_port_t
ipc_port_lookup_notify(
ipc_space_t space,
mach_port_name_t name)
{
ipc_port_t port;
ipc_entry_t entry;
assert(space->is_active);
entry = ipc_entry_lookup(space, name);
if (entry == IE_NULL)
return IP_NULL;
if ((entry->ie_bits & MACH_PORT_TYPE_RECEIVE) == 0)
return IP_NULL;
port = (ipc_port_t) entry->ie_object;
assert(port != IP_NULL);
ip_lock(port);
assert(ip_active(port));
assert(port->ip_receiver_name == name);
assert(port->ip_receiver == space);
ip_reference(port);
port->ip_sorights++;
ip_unlock(port);
return port;
}
ipc_port_t
ipc_port_make_send_locked(
ipc_port_t port)
{
assert(ip_active(port));
port->ip_mscount++;
port->ip_srights++;
ip_reference(port);
ip_unlock(port);
return port;
}
ipc_port_t
ipc_port_make_send(
ipc_port_t port)
{
if (!IP_VALID(port))
return port;
ip_lock(port);
if (ip_active(port)) {
port->ip_mscount++;
port->ip_srights++;
ip_reference(port);
ip_unlock(port);
return port;
}
ip_unlock(port);
return IP_DEAD;
}
ipc_port_t
ipc_port_copy_send(
ipc_port_t port)
{
ipc_port_t sright;
if (!IP_VALID(port))
return port;
ip_lock(port);
if (ip_active(port)) {
assert(port->ip_srights > 0);
ip_reference(port);
port->ip_srights++;
sright = port;
} else
sright = IP_DEAD;
ip_unlock(port);
return sright;
}
mach_port_name_t
ipc_port_copyout_send(
ipc_port_t sright,
ipc_space_t space)
{
mach_port_name_t name;
if (IP_VALID(sright)) {
kern_return_t kr;
kr = ipc_object_copyout(space, (ipc_object_t) sright,
MACH_MSG_TYPE_PORT_SEND, TRUE, &name);
if (kr != KERN_SUCCESS) {
ipc_port_release_send(sright);
if (kr == KERN_INVALID_CAPABILITY)
name = MACH_PORT_DEAD;
else
name = MACH_PORT_NULL;
}
} else
name = (mach_port_name_t) sright;
return name;
}
void
ipc_port_release_send(
ipc_port_t port)
{
ipc_port_t nsrequest = IP_NULL;
mach_port_mscount_t mscount;
assert(IP_VALID(port));
ip_lock(port);
ip_release(port);
if (!ip_active(port)) {
ip_check_unlock(port);
return;
}
assert(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);
ipc_notify_no_senders(nsrequest, mscount);
check_simple_locks();
} else
ip_unlock(port);
}
ipc_port_t
ipc_port_make_sonce(
ipc_port_t port)
{
assert(IP_VALID(port));
ip_lock(port);
assert(ip_active(port));
port->ip_sorights++;
ip_reference(port);
ip_unlock(port);
return port;
}
void
ipc_port_release_sonce(
ipc_port_t port)
{
assert(IP_VALID(port));
ip_lock(port);
assert(port->ip_sorights > 0);
port->ip_sorights--;
ip_release(port);
if (!ip_active(port)) {
ip_check_unlock(port);
return;
}
ip_unlock(port);
}
void
ipc_port_release_receive(
ipc_port_t port)
{
ipc_port_t dest;
assert(IP_VALID(port));
ip_lock(port);
assert(ip_active(port));
assert(port->ip_receiver_name == MACH_PORT_NULL);
dest = port->ip_destination;
ipc_port_destroy(port);
if (dest != IP_NULL)
ipc_port_release(dest);
}
ipc_port_t
ipc_port_alloc_special(
ipc_space_t space)
{
ipc_port_t port;
port = (ipc_port_t) io_alloc(IOT_PORT);
if (port == IP_NULL)
return IP_NULL;
bzero((char *)port, sizeof(*port));
io_lock_init(&port->ip_object);
port->ip_references = 1;
port->ip_object.io_bits = io_makebits(TRUE, IOT_PORT, 0);
ipc_port_init(port, space, 1);
return port;
}
void
ipc_port_dealloc_special(
ipc_port_t port,
ipc_space_t space)
{
ip_lock(port);
assert(ip_active(port));
assert(port->ip_receiver == space);
port->ip_receiver_name = MACH_PORT_NULL;
port->ip_receiver = IS_NULL;
ipc_port_set_mscount(port, 0);
port->ip_messages.imq_seqno = 0;
ipc_port_destroy(port);
}
#if MACH_ASSERT
queue_head_t port_alloc_queue;
decl_mutex_data(,port_alloc_queue_lock)
unsigned long port_count = 0;
unsigned long port_count_warning = 20000;
unsigned long port_timestamp = 0;
void db_port_stack_trace(
ipc_port_t port);
void db_ref(
int refs);
int db_port_walk(
unsigned int verbose,
unsigned int display,
unsigned int ref_search,
unsigned int ref_target);
void
ipc_port_debug_init(void)
{
queue_init(&port_alloc_queue);
mutex_init(&port_alloc_queue_lock, ETAP_IPC_PORT_ALLOCQ);
}
void
ipc_port_init_debug(
ipc_port_t port)
{
unsigned int i;
port->ip_thread = (unsigned long) current_thread();
port->ip_timetrack = port_timestamp++;
for (i = 0; i < IP_CALLSTACK_MAX; ++i)
port->ip_callstack[i] = 0;
for (i = 0; i < IP_NSPARES; ++i)
port->ip_spares[i] = 0;
machine_callstack(&port->ip_callstack[0], IP_CALLSTACK_MAX);
#if 0
mutex_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);
mutex_unlock(&port_alloc_queue_lock);
#endif
}
void
ipc_port_track_dealloc(
ipc_port_t port)
{
#if 0
mutex_lock(&port_alloc_queue_lock);
assert(port_count > 0);
--port_count;
queue_remove(&port_alloc_queue, port, ipc_port_t, ip_port_links);
mutex_unlock(&port_alloc_queue_lock);
#endif
}
#endif
#if MACH_KDB
#include <ddb/db_output.h>
#include <ddb/db_print.h>
#define printf kdbprintf
extern int db_indent;
int
db_port_queue_print(
ipc_port_t port);
static void ipc_entry_print(struct ipc_entry *, char *);
static void ipc_entry_print(struct ipc_entry *iep, char *tag)
{
ipc_entry_bits_t bits = iep->ie_bits;
iprintf("%s @", tag);
printf(" 0x%x, bits=%x object=%x\n", iep, bits, iep->ie_object);
db_indent += 2;
iprintf("urefs=%x ", IE_BITS_UREFS(bits));
printf("type=%x gen=%x\n", IE_BITS_TYPE(bits), IE_BITS_GEN(bits));
db_indent -= 2;
}
int ipc_port_print_long = 0;
void
ipc_port_print(
ipc_port_t port,
boolean_t have_addr,
db_expr_t count,
char *modif)
{
extern int db_indent;
db_addr_t task;
int task_id;
int nmsgs;
int verbose = 0;
#if MACH_ASSERT
int i, needs_db_indent, items_printed;
#endif
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))
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(", dnrequests=0x%x\n", port->ip_dnrequests);
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
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
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],
(vm_offset_t)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],
(vm_offset_t)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(PAGING_REQUEST);
PRINT_ONE_PORT_TYPE(MEMORY_OBJECT);
PRINT_ONE_PORT_TYPE(MIG);
PRINT_ONE_PORT_TYPE(XMM_PAGER);
PRINT_ONE_PORT_TYPE(XMM_KERNEL);
PRINT_ONE_PORT_TYPE(XMM_REPLY);
PRINT_ONE_PORT_TYPE(CLOCK);
PRINT_ONE_PORT_TYPE(CLOCK_CTRL);
PRINT_ONE_PORT_TYPE(MASTER_DEVICE);
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
#define KMSG_MATCH_FIELD(kmsg) ((unsigned int) kmsg->ikm_header.msgh_id)
#define DKQP_LONG(kmsg) FALSE
char *dkqp_long_format = "(%3d) <%10d> 0x%x %10d %10d\n";
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;
}
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
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 {
char *name;
unsigned long max;
unsigned long warning;
port_item items[ITEM_MAX];
} port_track;
port_track port_callers;
port_track port_threads;
port_track port_spaces;
void port_track_init(
port_track *trackp,
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,
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++;
}
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");
}
void
db_ref(
int refs)
{
db_port_walk(1, 1, 1, refs);
}
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;
unsigned int proxies = 0, principals = 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) {
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
#endif