FreeBSD/Linux Kernel Cross Reference
sys/vm/vm_pager.c
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 * from: @(#)vm_pager.c 8.6 (Berkeley) 1/12/94
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
65 /*
66 * Paging space routine stubs. Emulates a matchmaker-like interface
67 * for builtin pagers.
68 */
69
70 #include <sys/cdefs.h>
71 __FBSDID("$FreeBSD: releng/5.2/sys/vm/vm_pager.c 121267 2003-10-20 05:16:27Z alc $");
72
73 #include <sys/param.h>
74 #include <sys/systm.h>
75 #include <sys/kernel.h>
76 #include <sys/vnode.h>
77 #include <sys/bio.h>
78 #include <sys/buf.h>
79 #include <sys/ucred.h>
80 #include <sys/malloc.h>
81
82 #include <vm/vm.h>
83 #include <vm/vm_param.h>
84 #include <vm/vm_object.h>
85 #include <vm/vm_page.h>
86 #include <vm/vm_pager.h>
87 #include <vm/vm_extern.h>
88
89 MALLOC_DEFINE(M_VMPGDATA, "VM pgdata", "XXX: VM pager private data");
90
91 int cluster_pbuf_freecnt = -1; /* unlimited to begin with */
92
93 static int dead_pager_getpages(vm_object_t, vm_page_t *, int, int);
94 static vm_object_t dead_pager_alloc(void *, vm_ooffset_t, vm_prot_t,
95 vm_ooffset_t);
96 static void dead_pager_putpages(vm_object_t, vm_page_t *, int, int, int *);
97 static boolean_t dead_pager_haspage(vm_object_t, vm_pindex_t, int *, int *);
98 static void dead_pager_dealloc(vm_object_t);
99
100 static int
101 dead_pager_getpages(obj, ma, count, req)
102 vm_object_t obj;
103 vm_page_t *ma;
104 int count;
105 int req;
106 {
107 return VM_PAGER_FAIL;
108 }
109
110 static vm_object_t
111 dead_pager_alloc(handle, size, prot, off)
112 void *handle;
113 vm_ooffset_t size;
114 vm_prot_t prot;
115 vm_ooffset_t off;
116 {
117 return NULL;
118 }
119
120 static void
121 dead_pager_putpages(object, m, count, flags, rtvals)
122 vm_object_t object;
123 vm_page_t *m;
124 int count;
125 int flags;
126 int *rtvals;
127 {
128 int i;
129
130 for (i = 0; i < count; i++) {
131 rtvals[i] = VM_PAGER_AGAIN;
132 }
133 }
134
135 static int
136 dead_pager_haspage(object, pindex, prev, next)
137 vm_object_t object;
138 vm_pindex_t pindex;
139 int *prev;
140 int *next;
141 {
142 if (prev)
143 *prev = 0;
144 if (next)
145 *next = 0;
146 return FALSE;
147 }
148
149 static void
150 dead_pager_dealloc(object)
151 vm_object_t object;
152 {
153 return;
154 }
155
156 static struct pagerops deadpagerops = {
157 .pgo_alloc = dead_pager_alloc,
158 .pgo_dealloc = dead_pager_dealloc,
159 .pgo_getpages = dead_pager_getpages,
160 .pgo_putpages = dead_pager_putpages,
161 .pgo_haspage = dead_pager_haspage,
162 };
163
164 struct pagerops *pagertab[] = {
165 &defaultpagerops, /* OBJT_DEFAULT */
166 &swappagerops, /* OBJT_SWAP */
167 &vnodepagerops, /* OBJT_VNODE */
168 &devicepagerops, /* OBJT_DEVICE */
169 &physpagerops, /* OBJT_PHYS */
170 &deadpagerops /* OBJT_DEAD */
171 };
172
173 int npagers = sizeof(pagertab) / sizeof(pagertab[0]);
174
175 /*
176 * Kernel address space for mapping pages.
177 * Used by pagers where KVAs are needed for IO.
178 *
179 * XXX needs to be large enough to support the number of pending async
180 * cleaning requests (NPENDINGIO == 64) * the maximum swap cluster size
181 * (MAXPHYS == 64k) if you want to get the most efficiency.
182 */
183 #define PAGER_MAP_SIZE (8 * 1024 * 1024)
184
185 int pager_map_size = PAGER_MAP_SIZE;
186 vm_map_t pager_map;
187 static int bswneeded;
188 static vm_offset_t swapbkva; /* swap buffers kva */
189 struct mtx pbuf_mtx;
190 static TAILQ_HEAD(swqueue, buf) bswlist;
191
192 void
193 vm_pager_init()
194 {
195 struct pagerops **pgops;
196
197 TAILQ_INIT(&bswlist);
198 /*
199 * Initialize known pagers
200 */
201 for (pgops = pagertab; pgops < &pagertab[npagers]; pgops++)
202 if (pgops && ((*pgops)->pgo_init != NULL))
203 (*(*pgops)->pgo_init) ();
204 }
205
206 void
207 vm_pager_bufferinit()
208 {
209 struct buf *bp;
210 int i;
211
212 mtx_init(&pbuf_mtx, "pbuf mutex", NULL, MTX_DEF);
213 bp = swbuf;
214 /*
215 * Now set up swap and physical I/O buffer headers.
216 */
217 for (i = 0; i < nswbuf; i++, bp++) {
218 TAILQ_INSERT_HEAD(&bswlist, bp, b_freelist);
219 BUF_LOCKINIT(bp);
220 LIST_INIT(&bp->b_dep);
221 bp->b_rcred = bp->b_wcred = NOCRED;
222 bp->b_xflags = 0;
223 }
224
225 cluster_pbuf_freecnt = nswbuf / 2;
226
227 swapbkva = kmem_alloc_nofault(pager_map, nswbuf * MAXPHYS);
228 if (!swapbkva)
229 panic("Not enough pager_map VM space for physical buffers");
230 }
231
232 /*
233 * Allocate an instance of a pager of the given type.
234 * Size, protection and offset parameters are passed in for pagers that
235 * need to perform page-level validation (e.g. the device pager).
236 */
237 vm_object_t
238 vm_pager_allocate(objtype_t type, void *handle, vm_ooffset_t size,
239 vm_prot_t prot, vm_ooffset_t off)
240 {
241 vm_object_t ret;
242 struct pagerops *ops;
243
244 ops = pagertab[type];
245 if (ops)
246 ret = (*ops->pgo_alloc) (handle, size, prot, off);
247 else
248 ret = NULL;
249 return (ret);
250 }
251
252 /*
253 * The object must be locked.
254 */
255 void
256 vm_pager_deallocate(object)
257 vm_object_t object;
258 {
259
260 VM_OBJECT_LOCK_ASSERT(object, MA_OWNED);
261 (*pagertab[object->type]->pgo_dealloc) (object);
262 }
263
264 /*
265 * vm_pager_get_pages() - inline, see vm/vm_pager.h
266 * vm_pager_put_pages() - inline, see vm/vm_pager.h
267 * vm_pager_has_page() - inline, see vm/vm_pager.h
268 */
269
270 vm_offset_t
271 vm_pager_map_page(m)
272 vm_page_t m;
273 {
274 vm_offset_t kva;
275
276 kva = kmem_alloc_wait(pager_map, PAGE_SIZE);
277 pmap_qenter(kva, &m, 1);
278 return (kva);
279 }
280
281 void
282 vm_pager_unmap_page(kva)
283 vm_offset_t kva;
284 {
285
286 pmap_qremove(kva, 1);
287 kmem_free_wakeup(pager_map, kva, PAGE_SIZE);
288 }
289
290 vm_object_t
291 vm_pager_object_lookup(pg_list, handle)
292 struct pagerlst *pg_list;
293 void *handle;
294 {
295 vm_object_t object;
296
297 TAILQ_FOREACH(object, pg_list, pager_object_list)
298 if (object->handle == handle)
299 return (object);
300 return (NULL);
301 }
302
303 /*
304 * initialize a physical buffer
305 */
306
307 /*
308 * XXX This probably belongs in vfs_bio.c
309 */
310 static void
311 initpbuf(struct buf *bp)
312 {
313 bp->b_rcred = NOCRED;
314 bp->b_wcred = NOCRED;
315 bp->b_qindex = 0; /* On no queue (QUEUE_NONE) */
316 bp->b_saveaddr = (caddr_t) (MAXPHYS * (bp - swbuf)) + swapbkva;
317 bp->b_data = bp->b_saveaddr;
318 bp->b_kvabase = bp->b_saveaddr;
319 bp->b_kvasize = MAXPHYS;
320 bp->b_xflags = 0;
321 bp->b_flags = 0;
322 bp->b_ioflags = 0;
323 bp->b_iodone = NULL;
324 bp->b_error = 0;
325 bp->b_magic = B_MAGIC_BIO;
326 bp->b_op = &buf_ops_bio;
327 BUF_LOCK(bp, LK_EXCLUSIVE, NULL);
328 }
329
330 /*
331 * allocate a physical buffer
332 *
333 * There are a limited number (nswbuf) of physical buffers. We need
334 * to make sure that no single subsystem is able to hog all of them,
335 * so each subsystem implements a counter which is typically initialized
336 * to 1/2 nswbuf. getpbuf() decrements this counter in allocation and
337 * increments it on release, and blocks if the counter hits zero. A
338 * subsystem may initialize the counter to -1 to disable the feature,
339 * but it must still be sure to match up all uses of getpbuf() with
340 * relpbuf() using the same variable.
341 *
342 * NOTE: pfreecnt can be NULL, but this 'feature' will be removed
343 * relatively soon when the rest of the subsystems get smart about it. XXX
344 */
345 struct buf *
346 getpbuf(pfreecnt)
347 int *pfreecnt;
348 {
349 int s;
350 struct buf *bp;
351
352 s = splvm();
353 mtx_lock(&pbuf_mtx);
354
355 for (;;) {
356 if (pfreecnt) {
357 while (*pfreecnt == 0) {
358 msleep(pfreecnt, &pbuf_mtx, PVM, "wswbuf0", 0);
359 }
360 }
361
362 /* get a bp from the swap buffer header pool */
363 if ((bp = TAILQ_FIRST(&bswlist)) != NULL)
364 break;
365
366 bswneeded = 1;
367 msleep(&bswneeded, &pbuf_mtx, PVM, "wswbuf1", 0);
368 /* loop in case someone else grabbed one */
369 }
370 TAILQ_REMOVE(&bswlist, bp, b_freelist);
371 if (pfreecnt)
372 --*pfreecnt;
373 mtx_unlock(&pbuf_mtx);
374 splx(s);
375
376 initpbuf(bp);
377 return bp;
378 }
379
380 /*
381 * allocate a physical buffer, if one is available.
382 *
383 * Note that there is no NULL hack here - all subsystems using this
384 * call understand how to use pfreecnt.
385 */
386 struct buf *
387 trypbuf(pfreecnt)
388 int *pfreecnt;
389 {
390 int s;
391 struct buf *bp;
392
393 s = splvm();
394 mtx_lock(&pbuf_mtx);
395 if (*pfreecnt == 0 || (bp = TAILQ_FIRST(&bswlist)) == NULL) {
396 mtx_unlock(&pbuf_mtx);
397 splx(s);
398 return NULL;
399 }
400 TAILQ_REMOVE(&bswlist, bp, b_freelist);
401
402 --*pfreecnt;
403
404 mtx_unlock(&pbuf_mtx);
405 splx(s);
406
407 initpbuf(bp);
408
409 return bp;
410 }
411
412 /*
413 * release a physical buffer
414 *
415 * NOTE: pfreecnt can be NULL, but this 'feature' will be removed
416 * relatively soon when the rest of the subsystems get smart about it. XXX
417 */
418 void
419 relpbuf(bp, pfreecnt)
420 struct buf *bp;
421 int *pfreecnt;
422 {
423 int s;
424
425 s = splvm();
426
427 if (bp->b_rcred != NOCRED) {
428 crfree(bp->b_rcred);
429 bp->b_rcred = NOCRED;
430 }
431 if (bp->b_wcred != NOCRED) {
432 crfree(bp->b_wcred);
433 bp->b_wcred = NOCRED;
434 }
435
436 if (bp->b_vp)
437 pbrelvp(bp);
438
439 BUF_UNLOCK(bp);
440
441 mtx_lock(&pbuf_mtx);
442 TAILQ_INSERT_HEAD(&bswlist, bp, b_freelist);
443
444 if (bswneeded) {
445 bswneeded = 0;
446 wakeup(&bswneeded);
447 }
448 if (pfreecnt) {
449 if (++*pfreecnt == 1)
450 wakeup(pfreecnt);
451 }
452 mtx_unlock(&pbuf_mtx);
453 splx(s);
454 }
Cache object: 680532ccb8f131f559b00eb8f1c1d39f
|