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

/*
 * Copyright (c) 2000-2004 Apple Computer, 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);	/* 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,
				boolean_t	is_64bit);
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);

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

/*
 *	Sundry required (internal) routines
 */
extern void		pmap_collect(pmap_t pmap);/* Perform garbage
						 * collection, if any */

/*
 *	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);				\
	}								\
	pmap_enter(__pmap,						\
		   (virtual_address),					\
		   __page->phys_page,					\
		   (protection) & ~__page->page_lock,			\
		   (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);

#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 void		pmap_modify_pages(	/* Set modify bit for pages */
				pmap_t		map,
				vm_map_offset_t	s,
				vm_map_offset_t	e);

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,
				addr64_t	s,
				addr64_t	e);


#endif  /* KERNEL_PRIVATE */

#endif	/* _VM_PMAP_H_ */
Commit	Line	Data
1c79356b	1	/*
91447636	2	* Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
1c79356b	3	*
8f6c56a5	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
8f6c56a5 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.
	14	*
	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
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
8ad349bb	24	* limitations under the License.
8f6c56a5 A	25	*
8f6c56a5 A	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	*/
	144	extern void pmap_init(void); /* Initialization,
	145	* after kernel runs
	146	* in virtual memory.
	147	*/
	148
91447636 A	149	extern void mapping_adjust(void); /* Adjust free mapping count */
	150
	151	extern void mapping_free_prime(void); /* Primes the mapping block release list */
	152
1c79356b A	153	#ifndef MACHINE_PAGES
	154	/*
	155	* If machine/pmap.h defines MACHINE_PAGES, it must implement
	156	* the above functions. The pmap module has complete control.
	157	* Otherwise, it must implement
	158	* pmap_free_pages
	159	* pmap_virtual_space
	160	* pmap_next_page
	161	* pmap_init
	162	* and vm/vm_resident.c implements pmap_steal_memory and pmap_startup
	163	* using pmap_free_pages, pmap_next_page, pmap_virtual_space,
	164	* and pmap_enter. pmap_free_pages may over-estimate the number
	165	* of unused physical pages, and pmap_next_page may return FALSE
	166	* to indicate that there are no more unused pages to return.
	167	* However, for best performance pmap_free_pages should be accurate.
	168	*/
	169
55e303ae	170	extern boolean_t pmap_next_page(ppnum_t *pnum);
1c79356b A	171	/* During VM initialization,
	172	* return the next unused
	173	* physical page.
	174	*/
	175	extern void pmap_virtual_space(
	176	vm_offset_t *virtual_start,
	177	vm_offset_t *virtual_end);
	178	/* During VM initialization,
	179	* report virtual space
	180	* available for the kernel.
	181	*/
	182	#endif /* MACHINE_PAGES */
	183
	184	/*
	185	* Routines to manage the physical map data structure.
	186	*/
89b3af67 A	187	extern pmap_t pmap_create( /* Create a pmap_t. */
	188	vm_map_size_t size,
	189	boolean_t is_64bit);
1c79356b A	190	extern pmap_t (pmap_kernel)(void); /* Return the kernel's pmap */
	191	extern void pmap_reference(pmap_t pmap); /* Gain a reference. */
	192	extern void pmap_destroy(pmap_t pmap); /* Release a reference. */
	193	extern void pmap_switch(pmap_t);
	194
	195
	196	extern void pmap_enter( /* Enter a mapping */
	197	pmap_t pmap,
91447636	198	vm_map_offset_t v,
55e303ae	199	ppnum_t pn,
1c79356b	200	vm_prot_t prot,
9bccf70c	201	unsigned int flags,
1c79356b A	202	boolean_t wired);
1c79356b A	203
0b4e3aa0 A	204	extern void pmap_remove_some_phys(
0b4e3aa0 A	205	pmap_t pmap,
55e303ae	206	ppnum_t pn);
0b4e3aa0	207
1c79356b A	208
	209	/*
	210	* Routines that operate on physical addresses.
	211	*/
0b4e3aa0	212
1c79356b	213	extern void pmap_page_protect( /* Restrict access to page. */
55e303ae	214	ppnum_t phys,
1c79356b A	215	vm_prot_t prot);
	216
	217	extern void (pmap_zero_page)(
55e303ae	218	ppnum_t pn);
1c79356b A	219
1c79356b A	220	extern void (pmap_zero_part_page)(
55e303ae	221	ppnum_t pn,
1c79356b A	222	vm_offset_t offset,
	223	vm_size_t len);
	224
	225	extern void (pmap_copy_page)(
55e303ae A	226	ppnum_t src,
55e303ae A	227	ppnum_t dest);
1c79356b A	228
1c79356b A	229	extern void (pmap_copy_part_page)(
55e303ae	230	ppnum_t src,
1c79356b	231	vm_offset_t src_offset,
55e303ae	232	ppnum_t dst,
1c79356b A	233	vm_offset_t dst_offset,
	234	vm_size_t len);
	235
	236	extern void (pmap_copy_part_lpage)(
	237	vm_offset_t src,
55e303ae	238	ppnum_t dst,
1c79356b A	239	vm_offset_t dst_offset,
	240	vm_size_t len);
	241
	242	extern void (pmap_copy_part_rpage)(
55e303ae	243	ppnum_t src,
1c79356b A	244	vm_offset_t src_offset,
	245	vm_offset_t dst,
	246	vm_size_t len);
91447636 A	247
	248	extern unsigned int (pmap_disconnect)( /* disconnect mappings and return reference and change */
	249	ppnum_t phys);
	250
	251	extern kern_return_t (pmap_attribute_cache_sync)( /* Flush appropriate
	252	* cache based on
	253	* page number sent */
	254	ppnum_t pn,
	255	vm_size_t size,
	256	vm_machine_attribute_t attribute,
	257	vm_machine_attribute_val_t* value);
1c79356b	258
89b3af67 A	259	extern unsigned int (pmap_cache_attributes)(
	260	ppnum_t pn);
	261
1c79356b A	262	/*
	263	* debug/assertions. pmap_verify_free returns true iff
	264	* the given physical page is mapped into no pmap.
	265	*/
55e303ae	266	extern boolean_t pmap_verify_free(ppnum_t pn);
1c79356b A	267
	268	/*
	269	* Statistics routines
	270	*/
	271	extern int (pmap_resident_count)(pmap_t pmap);
	272
	273	/*
	274	* Sundry required (internal) routines
	275	*/
	276	extern void pmap_collect(pmap_t pmap);/* Perform garbage
	277	* collection, if any */
	278
1c79356b A	279	/*
	280	* Optional routines
	281	*/
	282	extern void (pmap_copy)( /* Copy range of mappings,
	283	* if desired. */
	284	pmap_t dest,
	285	pmap_t source,
91447636 A	286	vm_map_offset_t dest_va,
	287	vm_map_size_t size,
	288	vm_map_offset_t source_va);
1c79356b A	289
	290	extern kern_return_t (pmap_attribute)( /* Get/Set special memory
	291	* attributes */
	292	pmap_t pmap,
91447636 A	293	vm_map_offset_t va,
91447636 A	294	vm_map_size_t size,
1c79356b A	295	vm_machine_attribute_t attribute,
	296	vm_machine_attribute_val_t* value);
	297
	298	/*
	299	* Routines defined as macros.
	300	*/
	301	#ifndef PMAP_ACTIVATE_USER
91447636 A	302	#ifndef PMAP_ACTIVATE
	303	#define PMAP_ACTIVATE_USER(thr, cpu)
	304	#else /* PMAP_ACTIVATE */
	305	#define PMAP_ACTIVATE_USER(thr, cpu) { \
1c79356b A	306	pmap_t pmap; \
1c79356b A	307	\
91447636	308	pmap = (thr)->map->pmap; \
1c79356b	309	if (pmap != pmap_kernel()) \
91447636	310	PMAP_ACTIVATE(pmap, (thr), (cpu)); \
1c79356b	311	}
91447636	312	#endif /* PMAP_ACTIVATE */
1c79356b A	313	#endif /* PMAP_ACTIVATE_USER */
	314
	315	#ifndef PMAP_DEACTIVATE_USER
91447636 A	316	#ifndef PMAP_DEACTIVATE
	317	#define PMAP_DEACTIVATE_USER(thr, cpu)
	318	#else /* PMAP_DEACTIVATE */
	319	#define PMAP_DEACTIVATE_USER(thr, cpu) { \
1c79356b A	320	pmap_t pmap; \
1c79356b A	321	\
91447636 A	322	pmap = (thr)->map->pmap; \
	323	if ((pmap) != pmap_kernel()) \
	324	PMAP_DEACTIVATE(pmap, (thr), (cpu)); \
1c79356b	325	}
91447636	326	#endif /* PMAP_DEACTIVATE */
1c79356b A	327	#endif /* PMAP_DEACTIVATE_USER */
	328
	329	#ifndef PMAP_ACTIVATE_KERNEL
91447636 A	330	#ifndef PMAP_ACTIVATE
	331	#define PMAP_ACTIVATE_KERNEL(cpu)
	332	#else /* PMAP_ACTIVATE */
1c79356b	333	#define PMAP_ACTIVATE_KERNEL(cpu) \
91447636 A	334	PMAP_ACTIVATE(pmap_kernel(), THREAD_NULL, cpu)
91447636 A	335	#endif /* PMAP_ACTIVATE */
1c79356b A	336	#endif /* PMAP_ACTIVATE_KERNEL */
	337
	338	#ifndef PMAP_DEACTIVATE_KERNEL
91447636 A	339	#ifndef PMAP_DEACTIVATE
	340	#define PMAP_DEACTIVATE_KERNEL(cpu)
	341	#else /* PMAP_DEACTIVATE */
1c79356b	342	#define PMAP_DEACTIVATE_KERNEL(cpu) \
91447636 A	343	PMAP_DEACTIVATE(pmap_kernel(), THREAD_NULL, cpu)
91447636 A	344	#endif /* PMAP_DEACTIVATE */
1c79356b A	345	#endif /* PMAP_DEACTIVATE_KERNEL */
	346
	347	#ifndef PMAP_ENTER
	348	/*
	349	* Macro to be used in place of pmap_enter()
	350	*/
9bccf70c	351	#define PMAP_ENTER(pmap, virtual_address, page, protection, flags, wired) \
91447636 A	352	MACRO_BEGIN \
	353	pmap_t __pmap = (pmap); \
	354	vm_page_t __page = (page); \
	355	\
	356	if (__pmap != kernel_pmap) { \
	357	ASSERT_PAGE_DECRYPTED(__page); \
	358	} \
	359	pmap_enter(__pmap, \
	360	(virtual_address), \
	361	__page->phys_page, \
	362	(protection) & ~__page->page_lock, \
	363	(flags), \
	364	(wired)); \
	365	MACRO_END
1c79356b A	366	#endif /* !PMAP_ENTER */
1c79356b A	367
1c79356b A	368	/*
	369	* Routines to manage reference/modify bits based on
	370	* physical addresses, simulating them if not provided
	371	* by the hardware.
	372	*/
	373	/* Clear reference bit */
55e303ae	374	extern void pmap_clear_reference(ppnum_t pn);
1c79356b	375	/* Return reference bit */
55e303ae	376	extern boolean_t (pmap_is_referenced)(ppnum_t pn);
1c79356b	377	/* Set modify bit */
55e303ae	378	extern void pmap_set_modify(ppnum_t pn);
1c79356b	379	/* Clear modify bit */
55e303ae	380	extern void pmap_clear_modify(ppnum_t pn);
1c79356b	381	/* Return modify bit */
55e303ae	382	extern boolean_t pmap_is_modified(ppnum_t pn);
91447636 A	383	/* Return modified and referenced bits */
	384	extern unsigned int pmap_get_refmod(ppnum_t pn);
	385	/* Clear modified and referenced bits */
	386	extern void pmap_clear_refmod(ppnum_t pn, unsigned int mask);
	387	#define VM_MEM_MODIFIED 0x01 /* Modified bit */
	388	#define VM_MEM_REFERENCED 0x02 /* Referenced bit */
1c79356b A	389
	390	/*
	391	* Routines that operate on ranges of virtual addresses.
	392	*/
1c79356b A	393	extern void pmap_protect( /* Change protections. */
1c79356b A	394	pmap_t map,
91447636 A	395	vm_map_offset_t s,
91447636 A	396	vm_map_offset_t e,
1c79356b A	397	vm_prot_t prot);
	398
	399	extern void (pmap_pageable)(
	400	pmap_t pmap,
91447636 A	401	vm_map_offset_t start,
91447636 A	402	vm_map_offset_t end,
1c79356b A	403	boolean_t pageable);
1c79356b A	404
91447636	405	#endif /* MACH_KERNEL_PRIVATE */
9bccf70c A	406
	407	/*
	408	* JMM - This portion is exported to other kernel components right now,
	409	* but will be pulled back in the future when the needed functionality
	410	* is provided in a cleaner manner.
	411	*/
	412
9bccf70c A	413	extern pmap_t kernel_pmap; /* The kernel's map */
	414	#define pmap_kernel() (kernel_pmap)
	415
	416	/* machine independent WIMG bits */
	417
91447636 A	418	#define VM_MEM_GUARDED 0x1 /* (G) Guarded Storage */
	419	#define VM_MEM_COHERENT 0x2 /* (M) Memory Coherency */
	420	#define VM_MEM_NOT_CACHEABLE 0x4 /* (I) Cache Inhibit */
	421	#define VM_MEM_WRITE_THROUGH 0x8 /* (W) Write-Through */
9bccf70c A	422
	423	#define VM_WIMG_MASK 0xFF
	424	#define VM_WIMG_USE_DEFAULT 0x80000000
	425
1c79356b A	426	extern void pmap_modify_pages( /* Set modify bit for pages */
1c79356b A	427	pmap_t map,
91447636 A	428	vm_map_offset_t s,
91447636 A	429	vm_map_offset_t e);
1c79356b A	430
1c79356b A	431	extern vm_offset_t pmap_extract(pmap_t pmap,
91447636	432	vm_map_offset_t va);
1c79356b A	433
	434	extern void pmap_change_wiring( /* Specify pageability */
	435	pmap_t pmap,
91447636	436	vm_map_offset_t va,
1c79356b	437	boolean_t wired);
9bccf70c	438
91447636	439	/* LP64todo - switch to vm_map_offset_t when it grows */
9bccf70c A	440	extern void pmap_remove( /* Remove mappings. */
9bccf70c A	441	pmap_t map,
55e303ae A	442	addr64_t s,
	443	addr64_t e);
	444
9bccf70c	445
91447636	446	#endif /* KERNEL_PRIVATE */
9bccf70c	447
1c79356b	448	#endif /* _VM_PMAP_H_ */