[apple/xnu.git] / osfmk / vm / vm_debug.c

/*
 * Copyright (c) 2000 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:	vm/vm_debug.c.
 *	Author:	Rich Draves
 *	Date:	March, 1990
 *
 *	Exported kernel calls.  See mach_debug/mach_debug.defs.
 */
#include <mach_vm_debug.h>
#include <mach/kern_return.h>
#include <mach/mach_host_server.h>
#include <mach/vm_map_server.h>
#include <mach_debug/vm_info.h>
#include <mach_debug/page_info.h>
#include <mach_debug/hash_info.h>

#if MACH_VM_DEBUG
#include <mach/machine/vm_types.h>
#include <mach/memory_object_types.h>
#include <mach/vm_prot.h>
#include <mach/vm_inherit.h>
#include <mach/vm_param.h>
#include <kern/thread.h>
#include <vm/vm_map.h>
#include <vm/vm_kern.h>
#include <vm/vm_object.h>
#include <kern/task.h>
#include <kern/host.h>
#include <ipc/ipc_port.h>
#include <vm/vm_debug.h>
#endif

/*
 *	Routine:	mach_vm_region_info [kernel call]
 *	Purpose:
 *		Retrieve information about a VM region,
 *		including info about the object chain.
 *	Conditions:
 *		Nothing locked.
 *	Returns:
 *		KERN_SUCCESS		Retrieve region/object info.
 *		KERN_INVALID_TASK	The map is null.
 *		KERN_NO_SPACE		There is no entry at/after the address.
 *		KERN_RESOURCE_SHORTAGE	Can't allocate memory.
 */

kern_return_t
mach_vm_region_info(
	vm_map_t		map,
	vm_offset_t		address,
	vm_info_region_t	*regionp,
	vm_info_object_array_t	*objectsp,
	mach_msg_type_number_t	*objectsCntp)
{
#if !MACH_VM_DEBUG
        return KERN_FAILURE;
#else
	vm_map_copy_t copy;
	vm_offset_t addr;	/* memory for OOL data */
	vm_size_t size;		/* size of the memory */
	unsigned int room;	/* room for this many objects */
	unsigned int used;	/* actually this many objects */
	vm_info_region_t region;
	kern_return_t kr;

	if (map == VM_MAP_NULL)
		return KERN_INVALID_TASK;

	size = 0;		/* no memory allocated yet */

	for (;;) {
		vm_map_t cmap;	/* current map in traversal */
		vm_map_t nmap;	/* next map to look at */
		vm_map_entry_t entry;
		vm_object_t object, cobject, nobject;

		/* nothing is locked */

		vm_map_lock_read(map);
		for (cmap = map;; cmap = nmap) {
			/* cmap is read-locked */

			if (!vm_map_lookup_entry(cmap, address, &entry)) {
				entry = entry->vme_next;
				if (entry == vm_map_to_entry(cmap)) {
					vm_map_unlock_read(cmap);
					if (size != 0)
						kmem_free(ipc_kernel_map,
							  addr, size);
					return KERN_NO_SPACE;
				}
			}

			if (entry->is_sub_map)
				nmap = entry->object.sub_map;
			else
				break;

			/* move down to the lower map */

			vm_map_lock_read(nmap);
			vm_map_unlock_read(cmap);
		}

		/* cmap is read-locked; we have a real entry */

		object = entry->object.vm_object;
		region.vir_start = entry->vme_start;
		region.vir_end = entry->vme_end;
		region.vir_object = (vm_offset_t) object;
		region.vir_offset = entry->offset;
		region.vir_needs_copy = entry->needs_copy;
		region.vir_protection = entry->protection;
		region.vir_max_protection = entry->max_protection;
		region.vir_inheritance = entry->inheritance;
		region.vir_wired_count = entry->wired_count;
		region.vir_user_wired_count = entry->user_wired_count;

		used = 0;
		room = size / sizeof(vm_info_object_t);

		if (object == VM_OBJECT_NULL) {
			vm_map_unlock_read(cmap);
			/* no memory needed */
			break;
		}

		vm_object_lock(object);
		vm_map_unlock_read(cmap);

		for (cobject = object;; cobject = nobject) {
			/* cobject is locked */

			if (used < room) {
				vm_info_object_t *vio =
					&((vm_info_object_t *) addr)[used];

				vio->vio_object =
					(vm_offset_t) cobject;
				vio->vio_size =
					cobject->size;
				vio->vio_ref_count =
					cobject->ref_count;
				vio->vio_resident_page_count =
					cobject->resident_page_count;
				vio->vio_absent_count =
					cobject->absent_count;
				vio->vio_copy =
					(vm_offset_t) cobject->copy;
				vio->vio_shadow =
					(vm_offset_t) cobject->shadow;
				vio->vio_shadow_offset =
					cobject->shadow_offset;
				vio->vio_paging_offset =
					cobject->paging_offset;
				vio->vio_copy_strategy =
					cobject->copy_strategy;
				vio->vio_last_alloc =
					cobject->last_alloc;
				vio->vio_paging_in_progress =
					cobject->paging_in_progress;
				vio->vio_pager_created =
					cobject->pager_created;
				vio->vio_pager_initialized =
					cobject->pager_initialized;
				vio->vio_pager_ready =
					cobject->pager_ready;
				vio->vio_can_persist =
					cobject->can_persist;
				vio->vio_internal =
					cobject->internal;
				vio->vio_temporary =
					cobject->temporary;
				vio->vio_alive =
					cobject->alive;
				vio->vio_lock_in_progress =
					cobject->lock_in_progress;
				vio->vio_lock_restart =
					cobject->lock_restart;
			}

			used++;
			nobject = cobject->shadow;
			if (nobject == VM_OBJECT_NULL) {
				vm_object_unlock(cobject);
				break;
			}

			vm_object_lock(nobject);
			vm_object_unlock(cobject);
		}

		/* nothing locked */

		if (used <= room)
			break;

		/* must allocate more memory */

		if (size != 0)
			kmem_free(ipc_kernel_map, addr, size);
		size = round_page(2 * used * sizeof(vm_info_object_t));

		kr = vm_allocate(ipc_kernel_map, &addr, size, TRUE);
		if (kr != KERN_SUCCESS)
			return KERN_RESOURCE_SHORTAGE;

		kr = vm_map_wire(ipc_kernel_map, addr, addr + size,
				     VM_PROT_READ|VM_PROT_WRITE, FALSE);
		assert(kr == KERN_SUCCESS);
	}

	/* free excess memory; make remaining memory pageable */

	if (used == 0) {
		copy = VM_MAP_COPY_NULL;

		if (size != 0)
			kmem_free(ipc_kernel_map, addr, size);
	} else {
		vm_size_t size_used =
			round_page(used * sizeof(vm_info_object_t));

		kr = vm_map_unwire(ipc_kernel_map, addr, addr + size_used, FALSE);
		assert(kr == KERN_SUCCESS);

		kr = vm_map_copyin(ipc_kernel_map, addr, size_used,
				   TRUE, &copy);
		assert(kr == KERN_SUCCESS);

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

	*regionp = region;
	*objectsp = (vm_info_object_array_t) copy;
	*objectsCntp = used;
	return KERN_SUCCESS;
#endif /* MACH_VM_DEBUG */
}
/*
 *  Temporary call for 64 bit data path interface transiotion
 */

kern_return_t
mach_vm_region_info_64(
	vm_map_t		map,
	vm_offset_t		address,
	vm_info_region_64_t	*regionp,
	vm_info_object_array_t	*objectsp,
	mach_msg_type_number_t	*objectsCntp)
{
#if !MACH_VM_DEBUG
        return KERN_FAILURE;
#else
	vm_map_copy_t copy;
	vm_offset_t addr;	/* memory for OOL data */
	vm_size_t size;		/* size of the memory */
	unsigned int room;	/* room for this many objects */
	unsigned int used;	/* actually this many objects */
	vm_info_region_64_t region;
	kern_return_t kr;

	if (map == VM_MAP_NULL)
		return KERN_INVALID_TASK;

	size = 0;		/* no memory allocated yet */

	for (;;) {
		vm_map_t cmap;	/* current map in traversal */
		vm_map_t nmap;	/* next map to look at */
		vm_map_entry_t entry;
		vm_object_t object, cobject, nobject;

		/* nothing is locked */

		vm_map_lock_read(map);
		for (cmap = map;; cmap = nmap) {
			/* cmap is read-locked */

			if (!vm_map_lookup_entry(cmap, address, &entry)) {
				entry = entry->vme_next;
				if (entry == vm_map_to_entry(cmap)) {
					vm_map_unlock_read(cmap);
					if (size != 0)
						kmem_free(ipc_kernel_map,
							  addr, size);
					return KERN_NO_SPACE;
				}
			}

			if (entry->is_sub_map)
				nmap = entry->object.sub_map;
			else
				break;

			/* move down to the lower map */

			vm_map_lock_read(nmap);
			vm_map_unlock_read(cmap);
		}

		/* cmap is read-locked; we have a real entry */

		object = entry->object.vm_object;
		region.vir_start = entry->vme_start;
		region.vir_end = entry->vme_end;
		region.vir_object = (vm_offset_t) object;
		region.vir_offset = entry->offset;
		region.vir_needs_copy = entry->needs_copy;
		region.vir_protection = entry->protection;
		region.vir_max_protection = entry->max_protection;
		region.vir_inheritance = entry->inheritance;
		region.vir_wired_count = entry->wired_count;
		region.vir_user_wired_count = entry->user_wired_count;

		used = 0;
		room = size / sizeof(vm_info_object_t);

		if (object == VM_OBJECT_NULL) {
			vm_map_unlock_read(cmap);
			/* no memory needed */
			break;
		}

		vm_object_lock(object);
		vm_map_unlock_read(cmap);

		for (cobject = object;; cobject = nobject) {
			/* cobject is locked */

			if (used < room) {
				vm_info_object_t *vio =
					&((vm_info_object_t *) addr)[used];

				vio->vio_object =
					(vm_offset_t) cobject;
				vio->vio_size =
					cobject->size;
				vio->vio_ref_count =
					cobject->ref_count;
				vio->vio_resident_page_count =
					cobject->resident_page_count;
				vio->vio_absent_count =
					cobject->absent_count;
				vio->vio_copy =
					(vm_offset_t) cobject->copy;
				vio->vio_shadow =
					(vm_offset_t) cobject->shadow;
				vio->vio_shadow_offset =
					cobject->shadow_offset;
				vio->vio_paging_offset =
					cobject->paging_offset;
				vio->vio_copy_strategy =
					cobject->copy_strategy;
				vio->vio_last_alloc =
					cobject->last_alloc;
				vio->vio_paging_in_progress =
					cobject->paging_in_progress;
				vio->vio_pager_created =
					cobject->pager_created;
				vio->vio_pager_initialized =
					cobject->pager_initialized;
				vio->vio_pager_ready =
					cobject->pager_ready;
				vio->vio_can_persist =
					cobject->can_persist;
				vio->vio_internal =
					cobject->internal;
				vio->vio_temporary =
					cobject->temporary;
				vio->vio_alive =
					cobject->alive;
				vio->vio_lock_in_progress =
					cobject->lock_in_progress;
				vio->vio_lock_restart =
					cobject->lock_restart;
			}

			used++;
			nobject = cobject->shadow;
			if (nobject == VM_OBJECT_NULL) {
				vm_object_unlock(cobject);
				break;
			}

			vm_object_lock(nobject);
			vm_object_unlock(cobject);
		}

		/* nothing locked */

		if (used <= room)
			break;

		/* must allocate more memory */

		if (size != 0)
			kmem_free(ipc_kernel_map, addr, size);
		size = round_page(2 * used * sizeof(vm_info_object_t));

		kr = vm_allocate(ipc_kernel_map, &addr, size, TRUE);
		if (kr != KERN_SUCCESS)
			return KERN_RESOURCE_SHORTAGE;

		kr = vm_map_wire(ipc_kernel_map, addr, addr + size,
				     VM_PROT_READ|VM_PROT_WRITE, FALSE);
		assert(kr == KERN_SUCCESS);
	}

	/* free excess memory; make remaining memory pageable */

	if (used == 0) {
		copy = VM_MAP_COPY_NULL;

		if (size != 0)
			kmem_free(ipc_kernel_map, addr, size);
	} else {
		vm_size_t size_used =
			round_page(used * sizeof(vm_info_object_t));

		kr = vm_map_unwire(ipc_kernel_map, addr, addr + size_used, FALSE);
		assert(kr == KERN_SUCCESS);

		kr = vm_map_copyin(ipc_kernel_map, addr, size_used,
				   TRUE, &copy);
		assert(kr == KERN_SUCCESS);

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

	*regionp = region;
	*objectsp = (vm_info_object_array_t) copy;
	*objectsCntp = used;
	return KERN_SUCCESS;
#endif /* MACH_VM_DEBUG */
}
/*
 * Return an array of virtual pages that are mapped to a task.
 */
kern_return_t
vm_mapped_pages_info(
	vm_map_t		map,
	page_address_array_t	*pages,
	mach_msg_type_number_t  *pages_count)
{
#if !MACH_VM_DEBUG
        return KERN_FAILURE;
#else
	pmap_t		pmap;
	vm_size_t	size, size_used;
	unsigned int	actual, space;
	page_address_array_t list;
	vm_offset_t	addr;

	if (map == VM_MAP_NULL)
	    return (KERN_INVALID_ARGUMENT);

	pmap = map->pmap;
	size = pmap_resident_count(pmap) * sizeof(vm_offset_t);
	size = round_page(size);

	for (;;) {
	    (void) vm_allocate(ipc_kernel_map, &addr, size, TRUE);
	    (void) vm_map_unwire(ipc_kernel_map, addr, addr + size, FALSE);

	    list = (page_address_array_t) addr;
	    space = size / sizeof(vm_offset_t);

	    actual = pmap_list_resident_pages(pmap,
					list,
					space);
	    if (actual <= space)
		break;

	    /*
	     * Free memory if not enough
	     */
	    (void) kmem_free(ipc_kernel_map, addr, size);

	    /*
	     * Try again, doubling the size
	     */
	    size = round_page(actual * sizeof(vm_offset_t));
	}
	if (actual == 0) {
	    *pages = 0;
	    *pages_count = 0;
	    (void) kmem_free(ipc_kernel_map, addr, size);
	}
	else {
	    *pages_count = actual;
	    size_used = round_page(actual * sizeof(vm_offset_t));
	    (void) vm_map_wire(ipc_kernel_map,
				addr, addr + size, 
				VM_PROT_READ|VM_PROT_WRITE, FALSE);
	    (void) vm_map_copyin(
				ipc_kernel_map,
				addr,
				size_used,
				TRUE,
				(vm_map_copy_t *)pages);
	    if (size_used != size) {
		(void) kmem_free(ipc_kernel_map,
				addr + size_used,
				size - size_used);
	    }
	}

	return (KERN_SUCCESS);
#endif /* MACH_VM_DEBUG */
}

/*
 *	Routine:	host_virtual_physical_table_info
 *	Purpose:
 *		Return information about the VP 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.
 */

kern_return_t
host_virtual_physical_table_info(
	host_t				host,
	hash_info_bucket_array_t	*infop,
	mach_msg_type_number_t 		*countp)
{
#if !MACH_VM_DEBUG
        return KERN_FAILURE;
#else
	vm_offset_t addr;
	vm_size_t size;
	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 = vm_page_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, addr, used,
				   TRUE, &copy);
		assert(kr == KERN_SUCCESS);

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

	return KERN_SUCCESS;
#endif /* MACH_VM_DEBUG */
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	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.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	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.
	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: vm/vm_debug.c.
	54	* Author: Rich Draves
	55	* Date: March, 1990
	56	*
	57	* Exported kernel calls. See mach_debug/mach_debug.defs.
	58	*/
	59	#include <mach_vm_debug.h>
	60	#include <mach/kern_return.h>
	61	#include <mach/mach_host_server.h>
	62	#include <mach/vm_map_server.h>
	63	#include <mach_debug/vm_info.h>
	64	#include <mach_debug/page_info.h>
65	#include <mach_debug/hash_info.h>
66
67	#if MACH_VM_DEBUG
68	#include <mach/machine/vm_types.h>
69	#include <mach/memory_object_types.h>
70	#include <mach/vm_prot.h>
71	#include <mach/vm_inherit.h>
72	#include <mach/vm_param.h>
73	#include <kern/thread.h>
74	#include <vm/vm_map.h>
75	#include <vm/vm_kern.h>
76	#include <vm/vm_object.h>
77	#include <kern/task.h>
78	#include <kern/host.h>
79	#include <ipc/ipc_port.h>
80	#include <vm/vm_debug.h>
81	#endif
82
83	/*
84	* Routine: mach_vm_region_info [kernel call]
85	* Purpose:
86	* Retrieve information about a VM region,
87	* including info about the object chain.
88	* Conditions:
89	* Nothing locked.
90	* Returns:
91	* KERN_SUCCESS Retrieve region/object info.
92	* KERN_INVALID_TASK The map is null.
93	* KERN_NO_SPACE There is no entry at/after the address.
94	* KERN_RESOURCE_SHORTAGE Can't allocate memory.
95	*/
96
97	kern_return_t
98	mach_vm_region_info(
99	vm_map_t map,
100	vm_offset_t address,
101	vm_info_region_t *regionp,
102	vm_info_object_array_t *objectsp,
103	mach_msg_type_number_t *objectsCntp)
104	{
105	#if !MACH_VM_DEBUG
106	return KERN_FAILURE;
107	#else
108	vm_map_copy_t copy;
109	vm_offset_t addr; /* memory for OOL data */
110	vm_size_t size; /* size of the memory */
111	unsigned int room; /* room for this many objects */
112	unsigned int used; /* actually this many objects */
113	vm_info_region_t region;
114	kern_return_t kr;
115
116	if (map == VM_MAP_NULL)
117	return KERN_INVALID_TASK;
118
119	size = 0; /* no memory allocated yet */
120
121	for (;;) {
122	vm_map_t cmap; /* current map in traversal */
123	vm_map_t nmap; /* next map to look at */
124	vm_map_entry_t entry;
125	vm_object_t object, cobject, nobject;
126
127	/* nothing is locked */
128
129	vm_map_lock_read(map);
130	for (cmap = map;; cmap = nmap) {
131	/* cmap is read-locked */
132
133	if (!vm_map_lookup_entry(cmap, address, &entry)) {
134	entry = entry->vme_next;
135	if (entry == vm_map_to_entry(cmap)) {
136	vm_map_unlock_read(cmap);
137	if (size != 0)
138	kmem_free(ipc_kernel_map,
139	addr, size);
140	return KERN_NO_SPACE;
141	}
142	}
143
144	if (entry->is_sub_map)
145	nmap = entry->object.sub_map;
146	else
147	break;
148
149	/* move down to the lower map */
150
151	vm_map_lock_read(nmap);
152	vm_map_unlock_read(cmap);
153	}
154
155	/* cmap is read-locked; we have a real entry */
156
157	object = entry->object.vm_object;
158	region.vir_start = entry->vme_start;
159	region.vir_end = entry->vme_end;
160	region.vir_object = (vm_offset_t) object;
161	region.vir_offset = entry->offset;
162	region.vir_needs_copy = entry->needs_copy;
163	region.vir_protection = entry->protection;
164	region.vir_max_protection = entry->max_protection;
165	region.vir_inheritance = entry->inheritance;
166	region.vir_wired_count = entry->wired_count;
167	region.vir_user_wired_count = entry->user_wired_count;
168
169	used = 0;
170	room = size / sizeof(vm_info_object_t);
171
172	if (object == VM_OBJECT_NULL) {
173	vm_map_unlock_read(cmap);
174	/* no memory needed */
175	break;
176	}
177
178	vm_object_lock(object);
179	vm_map_unlock_read(cmap);
180
181	for (cobject = object;; cobject = nobject) {
182	/* cobject is locked */
183
184	if (used < room) {
185	vm_info_object_t *vio =
186	&((vm_info_object_t *) addr)[used];
187
188	vio->vio_object =
189	(vm_offset_t) cobject;
190	vio->vio_size =
191	cobject->size;
192	vio->vio_ref_count =
193	cobject->ref_count;
194	vio->vio_resident_page_count =
195	cobject->resident_page_count;
196	vio->vio_absent_count =
197	cobject->absent_count;
198	vio->vio_copy =
199	(vm_offset_t) cobject->copy;
200	vio->vio_shadow =
201	(vm_offset_t) cobject->shadow;
202	vio->vio_shadow_offset =
203	cobject->shadow_offset;
204	vio->vio_paging_offset =
205	cobject->paging_offset;
206	vio->vio_copy_strategy =
207	cobject->copy_strategy;
208	vio->vio_last_alloc =
209	cobject->last_alloc;
210	vio->vio_paging_in_progress =
211	cobject->paging_in_progress;
212	vio->vio_pager_created =
213	cobject->pager_created;
214	vio->vio_pager_initialized =
215	cobject->pager_initialized;
216	vio->vio_pager_ready =
217	cobject->pager_ready;
218	vio->vio_can_persist =
219	cobject->can_persist;
220	vio->vio_internal =
221	cobject->internal;
222	vio->vio_temporary =
223	cobject->temporary;
224	vio->vio_alive =
225	cobject->alive;
226	vio->vio_lock_in_progress =
227	cobject->lock_in_progress;
228	vio->vio_lock_restart =
229	cobject->lock_restart;
230	}
231
232	used++;
233	nobject = cobject->shadow;
234	if (nobject == VM_OBJECT_NULL) {
235	vm_object_unlock(cobject);
236	break;
237	}
238
239	vm_object_lock(nobject);
240	vm_object_unlock(cobject);
241	}
242
243	/* nothing locked */
244
245	if (used <= room)
246	break;
247
248	/* must allocate more memory */
249
250	if (size != 0)
251	kmem_free(ipc_kernel_map, addr, size);
252	size = round_page(2 * used * sizeof(vm_info_object_t));
253
254	kr = vm_allocate(ipc_kernel_map, &addr, size, TRUE);
255	if (kr != KERN_SUCCESS)
256	return KERN_RESOURCE_SHORTAGE;
257
258	kr = vm_map_wire(ipc_kernel_map, addr, addr + size,
259	VM_PROT_READ\|VM_PROT_WRITE, FALSE);
260	assert(kr == KERN_SUCCESS);
261	}
262
263	/* free excess memory; make remaining memory pageable */
264
265	if (used == 0) {
266	copy = VM_MAP_COPY_NULL;
267
268	if (size != 0)
269	kmem_free(ipc_kernel_map, addr, size);
270	} else {
271	vm_size_t size_used =
272	round_page(used * sizeof(vm_info_object_t));
273
274	kr = vm_map_unwire(ipc_kernel_map, addr, addr + size_used, FALSE);
275	assert(kr == KERN_SUCCESS);
276
277	kr = vm_map_copyin(ipc_kernel_map, addr, size_used,
278	TRUE, &copy);
279	assert(kr == KERN_SUCCESS);
280
281	if (size != size_used)
282	kmem_free(ipc_kernel_map,
283	addr + size_used, size - size_used);
284	}
285
286	*regionp = region;
287	*objectsp = (vm_info_object_array_t) copy;
288	*objectsCntp = used;
289	return KERN_SUCCESS;
290	#endif /* MACH_VM_DEBUG */
291	}
292	/*
293	* Temporary call for 64 bit data path interface transiotion
294	*/
295
296	kern_return_t
297	mach_vm_region_info_64(
298	vm_map_t map,
299	vm_offset_t address,
300	vm_info_region_64_t *regionp,
301	vm_info_object_array_t *objectsp,
302	mach_msg_type_number_t *objectsCntp)
303	{
304	#if !MACH_VM_DEBUG
305	return KERN_FAILURE;
306	#else
307	vm_map_copy_t copy;
308	vm_offset_t addr; /* memory for OOL data */
309	vm_size_t size; /* size of the memory */
310	unsigned int room; /* room for this many objects */
311	unsigned int used; /* actually this many objects */
312	vm_info_region_64_t region;
313	kern_return_t kr;
314
315	if (map == VM_MAP_NULL)
316	return KERN_INVALID_TASK;
317
318	size = 0; /* no memory allocated yet */
319
320	for (;;) {
321	vm_map_t cmap; /* current map in traversal */
322	vm_map_t nmap; /* next map to look at */
323	vm_map_entry_t entry;
324	vm_object_t object, cobject, nobject;
325
326	/* nothing is locked */
327
328	vm_map_lock_read(map);
329	for (cmap = map;; cmap = nmap) {
330	/* cmap is read-locked */
331
332	if (!vm_map_lookup_entry(cmap, address, &entry)) {
333	entry = entry->vme_next;
334	if (entry == vm_map_to_entry(cmap)) {
335	vm_map_unlock_read(cmap);
336	if (size != 0)
337	kmem_free(ipc_kernel_map,
338	addr, size);
339	return KERN_NO_SPACE;
340	}
341	}
342
343	if (entry->is_sub_map)
344	nmap = entry->object.sub_map;
345	else
346	break;
347
348	/* move down to the lower map */
349
350	vm_map_lock_read(nmap);
351	vm_map_unlock_read(cmap);
352	}
353
354	/* cmap is read-locked; we have a real entry */
355
356	object = entry->object.vm_object;
357	region.vir_start = entry->vme_start;
358	region.vir_end = entry->vme_end;
359	region.vir_object = (vm_offset_t) object;
360	region.vir_offset = entry->offset;
361	region.vir_needs_copy = entry->needs_copy;
362	region.vir_protection = entry->protection;
363	region.vir_max_protection = entry->max_protection;
364	region.vir_inheritance = entry->inheritance;
365	region.vir_wired_count = entry->wired_count;
366	region.vir_user_wired_count = entry->user_wired_count;
367
368	used = 0;
369	room = size / sizeof(vm_info_object_t);
370
371	if (object == VM_OBJECT_NULL) {
372	vm_map_unlock_read(cmap);
373	/* no memory needed */
374	break;
375	}
376
377	vm_object_lock(object);
378	vm_map_unlock_read(cmap);
379
380	for (cobject = object;; cobject = nobject) {
381	/* cobject is locked */
382
383	if (used < room) {
384	vm_info_object_t *vio =
385	&((vm_info_object_t *) addr)[used];
386
387	vio->vio_object =
388	(vm_offset_t) cobject;
389	vio->vio_size =
390	cobject->size;
391	vio->vio_ref_count =
392	cobject->ref_count;
393	vio->vio_resident_page_count =
394	cobject->resident_page_count;
395	vio->vio_absent_count =
396	cobject->absent_count;
397	vio->vio_copy =
398	(vm_offset_t) cobject->copy;
399	vio->vio_shadow =
400	(vm_offset_t) cobject->shadow;
401	vio->vio_shadow_offset =
402	cobject->shadow_offset;
403	vio->vio_paging_offset =
404	cobject->paging_offset;
405	vio->vio_copy_strategy =
406	cobject->copy_strategy;
407	vio->vio_last_alloc =
408	cobject->last_alloc;
409	vio->vio_paging_in_progress =
410	cobject->paging_in_progress;
411	vio->vio_pager_created =
412	cobject->pager_created;
413	vio->vio_pager_initialized =
414	cobject->pager_initialized;
415	vio->vio_pager_ready =
416	cobject->pager_ready;
417	vio->vio_can_persist =
418	cobject->can_persist;
419	vio->vio_internal =
420	cobject->internal;
421	vio->vio_temporary =
422	cobject->temporary;
423	vio->vio_alive =
424	cobject->alive;
425	vio->vio_lock_in_progress =
426	cobject->lock_in_progress;
427	vio->vio_lock_restart =
428	cobject->lock_restart;
429	}
430
431	used++;
432	nobject = cobject->shadow;
433	if (nobject == VM_OBJECT_NULL) {
434	vm_object_unlock(cobject);
435	break;
436	}
437
438	vm_object_lock(nobject);
439	vm_object_unlock(cobject);
440	}
441
442	/* nothing locked */
443
444	if (used <= room)
445	break;
446
447	/* must allocate more memory */
448
449	if (size != 0)
450	kmem_free(ipc_kernel_map, addr, size);
451	size = round_page(2 * used * sizeof(vm_info_object_t));
452
453	kr = vm_allocate(ipc_kernel_map, &addr, size, TRUE);
454	if (kr != KERN_SUCCESS)
455	return KERN_RESOURCE_SHORTAGE;
456
457	kr = vm_map_wire(ipc_kernel_map, addr, addr + size,
458	VM_PROT_READ\|VM_PROT_WRITE, FALSE);
459	assert(kr == KERN_SUCCESS);
460	}
461
462	/* free excess memory; make remaining memory pageable */
463
464	if (used == 0) {
465	copy = VM_MAP_COPY_NULL;
466
467	if (size != 0)
468	kmem_free(ipc_kernel_map, addr, size);
469	} else {
470	vm_size_t size_used =
471	round_page(used * sizeof(vm_info_object_t));
472
473	kr = vm_map_unwire(ipc_kernel_map, addr, addr + size_used, FALSE);
474	assert(kr == KERN_SUCCESS);
475
476	kr = vm_map_copyin(ipc_kernel_map, addr, size_used,
477	TRUE, &copy);
478	assert(kr == KERN_SUCCESS);
479
480	if (size != size_used)
481	kmem_free(ipc_kernel_map,
482	addr + size_used, size - size_used);
483	}
484
485	*regionp = region;
486	*objectsp = (vm_info_object_array_t) copy;
487	*objectsCntp = used;
488	return KERN_SUCCESS;
489	#endif /* MACH_VM_DEBUG */
490	}
491	/*
492	* Return an array of virtual pages that are mapped to a task.
493	*/
494	kern_return_t
495	vm_mapped_pages_info(
496	vm_map_t map,
497	page_address_array_t *pages,
498	mach_msg_type_number_t *pages_count)
499	{
500	#if !MACH_VM_DEBUG
501	return KERN_FAILURE;
502	#else
503	pmap_t pmap;
504	vm_size_t size, size_used;
505	unsigned int actual, space;
506	page_address_array_t list;
507	vm_offset_t addr;
508
509	if (map == VM_MAP_NULL)
510	return (KERN_INVALID_ARGUMENT);
511
512	pmap = map->pmap;
513	size = pmap_resident_count(pmap) * sizeof(vm_offset_t);
514	size = round_page(size);
515
516	for (;;) {
517	(void) vm_allocate(ipc_kernel_map, &addr, size, TRUE);
518	(void) vm_map_unwire(ipc_kernel_map, addr, addr + size, FALSE);
519
520	list = (page_address_array_t) addr;
521	space = size / sizeof(vm_offset_t);
522
523	actual = pmap_list_resident_pages(pmap,
524	list,
525	space);
526	if (actual <= space)
527	break;
528
529	/*
530	* Free memory if not enough
531	*/
532	(void) kmem_free(ipc_kernel_map, addr, size);
533
534	/*
535	* Try again, doubling the size
536	*/
537	size = round_page(actual * sizeof(vm_offset_t));
538	}
539	if (actual == 0) {
540	*pages = 0;
541	*pages_count = 0;
542	(void) kmem_free(ipc_kernel_map, addr, size);
543	}
544	else {
545	*pages_count = actual;
546	size_used = round_page(actual * sizeof(vm_offset_t));
547	(void) vm_map_wire(ipc_kernel_map,
548	addr, addr + size,
549	VM_PROT_READ\|VM_PROT_WRITE, FALSE);
550	(void) vm_map_copyin(
551	ipc_kernel_map,
552	addr,
553	size_used,
554	TRUE,
555	(vm_map_copy_t *)pages);
556	if (size_used != size) {
557	(void) kmem_free(ipc_kernel_map,
558	addr + size_used,
559	size - size_used);
560	}
561	}
562
563	return (KERN_SUCCESS);
564	#endif /* MACH_VM_DEBUG */
565	}
566
567	/*
568	* Routine: host_virtual_physical_table_info
569	* Purpose:
570	* Return information about the VP table.
571	* Conditions:
572	* Nothing locked. Obeys CountInOut protocol.
573	* Returns:
574	* KERN_SUCCESS Returned information.
575	* KERN_INVALID_HOST The host is null.
576	* KERN_RESOURCE_SHORTAGE Couldn't allocate memory.
577	*/
578
579	kern_return_t
580	host_virtual_physical_table_info(
581	host_t host,
582	hash_info_bucket_array_t *infop,
583	mach_msg_type_number_t *countp)
584	{
585	#if !MACH_VM_DEBUG
586	return KERN_FAILURE;
587	#else
588	vm_offset_t addr;
589	vm_size_t size;
590	hash_info_bucket_t *info;
591	unsigned int potential, actual;
592	kern_return_t kr;
593
594	if (host == HOST_NULL)
595	return KERN_INVALID_HOST;
596
597	/* start with in-line data */
598
599	info = *infop;
600	potential = *countp;
601
602	for (;;) {
603	actual = vm_page_info(info, potential);
604	if (actual <= potential)
605	break;
606
607	/* allocate more memory */
608
609	if (info != *infop)
610	kmem_free(ipc_kernel_map, addr, size);
611
612	size = round_page(actual * sizeof *info);
613	kr = kmem_alloc_pageable(ipc_kernel_map, &addr, size);
614	if (kr != KERN_SUCCESS)
615	return KERN_RESOURCE_SHORTAGE;
616
617	info = (hash_info_bucket_t *) addr;
618	potential = size/sizeof *info;
619	}
620
621	if (info == *infop) {
622	/* data fit in-line; nothing to deallocate */
623
624	*countp = actual;
625	} else if (actual == 0) {
626	kmem_free(ipc_kernel_map, addr, size);
627
628	*countp = 0;
629	} else {
630	vm_map_copy_t copy;
631	vm_size_t used;
632
633	used = round_page(actual * sizeof *info);
634
635	if (used != size)
636	kmem_free(ipc_kernel_map, addr + used, size - used);
637
638	kr = vm_map_copyin(ipc_kernel_map, addr, used,
639	TRUE, &copy);
640	assert(kr == KERN_SUCCESS);
641
642	infop = (hash_info_bucket_t ) copy;
643	*countp = actual;
644	}
645
646	return KERN_SUCCESS;
647	#endif /* MACH_VM_DEBUG */
648	}