[apple/xnu.git] / osfmk / vm / pmap.h

/*
 * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * @OSF_COPYRIGHT@
 */
/* 
 * Mach Operating System
 * Copyright (c) 1991,1990,1989,1988,1987 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/pmap.h
 *	Author:	Avadis Tevanian, Jr.
 *	Date:	1985
 *
 *	Machine address mapping definitions -- machine-independent
 *	section.  [For machine-dependent section, see "machine/pmap.h".]
 */

#ifndef	_VM_PMAP_H_
#define _VM_PMAP_H_

#include <mach/kern_return.h>
#include <mach/vm_param.h>
#include <mach/vm_types.h>
#include <mach/vm_attributes.h>
#include <mach/boolean.h>
#include <mach/vm_prot.h>

#ifdef	KERNEL_PRIVATE

/*
 *	The following is a description of the interface to the
 *	machine-dependent "physical map" data structure.  The module
 *	must provide a "pmap_t" data type that represents the
 *	set of valid virtual-to-physical addresses for one user
 *	address space.  [The kernel address space is represented
 *	by a distinguished "pmap_t".]  The routines described manage
 *	this type, install and update virtual-to-physical mappings,
 *	and perform operations on physical addresses common to
 *	many address spaces.
 */

/* Copy between a physical page and a virtual address */
/* LP64todo - switch to vm_map_offset_t when it grows */
extern kern_return_t 	copypv(
				addr64_t source, 
				addr64_t sink, 
				unsigned int size, 
				int which);	
#define cppvPsnk        1
#define cppvPsnkb      31
#define cppvPsrc        2
#define cppvPsrcb      30
#define cppvFsnk        4
#define cppvFsnkb      29
#define cppvFsrc        8
#define cppvFsrcb      28
#define cppvNoModSnk   16
#define cppvNoModSnkb  27
#define cppvNoRefSrc   32
#define cppvNoRefSrcb  26
#define cppvKmap       64	/* Use the kernel's vm_map */
#define cppvKmapb      25

#ifdef	MACH_KERNEL_PRIVATE

#include <machine/pmap.h>

/*
 *	Routines used for initialization.
 *	There is traditionally also a pmap_bootstrap,
 *	used very early by machine-dependent code,
 *	but it is not part of the interface.
 *
 *	LP64todo -
 *	These interfaces are tied to the size of the
 *	kernel pmap - and therefore use the "local"
 *	vm_offset_t, etc... types.
 */

extern void 		*pmap_steal_memory(vm_size_t size);
						/* During VM initialization,
						 * steal a chunk of memory.
						 */
extern unsigned int	pmap_free_pages(void);	/* During VM initialization,
						 * report remaining unused
						 * physical pages.
						 */
extern void		pmap_startup(
				vm_offset_t *startp,
				vm_offset_t *endp);
						/* During VM initialization,
						 * use remaining physical pages
						 * to allocate page frames.
						 */
extern void		pmap_init(void) __attribute__((section("__TEXT, initcode")));
						/* Initialization,
						 * after kernel runs
						 * in virtual memory.
						 */

extern void 		mapping_adjust(void);	/* Adjust free mapping count */

extern void 		mapping_free_prime(void); /* Primes the mapping block release list */

#ifndef	MACHINE_PAGES
/*
 *	If machine/pmap.h defines MACHINE_PAGES, it must implement
 *	the above functions.  The pmap module has complete control.
 *	Otherwise, it must implement
 *		pmap_free_pages
 *		pmap_virtual_space
 *		pmap_next_page
 *		pmap_init
 *	and vm/vm_resident.c implements pmap_steal_memory and pmap_startup
 *	using pmap_free_pages, pmap_next_page, pmap_virtual_space,
 *	and pmap_enter.  pmap_free_pages may over-estimate the number
 *	of unused physical pages, and pmap_next_page may return FALSE
 *	to indicate that there are no more unused pages to return.
 *	However, for best performance pmap_free_pages should be accurate.
 */

extern boolean_t	pmap_next_page(ppnum_t *pnum);
#if defined(__LP64__)
extern boolean_t	pmap_next_page_k64(ppnum_t *pnum);
#endif
						/* During VM initialization,
						 * return the next unused
						 * physical page.
						 */
extern void		pmap_virtual_space(
					vm_offset_t	*virtual_start,
					vm_offset_t	*virtual_end);
						/* During VM initialization,
						 * report virtual space
						 * available for the kernel.
						 */
#endif	/* MACHINE_PAGES */

/*
 *	Routines to manage the physical map data structure.
 */
extern pmap_t		pmap_create(	/* Create a pmap_t. */
				vm_map_size_t	size,
#ifdef __i386__
				boolean_t	is_64bit);
#else
				__unused boolean_t	is_64bit);
#endif
extern pmap_t		(pmap_kernel)(void);	/* Return the kernel's pmap */
extern void		pmap_reference(pmap_t pmap);	/* Gain a reference. */
extern void		pmap_destroy(pmap_t pmap); /* Release a reference. */
extern void		pmap_switch(pmap_t);


extern void		pmap_enter(	/* Enter a mapping */
				pmap_t		pmap,
				vm_map_offset_t	v,
				ppnum_t		pn,
				vm_prot_t	prot,
				unsigned int	flags,
				boolean_t	wired);

extern void		pmap_remove_some_phys(
				pmap_t		pmap,
				ppnum_t		pn);


/*
 *	Routines that operate on physical addresses.
 */

extern void		pmap_page_protect(	/* Restrict access to page. */
				ppnum_t	phys,
				vm_prot_t	prot);

extern void		(pmap_zero_page)(
				ppnum_t		pn);

extern void		(pmap_zero_part_page)(
				ppnum_t		pn,
				vm_offset_t     offset,
				vm_size_t       len);

extern void		(pmap_copy_page)(
				ppnum_t		src,
				ppnum_t		dest);

extern void		(pmap_copy_part_page)(
				ppnum_t		src,
				vm_offset_t	src_offset,
				ppnum_t		dst,
				vm_offset_t	dst_offset,
				vm_size_t	len);

extern void		(pmap_copy_part_lpage)(
				vm_offset_t	src,
				ppnum_t		dst,
				vm_offset_t	dst_offset,
				vm_size_t	len);

extern void		(pmap_copy_part_rpage)(
				ppnum_t		src,
				vm_offset_t	src_offset,
				vm_offset_t	dst,
				vm_size_t	len);
				
extern unsigned int (pmap_disconnect)(	/* disconnect mappings and return reference and change */
				ppnum_t		phys);

extern kern_return_t	(pmap_attribute_cache_sync)(  /* Flush appropriate 
						       * cache based on
						       * page number sent */
				ppnum_t		pn, 
				vm_size_t	size, 
				vm_machine_attribute_t attribute, 
				vm_machine_attribute_val_t* value);

extern unsigned int	(pmap_cache_attributes)(
				ppnum_t		pn);

extern void pmap_sync_page_data_phys(ppnum_t pa);
extern void pmap_sync_page_attributes_phys(ppnum_t pa);

/*
 * debug/assertions. pmap_verify_free returns true iff
 * the given physical page is mapped into no pmap.
 */
extern boolean_t	pmap_verify_free(ppnum_t pn);

/*
 *	Statistics routines
 */
extern int		(pmap_resident_count)(pmap_t pmap);
extern int		(pmap_resident_max)(pmap_t pmap);

/*
 *	Sundry required (internal) routines
 */
#ifdef CURRENTLY_UNUSED_AND_UNTESTED
extern void		pmap_collect(pmap_t pmap);/* Perform garbage
						 * collection, if any */
#endif
/*
 *	Optional routines
 */
extern void		(pmap_copy)(		/* Copy range of mappings,
						 * if desired. */
				pmap_t		dest,
				pmap_t		source,
				vm_map_offset_t	dest_va,
				vm_map_size_t	size,
				vm_map_offset_t	source_va);

extern kern_return_t	(pmap_attribute)(	/* Get/Set special memory
						 * attributes */
				pmap_t		pmap,
				vm_map_offset_t	va,
				vm_map_size_t	size,
				vm_machine_attribute_t  attribute,
				vm_machine_attribute_val_t* value);

/*
 * Routines defined as macros.
 */
#ifndef PMAP_ACTIVATE_USER
#ifndef	PMAP_ACTIVATE
#define PMAP_ACTIVATE_USER(thr, cpu)
#else	/* PMAP_ACTIVATE */
#define PMAP_ACTIVATE_USER(thr, cpu) {			\
	pmap_t  pmap;						\
								\
	pmap = (thr)->map->pmap;				\
	if (pmap != pmap_kernel())				\
		PMAP_ACTIVATE(pmap, (thr), (cpu));		\
}
#endif  /* PMAP_ACTIVATE */
#endif  /* PMAP_ACTIVATE_USER */

#ifndef PMAP_DEACTIVATE_USER
#ifndef PMAP_DEACTIVATE
#define PMAP_DEACTIVATE_USER(thr, cpu)
#else	/* PMAP_DEACTIVATE */
#define PMAP_DEACTIVATE_USER(thr, cpu) {			\
	pmap_t  pmap;						\
								\
	pmap = (thr)->map->pmap;				\
	if ((pmap) != pmap_kernel())			\
		PMAP_DEACTIVATE(pmap, (thr), (cpu));	\
}
#endif	/* PMAP_DEACTIVATE */
#endif  /* PMAP_DEACTIVATE_USER */

#ifndef	PMAP_ACTIVATE_KERNEL
#ifndef PMAP_ACTIVATE
#define	PMAP_ACTIVATE_KERNEL(cpu)
#else	/* PMAP_ACTIVATE */
#define	PMAP_ACTIVATE_KERNEL(cpu)			\
		PMAP_ACTIVATE(pmap_kernel(), THREAD_NULL, cpu)
#endif	/* PMAP_ACTIVATE */
#endif	/* PMAP_ACTIVATE_KERNEL */

#ifndef	PMAP_DEACTIVATE_KERNEL
#ifndef PMAP_DEACTIVATE
#define	PMAP_DEACTIVATE_KERNEL(cpu)
#else	/* PMAP_DEACTIVATE */
#define	PMAP_DEACTIVATE_KERNEL(cpu)			\
		PMAP_DEACTIVATE(pmap_kernel(), THREAD_NULL, cpu)
#endif	/* PMAP_DEACTIVATE */
#endif	/* PMAP_DEACTIVATE_KERNEL */

#ifndef	PMAP_ENTER
/*
 *	Macro to be used in place of pmap_enter()
 */
#define PMAP_ENTER(pmap, virtual_address, page, protection, flags, wired) \
	MACRO_BEGIN							\
	pmap_t		__pmap = (pmap);				\
	vm_page_t	__page = (page);				\
									\
	if (__pmap != kernel_pmap) {					\
		ASSERT_PAGE_DECRYPTED(__page);				\
	}								\
	if (__page->error) {						\
		panic("VM page %p should not have an error\n",		\
			__page);					\
	}								\
	pmap_enter(__pmap,						\
		   (virtual_address),					\
		   __page->phys_page,					\
		   (protection),					\
		   (flags),						\
		   (wired));						\
	MACRO_END
#endif	/* !PMAP_ENTER */

/*
 *	Routines to manage reference/modify bits based on
 *	physical addresses, simulating them if not provided
 *	by the hardware.
 */
				/* Clear reference bit */
extern void		pmap_clear_reference(ppnum_t	 pn);
				/* Return reference bit */
extern boolean_t	(pmap_is_referenced)(ppnum_t	 pn);
				/* Set modify bit */
extern void             pmap_set_modify(ppnum_t	 pn);
				/* Clear modify bit */
extern void		pmap_clear_modify(ppnum_t pn);
				/* Return modify bit */
extern boolean_t	pmap_is_modified(ppnum_t pn);
				/* Return modified and referenced bits */
extern unsigned int pmap_get_refmod(ppnum_t pn);
				/* Clear modified and referenced bits */
extern void			pmap_clear_refmod(ppnum_t pn, unsigned int mask);
#define VM_MEM_MODIFIED		0x01	/* Modified bit */
#define VM_MEM_REFERENCED	0x02	/* Referenced bit */

/*
 *	Routines that operate on ranges of virtual addresses.
 */
extern void		pmap_protect(	/* Change protections. */
				pmap_t		map,
				vm_map_offset_t	s,
				vm_map_offset_t	e,
				vm_prot_t	prot);

extern void		(pmap_pageable)(
				pmap_t		pmap,
				vm_map_offset_t	start,
				vm_map_offset_t	end,
				boolean_t	pageable);


extern uint64_t pmap_nesting_size_min;
extern uint64_t pmap_nesting_size_max;

extern kern_return_t pmap_nest(pmap_t grand,
			       pmap_t subord,
			       addr64_t vstart,
			       addr64_t nstart,
			       uint64_t size);
extern kern_return_t pmap_unnest(pmap_t grand,
				 addr64_t vaddr,
				 uint64_t size);
extern boolean_t pmap_adjust_unnest_parameters(pmap_t, vm_map_offset_t *, vm_map_offset_t *);
#endif	/* MACH_KERNEL_PRIVATE */

/*
 * JMM - This portion is exported to other kernel components right now,
 * but will be pulled back in the future when the needed functionality
 * is provided in a cleaner manner.
 */

extern pmap_t	kernel_pmap;			/* The kernel's map */
#define		pmap_kernel()	(kernel_pmap)

/* machine independent WIMG bits */

#define VM_MEM_GUARDED 		0x1		/* (G) Guarded Storage */
#define VM_MEM_COHERENT		0x2		/* (M) Memory Coherency */
#define VM_MEM_NOT_CACHEABLE	0x4		/* (I) Cache Inhibit */
#define VM_MEM_WRITE_THROUGH	0x8		/* (W) Write-Through */

#define VM_WIMG_MASK		0xFF
#define VM_WIMG_USE_DEFAULT	0x80000000

#define VM_MEM_SUPERPAGE	0x100		/* map a superpage instead of a base page */
#if	!defined(__LP64__)
extern vm_offset_t	pmap_extract(pmap_t pmap,
				vm_map_offset_t va);
#endif
extern void		pmap_change_wiring(	/* Specify pageability */
				pmap_t		pmap,
				vm_map_offset_t	va,
				boolean_t	wired);

/* LP64todo - switch to vm_map_offset_t when it grows */
extern void		pmap_remove(	/* Remove mappings. */
				pmap_t		map,
				vm_map_offset_t	s,
				vm_map_offset_t	e);

extern void		fillPage(ppnum_t pa, unsigned int fill);

extern void pmap_map_sharedpage(task_t task, pmap_t pmap);
extern void pmap_unmap_sharedpage(pmap_t pmap);

#if defined(__LP64__)
void pmap_pre_expand(pmap_t pmap, vm_map_offset_t vaddr);
#endif

#endif  /* KERNEL_PRIVATE */

#endif	/* _VM_PMAP_H_ */
Commit	Line	Data
1c79356b	1	/*
2d21ac55	2	* Copyright (c) 2000-2007 Apple Inc. All rights reserved.
1c79356b	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
2d21ac55 A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
8f6c56a5	14	*
2d21ac55 A	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
8f6c56a5 A	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 A	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55 A	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
8f6c56a5	25	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/*
	29	* @OSF_COPYRIGHT@
	30	*/
	31	/*
	32	* Mach Operating System
	33	* Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
	34	* All Rights Reserved.
	35	*
	36	* Permission to use, copy, modify and distribute this software and its
	37	* documentation is hereby granted, provided that both the copyright
	38	* notice and this permission notice appear in all copies of the
	39	* software, derivative works or modified versions, and any portions
	40	* thereof, and that both notices appear in supporting documentation.
	41	*
	42	* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
	43	* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
	44	* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
	45	*
	46	* Carnegie Mellon requests users of this software to return to
	47	*
	48	* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
	49	* School of Computer Science
	50	* Carnegie Mellon University
	51	* Pittsburgh PA 15213-3890
	52	*
	53	* any improvements or extensions that they make and grant Carnegie Mellon
	54	* the rights to redistribute these changes.
	55	*/
	56	/*
	57	*/
	58	/*
	59	* File: vm/pmap.h
	60	* Author: Avadis Tevanian, Jr.
	61	* Date: 1985
	62	*
	63	* Machine address mapping definitions -- machine-independent
	64	* section. [For machine-dependent section, see "machine/pmap.h".]
	65	*/
	66
	67	#ifndef _VM_PMAP_H_
	68	#define _VM_PMAP_H_
	69
	70	#include <mach/kern_return.h>
	71	#include <mach/vm_param.h>
	72	#include <mach/vm_types.h>
	73	#include <mach/vm_attributes.h>
	74	#include <mach/boolean.h>
	75	#include <mach/vm_prot.h>
	76
91447636 A	77	#ifdef KERNEL_PRIVATE
91447636 A	78
1c79356b A	79	/*
	80	* The following is a description of the interface to the
	81	* machine-dependent "physical map" data structure. The module
	82	* must provide a "pmap_t" data type that represents the
	83	* set of valid virtual-to-physical addresses for one user
	84	* address space. [The kernel address space is represented
	85	* by a distinguished "pmap_t".] The routines described manage
	86	* this type, install and update virtual-to-physical mappings,
	87	* and perform operations on physical addresses common to
	88	* many address spaces.
	89	*/
	90
55e303ae	91	/* Copy between a physical page and a virtual address */
91447636	92	/* LP64todo - switch to vm_map_offset_t when it grows */
55e303ae A	93	extern kern_return_t copypv(
	94	addr64_t source,
	95	addr64_t sink,
	96	unsigned int size,
	97	int which);
91447636 A	98	#define cppvPsnk 1
	99	#define cppvPsnkb 31
	100	#define cppvPsrc 2
	101	#define cppvPsrcb 30
	102	#define cppvFsnk 4
	103	#define cppvFsnkb 29
	104	#define cppvFsrc 8
	105	#define cppvFsrcb 28
55e303ae	106	#define cppvNoModSnk 16
91447636	107	#define cppvNoModSnkb 27
55e303ae	108	#define cppvNoRefSrc 32
91447636 A	109	#define cppvNoRefSrcb 26
	110	#define cppvKmap 64 /* Use the kernel's vm_map */
	111	#define cppvKmapb 25
1c79356b	112
91447636	113	#ifdef MACH_KERNEL_PRIVATE
1c79356b A	114
	115	#include <machine/pmap.h>
	116
	117	/*
	118	* Routines used for initialization.
	119	* There is traditionally also a pmap_bootstrap,
	120	* used very early by machine-dependent code,
	121	* but it is not part of the interface.
91447636 A	122	*
	123	* LP64todo -
	124	* These interfaces are tied to the size of the
	125	* kernel pmap - and therefore use the "local"
	126	* vm_offset_t, etc... types.
1c79356b A	127	*/
1c79356b A	128
91447636	129	extern void *pmap_steal_memory(vm_size_t size);
1c79356b A	130	/* During VM initialization,
	131	* steal a chunk of memory.
	132	*/
	133	extern unsigned int pmap_free_pages(void); /* During VM initialization,
	134	* report remaining unused
	135	* physical pages.
	136	*/
	137	extern void pmap_startup(
	138	vm_offset_t *startp,
	139	vm_offset_t *endp);
	140	/* During VM initialization,
	141	* use remaining physical pages
	142	* to allocate page frames.
	143	*/
2d21ac55 A	144	extern void pmap_init(void) __attribute__((section("__TEXT, initcode")));
2d21ac55 A	145	/* Initialization,
1c79356b A	146	* after kernel runs
	147	* in virtual memory.
	148	*/
	149
91447636 A	150	extern void mapping_adjust(void); /* Adjust free mapping count */
	151
	152	extern void mapping_free_prime(void); /* Primes the mapping block release list */
	153
1c79356b A	154	#ifndef MACHINE_PAGES
	155	/*
	156	* If machine/pmap.h defines MACHINE_PAGES, it must implement
	157	* the above functions. The pmap module has complete control.
	158	* Otherwise, it must implement
	159	* pmap_free_pages
	160	* pmap_virtual_space
	161	* pmap_next_page
	162	* pmap_init
	163	* and vm/vm_resident.c implements pmap_steal_memory and pmap_startup
	164	* using pmap_free_pages, pmap_next_page, pmap_virtual_space,
	165	* and pmap_enter. pmap_free_pages may over-estimate the number
	166	* of unused physical pages, and pmap_next_page may return FALSE
	167	* to indicate that there are no more unused pages to return.
	168	* However, for best performance pmap_free_pages should be accurate.
	169	*/
	170
55e303ae	171	extern boolean_t pmap_next_page(ppnum_t *pnum);
b0d623f7 A	172	#if defined(__LP64__)
	173	extern boolean_t pmap_next_page_k64(ppnum_t *pnum);
	174	#endif
1c79356b A	175	/* During VM initialization,
	176	* return the next unused
	177	* physical page.
	178	*/
	179	extern void pmap_virtual_space(
	180	vm_offset_t *virtual_start,
	181	vm_offset_t *virtual_end);
	182	/* During VM initialization,
	183	* report virtual space
	184	* available for the kernel.
	185	*/
	186	#endif /* MACHINE_PAGES */
	187
	188	/*
	189	* Routines to manage the physical map data structure.
	190	*/
0c530ab8 A	191	extern pmap_t pmap_create( /* Create a pmap_t. */
0c530ab8 A	192	vm_map_size_t size,
2d21ac55	193	#ifdef __i386__
0c530ab8	194	boolean_t is_64bit);
2d21ac55 A	195	#else
	196	__unused boolean_t is_64bit);
	197	#endif
1c79356b A	198	extern pmap_t (pmap_kernel)(void); /* Return the kernel's pmap */
	199	extern void pmap_reference(pmap_t pmap); /* Gain a reference. */
	200	extern void pmap_destroy(pmap_t pmap); /* Release a reference. */
	201	extern void pmap_switch(pmap_t);
	202
	203
	204	extern void pmap_enter( /* Enter a mapping */
	205	pmap_t pmap,
91447636	206	vm_map_offset_t v,
55e303ae	207	ppnum_t pn,
1c79356b	208	vm_prot_t prot,
9bccf70c	209	unsigned int flags,
1c79356b A	210	boolean_t wired);
1c79356b A	211
0b4e3aa0 A	212	extern void pmap_remove_some_phys(
0b4e3aa0 A	213	pmap_t pmap,
55e303ae	214	ppnum_t pn);
0b4e3aa0	215
1c79356b A	216
	217	/*
	218	* Routines that operate on physical addresses.
	219	*/
0b4e3aa0	220
1c79356b	221	extern void pmap_page_protect( /* Restrict access to page. */
55e303ae	222	ppnum_t phys,
1c79356b A	223	vm_prot_t prot);
	224
	225	extern void (pmap_zero_page)(
55e303ae	226	ppnum_t pn);
1c79356b A	227
1c79356b A	228	extern void (pmap_zero_part_page)(
55e303ae	229	ppnum_t pn,
1c79356b A	230	vm_offset_t offset,
	231	vm_size_t len);
	232
	233	extern void (pmap_copy_page)(
55e303ae A	234	ppnum_t src,
55e303ae A	235	ppnum_t dest);
1c79356b A	236
1c79356b A	237	extern void (pmap_copy_part_page)(
55e303ae	238	ppnum_t src,
1c79356b	239	vm_offset_t src_offset,
55e303ae	240	ppnum_t dst,
1c79356b A	241	vm_offset_t dst_offset,
	242	vm_size_t len);
	243
	244	extern void (pmap_copy_part_lpage)(
	245	vm_offset_t src,
55e303ae	246	ppnum_t dst,
1c79356b A	247	vm_offset_t dst_offset,
	248	vm_size_t len);
	249
	250	extern void (pmap_copy_part_rpage)(
55e303ae	251	ppnum_t src,
1c79356b A	252	vm_offset_t src_offset,
	253	vm_offset_t dst,
	254	vm_size_t len);
91447636 A	255
	256	extern unsigned int (pmap_disconnect)( /* disconnect mappings and return reference and change */
	257	ppnum_t phys);
	258
	259	extern kern_return_t (pmap_attribute_cache_sync)( /* Flush appropriate
	260	* cache based on
	261	* page number sent */
	262	ppnum_t pn,
	263	vm_size_t size,
	264	vm_machine_attribute_t attribute,
	265	vm_machine_attribute_val_t* value);
1c79356b	266
0c530ab8 A	267	extern unsigned int (pmap_cache_attributes)(
	268	ppnum_t pn);
	269
2d21ac55 A	270	extern void pmap_sync_page_data_phys(ppnum_t pa);
	271	extern void pmap_sync_page_attributes_phys(ppnum_t pa);
	272
1c79356b A	273	/*
	274	* debug/assertions. pmap_verify_free returns true iff
	275	* the given physical page is mapped into no pmap.
	276	*/
55e303ae	277	extern boolean_t pmap_verify_free(ppnum_t pn);
1c79356b A	278
	279	/*
	280	* Statistics routines
	281	*/
	282	extern int (pmap_resident_count)(pmap_t pmap);
2d21ac55	283	extern int (pmap_resident_max)(pmap_t pmap);
1c79356b A	284
	285	/*
	286	* Sundry required (internal) routines
	287	*/
2d21ac55	288	#ifdef CURRENTLY_UNUSED_AND_UNTESTED
1c79356b A	289	extern void pmap_collect(pmap_t pmap);/* Perform garbage
1c79356b A	290	* collection, if any */
2d21ac55	291	#endif
1c79356b A	292	/*
	293	* Optional routines
	294	*/
	295	extern void (pmap_copy)( /* Copy range of mappings,
	296	* if desired. */
	297	pmap_t dest,
	298	pmap_t source,
91447636 A	299	vm_map_offset_t dest_va,
	300	vm_map_size_t size,
	301	vm_map_offset_t source_va);
1c79356b A	302
	303	extern kern_return_t (pmap_attribute)( /* Get/Set special memory
	304	* attributes */
	305	pmap_t pmap,
91447636 A	306	vm_map_offset_t va,
91447636 A	307	vm_map_size_t size,
1c79356b A	308	vm_machine_attribute_t attribute,
	309	vm_machine_attribute_val_t* value);
	310
	311	/*
	312	* Routines defined as macros.
	313	*/
	314	#ifndef PMAP_ACTIVATE_USER
91447636 A	315	#ifndef PMAP_ACTIVATE
	316	#define PMAP_ACTIVATE_USER(thr, cpu)
	317	#else /* PMAP_ACTIVATE */
	318	#define PMAP_ACTIVATE_USER(thr, cpu) { \
1c79356b A	319	pmap_t pmap; \
1c79356b A	320	\
91447636	321	pmap = (thr)->map->pmap; \
1c79356b	322	if (pmap != pmap_kernel()) \
91447636	323	PMAP_ACTIVATE(pmap, (thr), (cpu)); \
1c79356b	324	}
91447636	325	#endif /* PMAP_ACTIVATE */
1c79356b A	326	#endif /* PMAP_ACTIVATE_USER */
	327
	328	#ifndef PMAP_DEACTIVATE_USER
91447636 A	329	#ifndef PMAP_DEACTIVATE
	330	#define PMAP_DEACTIVATE_USER(thr, cpu)
	331	#else /* PMAP_DEACTIVATE */
	332	#define PMAP_DEACTIVATE_USER(thr, cpu) { \
1c79356b A	333	pmap_t pmap; \
1c79356b A	334	\
91447636 A	335	pmap = (thr)->map->pmap; \
	336	if ((pmap) != pmap_kernel()) \
	337	PMAP_DEACTIVATE(pmap, (thr), (cpu)); \
1c79356b	338	}
91447636	339	#endif /* PMAP_DEACTIVATE */
1c79356b A	340	#endif /* PMAP_DEACTIVATE_USER */
	341
	342	#ifndef PMAP_ACTIVATE_KERNEL
91447636 A	343	#ifndef PMAP_ACTIVATE
	344	#define PMAP_ACTIVATE_KERNEL(cpu)
	345	#else /* PMAP_ACTIVATE */
1c79356b	346	#define PMAP_ACTIVATE_KERNEL(cpu) \
91447636 A	347	PMAP_ACTIVATE(pmap_kernel(), THREAD_NULL, cpu)
91447636 A	348	#endif /* PMAP_ACTIVATE */
1c79356b A	349	#endif /* PMAP_ACTIVATE_KERNEL */
	350
	351	#ifndef PMAP_DEACTIVATE_KERNEL
91447636 A	352	#ifndef PMAP_DEACTIVATE
	353	#define PMAP_DEACTIVATE_KERNEL(cpu)
	354	#else /* PMAP_DEACTIVATE */
1c79356b	355	#define PMAP_DEACTIVATE_KERNEL(cpu) \
91447636 A	356	PMAP_DEACTIVATE(pmap_kernel(), THREAD_NULL, cpu)
91447636 A	357	#endif /* PMAP_DEACTIVATE */
1c79356b A	358	#endif /* PMAP_DEACTIVATE_KERNEL */
	359
	360	#ifndef PMAP_ENTER
	361	/*
	362	* Macro to be used in place of pmap_enter()
	363	*/
9bccf70c	364	#define PMAP_ENTER(pmap, virtual_address, page, protection, flags, wired) \
91447636 A	365	MACRO_BEGIN \
	366	pmap_t __pmap = (pmap); \
	367	vm_page_t __page = (page); \
	368	\
	369	if (__pmap != kernel_pmap) { \
	370	ASSERT_PAGE_DECRYPTED(__page); \
	371	} \
2d21ac55 A	372	if (__page->error) { \
	373	panic("VM page %p should not have an error\n", \
	374	__page); \
	375	} \
91447636 A	376	pmap_enter(__pmap, \
	377	(virtual_address), \
	378	__page->phys_page, \
2d21ac55	379	(protection), \
91447636 A	380	(flags), \
	381	(wired)); \
	382	MACRO_END
1c79356b A	383	#endif /* !PMAP_ENTER */
1c79356b A	384
1c79356b A	385	/*
	386	* Routines to manage reference/modify bits based on
	387	* physical addresses, simulating them if not provided
	388	* by the hardware.
	389	*/
	390	/* Clear reference bit */
55e303ae	391	extern void pmap_clear_reference(ppnum_t pn);
1c79356b	392	/* Return reference bit */
55e303ae	393	extern boolean_t (pmap_is_referenced)(ppnum_t pn);
1c79356b	394	/* Set modify bit */
55e303ae	395	extern void pmap_set_modify(ppnum_t pn);
1c79356b	396	/* Clear modify bit */
55e303ae	397	extern void pmap_clear_modify(ppnum_t pn);
1c79356b	398	/* Return modify bit */
55e303ae	399	extern boolean_t pmap_is_modified(ppnum_t pn);
91447636 A	400	/* Return modified and referenced bits */
	401	extern unsigned int pmap_get_refmod(ppnum_t pn);
	402	/* Clear modified and referenced bits */
	403	extern void pmap_clear_refmod(ppnum_t pn, unsigned int mask);
	404	#define VM_MEM_MODIFIED 0x01 /* Modified bit */
	405	#define VM_MEM_REFERENCED 0x02 /* Referenced bit */
1c79356b A	406
	407	/*
	408	* Routines that operate on ranges of virtual addresses.
	409	*/
1c79356b A	410	extern void pmap_protect( /* Change protections. */
1c79356b A	411	pmap_t map,
91447636 A	412	vm_map_offset_t s,
91447636 A	413	vm_map_offset_t e,
1c79356b A	414	vm_prot_t prot);
	415
	416	extern void (pmap_pageable)(
	417	pmap_t pmap,
91447636 A	418	vm_map_offset_t start,
91447636 A	419	vm_map_offset_t end,
1c79356b A	420	boolean_t pageable);
1c79356b A	421
b0d623f7	422
2d21ac55 A	423	extern uint64_t pmap_nesting_size_min;
2d21ac55 A	424	extern uint64_t pmap_nesting_size_max;
b0d623f7	425
2d21ac55 A	426	extern kern_return_t pmap_nest(pmap_t grand,
	427	pmap_t subord,
	428	addr64_t vstart,
	429	addr64_t nstart,
	430	uint64_t size);
	431	extern kern_return_t pmap_unnest(pmap_t grand,
	432	addr64_t vaddr,
	433	uint64_t size);
b0d623f7	434	extern boolean_t pmap_adjust_unnest_parameters(pmap_t, vm_map_offset_t , vm_map_offset_t );
91447636	435	#endif /* MACH_KERNEL_PRIVATE */
9bccf70c A	436
	437	/*
	438	* JMM - This portion is exported to other kernel components right now,
	439	* but will be pulled back in the future when the needed functionality
	440	* is provided in a cleaner manner.
	441	*/
	442
9bccf70c A	443	extern pmap_t kernel_pmap; /* The kernel's map */
	444	#define pmap_kernel() (kernel_pmap)
	445
	446	/* machine independent WIMG bits */
	447
91447636 A	448	#define VM_MEM_GUARDED 0x1 /* (G) Guarded Storage */
	449	#define VM_MEM_COHERENT 0x2 /* (M) Memory Coherency */
	450	#define VM_MEM_NOT_CACHEABLE 0x4 /* (I) Cache Inhibit */
	451	#define VM_MEM_WRITE_THROUGH 0x8 /* (W) Write-Through */
9bccf70c A	452
	453	#define VM_WIMG_MASK 0xFF
	454	#define VM_WIMG_USE_DEFAULT 0x80000000
	455
b0d623f7 A	456	#define VM_MEM_SUPERPAGE 0x100 /* map a superpage instead of a base page */
b0d623f7 A	457	#if !defined(__LP64__)
1c79356b	458	extern vm_offset_t pmap_extract(pmap_t pmap,
91447636	459	vm_map_offset_t va);
b0d623f7	460	#endif
1c79356b A	461	extern void pmap_change_wiring( /* Specify pageability */
1c79356b A	462	pmap_t pmap,
91447636	463	vm_map_offset_t va,
1c79356b	464	boolean_t wired);
9bccf70c	465
91447636	466	/* LP64todo - switch to vm_map_offset_t when it grows */
9bccf70c A	467	extern void pmap_remove( /* Remove mappings. */
9bccf70c A	468	pmap_t map,
2d21ac55 A	469	vm_map_offset_t s,
	470	vm_map_offset_t e);
	471
	472	extern void fillPage(ppnum_t pa, unsigned int fill);
55e303ae	473
2d21ac55 A	474	extern void pmap_map_sharedpage(task_t task, pmap_t pmap);
2d21ac55 A	475	extern void pmap_unmap_sharedpage(pmap_t pmap);
9bccf70c	476
b0d623f7 A	477	#if defined(__LP64__)
	478	void pmap_pre_expand(pmap_t pmap, vm_map_offset_t vaddr);
	479	#endif
	480
91447636	481	#endif /* KERNEL_PRIVATE */
9bccf70c	482
1c79356b	483	#endif /* _VM_PMAP_H_ */