upstream/opnsense-src
1
0
Fork 0
mirror of https://github.com/opnsense/src.git synced 2026-06-07 07:42:26 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

vm_page: drop page_iter_lookup

Browse source 
The functions vm_page_iter_lookup and vm_page_iter_lookup_ge are just
wrappers around vm_radix_iter_lookup and vm_radix_iter_lookup_ge,
respectively. They server no real purpose, so drop them and use the
vm_radix versions everywhere.

Reviewed by:	kib
Differential Revision:	https://reviews.freebsd.org/D49203
This commit is contained in:
Doug Moore 2025-03-02 18:05:02 -06:00
parent e8a5b9fd73
commit 991dbf9f43
6 changed files with 15 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
sys/vm/device_pager.c
View file

@ -51,6 +51,7 @@
#include <vm/vm_object.h>
#include <vm/vm_page.h>
#include <vm/vm_pager.h>
#include <vm/vm_radix.h>
#include <vm/vm_phys.h>
#include <vm/vm_radix.h>
#include <vm/uma.h>
@ -267,7 +268,7 @@ cdev_pager_free_page(vm_object_t object, vm_page_t m)
struct pctrie_iter pages;
vm_page_iter_init(&pages, object);
vm_page_iter_lookup(&pages, m->pindex);
vm_radix_iter_lookup(&pages, m->pindex);
cdev_mgtdev_pager_free_page(&pages, m);
} else if (object->type == OBJT_DEVICE)
dev_pager_free_page(object, m);
@ -292,7 +293,7 @@ cdev_mgtdev_pager_free_pages(vm_object_t object)
vm_page_iter_init(&pages, object);
VM_OBJECT_WLOCK(object);
retry:
for (m = vm_page_iter_lookup_ge(&pages, 0); m != NULL;
for (m = vm_radix_iter_lookup_ge(&pages, 0); m != NULL;
m = vm_radix_iter_step(&pages)) {
if (!vm_page_busy_acquire(m, VM_ALLOC_WAITFAIL)) {
pctrie_iter_reset(&pages);

12
sys/vm/swap_pager.c
View file

@ -1966,7 +1966,7 @@ swap_pager_swapoff_object(struct swdevt *sp, vm_object_t object)
* found page has pending operations, sleep and restart
* the scan.
*/
m = vm_page_iter_lookup(&pages, blks.index + i);
m = vm_radix_iter_lookup(&pages, blks.index + i);
if (m != NULL && (m->oflags & VPO_SWAPINPROG) != 0) {
m->oflags |= VPO_SWAPSLEEP;
VM_OBJECT_SLEEP(object, &object->handle, PSWP,
@ -2393,7 +2393,7 @@ swp_pager_meta_free(vm_object_t object, vm_pindex_t pindex, vm_pindex_t count,
continue;
swp_pager_update_freerange(&range, sb->d[i]);
if (freed != NULL) {
m = vm_page_iter_lookup(&pages, blks.index + i);
m = vm_radix_iter_lookup(&pages, blks.index + i);
if (m == NULL || vm_page_none_valid(m))
fc++;
}
@ -2511,7 +2511,7 @@ swap_pager_seek_data(vm_object_t object, vm_pindex_t pindex)
VM_OBJECT_ASSERT_RLOCKED(object);
vm_page_iter_init(&pages, object);
m = vm_page_iter_lookup_ge(&pages, pindex);
m = vm_radix_iter_lookup_ge(&pages, pindex);
if (m != NULL && pages.index == pindex && vm_page_any_valid(m))
return (pages.index);
swblk_iter_init_only(&blks, object);
@ -2546,7 +2546,7 @@ swap_pager_seek_hole(vm_object_t object, vm_pindex_t pindex)
VM_OBJECT_ASSERT_RLOCKED(object);
vm_page_iter_init(&pages, object);
swblk_iter_init_only(&blks, object);
while (((m = vm_page_iter_lookup(&pages, pindex)) != NULL &&
while (((m = vm_radix_iter_lookup(&pages, pindex)) != NULL &&
vm_page_any_valid(m)) ||
((sb = swblk_iter_lookup(&blks, pindex)) != NULL &&
sb->d[pindex % SWAP_META_PAGES] != SWAPBLK_NONE))
@ -2591,7 +2591,7 @@ swap_pager_scan_all_shadowed(vm_object_t object)
pv = ps = pi = backing_offset_index - 1;
for (;;) {
if (pi == pv) {
p = vm_page_iter_lookup_ge(&backing_pages, pv + 1);
p = vm_radix_iter_lookup_ge(&backing_pages, pv + 1);
pv = p != NULL ? p->pindex : backing_object->size;
}
if (pi == ps)
@ -2633,7 +2633,7 @@ swap_pager_scan_all_shadowed(vm_object_t object)
* object and we might as well give up now.
*/
new_pindex = pi - backing_offset_index;
pp = vm_page_iter_lookup(&pages, new_pindex);
pp = vm_radix_iter_lookup(&pages, new_pindex);
/*
* The valid check here is stable due to object lock being

4
sys/vm/vm_kern.c
View file

@ -650,14 +650,14 @@ _kmem_unback(vm_object_t object, vm_offset_t addr, vm_size_t size)
end = offset + size;
VM_OBJECT_WLOCK(object);
vm_page_iter_init(&pages, object);
m = vm_page_iter_lookup(&pages, atop(offset));
m = vm_radix_iter_lookup(&pages, atop(offset));
domain = vm_page_domain(m);
if (__predict_true((m->oflags & VPO_KMEM_EXEC) == 0))
arena = vm_dom[domain].vmd_kernel_arena;
else
arena = vm_dom[domain].vmd_kernel_rwx_arena;
for (; offset < end; offset += PAGE_SIZE,
m = vm_page_iter_lookup(&pages, atop(offset))) {
m = vm_radix_iter_lookup(&pages, atop(offset))) {
vm_page_xbusy_claim(m);
vm_page_unwire_noq(m);
vm_page_iter_free(&pages, m);

8
sys/vm/vm_object.c
View file

@ -1577,7 +1577,7 @@ vm_object_split(vm_map_entry_t entry)
vm_page_iter_limit_init(&pages, orig_object, offidxstart + size);
retry:
pctrie_iter_reset(&pages);
for (m = vm_page_iter_lookup_ge(&pages, offidxstart); m != NULL;
for (m = vm_radix_iter_lookup_ge(&pages, offidxstart); m != NULL;
m = vm_radix_iter_step(&pages)) {
/*
* We must wait for pending I/O to complete before we can
@ -1681,7 +1681,7 @@ vm_object_collapse_scan_wait(struct pctrie_iter *pages, vm_object_t object,
}
VM_OBJECT_WLOCK(backing_object);
vm_page_iter_init(pages, backing_object);
return (vm_page_iter_lookup_ge(pages, 0));
return (vm_radix_iter_lookup_ge(pages, 0));
}
static void
@ -1702,7 +1702,7 @@ vm_object_collapse_scan(vm_object_t object)
* Our scan
*/
vm_page_iter_init(&pages, backing_object);
for (p = vm_page_iter_lookup_ge(&pages, 0); p != NULL; p = next) {
for (p = vm_radix_iter_lookup_ge(&pages, 0); p != NULL; p = next) {
/*
* Check for busy page
*/
@ -1997,7 +1997,7 @@ vm_object_page_remove(vm_object_t object, vm_pindex_t start, vm_pindex_t end,
vm_page_iter_limit_init(&pages, object, end);
again:
pctrie_iter_reset(&pages);
for (p = vm_page_iter_lookup_ge(&pages, start); p != NULL;
for (p = vm_radix_iter_lookup_ge(&pages, start); p != NULL;
p = vm_radix_iter_step(&pages)) {
/*
* Skip invalid pages if asked to do so. Try to avoid acquiring

31
sys/vm/vm_page.c
View file

@ -1836,21 +1836,6 @@ vm_page_iter_limit_init(struct pctrie_iter *pages, vm_object_t object,
vm_radix_iter_limit_init(pages, &object->rtree, limit);
}
/*
* vm_page_iter_lookup:
*
* Returns the page associated with the object/offset pair specified, and
* stores the path to its position; if none is found, NULL is returned.
*
* The iter pctrie must be locked.
*/
vm_page_t
vm_page_iter_lookup(struct pctrie_iter *pages, vm_pindex_t pindex)
{
return (vm_radix_iter_lookup(pages, pindex));
}
/*
* vm_page_lookup_unlocked:
*
@ -1935,22 +1920,6 @@ vm_page_find_least(vm_object_t object, vm_pindex_t pindex)
return (m);
}
/*
* vm_page_iter_lookup_ge:
*
* Returns the page associated with the object with least pindex
* greater than or equal to the parameter pindex, or NULL. Initializes the
* iterator to point to that page.
*
* The iter pctrie must be locked.
*/
vm_page_t
vm_page_iter_lookup_ge(struct pctrie_iter *pages, vm_pindex_t pindex)
{
return (vm_radix_iter_lookup_ge(pages, pindex));
}
/*
* Returns the given page's successor (by pindex) within the object if it is
* resident; if none is found, NULL is returned.

2
sys/vm/vm_page.h
View file

@ -645,7 +645,6 @@ void vm_page_deactivate_noreuse(vm_page_t);
void vm_page_dequeue(vm_page_t m);
void vm_page_dequeue_deferred(vm_page_t m);
vm_page_t vm_page_find_least(vm_object_t, vm_pindex_t);
vm_page_t vm_page_iter_lookup_ge(struct pctrie_iter *, vm_pindex_t);
void vm_page_free_invalid(vm_page_t);
vm_page_t vm_page_getfake(vm_paddr_t paddr, vm_memattr_t memattr);
void vm_page_initfake(vm_page_t m, vm_paddr_t paddr, vm_memattr_t memattr);
@ -656,7 +655,6 @@ void vm_page_invalid(vm_page_t m);
void vm_page_iter_free(struct pctrie_iter *pages, vm_page_t m);
void vm_page_iter_init(struct pctrie_iter *, vm_object_t);
void vm_page_iter_limit_init(struct pctrie_iter *, vm_object_t, vm_pindex_t);
vm_page_t vm_page_iter_lookup(struct pctrie_iter *, vm_pindex_t);
bool vm_page_iter_remove(struct pctrie_iter *pages, vm_page_t m);
bool vm_page_iter_rename(struct pctrie_iter *old_pages, vm_page_t m,
vm_object_t new_object, vm_pindex_t new_pindex);