 @@ -1,14 +1,14 @@
-/*	$NetBSD: pmap.c,v 1.101 2019/12/15 21:11:34 ad Exp $	*/
+/*	$NetBSD: pmap.c,v 1.102 2019/12/31 12:40:27 ad Exp $	*/
 /*-
  * Copyright (c) 2001, 2002 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Matthew Fredette.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -55,27 +55,27 @@
  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * References:
  * 1. PA7100LC ERS, Hewlett-Packard, March 30 1999, Public version 1.0
  * 2. PA7300LC ERS, Hewlett-Packard, March 18 1996, Version 1.0
  * 3. PA-RISC 1.1 Architecture and Instruction Set Reference Manual,
  *    Hewlett-Packard, February 1994, Third Edition
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: pmap.c,v 1.101 2019/12/15 21:11:34 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: pmap.c,v 1.102 2019/12/31 12:40:27 ad Exp $");
 #include "opt_cputype.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/malloc.h>
 #include <sys/proc.h>
 #include <sys/mutex.h>
 #include <uvm/uvm.h>
 #include <uvm/uvm_page_array.h>
 #include <machine/reg.h>
 @@ -569,42 +569,42 @@ pmap_pv_free(struct pv_entry *pv)
 	pool_put(&pmap_pv_pool, pv);
+}
 static inline void
 pmap_pv_enter(struct vm_page *pg, struct pv_entry *pve, pmap_t pm,
     vaddr_t va, struct vm_page *pdep, u_int flags)
+{
 	struct vm_page_md * const md = VM_PAGE_TO_MD(pg);
 	DPRINTF(PDB_FOLLOW|PDB_PV, ("%s(%p, %p, %p, 0x%lx, %p, 0x%x)\n",
 	    __func__, pg, pve, pm, va, pdep, flags));
-	KASSERT(pm == pmap_kernel() || uvm_page_locked_p(pg));
+	KASSERT(pm == pmap_kernel() || uvm_page_owner_locked_p(pg));
 	pve->pv_pmap = pm;
 	pve->pv_va = va | flags;
 	pve->pv_ptp = pdep;
 	pve->pv_next = md->pvh_list;
 	md->pvh_list = pve;
+}
 static inline struct pv_entry *
 pmap_pv_remove(struct vm_page *pg, pmap_t pmap, vaddr_t va)
+{
 	struct vm_page_md * const md = VM_PAGE_TO_MD(pg);
 	struct pv_entry **pve, *pv;
-	KASSERT(pmap == pmap_kernel() || uvm_page_locked_p(pg));
+	KASSERT(pmap == pmap_kernel() || uvm_page_owner_locked_p(pg));
 	for (pv = *(pve = &md->pvh_list);
 	    pv; pv = *(pve = &(*pve)->pv_next)) {
 		if (pv->pv_pmap == pmap && (pv->pv_va & PV_VAMASK) == va) {
 			*pve = pv->pv_next;
 			break;
+		}
+	}
 	if (IS_PVFEXEC_P(md->pvh_attrs)) {
 		if (md->pvh_list == NULL) {
 			md->pvh_attrs &= ~PVF_EXEC;
 		} else {

 @@ -1,14 +1,14 @@
-/*	$NetBSD: pmap.c,v 1.348 2019/12/22 15:15:20 ad Exp $	*/
+/*	$NetBSD: pmap.c,v 1.349 2019/12/31 12:40:27 ad Exp $	*/
 /*
  * Copyright (c) 2008, 2010, 2016, 2017, 2019 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran, and by Maxime Villard.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -120,27 +120,27 @@
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: pmap.c,v 1.348 2019/12/22 15:15:20 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: pmap.c,v 1.349 2019/12/31 12:40:27 ad Exp $");
 #include "opt_user_ldt.h"
 #include "opt_lockdebug.h"
 #include "opt_multiprocessor.h"
 #include "opt_xen.h"
 #include "opt_svs.h"
 #include "opt_kaslr.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/pool.h>
 #include <sys/kernel.h>
 @@ -3520,27 +3520,27 @@ pmap_remove_pte(struct pmap *pmap, struc
 	 * If we are not on a pv_head list - we are done.
 	 */
 	if ((opte & PTE_PVLIST) == 0) {
 #ifndef DOM0OPS
 		KASSERTMSG((PHYS_TO_VM_PAGE(pmap_pte2pa(opte)) == NULL),
 		    "managed page without PTE_PVLIST for %#"PRIxVADDR, va);
 		KASSERTMSG((pmap_pv_tracked(pmap_pte2pa(opte)) == NULL),
 		    "pv-tracked page without PTE_PVLIST for %#"PRIxVADDR, va);
 #endif
 		return true;
+	}
 	if ((pg = PHYS_TO_VM_PAGE(pmap_pte2pa(opte))) != NULL) {
-		KASSERT(uvm_page_locked_p(pg));
+		KASSERT(uvm_page_owner_locked_p(pg));
 		pp = VM_PAGE_TO_PP(pg);
 	} else if ((pp = pmap_pv_tracked(pmap_pte2pa(opte))) == NULL) {
 		paddr_t pa = pmap_pte2pa(opte);
 		panic("%s: PTE_PVLIST with pv-untracked page"
 		    " va = %#"PRIxVADDR"pa = %#"PRIxPADDR" (%#"PRIxPADDR")",
 		    __func__, va, pa, atop(pa));
+	}
 	/* Sync R/M bits. */
 	pp->pp_attrs |= pmap_pte_to_pp_attrs(opte);
 	pve = pmap_remove_pv(pp, ptp, va);
 	if (pve) {
 @@ -3858,27 +3858,27 @@ startover:
+}
 /*
  * pmap_page_remove: remove a managed vm_page from all pmaps that map it
+ *
  * => R/M bits are sync'd back to attrs
  */
 void
 pmap_page_remove(struct vm_page *pg)
+{
 	struct pmap_page *pp;
 	paddr_t pa;
-	KASSERT(uvm_page_locked_p(pg));
+	KASSERT(uvm_page_owner_locked_p(pg));
 	pp = VM_PAGE_TO_PP(pg);
 	pa = VM_PAGE_TO_PHYS(pg);
 	pmap_pp_remove(pp, pa);
+}
 /*
  * pmap_pv_remove: remove an unmanaged pv-tracked page from all pmaps
  * that map it
  */
 void
 pmap_pv_remove(paddr_t pa)
+{
 @@ -3899,27 +3899,27 @@ pmap_pv_remove(paddr_t pa)
 /*
  * pmap_test_attrs: test a page's attributes
  */
 bool
 pmap_test_attrs(struct vm_page *pg, unsigned testbits)
+{
 	struct pmap_page *pp;
 	struct pv_pte *pvpte;
 	uint8_t oattrs;
 	u_int result;
 	paddr_t pa;
-	KASSERT(uvm_page_locked_p(pg));
+	KASSERT(uvm_page_owner_locked_p(pg));
 	pp = VM_PAGE_TO_PP(pg);
 	if ((pp->pp_attrs & testbits) != 0) {
 		return true;
+	}
 	pa = VM_PAGE_TO_PHYS(pg);
 	kpreempt_disable();
 	for (pvpte = pv_pte_first(pp); pvpte; pvpte = pv_pte_next(pp, pvpte)) {
 		int error;
 		if ((pp->pp_attrs & testbits) != 0) {
 			break;
+		}
 @@ -3972,27 +3972,27 @@ startover:
+}
 /*
  * pmap_clear_attrs: clear the specified attribute for a page.
+ *
  * => we return true if we cleared one of the bits we were asked to
  */
 bool
 pmap_clear_attrs(struct vm_page *pg, unsigned clearbits)
+{
 	struct pmap_page *pp;
 	paddr_t pa;
-	KASSERT(uvm_page_locked_p(pg));
+	KASSERT(uvm_page_owner_locked_p(pg));
 	pp = VM_PAGE_TO_PP(pg);
 	pa = VM_PAGE_TO_PHYS(pg);
 	return pmap_pp_clear_attrs(pp, pa, clearbits);
+}
 /*
  * pmap_pv_clear_attrs: clear the specified attributes for an unmanaged
  * pv-tracked page.
  */
 bool
 pmap_pv_clear_attrs(paddr_t pa, unsigned clearbits)
 @@ -4364,27 +4364,27 @@ pmap_enter_ma(struct pmap *pmap, vaddr_t
 	/*
 	 * If the same page, we can skip pv_entry handling.
 	 */
 	if (((opte ^ npte) & (PTE_FRAME | PTE_P)) == 0) {
 		KASSERT(((opte ^ npte) & PTE_PVLIST) == 0);
 		goto same_pa;
+	}
 	/*
 	 * If old page is pv-tracked, remove pv_entry from its list.
 	 */
 	if ((~opte & (PTE_P | PTE_PVLIST)) == 0) {
 		if ((old_pg = PHYS_TO_VM_PAGE(oldpa)) != NULL) {
-			KASSERT(uvm_page_locked_p(old_pg));
+			KASSERT(uvm_page_owner_locked_p(old_pg));
 			old_pp = VM_PAGE_TO_PP(old_pg);
 		} else if ((old_pp = pmap_pv_tracked(oldpa)) == NULL) {
 			panic("%s: PTE_PVLIST with pv-untracked page"
 			    " va = %#"PRIxVADDR
 			    " pa = %#" PRIxPADDR " (%#" PRIxPADDR ")",
 			    __func__, va, oldpa, atop(pa));
+		}
 		old_pve = pmap_remove_pv(old_pp, ptp, va);
 		old_pp->pp_attrs |= pmap_pte_to_pp_attrs(opte);
+	}
 	/*
 @@ -5261,27 +5261,27 @@ pmap_ept_enter(struct pmap *pmap, vaddr_
 	/*
 	 * If the same page, we can skip pv_entry handling.
 	 */
 	if (((opte ^ npte) & (PTE_FRAME | EPT_R)) == 0) {
 		KASSERT(((opte ^ npte) & EPT_PVLIST) == 0);
 		goto same_pa;
+	}
 	/*
 	 * If old page is pv-tracked, remove pv_entry from its list.
 	 */
 	if ((~opte & (EPT_R | EPT_PVLIST)) == 0) {
 		if ((old_pg = PHYS_TO_VM_PAGE(oldpa)) != NULL) {
-			KASSERT(uvm_page_locked_p(old_pg));
+			KASSERT(uvm_page_owner_locked_p(old_pg));
 			old_pp = VM_PAGE_TO_PP(old_pg);
 		} else if ((old_pp = pmap_pv_tracked(oldpa)) == NULL) {
 			panic("%s: EPT_PVLIST with pv-untracked page"
 			    " va = %#"PRIxVADDR
 			    " pa = %#" PRIxPADDR " (%#" PRIxPADDR ")",
 			    __func__, va, oldpa, atop(pa));
+		}
 		old_pve = pmap_remove_pv(old_pp, ptp, va);
 		old_pp->pp_attrs |= pmap_ept_to_pp_attrs(opte);
+	}
 	/*
 @@ -5434,27 +5434,27 @@ pmap_ept_remove_pte(struct pmap *pmap, s
 	/*
 	 * If we are not on a pv_head list - we are done.
 	 */
 	if ((opte & EPT_PVLIST) == 0) {
 		KASSERTMSG((PHYS_TO_VM_PAGE(pmap_pte2pa(opte)) == NULL),
 		    "managed page without EPT_PVLIST for %#"PRIxVADDR, va);
 		KASSERTMSG((pmap_pv_tracked(pmap_pte2pa(opte)) == NULL),
 		    "pv-tracked page without EPT_PVLIST for %#"PRIxVADDR, va);
 		return true;
+	}
 	if ((pg = PHYS_TO_VM_PAGE(pmap_pte2pa(opte))) != NULL) {
-		KASSERT(uvm_page_locked_p(pg));
+		KASSERT(uvm_page_owner_locked_p(pg));
 		pp = VM_PAGE_TO_PP(pg);
 	} else if ((pp = pmap_pv_tracked(pmap_pte2pa(opte))) == NULL) {
 		paddr_t pa = pmap_pte2pa(opte);
 		panic("%s: EPT_PVLIST with pv-untracked page"
 		    " va = %#"PRIxVADDR"pa = %#"PRIxPADDR" (%#"PRIxPADDR")",
 		    __func__, va, pa, atop(pa));
+	}
 	/* Sync R/M bits. */
 	pp->pp_attrs |= pmap_ept_to_pp_attrs(opte);
 	pve = pmap_remove_pv(pp, ptp, va);
 	if (pve) {

 @@ -1,14 +1,14 @@
-/*	$NetBSD: genfs_io.c,v 1.81 2019/12/16 18:17:32 ad Exp $	*/
+/*	$NetBSD: genfs_io.c,v 1.82 2019/12/31 12:40:27 ad Exp $	*/
 /*
  * Copyright (c) 1982, 1986, 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -21,27 +21,27 @@
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: genfs_io.c,v 1.81 2019/12/16 18:17:32 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: genfs_io.c,v 1.82 2019/12/31 12:40:27 ad Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/kernel.h>
 #include <sys/mount.h>
 #include <sys/vnode.h>
 #include <sys/kmem.h>
 #include <sys/kauth.h>
 #include <sys/fstrans.h>
 #include <sys/buf.h>
 #include <miscfs/genfs/genfs.h>
 @@ -65,27 +65,27 @@ static void genfs_markdirty(struct vnode
 int genfs_maxdio = MAXPHYS;
 static void
 genfs_rel_pages(struct vm_page **pgs, unsigned int npages)
+{
 	unsigned int i;
 	for (i = 0; i < npages; i++) {
 		struct vm_page *pg = pgs[i];
 		if (pg == NULL || pg == PGO_DONTCARE)
 			continue;
-		KASSERT(uvm_page_locked_p(pg));
+		KASSERT(uvm_page_owner_locked_p(pg));
 		if (pg->flags & PG_FAKE) {
 			pg->flags |= PG_RELEASED;
+		}
+	}
 	uvm_page_unbusy(pgs, npages);
+}
 static void
 genfs_markdirty(struct vnode *vp)
+{
 	struct genfs_node * const gp = VTOG(vp);
 	KASSERT(mutex_owned(vp->v_interlock));

 @@ -1,14 +1,14 @@
-/*	$NetBSD: vm.c,v 1.177 2019/12/21 12:59:12 ad Exp $	*/
+/*	$NetBSD: vm.c,v 1.178 2019/12/31 12:40:27 ad Exp $	*/
 /*
  * Copyright (c) 2007-2011 Antti Kantee.  All Rights Reserved.
+ *
  * Development of this software was supported by
  * The Finnish Cultural Foundation and the Research Foundation of
  * The Helsinki University of Technology.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -31,27 +31,27 @@
 /*
  * Virtual memory emulation routines.
  */
 /*
  * XXX: we abuse pg->uanon for the virtual address of the storage
  * for each page.  phys_addr would fit the job description better,
  * except that it will create unnecessary lossage on some platforms
  * due to not being a pointer type.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vm.c,v 1.177 2019/12/21 12:59:12 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vm.c,v 1.178 2019/12/31 12:40:27 ad Exp $");
 #include <sys/param.h>
 #include <sys/atomic.h>
 #include <sys/buf.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/vmem.h>
 #include <sys/mman.h>
 #include <sys/null.h>
 #include <sys/vnode.h>
 #include <sys/radixtree.h>
 #include <machine/pmap.h>
 @@ -228,32 +228,32 @@ uvm_pagefree(struct vm_page *pg)
 	pool_cache_put(&pagecache, pg);
+}
 void
 uvm_pagezero(struct vm_page *pg)
+{
 	pg->flags &= ~PG_CLEAN;
 	memset((void *)pg->uanon, 0, PAGE_SIZE);
+}
 /*
- * uvm_page_locked_p: return true if object associated with page is
+ * uvm_page_owner_locked_p: return true if object associated with page is
  * locked.  this is a weak check for runtime assertions only.
  */
 bool
-uvm_page_locked_p(struct vm_page *pg)
+uvm_page_owner_locked_p(struct vm_page *pg)
+{
 	return mutex_owned(pg->uobject->vmobjlock);
+}
 /*
  * Misc routines
  */
 static kmutex_t pagermtx;
 void
 uvm_init(void)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_page.c,v 1.217 2019/12/30 17:45:53 ad Exp $	*/
+/*	$NetBSD: uvm_page.c,v 1.218 2019/12/31 12:40:27 ad Exp $	*/
 /*-
  * Copyright (c) 2019 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -85,27 +85,27 @@
  *  School of Computer Science
  *  Carnegie Mellon University
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 /*
  * uvm_page.c: page ops.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_page.c,v 1.217 2019/12/30 17:45:53 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_page.c,v 1.218 2019/12/31 12:40:27 ad Exp $");
 #include "opt_ddb.h"
 #include "opt_uvm.h"
 #include "opt_uvmhist.h"
 #include "opt_readahead.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/sched.h>
 #include <sys/kernel.h>
 #include <sys/vnode.h>
 #include <sys/proc.h>
 #include <sys/radixtree.h>
 @@ -1294,27 +1294,27 @@ uvm_pagealloc_strat(struct uvm_object *o
 	KASSERT((pg->flags & ~(PG_ZERO|PG_FREE)) == 0);
 	/*
 	 * assign the page to the object.  as the page was free, we know
 	 * that pg->uobject and pg->uanon are NULL.  we only need to take
 	 * the page's interlock if we are changing the values.
 	 */
 	if (anon != NULL || obj != NULL) {
 		mutex_enter(&pg->interlock);
+	}
 	pg->offset = off;
 	pg->uobject = obj;
 	pg->uanon = anon;
-	KASSERT(uvm_page_locked_p(pg));
+	KASSERT(uvm_page_owner_locked_p(pg));
 	pg->flags = PG_BUSY|PG_CLEAN|PG_FAKE;
 	if (anon) {
 		anon->an_page = pg;
 		pg->flags |= PG_ANON;
 		mutex_exit(&pg->interlock);
 	} else if (obj) {
 		uvm_pageinsert_object(obj, pg);
 		mutex_exit(&pg->interlock);
 		error = uvm_pageinsert_tree(obj, pg);
 		if (error != 0) {
 			mutex_enter(&pg->interlock);
 			uvm_pageremove_object(obj, pg);
 			mutex_exit(&pg->interlock);
 @@ -1626,27 +1626,27 @@ uvm_pagefree(struct vm_page *pg)
 void
 uvm_page_unbusy(struct vm_page **pgs, int npgs)
+{
 	struct vm_page *pg;
 	int i;
 	UVMHIST_FUNC("uvm_page_unbusy"); UVMHIST_CALLED(ubchist);
 	for (i = 0; i < npgs; i++) {
 		pg = pgs[i];
 		if (pg == NULL || pg == PGO_DONTCARE) {
 			continue;
+		}
-		KASSERT(uvm_page_locked_p(pg));
+		KASSERT(uvm_page_owner_locked_p(pg));
 		KASSERT(pg->flags & PG_BUSY);
 		KASSERT((pg->flags & PG_PAGEOUT) == 0);
 		if (pg->flags & PG_WANTED) {
 			/* XXXAD thundering herd problem. */
 			wakeup(pg);
+		}
 		if (pg->flags & PG_RELEASED) {
 			UVMHIST_LOG(ubchist, "releasing pg %#jx",
 			    (uintptr_t)pg, 0, 0, 0);
 			KASSERT(pg->uobject != NULL ||
 			    (pg->uanon != NULL && pg->uanon->an_ref > 0));
 			pg->flags &= ~PG_RELEASED;
 			uvm_pagefree(pg);
 @@ -1666,27 +1666,27 @@ uvm_page_unbusy(struct vm_page **pgs, in
+ *
  * => this is a debugging function that keeps track of who sets PG_BUSY
  *	and where they do it.   it can be used to track down problems
  *	such a process setting "PG_BUSY" and never releasing it.
  * => page's object [if any] must be locked
  * => if "tag" is NULL then we are releasing page ownership
  */
 void
 uvm_page_own(struct vm_page *pg, const char *tag)
+{
 	KASSERT((pg->flags & (PG_PAGEOUT|PG_RELEASED)) == 0);
 	KASSERT((pg->flags & PG_WANTED) == 0);
-	KASSERT(uvm_page_locked_p(pg));
+	KASSERT(uvm_page_owner_locked_p(pg));
 	/* gain ownership? */
 	if (tag) {
 		KASSERT((pg->flags & PG_BUSY) != 0);
 		if (pg->owner_tag) {
 			printf("uvm_page_own: page %p already owned "
 			    "by proc %d [%s]\n", pg,
 			    pg->owner, pg->owner_tag);
 			panic("uvm_page_own");
+		}
 		pg->owner = curproc->p_pid;
 		pg->lowner = curlwp->l_lid;
 		pg->owner_tag = tag;
 @@ -1740,27 +1740,27 @@ uvm_pagelookup(struct uvm_object *obj, v
 	return pg;
+}
 /*
  * uvm_pagewire: wire the page, thus removing it from the daemon's grasp
+ *
  * => caller must lock objects
  */
 void
 uvm_pagewire(struct vm_page *pg)
+{
-	KASSERT(uvm_page_locked_p(pg));
+	KASSERT(uvm_page_owner_locked_p(pg));
 #if defined(READAHEAD_STATS)
 	if ((pg->flags & PG_READAHEAD) != 0) {
 		uvm_ra_hit.ev_count++;
 		pg->flags &= ~PG_READAHEAD;
+	}
 #endif /* defined(READAHEAD_STATS) */
 	if (pg->wire_count == 0) {
 		uvm_pagedequeue(pg);
 		atomic_inc_uint(&uvmexp.wired);
+	}
 	mutex_enter(&pg->interlock);
 	pg->wire_count++;
 	mutex_exit(&pg->interlock);
 @@ -1768,107 +1768,107 @@ uvm_pagewire(struct vm_page *pg)
+}
 /*
  * uvm_pageunwire: unwire the page.
+ *
  * => activate if wire count goes to zero.
  * => caller must lock objects
  */
 void
 uvm_pageunwire(struct vm_page *pg)
+{
-	KASSERT(uvm_page_locked_p(pg));
+	KASSERT(uvm_page_owner_locked_p(pg));
 	KASSERT(pg->wire_count != 0);
 	KASSERT(!uvmpdpol_pageisqueued_p(pg));
 	mutex_enter(&pg->interlock);
 	pg->wire_count--;
 	mutex_exit(&pg->interlock);
 	if (pg->wire_count == 0) {
 		uvm_pageactivate(pg);
 		KASSERT(uvmexp.wired != 0);
 		atomic_dec_uint(&uvmexp.wired);
+	}
+}
 /*
  * uvm_pagedeactivate: deactivate page
+ *
  * => caller must lock objects
  * => caller must check to make sure page is not wired
  * => object that page belongs to must be locked (so we can adjust pg->flags)
  * => caller must clear the reference on the page before calling
  */
 void
 uvm_pagedeactivate(struct vm_page *pg)
+{
-	KASSERT(uvm_page_locked_p(pg));
+	KASSERT(uvm_page_owner_locked_p(pg));
 	if (pg->wire_count == 0) {
 		KASSERT(uvmpdpol_pageisqueued_p(pg));
 		uvmpdpol_pagedeactivate(pg);
+	}
+}
 /*
  * uvm_pageactivate: activate page
+ *
  * => caller must lock objects
  */
 void
 uvm_pageactivate(struct vm_page *pg)
+{
-	KASSERT(uvm_page_locked_p(pg));
+	KASSERT(uvm_page_owner_locked_p(pg));
 #if defined(READAHEAD_STATS)
 	if ((pg->flags & PG_READAHEAD) != 0) {
 		uvm_ra_hit.ev_count++;
 		pg->flags &= ~PG_READAHEAD;
+	}
 #endif /* defined(READAHEAD_STATS) */
 	if (pg->wire_count == 0) {
 		uvmpdpol_pageactivate(pg);
+	}
+}
 /*
  * uvm_pagedequeue: remove a page from any paging queue
+ *
  * => caller must lock objects
  */
 void
 uvm_pagedequeue(struct vm_page *pg)
+{
-	KASSERT(uvm_page_locked_p(pg));
+	KASSERT(uvm_page_owner_locked_p(pg));
 	if (uvmpdpol_pageisqueued_p(pg)) {
 		uvmpdpol_pagedequeue(pg);
+	}
+}
 /*
  * uvm_pageenqueue: add a page to a paging queue without activating.
  * used where a page is not really demanded (yet).  eg. read-ahead
+ *
  * => caller must lock objects
  */
 void
 uvm_pageenqueue(struct vm_page *pg)
+{
-	KASSERT(uvm_page_locked_p(pg));
+	KASSERT(uvm_page_owner_locked_p(pg));
 	if (pg->wire_count == 0 && !uvmpdpol_pageisqueued_p(pg)) {
 		uvmpdpol_pageenqueue(pg);
+	}
+}
 /*
  * uvm_pagezero: zero fill a page
+ *
  * => if page is part of an object then the object should be locked
  *	to protect pg->flags.
  */
 void
 @@ -1909,32 +1909,32 @@ uvm_pageismanaged(paddr_t pa)
  */
 int
 uvm_page_lookup_freelist(struct vm_page *pg)
+{
 	uvm_physseg_t upm;
 	upm = uvm_physseg_find(atop(VM_PAGE_TO_PHYS(pg)), NULL);
 	KASSERT(upm != UVM_PHYSSEG_TYPE_INVALID);
 	return uvm_physseg_get_free_list(upm);
+}
 /*
- * uvm_page_locked_p: return true if object associated with page is
+ * uvm_page_owner_locked_p: return true if object associated with page is
  * locked.  this is a weak check for runtime assertions only.
  */
 bool
-uvm_page_locked_p(struct vm_page *pg)
+uvm_page_owner_locked_p(struct vm_page *pg)
+{
 	if (pg->uobject != NULL) {
 		return mutex_owned(pg->uobject->vmobjlock);
+	}
 	if (pg->uanon != NULL) {
 		return mutex_owned(pg->uanon->an_lock);
+	}
 	return true;
+}
 #ifdef PMAP_DIRECT
 /*

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_page.h,v 1.90 2019/12/27 13:13:17 ad Exp $	*/
+/*	$NetBSD: uvm_page.h,v 1.91 2019/12/31 12:40:27 ad Exp $	*/
 /*
  * Copyright (c) 1997 Charles D. Cranor and Washington University.
  * Copyright (c) 1991, 1993, The Regents of the University of California.
+ *
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * The Mach Operating System project at Carnegie-Mellon University.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -102,27 +102,27 @@
  *        => flags set and cleared only with o&i held can
  *           safely be tested for with only o held.
  * o,i:	o|i for read, o&i for write (depends on context - if could be loaned)
  *	  => see uvm_loan.c
  * w:	wired page queue or uvm_pglistalloc:
  *	  => wired page queue: o&i to change, stable from wire to unwire
  *		XXX What about concurrent or nested wire?
  *	  => uvm_pglistalloc: owned by caller
  * ?:	locked by pmap or assumed page owner's lock
  * p:	locked by pagedaemon policy module (pdpolicy)
  * c:	cpu private
  * s:	stable, does not change
+ *
- * UVM and pmap(9) may use uvm_page_locked_p() to assert whether the
+ * UVM and pmap(9) may use uvm_page_owner_locked_p() to assert whether the
  * page owner's lock is acquired.
+ *
  * A page can have one of four identities:
+ *
  * o free
  *   => pageq.list is entry on global free page queue
  *   => uanon is unused (or (void *)0xdeadbeef for DEBUG)
  *   => uobject is unused (or (void *)0xdeadbeef for DEBUG)
  *   => PG_FREE is set in flags
  * o owned by a uvm_object
  *   => pageq.queue is entry on wired page queue, if any
  *   => uanon is NULL or the vm_anon to which it has been O->A loaned
  *   => uobject is owner
 @@ -301,27 +301,27 @@ void uvm_pageidlezero(void);
 void uvm_pageactivate(struct vm_page *);
 vaddr_t uvm_pageboot_alloc(vsize_t);
 void uvm_pagecopy(struct vm_page *, struct vm_page *);
 void uvm_pagedeactivate(struct vm_page *);
 void uvm_pagedequeue(struct vm_page *);
 void uvm_pageenqueue(struct vm_page *);
 void uvm_pagefree(struct vm_page *);
 void uvm_page_unbusy(struct vm_page **, int);
 struct vm_page *uvm_pagelookup(struct uvm_object *, voff_t);
 void uvm_pageunwire(struct vm_page *);
 void uvm_pagewire(struct vm_page *);
 void uvm_pagezero(struct vm_page *);
 bool uvm_pageismanaged(paddr_t);
-bool uvm_page_locked_p(struct vm_page *);
+bool uvm_page_owner_locked_p(struct vm_page *);
 void uvm_pgfl_lock(void);
 void uvm_pgfl_unlock(void);
 int uvm_page_lookup_freelist(struct vm_page *);
 struct vm_page *uvm_phys_to_vm_page(paddr_t);
 paddr_t uvm_vm_page_to_phys(const struct vm_page *);
 #if defined(PMAP_DIRECT)
 extern bool ubc_direct;
 int uvm_direct_process(struct vm_page **, u_int, voff_t, vsize_t,
 	    int (*)(void *, size_t, void *), void *);
 #endif

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_pdaemon.c,v 1.119 2019/12/30 18:08:37 ad Exp $	*/
+/*	$NetBSD: uvm_pdaemon.c,v 1.120 2019/12/31 12:40:27 ad Exp $	*/
 /*
  * Copyright (c) 1997 Charles D. Cranor and Washington University.
  * Copyright (c) 1991, 1993, The Regents of the University of California.
+ *
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * The Mach Operating System project at Carnegie-Mellon University.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -56,27 +56,27 @@
  *  School of Computer Science
  *  Carnegie Mellon University
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 /*
  * uvm_pdaemon.c: the page daemon
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_pdaemon.c,v 1.119 2019/12/30 18:08:37 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_pdaemon.c,v 1.120 2019/12/31 12:40:27 ad Exp $");
 #include "opt_uvmhist.h"
 #include "opt_readahead.h"
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/pool.h>
 #include <sys/buf.h>
 #include <sys/module.h>
 #include <sys/atomic.h>
 #include <sys/kthread.h>
 @@ -689,27 +689,27 @@ uvmpd_scan_queue(void)
 		 * the only time we expect to see an ownerless page
 		 * (i.e. a page with no uobject and !PG_ANON) is if an
 		 * anon has loaned a page from a uvm_object and the
 		 * uvm_object has dropped the ownership.  in that
 		 * case, the anon can "take over" the loaned page
 		 * and make it its own.
 		 */
 		p = uvmpdpol_selectvictim(&slock);
 		if (p == NULL) {
 			break;
+		}
 		KASSERT(uvmpdpol_pageisqueued_p(p));
-		KASSERT(uvm_page_locked_p(p));
+		KASSERT(uvm_page_owner_locked_p(p));
 		KASSERT(p->wire_count == 0);
 		/*
 		 * we are below target and have a new page to consider.
 		 */
 		anon = p->uanon;
 		uobj = p->uobject;
 		if (p->flags & PG_BUSY) {
 			mutex_exit(slock);
 			uvmexp.pdbusy++;
 			continue;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_pdpolicy_clock.c,v 1.25 2019/12/30 18:18:03 ad Exp $	*/
+/*	$NetBSD: uvm_pdpolicy_clock.c,v 1.26 2019/12/31 12:40:27 ad Exp $	*/
 /*	NetBSD: uvm_pdaemon.c,v 1.72 2006/01/05 10:47:33 yamt Exp $	*/
 /*
  * Copyright (c) 1997 Charles D. Cranor and Washington University.
  * Copyright (c) 1991, 1993, The Regents of the University of California.
+ *
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * The Mach Operating System project at Carnegie-Mellon University.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 @@ -59,27 +59,27 @@
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 #if defined(PDSIM)
 #include "pdsim.h"
 #else /* defined(PDSIM) */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_pdpolicy_clock.c,v 1.25 2019/12/30 18:18:03 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_pdpolicy_clock.c,v 1.26 2019/12/31 12:40:27 ad Exp $");
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <uvm/uvm.h>
 #include <uvm/uvm_pdpolicy.h>
 #include <uvm/uvm_pdpolicy_impl.h>
 #include <uvm/uvm_stat.h>
 #endif /* defined(PDSIM) */
 @@ -388,27 +388,27 @@ uvmpdpol_balancequeue(int swap_shortage)
 			uvmexp.pddeact++;
 			inactive_shortage--;
+		}
 		mutex_exit(lock);
+	}
 	TAILQ_REMOVE(&pdpol_state.s_activeq, &marker, pdqueue);
 	mutex_exit(&s->lock);
+}
 static void
 uvmpdpol_pagedeactivate_locked(struct vm_page *pg)
+{
-	KASSERT(uvm_page_locked_p(pg));
+	KASSERT(uvm_page_owner_locked_p(pg));
 	if (pg->pqflags & PQ_ACTIVE) {
 		TAILQ_REMOVE(&pdpol_state.s_activeq, pg, pdqueue);
 		pg->pqflags &= ~(PQ_ACTIVE | PQ_TIME);
 		KASSERT(pdpol_state.s_active > 0);
 		pdpol_state.s_active--;
+	}
 	if ((pg->pqflags & PQ_INACTIVE) == 0) {
 		KASSERT(pg->wire_count == 0);
 		pmap_clear_reference(pg);
 		TAILQ_INSERT_TAIL(&pdpol_state.s_inactiveq, pg, pdqueue);
 		pg->pqflags |= PQ_INACTIVE;
 		pdpol_state.s_inactive++;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_pdpolicy_clockpro.c,v 1.20 2019/12/30 18:08:38 ad Exp $	*/
+/*	$NetBSD: uvm_pdpolicy_clockpro.c,v 1.21 2019/12/31 12:40:27 ad Exp $	*/
 /*-
  * Copyright (c)2005, 2006 YAMAMOTO Takashi,
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -33,27 +33,27 @@
  * approximation of the list of non-resident pages using hash:
  *	http://linux-mm.org/ClockProApproximation
  */
 /* #define	CLOCKPRO_DEBUG */
 #if defined(PDSIM)
 #include "pdsim.h"
 #else /* defined(PDSIM) */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_pdpolicy_clockpro.c,v 1.20 2019/12/30 18:08:38 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_pdpolicy_clockpro.c,v 1.21 2019/12/31 12:40:27 ad Exp $");
 #include "opt_ddb.h"
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/hash.h>
 #include <uvm/uvm.h>
 #include <uvm/uvm_pdaemon.h>	/* for uvmpd_trylockowner */
 #include <uvm/uvm_pdpolicy.h>
 #include <uvm/uvm_pdpolicy_impl.h>
 @@ -633,27 +633,27 @@ clockpro_tune(void)
 	s->s_newqlenmax = coldtarget / 4;
 	if (s->s_newqlenmax < CLOCKPRO_NEWQMIN) {
 		s->s_newqlenmax = CLOCKPRO_NEWQMIN;
+	}
+}
 static void
 clockpro_movereferencebit(struct vm_page *pg, bool locked)
+{
 	kmutex_t *lock;
 	bool referenced;
 	KASSERT(mutex_owned(&clockpro.lock));
-	KASSERT(!locked || uvm_page_locked_p(pg));
+	KASSERT(!locked || uvm_page_owner_locked_p(pg));
 	if (!locked) {
 		/*
 		 * acquire interlock to stablize page identity.
 		 * if we have caught the page in a state of flux
 		 * and it should be dequeued, abort.  it will be
 		 * dequeued later.
 		 */
 		mutex_enter(&pg->interlock);
 	        if ((pg->uobject == NULL && pg->uanon == NULL) ||
 	            pg->wire_count > 0) {
 	            	mutex_exit(&pg->interlock);
 			PDPOL_EVCNT_INCR(lockfail);
 			return;