1/* $NetBSD: uvm_amap.h,v 1.37 2011/06/12 03:36:02 rmind Exp $ */
2
3/*
4 * Copyright (c) 1997 Charles D. Cranor and Washington University.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#ifndef _UVM_UVM_AMAP_H_
29#define _UVM_UVM_AMAP_H_
30
31/*
32 * uvm_amap.h: general amap interface and amap implementation-specific info
33 */
34
35/*
36 * an amap structure contains pointers to a set of anons that are
37 * mapped together in virtual memory (an anon is a single page of
38 * anonymous virtual memory -- see uvm_anon.h). in uvm we hide the
39 * details of the implementation of amaps behind a general amap
40 * interface. this allows us to change the amap implementation
41 * without having to touch the rest of the code. this file is divided
42 * into two parts: the definition of the uvm amap interface and the
43 * amap implementation-specific definitions.
44 */
45
46#ifdef _KERNEL
47
48/*
49 * part 1: amap interface
50 */
51
52void uvm_amap_init(void);
53
54/*
55 * forward definition of vm_amap structure. only amap
56 * implementation-specific code should directly access the fields of
57 * this structure.
58 */
59
60struct vm_amap;
61
62
63/*
64 * prototypes for the amap interface
65 */
66
67void amap_add /* add an anon to an amap */
68 (struct vm_aref *, vaddr_t,
69 struct vm_anon *, bool);
70struct vm_amap *amap_alloc /* allocate a new amap */
71 (vaddr_t, vaddr_t, int);
72void amap_copy /* clear amap needs-copy flag */
73 (struct vm_map *, struct vm_map_entry *, int,
74 vaddr_t, vaddr_t);
75void amap_cow_now /* resolve all COW faults now */
76 (struct vm_map *, struct vm_map_entry *);
77int amap_extend /* make amap larger */
78 (struct vm_map_entry *, vsize_t, int);
79int amap_flags /* get amap's flags */
80 (struct vm_amap *);
81void amap_free /* free amap */
82 (struct vm_amap *);
83void amap_lock /* lock amap */
84 (struct vm_amap *);
85struct vm_anon *amap_lookup /* lookup an anon @ offset in amap */
86 (struct vm_aref *, vaddr_t);
87void amap_lookups /* lookup multiple anons */
88 (struct vm_aref *, vaddr_t,
89 struct vm_anon **, int);
90void amap_ref /* add a reference to an amap */
91 (struct vm_amap *, vaddr_t, vsize_t, int);
92int amap_refs /* get number of references of amap */
93 (struct vm_amap *);
94void amap_share_protect /* protect pages in a shared amap */
95 (struct vm_map_entry *, vm_prot_t);
96void amap_splitref /* split reference to amap into two */
97 (struct vm_aref *, struct vm_aref *, vaddr_t);
98void amap_unadd /* remove an anon from an amap */
99 (struct vm_aref *, vaddr_t);
100void amap_unlock /* unlock amap */
101 (struct vm_amap *);
102void amap_unref /* drop reference to an amap */
103 (struct vm_amap *, vaddr_t, vsize_t, bool);
104void amap_wipeout /* remove all anons from amap */
105 (struct vm_amap *);
106bool amap_swap_off
107 (int, int);
108
109/*
110 * amap flag values
111 */
112
113#define AMAP_SHARED 0x1 /* amap is shared */
114#define AMAP_REFALL 0x2 /* amap_ref: reference entire amap */
115#define AMAP_SWAPOFF 0x4 /* amap_swap_off() is in progress */
116
117/*
118 * amap_copy flags
119 */
120
121#define AMAP_COPY_NOWAIT 0x02 /* not allowed to sleep */
122#define AMAP_COPY_NOCHUNK 0x04 /* not allowed to chunk */
123#define AMAP_COPY_NOMERGE 0x08 /* not allowed to merge */
124
125/*
126 * amap_extend flags
127 */
128#define AMAP_EXTEND_BACKWARDS 0x00 /* add "size" to start of map */
129#define AMAP_EXTEND_FORWARDS 0x01 /* add "size" to end of map */
130#define AMAP_EXTEND_NOWAIT 0x02 /* not allowed to sleep */
131
132#endif /* _KERNEL */
133
134/**********************************************************************/
135
136/*
137 * part 2: amap implementation-specific info
138 */
139
140/*
141 * we currently provide an array-based amap implementation. in this
142 * implementation we provide the option of tracking split references
143 * so that we don't lose track of references during partial unmaps
144 * ... this is enabled with the "UVM_AMAP_PPREF" define.
145 */
146
147#define UVM_AMAP_PPREF /* track partial references */
148
149/*
150 * here is the definition of the vm_amap structure for this implementation.
151 */
152
153struct vm_amap {
154 kmutex_t *am_lock; /* lock [locks all vm_amap fields] */
155 int am_ref; /* reference count */
156 int am_flags; /* flags */
157 int am_maxslot; /* max # of slots allocated */
158 int am_nslot; /* # of slots currently in map ( <= maxslot) */
159 int am_nused; /* # of slots currently in use */
160 int *am_slots; /* contig array of active slots */
161 int *am_bckptr; /* back pointer array to am_slots */
162 struct vm_anon **am_anon; /* array of anonymous pages */
163#ifdef UVM_AMAP_PPREF
164 int *am_ppref; /* per page reference count (if !NULL) */
165#endif
166 LIST_ENTRY(vm_amap) am_list;
167};
168
169/*
170 * note that am_slots, am_bckptr, and am_anon are arrays. this allows
171 * fast lookup of pages based on their virual address at the expense of
172 * some extra memory. in the future we should be smarter about memory
173 * usage and fall back to a non-array based implementation on systems
174 * that are short of memory (XXXCDC).
175 *
176 * the entries in the array are called slots... for example an amap that
177 * covers four pages of virtual memory is said to have four slots. here
178 * is an example of the array usage for a four slot amap. note that only
179 * slots one and three have anons assigned to them. "D/C" means that we
180 * "don't care" about the value.
181 *
182 * 0 1 2 3
183 * am_anon: NULL, anon0, NULL, anon1 (actual pointers to anons)
184 * am_bckptr: D/C, 1, D/C, 0 (points to am_slots entry)
185 *
186 * am_slots: 3, 1, D/C, D/C (says slots 3 and 1 are in use)
187 *
188 * note that am_bckptr is D/C if the slot in am_anon is set to NULL.
189 * to find the entry in am_slots for an anon, look at am_bckptr[slot],
190 * thus the entry for slot 3 in am_slots[] is at am_slots[am_bckptr[3]].
191 * in general, if am_anon[X] is non-NULL, then the following must be
192 * true: am_slots[am_bckptr[X]] == X
193 *
194 * note that am_slots is always contig-packed.
195 */
196
197/*
198 * defines for handling of large, sparse amaps:
199 *
200 * one of the problems of array-based amaps is that if you allocate a
201 * large, sparsely-used area of virtual memory you end up allocating
202 * large arrays that, for the most part, don't get used. this is a
203 * problem for BSD in that the kernel likes to make these types of
204 * allocations to "reserve" memory for possible future use.
205 *
206 * for example, the kernel allocates (reserves) a large chunk of user
207 * VM for possible stack growth. most of the time only a page or two
208 * of this VM is actually used. since the stack is anonymous memory
209 * it makes sense for it to live in an amap, but if we allocated an
210 * amap for the entire stack range we could end up wasting a large
211 * amount of allocated KVM.
212 *
213 * for example, on the i386 at boot time we allocate two amaps for the stack
214 * of /sbin/init:
215 * 1. a 7680 slot amap at protection 0 (reserve space for stack)
216 * 2. a 512 slot amap at protection 7 (top of stack)
217 *
218 * most of the array allocated for the amaps for this is never used.
219 * the amap interface provides a way for us to avoid this problem by
220 * allowing amap_copy() to break larger amaps up into smaller sized
221 * chunks (controlled by the "canchunk" option). we use this feature
222 * to reduce our memory usage with the BSD stack management. if we
223 * are asked to create an amap with more than UVM_AMAP_LARGE slots in it,
224 * we attempt to break it up into a UVM_AMAP_CHUNK sized amap if the
225 * "canchunk" flag is set.
226 *
227 * so, in the i386 example, the 7680 slot area is never referenced so
228 * nothing gets allocated (amap_copy is never called because the protection
229 * is zero). the 512 slot area for the top of the stack is referenced.
230 * the chunking code breaks it up into 16 slot chunks (hopefully a single
231 * 16 slot chunk is enough to handle the whole stack).
232 */
233
234#define UVM_AMAP_LARGE 256 /* # of slots in "large" amap */
235#define UVM_AMAP_CHUNK 16 /* # of slots to chunk large amaps in */
236
237#ifdef _KERNEL
238
239/*
240 * macros
241 */
242
243/* AMAP_B2SLOT: convert byte offset to slot */
244#define AMAP_B2SLOT(S,B) { \
245 KASSERT(((B) & (PAGE_SIZE - 1)) == 0); \
246 (S) = (B) >> PAGE_SHIFT; \
247}
248
249/*
250 * lock/unlock/refs/flags macros
251 */
252
253#define amap_flags(AMAP) ((AMAP)->am_flags)
254#define amap_lock(AMAP) mutex_enter((AMAP)->am_lock)
255#define amap_lock_try(AMAP) mutex_tryenter((AMAP)->am_lock)
256#define amap_refs(AMAP) ((AMAP)->am_ref)
257#define amap_unlock(AMAP) mutex_exit((AMAP)->am_lock)
258
259/*
260 * if we enable PPREF, then we have a couple of extra functions that
261 * we need to prototype here...
262 */
263
264#ifdef UVM_AMAP_PPREF
265
266#define PPREF_NONE ((int *) -1) /* not using ppref */
267
268void amap_pp_adjref /* adjust references */
269 (struct vm_amap *, int, vsize_t, int,
270 struct vm_anon **);
271void amap_pp_establish /* establish ppref */
272 (struct vm_amap *, vaddr_t);
273void amap_wiperange /* wipe part of an amap */
274 (struct vm_amap *, int, int, struct vm_anon **);
275#endif /* UVM_AMAP_PPREF */
276
277#endif /* _KERNEL */
278
279#endif /* _UVM_UVM_AMAP_H_ */
280