[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);
						/* 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);

#ifndef NO_NESTED_PMAP
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);
#endif /* NO_NESTED_PMAP */

#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

extern vm_offset_t	pmap_extract(pmap_t pmap,
				vm_map_offset_t va);

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);

#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);
1c79356b A	172	/* During VM initialization,
	173	* return the next unused
	174	* physical page.
	175	*/
	176	extern void pmap_virtual_space(
	177	vm_offset_t *virtual_start,
	178	vm_offset_t *virtual_end);
	179	/* During VM initialization,
	180	* report virtual space
	181	* available for the kernel.
	182	*/
	183	#endif /* MACHINE_PAGES */
	184
	185	/*
	186	* Routines to manage the physical map data structure.
	187	*/
0c530ab8 A	188	extern pmap_t pmap_create( /* Create a pmap_t. */
0c530ab8 A	189	vm_map_size_t size,
2d21ac55	190	#ifdef __i386__
0c530ab8	191	boolean_t is_64bit);
2d21ac55 A	192	#else
	193	__unused boolean_t is_64bit);
	194	#endif
1c79356b A	195	extern pmap_t (pmap_kernel)(void); /* Return the kernel's pmap */
	196	extern void pmap_reference(pmap_t pmap); /* Gain a reference. */
	197	extern void pmap_destroy(pmap_t pmap); /* Release a reference. */
	198	extern void pmap_switch(pmap_t);
	199
	200
	201	extern void pmap_enter( /* Enter a mapping */
	202	pmap_t pmap,
91447636	203	vm_map_offset_t v,
55e303ae	204	ppnum_t pn,
1c79356b	205	vm_prot_t prot,
9bccf70c	206	unsigned int flags,
1c79356b A	207	boolean_t wired);
1c79356b A	208
0b4e3aa0 A	209	extern void pmap_remove_some_phys(
0b4e3aa0 A	210	pmap_t pmap,
55e303ae	211	ppnum_t pn);
0b4e3aa0	212
1c79356b A	213
	214	/*
	215	* Routines that operate on physical addresses.
	216	*/
0b4e3aa0	217
1c79356b	218	extern void pmap_page_protect( /* Restrict access to page. */
55e303ae	219	ppnum_t phys,
1c79356b A	220	vm_prot_t prot);
	221
	222	extern void (pmap_zero_page)(
55e303ae	223	ppnum_t pn);
1c79356b A	224
1c79356b A	225	extern void (pmap_zero_part_page)(
55e303ae	226	ppnum_t pn,
1c79356b A	227	vm_offset_t offset,
	228	vm_size_t len);
	229
	230	extern void (pmap_copy_page)(
55e303ae A	231	ppnum_t src,
55e303ae A	232	ppnum_t dest);
1c79356b A	233
1c79356b A	234	extern void (pmap_copy_part_page)(
55e303ae	235	ppnum_t src,
1c79356b	236	vm_offset_t src_offset,
55e303ae	237	ppnum_t dst,
1c79356b A	238	vm_offset_t dst_offset,
	239	vm_size_t len);
	240
	241	extern void (pmap_copy_part_lpage)(
	242	vm_offset_t src,
55e303ae	243	ppnum_t dst,
1c79356b A	244	vm_offset_t dst_offset,
	245	vm_size_t len);
	246
	247	extern void (pmap_copy_part_rpage)(
55e303ae	248	ppnum_t src,
1c79356b A	249	vm_offset_t src_offset,
	250	vm_offset_t dst,
	251	vm_size_t len);
91447636 A	252
	253	extern unsigned int (pmap_disconnect)( /* disconnect mappings and return reference and change */
	254	ppnum_t phys);
	255
	256	extern kern_return_t (pmap_attribute_cache_sync)( /* Flush appropriate
	257	* cache based on
	258	* page number sent */
	259	ppnum_t pn,
	260	vm_size_t size,
	261	vm_machine_attribute_t attribute,
	262	vm_machine_attribute_val_t* value);
1c79356b	263
0c530ab8 A	264	extern unsigned int (pmap_cache_attributes)(
	265	ppnum_t pn);
	266
2d21ac55 A	267	extern void pmap_sync_page_data_phys(ppnum_t pa);
	268	extern void pmap_sync_page_attributes_phys(ppnum_t pa);
	269
1c79356b A	270	/*
	271	* debug/assertions. pmap_verify_free returns true iff
	272	* the given physical page is mapped into no pmap.
	273	*/
55e303ae	274	extern boolean_t pmap_verify_free(ppnum_t pn);
1c79356b A	275
	276	/*
	277	* Statistics routines
	278	*/
	279	extern int (pmap_resident_count)(pmap_t pmap);
2d21ac55	280	extern int (pmap_resident_max)(pmap_t pmap);
1c79356b A	281
	282	/*
	283	* Sundry required (internal) routines
	284	*/
2d21ac55	285	#ifdef CURRENTLY_UNUSED_AND_UNTESTED
1c79356b A	286	extern void pmap_collect(pmap_t pmap);/* Perform garbage
1c79356b A	287	* collection, if any */
2d21ac55	288	#endif
1c79356b A	289	/*
	290	* Optional routines
	291	*/
	292	extern void (pmap_copy)( /* Copy range of mappings,
	293	* if desired. */
	294	pmap_t dest,
	295	pmap_t source,
91447636 A	296	vm_map_offset_t dest_va,
	297	vm_map_size_t size,
	298	vm_map_offset_t source_va);
1c79356b A	299
	300	extern kern_return_t (pmap_attribute)( /* Get/Set special memory
	301	* attributes */
	302	pmap_t pmap,
91447636 A	303	vm_map_offset_t va,
91447636 A	304	vm_map_size_t size,
1c79356b A	305	vm_machine_attribute_t attribute,
	306	vm_machine_attribute_val_t* value);
	307
	308	/*
	309	* Routines defined as macros.
	310	*/
	311	#ifndef PMAP_ACTIVATE_USER
91447636 A	312	#ifndef PMAP_ACTIVATE
	313	#define PMAP_ACTIVATE_USER(thr, cpu)
	314	#else /* PMAP_ACTIVATE */
	315	#define PMAP_ACTIVATE_USER(thr, cpu) { \
1c79356b A	316	pmap_t pmap; \
1c79356b A	317	\
91447636	318	pmap = (thr)->map->pmap; \
1c79356b	319	if (pmap != pmap_kernel()) \
91447636	320	PMAP_ACTIVATE(pmap, (thr), (cpu)); \
1c79356b	321	}
91447636	322	#endif /* PMAP_ACTIVATE */
1c79356b A	323	#endif /* PMAP_ACTIVATE_USER */
	324
	325	#ifndef PMAP_DEACTIVATE_USER
91447636 A	326	#ifndef PMAP_DEACTIVATE
	327	#define PMAP_DEACTIVATE_USER(thr, cpu)
	328	#else /* PMAP_DEACTIVATE */
	329	#define PMAP_DEACTIVATE_USER(thr, cpu) { \
1c79356b A	330	pmap_t pmap; \
1c79356b A	331	\
91447636 A	332	pmap = (thr)->map->pmap; \
	333	if ((pmap) != pmap_kernel()) \
	334	PMAP_DEACTIVATE(pmap, (thr), (cpu)); \
1c79356b	335	}
91447636	336	#endif /* PMAP_DEACTIVATE */
1c79356b A	337	#endif /* PMAP_DEACTIVATE_USER */
	338
	339	#ifndef PMAP_ACTIVATE_KERNEL
91447636 A	340	#ifndef PMAP_ACTIVATE
	341	#define PMAP_ACTIVATE_KERNEL(cpu)
	342	#else /* PMAP_ACTIVATE */
1c79356b	343	#define PMAP_ACTIVATE_KERNEL(cpu) \
91447636 A	344	PMAP_ACTIVATE(pmap_kernel(), THREAD_NULL, cpu)
91447636 A	345	#endif /* PMAP_ACTIVATE */
1c79356b A	346	#endif /* PMAP_ACTIVATE_KERNEL */
	347
	348	#ifndef PMAP_DEACTIVATE_KERNEL
91447636 A	349	#ifndef PMAP_DEACTIVATE
	350	#define PMAP_DEACTIVATE_KERNEL(cpu)
	351	#else /* PMAP_DEACTIVATE */
1c79356b	352	#define PMAP_DEACTIVATE_KERNEL(cpu) \
91447636 A	353	PMAP_DEACTIVATE(pmap_kernel(), THREAD_NULL, cpu)
91447636 A	354	#endif /* PMAP_DEACTIVATE */
1c79356b A	355	#endif /* PMAP_DEACTIVATE_KERNEL */
	356
	357	#ifndef PMAP_ENTER
	358	/*
	359	* Macro to be used in place of pmap_enter()
	360	*/
9bccf70c	361	#define PMAP_ENTER(pmap, virtual_address, page, protection, flags, wired) \
91447636 A	362	MACRO_BEGIN \
	363	pmap_t __pmap = (pmap); \
	364	vm_page_t __page = (page); \
	365	\
	366	if (__pmap != kernel_pmap) { \
	367	ASSERT_PAGE_DECRYPTED(__page); \
	368	} \
2d21ac55 A	369	if (__page->error) { \
	370	panic("VM page %p should not have an error\n", \
	371	__page); \
	372	} \
91447636 A	373	pmap_enter(__pmap, \
	374	(virtual_address), \
	375	__page->phys_page, \
2d21ac55	376	(protection), \
91447636 A	377	(flags), \
	378	(wired)); \
	379	MACRO_END
1c79356b A	380	#endif /* !PMAP_ENTER */
1c79356b A	381
1c79356b A	382	/*
	383	* Routines to manage reference/modify bits based on
	384	* physical addresses, simulating them if not provided
	385	* by the hardware.
	386	*/
	387	/* Clear reference bit */
55e303ae	388	extern void pmap_clear_reference(ppnum_t pn);
1c79356b	389	/* Return reference bit */
55e303ae	390	extern boolean_t (pmap_is_referenced)(ppnum_t pn);
1c79356b	391	/* Set modify bit */
55e303ae	392	extern void pmap_set_modify(ppnum_t pn);
1c79356b	393	/* Clear modify bit */
55e303ae	394	extern void pmap_clear_modify(ppnum_t pn);
1c79356b	395	/* Return modify bit */
55e303ae	396	extern boolean_t pmap_is_modified(ppnum_t pn);
91447636 A	397	/* Return modified and referenced bits */
	398	extern unsigned int pmap_get_refmod(ppnum_t pn);
	399	/* Clear modified and referenced bits */
	400	extern void pmap_clear_refmod(ppnum_t pn, unsigned int mask);
	401	#define VM_MEM_MODIFIED 0x01 /* Modified bit */
	402	#define VM_MEM_REFERENCED 0x02 /* Referenced bit */
1c79356b A	403
	404	/*
	405	* Routines that operate on ranges of virtual addresses.
	406	*/
1c79356b A	407	extern void pmap_protect( /* Change protections. */
1c79356b A	408	pmap_t map,
91447636 A	409	vm_map_offset_t s,
91447636 A	410	vm_map_offset_t e,
1c79356b A	411	vm_prot_t prot);
	412
	413	extern void (pmap_pageable)(
	414	pmap_t pmap,
91447636 A	415	vm_map_offset_t start,
91447636 A	416	vm_map_offset_t end,
1c79356b A	417	boolean_t pageable);
1c79356b A	418
2d21ac55 A	419	#ifndef NO_NESTED_PMAP
	420	extern uint64_t pmap_nesting_size_min;
	421	extern uint64_t pmap_nesting_size_max;
	422	extern kern_return_t pmap_nest(pmap_t grand,
	423	pmap_t subord,
	424	addr64_t vstart,
	425	addr64_t nstart,
	426	uint64_t size);
	427	extern kern_return_t pmap_unnest(pmap_t grand,
	428	addr64_t vaddr,
	429	uint64_t size);
	430	#endif /* NO_NESTED_PMAP */
	431
91447636	432	#endif /* MACH_KERNEL_PRIVATE */
9bccf70c A	433
	434	/*
	435	* JMM - This portion is exported to other kernel components right now,
	436	* but will be pulled back in the future when the needed functionality
	437	* is provided in a cleaner manner.
	438	*/
	439
9bccf70c A	440	extern pmap_t kernel_pmap; /* The kernel's map */
	441	#define pmap_kernel() (kernel_pmap)
	442
	443	/* machine independent WIMG bits */
	444
91447636 A	445	#define VM_MEM_GUARDED 0x1 /* (G) Guarded Storage */
	446	#define VM_MEM_COHERENT 0x2 /* (M) Memory Coherency */
	447	#define VM_MEM_NOT_CACHEABLE 0x4 /* (I) Cache Inhibit */
	448	#define VM_MEM_WRITE_THROUGH 0x8 /* (W) Write-Through */
9bccf70c A	449
	450	#define VM_WIMG_MASK 0xFF
	451	#define VM_WIMG_USE_DEFAULT 0x80000000
	452
1c79356b	453	extern vm_offset_t pmap_extract(pmap_t pmap,
91447636	454	vm_map_offset_t va);
1c79356b A	455
	456	extern void pmap_change_wiring( /* Specify pageability */
	457	pmap_t pmap,
91447636	458	vm_map_offset_t va,
1c79356b	459	boolean_t wired);
9bccf70c	460
91447636	461	/* LP64todo - switch to vm_map_offset_t when it grows */
9bccf70c A	462	extern void pmap_remove( /* Remove mappings. */
9bccf70c A	463	pmap_t map,
2d21ac55 A	464	vm_map_offset_t s,
	465	vm_map_offset_t e);
	466
	467	extern void fillPage(ppnum_t pa, unsigned int fill);
55e303ae	468
2d21ac55 A	469	extern void pmap_map_sharedpage(task_t task, pmap_t pmap);
2d21ac55 A	470	extern void pmap_unmap_sharedpage(pmap_t pmap);
9bccf70c	471
91447636	472	#endif /* KERNEL_PRIVATE */
9bccf70c	473
1c79356b	474	#endif /* _VM_PMAP_H_ */