diff --git a/sys/vm/device_pager.c b/sys/vm/device_pager.c --- a/sys/vm/device_pager.c +++ b/sys/vm/device_pager.c @@ -51,6 +51,7 @@ #include #include #include +#include #include #include #include @@ -267,7 +268,7 @@ 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 @@ 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); diff --git a/sys/vm/swap_pager.c b/sys/vm/swap_pager.c --- a/sys/vm/swap_pager.c +++ b/sys/vm/swap_pager.c @@ -1966,7 +1966,7 @@ * 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ * 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 diff --git a/sys/vm/vm_kern.c b/sys/vm/vm_kern.c --- a/sys/vm/vm_kern.c +++ b/sys/vm/vm_kern.c @@ -650,14 +650,14 @@ 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); diff --git a/sys/vm/vm_object.c b/sys/vm/vm_object.c --- a/sys/vm/vm_object.c +++ b/sys/vm/vm_object.c @@ -1577,7 +1577,7 @@ 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_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 @@ * 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_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 diff --git a/sys/vm/vm_page.h b/sys/vm/vm_page.h --- a/sys/vm/vm_page.h +++ b/sys/vm/vm_page.h @@ -645,7 +645,6 @@ 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_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); diff --git a/sys/vm/vm_page.c b/sys/vm/vm_page.c --- a/sys/vm/vm_page.c +++ b/sys/vm/vm_page.c @@ -1836,21 +1836,6 @@ 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 @@ 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.