vm_reserv.c 32.6 KB
Newer Older
1
2
/*-
 * Copyright (c) 2002-2006 Rice University
Alan Cox's avatar
Alan Cox committed
3
 * Copyright (c) 2007-2011 Alan L. Cox <alc@cs.rice.edu>
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 * All rights reserved.
 *
 * This software was developed for the FreeBSD Project by Alan L. Cox,
 * Olivier Crameri, Peter Druschel, Sitaram Iyer, and Juan Navarro.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT
 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 *	Superpage reservation management module
34
35
36
 *
 * Any external functions defined by this module are only to be used by the
 * virtual memory system.
37
38
39
40
41
42
43
44
45
46
47
48
49
 */

#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");

#include "opt_vm.h"

#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/lock.h>
#include <sys/malloc.h>
#include <sys/mutex.h>
#include <sys/queue.h>
50
#include <sys/rwlock.h>
51
52
53
54
55
56
57
58
59
#include <sys/sbuf.h>
#include <sys/sysctl.h>
#include <sys/systm.h>

#include <vm/vm.h>
#include <vm/vm_param.h>
#include <vm/vm_object.h>
#include <vm/vm_page.h>
#include <vm/vm_phys.h>
60
#include <vm/vm_radix.h>
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
#include <vm/vm_reserv.h>

/*
 * The reservation system supports the speculative allocation of large physical
 * pages ("superpages").  Speculative allocation enables the fully-automatic
 * utilization of superpages by the virtual memory system.  In other words, no
 * programmatic directives are required to use superpages.
 */

#if VM_NRESERVLEVEL > 0

/*
 * The number of small pages that are contained in a level 0 reservation
 */
#define	VM_LEVEL_0_NPAGES	(1 << VM_LEVEL_0_ORDER)

/*
 * The number of bits by which a physical address is shifted to obtain the
 * reservation number
 */
#define	VM_LEVEL_0_SHIFT	(VM_LEVEL_0_ORDER + PAGE_SHIFT)

/*
 * The size of a level 0 reservation in bytes
 */
#define	VM_LEVEL_0_SIZE		(1 << VM_LEVEL_0_SHIFT)

/*
 * Computes the index of the small page underlying the given (object, pindex)
 * within the reservation's array of small pages.
 */
#define	VM_RESERV_INDEX(object, pindex)	\
    (((object)->pg_color + (pindex)) & (VM_LEVEL_0_NPAGES - 1))

Alan Cox's avatar
Alan Cox committed
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
/*
 * The size of a population map entry
 */
typedef	u_long		popmap_t;

/*
 * The number of bits in a population map entry
 */
#define	NBPOPMAP	(NBBY * sizeof(popmap_t))

/*
 * The number of population map entries in a reservation
 */
#define	NPOPMAP		howmany(VM_LEVEL_0_NPAGES, NBPOPMAP)

110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
/*
 * Clear a bit in the population map.
 */
static __inline void
popmap_clear(popmap_t popmap[], int i)
{

	popmap[i / NBPOPMAP] &= ~(1UL << (i % NBPOPMAP));
}

/*
 * Set a bit in the population map.
 */
static __inline void
popmap_set(popmap_t popmap[], int i)
{

	popmap[i / NBPOPMAP] |= 1UL << (i % NBPOPMAP);
}

/*
 * Is a bit in the population map clear?
 */
static __inline boolean_t
popmap_is_clear(popmap_t popmap[], int i)
{

	return ((popmap[i / NBPOPMAP] & (1UL << (i % NBPOPMAP))) == 0);
}

/*
 * Is a bit in the population map set?
 */
static __inline boolean_t
popmap_is_set(popmap_t popmap[], int i)
{

	return ((popmap[i / NBPOPMAP] & (1UL << (i % NBPOPMAP))) != 0);
}

150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
/*
 * The reservation structure
 *
 * A reservation structure is constructed whenever a large physical page is
 * speculatively allocated to an object.  The reservation provides the small
 * physical pages for the range [pindex, pindex + VM_LEVEL_0_NPAGES) of offsets
 * within that object.  The reservation's "popcnt" tracks the number of these
 * small physical pages that are in use at any given time.  When and if the
 * reservation is not fully utilized, it appears in the queue of partially-
 * populated reservations.  The reservation always appears on the containing
 * object's list of reservations.
 *
 * A partially-populated reservation can be broken and reclaimed at any time.
 */
struct vm_reserv {
	TAILQ_ENTRY(vm_reserv) partpopq;
	LIST_ENTRY(vm_reserv) objq;
	vm_object_t	object;			/* containing object */
	vm_pindex_t	pindex;			/* offset within object */
	vm_page_t	pages;			/* first page of a superpage */
	int		popcnt;			/* # of pages in use */
	char		inpartpopq;
Alan Cox's avatar
Alan Cox committed
172
	popmap_t	popmap[NPOPMAP];	/* bit vector of used pages */
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
};

/*
 * The reservation array
 *
 * This array is analoguous in function to vm_page_array.  It differs in the
 * respect that it may contain a greater number of useful reservation
 * structures than there are (physical) superpages.  These "invalid"
 * reservation structures exist to trade-off space for time in the
 * implementation of vm_reserv_from_page().  Invalid reservation structures are
 * distinguishable from "valid" reservation structures by inspecting the
 * reservation's "pages" field.  Invalid reservation structures have a NULL
 * "pages" field.
 *
 * vm_reserv_from_page() maps a small (physical) page to an element of this
 * array by computing a physical reservation number from the page's physical
 * address.  The physical reservation number is used as the array index.
 *
 * An "active" reservation is a valid reservation structure that has a non-NULL
 * "object" field and a non-zero "popcnt" field.  In other words, every active
 * reservation belongs to a particular object.  Moreover, every active
 * reservation has an entry in the containing object's list of reservations.  
 */
static vm_reserv_t vm_reserv_array;

/*
 * The partially-populated reservation queue
 *
 * This queue enables the fast recovery of an unused cached or free small page
202
203
 * from a partially-populated reservation.  The reservation at the head of
 * this queue is the least-recently-changed, partially-populated reservation.
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
 *
 * Access to this queue is synchronized by the free page queue lock.
 */
static TAILQ_HEAD(, vm_reserv) vm_rvq_partpop =
			    TAILQ_HEAD_INITIALIZER(vm_rvq_partpop);

static SYSCTL_NODE(_vm, OID_AUTO, reserv, CTLFLAG_RD, 0, "Reservation Info");

static long vm_reserv_broken;
SYSCTL_LONG(_vm_reserv, OID_AUTO, broken, CTLFLAG_RD,
    &vm_reserv_broken, 0, "Cumulative number of broken reservations");

static long vm_reserv_freed;
SYSCTL_LONG(_vm_reserv, OID_AUTO, freed, CTLFLAG_RD,
    &vm_reserv_freed, 0, "Cumulative number of freed reservations");

220
221
222
223
224
static int sysctl_vm_reserv_fullpop(SYSCTL_HANDLER_ARGS);

SYSCTL_PROC(_vm_reserv, OID_AUTO, fullpop, CTLTYPE_INT | CTLFLAG_RD, NULL, 0,
    sysctl_vm_reserv_fullpop, "I", "Current number of full reservations");

225
226
227
228
229
230
231
232
233
static int sysctl_vm_reserv_partpopq(SYSCTL_HANDLER_ARGS);

SYSCTL_OID(_vm_reserv, OID_AUTO, partpopq, CTLTYPE_STRING | CTLFLAG_RD, NULL, 0,
    sysctl_vm_reserv_partpopq, "A", "Partially-populated reservation queues");

static long vm_reserv_reclaimed;
SYSCTL_LONG(_vm_reserv, OID_AUTO, reclaimed, CTLFLAG_RD,
    &vm_reserv_reclaimed, 0, "Cumulative number of reclaimed reservations");

Alan Cox's avatar
Alan Cox committed
234
235
static void		vm_reserv_break(vm_reserv_t rv, vm_page_t m);
static void		vm_reserv_depopulate(vm_reserv_t rv, int index);
236
237
238
static vm_reserv_t	vm_reserv_from_page(vm_page_t m);
static boolean_t	vm_reserv_has_pindex(vm_reserv_t rv,
			    vm_pindex_t pindex);
Alan Cox's avatar
Alan Cox committed
239
static void		vm_reserv_populate(vm_reserv_t rv, int index);
240
static void		vm_reserv_reclaim(vm_reserv_t rv);
241

242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
/*
 * Returns the current number of full reservations.
 *
 * Since the number of full reservations is computed without acquiring the
 * free page queue lock, the returned value may be inexact.
 */
static int
sysctl_vm_reserv_fullpop(SYSCTL_HANDLER_ARGS)
{
	vm_paddr_t paddr;
	struct vm_phys_seg *seg;
	vm_reserv_t rv;
	int fullpop, segind;

	fullpop = 0;
	for (segind = 0; segind < vm_phys_nsegs; segind++) {
		seg = &vm_phys_segs[segind];
		paddr = roundup2(seg->start, VM_LEVEL_0_SIZE);
		while (paddr + VM_LEVEL_0_SIZE <= seg->end) {
			rv = &vm_reserv_array[paddr >> VM_LEVEL_0_SHIFT];
			fullpop += rv->popcnt == VM_LEVEL_0_NPAGES;
			paddr += VM_LEVEL_0_SIZE;
		}
	}
	return (sysctl_handle_int(oidp, &fullpop, 0, req));
}

269
270
271
272
273
274
275
276
277
278
/*
 * Describes the current state of the partially-populated reservation queue.
 */
static int
sysctl_vm_reserv_partpopq(SYSCTL_HANDLER_ARGS)
{
	struct sbuf sbuf;
	vm_reserv_t rv;
	int counter, error, level, unused_pages;

279
280
281
	error = sysctl_wire_old_buffer(req, 0);
	if (error != 0)
		return (error);
282
	sbuf_new_for_sysctl(&sbuf, NULL, 128, req);
283
284
285
286
287
288
289
290
291
292
	sbuf_printf(&sbuf, "\nLEVEL     SIZE  NUMBER\n\n");
	for (level = -1; level <= VM_NRESERVLEVEL - 2; level++) {
		counter = 0;
		unused_pages = 0;
		mtx_lock(&vm_page_queue_free_mtx);
		TAILQ_FOREACH(rv, &vm_rvq_partpop/*[level]*/, partpopq) {
			counter++;
			unused_pages += VM_LEVEL_0_NPAGES - rv->popcnt;
		}
		mtx_unlock(&vm_page_queue_free_mtx);
293
		sbuf_printf(&sbuf, "%5d: %6dK, %6d\n", level,
294
		    unused_pages * ((int)PAGE_SIZE / 1024), counter);
295
	}
296
	error = sbuf_finish(&sbuf);
297
298
299
300
301
302
303
	sbuf_delete(&sbuf);
	return (error);
}

/*
 * Reduces the given reservation's population count.  If the population count
 * becomes zero, the reservation is destroyed.  Additionally, moves the
Alan Cox's avatar
Alan Cox committed
304
 * reservation to the tail of the partially-populated reservation queue if the
305
306
307
308
309
 * population count is non-zero.
 *
 * The free page queue lock must be held.
 */
static void
Alan Cox's avatar
Alan Cox committed
310
vm_reserv_depopulate(vm_reserv_t rv, int index)
311
312
313
314
315
{

	mtx_assert(&vm_page_queue_free_mtx, MA_OWNED);
	KASSERT(rv->object != NULL,
	    ("vm_reserv_depopulate: reserv %p is free", rv));
316
	KASSERT(popmap_is_set(rv->popmap, index),
317
318
	    ("vm_reserv_depopulate: reserv %p's popmap[%d] is clear", rv,
	    index));
319
320
321
322
323
	KASSERT(rv->popcnt > 0,
	    ("vm_reserv_depopulate: reserv %p's popcnt is corrupted", rv));
	if (rv->inpartpopq) {
		TAILQ_REMOVE(&vm_rvq_partpop, rv, partpopq);
		rv->inpartpopq = FALSE;
324
325
326
327
328
	} else {
		KASSERT(rv->pages->psind == 1,
		    ("vm_reserv_depopulate: reserv %p is already demoted",
		    rv));
		rv->pages->psind = 0;
329
	}
330
	popmap_clear(rv->popmap, index);
331
332
333
334
335
336
337
338
	rv->popcnt--;
	if (rv->popcnt == 0) {
		LIST_REMOVE(rv, objq);
		rv->object = NULL;
		vm_phys_free_pages(rv->pages, VM_LEVEL_0_ORDER);
		vm_reserv_freed++;
	} else {
		rv->inpartpopq = TRUE;
339
		TAILQ_INSERT_TAIL(&vm_rvq_partpop, rv, partpopq);
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
	}
}

/*
 * Returns the reservation to which the given page might belong.
 */
static __inline vm_reserv_t
vm_reserv_from_page(vm_page_t m)
{

	return (&vm_reserv_array[VM_PAGE_TO_PHYS(m) >> VM_LEVEL_0_SHIFT]);
}

/*
 * Returns TRUE if the given reservation contains the given page index and
 * FALSE otherwise.
 */
static __inline boolean_t
vm_reserv_has_pindex(vm_reserv_t rv, vm_pindex_t pindex)
{

	return (((pindex - rv->pindex) & ~(VM_LEVEL_0_NPAGES - 1)) == 0);
}

/*
 * Increases the given reservation's population count.  Moves the reservation
 * to the tail of the partially-populated reservation queue.
 *
 * The free page queue must be locked.
 */
static void
Alan Cox's avatar
Alan Cox committed
371
vm_reserv_populate(vm_reserv_t rv, int index)
372
373
374
375
376
{

	mtx_assert(&vm_page_queue_free_mtx, MA_OWNED);
	KASSERT(rv->object != NULL,
	    ("vm_reserv_populate: reserv %p is free", rv));
377
	KASSERT(popmap_is_clear(rv->popmap, index),
378
379
	    ("vm_reserv_populate: reserv %p's popmap[%d] is set", rv,
	    index));
380
381
	KASSERT(rv->popcnt < VM_LEVEL_0_NPAGES,
	    ("vm_reserv_populate: reserv %p is already full", rv));
382
383
	KASSERT(rv->pages->psind == 0,
	    ("vm_reserv_populate: reserv %p is already promoted", rv));
384
385
386
387
	if (rv->inpartpopq) {
		TAILQ_REMOVE(&vm_rvq_partpop, rv, partpopq);
		rv->inpartpopq = FALSE;
	}
388
	popmap_set(rv->popmap, index);
389
390
391
392
	rv->popcnt++;
	if (rv->popcnt < VM_LEVEL_0_NPAGES) {
		rv->inpartpopq = TRUE;
		TAILQ_INSERT_TAIL(&vm_rvq_partpop, rv, partpopq);
393
394
	} else
		rv->pages->psind = 1;
395
396
397
}

/*
398
 * Allocates a contiguous set of physical pages of the given size "npages"
399
 * from existing or newly created reservations.  All of the physical pages
400
401
402
403
404
405
 * must be at or above the given physical address "low" and below the given
 * physical address "high".  The given value "alignment" determines the
 * alignment of the first physical page in the set.  If the given value
 * "boundary" is non-zero, then the set of physical pages cannot cross any
 * physical address boundary that is a multiple of that value.  Both
 * "alignment" and "boundary" must be a power of two.
406
407
408
409
 *
 * The object and free page queue must be locked.
 */
vm_page_t
410
411
vm_reserv_alloc_contig(vm_object_t object, vm_pindex_t pindex, u_long npages,
    vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary)
412
{
413
414
	vm_paddr_t pa, size;
	vm_page_t m, m_ret, mpred, msucc;
415
416
	vm_pindex_t first, leftcap, rightcap;
	vm_reserv_t rv;
417
418
	u_long allocpages, maxpages, minpages;
	int i, index, n;
419
420

	mtx_assert(&vm_page_queue_free_mtx, MA_OWNED);
421
	VM_OBJECT_ASSERT_WLOCKED(object);
422
	KASSERT(npages != 0, ("vm_reserv_alloc_contig: npages is 0"));
423
424

	/*
425
	 * Is a reservation fundamentally impossible?
426
427
	 */
	if (pindex < VM_RESERV_INDEX(object, pindex) ||
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
	    pindex + npages > object->size)
		return (NULL);

	/*
	 * All reservations of a particular size have the same alignment.
	 * Assuming that the first page is allocated from a reservation, the
	 * least significant bits of its physical address can be determined
	 * from its offset from the beginning of the reservation and the size
	 * of the reservation.
	 *
	 * Could the specified index within a reservation of the smallest
	 * possible size satisfy the alignment and boundary requirements?
	 */
	pa = VM_RESERV_INDEX(object, pindex) << PAGE_SHIFT;
	if ((pa & (alignment - 1)) != 0)
		return (NULL);
	size = npages << PAGE_SHIFT;
	if (((pa ^ (pa + size - 1)) & ~(boundary - 1)) != 0)
446
447
448
449
450
		return (NULL);

	/*
	 * Look for an existing reservation.
	 */
451
452
453
	mpred = vm_radix_lookup_le(&object->rtree, pindex);
	if (mpred != NULL) {
		KASSERT(mpred->pindex < pindex,
454
		    ("vm_reserv_alloc_contig: pindex already allocated"));
455
		rv = vm_reserv_from_page(mpred);
456
457
		if (rv->object == object && vm_reserv_has_pindex(rv, pindex))
			goto found;
458
459
460
461
462
		msucc = TAILQ_NEXT(mpred, listq);
	} else
		msucc = TAILQ_FIRST(&object->memq);
	if (msucc != NULL) {
		KASSERT(msucc->pindex > pindex,
463
		    ("vm_reserv_alloc_contig: pindex already allocated"));
464
465
466
		rv = vm_reserv_from_page(msucc);
		if (rv->object == object && vm_reserv_has_pindex(rv, pindex))
			goto found;
467
468
469
	}

	/*
470
	 * Could at least one reservation fit between the first index to the
471
472
	 * left that can be used ("leftcap") and the first index to the right
	 * that cannot be used ("rightcap")?
473
474
	 */
	first = pindex - VM_RESERV_INDEX(object, pindex);
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
	if (mpred != NULL) {
		if ((rv = vm_reserv_from_page(mpred))->object != object)
			leftcap = mpred->pindex + 1;
		else
			leftcap = rv->pindex + VM_LEVEL_0_NPAGES;
		if (leftcap > first)
			return (NULL);
	}
	minpages = VM_RESERV_INDEX(object, pindex) + npages;
	maxpages = roundup2(minpages, VM_LEVEL_0_NPAGES);
	allocpages = maxpages;
	if (msucc != NULL) {
		if ((rv = vm_reserv_from_page(msucc))->object != object)
			rightcap = msucc->pindex;
		else
			rightcap = rv->pindex;
		if (first + maxpages > rightcap) {
			if (maxpages == VM_LEVEL_0_NPAGES)
				return (NULL);
494
495
496
497
498
499
500

			/*
			 * At least one reservation will fit between "leftcap"
			 * and "rightcap".  However, a reservation for the
			 * last of the requested pages will not fit.  Reduce
			 * the size of the upcoming allocation accordingly.
			 */
501
502
503
			allocpages = minpages;
		}
	}
504
505

	/*
506
	 * Would the last new reservation extend past the end of the object?
507
	 */
508
	if (first + maxpages > object->size) {
509
		/*
510
511
		 * Don't allocate the last new reservation if the object is a
		 * vnode or backed by another object that is a vnode. 
512
513
514
		 */
		if (object->type == OBJT_VNODE ||
		    (object->backing_object != NULL &&
515
516
517
518
519
		    object->backing_object->type == OBJT_VNODE)) {
			if (maxpages == VM_LEVEL_0_NPAGES)
				return (NULL);
			allocpages = minpages;
		}
520
521
522
523
		/* Speculate that the object may grow. */
	}

	/*
524
525
526
527
528
	 * Allocate the physical pages.  The alignment and boundary specified
	 * for this allocation may be different from the alignment and
	 * boundary specified for the requested pages.  For instance, the
	 * specified index may not be the first page within the first new
	 * reservation.
529
	 */
530
531
532
533
	m = vm_phys_alloc_contig(allocpages, low, high, ulmax(alignment,
	    VM_LEVEL_0_SIZE), boundary > VM_LEVEL_0_SIZE ? boundary : 0);
	if (m == NULL)
		return (NULL);
534
535
536
537
538
539
540

	/*
	 * The allocated physical pages always begin at a reservation
	 * boundary, but they do not always end at a reservation boundary.
	 * Initialize every reservation that is completely covered by the
	 * allocated physical pages.
	 */
541
542
543
	m_ret = NULL;
	index = VM_RESERV_INDEX(object, pindex);
	do {
544
545
		rv = vm_reserv_from_page(m);
		KASSERT(rv->pages == m,
546
		    ("vm_reserv_alloc_contig: reserv %p's pages is corrupted",
547
548
		    rv));
		KASSERT(rv->object == NULL,
549
		    ("vm_reserv_alloc_contig: reserv %p isn't free", rv));
550
551
552
553
		LIST_INSERT_HEAD(&object->rvq, rv, objq);
		rv->object = object;
		rv->pindex = first;
		KASSERT(rv->popcnt == 0,
554
		    ("vm_reserv_alloc_contig: reserv %p's popcnt is corrupted",
555
556
		    rv));
		KASSERT(!rv->inpartpopq,
557
		    ("vm_reserv_alloc_contig: reserv %p's inpartpopq is TRUE",
558
		    rv));
Alan Cox's avatar
Alan Cox committed
559
560
561
562
		for (i = 0; i < NPOPMAP; i++)
			KASSERT(rv->popmap[i] == 0,
		    ("vm_reserv_alloc_contig: reserv %p's popmap is corrupted",
			    rv));
563
564
		n = ulmin(VM_LEVEL_0_NPAGES - index, npages);
		for (i = 0; i < n; i++)
Alan Cox's avatar
Alan Cox committed
565
			vm_reserv_populate(rv, index + i);
566
567
568
569
570
571
572
573
		npages -= n;
		if (m_ret == NULL) {
			m_ret = &rv->pages[index];
			index = 0;
		}
		m += VM_LEVEL_0_NPAGES;
		first += VM_LEVEL_0_NPAGES;
		allocpages -= VM_LEVEL_0_NPAGES;
574
	} while (allocpages >= VM_LEVEL_0_NPAGES);
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
	return (m_ret);

	/*
	 * Found a matching reservation.
	 */
found:
	index = VM_RESERV_INDEX(object, pindex);
	/* Does the allocation fit within the reservation? */
	if (index + npages > VM_LEVEL_0_NPAGES)
		return (NULL);
	m = &rv->pages[index];
	pa = VM_PAGE_TO_PHYS(m);
	if (pa < low || pa + size > high || (pa & (alignment - 1)) != 0 ||
	    ((pa ^ (pa + size - 1)) & ~(boundary - 1)) != 0)
		return (NULL);
	/* Handle vm_page_rename(m, new_object, ...). */
	for (i = 0; i < npages; i++)
592
		if (popmap_is_set(rv->popmap, index + i))
593
594
			return (NULL);
	for (i = 0; i < npages; i++)
Alan Cox's avatar
Alan Cox committed
595
		vm_reserv_populate(rv, index + i);
596
597
598
599
600
601
	return (m);
}

/*
 * Allocates a page from an existing or newly-created reservation.
 *
602
603
604
 * The page "mpred" must immediately precede the offset "pindex" within the
 * specified object.
 *
605
606
607
 * The object and free page queue must be locked.
 */
vm_page_t
608
vm_reserv_alloc_page(vm_object_t object, vm_pindex_t pindex, vm_page_t mpred)
609
{
610
	vm_page_t m, msucc;
611
612
	vm_pindex_t first, leftcap, rightcap;
	vm_reserv_t rv;
Alan Cox's avatar
Alan Cox committed
613
	int i, index;
614
615

	mtx_assert(&vm_page_queue_free_mtx, MA_OWNED);
616
	VM_OBJECT_ASSERT_WLOCKED(object);
617
618
619
620
621
622
623
624
625
626
627

	/*
	 * Is a reservation fundamentally impossible?
	 */
	if (pindex < VM_RESERV_INDEX(object, pindex) ||
	    pindex >= object->size)
		return (NULL);

	/*
	 * Look for an existing reservation.
	 */
628
	if (mpred != NULL) {
629
		KASSERT(mpred->object == object,
630
		    ("vm_reserv_alloc_page: object doesn't contain mpred"));
631
		KASSERT(mpred->pindex < pindex,
632
		    ("vm_reserv_alloc_page: mpred doesn't precede pindex"));
633
634
635
		rv = vm_reserv_from_page(mpred);
		if (rv->object == object && vm_reserv_has_pindex(rv, pindex))
			goto found;
636
637
638
639
640
		msucc = TAILQ_NEXT(mpred, listq);
	} else
		msucc = TAILQ_FIRST(&object->memq);
	if (msucc != NULL) {
		KASSERT(msucc->pindex > pindex,
641
		    ("vm_reserv_alloc_page: msucc doesn't succeed pindex"));
642
643
644
		rv = vm_reserv_from_page(msucc);
		if (rv->object == object && vm_reserv_has_pindex(rv, pindex))
			goto found;
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
	}

	/*
	 * Could a reservation fit between the first index to the left that
	 * can be used and the first index to the right that cannot be used?
	 */
	first = pindex - VM_RESERV_INDEX(object, pindex);
	if (mpred != NULL) {
		if ((rv = vm_reserv_from_page(mpred))->object != object)
			leftcap = mpred->pindex + 1;
		else
			leftcap = rv->pindex + VM_LEVEL_0_NPAGES;
		if (leftcap > first)
			return (NULL);
	}
	if (msucc != NULL) {
		if ((rv = vm_reserv_from_page(msucc))->object != object)
			rightcap = msucc->pindex;
		else
			rightcap = rv->pindex;
		if (first + VM_LEVEL_0_NPAGES > rightcap)
			return (NULL);
	}

	/*
	 * Would a new reservation extend past the end of the object? 
	 */
	if (first + VM_LEVEL_0_NPAGES > object->size) {
		/*
		 * Don't allocate a new reservation if the object is a vnode or
		 * backed by another object that is a vnode. 
		 */
		if (object->type == OBJT_VNODE ||
		    (object->backing_object != NULL &&
		    object->backing_object->type == OBJT_VNODE))
			return (NULL);
		/* Speculate that the object may grow. */
682
	}
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701

	/*
	 * Allocate and populate the new reservation.
	 */
	m = vm_phys_alloc_pages(VM_FREEPOOL_DEFAULT, VM_LEVEL_0_ORDER);
	if (m == NULL)
		return (NULL);
	rv = vm_reserv_from_page(m);
	KASSERT(rv->pages == m,
	    ("vm_reserv_alloc_page: reserv %p's pages is corrupted", rv));
	KASSERT(rv->object == NULL,
	    ("vm_reserv_alloc_page: reserv %p isn't free", rv));
	LIST_INSERT_HEAD(&object->rvq, rv, objq);
	rv->object = object;
	rv->pindex = first;
	KASSERT(rv->popcnt == 0,
	    ("vm_reserv_alloc_page: reserv %p's popcnt is corrupted", rv));
	KASSERT(!rv->inpartpopq,
	    ("vm_reserv_alloc_page: reserv %p's inpartpopq is TRUE", rv));
Alan Cox's avatar
Alan Cox committed
702
703
704
705
706
707
708
	for (i = 0; i < NPOPMAP; i++)
		KASSERT(rv->popmap[i] == 0,
		    ("vm_reserv_alloc_page: reserv %p's popmap is corrupted",
		    rv));
	index = VM_RESERV_INDEX(object, pindex);
	vm_reserv_populate(rv, index);
	return (&rv->pages[index]);
709
710
711
712
713

	/*
	 * Found a matching reservation.
	 */
found:
Alan Cox's avatar
Alan Cox committed
714
715
	index = VM_RESERV_INDEX(object, pindex);
	m = &rv->pages[index];
716
	/* Handle vm_page_rename(m, new_object, ...). */
717
	if (popmap_is_set(rv->popmap, index))
718
		return (NULL);
Alan Cox's avatar
Alan Cox committed
719
	vm_reserv_populate(rv, index);
720
721
722
	return (m);
}

Alan Cox's avatar
Alan Cox committed
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
/*
 * Breaks the given reservation.  Except for the specified cached or free
 * page, all cached and free pages in the reservation are returned to the
 * physical memory allocator.  The reservation's population count and map are
 * reset to their initial state.
 *
 * The given reservation must not be in the partially-populated reservation
 * queue.  The free page queue lock must be held.
 */
static void
vm_reserv_break(vm_reserv_t rv, vm_page_t m)
{
	int begin_zeroes, hi, i, lo;

	mtx_assert(&vm_page_queue_free_mtx, MA_OWNED);
	KASSERT(rv->object != NULL,
	    ("vm_reserv_break: reserv %p is free", rv));
	KASSERT(!rv->inpartpopq,
	    ("vm_reserv_break: reserv %p's inpartpopq is TRUE", rv));
	LIST_REMOVE(rv, objq);
	rv->object = NULL;
	if (m != NULL) {
		/*
		 * Since the reservation is being broken, there is no harm in
		 * abusing the population map to stop "m" from being returned
		 * to the physical memory allocator.
		 */
		i = m - rv->pages;
751
		KASSERT(popmap_is_clear(rv->popmap, i),
Alan Cox's avatar
Alan Cox committed
752
		    ("vm_reserv_break: reserv %p's popmap is corrupted", rv));
753
		popmap_set(rv->popmap, i);
Alan Cox's avatar
Alan Cox committed
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
		rv->popcnt++;
	}
	i = hi = 0;
	do {
		/* Find the next 0 bit.  Any previous 0 bits are < "hi". */
		lo = ffsl(~(((1UL << hi) - 1) | rv->popmap[i]));
		if (lo == 0) {
			/* Redundantly clears bits < "hi". */
			rv->popmap[i] = 0;
			rv->popcnt -= NBPOPMAP - hi;
			while (++i < NPOPMAP) {
				lo = ffsl(~rv->popmap[i]);
				if (lo == 0) {
					rv->popmap[i] = 0;
					rv->popcnt -= NBPOPMAP;
				} else
					break;
			}
			if (i == NPOPMAP)
				break;
			hi = 0;
		}
		KASSERT(lo > 0, ("vm_reserv_break: lo is %d", lo));
		/* Convert from ffsl() to ordinary bit numbering. */
		lo--;
		if (lo > 0) {
			/* Redundantly clears bits < "hi". */
			rv->popmap[i] &= ~((1UL << lo) - 1);
			rv->popcnt -= lo - hi;
		}
		begin_zeroes = NBPOPMAP * i + lo;
		/* Find the next 1 bit. */
		do
			hi = ffsl(rv->popmap[i]);
		while (hi == 0 && ++i < NPOPMAP);
		if (i != NPOPMAP)
			/* Convert from ffsl() to ordinary bit numbering. */
			hi--;
		vm_phys_free_contig(&rv->pages[begin_zeroes], NBPOPMAP * i +
		    hi - begin_zeroes);
	} while (i < NPOPMAP);
	KASSERT(rv->popcnt == 0,
	    ("vm_reserv_break: reserv %p's popcnt is corrupted", rv));
	vm_reserv_broken++;
}

800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
/*
 * Breaks all reservations belonging to the given object.
 */
void
vm_reserv_break_all(vm_object_t object)
{
	vm_reserv_t rv;

	mtx_lock(&vm_page_queue_free_mtx);
	while ((rv = LIST_FIRST(&object->rvq)) != NULL) {
		KASSERT(rv->object == object,
		    ("vm_reserv_break_all: reserv %p is corrupted", rv));
		if (rv->inpartpopq) {
			TAILQ_REMOVE(&vm_rvq_partpop, rv, partpopq);
			rv->inpartpopq = FALSE;
		}
Alan Cox's avatar
Alan Cox committed
816
		vm_reserv_break(rv, NULL);
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
	}
	mtx_unlock(&vm_page_queue_free_mtx);
}

/*
 * Frees the given page if it belongs to a reservation.  Returns TRUE if the
 * page is freed and FALSE otherwise.
 *
 * The free page queue lock must be held.
 */
boolean_t
vm_reserv_free_page(vm_page_t m)
{
	vm_reserv_t rv;

	mtx_assert(&vm_page_queue_free_mtx, MA_OWNED);
	rv = vm_reserv_from_page(m);
834
835
	if (rv->object == NULL)
		return (FALSE);
Alan Cox's avatar
Alan Cox committed
836
	vm_reserv_depopulate(rv, m - rv->pages);
837
	return (TRUE);
838
839
840
841
842
843
844
845
846
847
848
849
}

/*
 * Initializes the reservation management system.  Specifically, initializes
 * the reservation array.
 *
 * Requires that vm_page_array and first_page are initialized!
 */
void
vm_reserv_init(void)
{
	vm_paddr_t paddr;
850
851
	struct vm_phys_seg *seg;
	int segind;
852
853
854
855
856

	/*
	 * Initialize the reservation array.  Specifically, initialize the
	 * "pages" field for every element that has an underlying superpage.
	 */
857
858
859
860
	for (segind = 0; segind < vm_phys_nsegs; segind++) {
		seg = &vm_phys_segs[segind];
		paddr = roundup2(seg->start, VM_LEVEL_0_SIZE);
		while (paddr + VM_LEVEL_0_SIZE <= seg->end) {
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
			vm_reserv_array[paddr >> VM_LEVEL_0_SHIFT].pages =
			    PHYS_TO_VM_PAGE(paddr);
			paddr += VM_LEVEL_0_SIZE;
		}
	}
}

/*
 * Returns a reservation level if the given page belongs to a fully-populated
 * reservation and -1 otherwise.
 */
int
vm_reserv_level_iffullpop(vm_page_t m)
{
	vm_reserv_t rv;

	rv = vm_reserv_from_page(m);
	return (rv->popcnt == VM_LEVEL_0_NPAGES ? 0 : -1);
}

/*
 * Prepare for the reactivation of a cached page.
 *
 * First, suppose that the given page "m" was allocated individually, i.e., not
 * as part of a reservation, and cached.  Then, suppose a reservation
 * containing "m" is allocated by the same object.  Although "m" and the
 * reservation belong to the same object, "m"'s pindex may not match the
 * reservation's.
 *
 * The free page queue must be locked.
 */
boolean_t
vm_reserv_reactivate_page(vm_page_t m)
{
	vm_reserv_t rv;
Alan Cox's avatar
Alan Cox committed
896
	int index;
897
898
899
900
901
902

	mtx_assert(&vm_page_queue_free_mtx, MA_OWNED);
	rv = vm_reserv_from_page(m);
	if (rv->object == NULL)
		return (FALSE);
	KASSERT((m->flags & PG_CACHED) != 0,
Alan Cox's avatar
Alan Cox committed
903
	    ("vm_reserv_reactivate_page: page %p is not cached", m));
904
	if (m->object == rv->object &&
Alan Cox's avatar
Alan Cox committed
905
906
907
	    m->pindex - rv->pindex == (index = VM_RESERV_INDEX(m->object,
	    m->pindex)))
		vm_reserv_populate(rv, index);
908
909
	else {
		KASSERT(rv->inpartpopq,
Alan Cox's avatar
Alan Cox committed
910
	    ("vm_reserv_reactivate_page: reserv %p's inpartpopq is FALSE",
911
912
913
		    rv));
		TAILQ_REMOVE(&vm_rvq_partpop, rv, partpopq);
		rv->inpartpopq = FALSE;
Alan Cox's avatar
Alan Cox committed
914
915
		/* Don't release "m" to the physical memory allocator. */
		vm_reserv_break(rv, m);
916
917
918
919
	}
	return (TRUE);
}

920
921
922
923
924
925
926
927
928
929
930
931
/*
 * Breaks the given partially-populated reservation, releasing its cached and
 * free pages to the physical memory allocator.
 *
 * The free page queue lock must be held.
 */
static void
vm_reserv_reclaim(vm_reserv_t rv)
{

	mtx_assert(&vm_page_queue_free_mtx, MA_OWNED);
	KASSERT(rv->inpartpopq,
Alan Cox's avatar
Alan Cox committed
932
	    ("vm_reserv_reclaim: reserv %p's inpartpopq is FALSE", rv));
933
934
	TAILQ_REMOVE(&vm_rvq_partpop, rv, partpopq);
	rv->inpartpopq = FALSE;
Alan Cox's avatar
Alan Cox committed
935
	vm_reserv_break(rv, NULL);
936
937
938
	vm_reserv_reclaimed++;
}

939
940
941
942
943
944
945
946
/*
 * Breaks the reservation at the head of the partially-populated reservation
 * queue, releasing its cached and free pages to the physical memory
 * allocator.  Returns TRUE if a reservation is broken and FALSE otherwise.
 *
 * The free page queue lock must be held.
 */
boolean_t
947
vm_reserv_reclaim_inactive(void)
948
949
950
951
952
{
	vm_reserv_t rv;

	mtx_assert(&vm_page_queue_free_mtx, MA_OWNED);
	if ((rv = TAILQ_FIRST(&vm_rvq_partpop)) != NULL) {
953
		vm_reserv_reclaim(rv);
954
955
956
957
958
		return (TRUE);
	}
	return (FALSE);
}

959
960
961
962
963
964
965
966
967
968
/*
 * Searches the partially-populated reservation queue for the least recently
 * active reservation with unused pages, i.e., cached or free, that satisfy the
 * given request for contiguous physical memory.  If a satisfactory reservation
 * is found, it is broken.  Returns TRUE if a reservation is broken and FALSE
 * otherwise.
 *
 * The free page queue lock must be held.
 */
boolean_t
969
vm_reserv_reclaim_contig(u_long npages, vm_paddr_t low, vm_paddr_t high,
970
    u_long alignment, vm_paddr_t boundary)
971
{
Alan Cox's avatar
Alan Cox committed
972
	vm_paddr_t pa, size;
973
	vm_reserv_t rv;
974
	int hi, i, lo, low_index, next_free;
975
976

	mtx_assert(&vm_page_queue_free_mtx, MA_OWNED);
977
	if (npages > VM_LEVEL_0_NPAGES - 1)
978
		return (FALSE);
979
	size = npages << PAGE_SHIFT;
980
981
982
	TAILQ_FOREACH(rv, &vm_rvq_partpop, partpopq) {
		pa = VM_PAGE_TO_PHYS(&rv->pages[VM_LEVEL_0_NPAGES - 1]);
		if (pa + PAGE_SIZE - size < low) {
Alan Cox's avatar
Alan Cox committed
983
			/* This entire reservation is too low; go to next. */
984
985
			continue;
		}
Alan Cox's avatar
Alan Cox committed
986
987
988
989
990
991
992
		pa = VM_PAGE_TO_PHYS(&rv->pages[0]);
		if (pa + size > high) {
			/* This entire reservation is too high; go to next. */
			continue;
		}
		if (pa < low) {
			/* Start the search for free pages at "low". */
993
994
995
			low_index = (low + PAGE_MASK - pa) >> PAGE_SHIFT;
			i = low_index / NBPOPMAP;
			hi = low_index % NBPOPMAP;
Alan Cox's avatar
Alan Cox committed
996
997
998
999
1000
		} else
			i = hi = 0;
		do {
			/* Find the next free page. */
			lo = ffsl(~(((1UL << hi) - 1) | rv->popmap[i]));
For faster browsing, not all history is shown. View entire blame