uvm_pdaemon.c revision 1.62 1 1.62 yamt /* $NetBSD: uvm_pdaemon.c,v 1.62 2005/04/12 13:11:45 yamt Exp $ */
2 1.1 mrg
3 1.34 chs /*
4 1.1 mrg * Copyright (c) 1997 Charles D. Cranor and Washington University.
5 1.34 chs * Copyright (c) 1991, 1993, The Regents of the University of California.
6 1.1 mrg *
7 1.1 mrg * All rights reserved.
8 1.1 mrg *
9 1.1 mrg * This code is derived from software contributed to Berkeley by
10 1.1 mrg * The Mach Operating System project at Carnegie-Mellon University.
11 1.1 mrg *
12 1.1 mrg * Redistribution and use in source and binary forms, with or without
13 1.1 mrg * modification, are permitted provided that the following conditions
14 1.1 mrg * are met:
15 1.1 mrg * 1. Redistributions of source code must retain the above copyright
16 1.1 mrg * notice, this list of conditions and the following disclaimer.
17 1.1 mrg * 2. Redistributions in binary form must reproduce the above copyright
18 1.1 mrg * notice, this list of conditions and the following disclaimer in the
19 1.1 mrg * documentation and/or other materials provided with the distribution.
20 1.1 mrg * 3. All advertising materials mentioning features or use of this software
21 1.1 mrg * must display the following acknowledgement:
22 1.1 mrg * This product includes software developed by Charles D. Cranor,
23 1.34 chs * Washington University, the University of California, Berkeley and
24 1.1 mrg * its contributors.
25 1.1 mrg * 4. Neither the name of the University nor the names of its contributors
26 1.1 mrg * may be used to endorse or promote products derived from this software
27 1.1 mrg * without specific prior written permission.
28 1.1 mrg *
29 1.1 mrg * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
30 1.1 mrg * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
31 1.1 mrg * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
32 1.1 mrg * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
33 1.1 mrg * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
34 1.1 mrg * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
35 1.1 mrg * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
36 1.1 mrg * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
37 1.1 mrg * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
38 1.1 mrg * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
39 1.1 mrg * SUCH DAMAGE.
40 1.1 mrg *
41 1.1 mrg * @(#)vm_pageout.c 8.5 (Berkeley) 2/14/94
42 1.4 mrg * from: Id: uvm_pdaemon.c,v 1.1.2.32 1998/02/06 05:26:30 chs Exp
43 1.1 mrg *
44 1.1 mrg *
45 1.1 mrg * Copyright (c) 1987, 1990 Carnegie-Mellon University.
46 1.1 mrg * All rights reserved.
47 1.34 chs *
48 1.1 mrg * Permission to use, copy, modify and distribute this software and
49 1.1 mrg * its documentation is hereby granted, provided that both the copyright
50 1.1 mrg * notice and this permission notice appear in all copies of the
51 1.1 mrg * software, derivative works or modified versions, and any portions
52 1.1 mrg * thereof, and that both notices appear in supporting documentation.
53 1.34 chs *
54 1.34 chs * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
55 1.34 chs * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
56 1.1 mrg * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
57 1.34 chs *
58 1.1 mrg * Carnegie Mellon requests users of this software to return to
59 1.1 mrg *
60 1.1 mrg * Software Distribution Coordinator or Software.Distribution (at) CS.CMU.EDU
61 1.1 mrg * School of Computer Science
62 1.1 mrg * Carnegie Mellon University
63 1.1 mrg * Pittsburgh PA 15213-3890
64 1.1 mrg *
65 1.1 mrg * any improvements or extensions that they make and grant Carnegie the
66 1.1 mrg * rights to redistribute these changes.
67 1.1 mrg */
68 1.1 mrg
69 1.1 mrg /*
70 1.1 mrg * uvm_pdaemon.c: the page daemon
71 1.1 mrg */
72 1.42 lukem
73 1.42 lukem #include <sys/cdefs.h>
74 1.62 yamt __KERNEL_RCSID(0, "$NetBSD: uvm_pdaemon.c,v 1.62 2005/04/12 13:11:45 yamt Exp $");
75 1.42 lukem
76 1.42 lukem #include "opt_uvmhist.h"
77 1.1 mrg
78 1.1 mrg #include <sys/param.h>
79 1.1 mrg #include <sys/proc.h>
80 1.1 mrg #include <sys/systm.h>
81 1.1 mrg #include <sys/kernel.h>
82 1.9 pk #include <sys/pool.h>
83 1.24 chs #include <sys/buf.h>
84 1.30 chs #include <sys/vnode.h>
85 1.1 mrg
86 1.1 mrg #include <uvm/uvm.h>
87 1.1 mrg
88 1.1 mrg /*
89 1.45 wiz * UVMPD_NUMDIRTYREACTS is how many dirty pages the pagedaemon will reactivate
90 1.14 chs * in a pass thru the inactive list when swap is full. the value should be
91 1.14 chs * "small"... if it's too large we'll cycle the active pages thru the inactive
92 1.14 chs * queue too quickly to for them to be referenced and avoid being freed.
93 1.14 chs */
94 1.14 chs
95 1.14 chs #define UVMPD_NUMDIRTYREACTS 16
96 1.14 chs
97 1.14 chs
98 1.14 chs /*
99 1.1 mrg * local prototypes
100 1.1 mrg */
101 1.1 mrg
102 1.59 junyoung void uvmpd_scan(void);
103 1.59 junyoung void uvmpd_scan_inactive(struct pglist *);
104 1.59 junyoung void uvmpd_tune(void);
105 1.1 mrg
106 1.1 mrg /*
107 1.61 chs * XXX hack to avoid hangs when large processes fork.
108 1.61 chs */
109 1.61 chs int uvm_extrapages;
110 1.61 chs
111 1.61 chs /*
112 1.1 mrg * uvm_wait: wait (sleep) for the page daemon to free some pages
113 1.1 mrg *
114 1.1 mrg * => should be called with all locks released
115 1.1 mrg * => should _not_ be called by the page daemon (to avoid deadlock)
116 1.1 mrg */
117 1.1 mrg
118 1.19 thorpej void
119 1.19 thorpej uvm_wait(wmsg)
120 1.19 thorpej const char *wmsg;
121 1.8 mrg {
122 1.8 mrg int timo = 0;
123 1.8 mrg int s = splbio();
124 1.1 mrg
125 1.8 mrg /*
126 1.8 mrg * check for page daemon going to sleep (waiting for itself)
127 1.8 mrg */
128 1.1 mrg
129 1.37 chs if (curproc == uvm.pagedaemon_proc && uvmexp.paging == 0) {
130 1.8 mrg /*
131 1.8 mrg * now we have a problem: the pagedaemon wants to go to
132 1.8 mrg * sleep until it frees more memory. but how can it
133 1.8 mrg * free more memory if it is asleep? that is a deadlock.
134 1.8 mrg * we have two options:
135 1.8 mrg * [1] panic now
136 1.8 mrg * [2] put a timeout on the sleep, thus causing the
137 1.8 mrg * pagedaemon to only pause (rather than sleep forever)
138 1.8 mrg *
139 1.8 mrg * note that option [2] will only help us if we get lucky
140 1.8 mrg * and some other process on the system breaks the deadlock
141 1.8 mrg * by exiting or freeing memory (thus allowing the pagedaemon
142 1.8 mrg * to continue). for now we panic if DEBUG is defined,
143 1.8 mrg * otherwise we hope for the best with option [2] (better
144 1.8 mrg * yet, this should never happen in the first place!).
145 1.8 mrg */
146 1.1 mrg
147 1.8 mrg printf("pagedaemon: deadlock detected!\n");
148 1.8 mrg timo = hz >> 3; /* set timeout */
149 1.1 mrg #if defined(DEBUG)
150 1.8 mrg /* DEBUG: panic so we can debug it */
151 1.8 mrg panic("pagedaemon deadlock");
152 1.1 mrg #endif
153 1.8 mrg }
154 1.1 mrg
155 1.8 mrg simple_lock(&uvm.pagedaemon_lock);
156 1.17 thorpej wakeup(&uvm.pagedaemon); /* wake the daemon! */
157 1.8 mrg UVM_UNLOCK_AND_WAIT(&uvmexp.free, &uvm.pagedaemon_lock, FALSE, wmsg,
158 1.8 mrg timo);
159 1.1 mrg
160 1.8 mrg splx(s);
161 1.1 mrg }
162 1.1 mrg
163 1.1 mrg
164 1.1 mrg /*
165 1.1 mrg * uvmpd_tune: tune paging parameters
166 1.1 mrg *
167 1.1 mrg * => called when ever memory is added (or removed?) to the system
168 1.1 mrg * => caller must call with page queues locked
169 1.1 mrg */
170 1.1 mrg
171 1.37 chs void
172 1.37 chs uvmpd_tune(void)
173 1.8 mrg {
174 1.8 mrg UVMHIST_FUNC("uvmpd_tune"); UVMHIST_CALLED(pdhist);
175 1.1 mrg
176 1.8 mrg uvmexp.freemin = uvmexp.npages / 20;
177 1.1 mrg
178 1.8 mrg /* between 16k and 256k */
179 1.8 mrg /* XXX: what are these values good for? */
180 1.37 chs uvmexp.freemin = MAX(uvmexp.freemin, (16*1024) >> PAGE_SHIFT);
181 1.37 chs uvmexp.freemin = MIN(uvmexp.freemin, (256*1024) >> PAGE_SHIFT);
182 1.23 bjh21
183 1.23 bjh21 /* Make sure there's always a user page free. */
184 1.23 bjh21 if (uvmexp.freemin < uvmexp.reserve_kernel + 1)
185 1.23 bjh21 uvmexp.freemin = uvmexp.reserve_kernel + 1;
186 1.1 mrg
187 1.8 mrg uvmexp.freetarg = (uvmexp.freemin * 4) / 3;
188 1.8 mrg if (uvmexp.freetarg <= uvmexp.freemin)
189 1.8 mrg uvmexp.freetarg = uvmexp.freemin + 1;
190 1.1 mrg
191 1.61 chs uvmexp.freetarg += uvm_extrapages;
192 1.61 chs uvm_extrapages = 0;
193 1.61 chs
194 1.8 mrg /* uvmexp.inactarg: computed in main daemon loop */
195 1.1 mrg
196 1.8 mrg uvmexp.wiredmax = uvmexp.npages / 3;
197 1.8 mrg UVMHIST_LOG(pdhist, "<- done, freemin=%d, freetarg=%d, wiredmax=%d",
198 1.1 mrg uvmexp.freemin, uvmexp.freetarg, uvmexp.wiredmax, 0);
199 1.1 mrg }
200 1.1 mrg
201 1.1 mrg /*
202 1.1 mrg * uvm_pageout: the main loop for the pagedaemon
203 1.1 mrg */
204 1.1 mrg
205 1.8 mrg void
206 1.22 thorpej uvm_pageout(void *arg)
207 1.8 mrg {
208 1.60 enami int bufcnt, npages = 0;
209 1.61 chs int extrapages = 0;
210 1.8 mrg UVMHIST_FUNC("uvm_pageout"); UVMHIST_CALLED(pdhist);
211 1.24 chs
212 1.8 mrg UVMHIST_LOG(pdhist,"<starting uvm pagedaemon>", 0, 0, 0, 0);
213 1.8 mrg
214 1.8 mrg /*
215 1.8 mrg * ensure correct priority and set paging parameters...
216 1.8 mrg */
217 1.8 mrg
218 1.8 mrg uvm.pagedaemon_proc = curproc;
219 1.8 mrg uvm_lock_pageq();
220 1.8 mrg npages = uvmexp.npages;
221 1.8 mrg uvmpd_tune();
222 1.8 mrg uvm_unlock_pageq();
223 1.8 mrg
224 1.8 mrg /*
225 1.8 mrg * main loop
226 1.8 mrg */
227 1.24 chs
228 1.24 chs for (;;) {
229 1.24 chs simple_lock(&uvm.pagedaemon_lock);
230 1.24 chs
231 1.24 chs UVMHIST_LOG(pdhist," <<SLEEPING>>",0,0,0,0);
232 1.24 chs UVM_UNLOCK_AND_WAIT(&uvm.pagedaemon,
233 1.24 chs &uvm.pagedaemon_lock, FALSE, "pgdaemon", 0);
234 1.24 chs uvmexp.pdwoke++;
235 1.24 chs UVMHIST_LOG(pdhist," <<WOKE UP>>",0,0,0,0);
236 1.24 chs
237 1.8 mrg /*
238 1.24 chs * now lock page queues and recompute inactive count
239 1.8 mrg */
240 1.8 mrg
241 1.24 chs uvm_lock_pageq();
242 1.61 chs if (npages != uvmexp.npages || extrapages != uvm_extrapages) {
243 1.24 chs npages = uvmexp.npages;
244 1.61 chs extrapages = uvm_extrapages;
245 1.24 chs uvmpd_tune();
246 1.24 chs }
247 1.24 chs
248 1.24 chs uvmexp.inactarg = (uvmexp.active + uvmexp.inactive) / 3;
249 1.24 chs if (uvmexp.inactarg <= uvmexp.freetarg) {
250 1.24 chs uvmexp.inactarg = uvmexp.freetarg + 1;
251 1.24 chs }
252 1.24 chs
253 1.60 enami /*
254 1.60 enami * Estimate a hint. Note that bufmem are returned to
255 1.60 enami * system only when entire pool page is empty.
256 1.60 enami */
257 1.60 enami bufcnt = uvmexp.freetarg - uvmexp.free;
258 1.60 enami if (bufcnt < 0)
259 1.60 enami bufcnt = 0;
260 1.60 enami
261 1.24 chs UVMHIST_LOG(pdhist," free/ftarg=%d/%d, inact/itarg=%d/%d",
262 1.24 chs uvmexp.free, uvmexp.freetarg, uvmexp.inactive,
263 1.24 chs uvmexp.inactarg);
264 1.8 mrg
265 1.8 mrg /*
266 1.24 chs * scan if needed
267 1.8 mrg */
268 1.8 mrg
269 1.24 chs if (uvmexp.free + uvmexp.paging < uvmexp.freetarg ||
270 1.30 chs uvmexp.inactive < uvmexp.inactarg) {
271 1.24 chs uvmpd_scan();
272 1.8 mrg }
273 1.8 mrg
274 1.8 mrg /*
275 1.24 chs * if there's any free memory to be had,
276 1.24 chs * wake up any waiters.
277 1.8 mrg */
278 1.8 mrg
279 1.24 chs if (uvmexp.free > uvmexp.reserve_kernel ||
280 1.24 chs uvmexp.paging == 0) {
281 1.24 chs wakeup(&uvmexp.free);
282 1.8 mrg }
283 1.1 mrg
284 1.8 mrg /*
285 1.24 chs * scan done. unlock page queues (the only lock we are holding)
286 1.8 mrg */
287 1.8 mrg
288 1.24 chs uvm_unlock_pageq();
289 1.38 chs
290 1.60 enami buf_drain(bufcnt << PAGE_SHIFT);
291 1.60 enami
292 1.38 chs /*
293 1.38 chs * drain pool resources now that we're not holding any locks
294 1.38 chs */
295 1.38 chs
296 1.38 chs pool_drain(0);
297 1.57 jdolecek
298 1.57 jdolecek /*
299 1.57 jdolecek * free any cached u-areas we don't need
300 1.57 jdolecek */
301 1.57 jdolecek uvm_uarea_drain(TRUE);
302 1.57 jdolecek
303 1.24 chs }
304 1.24 chs /*NOTREACHED*/
305 1.24 chs }
306 1.24 chs
307 1.8 mrg
308 1.24 chs /*
309 1.24 chs * uvm_aiodone_daemon: main loop for the aiodone daemon.
310 1.24 chs */
311 1.8 mrg
312 1.24 chs void
313 1.24 chs uvm_aiodone_daemon(void *arg)
314 1.24 chs {
315 1.24 chs int s, free;
316 1.24 chs struct buf *bp, *nbp;
317 1.24 chs UVMHIST_FUNC("uvm_aiodoned"); UVMHIST_CALLED(pdhist);
318 1.9 pk
319 1.24 chs for (;;) {
320 1.8 mrg
321 1.8 mrg /*
322 1.24 chs * carefully attempt to go to sleep (without losing "wakeups"!).
323 1.24 chs * we need splbio because we want to make sure the aio_done list
324 1.24 chs * is totally empty before we go to sleep.
325 1.8 mrg */
326 1.8 mrg
327 1.24 chs s = splbio();
328 1.24 chs simple_lock(&uvm.aiodoned_lock);
329 1.24 chs if (TAILQ_FIRST(&uvm.aio_done) == NULL) {
330 1.24 chs UVMHIST_LOG(pdhist," <<SLEEPING>>",0,0,0,0);
331 1.24 chs UVM_UNLOCK_AND_WAIT(&uvm.aiodoned,
332 1.24 chs &uvm.aiodoned_lock, FALSE, "aiodoned", 0);
333 1.24 chs UVMHIST_LOG(pdhist," <<WOKE UP>>",0,0,0,0);
334 1.24 chs
335 1.24 chs /* relock aiodoned_lock, still at splbio */
336 1.24 chs simple_lock(&uvm.aiodoned_lock);
337 1.8 mrg }
338 1.8 mrg
339 1.24 chs /*
340 1.24 chs * check for done aio structures
341 1.24 chs */
342 1.8 mrg
343 1.24 chs bp = TAILQ_FIRST(&uvm.aio_done);
344 1.24 chs if (bp) {
345 1.24 chs TAILQ_INIT(&uvm.aio_done);
346 1.24 chs }
347 1.8 mrg
348 1.24 chs simple_unlock(&uvm.aiodoned_lock);
349 1.24 chs splx(s);
350 1.8 mrg
351 1.8 mrg /*
352 1.24 chs * process each i/o that's done.
353 1.8 mrg */
354 1.8 mrg
355 1.24 chs free = uvmexp.free;
356 1.24 chs while (bp != NULL) {
357 1.24 chs nbp = TAILQ_NEXT(bp, b_freelist);
358 1.24 chs (*bp->b_iodone)(bp);
359 1.24 chs bp = nbp;
360 1.24 chs }
361 1.24 chs if (free <= uvmexp.reserve_kernel) {
362 1.24 chs s = uvm_lock_fpageq();
363 1.24 chs wakeup(&uvm.pagedaemon);
364 1.24 chs uvm_unlock_fpageq(s);
365 1.24 chs } else {
366 1.24 chs simple_lock(&uvm.pagedaemon_lock);
367 1.17 thorpej wakeup(&uvmexp.free);
368 1.24 chs simple_unlock(&uvm.pagedaemon_lock);
369 1.24 chs }
370 1.8 mrg }
371 1.1 mrg }
372 1.1 mrg
373 1.1 mrg /*
374 1.24 chs * uvmpd_scan_inactive: scan an inactive list for pages to clean or free.
375 1.1 mrg *
376 1.1 mrg * => called with page queues locked
377 1.1 mrg * => we work on meeting our free target by converting inactive pages
378 1.1 mrg * into free pages.
379 1.1 mrg * => we handle the building of swap-backed clusters
380 1.1 mrg * => we return TRUE if we are exiting because we met our target
381 1.1 mrg */
382 1.1 mrg
383 1.46 chs void
384 1.8 mrg uvmpd_scan_inactive(pglst)
385 1.8 mrg struct pglist *pglst;
386 1.8 mrg {
387 1.37 chs int error;
388 1.48 scw struct vm_page *p, *nextpg = NULL; /* Quell compiler warning */
389 1.8 mrg struct uvm_object *uobj;
390 1.37 chs struct vm_anon *anon;
391 1.51 tls struct vm_page *swpps[round_page(MAXPHYS) >> PAGE_SHIFT];
392 1.37 chs struct simplelock *slock;
393 1.37 chs int swnpages, swcpages;
394 1.14 chs int swslot;
395 1.37 chs int dirtyreacts, t, result;
396 1.43 chs boolean_t anonunder, fileunder, execunder;
397 1.43 chs boolean_t anonover, fileover, execover;
398 1.43 chs boolean_t anonreact, filereact, execreact;
399 1.8 mrg UVMHIST_FUNC("uvmpd_scan_inactive"); UVMHIST_CALLED(pdhist);
400 1.1 mrg
401 1.8 mrg /*
402 1.8 mrg * swslot is non-zero if we are building a swap cluster. we want
403 1.24 chs * to stay in the loop while we have a page to scan or we have
404 1.8 mrg * a swap-cluster to build.
405 1.8 mrg */
406 1.24 chs
407 1.8 mrg swslot = 0;
408 1.8 mrg swnpages = swcpages = 0;
409 1.14 chs dirtyreacts = 0;
410 1.43 chs
411 1.43 chs /*
412 1.43 chs * decide which types of pages we want to reactivate instead of freeing
413 1.43 chs * to keep usage within the minimum and maximum usage limits.
414 1.43 chs */
415 1.43 chs
416 1.43 chs t = uvmexp.active + uvmexp.inactive + uvmexp.free;
417 1.43 chs anonunder = (uvmexp.anonpages <= (t * uvmexp.anonmin) >> 8);
418 1.43 chs fileunder = (uvmexp.filepages <= (t * uvmexp.filemin) >> 8);
419 1.43 chs execunder = (uvmexp.execpages <= (t * uvmexp.execmin) >> 8);
420 1.43 chs anonover = uvmexp.anonpages > ((t * uvmexp.anonmax) >> 8);
421 1.43 chs fileover = uvmexp.filepages > ((t * uvmexp.filemax) >> 8);
422 1.43 chs execover = uvmexp.execpages > ((t * uvmexp.execmax) >> 8);
423 1.43 chs anonreact = anonunder || (!anonover && (fileover || execover));
424 1.43 chs filereact = fileunder || (!fileover && (anonover || execover));
425 1.43 chs execreact = execunder || (!execover && (anonover || fileover));
426 1.62 yamt if (filereact && execreact && (anonreact || uvm_swapisfull())) {
427 1.62 yamt anonreact = filereact = execreact = FALSE;
428 1.62 yamt }
429 1.24 chs for (p = TAILQ_FIRST(pglst); p != NULL || swslot != 0; p = nextpg) {
430 1.24 chs uobj = NULL;
431 1.24 chs anon = NULL;
432 1.8 mrg if (p) {
433 1.24 chs
434 1.8 mrg /*
435 1.37 chs * see if we've met the free target.
436 1.8 mrg */
437 1.24 chs
438 1.37 chs if (uvmexp.free + uvmexp.paging >=
439 1.37 chs uvmexp.freetarg << 2 ||
440 1.30 chs dirtyreacts == UVMPD_NUMDIRTYREACTS) {
441 1.30 chs UVMHIST_LOG(pdhist," met free target: "
442 1.30 chs "exit loop", 0, 0, 0, 0);
443 1.24 chs
444 1.30 chs if (swslot == 0) {
445 1.30 chs /* exit now if no swap-i/o pending */
446 1.30 chs break;
447 1.24 chs }
448 1.30 chs
449 1.30 chs /* set p to null to signal final swap i/o */
450 1.30 chs p = NULL;
451 1.37 chs nextpg = NULL;
452 1.8 mrg }
453 1.8 mrg }
454 1.24 chs if (p) { /* if (we have a new page to consider) */
455 1.30 chs
456 1.8 mrg /*
457 1.8 mrg * we are below target and have a new page to consider.
458 1.8 mrg */
459 1.37 chs
460 1.8 mrg uvmexp.pdscans++;
461 1.24 chs nextpg = TAILQ_NEXT(p, pageq);
462 1.8 mrg
463 1.27 mycroft /*
464 1.27 mycroft * move referenced pages back to active queue and
465 1.30 chs * skip to next page.
466 1.27 mycroft */
467 1.30 chs
468 1.37 chs if (pmap_clear_reference(p)) {
469 1.27 mycroft uvm_pageactivate(p);
470 1.27 mycroft uvmexp.pdreact++;
471 1.27 mycroft continue;
472 1.27 mycroft }
473 1.37 chs anon = p->uanon;
474 1.37 chs uobj = p->uobject;
475 1.30 chs
476 1.30 chs /*
477 1.30 chs * enforce the minimum thresholds on different
478 1.30 chs * types of memory usage. if reusing the current
479 1.30 chs * page would reduce that type of usage below its
480 1.30 chs * minimum, reactivate the page instead and move
481 1.30 chs * on to the next page.
482 1.30 chs */
483 1.30 chs
484 1.43 chs if (uobj && UVM_OBJ_IS_VTEXT(uobj) && execreact) {
485 1.30 chs uvm_pageactivate(p);
486 1.43 chs uvmexp.pdreexec++;
487 1.30 chs continue;
488 1.30 chs }
489 1.37 chs if (uobj && UVM_OBJ_IS_VNODE(uobj) &&
490 1.43 chs !UVM_OBJ_IS_VTEXT(uobj) && filereact) {
491 1.30 chs uvm_pageactivate(p);
492 1.43 chs uvmexp.pdrefile++;
493 1.30 chs continue;
494 1.30 chs }
495 1.47 chs if ((anon || UVM_OBJ_IS_AOBJ(uobj)) && anonreact) {
496 1.44 chs uvm_pageactivate(p);
497 1.44 chs uvmexp.pdreanon++;
498 1.44 chs continue;
499 1.44 chs }
500 1.30 chs
501 1.8 mrg /*
502 1.8 mrg * first we attempt to lock the object that this page
503 1.8 mrg * belongs to. if our attempt fails we skip on to
504 1.8 mrg * the next page (no harm done). it is important to
505 1.8 mrg * "try" locking the object as we are locking in the
506 1.8 mrg * wrong order (pageq -> object) and we don't want to
507 1.24 chs * deadlock.
508 1.8 mrg *
509 1.24 chs * the only time we expect to see an ownerless page
510 1.8 mrg * (i.e. a page with no uobject and !PQ_ANON) is if an
511 1.8 mrg * anon has loaned a page from a uvm_object and the
512 1.8 mrg * uvm_object has dropped the ownership. in that
513 1.8 mrg * case, the anon can "take over" the loaned page
514 1.8 mrg * and make it its own.
515 1.8 mrg */
516 1.30 chs
517 1.44 chs /* does the page belong to an object? */
518 1.44 chs if (uobj != NULL) {
519 1.44 chs slock = &uobj->vmobjlock;
520 1.44 chs if (!simple_lock_try(slock)) {
521 1.44 chs continue;
522 1.44 chs }
523 1.44 chs if (p->flags & PG_BUSY) {
524 1.44 chs simple_unlock(slock);
525 1.44 chs uvmexp.pdbusy++;
526 1.44 chs continue;
527 1.44 chs }
528 1.44 chs uvmexp.pdobscan++;
529 1.44 chs } else {
530 1.24 chs KASSERT(anon != NULL);
531 1.37 chs slock = &anon->an_lock;
532 1.37 chs if (!simple_lock_try(slock)) {
533 1.8 mrg continue;
534 1.30 chs }
535 1.8 mrg
536 1.8 mrg /*
537 1.44 chs * set PQ_ANON if it isn't set already.
538 1.8 mrg */
539 1.24 chs
540 1.8 mrg if ((p->pqflags & PQ_ANON) == 0) {
541 1.24 chs KASSERT(p->loan_count > 0);
542 1.8 mrg p->loan_count--;
543 1.24 chs p->pqflags |= PQ_ANON;
544 1.24 chs /* anon now owns it */
545 1.8 mrg }
546 1.8 mrg if (p->flags & PG_BUSY) {
547 1.37 chs simple_unlock(slock);
548 1.8 mrg uvmexp.pdbusy++;
549 1.8 mrg continue;
550 1.8 mrg }
551 1.8 mrg uvmexp.pdanscan++;
552 1.8 mrg }
553 1.8 mrg
554 1.37 chs
555 1.8 mrg /*
556 1.8 mrg * we now have the object and the page queues locked.
557 1.37 chs * if the page is not swap-backed, call the object's
558 1.37 chs * pager to flush and free the page.
559 1.37 chs */
560 1.37 chs
561 1.37 chs if ((p->pqflags & PQ_SWAPBACKED) == 0) {
562 1.37 chs uvm_unlock_pageq();
563 1.50 simonb (void) (uobj->pgops->pgo_put)(uobj, p->offset,
564 1.37 chs p->offset + PAGE_SIZE,
565 1.37 chs PGO_CLEANIT|PGO_FREE);
566 1.37 chs uvm_lock_pageq();
567 1.37 chs if (nextpg &&
568 1.46 chs (nextpg->pqflags & PQ_INACTIVE) == 0) {
569 1.37 chs nextpg = TAILQ_FIRST(pglst);
570 1.37 chs }
571 1.37 chs continue;
572 1.37 chs }
573 1.37 chs
574 1.37 chs /*
575 1.37 chs * the page is swap-backed. remove all the permissions
576 1.29 thorpej * from the page so we can sync the modified info
577 1.29 thorpej * without any race conditions. if the page is clean
578 1.29 thorpej * we can free it now and continue.
579 1.8 mrg */
580 1.8 mrg
581 1.29 thorpej pmap_page_protect(p, VM_PROT_NONE);
582 1.37 chs if ((p->flags & PG_CLEAN) && pmap_clear_modify(p)) {
583 1.37 chs p->flags &= ~(PG_CLEAN);
584 1.30 chs }
585 1.8 mrg if (p->flags & PG_CLEAN) {
586 1.53 pk int slot;
587 1.55 chs int pageidx;
588 1.55 chs
589 1.55 chs pageidx = p->offset >> PAGE_SHIFT;
590 1.8 mrg uvm_pagefree(p);
591 1.8 mrg uvmexp.pdfreed++;
592 1.24 chs
593 1.37 chs /*
594 1.37 chs * for anons, we need to remove the page
595 1.37 chs * from the anon ourselves. for aobjs,
596 1.37 chs * pagefree did that for us.
597 1.37 chs */
598 1.37 chs
599 1.8 mrg if (anon) {
600 1.24 chs KASSERT(anon->an_swslot != 0);
601 1.8 mrg anon->u.an_page = NULL;
602 1.53 pk slot = anon->an_swslot;
603 1.53 pk } else {
604 1.55 chs slot = uao_find_swslot(uobj, pageidx);
605 1.8 mrg }
606 1.37 chs simple_unlock(slock);
607 1.41 chs
608 1.53 pk if (slot > 0) {
609 1.53 pk /* this page is now only in swap. */
610 1.53 pk simple_lock(&uvm.swap_data_lock);
611 1.53 pk KASSERT(uvmexp.swpgonly <
612 1.53 pk uvmexp.swpginuse);
613 1.53 pk uvmexp.swpgonly++;
614 1.53 pk simple_unlock(&uvm.swap_data_lock);
615 1.53 pk }
616 1.8 mrg continue;
617 1.8 mrg }
618 1.8 mrg
619 1.8 mrg /*
620 1.8 mrg * this page is dirty, skip it if we'll have met our
621 1.8 mrg * free target when all the current pageouts complete.
622 1.8 mrg */
623 1.24 chs
624 1.37 chs if (uvmexp.free + uvmexp.paging >
625 1.37 chs uvmexp.freetarg << 2) {
626 1.37 chs simple_unlock(slock);
627 1.8 mrg continue;
628 1.8 mrg }
629 1.8 mrg
630 1.8 mrg /*
631 1.37 chs * free any swap space allocated to the page since
632 1.37 chs * we'll have to write it again with its new data.
633 1.37 chs */
634 1.37 chs
635 1.37 chs if ((p->pqflags & PQ_ANON) && anon->an_swslot) {
636 1.37 chs uvm_swap_free(anon->an_swslot, 1);
637 1.37 chs anon->an_swslot = 0;
638 1.37 chs } else if (p->pqflags & PQ_AOBJ) {
639 1.37 chs uao_dropswap(uobj, p->offset >> PAGE_SHIFT);
640 1.37 chs }
641 1.37 chs
642 1.37 chs /*
643 1.37 chs * if all pages in swap are only in swap,
644 1.37 chs * the swap space is full and we can't page out
645 1.37 chs * any more swap-backed pages. reactivate this page
646 1.37 chs * so that we eventually cycle all pages through
647 1.37 chs * the inactive queue.
648 1.14 chs */
649 1.24 chs
650 1.52 pk if (uvm_swapisfull()) {
651 1.14 chs dirtyreacts++;
652 1.14 chs uvm_pageactivate(p);
653 1.37 chs simple_unlock(slock);
654 1.14 chs continue;
655 1.14 chs }
656 1.14 chs
657 1.14 chs /*
658 1.37 chs * start new swap pageout cluster (if necessary).
659 1.14 chs */
660 1.24 chs
661 1.37 chs if (swslot == 0) {
662 1.51 tls /* Even with strange MAXPHYS, the shift
663 1.51 tls implicitly rounds down to a page. */
664 1.51 tls swnpages = MAXPHYS >> PAGE_SHIFT;
665 1.37 chs swslot = uvm_swap_alloc(&swnpages, TRUE);
666 1.37 chs if (swslot == 0) {
667 1.37 chs simple_unlock(slock);
668 1.37 chs continue;
669 1.14 chs }
670 1.37 chs swcpages = 0;
671 1.14 chs }
672 1.14 chs
673 1.14 chs /*
674 1.37 chs * at this point, we're definitely going reuse this
675 1.37 chs * page. mark the page busy and delayed-free.
676 1.37 chs * we should remove the page from the page queues
677 1.37 chs * so we don't ever look at it again.
678 1.37 chs * adjust counters and such.
679 1.8 mrg */
680 1.30 chs
681 1.37 chs p->flags |= PG_BUSY;
682 1.8 mrg UVM_PAGE_OWN(p, "scan_inactive");
683 1.37 chs
684 1.37 chs p->flags |= PG_PAGEOUT;
685 1.37 chs uvmexp.paging++;
686 1.37 chs uvm_pagedequeue(p);
687 1.37 chs
688 1.8 mrg uvmexp.pgswapout++;
689 1.8 mrg
690 1.8 mrg /*
691 1.37 chs * add the new page to the cluster.
692 1.8 mrg */
693 1.24 chs
694 1.37 chs if (anon) {
695 1.37 chs anon->an_swslot = swslot + swcpages;
696 1.37 chs simple_unlock(slock);
697 1.37 chs } else {
698 1.37 chs result = uao_set_swslot(uobj,
699 1.37 chs p->offset >> PAGE_SHIFT, swslot + swcpages);
700 1.37 chs if (result == -1) {
701 1.37 chs p->flags &= ~(PG_BUSY|PG_PAGEOUT);
702 1.37 chs UVM_PAGE_OWN(p, NULL);
703 1.37 chs uvmexp.paging--;
704 1.37 chs uvm_pageactivate(p);
705 1.37 chs simple_unlock(slock);
706 1.37 chs continue;
707 1.8 mrg }
708 1.37 chs simple_unlock(slock);
709 1.37 chs }
710 1.37 chs swpps[swcpages] = p;
711 1.37 chs swcpages++;
712 1.8 mrg
713 1.37 chs /*
714 1.37 chs * if the cluster isn't full, look for more pages
715 1.37 chs * before starting the i/o.
716 1.37 chs */
717 1.24 chs
718 1.37 chs if (swcpages < swnpages) {
719 1.37 chs continue;
720 1.8 mrg }
721 1.8 mrg }
722 1.8 mrg
723 1.8 mrg /*
724 1.37 chs * if this is the final pageout we could have a few
725 1.37 chs * unused swap blocks. if so, free them now.
726 1.8 mrg */
727 1.24 chs
728 1.37 chs if (swcpages < swnpages) {
729 1.37 chs uvm_swap_free(swslot + swcpages, (swnpages - swcpages));
730 1.8 mrg }
731 1.8 mrg
732 1.8 mrg /*
733 1.37 chs * now start the pageout.
734 1.8 mrg */
735 1.8 mrg
736 1.37 chs uvm_unlock_pageq();
737 1.8 mrg uvmexp.pdpageouts++;
738 1.37 chs error = uvm_swap_put(swslot, swpps, swcpages, 0);
739 1.37 chs KASSERT(error == 0);
740 1.37 chs uvm_lock_pageq();
741 1.8 mrg
742 1.8 mrg /*
743 1.37 chs * zero swslot to indicate that we are
744 1.8 mrg * no longer building a swap-backed cluster.
745 1.8 mrg */
746 1.8 mrg
747 1.37 chs swslot = 0;
748 1.24 chs
749 1.8 mrg /*
750 1.31 chs * the pageout is in progress. bump counters and set up
751 1.31 chs * for the next loop.
752 1.8 mrg */
753 1.8 mrg
754 1.31 chs uvmexp.pdpending++;
755 1.37 chs if (nextpg && (nextpg->pqflags & PQ_INACTIVE) == 0) {
756 1.37 chs nextpg = TAILQ_FIRST(pglst);
757 1.8 mrg }
758 1.24 chs }
759 1.1 mrg }
760 1.1 mrg
761 1.1 mrg /*
762 1.1 mrg * uvmpd_scan: scan the page queues and attempt to meet our targets.
763 1.1 mrg *
764 1.1 mrg * => called with pageq's locked
765 1.1 mrg */
766 1.1 mrg
767 1.8 mrg void
768 1.37 chs uvmpd_scan(void)
769 1.1 mrg {
770 1.37 chs int inactive_shortage, swap_shortage, pages_freed;
771 1.8 mrg struct vm_page *p, *nextpg;
772 1.8 mrg struct uvm_object *uobj;
773 1.37 chs struct vm_anon *anon;
774 1.44 chs struct simplelock *slock;
775 1.8 mrg UVMHIST_FUNC("uvmpd_scan"); UVMHIST_CALLED(pdhist);
776 1.1 mrg
777 1.37 chs uvmexp.pdrevs++;
778 1.24 chs uobj = NULL;
779 1.37 chs anon = NULL;
780 1.1 mrg
781 1.1 mrg #ifndef __SWAP_BROKEN
782 1.39 chs
783 1.8 mrg /*
784 1.8 mrg * swap out some processes if we are below our free target.
785 1.8 mrg * we need to unlock the page queues for this.
786 1.8 mrg */
787 1.39 chs
788 1.39 chs if (uvmexp.free < uvmexp.freetarg && uvmexp.nswapdev != 0) {
789 1.8 mrg uvmexp.pdswout++;
790 1.37 chs UVMHIST_LOG(pdhist," free %d < target %d: swapout",
791 1.37 chs uvmexp.free, uvmexp.freetarg, 0, 0);
792 1.8 mrg uvm_unlock_pageq();
793 1.8 mrg uvm_swapout_threads();
794 1.8 mrg uvm_lock_pageq();
795 1.1 mrg
796 1.8 mrg }
797 1.1 mrg #endif
798 1.1 mrg
799 1.8 mrg /*
800 1.8 mrg * now we want to work on meeting our targets. first we work on our
801 1.8 mrg * free target by converting inactive pages into free pages. then
802 1.8 mrg * we work on meeting our inactive target by converting active pages
803 1.8 mrg * to inactive ones.
804 1.8 mrg */
805 1.8 mrg
806 1.8 mrg UVMHIST_LOG(pdhist, " starting 'free' loop",0,0,0,0);
807 1.8 mrg
808 1.14 chs pages_freed = uvmexp.pdfreed;
809 1.46 chs uvmpd_scan_inactive(&uvm.page_inactive);
810 1.14 chs pages_freed = uvmexp.pdfreed - pages_freed;
811 1.8 mrg
812 1.8 mrg /*
813 1.8 mrg * we have done the scan to get free pages. now we work on meeting
814 1.8 mrg * our inactive target.
815 1.8 mrg */
816 1.8 mrg
817 1.14 chs inactive_shortage = uvmexp.inactarg - uvmexp.inactive;
818 1.14 chs
819 1.14 chs /*
820 1.14 chs * detect if we're not going to be able to page anything out
821 1.14 chs * until we free some swap resources from active pages.
822 1.14 chs */
823 1.24 chs
824 1.14 chs swap_shortage = 0;
825 1.14 chs if (uvmexp.free < uvmexp.freetarg &&
826 1.52 pk uvmexp.swpginuse >= uvmexp.swpgavail &&
827 1.52 pk !uvm_swapisfull() &&
828 1.14 chs pages_freed == 0) {
829 1.14 chs swap_shortage = uvmexp.freetarg - uvmexp.free;
830 1.14 chs }
831 1.24 chs
832 1.14 chs UVMHIST_LOG(pdhist, " loop 2: inactive_shortage=%d swap_shortage=%d",
833 1.14 chs inactive_shortage, swap_shortage,0,0);
834 1.24 chs for (p = TAILQ_FIRST(&uvm.page_active);
835 1.14 chs p != NULL && (inactive_shortage > 0 || swap_shortage > 0);
836 1.14 chs p = nextpg) {
837 1.24 chs nextpg = TAILQ_NEXT(p, pageq);
838 1.37 chs if (p->flags & PG_BUSY) {
839 1.37 chs continue;
840 1.37 chs }
841 1.8 mrg
842 1.8 mrg /*
843 1.14 chs * lock the page's owner.
844 1.8 mrg */
845 1.44 chs
846 1.44 chs if (p->uobject != NULL) {
847 1.44 chs uobj = p->uobject;
848 1.44 chs slock = &uobj->vmobjlock;
849 1.44 chs if (!simple_lock_try(slock)) {
850 1.44 chs continue;
851 1.44 chs }
852 1.44 chs } else {
853 1.37 chs anon = p->uanon;
854 1.37 chs KASSERT(anon != NULL);
855 1.44 chs slock = &anon->an_lock;
856 1.44 chs if (!simple_lock_try(slock)) {
857 1.8 mrg continue;
858 1.37 chs }
859 1.1 mrg
860 1.8 mrg /* take over the page? */
861 1.8 mrg if ((p->pqflags & PQ_ANON) == 0) {
862 1.24 chs KASSERT(p->loan_count > 0);
863 1.8 mrg p->loan_count--;
864 1.8 mrg p->pqflags |= PQ_ANON;
865 1.8 mrg }
866 1.8 mrg }
867 1.24 chs
868 1.14 chs /*
869 1.14 chs * skip this page if it's busy.
870 1.14 chs */
871 1.24 chs
872 1.14 chs if ((p->flags & PG_BUSY) != 0) {
873 1.44 chs simple_unlock(slock);
874 1.14 chs continue;
875 1.14 chs }
876 1.24 chs
877 1.14 chs /*
878 1.14 chs * if there's a shortage of swap, free any swap allocated
879 1.14 chs * to this page so that other pages can be paged out.
880 1.14 chs */
881 1.24 chs
882 1.14 chs if (swap_shortage > 0) {
883 1.37 chs if ((p->pqflags & PQ_ANON) && anon->an_swslot) {
884 1.37 chs uvm_swap_free(anon->an_swslot, 1);
885 1.37 chs anon->an_swslot = 0;
886 1.14 chs p->flags &= ~PG_CLEAN;
887 1.14 chs swap_shortage--;
888 1.37 chs } else if (p->pqflags & PQ_AOBJ) {
889 1.37 chs int slot = uao_set_swslot(uobj,
890 1.14 chs p->offset >> PAGE_SHIFT, 0);
891 1.14 chs if (slot) {
892 1.14 chs uvm_swap_free(slot, 1);
893 1.14 chs p->flags &= ~PG_CLEAN;
894 1.14 chs swap_shortage--;
895 1.14 chs }
896 1.14 chs }
897 1.14 chs }
898 1.24 chs
899 1.14 chs /*
900 1.37 chs * if there's a shortage of inactive pages, deactivate.
901 1.14 chs */
902 1.24 chs
903 1.32 thorpej if (inactive_shortage > 0) {
904 1.8 mrg /* no need to check wire_count as pg is "active" */
905 1.8 mrg uvm_pagedeactivate(p);
906 1.8 mrg uvmexp.pddeact++;
907 1.14 chs inactive_shortage--;
908 1.8 mrg }
909 1.37 chs
910 1.37 chs /*
911 1.37 chs * we're done with this page.
912 1.37 chs */
913 1.37 chs
914 1.44 chs simple_unlock(slock);
915 1.8 mrg }
916 1.1 mrg }
917 1.62 yamt
918 1.62 yamt /*
919 1.62 yamt * uvm_reclaimable: decide whether to wait for pagedaemon.
920 1.62 yamt *
921 1.62 yamt * => return TRUE if it seems to be worth to do uvm_wait.
922 1.62 yamt *
923 1.62 yamt * XXX should be tunable.
924 1.62 yamt * XXX should consider pools, etc?
925 1.62 yamt */
926 1.62 yamt
927 1.62 yamt boolean_t
928 1.62 yamt uvm_reclaimable(void)
929 1.62 yamt {
930 1.62 yamt int filepages;
931 1.62 yamt
932 1.62 yamt /*
933 1.62 yamt * if swap is not full, no problem.
934 1.62 yamt */
935 1.62 yamt
936 1.62 yamt if (!uvm_swapisfull()) {
937 1.62 yamt return TRUE;
938 1.62 yamt }
939 1.62 yamt
940 1.62 yamt /*
941 1.62 yamt * file-backed pages can be reclaimed even when swap is full.
942 1.62 yamt * if we have more than 1/16 of pageable memory or 5MB, try to reclaim.
943 1.62 yamt *
944 1.62 yamt * XXX assume the worst case, ie. all wired pages are file-backed.
945 1.62 yamt */
946 1.62 yamt
947 1.62 yamt filepages = uvmexp.filepages + uvmexp.execpages - uvmexp.wired;
948 1.62 yamt if (filepages >= MIN((uvmexp.active + uvmexp.inactive) >> 4,
949 1.62 yamt 5 * 1024 * 1024 >> PAGE_SHIFT)) {
950 1.62 yamt return TRUE;
951 1.62 yamt }
952 1.62 yamt
953 1.62 yamt /*
954 1.62 yamt * kill the process, fail allocation, etc..
955 1.62 yamt */
956 1.62 yamt
957 1.62 yamt return FALSE;
958 1.62 yamt }
959