1 /* $OpenBSD: uvm_aobj.c,v 1.31 2006/07/31 11:51:29 mickey Exp $ */
2 /* $NetBSD: uvm_aobj.c,v 1.39 2001/02/18 21:19:08 chs Exp $ */
3
4 /*
5 * Copyright (c) 1998 Chuck Silvers, Charles D. Cranor and
6 * Washington University.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. All advertising materials mentioning features or use of this software
18 * must display the following acknowledgement:
19 * This product includes software developed by Charles D. Cranor and
20 * Washington University.
21 * 4. The name of the author may not be used to endorse or promote products
22 * derived from this software without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
25 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
26 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
27 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
28 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
29 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
33 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 *
35 * from: Id: uvm_aobj.c,v 1.1.2.5 1998/02/06 05:14:38 chs Exp
36 */
37 /*
38 * uvm_aobj.c: anonymous memory uvm_object pager
39 *
40 * author: Chuck Silvers <chuq@chuq.com>
41 * started: Jan-1998
42 *
43 * - design mostly from Chuck Cranor
44 */
45
46 #include <sys/param.h>
47 #include <sys/systm.h>
48 #include <sys/proc.h>
49 #include <sys/malloc.h>
50 #include <sys/kernel.h>
51 #include <sys/pool.h>
52 #include <sys/kernel.h>
53
54 #include <uvm/uvm.h>
55
56 /*
57 * an aobj manages anonymous-memory backed uvm_objects. in addition
58 * to keeping the list of resident pages, it also keeps a list of
59 * allocated swap blocks. depending on the size of the aobj this list
60 * of allocated swap blocks is either stored in an array (small objects)
61 * or in a hash table (large objects).
62 */
63
64 /*
65 * local structures
66 */
67
68 /*
69 * for hash tables, we break the address space of the aobj into blocks
70 * of UAO_SWHASH_CLUSTER_SIZE pages. we require the cluster size to
71 * be a power of two.
72 */
73
74 #define UAO_SWHASH_CLUSTER_SHIFT 4
75 #define UAO_SWHASH_CLUSTER_SIZE (1 << UAO_SWHASH_CLUSTER_SHIFT)
76
77 /* get the "tag" for this page index */
78 #define UAO_SWHASH_ELT_TAG(PAGEIDX) \
79 ((PAGEIDX) >> UAO_SWHASH_CLUSTER_SHIFT)
80
81 /* given an ELT and a page index, find the swap slot */
82 #define UAO_SWHASH_ELT_PAGESLOT(ELT, PAGEIDX) \
83 ((ELT)->slots[(PAGEIDX) & (UAO_SWHASH_CLUSTER_SIZE - 1)])
84
85 /* given an ELT, return its pageidx base */
86 #define UAO_SWHASH_ELT_PAGEIDX_BASE(ELT) \
87 ((ELT)->tag << UAO_SWHASH_CLUSTER_SHIFT)
88
89 /*
90 * the swhash hash function
91 */
92 #define UAO_SWHASH_HASH(AOBJ, PAGEIDX) \
93 (&(AOBJ)->u_swhash[(((PAGEIDX) >> UAO_SWHASH_CLUSTER_SHIFT) \
94 & (AOBJ)->u_swhashmask)])
95
96 /*
97 * the swhash threshold determines if we will use an array or a
98 * hash table to store the list of allocated swap blocks.
99 */
100
101 #define UAO_SWHASH_THRESHOLD (UAO_SWHASH_CLUSTER_SIZE * 4)
102 #define UAO_USES_SWHASH(AOBJ) \
103 ((AOBJ)->u_pages > UAO_SWHASH_THRESHOLD) /* use hash? */
104
105 /*
106 * the number of buckets in a swhash, with an upper bound
107 */
108 #define UAO_SWHASH_MAXBUCKETS 256
109 #define UAO_SWHASH_BUCKETS(AOBJ) \
110 (min((AOBJ)->u_pages >> UAO_SWHASH_CLUSTER_SHIFT, \
111 UAO_SWHASH_MAXBUCKETS))
112
113
114 /*
115 * uao_swhash_elt: when a hash table is being used, this structure defines
116 * the format of an entry in the bucket list.
117 */
118
119 struct uao_swhash_elt {
120 LIST_ENTRY(uao_swhash_elt) list; /* the hash list */
121 voff_t tag; /* our 'tag' */
122 int count; /* our number of active slots */
123 int slots[UAO_SWHASH_CLUSTER_SIZE]; /* the slots */
124 };
125
126 /*
127 * uao_swhash: the swap hash table structure
128 */
129
130 LIST_HEAD(uao_swhash, uao_swhash_elt);
131
132 /*
133 * uao_swhash_elt_pool: pool of uao_swhash_elt structures
134 */
135
136 struct pool uao_swhash_elt_pool;
137
138 /*
139 * uvm_aobj: the actual anon-backed uvm_object
140 *
141 * => the uvm_object is at the top of the structure, this allows
142 * (struct uvm_device *) == (struct uvm_object *)
143 * => only one of u_swslots and u_swhash is used in any given aobj
144 */
145
146 struct uvm_aobj {
147 struct uvm_object u_obj; /* has: lock, pgops, memq, #pages, #refs */
148 int u_pages; /* number of pages in entire object */
149 int u_flags; /* the flags (see uvm_aobj.h) */
150 int *u_swslots; /* array of offset->swapslot mappings */
151 /*
152 * hashtable of offset->swapslot mappings
153 * (u_swhash is an array of bucket heads)
154 */
155 struct uao_swhash *u_swhash;
156 u_long u_swhashmask; /* mask for hashtable */
157 LIST_ENTRY(uvm_aobj) u_list; /* global list of aobjs */
158 };
159
160 /*
161 * uvm_aobj_pool: pool of uvm_aobj structures
162 */
163
164 struct pool uvm_aobj_pool;
165
166 /*
167 * local functions
168 */
169
170 static struct uao_swhash_elt *uao_find_swhash_elt(struct uvm_aobj *,
171 int, boolean_t);
172 static int uao_find_swslot(struct uvm_aobj *, int);
173 static boolean_t uao_flush(struct uvm_object *,
174 voff_t, voff_t, int);
175 static void uao_free(struct uvm_aobj *);
176 static int uao_get(struct uvm_object *, voff_t,
177 vm_page_t *, int *, int,
178 vm_prot_t, int, int);
179 static boolean_t uao_releasepg(struct vm_page *,
180 struct vm_page **);
181 static boolean_t uao_pagein(struct uvm_aobj *, int, int);
182 static boolean_t uao_pagein_page(struct uvm_aobj *, int);
183
184 /*
185 * aobj_pager
186 *
187 * note that some functions (e.g. put) are handled elsewhere
188 */
189
190 struct uvm_pagerops aobj_pager = {
191 NULL, /* init */
192 uao_reference, /* reference */
193 uao_detach, /* detach */
194 NULL, /* fault */
195 uao_flush, /* flush */
196 uao_get, /* get */
197 NULL, /* put (done by pagedaemon) */
198 NULL, /* cluster */
199 NULL, /* mk_pcluster */
200 uao_releasepg /* releasepg */
201 };
202
203 /*
204 * uao_list: global list of active aobjs, locked by uao_list_lock
205 */
206
207 static LIST_HEAD(aobjlist, uvm_aobj) uao_list;
208 static simple_lock_data_t uao_list_lock;
209
210
211 /*
212 * functions
213 */
214
215 /*
216 * hash table/array related functions
217 */
218
219 /*
220 * uao_find_swhash_elt: find (or create) a hash table entry for a page
221 * offset.
222 *
223 * => the object should be locked by the caller
224 */
225
226 static struct uao_swhash_elt *
uao_find_swhash_elt(aobj,pageidx,create)227 uao_find_swhash_elt(aobj, pageidx, create)
228 struct uvm_aobj *aobj;
229 int pageidx;
230 boolean_t create;
231 {
232 struct uao_swhash *swhash;
233 struct uao_swhash_elt *elt;
234 voff_t page_tag;
235
236 swhash = UAO_SWHASH_HASH(aobj, pageidx); /* first hash to get bucket */
237 page_tag = UAO_SWHASH_ELT_TAG(pageidx); /* tag to search for */
238
239 /*
240 * now search the bucket for the requested tag
241 */
242 LIST_FOREACH(elt, swhash, list) {
243 if (elt->tag == page_tag)
244 return(elt);
245 }
246
247 /* fail now if we are not allowed to create a new entry in the bucket */
248 if (!create)
249 return NULL;
250
251
252 /*
253 * allocate a new entry for the bucket and init/insert it in
254 */
255 elt = pool_get(&uao_swhash_elt_pool, PR_WAITOK);
256 LIST_INSERT_HEAD(swhash, elt, list);
257 elt->tag = page_tag;
258 elt->count = 0;
259 memset(elt->slots, 0, sizeof(elt->slots));
260
261 return(elt);
262 }
263
264 /*
265 * uao_find_swslot: find the swap slot number for an aobj/pageidx
266 *
267 * => object must be locked by caller
268 */
269 __inline static int
uao_find_swslot(aobj,pageidx)270 uao_find_swslot(aobj, pageidx)
271 struct uvm_aobj *aobj;
272 int pageidx;
273 {
274
275 /*
276 * if noswap flag is set, then we never return a slot
277 */
278
279 if (aobj->u_flags & UAO_FLAG_NOSWAP)
280 return(0);
281
282 /*
283 * if hashing, look in hash table.
284 */
285
286 if (UAO_USES_SWHASH(aobj)) {
287 struct uao_swhash_elt *elt =
288 uao_find_swhash_elt(aobj, pageidx, FALSE);
289
290 if (elt)
291 return(UAO_SWHASH_ELT_PAGESLOT(elt, pageidx));
292 else
293 return(0);
294 }
295
296 /*
297 * otherwise, look in the array
298 */
299 return(aobj->u_swslots[pageidx]);
300 }
301
302 /*
303 * uao_set_swslot: set the swap slot for a page in an aobj.
304 *
305 * => setting a slot to zero frees the slot
306 * => object must be locked by caller
307 */
308 int
uao_set_swslot(uobj,pageidx,slot)309 uao_set_swslot(uobj, pageidx, slot)
310 struct uvm_object *uobj;
311 int pageidx, slot;
312 {
313 struct uvm_aobj *aobj = (struct uvm_aobj *)uobj;
314 int oldslot;
315 UVMHIST_FUNC("uao_set_swslot"); UVMHIST_CALLED(pdhist);
316 UVMHIST_LOG(pdhist, "aobj %p pageidx %ld slot %ld",
317 aobj, pageidx, slot, 0);
318
319 /*
320 * if noswap flag is set, then we can't set a slot
321 */
322
323 if (aobj->u_flags & UAO_FLAG_NOSWAP) {
324
325 if (slot == 0)
326 return(0); /* a clear is ok */
327
328 /* but a set is not */
329 printf("uao_set_swslot: uobj = %p\n", uobj);
330 panic("uao_set_swslot: attempt to set a slot on a NOSWAP object");
331 }
332
333 /*
334 * are we using a hash table? if so, add it in the hash.
335 */
336
337 if (UAO_USES_SWHASH(aobj)) {
338
339 /*
340 * Avoid allocating an entry just to free it again if
341 * the page had not swap slot in the first place, and
342 * we are freeing.
343 */
344
345 struct uao_swhash_elt *elt =
346 uao_find_swhash_elt(aobj, pageidx, slot ? TRUE : FALSE);
347 if (elt == NULL) {
348 KASSERT(slot == 0);
349 return (0);
350 }
351
352 oldslot = UAO_SWHASH_ELT_PAGESLOT(elt, pageidx);
353 UAO_SWHASH_ELT_PAGESLOT(elt, pageidx) = slot;
354
355 /*
356 * now adjust the elt's reference counter and free it if we've
357 * dropped it to zero.
358 */
359
360 /* an allocation? */
361 if (slot) {
362 if (oldslot == 0)
363 elt->count++;
364 } else { /* freeing slot ... */
365 if (oldslot) /* to be safe */
366 elt->count--;
367
368 if (elt->count == 0) {
369 LIST_REMOVE(elt, list);
370 pool_put(&uao_swhash_elt_pool, elt);
371 }
372 }
373 } else {
374 /* we are using an array */
375 oldslot = aobj->u_swslots[pageidx];
376 aobj->u_swslots[pageidx] = slot;
377 }
378 return (oldslot);
379 }
380
381 /*
382 * end of hash/array functions
383 */
384
385 /*
386 * uao_free: free all resources held by an aobj, and then free the aobj
387 *
388 * => the aobj should be dead
389 */
390 static void
uao_free(aobj)391 uao_free(aobj)
392 struct uvm_aobj *aobj;
393 {
394
395 simple_unlock(&aobj->u_obj.vmobjlock);
396
397 if (UAO_USES_SWHASH(aobj)) {
398 int i, hashbuckets = aobj->u_swhashmask + 1;
399
400 /*
401 * free the swslots from each hash bucket,
402 * then the hash bucket, and finally the hash table itself.
403 */
404 for (i = 0; i < hashbuckets; i++) {
405 struct uao_swhash_elt *elt, *next;
406
407 for (elt = LIST_FIRST(&aobj->u_swhash[i]);
408 elt != NULL;
409 elt = next) {
410 int j;
411
412 for (j = 0; j < UAO_SWHASH_CLUSTER_SIZE; j++) {
413 int slot = elt->slots[j];
414
415 if (slot == 0) {
416 continue;
417 }
418 uvm_swap_free(slot, 1);
419
420 /*
421 * this page is no longer
422 * only in swap.
423 */
424 simple_lock(&uvm.swap_data_lock);
425 uvmexp.swpgonly--;
426 simple_unlock(&uvm.swap_data_lock);
427 }
428
429 next = LIST_NEXT(elt, list);
430 pool_put(&uao_swhash_elt_pool, elt);
431 }
432 }
433 free(aobj->u_swhash, M_UVMAOBJ);
434 } else {
435 int i;
436
437 /*
438 * free the array
439 */
440
441 for (i = 0; i < aobj->u_pages; i++) {
442 int slot = aobj->u_swslots[i];
443
444 if (slot) {
445 uvm_swap_free(slot, 1);
446
447 /* this page is no longer only in swap. */
448 simple_lock(&uvm.swap_data_lock);
449 uvmexp.swpgonly--;
450 simple_unlock(&uvm.swap_data_lock);
451 }
452 }
453 free(aobj->u_swslots, M_UVMAOBJ);
454 }
455
456 /*
457 * finally free the aobj itself
458 */
459 pool_put(&uvm_aobj_pool, aobj);
460 }
461
462 /*
463 * pager functions
464 */
465
466 /*
467 * uao_create: create an aobj of the given size and return its uvm_object.
468 *
469 * => for normal use, flags are always zero
470 * => for the kernel object, the flags are:
471 * UAO_FLAG_KERNOBJ - allocate the kernel object (can only happen once)
472 * UAO_FLAG_KERNSWAP - enable swapping of kernel object (" ")
473 */
474 struct uvm_object *
uao_create(size,flags)475 uao_create(size, flags)
476 vsize_t size;
477 int flags;
478 {
479 static struct uvm_aobj kernel_object_store; /* home of kernel_object */
480 static int kobj_alloced = 0; /* not allocated yet */
481 int pages = round_page(size) >> PAGE_SHIFT;
482 struct uvm_aobj *aobj;
483
484 /*
485 * malloc a new aobj unless we are asked for the kernel object
486 */
487 if (flags & UAO_FLAG_KERNOBJ) { /* want kernel object? */
488 if (kobj_alloced)
489 panic("uao_create: kernel object already allocated");
490
491 aobj = &kernel_object_store;
492 aobj->u_pages = pages;
493 aobj->u_flags = UAO_FLAG_NOSWAP; /* no swap to start */
494 /* we are special, we never die */
495 aobj->u_obj.uo_refs = UVM_OBJ_KERN;
496 kobj_alloced = UAO_FLAG_KERNOBJ;
497 } else if (flags & UAO_FLAG_KERNSWAP) {
498 aobj = &kernel_object_store;
499 if (kobj_alloced != UAO_FLAG_KERNOBJ)
500 panic("uao_create: asked to enable swap on kernel object");
501 kobj_alloced = UAO_FLAG_KERNSWAP;
502 } else { /* normal object */
503 aobj = pool_get(&uvm_aobj_pool, PR_WAITOK);
504 aobj->u_pages = pages;
505 aobj->u_flags = 0; /* normal object */
506 aobj->u_obj.uo_refs = 1; /* start with 1 reference */
507 }
508
509 /*
510 * allocate hash/array if necessary
511 *
512 * note: in the KERNSWAP case no need to worry about locking since
513 * we are still booting we should be the only thread around.
514 */
515 if (flags == 0 || (flags & UAO_FLAG_KERNSWAP) != 0) {
516 int mflags = (flags & UAO_FLAG_KERNSWAP) != 0 ?
517 M_NOWAIT : M_WAITOK;
518
519 /* allocate hash table or array depending on object size */
520 if (UAO_USES_SWHASH(aobj)) {
521 aobj->u_swhash = hashinit(UAO_SWHASH_BUCKETS(aobj),
522 M_UVMAOBJ, mflags, &aobj->u_swhashmask);
523 if (aobj->u_swhash == NULL)
524 panic("uao_create: hashinit swhash failed");
525 } else {
526 aobj->u_swslots = malloc(pages * sizeof(int),
527 M_UVMAOBJ, mflags);
528 if (aobj->u_swslots == NULL)
529 panic("uao_create: malloc swslots failed");
530 memset(aobj->u_swslots, 0, pages * sizeof(int));
531 }
532
533 if (flags) {
534 aobj->u_flags &= ~UAO_FLAG_NOSWAP; /* clear noswap */
535 return(&aobj->u_obj);
536 /* done! */
537 }
538 }
539
540 /*
541 * init aobj fields
542 */
543 simple_lock_init(&aobj->u_obj.vmobjlock);
544 aobj->u_obj.pgops = &aobj_pager;
545 TAILQ_INIT(&aobj->u_obj.memq);
546 aobj->u_obj.uo_npages = 0;
547
548 /*
549 * now that aobj is ready, add it to the global list
550 */
551 simple_lock(&uao_list_lock);
552 LIST_INSERT_HEAD(&uao_list, aobj, u_list);
553 simple_unlock(&uao_list_lock);
554
555 /*
556 * done!
557 */
558 return(&aobj->u_obj);
559 }
560
561
562
563 /*
564 * uao_init: set up aobj pager subsystem
565 *
566 * => called at boot time from uvm_pager_init()
567 */
568 void
uao_init()569 uao_init()
570 {
571 static int uao_initialized;
572
573 if (uao_initialized)
574 return;
575 uao_initialized = TRUE;
576
577 LIST_INIT(&uao_list);
578 simple_lock_init(&uao_list_lock);
579
580 /*
581 * NOTE: Pages fror this pool must not come from a pageable
582 * kernel map!
583 */
584 pool_init(&uao_swhash_elt_pool, sizeof(struct uao_swhash_elt),
585 0, 0, 0, "uaoeltpl", &pool_allocator_nointr);
586
587 pool_init(&uvm_aobj_pool, sizeof(struct uvm_aobj), 0, 0, 0,
588 "aobjpl", &pool_allocator_nointr);
589 }
590
591 /*
592 * uao_reference: add a ref to an aobj
593 *
594 * => aobj must be unlocked
595 * => just lock it and call the locked version
596 */
597 void
uao_reference(uobj)598 uao_reference(uobj)
599 struct uvm_object *uobj;
600 {
601 simple_lock(&uobj->vmobjlock);
602 uao_reference_locked(uobj);
603 simple_unlock(&uobj->vmobjlock);
604 }
605
606 /*
607 * uao_reference_locked: add a ref to an aobj that is already locked
608 *
609 * => aobj must be locked
610 * this needs to be separate from the normal routine
611 * since sometimes we need to add a reference to an aobj when
612 * it's already locked.
613 */
614 void
uao_reference_locked(uobj)615 uao_reference_locked(uobj)
616 struct uvm_object *uobj;
617 {
618 UVMHIST_FUNC("uao_reference"); UVMHIST_CALLED(maphist);
619
620 /*
621 * kernel_object already has plenty of references, leave it alone.
622 */
623
624 if (UVM_OBJ_IS_KERN_OBJECT(uobj))
625 return;
626
627 uobj->uo_refs++; /* bump! */
628 UVMHIST_LOG(maphist, "<- done (uobj=%p, ref = %ld)",
629 uobj, uobj->uo_refs,0,0);
630 }
631
632
633 /*
634 * uao_detach: drop a reference to an aobj
635 *
636 * => aobj must be unlocked
637 * => just lock it and call the locked version
638 */
639 void
uao_detach(uobj)640 uao_detach(uobj)
641 struct uvm_object *uobj;
642 {
643 simple_lock(&uobj->vmobjlock);
644 uao_detach_locked(uobj);
645 }
646
647
648 /*
649 * uao_detach_locked: drop a reference to an aobj
650 *
651 * => aobj must be locked, and is unlocked (or freed) upon return.
652 * this needs to be separate from the normal routine
653 * since sometimes we need to detach from an aobj when
654 * it's already locked.
655 */
656 void
uao_detach_locked(uobj)657 uao_detach_locked(uobj)
658 struct uvm_object *uobj;
659 {
660 struct uvm_aobj *aobj = (struct uvm_aobj *)uobj;
661 struct vm_page *pg, *next;
662 boolean_t busybody;
663 UVMHIST_FUNC("uao_detach"); UVMHIST_CALLED(maphist);
664
665 /*
666 * detaching from kernel_object is a noop.
667 */
668 if (UVM_OBJ_IS_KERN_OBJECT(uobj)) {
669 simple_unlock(&uobj->vmobjlock);
670 return;
671 }
672
673 UVMHIST_LOG(maphist," (uobj=%p) ref=%ld", uobj,uobj->uo_refs,0,0);
674 uobj->uo_refs--; /* drop ref! */
675 if (uobj->uo_refs) { /* still more refs? */
676 simple_unlock(&uobj->vmobjlock);
677 UVMHIST_LOG(maphist, "<- done (rc>0)", 0,0,0,0);
678 return;
679 }
680
681 /*
682 * remove the aobj from the global list.
683 */
684 simple_lock(&uao_list_lock);
685 LIST_REMOVE(aobj, u_list);
686 simple_unlock(&uao_list_lock);
687
688 /*
689 * free all the pages that aren't PG_BUSY,
690 * mark for release any that are.
691 */
692 busybody = FALSE;
693 for (pg = TAILQ_FIRST(&uobj->memq); pg != NULL; pg = next) {
694 next = TAILQ_NEXT(pg, listq);
695 if (pg->flags & PG_BUSY) {
696 pg->flags |= PG_RELEASED;
697 busybody = TRUE;
698 continue;
699 }
700
701 /* zap the mappings, free the swap slot, free the page */
702 pmap_page_protect(pg, VM_PROT_NONE);
703 uao_dropswap(&aobj->u_obj, pg->offset >> PAGE_SHIFT);
704 uvm_lock_pageq();
705 uvm_pagefree(pg);
706 uvm_unlock_pageq();
707 }
708
709 /*
710 * if we found any busy pages, we're done for now.
711 * mark the aobj for death, releasepg will finish up for us.
712 */
713 if (busybody) {
714 aobj->u_flags |= UAO_FLAG_KILLME;
715 simple_unlock(&aobj->u_obj.vmobjlock);
716 return;
717 }
718
719 /*
720 * finally, free the rest.
721 */
722 uao_free(aobj);
723 }
724
725 /*
726 * uao_flush: "flush" pages out of a uvm object
727 *
728 * => object should be locked by caller. we may _unlock_ the object
729 * if (and only if) we need to clean a page (PGO_CLEANIT).
730 * XXXJRT Currently, however, we don't. In the case of cleaning
731 * XXXJRT a page, we simply just deactivate it. Should probably
732 * XXXJRT handle this better, in the future (although "flushing"
733 * XXXJRT anonymous memory isn't terribly important).
734 * => if PGO_CLEANIT is not set, then we will neither unlock the object
735 * or block.
736 * => if PGO_ALLPAGE is set, then all pages in the object are valid targets
737 * for flushing.
738 * => NOTE: we rely on the fact that the object's memq is a TAILQ and
739 * that new pages are inserted on the tail end of the list. thus,
740 * we can make a complete pass through the object in one go by starting
741 * at the head and working towards the tail (new pages are put in
742 * front of us).
743 * => NOTE: we are allowed to lock the page queues, so the caller
744 * must not be holding the lock on them [e.g. pagedaemon had
745 * better not call us with the queues locked]
746 * => we return TRUE unless we encountered some sort of I/O error
747 * XXXJRT currently never happens, as we never directly initiate
748 * XXXJRT I/O
749 *
750 * comment on "cleaning" object and PG_BUSY pages:
751 * this routine is holding the lock on the object. the only time
752 * that is can run into a PG_BUSY page that it does not own is if
753 * some other process has started I/O on the page (e.g. either
754 * a pagein or a pageout). if the PG_BUSY page is being paged
755 * in, then it can not be dirty (!PG_CLEAN) because no one has
756 * had a change to modify it yet. if the PG_BUSY page is being
757 * paged out then it means that someone else has already started
758 * cleaning the page for us (how nice!). in this case, if we
759 * have syncio specified, then after we make our pass through the
760 * object we need to wait for the other PG_BUSY pages to clear
761 * off (i.e. we need to do an iosync). also note that once a
762 * page is PG_BUSY is must stary in its object until it is un-busyed.
763 * XXXJRT We never actually do this, as we are "flushing" anonymous
764 * XXXJRT memory, which doesn't have persistent backing store.
765 *
766 * note on page traversal:
767 * we can traverse the pages in an object either by going down the
768 * linked list in "uobj->memq", or we can go over the address range
769 * by page doing hash table lookups for each address. depending
770 * on how many pages are in the object it may be cheaper to do one
771 * or the other. we set "by_list" to true if we are using memq.
772 * if the cost of a hash lookup was equal to the cost of the list
773 * traversal we could compare the number of pages in the start->stop
774 * range to the total number of pages in the object. however, it
775 * seems that a hash table lookup is more expensive than the linked
776 * list traversal, so we multiply the number of pages in the
777 * start->stop range by a penalty which we define below.
778 */
779
780 #define UAO_HASH_PENALTY 4 /* XXX: a guess */
781
782 boolean_t
uao_flush(uobj,start,stop,flags)783 uao_flush(uobj, start, stop, flags)
784 struct uvm_object *uobj;
785 voff_t start, stop;
786 int flags;
787 {
788 struct uvm_aobj *aobj = (struct uvm_aobj *) uobj;
789 struct vm_page *pp, *ppnext;
790 boolean_t retval, by_list;
791 voff_t curoff;
792 UVMHIST_FUNC("uao_flush"); UVMHIST_CALLED(maphist);
793
794 curoff = 0; /* XXX: shut up gcc */
795
796 retval = TRUE; /* default to success */
797
798 if (flags & PGO_ALLPAGES) {
799 start = 0;
800 stop = aobj->u_pages << PAGE_SHIFT;
801 by_list = TRUE; /* always go by the list */
802 } else {
803 start = trunc_page(start);
804 stop = round_page(stop);
805 if (stop > (aobj->u_pages << PAGE_SHIFT)) {
806 printf("uao_flush: strange, got an out of range "
807 "flush (fixed)\n");
808 stop = aobj->u_pages << PAGE_SHIFT;
809 }
810 by_list = (uobj->uo_npages <=
811 ((stop - start) >> PAGE_SHIFT) * UAO_HASH_PENALTY);
812 }
813
814 UVMHIST_LOG(maphist,
815 " flush start=0x%lx, stop=0x%lx, by_list=%ld, flags=0x%lx",
816 (u_long)start, (u_long)stop, by_list, flags);
817
818 /*
819 * Don't need to do any work here if we're not freeing
820 * or deactivating pages.
821 */
822 if ((flags & (PGO_DEACTIVATE|PGO_FREE)) == 0) {
823 UVMHIST_LOG(maphist,
824 "<- done (no work to do)",0,0,0,0);
825 return (retval);
826 }
827
828 /*
829 * now do it. note: we must update ppnext in the body of loop or we
830 * will get stuck. we need to use ppnext because we may free "pp"
831 * before doing the next loop.
832 */
833
834 if (by_list) {
835 pp = TAILQ_FIRST(&uobj->memq);
836 } else {
837 curoff = start;
838 pp = uvm_pagelookup(uobj, curoff);
839 }
840
841 ppnext = NULL; /* XXX: shut up gcc */
842 uvm_lock_pageq(); /* page queues locked */
843
844 /* locked: both page queues and uobj */
845 for ( ; (by_list && pp != NULL) ||
846 (!by_list && curoff < stop) ; pp = ppnext) {
847 if (by_list) {
848 ppnext = TAILQ_NEXT(pp, listq);
849
850 /* range check */
851 if (pp->offset < start || pp->offset >= stop)
852 continue;
853 } else {
854 curoff += PAGE_SIZE;
855 if (curoff < stop)
856 ppnext = uvm_pagelookup(uobj, curoff);
857
858 /* null check */
859 if (pp == NULL)
860 continue;
861 }
862
863 switch (flags & (PGO_CLEANIT|PGO_FREE|PGO_DEACTIVATE)) {
864 /*
865 * XXX In these first 3 cases, we always just
866 * XXX deactivate the page. We may want to
867 * XXX handle the different cases more specifically
868 * XXX in the future.
869 */
870 case PGO_CLEANIT|PGO_FREE:
871 case PGO_CLEANIT|PGO_DEACTIVATE:
872 case PGO_DEACTIVATE:
873 deactivate_it:
874 /* skip the page if it's loaned or wired */
875 if (pp->loan_count != 0 ||
876 pp->wire_count != 0)
877 continue;
878
879 #ifdef UBC
880 /* ...and deactivate the page. */
881 pmap_clear_reference(pp);
882 #else
883 /* zap all mappings for the page. */
884 pmap_page_protect(pp, VM_PROT_NONE);
885
886 /* ...and deactivate the page. */
887 #endif
888 uvm_pagedeactivate(pp);
889
890 continue;
891
892 case PGO_FREE:
893 /*
894 * If there are multiple references to
895 * the object, just deactivate the page.
896 */
897 if (uobj->uo_refs > 1)
898 goto deactivate_it;
899
900 /* XXX skip the page if it's loaned or wired */
901 if (pp->loan_count != 0 ||
902 pp->wire_count != 0)
903 continue;
904
905 /*
906 * mark the page as released if its busy.
907 */
908 if (pp->flags & PG_BUSY) {
909 pp->flags |= PG_RELEASED;
910 continue;
911 }
912
913 /* zap all mappings for the page. */
914 pmap_page_protect(pp, VM_PROT_NONE);
915
916 uao_dropswap(uobj, pp->offset >> PAGE_SHIFT);
917 uvm_pagefree(pp);
918
919 continue;
920
921 default:
922 panic("uao_flush: weird flags");
923 }
924 }
925
926 uvm_unlock_pageq();
927
928 UVMHIST_LOG(maphist,
929 "<- done, rv=%ld",retval,0,0,0);
930 return (retval);
931 }
932
933 /*
934 * uao_get: fetch me a page
935 *
936 * we have three cases:
937 * 1: page is resident -> just return the page.
938 * 2: page is zero-fill -> allocate a new page and zero it.
939 * 3: page is swapped out -> fetch the page from swap.
940 *
941 * cases 1 and 2 can be handled with PGO_LOCKED, case 3 cannot.
942 * so, if the "center" page hits case 3 (or any page, with PGO_ALLPAGES),
943 * then we will need to return VM_PAGER_UNLOCK.
944 *
945 * => prefer map unlocked (not required)
946 * => object must be locked! we will _unlock_ it before starting any I/O.
947 * => flags: PGO_ALLPAGES: get all of the pages
948 * PGO_LOCKED: fault data structures are locked
949 * => NOTE: offset is the offset of pps[0], _NOT_ pps[centeridx]
950 * => NOTE: caller must check for released pages!!
951 */
952 static int
uao_get(uobj,offset,pps,npagesp,centeridx,access_type,advice,flags)953 uao_get(uobj, offset, pps, npagesp, centeridx, access_type, advice, flags)
954 struct uvm_object *uobj;
955 voff_t offset;
956 struct vm_page **pps;
957 int *npagesp;
958 int centeridx, advice, flags;
959 vm_prot_t access_type;
960 {
961 struct uvm_aobj *aobj = (struct uvm_aobj *)uobj;
962 voff_t current_offset;
963 vm_page_t ptmp;
964 int lcv, gotpages, maxpages, swslot, rv, pageidx;
965 boolean_t done;
966 UVMHIST_FUNC("uao_get"); UVMHIST_CALLED(pdhist);
967
968 UVMHIST_LOG(pdhist, "aobj=%p offset=%ld, flags=%ld",
969 aobj, (u_long)offset, flags,0);
970
971 /*
972 * get number of pages
973 */
974 maxpages = *npagesp;
975
976 /*
977 * step 1: handled the case where fault data structures are locked.
978 */
979
980 if (flags & PGO_LOCKED) {
981 /*
982 * step 1a: get pages that are already resident. only do
983 * this if the data structures are locked (i.e. the first
984 * time through).
985 */
986
987 done = TRUE; /* be optimistic */
988 gotpages = 0; /* # of pages we got so far */
989
990 for (lcv = 0, current_offset = offset ; lcv < maxpages ;
991 lcv++, current_offset += PAGE_SIZE) {
992 /* do we care about this page? if not, skip it */
993 if (pps[lcv] == PGO_DONTCARE)
994 continue;
995
996 ptmp = uvm_pagelookup(uobj, current_offset);
997
998 /*
999 * if page is new, attempt to allocate the page,
1000 * zero-fill'd.
1001 */
1002 if (ptmp == NULL && uao_find_swslot(aobj,
1003 current_offset >> PAGE_SHIFT) == 0) {
1004 ptmp = uvm_pagealloc(uobj, current_offset,
1005 NULL, UVM_PGA_ZERO);
1006 if (ptmp) {
1007 /* new page */
1008 ptmp->flags &= ~(PG_BUSY|PG_FAKE);
1009 ptmp->pqflags |= PQ_AOBJ;
1010 UVM_PAGE_OWN(ptmp, NULL);
1011 }
1012 }
1013
1014 /*
1015 * to be useful must get a non-busy, non-released page
1016 */
1017 if (ptmp == NULL ||
1018 (ptmp->flags & (PG_BUSY|PG_RELEASED)) != 0) {
1019 if (lcv == centeridx ||
1020 (flags & PGO_ALLPAGES) != 0)
1021 /* need to do a wait or I/O! */
1022 done = FALSE;
1023 continue;
1024 }
1025
1026 /*
1027 * useful page: busy/lock it and plug it in our
1028 * result array
1029 */
1030 /* caller must un-busy this page */
1031 ptmp->flags |= PG_BUSY;
1032 UVM_PAGE_OWN(ptmp, "uao_get1");
1033 pps[lcv] = ptmp;
1034 gotpages++;
1035
1036 } /* "for" lcv loop */
1037
1038 /*
1039 * step 1b: now we've either done everything needed or we
1040 * to unlock and do some waiting or I/O.
1041 */
1042
1043 UVMHIST_LOG(pdhist, "<- done (done=%ld)", done, 0,0,0);
1044
1045 *npagesp = gotpages;
1046 if (done)
1047 /* bingo! */
1048 return(VM_PAGER_OK);
1049 else
1050 /* EEK! Need to unlock and I/O */
1051 return(VM_PAGER_UNLOCK);
1052 }
1053
1054 /*
1055 * step 2: get non-resident or busy pages.
1056 * object is locked. data structures are unlocked.
1057 */
1058
1059 for (lcv = 0, current_offset = offset ; lcv < maxpages ;
1060 lcv++, current_offset += PAGE_SIZE) {
1061
1062 /*
1063 * - skip over pages we've already gotten or don't want
1064 * - skip over pages we don't _have_ to get
1065 */
1066
1067 if (pps[lcv] != NULL ||
1068 (lcv != centeridx && (flags & PGO_ALLPAGES) == 0))
1069 continue;
1070
1071 pageidx = current_offset >> PAGE_SHIFT;
1072
1073 /*
1074 * we have yet to locate the current page (pps[lcv]). we
1075 * first look for a page that is already at the current offset.
1076 * if we find a page, we check to see if it is busy or
1077 * released. if that is the case, then we sleep on the page
1078 * until it is no longer busy or released and repeat the lookup.
1079 * if the page we found is neither busy nor released, then we
1080 * busy it (so we own it) and plug it into pps[lcv]. this
1081 * 'break's the following while loop and indicates we are
1082 * ready to move on to the next page in the "lcv" loop above.
1083 *
1084 * if we exit the while loop with pps[lcv] still set to NULL,
1085 * then it means that we allocated a new busy/fake/clean page
1086 * ptmp in the object and we need to do I/O to fill in the data.
1087 */
1088
1089 /* top of "pps" while loop */
1090 while (pps[lcv] == NULL) {
1091 /* look for a resident page */
1092 ptmp = uvm_pagelookup(uobj, current_offset);
1093
1094 /* not resident? allocate one now (if we can) */
1095 if (ptmp == NULL) {
1096
1097 ptmp = uvm_pagealloc(uobj, current_offset,
1098 NULL, 0);
1099
1100 /* out of RAM? */
1101 if (ptmp == NULL) {
1102 simple_unlock(&uobj->vmobjlock);
1103 UVMHIST_LOG(pdhist,
1104 "sleeping, ptmp == NULL\n",0,0,0,0);
1105 uvm_wait("uao_getpage");
1106 simple_lock(&uobj->vmobjlock);
1107 /* goto top of pps while loop */
1108 continue;
1109 }
1110
1111 /*
1112 * safe with PQ's unlocked: because we just
1113 * alloc'd the page
1114 */
1115 ptmp->pqflags |= PQ_AOBJ;
1116
1117 /*
1118 * got new page ready for I/O. break pps while
1119 * loop. pps[lcv] is still NULL.
1120 */
1121 break;
1122 }
1123
1124 /* page is there, see if we need to wait on it */
1125 if ((ptmp->flags & (PG_BUSY|PG_RELEASED)) != 0) {
1126 ptmp->flags |= PG_WANTED;
1127 UVMHIST_LOG(pdhist,
1128 "sleeping, ptmp->flags 0x%lx\n",
1129 ptmp->flags,0,0,0);
1130 UVM_UNLOCK_AND_WAIT(ptmp, &uobj->vmobjlock,
1131 FALSE, "uao_get", 0);
1132 simple_lock(&uobj->vmobjlock);
1133 continue; /* goto top of pps while loop */
1134 }
1135
1136 /*
1137 * if we get here then the page has become resident and
1138 * unbusy between steps 1 and 2. we busy it now (so we
1139 * own it) and set pps[lcv] (so that we exit the while
1140 * loop).
1141 */
1142 /* we own it, caller must un-busy */
1143 ptmp->flags |= PG_BUSY;
1144 UVM_PAGE_OWN(ptmp, "uao_get2");
1145 pps[lcv] = ptmp;
1146 }
1147
1148 /*
1149 * if we own the valid page at the correct offset, pps[lcv] will
1150 * point to it. nothing more to do except go to the next page.
1151 */
1152 if (pps[lcv])
1153 continue; /* next lcv */
1154
1155 /*
1156 * we have a "fake/busy/clean" page that we just allocated.
1157 * do the needed "i/o", either reading from swap or zeroing.
1158 */
1159 swslot = uao_find_swslot(aobj, pageidx);
1160
1161 /*
1162 * just zero the page if there's nothing in swap.
1163 */
1164 if (swslot == 0)
1165 {
1166 /*
1167 * page hasn't existed before, just zero it.
1168 */
1169 uvm_pagezero(ptmp);
1170 } else {
1171 UVMHIST_LOG(pdhist, "pagein from swslot %ld",
1172 swslot, 0,0,0);
1173
1174 /*
1175 * page in the swapped-out page.
1176 * unlock object for i/o, relock when done.
1177 */
1178 simple_unlock(&uobj->vmobjlock);
1179 rv = uvm_swap_get(ptmp, swslot, PGO_SYNCIO);
1180 simple_lock(&uobj->vmobjlock);
1181
1182 /*
1183 * I/O done. check for errors.
1184 */
1185 if (rv != VM_PAGER_OK)
1186 {
1187 UVMHIST_LOG(pdhist, "<- done (error=%ld)",
1188 rv,0,0,0);
1189 if (ptmp->flags & PG_WANTED)
1190 wakeup(ptmp);
1191
1192 /*
1193 * remove the swap slot from the aobj
1194 * and mark the aobj as having no real slot.
1195 * don't free the swap slot, thus preventing
1196 * it from being used again.
1197 */
1198 swslot = uao_set_swslot(&aobj->u_obj, pageidx,
1199 SWSLOT_BAD);
1200 uvm_swap_markbad(swslot, 1);
1201
1202 ptmp->flags &= ~(PG_WANTED|PG_BUSY);
1203 UVM_PAGE_OWN(ptmp, NULL);
1204 uvm_lock_pageq();
1205 uvm_pagefree(ptmp);
1206 uvm_unlock_pageq();
1207
1208 simple_unlock(&uobj->vmobjlock);
1209 return (rv);
1210 }
1211 }
1212
1213 /*
1214 * we got the page! clear the fake flag (indicates valid
1215 * data now in page) and plug into our result array. note
1216 * that page is still busy.
1217 *
1218 * it is the callers job to:
1219 * => check if the page is released
1220 * => unbusy the page
1221 * => activate the page
1222 */
1223
1224 ptmp->flags &= ~PG_FAKE; /* data is valid ... */
1225 pmap_clear_modify(ptmp); /* ... and clean */
1226 pps[lcv] = ptmp;
1227
1228 } /* lcv loop */
1229
1230 /*
1231 * finally, unlock object and return.
1232 */
1233
1234 simple_unlock(&uobj->vmobjlock);
1235 UVMHIST_LOG(pdhist, "<- done (OK)",0,0,0,0);
1236 return(VM_PAGER_OK);
1237 }
1238
1239 /*
1240 * uao_releasepg: handle released page in an aobj
1241 *
1242 * => "pg" is a PG_BUSY [caller owns it], PG_RELEASED page that we need
1243 * to dispose of.
1244 * => caller must handle PG_WANTED case
1245 * => called with page's object locked, pageq's unlocked
1246 * => returns TRUE if page's object is still alive, FALSE if we
1247 * killed the page's object. if we return TRUE, then we
1248 * return with the object locked.
1249 * => if (nextpgp != NULL) => we return the next page on the queue, and return
1250 * with the page queues locked [for pagedaemon]
1251 * => if (nextpgp == NULL) => we return with page queues unlocked [normal case]
1252 * => we kill the aobj if it is not referenced and we are suppose to
1253 * kill it ("KILLME").
1254 */
1255 static boolean_t
uao_releasepg(pg,nextpgp)1256 uao_releasepg(pg, nextpgp)
1257 struct vm_page *pg;
1258 struct vm_page **nextpgp; /* OUT */
1259 {
1260 struct uvm_aobj *aobj = (struct uvm_aobj *) pg->uobject;
1261
1262 KASSERT(pg->flags & PG_RELEASED);
1263
1264 /*
1265 * dispose of the page [caller handles PG_WANTED] and swap slot.
1266 */
1267 pmap_page_protect(pg, VM_PROT_NONE);
1268 uao_dropswap(&aobj->u_obj, pg->offset >> PAGE_SHIFT);
1269 uvm_lock_pageq();
1270 if (nextpgp)
1271 *nextpgp = TAILQ_NEXT(pg, pageq); /* next page for daemon */
1272 uvm_pagefree(pg);
1273 if (!nextpgp)
1274 uvm_unlock_pageq(); /* keep locked for daemon */
1275
1276 /*
1277 * if we're not killing the object, we're done.
1278 */
1279 if ((aobj->u_flags & UAO_FLAG_KILLME) == 0)
1280 return TRUE;
1281 KASSERT(aobj->u_obj.uo_refs == 0);
1282
1283 /*
1284 * if there are still pages in the object, we're done for now.
1285 */
1286 if (aobj->u_obj.uo_npages != 0)
1287 return TRUE;
1288
1289 KASSERT(TAILQ_EMPTY(&aobj->u_obj.memq));
1290
1291 /*
1292 * finally, free the rest.
1293 */
1294 uao_free(aobj);
1295
1296 return FALSE;
1297 }
1298
1299
1300 /*
1301 * uao_dropswap: release any swap resources from this aobj page.
1302 *
1303 * => aobj must be locked or have a reference count of 0.
1304 */
1305
1306 void
uao_dropswap(uobj,pageidx)1307 uao_dropswap(uobj, pageidx)
1308 struct uvm_object *uobj;
1309 int pageidx;
1310 {
1311 int slot;
1312
1313 slot = uao_set_swslot(uobj, pageidx, 0);
1314 if (slot) {
1315 uvm_swap_free(slot, 1);
1316 }
1317 }
1318
1319
1320 /*
1321 * page in every page in every aobj that is paged-out to a range of swslots.
1322 *
1323 * => nothing should be locked.
1324 * => returns TRUE if pagein was aborted due to lack of memory.
1325 */
1326 boolean_t
uao_swap_off(startslot,endslot)1327 uao_swap_off(startslot, endslot)
1328 int startslot, endslot;
1329 {
1330 struct uvm_aobj *aobj, *nextaobj;
1331
1332 /*
1333 * walk the list of all aobjs.
1334 */
1335
1336 restart:
1337 simple_lock(&uao_list_lock);
1338
1339 for (aobj = LIST_FIRST(&uao_list);
1340 aobj != NULL;
1341 aobj = nextaobj) {
1342 boolean_t rv;
1343
1344 /*
1345 * try to get the object lock,
1346 * start all over if we fail.
1347 * most of the time we'll get the aobj lock,
1348 * so this should be a rare case.
1349 */
1350 if (!simple_lock_try(&aobj->u_obj.vmobjlock)) {
1351 simple_unlock(&uao_list_lock);
1352 goto restart;
1353 }
1354
1355 /*
1356 * add a ref to the aobj so it doesn't disappear
1357 * while we're working.
1358 */
1359 uao_reference_locked(&aobj->u_obj);
1360
1361 /*
1362 * now it's safe to unlock the uao list.
1363 */
1364 simple_unlock(&uao_list_lock);
1365
1366 /*
1367 * page in any pages in the swslot range.
1368 * if there's an error, abort and return the error.
1369 */
1370 rv = uao_pagein(aobj, startslot, endslot);
1371 if (rv) {
1372 uao_detach_locked(&aobj->u_obj);
1373 return rv;
1374 }
1375
1376 /*
1377 * we're done with this aobj.
1378 * relock the list and drop our ref on the aobj.
1379 */
1380 simple_lock(&uao_list_lock);
1381 nextaobj = LIST_NEXT(aobj, u_list);
1382 uao_detach_locked(&aobj->u_obj);
1383 }
1384
1385 /*
1386 * done with traversal, unlock the list
1387 */
1388 simple_unlock(&uao_list_lock);
1389 return FALSE;
1390 }
1391
1392
1393 /*
1394 * page in any pages from aobj in the given range.
1395 *
1396 * => aobj must be locked and is returned locked.
1397 * => returns TRUE if pagein was aborted due to lack of memory.
1398 */
1399 static boolean_t
uao_pagein(aobj,startslot,endslot)1400 uao_pagein(aobj, startslot, endslot)
1401 struct uvm_aobj *aobj;
1402 int startslot, endslot;
1403 {
1404 boolean_t rv;
1405
1406 if (UAO_USES_SWHASH(aobj)) {
1407 struct uao_swhash_elt *elt;
1408 int bucket;
1409
1410 restart:
1411 for (bucket = aobj->u_swhashmask; bucket >= 0; bucket--) {
1412 for (elt = LIST_FIRST(&aobj->u_swhash[bucket]);
1413 elt != NULL;
1414 elt = LIST_NEXT(elt, list)) {
1415 int i;
1416
1417 for (i = 0; i < UAO_SWHASH_CLUSTER_SIZE; i++) {
1418 int slot = elt->slots[i];
1419
1420 /*
1421 * if the slot isn't in range, skip it.
1422 */
1423 if (slot < startslot ||
1424 slot >= endslot) {
1425 continue;
1426 }
1427
1428 /*
1429 * process the page,
1430 * the start over on this object
1431 * since the swhash elt
1432 * may have been freed.
1433 */
1434 rv = uao_pagein_page(aobj,
1435 UAO_SWHASH_ELT_PAGEIDX_BASE(elt) + i);
1436 if (rv) {
1437 return rv;
1438 }
1439 goto restart;
1440 }
1441 }
1442 }
1443 } else {
1444 int i;
1445
1446 for (i = 0; i < aobj->u_pages; i++) {
1447 int slot = aobj->u_swslots[i];
1448
1449 /*
1450 * if the slot isn't in range, skip it
1451 */
1452 if (slot < startslot || slot >= endslot) {
1453 continue;
1454 }
1455
1456 /*
1457 * process the page.
1458 */
1459 rv = uao_pagein_page(aobj, i);
1460 if (rv) {
1461 return rv;
1462 }
1463 }
1464 }
1465
1466 return FALSE;
1467 }
1468
1469 /*
1470 * page in a page from an aobj. used for swap_off.
1471 * returns TRUE if pagein was aborted due to lack of memory.
1472 *
1473 * => aobj must be locked and is returned locked.
1474 */
1475 static boolean_t
uao_pagein_page(aobj,pageidx)1476 uao_pagein_page(aobj, pageidx)
1477 struct uvm_aobj *aobj;
1478 int pageidx;
1479 {
1480 struct vm_page *pg;
1481 int rv, slot, npages;
1482
1483 pg = NULL;
1484 npages = 1;
1485 /* locked: aobj */
1486 rv = uao_get(&aobj->u_obj, pageidx << PAGE_SHIFT,
1487 &pg, &npages, 0, VM_PROT_READ|VM_PROT_WRITE, 0, 0);
1488 /* unlocked: aobj */
1489
1490 /*
1491 * relock and finish up.
1492 */
1493 simple_lock(&aobj->u_obj.vmobjlock);
1494
1495 switch (rv) {
1496 case VM_PAGER_OK:
1497 break;
1498
1499 case VM_PAGER_ERROR:
1500 case VM_PAGER_REFAULT:
1501 /*
1502 * nothing more to do on errors.
1503 * VM_PAGER_REFAULT can only mean that the anon was freed,
1504 * so again there's nothing to do.
1505 */
1506 return FALSE;
1507
1508 }
1509 KASSERT((pg->flags & PG_RELEASED) == 0);
1510
1511 /*
1512 * ok, we've got the page now.
1513 * mark it as dirty, clear its swslot and un-busy it.
1514 */
1515 slot = uao_set_swslot(&aobj->u_obj, pageidx, 0);
1516 uvm_swap_free(slot, 1);
1517 pg->flags &= ~(PG_BUSY|PG_CLEAN|PG_FAKE);
1518 UVM_PAGE_OWN(pg, NULL);
1519
1520 /*
1521 * deactivate the page (to put it on a page queue).
1522 */
1523 pmap_clear_reference(pg);
1524 #ifndef UBC
1525 pmap_page_protect(pg, VM_PROT_NONE);
1526 #endif
1527 uvm_lock_pageq();
1528 uvm_pagedeactivate(pg);
1529 uvm_unlock_pageq();
1530
1531 return FALSE;
1532 }
1533