2 * Copyright (c) 1991, 1993
3 * The Regents of the University of California. All rights reserved.
5 * This code is derived from software contributed to Berkeley by
6 * The Mach Operating System project at Carnegie-Mellon University.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by the University of
19 * California, Berkeley and its contributors.
20 * 4. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * from: @(#)vm_object.c 8.5 (Berkeley) 3/22/94
39 * Copyright (c) 1987, 1990 Carnegie-Mellon University.
40 * All rights reserved.
42 * Authors: Avadis Tevanian, Jr., Michael Wayne Young
44 * Permission to use, copy, modify and distribute this software and
45 * its documentation is hereby granted, provided that both the copyright
46 * notice and this permission notice appear in all copies of the
47 * software, derivative works or modified versions, and any portions
48 * thereof, and that both notices appear in supporting documentation.
50 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
51 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
52 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
54 * Carnegie Mellon requests users of this software to return to
56 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
57 * School of Computer Science
58 * Carnegie Mellon University
59 * Pittsburgh PA 15213-3890
61 * any improvements or extensions that they make and grant Carnegie the
62 * rights to redistribute these changes.
64 * $FreeBSD: src/sys/vm/vm_object.c,v 1.171.2.8 2003/05/26 19:17:56 alc Exp $
65 * $DragonFly: src/sys/vm/vm_object.c,v 1.25 2006/05/25 07:36:37 dillon Exp $
69 * Virtual memory object module.
72 #include <sys/param.h>
73 #include <sys/systm.h>
74 #include <sys/proc.h> /* for curproc, pageproc */
75 #include <sys/vnode.h>
76 #include <sys/vmmeter.h>
78 #include <sys/mount.h>
79 #include <sys/kernel.h>
80 #include <sys/sysctl.h>
83 #include <vm/vm_param.h>
85 #include <vm/vm_map.h>
86 #include <vm/vm_object.h>
87 #include <vm/vm_page.h>
88 #include <vm/vm_pageout.h>
89 #include <vm/vm_pager.h>
90 #include <vm/swap_pager.h>
91 #include <vm/vm_kern.h>
92 #include <vm/vm_extern.h>
93 #include <vm/vm_zone.h>
95 #define EASY_SCAN_FACTOR 8
97 #define MSYNC_FLUSH_HARDSEQ 0x01
98 #define MSYNC_FLUSH_SOFTSEQ 0x02
100 static int msync_flush_flags
= MSYNC_FLUSH_HARDSEQ
| MSYNC_FLUSH_SOFTSEQ
;
101 SYSCTL_INT(_vm
, OID_AUTO
, msync_flush_flags
,
102 CTLFLAG_RW
, &msync_flush_flags
, 0, "");
104 static void vm_object_qcollapse (vm_object_t object
);
105 static int vm_object_page_collect_flush(vm_object_t object
, vm_page_t p
, int curgeneration
, int pagerflags
);
108 * Virtual memory objects maintain the actual data
109 * associated with allocated virtual memory. A given
110 * page of memory exists within exactly one object.
112 * An object is only deallocated when all "references"
113 * are given up. Only one "reference" to a given
114 * region of an object should be writeable.
116 * Associated with each object is a list of all resident
117 * memory pages belonging to that object; this list is
118 * maintained by the "vm_page" module, and locked by the object's
121 * Each object also records a "pager" routine which is
122 * used to retrieve (and store) pages to the proper backing
123 * storage. In addition, objects may be backed by other
124 * objects from which they were virtual-copied.
126 * The only items within the object structure which are
127 * modified after time of creation are:
128 * reference count locked by object's lock
129 * pager routine locked by object's lock
133 struct object_q vm_object_list
;
134 static long vm_object_count
; /* count of all objects */
135 vm_object_t kernel_object
;
136 vm_object_t kmem_object
;
137 static struct vm_object kernel_object_store
;
138 static struct vm_object kmem_object_store
;
139 extern int vm_pageout_page_count
;
141 static long object_collapses
;
142 static long object_bypasses
;
143 static int next_index
;
144 static vm_zone_t obj_zone
;
145 static struct vm_zone obj_zone_store
;
146 static int object_hash_rand
;
147 #define VM_OBJECTS_INIT 256
148 static struct vm_object vm_objects_init
[VM_OBJECTS_INIT
];
151 _vm_object_allocate(objtype_t type
, vm_size_t size
, vm_object_t object
)
154 TAILQ_INIT(&object
->memq
);
155 LIST_INIT(&object
->shadow_head
);
159 object
->ref_count
= 1;
161 if ((object
->type
== OBJT_DEFAULT
) || (object
->type
== OBJT_SWAP
))
162 vm_object_set_flag(object
, OBJ_ONEMAPPING
);
163 object
->paging_in_progress
= 0;
164 object
->resident_page_count
= 0;
165 object
->shadow_count
= 0;
166 object
->pg_color
= next_index
;
167 if ( size
> (PQ_L2_SIZE
/ 3 + PQ_PRIME1
))
168 incr
= PQ_L2_SIZE
/ 3 + PQ_PRIME1
;
171 next_index
= (next_index
+ incr
) & PQ_L2_MASK
;
172 object
->handle
= NULL
;
173 object
->backing_object
= NULL
;
174 object
->backing_object_offset
= (vm_ooffset_t
) 0;
176 * Try to generate a number that will spread objects out in the
177 * hash table. We 'wipe' new objects across the hash in 128 page
178 * increments plus 1 more to offset it a little more by the time
181 object
->hash_rand
= object_hash_rand
- 129;
183 object
->generation
++;
186 TAILQ_INSERT_TAIL(&vm_object_list
, object
, object_list
);
188 object_hash_rand
= object
->hash_rand
;
195 * Initialize the VM objects module.
200 TAILQ_INIT(&vm_object_list
);
202 kernel_object
= &kernel_object_store
;
203 _vm_object_allocate(OBJT_DEFAULT
, OFF_TO_IDX(VM_MAX_KERNEL_ADDRESS
- VM_MIN_KERNEL_ADDRESS
),
206 kmem_object
= &kmem_object_store
;
207 _vm_object_allocate(OBJT_DEFAULT
, OFF_TO_IDX(VM_MAX_KERNEL_ADDRESS
- VM_MIN_KERNEL_ADDRESS
),
210 obj_zone
= &obj_zone_store
;
211 zbootinit(obj_zone
, "VM OBJECT", sizeof (struct vm_object
),
212 vm_objects_init
, VM_OBJECTS_INIT
);
216 vm_object_init2(void)
218 zinitna(obj_zone
, NULL
, NULL
, 0, 0, ZONE_PANICFAIL
, 1);
222 * vm_object_allocate:
224 * Returns a new object with the given size.
228 vm_object_allocate(objtype_t type
, vm_size_t size
)
232 result
= (vm_object_t
) zalloc(obj_zone
);
234 _vm_object_allocate(type
, size
, result
);
241 * vm_object_reference:
243 * Gets another reference to the given object.
246 vm_object_reference(vm_object_t object
)
252 if (object
->type
== OBJT_VNODE
) {
253 vref(object
->handle
);
254 /* XXX what if the vnode is being destroyed? */
259 vm_object_vndeallocate(vm_object_t object
)
261 struct vnode
*vp
= (struct vnode
*) object
->handle
;
263 KASSERT(object
->type
== OBJT_VNODE
,
264 ("vm_object_vndeallocate: not a vnode object"));
265 KASSERT(vp
!= NULL
, ("vm_object_vndeallocate: missing vp"));
267 if (object
->ref_count
== 0) {
268 vprint("vm_object_vndeallocate", vp
);
269 panic("vm_object_vndeallocate: bad object reference count");
274 if (object
->ref_count
== 0)
275 vp
->v_flag
&= ~VTEXT
;
280 * vm_object_deallocate:
282 * Release a reference to the specified object,
283 * gained either through a vm_object_allocate
284 * or a vm_object_reference call. When all references
285 * are gone, storage associated with this object
286 * may be relinquished.
288 * No object may be locked.
291 vm_object_deallocate(vm_object_t object
)
295 while (object
!= NULL
) {
296 if (object
->type
== OBJT_VNODE
) {
297 vm_object_vndeallocate(object
);
301 if (object
->ref_count
== 0) {
302 panic("vm_object_deallocate: object deallocated too many times: %d", object
->type
);
303 } else if (object
->ref_count
> 2) {
309 * Here on ref_count of one or two, which are special cases for
312 if ((object
->ref_count
== 2) && (object
->shadow_count
== 0)) {
313 vm_object_set_flag(object
, OBJ_ONEMAPPING
);
316 } else if ((object
->ref_count
== 2) && (object
->shadow_count
== 1)) {
318 if ((object
->handle
== NULL
) &&
319 (object
->type
== OBJT_DEFAULT
||
320 object
->type
== OBJT_SWAP
)) {
323 robject
= LIST_FIRST(&object
->shadow_head
);
324 KASSERT(robject
!= NULL
,
325 ("vm_object_deallocate: ref_count: %d, shadow_count: %d",
327 object
->shadow_count
));
328 if ((robject
->handle
== NULL
) &&
329 (robject
->type
== OBJT_DEFAULT
||
330 robject
->type
== OBJT_SWAP
)) {
332 robject
->ref_count
++;
335 robject
->paging_in_progress
||
336 object
->paging_in_progress
338 vm_object_pip_sleep(robject
, "objde1");
339 vm_object_pip_sleep(object
, "objde2");
342 if (robject
->ref_count
== 1) {
343 robject
->ref_count
--;
349 vm_object_collapse(object
);
358 if (object
->ref_count
!= 0)
364 temp
= object
->backing_object
;
366 LIST_REMOVE(object
, shadow_list
);
367 temp
->shadow_count
--;
369 object
->backing_object
= NULL
;
373 * Don't double-terminate, we could be in a termination
374 * recursion due to the terminate having to sync data
377 if ((object
->flags
& OBJ_DEAD
) == 0)
378 vm_object_terminate(object
);
384 * vm_object_terminate actually destroys the specified object, freeing
385 * up all previously used resources.
387 * The object must be locked.
388 * This routine may block.
391 vm_object_terminate(vm_object_t object
)
396 * Make sure no one uses us.
398 vm_object_set_flag(object
, OBJ_DEAD
);
401 * wait for the pageout daemon to be done with the object
403 vm_object_pip_wait(object
, "objtrm");
405 KASSERT(!object
->paging_in_progress
,
406 ("vm_object_terminate: pageout in progress"));
409 * Clean and free the pages, as appropriate. All references to the
410 * object are gone, so we don't need to lock it.
412 if (object
->type
== OBJT_VNODE
) {
416 * Clean pages and flush buffers.
418 vm_object_page_clean(object
, 0, 0, OBJPC_SYNC
);
420 vp
= (struct vnode
*) object
->handle
;
421 vinvalbuf(vp
, V_SAVE
, 0, 0);
425 * Wait for any I/O to complete, after which there had better not
426 * be any references left on the object.
428 vm_object_pip_wait(object
, "objtrm");
430 if (object
->ref_count
!= 0)
431 panic("vm_object_terminate: object with references, ref_count=%d", object
->ref_count
);
434 * Now free any remaining pages. For internal objects, this also
435 * removes them from paging queues. Don't free wired pages, just
436 * remove them from the object.
439 while ((p
= TAILQ_FIRST(&object
->memq
)) != NULL
) {
440 if (p
->busy
|| (p
->flags
& PG_BUSY
))
441 panic("vm_object_terminate: freeing busy page %p", p
);
442 if (p
->wire_count
== 0) {
445 mycpu
->gd_cnt
.v_pfree
++;
455 * Let the pager know object is dead.
457 vm_pager_deallocate(object
);
460 * Remove the object from the global object list.
463 TAILQ_REMOVE(&vm_object_list
, object
, object_list
);
468 if (object
->ref_count
!= 0)
469 panic("vm_object_terminate2: object with references, ref_count=%d", object
->ref_count
);
472 * Free the space for the object.
474 zfree(obj_zone
, object
);
478 * vm_object_page_clean
480 * Clean all dirty pages in the specified range of object. Leaves page
481 * on whatever queue it is currently on. If NOSYNC is set then do not
482 * write out pages with PG_NOSYNC set (originally comes from MAP_NOSYNC),
483 * leaving the object dirty.
485 * When stuffing pages asynchronously, allow clustering. XXX we need a
486 * synchronous clustering mode implementation.
488 * Odd semantics: if start == end, we clean everything.
492 vm_object_page_clean(vm_object_t object
, vm_pindex_t start
, vm_pindex_t end
,
496 vm_offset_t tstart
, tend
;
503 if (object
->type
!= OBJT_VNODE
||
504 (object
->flags
& OBJ_MIGHTBEDIRTY
) == 0)
507 pagerflags
= (flags
& (OBJPC_SYNC
| OBJPC_INVAL
)) ? VM_PAGER_PUT_SYNC
: VM_PAGER_CLUSTER_OK
;
508 pagerflags
|= (flags
& OBJPC_INVAL
) ? VM_PAGER_PUT_INVAL
: 0;
512 vm_object_set_flag(object
, OBJ_CLEANING
);
515 * Handle 'entire object' case
525 * If the caller is smart and only msync()s a range he knows is
526 * dirty, we may be able to avoid an object scan. This results in
527 * a phenominal improvement in performance. We cannot do this
528 * as a matter of course because the object may be huge - e.g.
529 * the size might be in the gigabytes or terrabytes.
531 if (msync_flush_flags
& MSYNC_FLUSH_HARDSEQ
) {
536 scanreset
= object
->resident_page_count
/ EASY_SCAN_FACTOR
;
539 pagerflags
|= VM_PAGER_IGNORE_CLEANCHK
;
541 scanlimit
= scanreset
;
545 * spl protection is required despite the obj generation
546 * tracking because we cannot safely call vm_page_test_dirty()
547 * or avoid page field tests against an interrupt unbusy/free
548 * race that might occur prior to the busy check in
549 * vm_object_page_collect_flush().
552 while (tscan
< tend
) {
553 curgeneration
= object
->generation
;
554 p
= vm_page_lookup(object
, tscan
);
555 if (p
== NULL
|| p
->valid
== 0 ||
556 (p
->queue
- p
->pc
) == PQ_CACHE
) {
557 if (--scanlimit
== 0)
562 vm_page_test_dirty(p
);
563 if ((p
->dirty
& p
->valid
) == 0) {
564 if (--scanlimit
== 0)
570 * If we have been asked to skip nosync pages and
571 * this is a nosync page, we can't continue.
573 if ((flags
& OBJPC_NOSYNC
) && (p
->flags
& PG_NOSYNC
)) {
574 if (--scanlimit
== 0)
579 scanlimit
= scanreset
;
582 * This returns 0 if it was unable to busy the first
583 * page (i.e. had to sleep).
585 tscan
+= vm_object_page_collect_flush(object
, p
,
586 curgeneration
, pagerflags
);
591 * If everything was dirty and we flushed it successfully,
592 * and the requested range is not the entire object, we
593 * don't have to mess with CLEANCHK or MIGHTBEDIRTY and can
594 * return immediately.
596 if (tscan
>= tend
&& (tstart
|| tend
< object
->size
)) {
597 vm_object_clear_flag(object
, OBJ_CLEANING
);
600 pagerflags
&= ~VM_PAGER_IGNORE_CLEANCHK
;
604 * Generally set CLEANCHK interlock and make the page read-only so
605 * we can then clear the object flags.
607 * However, if this is a nosync mmap then the object is likely to
608 * stay dirty so do not mess with the page and do not clear the
611 * spl protection is required because an interrupt can remove page
617 for (p
= TAILQ_FIRST(&object
->memq
); p
; p
= TAILQ_NEXT(p
, listq
)) {
618 vm_page_flag_set(p
, PG_CLEANCHK
);
619 if ((flags
& OBJPC_NOSYNC
) && (p
->flags
& PG_NOSYNC
))
622 vm_page_protect(p
, VM_PROT_READ
);
626 if (clearobjflags
&& (tstart
== 0) && (tend
== object
->size
)) {
629 vm_object_clear_flag(object
, OBJ_WRITEABLE
|OBJ_MIGHTBEDIRTY
);
630 if (object
->type
== OBJT_VNODE
&&
631 (vp
= (struct vnode
*)object
->handle
) != NULL
) {
632 if (vp
->v_flag
& VOBJDIRTY
)
633 vclrflags(vp
, VOBJDIRTY
);
638 * spl protection is required both to avoid an interrupt unbusy/free
639 * race against a vm_page_lookup(), and also to ensure that the
640 * memq is consistent. We do not want a busy page to be ripped out
647 curgeneration
= object
->generation
;
649 for (p
= TAILQ_FIRST(&object
->memq
); p
; p
= np
) {
652 np
= TAILQ_NEXT(p
, listq
);
656 if (((p
->flags
& PG_CLEANCHK
) == 0) ||
657 (pi
< tstart
) || (pi
>= tend
) ||
659 ((p
->queue
- p
->pc
) == PQ_CACHE
)) {
660 vm_page_flag_clear(p
, PG_CLEANCHK
);
664 vm_page_test_dirty(p
);
665 if ((p
->dirty
& p
->valid
) == 0) {
666 vm_page_flag_clear(p
, PG_CLEANCHK
);
671 * If we have been asked to skip nosync pages and this is a
672 * nosync page, skip it. Note that the object flags were
673 * not cleared in this case so we do not have to set them.
675 if ((flags
& OBJPC_NOSYNC
) && (p
->flags
& PG_NOSYNC
)) {
676 vm_page_flag_clear(p
, PG_CLEANCHK
);
680 n
= vm_object_page_collect_flush(object
, p
,
681 curgeneration
, pagerflags
);
684 if (object
->generation
!= curgeneration
)
688 * Try to optimize the next page. If we can't we pick up
689 * our (random) scan where we left off.
691 if (msync_flush_flags
& MSYNC_FLUSH_SOFTSEQ
) {
692 if ((p
= vm_page_lookup(object
, pi
+ n
)) != NULL
)
698 vm_object_clear_flag(object
, OBJ_CLEANING
);
703 * This routine must be called within a critical section to properly avoid
704 * an interrupt unbusy/free race that can occur prior to the busy check.
706 * Using the object generation number here to detect page ripout is not
707 * the best idea in the world. XXX
709 * NOTE: we operate under the assumption that a page found to not be busy
710 * will not be ripped out from under us by an interrupt. XXX we should
711 * recode this to explicitly busy the pages.
714 vm_object_page_collect_flush(vm_object_t object
, vm_page_t p
, int curgeneration
, int pagerflags
)
722 vm_page_t maf
[vm_pageout_page_count
];
723 vm_page_t mab
[vm_pageout_page_count
];
724 vm_page_t ma
[vm_pageout_page_count
];
727 while (vm_page_sleep_busy(p
, TRUE
, "vpcwai")) {
728 if (object
->generation
!= curgeneration
) {
734 for(i
= 1; i
< vm_pageout_page_count
; i
++) {
737 if ((tp
= vm_page_lookup(object
, pi
+ i
)) != NULL
) {
738 if ((tp
->flags
& PG_BUSY
) ||
739 ((pagerflags
& VM_PAGER_IGNORE_CLEANCHK
) == 0 &&
740 (tp
->flags
& PG_CLEANCHK
) == 0) ||
743 if((tp
->queue
- tp
->pc
) == PQ_CACHE
) {
744 vm_page_flag_clear(tp
, PG_CLEANCHK
);
747 vm_page_test_dirty(tp
);
748 if ((tp
->dirty
& tp
->valid
) == 0) {
749 vm_page_flag_clear(tp
, PG_CLEANCHK
);
760 chkb
= vm_pageout_page_count
- maxf
;
762 for(i
= 1; i
< chkb
;i
++) {
765 if ((tp
= vm_page_lookup(object
, pi
- i
)) != NULL
) {
766 if ((tp
->flags
& PG_BUSY
) ||
767 ((pagerflags
& VM_PAGER_IGNORE_CLEANCHK
) == 0 &&
768 (tp
->flags
& PG_CLEANCHK
) == 0) ||
771 if((tp
->queue
- tp
->pc
) == PQ_CACHE
) {
772 vm_page_flag_clear(tp
, PG_CLEANCHK
);
775 vm_page_test_dirty(tp
);
776 if ((tp
->dirty
& tp
->valid
) == 0) {
777 vm_page_flag_clear(tp
, PG_CLEANCHK
);
788 for(i
= 0; i
< maxb
; i
++) {
789 int index
= (maxb
- i
) - 1;
791 vm_page_flag_clear(ma
[index
], PG_CLEANCHK
);
793 vm_page_flag_clear(p
, PG_CLEANCHK
);
795 for(i
= 0; i
< maxf
; i
++) {
796 int index
= (maxb
+ i
) + 1;
798 vm_page_flag_clear(ma
[index
], PG_CLEANCHK
);
800 runlen
= maxb
+ maxf
+ 1;
802 vm_pageout_flush(ma
, runlen
, pagerflags
);
803 for (i
= 0; i
< runlen
; i
++) {
804 if (ma
[i
]->valid
& ma
[i
]->dirty
) {
805 vm_page_protect(ma
[i
], VM_PROT_READ
);
806 vm_page_flag_set(ma
[i
], PG_CLEANCHK
);
809 * maxf will end up being the actual number of pages
810 * we wrote out contiguously, non-inclusive of the
811 * first page. We do not count look-behind pages.
813 if (i
>= maxb
+ 1 && (maxf
> i
- maxb
- 1))
821 /* XXX I cannot tell if this should be an exported symbol */
823 * vm_object_deactivate_pages
825 * Deactivate all pages in the specified object. (Keep its pages
826 * in memory even though it is no longer referenced.)
828 * The object must be locked.
831 vm_object_deactivate_pages(vm_object_t object
)
836 for (p
= TAILQ_FIRST(&object
->memq
); p
!= NULL
; p
= next
) {
837 next
= TAILQ_NEXT(p
, listq
);
838 vm_page_deactivate(p
);
845 * Same as vm_object_pmap_copy, except range checking really
846 * works, and is meant for small sections of an object.
848 * This code protects resident pages by making them read-only
849 * and is typically called on a fork or split when a page
850 * is converted to copy-on-write.
852 * NOTE: If the page is already at VM_PROT_NONE, calling
853 * vm_page_protect will have no effect.
856 vm_object_pmap_copy_1(vm_object_t object
, vm_pindex_t start
, vm_pindex_t end
)
861 if (object
== NULL
|| (object
->flags
& OBJ_WRITEABLE
) == 0)
865 * spl protection needed to prevent races between the lookup,
866 * an interrupt unbusy/free, and our protect call.
869 for (idx
= start
; idx
< end
; idx
++) {
870 p
= vm_page_lookup(object
, idx
);
873 vm_page_protect(p
, VM_PROT_READ
);
879 * vm_object_pmap_remove:
881 * Removes all physical pages in the specified
882 * object range from all physical maps.
884 * The object must *not* be locked.
887 vm_object_pmap_remove(vm_object_t object
, vm_pindex_t start
, vm_pindex_t end
)
895 * spl protection is required because an interrupt can unbusy/free
899 for (p
= TAILQ_FIRST(&object
->memq
);
901 p
= TAILQ_NEXT(p
, listq
)
903 if (p
->pindex
>= start
&& p
->pindex
< end
)
904 vm_page_protect(p
, VM_PROT_NONE
);
907 if ((start
== 0) && (object
->size
== end
))
908 vm_object_clear_flag(object
, OBJ_WRITEABLE
);
914 * Implements the madvise function at the object/page level.
916 * MADV_WILLNEED (any object)
918 * Activate the specified pages if they are resident.
920 * MADV_DONTNEED (any object)
922 * Deactivate the specified pages if they are resident.
924 * MADV_FREE (OBJT_DEFAULT/OBJT_SWAP objects,
925 * OBJ_ONEMAPPING only)
927 * Deactivate and clean the specified pages if they are
928 * resident. This permits the process to reuse the pages
929 * without faulting or the kernel to reclaim the pages
933 vm_object_madvise(vm_object_t object
, vm_pindex_t pindex
, int count
, int advise
)
935 vm_pindex_t end
, tpindex
;
942 end
= pindex
+ count
;
945 * Locate and adjust resident pages
948 for (; pindex
< end
; pindex
+= 1) {
954 * MADV_FREE only operates on OBJT_DEFAULT or OBJT_SWAP pages
955 * and those pages must be OBJ_ONEMAPPING.
957 if (advise
== MADV_FREE
) {
958 if ((tobject
->type
!= OBJT_DEFAULT
&&
959 tobject
->type
!= OBJT_SWAP
) ||
960 (tobject
->flags
& OBJ_ONEMAPPING
) == 0) {
966 * spl protection is required to avoid a race between the
967 * lookup, an interrupt unbusy/free, and our busy check.
971 m
= vm_page_lookup(tobject
, tpindex
);
975 * There may be swap even if there is no backing page
977 if (advise
== MADV_FREE
&& tobject
->type
== OBJT_SWAP
)
978 swap_pager_freespace(tobject
, tpindex
, 1);
984 if (tobject
->backing_object
== NULL
)
986 tpindex
+= OFF_TO_IDX(tobject
->backing_object_offset
);
987 tobject
= tobject
->backing_object
;
992 * If the page is busy or not in a normal active state,
993 * we skip it. If the page is not managed there are no
994 * page queues to mess with. Things can break if we mess
995 * with pages in any of the below states.
1000 (m
->flags
& PG_UNMANAGED
) ||
1001 m
->valid
!= VM_PAGE_BITS_ALL
1007 if (vm_page_sleep_busy(m
, TRUE
, "madvpo")) {
1014 * Theoretically once a page is known not to be busy, an
1015 * interrupt cannot come along and rip it out from under us.
1018 if (advise
== MADV_WILLNEED
) {
1019 vm_page_activate(m
);
1020 } else if (advise
== MADV_DONTNEED
) {
1021 vm_page_dontneed(m
);
1022 } else if (advise
== MADV_FREE
) {
1024 * Mark the page clean. This will allow the page
1025 * to be freed up by the system. However, such pages
1026 * are often reused quickly by malloc()/free()
1027 * so we do not do anything that would cause
1028 * a page fault if we can help it.
1030 * Specifically, we do not try to actually free
1031 * the page now nor do we try to put it in the
1032 * cache (which would cause a page fault on reuse).
1034 * But we do make the page is freeable as we
1035 * can without actually taking the step of unmapping
1038 pmap_clear_modify(m
);
1041 vm_page_dontneed(m
);
1042 if (tobject
->type
== OBJT_SWAP
)
1043 swap_pager_freespace(tobject
, tpindex
, 1);
1051 * Create a new object which is backed by the
1052 * specified existing object range. The source
1053 * object reference is deallocated.
1055 * The new object and offset into that object
1056 * are returned in the source parameters.
1060 vm_object_shadow(vm_object_t
*object
, /* IN/OUT */
1061 vm_ooffset_t
*offset
, /* IN/OUT */
1070 * Don't create the new object if the old object isn't shared.
1073 if (source
!= NULL
&&
1074 source
->ref_count
== 1 &&
1075 source
->handle
== NULL
&&
1076 (source
->type
== OBJT_DEFAULT
||
1077 source
->type
== OBJT_SWAP
))
1081 * Allocate a new object with the given length
1084 if ((result
= vm_object_allocate(OBJT_DEFAULT
, length
)) == NULL
)
1085 panic("vm_object_shadow: no object for shadowing");
1088 * The new object shadows the source object, adding a reference to it.
1089 * Our caller changes his reference to point to the new object,
1090 * removing a reference to the source object. Net result: no change
1091 * of reference count.
1093 * Try to optimize the result object's page color when shadowing
1094 * in order to maintain page coloring consistency in the combined
1097 result
->backing_object
= source
;
1099 LIST_INSERT_HEAD(&source
->shadow_head
, result
, shadow_list
);
1100 source
->shadow_count
++;
1101 source
->generation
++;
1102 result
->pg_color
= (source
->pg_color
+ OFF_TO_IDX(*offset
)) & PQ_L2_MASK
;
1106 * Store the offset into the source object, and fix up the offset into
1110 result
->backing_object_offset
= *offset
;
1113 * Return the new things
1120 #define OBSC_TEST_ALL_SHADOWED 0x0001
1121 #define OBSC_COLLAPSE_NOWAIT 0x0002
1122 #define OBSC_COLLAPSE_WAIT 0x0004
1125 vm_object_backing_scan(vm_object_t object
, int op
)
1129 vm_object_t backing_object
;
1130 vm_pindex_t backing_offset_index
;
1133 * spl protection is required to avoid races between the memq/lookup,
1134 * an interrupt doing an unbusy/free, and our busy check. Amoung
1139 backing_object
= object
->backing_object
;
1140 backing_offset_index
= OFF_TO_IDX(object
->backing_object_offset
);
1143 * Initial conditions
1146 if (op
& OBSC_TEST_ALL_SHADOWED
) {
1148 * We do not want to have to test for the existence of
1149 * swap pages in the backing object. XXX but with the
1150 * new swapper this would be pretty easy to do.
1152 * XXX what about anonymous MAP_SHARED memory that hasn't
1153 * been ZFOD faulted yet? If we do not test for this, the
1154 * shadow test may succeed! XXX
1156 if (backing_object
->type
!= OBJT_DEFAULT
) {
1161 if (op
& OBSC_COLLAPSE_WAIT
) {
1162 KKASSERT((backing_object
->flags
& OBJ_DEAD
) == 0);
1163 vm_object_set_flag(backing_object
, OBJ_DEAD
);
1170 p
= TAILQ_FIRST(&backing_object
->memq
);
1172 vm_page_t next
= TAILQ_NEXT(p
, listq
);
1173 vm_pindex_t new_pindex
= p
->pindex
- backing_offset_index
;
1175 if (op
& OBSC_TEST_ALL_SHADOWED
) {
1179 * Ignore pages outside the parent object's range
1180 * and outside the parent object's mapping of the
1183 * note that we do not busy the backing object's
1188 p
->pindex
< backing_offset_index
||
1189 new_pindex
>= object
->size
1196 * See if the parent has the page or if the parent's
1197 * object pager has the page. If the parent has the
1198 * page but the page is not valid, the parent's
1199 * object pager must have the page.
1201 * If this fails, the parent does not completely shadow
1202 * the object and we might as well give up now.
1205 pp
= vm_page_lookup(object
, new_pindex
);
1207 (pp
== NULL
|| pp
->valid
== 0) &&
1208 !vm_pager_has_page(object
, new_pindex
, NULL
, NULL
)
1216 * Check for busy page
1219 if (op
& (OBSC_COLLAPSE_WAIT
| OBSC_COLLAPSE_NOWAIT
)) {
1222 if (op
& OBSC_COLLAPSE_NOWAIT
) {
1224 (p
->flags
& PG_BUSY
) ||
1233 } else if (op
& OBSC_COLLAPSE_WAIT
) {
1234 if (vm_page_sleep_busy(p
, TRUE
, "vmocol")) {
1236 * If we slept, anything could have
1237 * happened. Since the object is
1238 * marked dead, the backing offset
1239 * should not have changed so we
1240 * just restart our scan.
1242 p
= TAILQ_FIRST(&backing_object
->memq
);
1253 p
->object
== backing_object
,
1254 ("vm_object_qcollapse(): object mismatch")
1258 * Destroy any associated swap
1260 if (backing_object
->type
== OBJT_SWAP
) {
1261 swap_pager_freespace(
1269 p
->pindex
< backing_offset_index
||
1270 new_pindex
>= object
->size
1273 * Page is out of the parent object's range, we
1274 * can simply destroy it.
1276 vm_page_protect(p
, VM_PROT_NONE
);
1282 pp
= vm_page_lookup(object
, new_pindex
);
1285 vm_pager_has_page(object
, new_pindex
, NULL
, NULL
)
1288 * page already exists in parent OR swap exists
1289 * for this location in the parent. Destroy
1290 * the original page from the backing object.
1292 * Leave the parent's page alone
1294 vm_page_protect(p
, VM_PROT_NONE
);
1301 * Page does not exist in parent, rename the
1302 * page from the backing object to the main object.
1304 * If the page was mapped to a process, it can remain
1305 * mapped through the rename.
1307 if ((p
->queue
- p
->pc
) == PQ_CACHE
)
1308 vm_page_deactivate(p
);
1310 vm_page_rename(p
, object
, new_pindex
);
1311 /* page automatically made dirty by rename */
1321 * this version of collapse allows the operation to occur earlier and
1322 * when paging_in_progress is true for an object... This is not a complete
1323 * operation, but should plug 99.9% of the rest of the leaks.
1326 vm_object_qcollapse(vm_object_t object
)
1328 vm_object_t backing_object
= object
->backing_object
;
1330 if (backing_object
->ref_count
!= 1)
1333 backing_object
->ref_count
+= 2;
1335 vm_object_backing_scan(object
, OBSC_COLLAPSE_NOWAIT
);
1337 backing_object
->ref_count
-= 2;
1341 * vm_object_collapse:
1343 * Collapse an object with the object backing it.
1344 * Pages in the backing object are moved into the
1345 * parent, and the backing object is deallocated.
1348 vm_object_collapse(vm_object_t object
)
1351 vm_object_t backing_object
;
1354 * Verify that the conditions are right for collapse:
1356 * The object exists and the backing object exists.
1361 if ((backing_object
= object
->backing_object
) == NULL
)
1365 * we check the backing object first, because it is most likely
1368 if (backing_object
->handle
!= NULL
||
1369 (backing_object
->type
!= OBJT_DEFAULT
&&
1370 backing_object
->type
!= OBJT_SWAP
) ||
1371 (backing_object
->flags
& OBJ_DEAD
) ||
1372 object
->handle
!= NULL
||
1373 (object
->type
!= OBJT_DEFAULT
&&
1374 object
->type
!= OBJT_SWAP
) ||
1375 (object
->flags
& OBJ_DEAD
)) {
1380 object
->paging_in_progress
!= 0 ||
1381 backing_object
->paging_in_progress
!= 0
1383 vm_object_qcollapse(object
);
1388 * We know that we can either collapse the backing object (if
1389 * the parent is the only reference to it) or (perhaps) have
1390 * the parent bypass the object if the parent happens to shadow
1391 * all the resident pages in the entire backing object.
1393 * This is ignoring pager-backed pages such as swap pages.
1394 * vm_object_backing_scan fails the shadowing test in this
1398 if (backing_object
->ref_count
== 1) {
1400 * If there is exactly one reference to the backing
1401 * object, we can collapse it into the parent.
1403 vm_object_backing_scan(object
, OBSC_COLLAPSE_WAIT
);
1406 * Move the pager from backing_object to object.
1409 if (backing_object
->type
== OBJT_SWAP
) {
1410 vm_object_pip_add(backing_object
, 1);
1413 * scrap the paging_offset junk and do a
1414 * discrete copy. This also removes major
1415 * assumptions about how the swap-pager
1416 * works from where it doesn't belong. The
1417 * new swapper is able to optimize the
1418 * destroy-source case.
1421 vm_object_pip_add(object
, 1);
1425 OFF_TO_IDX(object
->backing_object_offset
), TRUE
);
1426 vm_object_pip_wakeup(object
);
1428 vm_object_pip_wakeup(backing_object
);
1431 * Object now shadows whatever backing_object did.
1432 * Note that the reference to
1433 * backing_object->backing_object moves from within
1434 * backing_object to within object.
1437 LIST_REMOVE(object
, shadow_list
);
1438 object
->backing_object
->shadow_count
--;
1439 object
->backing_object
->generation
++;
1440 if (backing_object
->backing_object
) {
1441 LIST_REMOVE(backing_object
, shadow_list
);
1442 backing_object
->backing_object
->shadow_count
--;
1443 backing_object
->backing_object
->generation
++;
1445 object
->backing_object
= backing_object
->backing_object
;
1446 if (object
->backing_object
) {
1448 &object
->backing_object
->shadow_head
,
1452 object
->backing_object
->shadow_count
++;
1453 object
->backing_object
->generation
++;
1456 object
->backing_object_offset
+=
1457 backing_object
->backing_object_offset
;
1460 * Discard backing_object.
1462 * Since the backing object has no pages, no pager left,
1463 * and no object references within it, all that is
1464 * necessary is to dispose of it.
1467 KASSERT(backing_object
->ref_count
== 1, ("backing_object %p was somehow re-referenced during collapse!", backing_object
));
1468 KASSERT(TAILQ_FIRST(&backing_object
->memq
) == NULL
, ("backing_object %p somehow has left over pages during collapse!", backing_object
));
1478 zfree(obj_zone
, backing_object
);
1482 vm_object_t new_backing_object
;
1485 * If we do not entirely shadow the backing object,
1486 * there is nothing we can do so we give up.
1489 if (vm_object_backing_scan(object
, OBSC_TEST_ALL_SHADOWED
) == 0) {
1494 * Make the parent shadow the next object in the
1495 * chain. Deallocating backing_object will not remove
1496 * it, since its reference count is at least 2.
1499 LIST_REMOVE(object
, shadow_list
);
1500 backing_object
->shadow_count
--;
1501 backing_object
->generation
++;
1503 new_backing_object
= backing_object
->backing_object
;
1504 if ((object
->backing_object
= new_backing_object
) != NULL
) {
1505 vm_object_reference(new_backing_object
);
1507 &new_backing_object
->shadow_head
,
1511 new_backing_object
->shadow_count
++;
1512 new_backing_object
->generation
++;
1513 object
->backing_object_offset
+=
1514 backing_object
->backing_object_offset
;
1518 * Drop the reference count on backing_object. Since
1519 * its ref_count was at least 2, it will not vanish;
1520 * so we don't need to call vm_object_deallocate, but
1523 vm_object_deallocate(backing_object
);
1528 * Try again with this object's new backing object.
1534 * vm_object_page_remove: [internal]
1536 * Removes all physical pages in the specified
1537 * object range from the object's list of pages.
1540 vm_object_page_remove(vm_object_t object
, vm_pindex_t start
, vm_pindex_t end
,
1541 boolean_t clean_only
)
1547 if (object
== NULL
|| object
->resident_page_count
== 0)
1550 all
= ((end
== 0) && (start
== 0));
1553 * Since physically-backed objects do not use managed pages, we can't
1554 * remove pages from the object (we must instead remove the page
1555 * references, and then destroy the object).
1557 KASSERT(object
->type
!= OBJT_PHYS
,
1558 ("attempt to remove pages from a physical object"));
1561 * Indicating that the object is undergoing paging.
1563 * spl protection is required to avoid a race between the memq scan,
1564 * an interrupt unbusy/free, and the busy check.
1566 vm_object_pip_add(object
, 1);
1570 if (all
|| size
> object
->resident_page_count
/ 4) {
1571 for (p
= TAILQ_FIRST(&object
->memq
); p
!= NULL
; p
= next
) {
1572 next
= TAILQ_NEXT(p
, listq
);
1573 if (all
|| ((start
<= p
->pindex
) && (p
->pindex
< end
))) {
1574 if (p
->wire_count
!= 0) {
1575 vm_page_protect(p
, VM_PROT_NONE
);
1582 * The busy flags are only cleared at
1583 * interrupt -- minimize the spl transitions
1586 if (vm_page_sleep_busy(p
, TRUE
, "vmopar"))
1589 if (clean_only
&& p
->valid
) {
1590 vm_page_test_dirty(p
);
1591 if (p
->valid
& p
->dirty
)
1596 vm_page_protect(p
, VM_PROT_NONE
);
1602 if ((p
= vm_page_lookup(object
, start
)) != 0) {
1603 if (p
->wire_count
!= 0) {
1604 vm_page_protect(p
, VM_PROT_NONE
);
1613 * The busy flags are only cleared at
1614 * interrupt -- minimize the spl transitions
1616 if (vm_page_sleep_busy(p
, TRUE
, "vmopar"))
1619 if (clean_only
&& p
->valid
) {
1620 vm_page_test_dirty(p
);
1621 if (p
->valid
& p
->dirty
) {
1629 vm_page_protect(p
, VM_PROT_NONE
);
1637 vm_object_pip_wakeup(object
);
1641 * Routine: vm_object_coalesce
1642 * Function: Coalesces two objects backing up adjoining
1643 * regions of memory into a single object.
1645 * returns TRUE if objects were combined.
1647 * NOTE: Only works at the moment if the second object is NULL -
1648 * if it's not, which object do we lock first?
1651 * prev_object First object to coalesce
1652 * prev_offset Offset into prev_object
1653 * next_object Second object into coalesce
1654 * next_offset Offset into next_object
1656 * prev_size Size of reference to prev_object
1657 * next_size Size of reference to next_object
1660 * The object must *not* be locked.
1663 vm_object_coalesce(vm_object_t prev_object
, vm_pindex_t prev_pindex
,
1664 vm_size_t prev_size
, vm_size_t next_size
)
1666 vm_pindex_t next_pindex
;
1668 if (prev_object
== NULL
) {
1672 if (prev_object
->type
!= OBJT_DEFAULT
&&
1673 prev_object
->type
!= OBJT_SWAP
) {
1678 * Try to collapse the object first
1680 vm_object_collapse(prev_object
);
1683 * Can't coalesce if: . more than one reference . paged out . shadows
1684 * another object . has a copy elsewhere (any of which mean that the
1685 * pages not mapped to prev_entry may be in use anyway)
1688 if (prev_object
->backing_object
!= NULL
) {
1692 prev_size
>>= PAGE_SHIFT
;
1693 next_size
>>= PAGE_SHIFT
;
1694 next_pindex
= prev_pindex
+ prev_size
;
1696 if ((prev_object
->ref_count
> 1) &&
1697 (prev_object
->size
!= next_pindex
)) {
1702 * Remove any pages that may still be in the object from a previous
1705 if (next_pindex
< prev_object
->size
) {
1706 vm_object_page_remove(prev_object
,
1708 next_pindex
+ next_size
, FALSE
);
1709 if (prev_object
->type
== OBJT_SWAP
)
1710 swap_pager_freespace(prev_object
,
1711 next_pindex
, next_size
);
1715 * Extend the object if necessary.
1717 if (next_pindex
+ next_size
> prev_object
->size
)
1718 prev_object
->size
= next_pindex
+ next_size
;
1724 vm_object_set_writeable_dirty(vm_object_t object
)
1728 vm_object_set_flag(object
, OBJ_WRITEABLE
|OBJ_MIGHTBEDIRTY
);
1729 if (object
->type
== OBJT_VNODE
&&
1730 (vp
= (struct vnode
*)object
->handle
) != NULL
) {
1731 if ((vp
->v_flag
& VOBJDIRTY
) == 0) {
1732 vsetflags(vp
, VOBJDIRTY
);
1739 #include "opt_ddb.h"
1741 #include <sys/kernel.h>
1743 #include <sys/cons.h>
1745 #include <ddb/ddb.h>
1747 static int _vm_object_in_map (vm_map_t map
, vm_object_t object
,
1748 vm_map_entry_t entry
);
1749 static int vm_object_in_map (vm_object_t object
);
1752 _vm_object_in_map(vm_map_t map
, vm_object_t object
, vm_map_entry_t entry
)
1755 vm_map_entry_t tmpe
;
1763 tmpe
= map
->header
.next
;
1764 entcount
= map
->nentries
;
1765 while (entcount
-- && (tmpe
!= &map
->header
)) {
1766 if( _vm_object_in_map(map
, object
, tmpe
)) {
1771 } else if (entry
->eflags
& MAP_ENTRY_IS_SUB_MAP
) {
1772 tmpm
= entry
->object
.sub_map
;
1773 tmpe
= tmpm
->header
.next
;
1774 entcount
= tmpm
->nentries
;
1775 while (entcount
-- && tmpe
!= &tmpm
->header
) {
1776 if( _vm_object_in_map(tmpm
, object
, tmpe
)) {
1781 } else if ((obj
= entry
->object
.vm_object
) != NULL
) {
1782 for(; obj
; obj
=obj
->backing_object
)
1783 if( obj
== object
) {
1790 static int vm_object_in_map_callback(struct proc
*p
, void *data
);
1792 struct vm_object_in_map_info
{
1798 vm_object_in_map(vm_object_t object
)
1800 struct vm_object_in_map_info info
;
1803 info
.object
= object
;
1805 allproc_scan(vm_object_in_map_callback
, &info
);
1808 if( _vm_object_in_map( kernel_map
, object
, 0))
1810 if( _vm_object_in_map( pager_map
, object
, 0))
1812 if( _vm_object_in_map( buffer_map
, object
, 0))
1818 vm_object_in_map_callback(struct proc
*p
, void *data
)
1820 struct vm_object_in_map_info
*info
= data
;
1823 if (_vm_object_in_map(&p
->p_vmspace
->vm_map
, info
->object
, 0)) {
1831 DB_SHOW_COMMAND(vmochk
, vm_object_check
)
1836 * make sure that internal objs are in a map somewhere
1837 * and none have zero ref counts.
1839 for (object
= TAILQ_FIRST(&vm_object_list
);
1841 object
= TAILQ_NEXT(object
, object_list
)) {
1842 if (object
->handle
== NULL
&&
1843 (object
->type
== OBJT_DEFAULT
|| object
->type
== OBJT_SWAP
)) {
1844 if (object
->ref_count
== 0) {
1845 db_printf("vmochk: internal obj has zero ref count: %ld\n",
1846 (long)object
->size
);
1848 if (!vm_object_in_map(object
)) {
1850 "vmochk: internal obj is not in a map: "
1851 "ref: %d, size: %lu: 0x%lx, backing_object: %p\n",
1852 object
->ref_count
, (u_long
)object
->size
,
1853 (u_long
)object
->size
,
1854 (void *)object
->backing_object
);
1861 * vm_object_print: [ debug ]
1863 DB_SHOW_COMMAND(object
, vm_object_print_static
)
1865 /* XXX convert args. */
1866 vm_object_t object
= (vm_object_t
)addr
;
1867 boolean_t full
= have_addr
;
1871 /* XXX count is an (unused) arg. Avoid shadowing it. */
1872 #define count was_count
1880 "Object %p: type=%d, size=0x%lx, res=%d, ref=%d, flags=0x%x\n",
1881 object
, (int)object
->type
, (u_long
)object
->size
,
1882 object
->resident_page_count
, object
->ref_count
, object
->flags
);
1884 * XXX no %qd in kernel. Truncate object->backing_object_offset.
1886 db_iprintf(" sref=%d, backing_object(%d)=(%p)+0x%lx\n",
1887 object
->shadow_count
,
1888 object
->backing_object
? object
->backing_object
->ref_count
: 0,
1889 object
->backing_object
, (long)object
->backing_object_offset
);
1896 for (p
= TAILQ_FIRST(&object
->memq
); p
!= NULL
; p
= TAILQ_NEXT(p
, listq
)) {
1898 db_iprintf("memory:=");
1899 else if (count
== 6) {
1907 db_printf("(off=0x%lx,page=0x%lx)",
1908 (u_long
) p
->pindex
, (u_long
) VM_PAGE_TO_PHYS(p
));
1918 /* XXX need this non-static entry for calling from vm_map_print. */
1920 vm_object_print(/* db_expr_t */ long addr
,
1921 boolean_t have_addr
,
1922 /* db_expr_t */ long count
,
1925 vm_object_print_static(addr
, have_addr
, count
, modif
);
1928 DB_SHOW_COMMAND(vmopag
, vm_object_print_pages
)
1933 for (object
= TAILQ_FIRST(&vm_object_list
);
1935 object
= TAILQ_NEXT(object
, object_list
)) {
1936 vm_pindex_t idx
, fidx
;
1938 vm_paddr_t pa
= -1, padiff
;
1942 db_printf("new object: %p\n", (void *)object
);
1952 osize
= object
->size
;
1955 for (idx
= 0; idx
< osize
; idx
++) {
1956 m
= vm_page_lookup(object
, idx
);
1959 db_printf(" index(%ld)run(%d)pa(0x%lx)\n",
1960 (long)fidx
, rcount
, (long)pa
);
1975 (VM_PAGE_TO_PHYS(m
) == pa
+ rcount
* PAGE_SIZE
)) {
1980 padiff
= pa
+ rcount
* PAGE_SIZE
- VM_PAGE_TO_PHYS(m
);
1981 padiff
>>= PAGE_SHIFT
;
1982 padiff
&= PQ_L2_MASK
;
1984 pa
= VM_PAGE_TO_PHYS(m
) - rcount
* PAGE_SIZE
;
1988 db_printf(" index(%ld)run(%d)pa(0x%lx)",
1989 (long)fidx
, rcount
, (long)pa
);
1990 db_printf("pd(%ld)\n", (long)padiff
);
2000 pa
= VM_PAGE_TO_PHYS(m
);
2004 db_printf(" index(%ld)run(%d)pa(0x%lx)\n",
2005 (long)fidx
, rcount
, (long)pa
);