xref: /freebsd/sys/vm/vm_pager.c (revision ebacd8013fe5f7fdf9f6a5b286f6680dd2891036)
1 /*-
2  * SPDX-License-Identifier: (BSD-3-Clause AND MIT-CMU)
3  *
4  * Copyright (c) 1991, 1993
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * This code is derived from software contributed to Berkeley by
8  * The Mach Operating System project at Carnegie-Mellon University.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. Neither the name of the University nor the names of its contributors
19  *    may be used to endorse or promote products derived from this software
20  *    without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  *
34  *	from: @(#)vm_pager.c	8.6 (Berkeley) 1/12/94
35  *
36  *
37  * Copyright (c) 1987, 1990 Carnegie-Mellon University.
38  * All rights reserved.
39  *
40  * Authors: Avadis Tevanian, Jr., Michael Wayne Young
41  *
42  * Permission to use, copy, modify and distribute this software and
43  * its documentation is hereby granted, provided that both the copyright
44  * notice and this permission notice appear in all copies of the
45  * software, derivative works or modified versions, and any portions
46  * thereof, and that both notices appear in supporting documentation.
47  *
48  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
49  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
50  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
51  *
52  * Carnegie Mellon requests users of this software to return to
53  *
54  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
55  *  School of Computer Science
56  *  Carnegie Mellon University
57  *  Pittsburgh PA 15213-3890
58  *
59  * any improvements or extensions that they make and grant Carnegie the
60  * rights to redistribute these changes.
61  */
62 
63 /*
64  *	Paging space routine stubs.  Emulates a matchmaker-like interface
65  *	for builtin pagers.
66  */
67 
68 #include <sys/cdefs.h>
69 __FBSDID("$FreeBSD$");
70 
71 #include "opt_param.h"
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 #include <sys/rwlock.h>
82 #include <sys/user.h>
83 
84 #include <vm/vm.h>
85 #include <vm/vm_param.h>
86 #include <vm/vm_kern.h>
87 #include <vm/vm_object.h>
88 #include <vm/vm_page.h>
89 #include <vm/vm_pager.h>
90 #include <vm/vm_extern.h>
91 #include <vm/uma.h>
92 
93 uma_zone_t pbuf_zone;
94 static int	pbuf_init(void *, int, int);
95 static int	pbuf_ctor(void *, int, void *, int);
96 static void	pbuf_dtor(void *, int, void *);
97 
98 static int dead_pager_getpages(vm_object_t, vm_page_t *, int, int *, int *);
99 static vm_object_t dead_pager_alloc(void *, vm_ooffset_t, vm_prot_t,
100     vm_ooffset_t, struct ucred *);
101 static void dead_pager_putpages(vm_object_t, vm_page_t *, int, int, int *);
102 static boolean_t dead_pager_haspage(vm_object_t, vm_pindex_t, int *, int *);
103 static void dead_pager_dealloc(vm_object_t);
104 static void dead_pager_getvp(vm_object_t, struct vnode **, bool *);
105 
106 static int
107 dead_pager_getpages(vm_object_t obj, vm_page_t *ma, int count, int *rbehind,
108     int *rahead)
109 {
110 
111 	return (VM_PAGER_FAIL);
112 }
113 
114 static vm_object_t
115 dead_pager_alloc(void *handle, vm_ooffset_t size, vm_prot_t prot,
116     vm_ooffset_t off, struct ucred *cred)
117 {
118 
119 	return (NULL);
120 }
121 
122 static void
123 dead_pager_putpages(vm_object_t object, vm_page_t *m, int count,
124     int flags, int *rtvals)
125 {
126 	int i;
127 
128 	for (i = 0; i < count; i++)
129 		rtvals[i] = VM_PAGER_AGAIN;
130 }
131 
132 static int
133 dead_pager_haspage(vm_object_t object, vm_pindex_t pindex, int *prev, int *next)
134 {
135 
136 	if (prev != NULL)
137 		*prev = 0;
138 	if (next != NULL)
139 		*next = 0;
140 	return (FALSE);
141 }
142 
143 static void
144 dead_pager_dealloc(vm_object_t object)
145 {
146 
147 }
148 
149 static void
150 dead_pager_getvp(vm_object_t object, struct vnode **vpp, bool *vp_heldp)
151 {
152 	/*
153 	 * For OBJT_DEAD objects, v_writecount was handled in
154 	 * vnode_pager_dealloc().
155 	 */
156 }
157 
158 static const struct pagerops deadpagerops = {
159 	.pgo_kvme_type = KVME_TYPE_DEAD,
160 	.pgo_alloc = 	dead_pager_alloc,
161 	.pgo_dealloc =	dead_pager_dealloc,
162 	.pgo_getpages =	dead_pager_getpages,
163 	.pgo_putpages =	dead_pager_putpages,
164 	.pgo_haspage =	dead_pager_haspage,
165 	.pgo_getvp =	dead_pager_getvp,
166 };
167 
168 const struct pagerops *pagertab[16] __read_mostly = {
169 	[OBJT_SWAP] =		&swappagerops,
170 	[OBJT_VNODE] =		&vnodepagerops,
171 	[OBJT_DEVICE] =		&devicepagerops,
172 	[OBJT_PHYS] =		&physpagerops,
173 	[OBJT_DEAD] =		&deadpagerops,
174 	[OBJT_SG] = 		&sgpagerops,
175 	[OBJT_MGTDEVICE] = 	&mgtdevicepagerops,
176 };
177 static struct mtx pagertab_lock;
178 
179 void
180 vm_pager_init(void)
181 {
182 	const struct pagerops **pgops;
183 	int i;
184 
185 	mtx_init(&pagertab_lock, "dynpag", NULL, MTX_DEF);
186 
187 	/*
188 	 * Initialize known pagers
189 	 */
190 	for (i = 0; i < OBJT_FIRST_DYN; i++) {
191 		pgops = &pagertab[i];
192 		if (*pgops != NULL && (*pgops)->pgo_init != NULL)
193 			(*(*pgops)->pgo_init)();
194 	}
195 }
196 
197 static int nswbuf_max;
198 
199 void
200 vm_pager_bufferinit(void)
201 {
202 
203 	/* Main zone for paging bufs. */
204 	pbuf_zone = uma_zcreate("pbuf",
205 	    sizeof(struct buf) + PBUF_PAGES * sizeof(vm_page_t),
206 	    pbuf_ctor, pbuf_dtor, pbuf_init, NULL, UMA_ALIGN_CACHE,
207 	    UMA_ZONE_NOFREE);
208 	/* Few systems may still use this zone directly, so it needs a limit. */
209 	nswbuf_max += uma_zone_set_max(pbuf_zone, NSWBUF_MIN);
210 }
211 
212 uma_zone_t
213 pbuf_zsecond_create(const char *name, int max)
214 {
215 	uma_zone_t zone;
216 
217 	zone = uma_zsecond_create(name, pbuf_ctor, pbuf_dtor, NULL, NULL,
218 	    pbuf_zone);
219 
220 #ifdef KMSAN
221 	/*
222 	 * Shrink the size of the pbuf pools if KMSAN is enabled, otherwise the
223 	 * shadows of the large KVA allocations eat up too much memory.
224 	 */
225 	max /= 3;
226 #endif
227 
228 	/*
229 	 * uma_prealloc() rounds up to items per slab. If we would prealloc
230 	 * immediately on every pbuf_zsecond_create(), we may accumulate too
231 	 * much of difference between hard limit and prealloced items, which
232 	 * means wasted memory.
233 	 */
234 	if (nswbuf_max > 0)
235 		nswbuf_max += uma_zone_set_max(zone, max);
236 	else
237 		uma_prealloc(pbuf_zone, uma_zone_set_max(zone, max));
238 
239 	return (zone);
240 }
241 
242 static void
243 pbuf_prealloc(void *arg __unused)
244 {
245 
246 	uma_prealloc(pbuf_zone, nswbuf_max);
247 	nswbuf_max = -1;
248 }
249 
250 SYSINIT(pbuf, SI_SUB_KTHREAD_BUF, SI_ORDER_ANY, pbuf_prealloc, NULL);
251 
252 /*
253  * Allocate an instance of a pager of the given type.
254  * Size, protection and offset parameters are passed in for pagers that
255  * need to perform page-level validation (e.g. the device pager).
256  */
257 vm_object_t
258 vm_pager_allocate(objtype_t type, void *handle, vm_ooffset_t size,
259     vm_prot_t prot, vm_ooffset_t off, struct ucred *cred)
260 {
261 	vm_object_t object;
262 
263 	MPASS(type < nitems(pagertab));
264 
265 	object = (*pagertab[type]->pgo_alloc)(handle, size, prot, off, cred);
266 	if (object != NULL)
267 		object->type = type;
268 	return (object);
269 }
270 
271 /*
272  *	The object must be locked.
273  */
274 void
275 vm_pager_deallocate(vm_object_t object)
276 {
277 
278 	VM_OBJECT_ASSERT_WLOCKED(object);
279 	MPASS(object->type < nitems(pagertab));
280 	(*pagertab[object->type]->pgo_dealloc) (object);
281 }
282 
283 static void
284 vm_pager_assert_in(vm_object_t object, vm_page_t *m, int count)
285 {
286 #ifdef INVARIANTS
287 
288 	/*
289 	 * All pages must be consecutive, busied, not mapped, not fully valid,
290 	 * not dirty and belong to the proper object.  Some pages may be the
291 	 * bogus page, but the first and last pages must be a real ones.
292 	 */
293 
294 	VM_OBJECT_ASSERT_UNLOCKED(object);
295 	VM_OBJECT_ASSERT_PAGING(object);
296 	KASSERT(count > 0, ("%s: 0 count", __func__));
297 	for (int i = 0 ; i < count; i++) {
298 		if (m[i] == bogus_page) {
299 			KASSERT(i != 0 && i != count - 1,
300 			    ("%s: page %d is the bogus page", __func__, i));
301 			continue;
302 		}
303 		vm_page_assert_xbusied(m[i]);
304 		KASSERT(!pmap_page_is_mapped(m[i]),
305 		    ("%s: page %p is mapped", __func__, m[i]));
306 		KASSERT(m[i]->valid != VM_PAGE_BITS_ALL,
307 		    ("%s: request for a valid page %p", __func__, m[i]));
308 		KASSERT(m[i]->dirty == 0,
309 		    ("%s: page %p is dirty", __func__, m[i]));
310 		KASSERT(m[i]->object == object,
311 		    ("%s: wrong object %p/%p", __func__, object, m[i]->object));
312 		KASSERT(m[i]->pindex == m[0]->pindex + i,
313 		    ("%s: page %p isn't consecutive", __func__, m[i]));
314 	}
315 #endif
316 }
317 
318 /*
319  * Page in the pages for the object using its associated pager.
320  * The requested page must be fully valid on successful return.
321  */
322 int
323 vm_pager_get_pages(vm_object_t object, vm_page_t *m, int count, int *rbehind,
324     int *rahead)
325 {
326 #ifdef INVARIANTS
327 	vm_pindex_t pindex = m[0]->pindex;
328 #endif
329 	int r;
330 
331 	MPASS(object->type < nitems(pagertab));
332 	vm_pager_assert_in(object, m, count);
333 
334 	r = (*pagertab[object->type]->pgo_getpages)(object, m, count, rbehind,
335 	    rahead);
336 	if (r != VM_PAGER_OK)
337 		return (r);
338 
339 	for (int i = 0; i < count; i++) {
340 		/*
341 		 * If pager has replaced a page, assert that it had
342 		 * updated the array.
343 		 */
344 #ifdef INVARIANTS
345 		KASSERT(m[i] == vm_page_relookup(object, pindex++),
346 		    ("%s: mismatch page %p pindex %ju", __func__,
347 		    m[i], (uintmax_t )pindex - 1));
348 #endif
349 
350 		/*
351 		 * Zero out partially filled data.
352 		 */
353 		if (m[i]->valid != VM_PAGE_BITS_ALL)
354 			vm_page_zero_invalid(m[i], TRUE);
355 	}
356 	return (VM_PAGER_OK);
357 }
358 
359 int
360 vm_pager_get_pages_async(vm_object_t object, vm_page_t *m, int count,
361     int *rbehind, int *rahead, pgo_getpages_iodone_t iodone, void *arg)
362 {
363 
364 	MPASS(object->type < nitems(pagertab));
365 	vm_pager_assert_in(object, m, count);
366 
367 	return ((*pagertab[object->type]->pgo_getpages_async)(object, m,
368 	    count, rbehind, rahead, iodone, arg));
369 }
370 
371 /*
372  * vm_pager_put_pages() - inline, see vm/vm_pager.h
373  * vm_pager_has_page() - inline, see vm/vm_pager.h
374  */
375 
376 /*
377  * Search the specified pager object list for an object with the
378  * specified handle.  If an object with the specified handle is found,
379  * increase its reference count and return it.  Otherwise, return NULL.
380  *
381  * The pager object list must be locked.
382  */
383 vm_object_t
384 vm_pager_object_lookup(struct pagerlst *pg_list, void *handle)
385 {
386 	vm_object_t object;
387 
388 	TAILQ_FOREACH(object, pg_list, pager_object_list) {
389 		if (object->handle == handle) {
390 			VM_OBJECT_WLOCK(object);
391 			if ((object->flags & OBJ_DEAD) == 0) {
392 				vm_object_reference_locked(object);
393 				VM_OBJECT_WUNLOCK(object);
394 				break;
395 			}
396 			VM_OBJECT_WUNLOCK(object);
397 		}
398 	}
399 	return (object);
400 }
401 
402 int
403 vm_pager_alloc_dyn_type(struct pagerops *ops, int base_type)
404 {
405 	int res;
406 
407 	mtx_lock(&pagertab_lock);
408 	MPASS(base_type == -1 ||
409 	    (base_type >= OBJT_SWAP && base_type < nitems(pagertab)));
410 	for (res = OBJT_FIRST_DYN; res < nitems(pagertab); res++) {
411 		if (pagertab[res] == NULL)
412 			break;
413 	}
414 	if (res == nitems(pagertab)) {
415 		mtx_unlock(&pagertab_lock);
416 		return (-1);
417 	}
418 	if (base_type != -1) {
419 		MPASS(pagertab[base_type] != NULL);
420 #define	FIX(n)								\
421 		if (ops->pgo_##n == NULL)				\
422 			ops->pgo_##n = pagertab[base_type]->pgo_##n
423 		FIX(init);
424 		FIX(alloc);
425 		FIX(dealloc);
426 		FIX(getpages);
427 		FIX(getpages_async);
428 		FIX(putpages);
429 		FIX(haspage);
430 		FIX(populate);
431 		FIX(pageunswapped);
432 		FIX(update_writecount);
433 		FIX(release_writecount);
434 		FIX(set_writeable_dirty);
435 		FIX(mightbedirty);
436 		FIX(getvp);
437 		FIX(freespace);
438 		FIX(page_inserted);
439 		FIX(page_removed);
440 		FIX(can_alloc_page);
441 #undef FIX
442 	}
443 	pagertab[res] = ops;	/* XXXKIB should be rel, but acq is too much */
444 	mtx_unlock(&pagertab_lock);
445 	return (res);
446 }
447 
448 void
449 vm_pager_free_dyn_type(objtype_t type)
450 {
451 	MPASS(type >= OBJT_FIRST_DYN && type < nitems(pagertab));
452 
453 	mtx_lock(&pagertab_lock);
454 	MPASS(pagertab[type] != NULL);
455 	pagertab[type] = NULL;
456 	mtx_unlock(&pagertab_lock);
457 }
458 
459 static int
460 pbuf_ctor(void *mem, int size, void *arg, int flags)
461 {
462 	struct buf *bp = mem;
463 
464 	bp->b_vp = NULL;
465 	bp->b_bufobj = NULL;
466 
467 	/* copied from initpbuf() */
468 	bp->b_rcred = NOCRED;
469 	bp->b_wcred = NOCRED;
470 	bp->b_qindex = 0;       /* On no queue (QUEUE_NONE) */
471 	bp->b_data = bp->b_kvabase;
472 	bp->b_xflags = 0;
473 	bp->b_flags = B_MAXPHYS;
474 	bp->b_ioflags = 0;
475 	bp->b_iodone = NULL;
476 	bp->b_error = 0;
477 	BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL);
478 
479 	return (0);
480 }
481 
482 static void
483 pbuf_dtor(void *mem, int size, void *arg)
484 {
485 	struct buf *bp = mem;
486 
487 	if (bp->b_rcred != NOCRED) {
488 		crfree(bp->b_rcred);
489 		bp->b_rcred = NOCRED;
490 	}
491 	if (bp->b_wcred != NOCRED) {
492 		crfree(bp->b_wcred);
493 		bp->b_wcred = NOCRED;
494 	}
495 
496 	BUF_UNLOCK(bp);
497 }
498 
499 static const char pbuf_wmesg[] = "pbufwait";
500 
501 static int
502 pbuf_init(void *mem, int size, int flags)
503 {
504 	struct buf *bp = mem;
505 
506 	TSENTER();
507 
508 	bp->b_kvabase = (void *)kva_alloc(ptoa(PBUF_PAGES));
509 	if (bp->b_kvabase == NULL)
510 		return (ENOMEM);
511 	bp->b_kvasize = ptoa(PBUF_PAGES);
512 	BUF_LOCKINIT(bp, pbuf_wmesg);
513 	LIST_INIT(&bp->b_dep);
514 	bp->b_rcred = bp->b_wcred = NOCRED;
515 	bp->b_xflags = 0;
516 
517 	TSEXIT();
518 
519 	return (0);
520 }
521 
522 /*
523  * Associate a p-buffer with a vnode.
524  *
525  * Also sets B_PAGING flag to indicate that vnode is not fully associated
526  * with the buffer.  i.e. the bp has not been linked into the vnode or
527  * ref-counted.
528  */
529 void
530 pbgetvp(struct vnode *vp, struct buf *bp)
531 {
532 
533 	KASSERT(bp->b_vp == NULL, ("pbgetvp: not free"));
534 	KASSERT(bp->b_bufobj == NULL, ("pbgetvp: not free (bufobj)"));
535 
536 	bp->b_vp = vp;
537 	bp->b_flags |= B_PAGING;
538 	bp->b_bufobj = &vp->v_bufobj;
539 }
540 
541 /*
542  * Associate a p-buffer with a vnode.
543  *
544  * Also sets B_PAGING flag to indicate that vnode is not fully associated
545  * with the buffer.  i.e. the bp has not been linked into the vnode or
546  * ref-counted.
547  */
548 void
549 pbgetbo(struct bufobj *bo, struct buf *bp)
550 {
551 
552 	KASSERT(bp->b_vp == NULL, ("pbgetbo: not free (vnode)"));
553 	KASSERT(bp->b_bufobj == NULL, ("pbgetbo: not free (bufobj)"));
554 
555 	bp->b_flags |= B_PAGING;
556 	bp->b_bufobj = bo;
557 }
558 
559 /*
560  * Disassociate a p-buffer from a vnode.
561  */
562 void
563 pbrelvp(struct buf *bp)
564 {
565 
566 	KASSERT(bp->b_vp != NULL, ("pbrelvp: NULL"));
567 	KASSERT(bp->b_bufobj != NULL, ("pbrelvp: NULL bufobj"));
568 	KASSERT((bp->b_xflags & (BX_VNDIRTY | BX_VNCLEAN)) == 0,
569 	    ("pbrelvp: pager buf on vnode list."));
570 
571 	bp->b_vp = NULL;
572 	bp->b_bufobj = NULL;
573 	bp->b_flags &= ~B_PAGING;
574 }
575 
576 /*
577  * Disassociate a p-buffer from a bufobj.
578  */
579 void
580 pbrelbo(struct buf *bp)
581 {
582 
583 	KASSERT(bp->b_vp == NULL, ("pbrelbo: vnode"));
584 	KASSERT(bp->b_bufobj != NULL, ("pbrelbo: NULL bufobj"));
585 	KASSERT((bp->b_xflags & (BX_VNDIRTY | BX_VNCLEAN)) == 0,
586 	    ("pbrelbo: pager buf on vnode list."));
587 
588 	bp->b_bufobj = NULL;
589 	bp->b_flags &= ~B_PAGING;
590 }
591 
592 void
593 vm_object_set_writeable_dirty(vm_object_t object)
594 {
595 	pgo_set_writeable_dirty_t *method;
596 
597 	MPASS(object->type < nitems(pagertab));
598 
599 	method = pagertab[object->type]->pgo_set_writeable_dirty;
600 	if (method != NULL)
601 		method(object);
602 }
603 
604 bool
605 vm_object_mightbedirty(vm_object_t object)
606 {
607 	pgo_mightbedirty_t *method;
608 
609 	MPASS(object->type < nitems(pagertab));
610 
611 	method = pagertab[object->type]->pgo_mightbedirty;
612 	if (method == NULL)
613 		return (false);
614 	return (method(object));
615 }
616 
617 /*
618  * Return the kvme type of the given object.
619  * If vpp is not NULL, set it to the object's vm_object_vnode() or NULL.
620  */
621 int
622 vm_object_kvme_type(vm_object_t object, struct vnode **vpp)
623 {
624 	VM_OBJECT_ASSERT_LOCKED(object);
625 	MPASS(object->type < nitems(pagertab));
626 
627 	if (vpp != NULL)
628 		*vpp = vm_object_vnode(object);
629 	return (pagertab[object->type]->pgo_kvme_type);
630 }
631