xref: /freebsd/sys/vm/vm_map.h (revision 71fe318b852b8dfb3e799cb12ef184750f7f8eac)
1 /*
2  * Copyright (c) 1991, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * The Mach Operating System project at Carnegie-Mellon University.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *	This product includes software developed by the University of
19  *	California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  *	@(#)vm_map.h	8.9 (Berkeley) 5/17/95
37  *
38  *
39  * Copyright (c) 1987, 1990 Carnegie-Mellon University.
40  * All rights reserved.
41  *
42  * Authors: Avadis Tevanian, Jr., Michael Wayne Young
43  *
44  * Permission to use, copy, modify and distribute this software and
45  * its documentation is hereby granted, provided that both the copyright
46  * notice and this permission notice appear in all copies of the
47  * software, derivative works or modified versions, and any portions
48  * thereof, and that both notices appear in supporting documentation.
49  *
50  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
51  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
52  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
53  *
54  * Carnegie Mellon requests users of this software to return to
55  *
56  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
57  *  School of Computer Science
58  *  Carnegie Mellon University
59  *  Pittsburgh PA 15213-3890
60  *
61  * any improvements or extensions that they make and grant Carnegie the
62  * rights to redistribute these changes.
63  *
64  * $FreeBSD$
65  */
66 
67 /*
68  *	Virtual memory map module definitions.
69  */
70 #ifndef	_VM_MAP_
71 #define	_VM_MAP_
72 
73 #include <sys/lock.h>
74 #include <sys/lockmgr.h>
75 
76 /*
77  *	Types defined:
78  *
79  *	vm_map_t		the high-level address map data structure.
80  *	vm_map_entry_t		an entry in an address map.
81  */
82 
83 typedef u_int vm_eflags_t;
84 
85 /*
86  *	Objects which live in maps may be either VM objects, or
87  *	another map (called a "sharing map") which denotes read-write
88  *	sharing with other maps.
89  */
90 union vm_map_object {
91 	struct vm_object *vm_object;	/* object object */
92 	struct vm_map *sub_map;		/* belongs to another map */
93 };
94 
95 /*
96  *	Address map entries consist of start and end addresses,
97  *	a VM object (or sharing map) and offset into that object,
98  *	and user-exported inheritance and protection information.
99  *	Also included is control information for virtual copy operations.
100  */
101 struct vm_map_entry {
102 	struct vm_map_entry *prev;	/* previous entry */
103 	struct vm_map_entry *next;	/* next entry */
104 	struct vm_map_entry *left;	/* left child in binary search tree */
105 	struct vm_map_entry *right;	/* right child in binary search tree */
106 	vm_offset_t start;		/* start address */
107 	vm_offset_t end;		/* end address */
108 	vm_offset_t avail_ssize;	/* amt can grow if this is a stack */
109 	union vm_map_object object;	/* object I point to */
110 	vm_ooffset_t offset;		/* offset into object */
111 	vm_eflags_t eflags;		/* map entry flags */
112 	/* Only in task maps: */
113 	vm_prot_t protection;		/* protection code */
114 	vm_prot_t max_protection;	/* maximum protection */
115 	vm_inherit_t inheritance;	/* inheritance */
116 	int wired_count;		/* can be paged if = 0 */
117 	vm_pindex_t lastr;		/* last read */
118 };
119 
120 #define MAP_ENTRY_NOSYNC		0x0001
121 #define MAP_ENTRY_IS_SUB_MAP		0x0002
122 #define MAP_ENTRY_COW			0x0004
123 #define MAP_ENTRY_NEEDS_COPY		0x0008
124 #define MAP_ENTRY_NOFAULT		0x0010
125 #define MAP_ENTRY_USER_WIRED		0x0020
126 
127 #define MAP_ENTRY_BEHAV_NORMAL		0x0000	/* default behavior */
128 #define MAP_ENTRY_BEHAV_SEQUENTIAL	0x0040	/* expect sequential access */
129 #define MAP_ENTRY_BEHAV_RANDOM		0x0080	/* expect random access */
130 #define MAP_ENTRY_BEHAV_RESERVED	0x00C0	/* future use */
131 
132 #define MAP_ENTRY_BEHAV_MASK		0x00C0
133 
134 #define MAP_ENTRY_IN_TRANSITION		0x0100	/* entry being changed */
135 #define MAP_ENTRY_NEEDS_WAKEUP		0x0200	/* waiters in transition */
136 #define MAP_ENTRY_NOCOREDUMP		0x0400	/* don't include in a core */
137 
138 #ifdef	_KERNEL
139 static __inline u_char
140 vm_map_entry_behavior(vm_map_entry_t entry)
141 {
142 	return (entry->eflags & MAP_ENTRY_BEHAV_MASK);
143 }
144 #endif	/* _KERNEL */
145 
146 /*
147  *	A map is a set of map entries.  These map entries are
148  *	organized both as a binary search tree and as a doubly-linked
149  *	list.  Both structures are ordered based upon the start and
150  *	end addresses contained within each map entry.  Sleator and
151  *	Tarjan's top-down splay algorithm is employed to control
152  *	height imbalance in the binary search tree.
153  *
154  *	Note: the lock structure cannot be the first element of vm_map
155  *	because this can result in a running lockup between two or more
156  *	system processes trying to kmem_alloc_wait() due to kmem_alloc_wait()
157  *	and free tsleep/waking up 'map' and the underlying lockmgr also
158  *	sleeping and waking up on 'map'.  The lockup occurs when the map fills
159  *	up.  The 'exec' map, for example.
160  *
161  * List of locks
162  *	(c)	const until freed
163  */
164 struct vm_map {
165 	struct vm_map_entry header;	/* List of entries */
166 	struct lock lock;		/* Lock for map data */
167 	int nentries;			/* Number of entries */
168 	vm_size_t size;			/* virtual size */
169 	u_char needs_wakeup;
170 	u_char system_map;		/* Am I a system map? */
171 	u_char infork;			/* Am I in fork processing? */
172 	vm_map_entry_t root;		/* Root of a binary search tree */
173 	unsigned int timestamp;		/* Version number */
174 	vm_map_entry_t first_free;	/* First free space hint */
175 	pmap_t pmap;			/* (c) Physical map */
176 #define	min_offset	header.start	/* (c) */
177 #define	max_offset	header.end	/* (c) */
178 };
179 
180 #ifdef	_KERNEL
181 static __inline vm_offset_t
182 vm_map_max(vm_map_t map)
183 {
184 	return (map->max_offset);
185 }
186 
187 static __inline vm_offset_t
188 vm_map_min(vm_map_t map)
189 {
190 	return (map->min_offset);
191 }
192 
193 static __inline pmap_t
194 vm_map_pmap(vm_map_t map)
195 {
196 	return (map->pmap);
197 }
198 #endif	/* _KERNEL */
199 
200 /*
201  * Shareable process virtual address space.
202  *
203  * List of locks
204  *	(c)	const until freed
205  */
206 struct vmspace {
207 	struct vm_map vm_map;	/* VM address map */
208 	struct pmap vm_pmap;	/* private physical map */
209 	int vm_refcnt;		/* number of references */
210 	struct shmmap_state *vm_shm;	/* SYS5 shared memory private data XXX */
211 /* we copy from vm_startcopy to the end of the structure on fork */
212 #define vm_startcopy vm_rssize
213 	segsz_t vm_rssize;	/* current resident set size in pages */
214 	segsz_t vm_swrss;	/* resident set size before last swap */
215 	segsz_t vm_tsize;	/* text size (pages) XXX */
216 	segsz_t vm_dsize;	/* data size (pages) XXX */
217 	segsz_t vm_ssize;	/* stack size (pages) */
218 	caddr_t vm_taddr;	/* (c) user virtual address of text */
219 	caddr_t vm_daddr;	/* (c) user virtual address of data */
220 	caddr_t vm_maxsaddr;	/* user VA at max stack growth */
221 #define	vm_endcopy vm_freer
222 	struct proc *vm_freer;	/* vm freed on whose behalf */
223 };
224 
225 #ifdef	_KERNEL
226 static __inline pmap_t
227 vmspace_pmap(struct vmspace *vmspace)
228 {
229 	return &vmspace->vm_pmap;
230 }
231 #endif	/* _KERNEL */
232 
233 #ifdef	_KERNEL
234 /*
235  *	Macros:		vm_map_lock, etc.
236  *	Function:
237  *		Perform locking on the data portion of a map.  Note that
238  *		these macros mimic procedure calls returning void.  The
239  *		semicolon is supplied by the user of these macros, not
240  *		by the macros themselves.  The macros can safely be used
241  *		as unbraced elements in a higher level statement.
242  */
243 
244 void _vm_map_lock(vm_map_t map, const char *file, int line);
245 void _vm_map_unlock(vm_map_t map, const char *file, int line);
246 void _vm_map_lock_read(vm_map_t map, const char *file, int line);
247 void _vm_map_unlock_read(vm_map_t map, const char *file, int line);
248 int _vm_map_trylock(vm_map_t map, const char *file, int line);
249 int _vm_map_lock_upgrade(vm_map_t map, const char *file, int line);
250 void _vm_map_lock_downgrade(vm_map_t map, const char *file, int line);
251 int vm_map_unlock_and_wait(vm_map_t map, boolean_t user_wait);
252 void vm_map_wakeup(vm_map_t map);
253 
254 #define	vm_map_lock(map)	_vm_map_lock(map, LOCK_FILE, LOCK_LINE)
255 #define	vm_map_unlock(map)	_vm_map_unlock(map, LOCK_FILE, LOCK_LINE)
256 #define	vm_map_lock_read(map)	_vm_map_lock_read(map, LOCK_FILE, LOCK_LINE)
257 #define	vm_map_unlock_read(map)	_vm_map_unlock_read(map, LOCK_FILE, LOCK_LINE)
258 #define	vm_map_trylock(map)	_vm_map_trylock(map, LOCK_FILE, LOCK_LINE)
259 #define	vm_map_lock_upgrade(map)	\
260 			_vm_map_lock_upgrade(map, LOCK_FILE, LOCK_LINE)
261 #define	vm_map_lock_downgrade(map)	\
262 			_vm_map_lock_downgrade(map, LOCK_FILE, LOCK_LINE)
263 
264 long vmspace_resident_count(struct vmspace *vmspace);
265 #endif	/* _KERNEL */
266 
267 
268 /* XXX: number of kernel maps and entries to statically allocate */
269 #define MAX_KMAP	10
270 #define	MAX_KMAPENT	128
271 #define	MAX_MAPENT	128
272 
273 /*
274  * Copy-on-write flags for vm_map operations
275  */
276 #define MAP_UNUSED_01		0x0001
277 #define MAP_COPY_ON_WRITE	0x0002
278 #define MAP_NOFAULT		0x0004
279 #define MAP_PREFAULT		0x0008
280 #define MAP_PREFAULT_PARTIAL	0x0010
281 #define MAP_DISABLE_SYNCER	0x0020
282 #define MAP_DISABLE_COREDUMP	0x0100
283 #define MAP_PREFAULT_MADVISE	0x0200	/* from (user) madvise request */
284 
285 /*
286  * vm_fault option flags
287  */
288 #define VM_FAULT_NORMAL 0		/* Nothing special */
289 #define VM_FAULT_CHANGE_WIRING 1	/* Change the wiring as appropriate */
290 #define VM_FAULT_USER_WIRE 2		/* Likewise, but for user purposes */
291 #define VM_FAULT_WIRE_MASK (VM_FAULT_CHANGE_WIRING|VM_FAULT_USER_WIRE)
292 #define VM_FAULT_DIRTY 8		/* Dirty the page */
293 
294 #ifdef _KERNEL
295 boolean_t vm_map_check_protection (vm_map_t, vm_offset_t, vm_offset_t, vm_prot_t);
296 struct pmap;
297 vm_map_t vm_map_create (struct pmap *, vm_offset_t, vm_offset_t);
298 int vm_map_delete (vm_map_t, vm_offset_t, vm_offset_t);
299 int vm_map_find (vm_map_t, vm_object_t, vm_ooffset_t, vm_offset_t *, vm_size_t, boolean_t, vm_prot_t, vm_prot_t, int);
300 int vm_map_findspace (vm_map_t, vm_offset_t, vm_size_t, vm_offset_t *);
301 int vm_map_inherit (vm_map_t, vm_offset_t, vm_offset_t, vm_inherit_t);
302 void vm_map_init (struct vm_map *, vm_offset_t, vm_offset_t);
303 int vm_map_insert (vm_map_t, vm_object_t, vm_ooffset_t, vm_offset_t, vm_offset_t, vm_prot_t, vm_prot_t, int);
304 int vm_map_lookup (vm_map_t *, vm_offset_t, vm_prot_t, vm_map_entry_t *, vm_object_t *,
305     vm_pindex_t *, vm_prot_t *, boolean_t *);
306 void vm_map_lookup_done (vm_map_t, vm_map_entry_t);
307 boolean_t vm_map_lookup_entry (vm_map_t, vm_offset_t, vm_map_entry_t *);
308 int vm_map_clean (vm_map_t, vm_offset_t, vm_offset_t, boolean_t, boolean_t);
309 int vm_map_protect (vm_map_t, vm_offset_t, vm_offset_t, vm_prot_t, boolean_t);
310 int vm_map_remove (vm_map_t, vm_offset_t, vm_offset_t);
311 void vm_map_startup (void);
312 int vm_map_submap (vm_map_t, vm_offset_t, vm_offset_t, vm_map_t);
313 int vm_map_madvise (vm_map_t, vm_offset_t, vm_offset_t, int);
314 void vm_map_simplify_entry (vm_map_t, vm_map_entry_t);
315 void vm_init2 (void);
316 int vm_map_stack (vm_map_t, vm_offset_t, vm_size_t, vm_prot_t, vm_prot_t, int);
317 int vm_map_growstack (struct proc *p, vm_offset_t addr);
318 int vm_map_unwire(vm_map_t map, vm_offset_t start, vm_offset_t end,
319     boolean_t user_unwire);
320 int vm_map_wire(vm_map_t map, vm_offset_t start, vm_offset_t end,
321     boolean_t user_wire);
322 int vmspace_swap_count (struct vmspace *vmspace);
323 int vm_uiomove(vm_map_t, vm_object_t, off_t, int, vm_offset_t, int *);
324 #endif				/* _KERNEL */
325 #endif				/* _VM_MAP_ */
326