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

/*
 * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 */
/* 
 * Mach Operating System
 * Copyright (c) 1991,1990 Carnegie Mellon University
 * All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this software and its
 * documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 * 
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 * 
 * Carnegie Mellon requests users of this software to return to
 * 
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 * 
 * any improvements or extensions that they make and grant Carnegie Mellon
 * the rights to redistribute these changes.
 */
/*
 */
/*
 *	File:	ipc/mach_debug.c
 *	Author:	Rich Draves
 *	Date:	1989
 *
 *	Exported IPC debug calls.
 */
#include <mach_ipc_debug.h>

#include <mach/vm_param.h>
#include <mach/kern_return.h>
#include <mach/machine/vm_types.h>
#include <mach/mach_host_server.h>
#include <mach/mach_port_server.h>
#include <mach_debug/ipc_info.h>
#include <mach_debug/hash_info.h>

#if MACH_IPC_DEBUG
#include <kern/host.h>
#include <kern/misc_protos.h>
#include <vm/vm_map.h>
#include <vm/vm_kern.h>
#include <ipc/port.h>
#include <ipc/ipc_types.h>
#include <ipc/ipc_space.h>
#include <ipc/ipc_port.h>
#include <ipc/ipc_hash.h>
#include <ipc/ipc_table.h>
#include <ipc/ipc_right.h>
#endif

/*
 *	Routine:	mach_port_get_srights [kernel call]
 *	Purpose:
 *		Retrieve the number of extant send rights
 *		that a receive right has.
 *	Conditions:
 *		Nothing locked.
 *	Returns:
 *		KERN_SUCCESS		Retrieved number of send rights.
 *		KERN_INVALID_TASK	The space is null.
 *		KERN_INVALID_TASK	The space is dead.
 *		KERN_INVALID_NAME	The name doesn't denote a right.
 *		KERN_INVALID_RIGHT	Name doesn't denote receive rights.
 */

#if !MACH_IPC_DEBUG
kern_return_t
mach_port_get_srights(
	__unused ipc_space_t		space,
	__unused mach_port_name_t	name,
	__unused mach_port_rights_t	*srightsp)
{
        return KERN_FAILURE;
}
#else
kern_return_t
mach_port_get_srights(
	ipc_space_t		space,
	mach_port_name_t	name,
	mach_port_rights_t	*srightsp)
{
	ipc_port_t port;
	kern_return_t kr;
	mach_port_rights_t srights;

	if (space == IS_NULL)
		return KERN_INVALID_TASK;

	kr = ipc_port_translate_receive(space, name, &port);
	if (kr != KERN_SUCCESS)
		return kr;
	/* port is locked and active */

	srights = port->ip_srights;
	ip_unlock(port);

	*srightsp = srights;
	return KERN_SUCCESS;
}
#endif /* MACH_IPC_DEBUG */

/*
 *	Routine:	host_ipc_hash_info
 *	Purpose:
 *		Return information about the global reverse hash table.
 *	Conditions:
 *		Nothing locked.  Obeys CountInOut protocol.
 *	Returns:
 *		KERN_SUCCESS		Returned information.
 *		KERN_INVALID_HOST	The host is null.
 *		KERN_RESOURCE_SHORTAGE	Couldn't allocate memory.
 */

#if !MACH_IPC_DEBUG
kern_return_t
host_ipc_hash_info(
	__unused host_t			host,
	__unused hash_info_bucket_array_t	*infop,
	__unused mach_msg_type_number_t 	*countp)
{
        return KERN_FAILURE;
}
#else
kern_return_t
host_ipc_hash_info(
	host_t					host,
	hash_info_bucket_array_t		*infop,
	mach_msg_type_number_t 		*countp)
{
	vm_offset_t addr;
	vm_size_t size = 0;
	hash_info_bucket_t *info;
	unsigned int potential, actual;
	kern_return_t kr;

	if (host == HOST_NULL)
		return KERN_INVALID_HOST;

	/* start with in-line data */

	info = *infop;
	potential = *countp;

	for (;;) {
		actual = ipc_hash_info(info, potential);
		if (actual <= potential)
			break;

		/* allocate more memory */

		if (info != *infop)
			kmem_free(ipc_kernel_map, addr, size);

		size = round_page(actual * sizeof *info);
		kr = kmem_alloc_pageable(ipc_kernel_map, &addr, size);
		if (kr != KERN_SUCCESS)
			return KERN_RESOURCE_SHORTAGE;

		info = (hash_info_bucket_t *) addr;
		potential = size/sizeof *info;
	}

	if (info == *infop) {
		/* data fit in-line; nothing to deallocate */

		*countp = actual;
	} else if (actual == 0) {
		kmem_free(ipc_kernel_map, addr, size);

		*countp = 0;
	} else {
		vm_map_copy_t copy;
		vm_size_t used;

		used = round_page(actual * sizeof *info);

		if (used != size)
			kmem_free(ipc_kernel_map, addr + used, size - used);

		kr = vm_map_copyin(ipc_kernel_map, (vm_map_address_t)addr, 
				   (vm_map_size_t)used, TRUE, &copy);
		assert(kr == KERN_SUCCESS);

		*infop = (hash_info_bucket_t *) copy;
		*countp = actual;
	}

	return KERN_SUCCESS;
}
#endif /* MACH_IPC_DEBUG */

/*
 *	Routine:	mach_port_space_info
 *	Purpose:
 *		Returns information about an IPC space.
 *	Conditions:
 *		Nothing locked.  Obeys CountInOut protocol.
 *	Returns:
 *		KERN_SUCCESS		Returned information.
 *		KERN_INVALID_TASK	The space is null.
 *		KERN_INVALID_TASK	The space is dead.
 *		KERN_RESOURCE_SHORTAGE	Couldn't allocate memory.
 */

#if !MACH_IPC_DEBUG
kern_return_t
mach_port_space_info(
	__unused ipc_space_t			space,
	__unused ipc_info_space_t		*infop,
	__unused ipc_info_name_array_t	*tablep,
	__unused mach_msg_type_number_t 	*tableCntp,
	__unused ipc_info_tree_name_array_t *treep,
	__unused mach_msg_type_number_t 	*treeCntp)
{
        return KERN_FAILURE;
}
#else
kern_return_t
mach_port_space_info(
	ipc_space_t				space,
	ipc_info_space_t			*infop,
	ipc_info_name_array_t		*tablep,
	mach_msg_type_number_t 		*tableCntp,
	ipc_info_tree_name_array_t		*treep,
	mach_msg_type_number_t 		*treeCntp)
{
	ipc_info_name_t *table_info;
	unsigned int table_potential, table_actual;
	vm_offset_t table_addr;
	vm_size_t table_size;
	ipc_info_tree_name_t *tree_info;
	unsigned int tree_potential, tree_actual;
	vm_offset_t tree_addr;
	vm_size_t tree_size;
	ipc_tree_entry_t tentry;
	ipc_entry_t table;
	ipc_entry_num_t tsize;
	mach_port_index_t index;
	kern_return_t kr;

	if (space == IS_NULL)
		return KERN_INVALID_TASK;

	/* start with in-line memory */

	table_size = 0;
	table_info = *tablep;
	table_potential = *tableCntp;
	tree_size = 0;
	tree_info = *treep;
	tree_potential = *treeCntp;

	for (;;) {
		is_read_lock(space);
		if (!space->is_active) {
			is_read_unlock(space);
			if (table_info != *tablep)
				kmem_free(ipc_kernel_map,
					  table_addr, table_size);
			if (tree_info != *treep)
				kmem_free(ipc_kernel_map,
					  tree_addr, tree_size);
			return KERN_INVALID_TASK;
		}

		table_actual = space->is_table_size;
		tree_actual = space->is_tree_total;

		if ((table_actual <= table_potential) &&
		    (tree_actual <= tree_potential))
			break;

		is_read_unlock(space);

		if (table_actual > table_potential) {
			if (table_info != *tablep)
				kmem_free(ipc_kernel_map,
					  table_addr, table_size);

			table_size = round_page(table_actual *
						sizeof *table_info);
			kr = kmem_alloc(ipc_kernel_map,
					&table_addr, table_size);
			if (kr != KERN_SUCCESS) {
				if (tree_info != *treep)
					kmem_free(ipc_kernel_map,
						  tree_addr, tree_size);

				return KERN_RESOURCE_SHORTAGE;
			}

			table_info = (ipc_info_name_t *) table_addr;
			table_potential = table_size/sizeof *table_info;
		}

		if (tree_actual > tree_potential) {
			if (tree_info != *treep)
				kmem_free(ipc_kernel_map,
					  tree_addr, tree_size);

			tree_size = round_page(tree_actual *
					       sizeof *tree_info);
			kr = kmem_alloc(ipc_kernel_map,
					&tree_addr, tree_size);
			if (kr != KERN_SUCCESS) {
				if (table_info != *tablep)
					kmem_free(ipc_kernel_map,
						  table_addr, table_size);

				return KERN_RESOURCE_SHORTAGE;
			}

			tree_info = (ipc_info_tree_name_t *) tree_addr;
			tree_potential = tree_size/sizeof *tree_info;
		}
	}
	/* space is read-locked and active; we have enough wired memory */

	infop->iis_genno_mask = MACH_PORT_NGEN(MACH_PORT_DEAD);
	infop->iis_table_size = space->is_table_size;
	infop->iis_table_next = space->is_table_next->its_size;
	infop->iis_tree_size = space->is_tree_total;
	infop->iis_tree_small = space->is_tree_small;
	infop->iis_tree_hash = space->is_tree_hash;

	table = space->is_table;
	tsize = space->is_table_size;

	for (index = 0; index < tsize; index++) {
		ipc_info_name_t *iin = &table_info[index];
		ipc_entry_t entry = &table[index];
		ipc_entry_bits_t bits;

		bits = entry->ie_bits;
		iin->iin_name = MACH_PORT_MAKE(index, IE_BITS_GEN(bits));
		iin->iin_collision = (bits & IE_BITS_COLLISION) ? TRUE : FALSE;
		iin->iin_type = IE_BITS_TYPE(bits);
		iin->iin_urefs = IE_BITS_UREFS(bits);
		iin->iin_object = (vm_offset_t) entry->ie_object;
		iin->iin_next = entry->ie_next;
		iin->iin_hash = entry->ie_index;
	}

	for (tentry = ipc_splay_traverse_start(&space->is_tree), index = 0;
	     tentry != ITE_NULL;
	     tentry = ipc_splay_traverse_next(&space->is_tree, FALSE)) {
		ipc_info_tree_name_t *iitn = &tree_info[index++];
		ipc_info_name_t *iin = &iitn->iitn_name;
		ipc_entry_t entry = &tentry->ite_entry;
		ipc_entry_bits_t bits = entry->ie_bits;

		assert(IE_BITS_TYPE(bits) != MACH_PORT_TYPE_NONE);

		iin->iin_name = tentry->ite_name;
		iin->iin_collision = (bits & IE_BITS_COLLISION) ? TRUE : FALSE;
		iin->iin_type = IE_BITS_TYPE(bits);
		iin->iin_urefs = IE_BITS_UREFS(bits);
		iin->iin_object = (vm_offset_t) entry->ie_object;
		iin->iin_next = entry->ie_next;
		iin->iin_hash = entry->ie_index;

		if (tentry->ite_lchild == ITE_NULL)
			iitn->iitn_lchild = MACH_PORT_NULL;
		else
			iitn->iitn_lchild = tentry->ite_lchild->ite_name;

		if (tentry->ite_rchild == ITE_NULL)
			iitn->iitn_rchild = MACH_PORT_NULL;
		else
			iitn->iitn_rchild = tentry->ite_rchild->ite_name;

	}
	ipc_splay_traverse_finish(&space->is_tree);
	is_read_unlock(space);

	if (table_info == *tablep) {
		/* data fit in-line; nothing to deallocate */

		*tableCntp = table_actual;
	} else if (table_actual == 0) {
		kmem_free(ipc_kernel_map, table_addr, table_size);

		*tableCntp = 0;
	} else {
		vm_size_t size_used, rsize_used;
		vm_map_copy_t copy;

		/* kmem_alloc doesn't zero memory */

		size_used = table_actual * sizeof *table_info;
		rsize_used = round_page(size_used);

		if (rsize_used != table_size)
			kmem_free(ipc_kernel_map,
				  table_addr + rsize_used,
				  table_size - rsize_used);

		if (size_used != rsize_used)
			bzero((char *) (table_addr + size_used),
			      rsize_used - size_used);

		kr = vm_map_unwire(ipc_kernel_map, vm_map_trunc_page(table_addr),
				   vm_map_round_page(table_addr + rsize_used), FALSE);
		assert(kr == KERN_SUCCESS);

		kr = vm_map_copyin(ipc_kernel_map, (vm_map_address_t)table_addr, 
				   (vm_map_size_t)rsize_used, TRUE, &copy);
		assert(kr == KERN_SUCCESS);

		*tablep = (ipc_info_name_t *) copy;
		*tableCntp = table_actual;
	}

	if (tree_info == *treep) {
		/* data fit in-line; nothing to deallocate */

		*treeCntp = tree_actual;
	} else if (tree_actual == 0) {
		kmem_free(ipc_kernel_map, tree_addr, tree_size);

		*treeCntp = 0;
	} else {
		vm_size_t size_used, rsize_used;
		vm_map_copy_t copy;

		/* kmem_alloc doesn't zero memory */

		size_used = tree_actual * sizeof *tree_info;
		rsize_used = round_page(size_used);

		if (rsize_used != tree_size)
			kmem_free(ipc_kernel_map,
				  tree_addr + rsize_used,
				  tree_size - rsize_used);

		if (size_used != rsize_used)
			bzero((char *) (tree_addr + size_used),
			      rsize_used - size_used);

		kr = vm_map_unwire(ipc_kernel_map, vm_map_trunc_page(tree_addr),
				   vm_map_round_page(tree_addr + rsize_used), FALSE);
		assert(kr == KERN_SUCCESS);

		kr = vm_map_copyin(ipc_kernel_map, (vm_map_address_t)tree_addr,
				   (vm_map_size_t)rsize_used, TRUE, &copy);
		assert(kr == KERN_SUCCESS);

		*treep = (ipc_info_tree_name_t *) copy;
		*treeCntp = tree_actual;
	}

	return KERN_SUCCESS;
}
#endif /* MACH_IPC_DEBUG */

/*
 *	Routine:	mach_port_dnrequest_info
 *	Purpose:
 *		Returns information about the dead-name requests
 *		registered with the named receive right.
 *	Conditions:
 *		Nothing locked.
 *	Returns:
 *		KERN_SUCCESS		Retrieved information.
 *		KERN_INVALID_TASK	The space is null.
 *		KERN_INVALID_TASK	The space is dead.
 *		KERN_INVALID_NAME	The name doesn't denote a right.
 *		KERN_INVALID_RIGHT	Name doesn't denote receive rights.
 */

#if !MACH_IPC_DEBUG
kern_return_t
mach_port_dnrequest_info(
	__unused ipc_space_t		space,
	__unused mach_port_name_t	name,
	__unused unsigned int	*totalp,
	__unused unsigned int	*usedp)
{
        return KERN_FAILURE;
}
#else
kern_return_t
mach_port_dnrequest_info(
	ipc_space_t			space,
	mach_port_name_t		name,
	unsigned int			*totalp,
	unsigned int			*usedp)
{
	unsigned int total, used;
	ipc_port_t port;
	kern_return_t kr;

	if (space == IS_NULL)
		return KERN_INVALID_TASK;

	kr = ipc_port_translate_receive(space, name, &port);
	if (kr != KERN_SUCCESS)
		return kr;
	/* port is locked and active */

	if (port->ip_dnrequests == IPR_NULL) {
		total = 0;
		used = 0;
	} else {
		ipc_port_request_t dnrequests = port->ip_dnrequests;
		ipc_port_request_index_t index;

		total = dnrequests->ipr_size->its_size;

		for (index = 1, used = 0;
		     index < total; index++) {
			ipc_port_request_t ipr = &dnrequests[index];

			if (ipr->ipr_name != MACH_PORT_NULL)
				used++;
		}
	}
	ip_unlock(port);

	*totalp = total;
	*usedp = used;
	return KERN_SUCCESS;
}
#endif /* MACH_IPC_DEBUG */

/*
 *	Routine:	mach_port_kernel_object [kernel call]
 *	Purpose:
 *		Retrieve the type and address of the kernel object
 *		represented by a send or receive right.
 *	Conditions:
 *		Nothing locked.
 *	Returns:
 *		KERN_SUCCESS		Retrieved kernel object info.
 *		KERN_INVALID_TASK	The space is null.
 *		KERN_INVALID_TASK	The space is dead.
 *		KERN_INVALID_NAME	The name doesn't denote a right.
 *		KERN_INVALID_RIGHT	Name doesn't denote
 *					send or receive rights.
 */

#if !MACH_IPC_DEBUG
kern_return_t
mach_port_kernel_object(
	__unused ipc_space_t		space,
	__unused mach_port_name_t	name,
	__unused unsigned int	*typep,
	__unused vm_offset_t		*addrp)
{
        return KERN_FAILURE;
}
#else
kern_return_t
mach_port_kernel_object(
	ipc_space_t			space,
	mach_port_name_t		name,
	unsigned int			*typep,
	vm_offset_t			*addrp)
{
	ipc_entry_t entry;
	ipc_port_t port;
	kern_return_t kr;

	kr = ipc_right_lookup_read(space, name, &entry);
	if (kr != KERN_SUCCESS)
		return kr;
	/* space is read-locked and active */

	if ((entry->ie_bits & MACH_PORT_TYPE_SEND_RECEIVE) == 0) {
		is_read_unlock(space);
		return KERN_INVALID_RIGHT;
	}

	port = (ipc_port_t) entry->ie_object;
	assert(port != IP_NULL);

	ip_lock(port);
	is_read_unlock(space);

	if (!ip_active(port)) {
		ip_unlock(port);
		return KERN_INVALID_RIGHT;
	}

	*typep = (unsigned int) ip_kotype(port);
	*addrp = (vm_offset_t) port->ip_kobject;
	ip_unlock(port);
	return KERN_SUCCESS;

}
#endif /* MACH_IPC_DEBUG */
Commit	Line	Data
1c79356b	1	/*
91447636	2	* Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
1c79356b A	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
37839358 A	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
1c79356b	11	*
37839358 A	12	* This Original Code and all software distributed under the License are
37839358 A	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
37839358 A	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
1c79356b A	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* @OSF_COPYRIGHT@
	24	*/
	25	/*
	26	* Mach Operating System
	27	* Copyright (c) 1991,1990 Carnegie Mellon University
	28	* All Rights Reserved.
	29	*
	30	* Permission to use, copy, modify and distribute this software and its
	31	* documentation is hereby granted, provided that both the copyright
	32	* notice and this permission notice appear in all copies of the
	33	* software, derivative works or modified versions, and any portions
	34	* thereof, and that both notices appear in supporting documentation.
	35	*
	36	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
	37	* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
	38	* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
	39	*
	40	* Carnegie Mellon requests users of this software to return to
	41	*
	42	* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
	43	* School of Computer Science
	44	* Carnegie Mellon University
	45	* Pittsburgh PA 15213-3890
	46	*
	47	* any improvements or extensions that they make and grant Carnegie Mellon
	48	* the rights to redistribute these changes.
	49	*/
	50	/*
	51	*/
	52	/*
	53	* File: ipc/mach_debug.c
	54	* Author: Rich Draves
	55	* Date: 1989
	56	*
	57	* Exported IPC debug calls.
	58	*/
	59	#include <mach_ipc_debug.h>
	60
	61	#include <mach/vm_param.h>
	62	#include <mach/kern_return.h>
	63	#include <mach/machine/vm_types.h>
	64	#include <mach/mach_host_server.h>
	65	#include <mach/mach_port_server.h>
	66	#include <mach_debug/ipc_info.h>
	67	#include <mach_debug/hash_info.h>
	68
	69	#if MACH_IPC_DEBUG
	70	#include <kern/host.h>
	71	#include <kern/misc_protos.h>
	72	#include <vm/vm_map.h>
	73	#include <vm/vm_kern.h>
91447636 A	74	#include <ipc/port.h>
91447636 A	75	#include <ipc/ipc_types.h>
1c79356b A	76	#include <ipc/ipc_space.h>
	77	#include <ipc/ipc_port.h>
	78	#include <ipc/ipc_hash.h>
	79	#include <ipc/ipc_table.h>
	80	#include <ipc/ipc_right.h>
	81	#endif
	82
	83	/*
	84	* Routine: mach_port_get_srights [kernel call]
	85	* Purpose:
	86	* Retrieve the number of extant send rights
	87	* that a receive right has.
	88	* Conditions:
	89	* Nothing locked.
	90	* Returns:
	91	* KERN_SUCCESS Retrieved number of send rights.
	92	* KERN_INVALID_TASK The space is null.
	93	* KERN_INVALID_TASK The space is dead.
	94	* KERN_INVALID_NAME The name doesn't denote a right.
	95	* KERN_INVALID_RIGHT Name doesn't denote receive rights.
	96	*/
	97
91447636 A	98	#if !MACH_IPC_DEBUG
	99	kern_return_t
	100	mach_port_get_srights(
	101	__unused ipc_space_t space,
	102	__unused mach_port_name_t name,
	103	__unused mach_port_rights_t *srightsp)
	104	{
	105	return KERN_FAILURE;
	106	}
	107	#else
1c79356b A	108	kern_return_t
	109	mach_port_get_srights(
	110	ipc_space_t space,
	111	mach_port_name_t name,
	112	mach_port_rights_t *srightsp)
	113	{
1c79356b A	114	ipc_port_t port;
	115	kern_return_t kr;
	116	mach_port_rights_t srights;
	117
	118	if (space == IS_NULL)
	119	return KERN_INVALID_TASK;
	120
	121	kr = ipc_port_translate_receive(space, name, &port);
	122	if (kr != KERN_SUCCESS)
	123	return kr;
	124	/* port is locked and active */
	125
	126	srights = port->ip_srights;
	127	ip_unlock(port);
	128
	129	*srightsp = srights;
	130	return KERN_SUCCESS;
1c79356b	131	}
91447636	132	#endif /* MACH_IPC_DEBUG */
1c79356b A	133
	134	/*
	135	* Routine: host_ipc_hash_info
	136	* Purpose:
	137	* Return information about the global reverse hash table.
	138	* Conditions:
	139	* Nothing locked. Obeys CountInOut protocol.
	140	* Returns:
	141	* KERN_SUCCESS Returned information.
	142	* KERN_INVALID_HOST The host is null.
	143	* KERN_RESOURCE_SHORTAGE Couldn't allocate memory.
	144	*/
	145
91447636	146	#if !MACH_IPC_DEBUG
1c79356b A	147	kern_return_t
1c79356b A	148	host_ipc_hash_info(
91447636 A	149	__unused host_t host,
	150	__unused hash_info_bucket_array_t *infop,
	151	__unused mach_msg_type_number_t *countp)
1c79356b	152	{
1c79356b	153	return KERN_FAILURE;
91447636	154	}
1c79356b	155	#else
91447636 A	156	kern_return_t
	157	host_ipc_hash_info(
	158	host_t host,
	159	hash_info_bucket_array_t *infop,
	160	mach_msg_type_number_t *countp)
	161	{
1c79356b	162	vm_offset_t addr;
91447636	163	vm_size_t size = 0;
1c79356b A	164	hash_info_bucket_t *info;
	165	unsigned int potential, actual;
	166	kern_return_t kr;
	167
	168	if (host == HOST_NULL)
	169	return KERN_INVALID_HOST;
	170
	171	/* start with in-line data */
	172
	173	info = *infop;
	174	potential = *countp;
	175
	176	for (;;) {
	177	actual = ipc_hash_info(info, potential);
	178	if (actual <= potential)
	179	break;
	180
	181	/* allocate more memory */
	182
	183	if (info != *infop)
	184	kmem_free(ipc_kernel_map, addr, size);
	185
91447636	186	size = round_page(actual * sizeof *info);
1c79356b A	187	kr = kmem_alloc_pageable(ipc_kernel_map, &addr, size);
	188	if (kr != KERN_SUCCESS)
	189	return KERN_RESOURCE_SHORTAGE;
	190
	191	info = (hash_info_bucket_t *) addr;
	192	potential = size/sizeof *info;
	193	}
	194
	195	if (info == *infop) {
	196	/* data fit in-line; nothing to deallocate */
	197
	198	*countp = actual;
	199	} else if (actual == 0) {
	200	kmem_free(ipc_kernel_map, addr, size);
	201
	202	*countp = 0;
	203	} else {
	204	vm_map_copy_t copy;
	205	vm_size_t used;
	206
91447636	207	used = round_page(actual * sizeof *info);
1c79356b A	208
	209	if (used != size)
	210	kmem_free(ipc_kernel_map, addr + used, size - used);
	211
91447636 A	212	kr = vm_map_copyin(ipc_kernel_map, (vm_map_address_t)addr,
91447636 A	213	(vm_map_size_t)used, TRUE, &copy);
1c79356b A	214	assert(kr == KERN_SUCCESS);
	215
	216	infop = (hash_info_bucket_t ) copy;
	217	*countp = actual;
	218	}
	219
	220	return KERN_SUCCESS;
1c79356b	221	}
91447636	222	#endif /* MACH_IPC_DEBUG */
1c79356b A	223
	224	/*
	225	* Routine: mach_port_space_info
	226	* Purpose:
	227	* Returns information about an IPC space.
	228	* Conditions:
	229	* Nothing locked. Obeys CountInOut protocol.
	230	* Returns:
	231	* KERN_SUCCESS Returned information.
	232	* KERN_INVALID_TASK The space is null.
	233	* KERN_INVALID_TASK The space is dead.
	234	* KERN_RESOURCE_SHORTAGE Couldn't allocate memory.
	235	*/
	236
91447636	237	#if !MACH_IPC_DEBUG
1c79356b A	238	kern_return_t
1c79356b A	239	mach_port_space_info(
91447636 A	240	__unused ipc_space_t space,
	241	__unused ipc_info_space_t *infop,
	242	__unused ipc_info_name_array_t *tablep,
	243	__unused mach_msg_type_number_t *tableCntp,
	244	__unused ipc_info_tree_name_array_t *treep,
	245	__unused mach_msg_type_number_t *treeCntp)
	246	{
	247	return KERN_FAILURE;
	248	}
	249	#else
	250	kern_return_t
	251	mach_port_space_info(
	252	ipc_space_t space,
	253	ipc_info_space_t *infop,
1c79356b A	254	ipc_info_name_array_t *tablep,
1c79356b A	255	mach_msg_type_number_t *tableCntp,
91447636	256	ipc_info_tree_name_array_t *treep,
1c79356b A	257	mach_msg_type_number_t *treeCntp)
1c79356b A	258	{
1c79356b A	259	ipc_info_name_t *table_info;
	260	unsigned int table_potential, table_actual;
	261	vm_offset_t table_addr;
	262	vm_size_t table_size;
	263	ipc_info_tree_name_t *tree_info;
	264	unsigned int tree_potential, tree_actual;
	265	vm_offset_t tree_addr;
	266	vm_size_t tree_size;
	267	ipc_tree_entry_t tentry;
	268	ipc_entry_t table;
	269	ipc_entry_num_t tsize;
	270	mach_port_index_t index;
	271	kern_return_t kr;
1c79356b A	272
	273	if (space == IS_NULL)
	274	return KERN_INVALID_TASK;
	275
	276	/* start with in-line memory */
	277
91447636	278	table_size = 0;
1c79356b A	279	table_info = *tablep;
1c79356b A	280	table_potential = *tableCntp;
91447636	281	tree_size = 0;
1c79356b A	282	tree_info = *treep;
	283	tree_potential = *treeCntp;
	284
	285	for (;;) {
	286	is_read_lock(space);
	287	if (!space->is_active) {
	288	is_read_unlock(space);
	289	if (table_info != *tablep)
	290	kmem_free(ipc_kernel_map,
	291	table_addr, table_size);
	292	if (tree_info != *treep)
	293	kmem_free(ipc_kernel_map,
	294	tree_addr, tree_size);
	295	return KERN_INVALID_TASK;
	296	}
	297
	298	table_actual = space->is_table_size;
	299	tree_actual = space->is_tree_total;
	300
	301	if ((table_actual <= table_potential) &&
	302	(tree_actual <= tree_potential))
	303	break;
	304
	305	is_read_unlock(space);
	306
	307	if (table_actual > table_potential) {
	308	if (table_info != *tablep)
	309	kmem_free(ipc_kernel_map,
	310	table_addr, table_size);
	311
91447636	312	table_size = round_page(table_actual *
1c79356b A	313	sizeof *table_info);
	314	kr = kmem_alloc(ipc_kernel_map,
	315	&table_addr, table_size);
	316	if (kr != KERN_SUCCESS) {
	317	if (tree_info != *treep)
	318	kmem_free(ipc_kernel_map,
	319	tree_addr, tree_size);
	320
	321	return KERN_RESOURCE_SHORTAGE;
	322	}
	323
	324	table_info = (ipc_info_name_t *) table_addr;
	325	table_potential = table_size/sizeof *table_info;
	326	}
	327
	328	if (tree_actual > tree_potential) {
	329	if (tree_info != *treep)
	330	kmem_free(ipc_kernel_map,
	331	tree_addr, tree_size);
	332
91447636	333	tree_size = round_page(tree_actual *
1c79356b A	334	sizeof *tree_info);
	335	kr = kmem_alloc(ipc_kernel_map,
	336	&tree_addr, tree_size);
	337	if (kr != KERN_SUCCESS) {
	338	if (table_info != *tablep)
	339	kmem_free(ipc_kernel_map,
	340	table_addr, table_size);
	341
	342	return KERN_RESOURCE_SHORTAGE;
	343	}
	344
	345	tree_info = (ipc_info_tree_name_t *) tree_addr;
	346	tree_potential = tree_size/sizeof *tree_info;
	347	}
	348	}
	349	/* space is read-locked and active; we have enough wired memory */
	350
	351	infop->iis_genno_mask = MACH_PORT_NGEN(MACH_PORT_DEAD);
	352	infop->iis_table_size = space->is_table_size;
	353	infop->iis_table_next = space->is_table_next->its_size;
	354	infop->iis_tree_size = space->is_tree_total;
	355	infop->iis_tree_small = space->is_tree_small;
	356	infop->iis_tree_hash = space->is_tree_hash;
	357
	358	table = space->is_table;
	359	tsize = space->is_table_size;
	360
	361	for (index = 0; index < tsize; index++) {
	362	ipc_info_name_t *iin = &table_info[index];
	363	ipc_entry_t entry = &table[index];
	364	ipc_entry_bits_t bits;
	365
	366	bits = entry->ie_bits;
	367	iin->iin_name = MACH_PORT_MAKE(index, IE_BITS_GEN(bits));
	368	iin->iin_collision = (bits & IE_BITS_COLLISION) ? TRUE : FALSE;
	369	iin->iin_type = IE_BITS_TYPE(bits);
	370	iin->iin_urefs = IE_BITS_UREFS(bits);
	371	iin->iin_object = (vm_offset_t) entry->ie_object;
	372	iin->iin_next = entry->ie_next;
	373	iin->iin_hash = entry->ie_index;
	374	}
	375
	376	for (tentry = ipc_splay_traverse_start(&space->is_tree), index = 0;
	377	tentry != ITE_NULL;
	378	tentry = ipc_splay_traverse_next(&space->is_tree, FALSE)) {
	379	ipc_info_tree_name_t *iitn = &tree_info[index++];
	380	ipc_info_name_t *iin = &iitn->iitn_name;
	381	ipc_entry_t entry = &tentry->ite_entry;
	382	ipc_entry_bits_t bits = entry->ie_bits;
	383
	384	assert(IE_BITS_TYPE(bits) != MACH_PORT_TYPE_NONE);
	385
	386	iin->iin_name = tentry->ite_name;
	387	iin->iin_collision = (bits & IE_BITS_COLLISION) ? TRUE : FALSE;
	388	iin->iin_type = IE_BITS_TYPE(bits);
	389	iin->iin_urefs = IE_BITS_UREFS(bits);
	390	iin->iin_object = (vm_offset_t) entry->ie_object;
	391	iin->iin_next = entry->ie_next;
	392	iin->iin_hash = entry->ie_index;
	393
	394	if (tentry->ite_lchild == ITE_NULL)
	395	iitn->iitn_lchild = MACH_PORT_NULL;
	396	else
	397	iitn->iitn_lchild = tentry->ite_lchild->ite_name;
398
399	if (tentry->ite_rchild == ITE_NULL)
400	iitn->iitn_rchild = MACH_PORT_NULL;
401	else
402	iitn->iitn_rchild = tentry->ite_rchild->ite_name;
403
404	}
405	ipc_splay_traverse_finish(&space->is_tree);
406	is_read_unlock(space);
407
408	if (table_info == *tablep) {
409	/* data fit in-line; nothing to deallocate */
410
411	*tableCntp = table_actual;
412	} else if (table_actual == 0) {
413	kmem_free(ipc_kernel_map, table_addr, table_size);
414
415	*tableCntp = 0;
416	} else {
417	vm_size_t size_used, rsize_used;
418	vm_map_copy_t copy;
419
420	/* kmem_alloc doesn't zero memory */
421
422	size_used = table_actual * sizeof *table_info;
91447636	423	rsize_used = round_page(size_used);
1c79356b A	424
	425	if (rsize_used != table_size)
	426	kmem_free(ipc_kernel_map,
	427	table_addr + rsize_used,
	428	table_size - rsize_used);
	429
	430	if (size_used != rsize_used)
	431	bzero((char *) (table_addr + size_used),
	432	rsize_used - size_used);
	433
91447636 A	434	kr = vm_map_unwire(ipc_kernel_map, vm_map_trunc_page(table_addr),
91447636 A	435	vm_map_round_page(table_addr + rsize_used), FALSE);
1c79356b A	436	assert(kr == KERN_SUCCESS);
1c79356b A	437
91447636 A	438	kr = vm_map_copyin(ipc_kernel_map, (vm_map_address_t)table_addr,
91447636 A	439	(vm_map_size_t)rsize_used, TRUE, &copy);
1c79356b A	440	assert(kr == KERN_SUCCESS);
	441
	442	tablep = (ipc_info_name_t ) copy;
	443	*tableCntp = table_actual;
	444	}
	445
	446	if (tree_info == *treep) {
	447	/* data fit in-line; nothing to deallocate */
	448
	449	*treeCntp = tree_actual;
	450	} else if (tree_actual == 0) {
	451	kmem_free(ipc_kernel_map, tree_addr, tree_size);
	452
	453	*treeCntp = 0;
	454	} else {
	455	vm_size_t size_used, rsize_used;
	456	vm_map_copy_t copy;
	457
	458	/* kmem_alloc doesn't zero memory */
	459
	460	size_used = tree_actual * sizeof *tree_info;
91447636	461	rsize_used = round_page(size_used);
1c79356b A	462
	463	if (rsize_used != tree_size)
	464	kmem_free(ipc_kernel_map,
	465	tree_addr + rsize_used,
	466	tree_size - rsize_used);
	467
	468	if (size_used != rsize_used)
	469	bzero((char *) (tree_addr + size_used),
	470	rsize_used - size_used);
	471
91447636 A	472	kr = vm_map_unwire(ipc_kernel_map, vm_map_trunc_page(tree_addr),
91447636 A	473	vm_map_round_page(tree_addr + rsize_used), FALSE);
1c79356b A	474	assert(kr == KERN_SUCCESS);
1c79356b A	475
91447636 A	476	kr = vm_map_copyin(ipc_kernel_map, (vm_map_address_t)tree_addr,
91447636 A	477	(vm_map_size_t)rsize_used, TRUE, &copy);
1c79356b A	478	assert(kr == KERN_SUCCESS);
	479
	480	treep = (ipc_info_tree_name_t ) copy;
	481	*treeCntp = tree_actual;
	482	}
	483
	484	return KERN_SUCCESS;
1c79356b	485	}
91447636	486	#endif /* MACH_IPC_DEBUG */
1c79356b A	487
	488	/*
	489	* Routine: mach_port_dnrequest_info
	490	* Purpose:
	491	* Returns information about the dead-name requests
	492	* registered with the named receive right.
	493	* Conditions:
	494	* Nothing locked.
	495	* Returns:
	496	* KERN_SUCCESS Retrieved information.
	497	* KERN_INVALID_TASK The space is null.
	498	* KERN_INVALID_TASK The space is dead.
	499	* KERN_INVALID_NAME The name doesn't denote a right.
	500	* KERN_INVALID_RIGHT Name doesn't denote receive rights.
	501	*/
	502
91447636	503	#if !MACH_IPC_DEBUG
1c79356b A	504	kern_return_t
1c79356b A	505	mach_port_dnrequest_info(
91447636 A	506	__unused ipc_space_t space,
	507	__unused mach_port_name_t name,
	508	__unused unsigned int *totalp,
	509	__unused unsigned int *usedp)
1c79356b	510	{
1c79356b	511	return KERN_FAILURE;
91447636	512	}
1c79356b	513	#else
91447636 A	514	kern_return_t
	515	mach_port_dnrequest_info(
	516	ipc_space_t space,
	517	mach_port_name_t name,
	518	unsigned int *totalp,
	519	unsigned int *usedp)
	520	{
1c79356b A	521	unsigned int total, used;
	522	ipc_port_t port;
	523	kern_return_t kr;
	524
	525	if (space == IS_NULL)
	526	return KERN_INVALID_TASK;
	527
	528	kr = ipc_port_translate_receive(space, name, &port);
	529	if (kr != KERN_SUCCESS)
	530	return kr;
	531	/* port is locked and active */
	532
	533	if (port->ip_dnrequests == IPR_NULL) {
	534	total = 0;
	535	used = 0;
	536	} else {
	537	ipc_port_request_t dnrequests = port->ip_dnrequests;
	538	ipc_port_request_index_t index;
	539
	540	total = dnrequests->ipr_size->its_size;
	541
	542	for (index = 1, used = 0;
	543	index < total; index++) {
	544	ipc_port_request_t ipr = &dnrequests[index];
	545
	546	if (ipr->ipr_name != MACH_PORT_NULL)
	547	used++;
	548	}
	549	}
	550	ip_unlock(port);
	551
	552	*totalp = total;
	553	*usedp = used;
	554	return KERN_SUCCESS;
1c79356b	555	}
91447636	556	#endif /* MACH_IPC_DEBUG */
1c79356b A	557
	558	/*
	559	* Routine: mach_port_kernel_object [kernel call]
	560	* Purpose:
	561	* Retrieve the type and address of the kernel object
	562	* represented by a send or receive right.
	563	* Conditions:
	564	* Nothing locked.
	565	* Returns:
	566	* KERN_SUCCESS Retrieved kernel object info.
	567	* KERN_INVALID_TASK The space is null.
	568	* KERN_INVALID_TASK The space is dead.
	569	* KERN_INVALID_NAME The name doesn't denote a right.
	570	* KERN_INVALID_RIGHT Name doesn't denote
	571	* send or receive rights.
	572	*/
	573
91447636	574	#if !MACH_IPC_DEBUG
1c79356b A	575	kern_return_t
1c79356b A	576	mach_port_kernel_object(
91447636 A	577	__unused ipc_space_t space,
	578	__unused mach_port_name_t name,
	579	__unused unsigned int *typep,
	580	__unused vm_offset_t *addrp)
1c79356b	581	{
1c79356b	582	return KERN_FAILURE;
91447636	583	}
1c79356b	584	#else
91447636 A	585	kern_return_t
	586	mach_port_kernel_object(
	587	ipc_space_t space,
	588	mach_port_name_t name,
	589	unsigned int *typep,
	590	vm_offset_t *addrp)
	591	{
1c79356b A	592	ipc_entry_t entry;
	593	ipc_port_t port;
	594	kern_return_t kr;
	595
	596	kr = ipc_right_lookup_read(space, name, &entry);
	597	if (kr != KERN_SUCCESS)
	598	return kr;
	599	/* space is read-locked and active */
	600
	601	if ((entry->ie_bits & MACH_PORT_TYPE_SEND_RECEIVE) == 0) {
	602	is_read_unlock(space);
	603	return KERN_INVALID_RIGHT;
	604	}
	605
	606	port = (ipc_port_t) entry->ie_object;
	607	assert(port != IP_NULL);
	608
	609	ip_lock(port);
	610	is_read_unlock(space);
	611
	612	if (!ip_active(port)) {
	613	ip_unlock(port);
	614	return KERN_INVALID_RIGHT;
	615	}
	616
	617	*typep = (unsigned int) ip_kotype(port);
	618	*addrp = (vm_offset_t) port->ip_kobject;
	619	ip_unlock(port);
	620	return KERN_SUCCESS;
	621
1c79356b	622	}
91447636	623	#endif /* MACH_IPC_DEBUG */