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

/*
 * 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,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>

/*
 *	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.
 */

#ifndef MACH_KERNEL_PRIVATE

typedef void *pmap_t;

#else /* MACH_KERNEL_PRIVATE */

typedef struct pmap *pmap_t;

#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.
 */

extern vm_offset_t	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.
						 */

#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(vm_offset_t *paddr);
						/* 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(vm_size_t size);	/* Create a pmap_t. */
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_offset_t	v,
				vm_offset_t	pa,
				vm_prot_t	prot,
				boolean_t	wired);

extern void		pmap_remove_some_phys(
				pmap_t		pmap,
				vm_offset_t	pa);


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

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

extern void		(pmap_zero_page)(
				vm_offset_t	phys);

extern void		(pmap_zero_part_page)(
				vm_offset_t	p,
				vm_offset_t     offset,
				vm_size_t       len);

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

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

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

extern void		(pmap_copy_part_rpage)(
				vm_offset_t	src,
				vm_offset_t	src_offset,
				vm_offset_t	dst,
				vm_size_t	len);

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

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


extern vm_offset_t	(pmap_phys_address)(	/* Transform address returned
						 * by device driver mapping
						 * function to physical address
						 * known to this module.  */
				int		frame);

extern int		(pmap_phys_to_frame)(	/* Inverse of pmap_phys_addess,
						 * for use by device driver
						 * mapping function in
						 * machine-independent
						 * pseudo-devices.  */
				vm_offset_t	phys);

/*
 *	Optional routines
 */
extern void		(pmap_copy)(		/* Copy range of mappings,
						 * if desired. */
				pmap_t		dest,
				pmap_t		source,
				vm_offset_t	dest_va,
				vm_size_t	size,
				vm_offset_t	source_va);

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

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

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

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

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

#ifndef	PMAP_ENTER
/*
 *	Macro to be used in place of pmap_enter()
 */
#define PMAP_ENTER(pmap, virtual_address, page, protection, wired) \
		MACRO_BEGIN					\
		pmap_enter(					\
			(pmap),					\
			(virtual_address),			\
			(page)->phys_addr,			\
			(protection) & ~(page)->page_lock,	\
			(wired)					\
		 );						\
		MACRO_END
#endif	/* !PMAP_ENTER */

#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.
 */

#define PMAP_NULL  ((pmap_t) 0)

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

/*
 *	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(vm_offset_t paddr);
				/* Return reference bit */
extern boolean_t	(pmap_is_referenced)(vm_offset_t paddr);
				/* Set modify bit */
extern void             pmap_set_modify(vm_offset_t paddr);
				/* Clear modify bit */
extern void		pmap_clear_modify(vm_offset_t paddr);
				/* Return modify bit */
extern boolean_t	pmap_is_modified(vm_offset_t paddr);

/*
 *	Routines that operate on ranges of virtual addresses.
 */
extern void		pmap_remove(	/* Remove mappings. */
				pmap_t		map,
				vm_offset_t	s,
				vm_offset_t	e);

extern void		pmap_protect(	/* Change protections. */
				pmap_t		map,
				vm_offset_t	s,
				vm_offset_t	e,
				vm_prot_t	prot);

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

extern void		pmap_modify_pages(	/* Set modify bit for pages */
				pmap_t		map,
				vm_offset_t	s,
				vm_offset_t	e);

extern vm_offset_t	pmap_extract(pmap_t pmap,
				vm_offset_t va);

extern void		pmap_change_wiring(	/* Specify pageability */
				pmap_t		pmap,
				vm_offset_t	va,
				boolean_t	wired);
#endif	/* _VM_PMAP_H_ */
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,1989,1988,1987 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/pmap.h
	54	* Author: Avadis Tevanian, Jr.
	55	* Date: 1985
	56	*
	57	* Machine address mapping definitions -- machine-independent
	58	* section. [For machine-dependent section, see "machine/pmap.h".]
	59	*/
	60
	61	#ifndef _VM_PMAP_H_
	62	#define _VM_PMAP_H_
	63
	64	#include <mach/kern_return.h>
65	#include <mach/vm_param.h>
66	#include <mach/vm_types.h>
67	#include <mach/vm_attributes.h>
68	#include <mach/boolean.h>
69	#include <mach/vm_prot.h>
70
71	/*
72	* The following is a description of the interface to the
73	* machine-dependent "physical map" data structure. The module
74	* must provide a "pmap_t" data type that represents the
75	* set of valid virtual-to-physical addresses for one user
76	* address space. [The kernel address space is represented
77	* by a distinguished "pmap_t".] The routines described manage
78	* this type, install and update virtual-to-physical mappings,
79	* and perform operations on physical addresses common to
80	* many address spaces.
81	*/
82
83	#ifndef MACH_KERNEL_PRIVATE
84
85	typedef void *pmap_t;
86
87	#else /* MACH_KERNEL_PRIVATE */
88
89	typedef struct pmap *pmap_t;
90
91	#include <machine/pmap.h>
92
93	/*
94	* Routines used for initialization.
95	* There is traditionally also a pmap_bootstrap,
96	* used very early by machine-dependent code,
97	* but it is not part of the interface.
98	*/
99
100	extern vm_offset_t pmap_steal_memory(vm_size_t size);
101	/* During VM initialization,
102	* steal a chunk of memory.
103	*/
104	extern unsigned int pmap_free_pages(void); /* During VM initialization,
105	* report remaining unused
106	* physical pages.
107	*/
108	extern void pmap_startup(
109	vm_offset_t *startp,
110	vm_offset_t *endp);
111	/* During VM initialization,
112	* use remaining physical pages
113	* to allocate page frames.
114	*/
115	extern void pmap_init(void); /* Initialization,
116	* after kernel runs
117	* in virtual memory.
118	*/
119
120	#ifndef MACHINE_PAGES
121	/*
122	* If machine/pmap.h defines MACHINE_PAGES, it must implement
123	* the above functions. The pmap module has complete control.
124	* Otherwise, it must implement
125	* pmap_free_pages
126	* pmap_virtual_space
127	* pmap_next_page
128	* pmap_init
129	* and vm/vm_resident.c implements pmap_steal_memory and pmap_startup
130	* using pmap_free_pages, pmap_next_page, pmap_virtual_space,
131	* and pmap_enter. pmap_free_pages may over-estimate the number
132	* of unused physical pages, and pmap_next_page may return FALSE
133	* to indicate that there are no more unused pages to return.
134	* However, for best performance pmap_free_pages should be accurate.
135	*/
136
137	extern boolean_t pmap_next_page(vm_offset_t *paddr);
138	/* During VM initialization,
139	* return the next unused
140	* physical page.
141	*/
142	extern void pmap_virtual_space(
143	vm_offset_t *virtual_start,
144	vm_offset_t *virtual_end);
145	/* During VM initialization,
146	* report virtual space
147	* available for the kernel.
148	*/
149	#endif /* MACHINE_PAGES */
150
151	/*
152	* Routines to manage the physical map data structure.
153	*/
154	extern pmap_t pmap_create(vm_size_t size); /* Create a pmap_t. */
155	extern pmap_t (pmap_kernel)(void); /* Return the kernel's pmap */
156	extern void pmap_reference(pmap_t pmap); /* Gain a reference. */
157	extern void pmap_destroy(pmap_t pmap); /* Release a reference. */
158	extern void pmap_switch(pmap_t);
159
160
161	extern void pmap_enter( /* Enter a mapping */
162	pmap_t pmap,
163	vm_offset_t v,
164	vm_offset_t pa,
165	vm_prot_t prot,
166	boolean_t wired);
167
0b4e3aa0 A	168	extern void pmap_remove_some_phys(
	169	pmap_t pmap,
	170	vm_offset_t pa);
	171
1c79356b A	172
	173	/*
	174	* Routines that operate on physical addresses.
	175	*/
0b4e3aa0	176
1c79356b A	177	extern void pmap_page_protect( /* Restrict access to page. */
	178	vm_offset_t phys,
	179	vm_prot_t prot);
	180
	181	extern void (pmap_zero_page)(
	182	vm_offset_t phys);
	183
	184	extern void (pmap_zero_part_page)(
	185	vm_offset_t p,
	186	vm_offset_t offset,
	187	vm_size_t len);
	188
	189	extern void (pmap_copy_page)(
	190	vm_offset_t src,
	191	vm_offset_t dest);
	192
	193	extern void (pmap_copy_part_page)(
	194	vm_offset_t src,
	195	vm_offset_t src_offset,
	196	vm_offset_t dst,
	197	vm_offset_t dst_offset,
	198	vm_size_t len);
	199
	200	extern void (pmap_copy_part_lpage)(
	201	vm_offset_t src,
	202	vm_offset_t dst,
	203	vm_offset_t dst_offset,
	204	vm_size_t len);
	205
	206	extern void (pmap_copy_part_rpage)(
	207	vm_offset_t src,
	208	vm_offset_t src_offset,
	209	vm_offset_t dst,
	210	vm_size_t len);
	211
	212	/*
	213	* debug/assertions. pmap_verify_free returns true iff
	214	* the given physical page is mapped into no pmap.
	215	*/
	216	extern boolean_t pmap_verify_free(vm_offset_t paddr);
	217
	218	/*
	219	* Statistics routines
	220	*/
	221	extern int (pmap_resident_count)(pmap_t pmap);
	222
	223	/*
	224	* Sundry required (internal) routines
	225	*/
	226	extern void pmap_collect(pmap_t pmap);/* Perform garbage
	227	* collection, if any */
	228
	229
	230	extern vm_offset_t (pmap_phys_address)( /* Transform address returned
	231	* by device driver mapping
	232	* function to physical address
	233	* known to this module. */
	234	int frame);
	235
	236	extern int (pmap_phys_to_frame)( /* Inverse of pmap_phys_addess,
	237	* for use by device driver
	238	* mapping function in
	239	* machine-independent
	240	* pseudo-devices. */
241	vm_offset_t phys);
242
243	/*
244	* Optional routines
245	*/
246	extern void (pmap_copy)( /* Copy range of mappings,
247	* if desired. */
248	pmap_t dest,
249	pmap_t source,
250	vm_offset_t dest_va,
251	vm_size_t size,
252	vm_offset_t source_va);
253
254	extern kern_return_t (pmap_attribute)( /* Get/Set special memory
255	* attributes */
256	pmap_t pmap,
257	vm_offset_t va,
258	vm_size_t size,
259	vm_machine_attribute_t attribute,
260	vm_machine_attribute_val_t* value);
261
262	/*
263	* Routines defined as macros.
264	*/
265	#ifndef PMAP_ACTIVATE_USER
266	#define PMAP_ACTIVATE_USER(act, cpu) { \
267	pmap_t pmap; \
268	\
269	pmap = (act)->map->pmap; \
270	if (pmap != pmap_kernel()) \
271	PMAP_ACTIVATE(pmap, (act), (cpu)); \
272	}
273	#endif /* PMAP_ACTIVATE_USER */
274
275	#ifndef PMAP_DEACTIVATE_USER
276	#define PMAP_DEACTIVATE_USER(act, cpu) { \
277	pmap_t pmap; \
278	\
279	pmap = (act)->map->pmap; \
280	if ((pmap) != pmap_kernel()) \
281	PMAP_DEACTIVATE(pmap, (act), (cpu)); \
282	}
283	#endif /* PMAP_DEACTIVATE_USER */
284
285	#ifndef PMAP_ACTIVATE_KERNEL
286	#define PMAP_ACTIVATE_KERNEL(cpu) \
287	PMAP_ACTIVATE(pmap_kernel(), THR_ACT_NULL, cpu)
288	#endif /* PMAP_ACTIVATE_KERNEL */
289
290	#ifndef PMAP_DEACTIVATE_KERNEL
291	#define PMAP_DEACTIVATE_KERNEL(cpu) \
292	PMAP_DEACTIVATE(pmap_kernel(), THR_ACT_NULL, cpu)
293	#endif /* PMAP_DEACTIVATE_KERNEL */
294
295	#ifndef PMAP_ENTER
296	/*
297	* Macro to be used in place of pmap_enter()
298	*/
299	#define PMAP_ENTER(pmap, virtual_address, page, protection, wired) \
300	MACRO_BEGIN \
301	pmap_enter( \
302	(pmap), \
303	(virtual_address), \
304	(page)->phys_addr, \
305	(protection) & ~(page)->page_lock, \
306	(wired) \
307	); \
308	MACRO_END
309	#endif /* !PMAP_ENTER */
310
311	#endif /* MACH_KERNEL_PRIVATE */
312
313	/*
314	* JMM - This portion is exported to other kernel components right now,
315	* but will be pulled back in the future when the needed functionality
316	* is provided in a cleaner manner.
317	*/
318
319	#define PMAP_NULL ((pmap_t) 0)
320
321	extern pmap_t kernel_pmap; /* The kernel's map */
322	#define pmap_kernel() (kernel_pmap)
323
324	/*
325	* Routines to manage reference/modify bits based on
326	* physical addresses, simulating them if not provided
327	* by the hardware.
328	*/
329	/* Clear reference bit */
330	extern void pmap_clear_reference(vm_offset_t paddr);
331	/* Return reference bit */
332	extern boolean_t (pmap_is_referenced)(vm_offset_t paddr);
333	/* Set modify bit */
334	extern void pmap_set_modify(vm_offset_t paddr);
335	/* Clear modify bit */
336	extern void pmap_clear_modify(vm_offset_t paddr);
337	/* Return modify bit */
338	extern boolean_t pmap_is_modified(vm_offset_t paddr);
339
340	/*
341	* Routines that operate on ranges of virtual addresses.
342	*/
343	extern void pmap_remove( /* Remove mappings. */
344	pmap_t map,
345	vm_offset_t s,
346	vm_offset_t e);
347
348	extern void pmap_protect( /* Change protections. */
349	pmap_t map,
350	vm_offset_t s,
351	vm_offset_t e,
352	vm_prot_t prot);
353
354	extern void (pmap_pageable)(
355	pmap_t pmap,
356	vm_offset_t start,
357	vm_offset_t end,
358	boolean_t pageable);
359
360	extern void pmap_modify_pages( /* Set modify bit for pages */
361	pmap_t map,
362	vm_offset_t s,
363	vm_offset_t e);
364
365	extern vm_offset_t pmap_extract(pmap_t pmap,
366	vm_offset_t va);
367
368	extern void pmap_change_wiring( /* Specify pageability */
369	pmap_t pmap,
370	vm_offset_t va,
371	boolean_t wired);
372	#endif /* _VM_PMAP_H_ */