 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_amap.c,v 1.125 2020/09/21 18:41:59 chs Exp $	*/
+/*	$NetBSD: uvm_amap.c,v 1.126 2021/03/13 15:29:55 skrll Exp $	*/
 /*
  * Copyright (c) 1997 Charles D. Cranor and Washington University.
  * 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.
 @@ -25,27 +25,27 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * uvm_amap.c: amap operations
  */
 /*
  * this file contains functions that perform operations on amaps.  see
  * uvm_amap.h for a brief explanation of the role of amaps in uvm.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_amap.c,v 1.125 2020/09/21 18:41:59 chs Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_amap.c,v 1.126 2021/03/13 15:29:55 skrll Exp $");
 #include "opt_uvmhist.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/pool.h>
 #include <sys/atomic.h>
 #include <uvm/uvm.h>
 #include <uvm/uvm_swap.h>
 @@ -817,27 +817,27 @@ amap_wipeout(struct vm_amap *amap)
  */
 void
 amap_copy(struct vm_map *map, struct vm_map_entry *entry, int flags,
     vaddr_t startva, vaddr_t endva)
+{
 	const int waitf = (flags & AMAP_COPY_NOWAIT) ? UVM_FLAG_NOWAIT : 0;
 	struct vm_amap *amap, *srcamap;
 	u_int slots, lcv;
 	krwlock_t *oldlock;
 	vsize_t len;
 	UVMHIST_FUNC(__func__);
-	UVMHIST_CALLARGS(maphist, "  (map=%#j, entry=%#j, flags=%jd)",
+	UVMHIST_CALLARGS(maphist, "  (map=%#jx, entry=%#jx, flags=%#jx)",
 	    (uintptr_t)map, (uintptr_t)entry, flags, -2);
 	KASSERT(map != kernel_map);	/* we use nointr pool */
 	srcamap = entry->aref.ar_amap;
 	len = entry->end - entry->start;
 	/*
 	 * Is there an amap to copy?  If not, create one.
 	 */
 	if (srcamap == NULL) {
 		const bool canchunk = (flags & AMAP_COPY_NOCHUNK) == 0;
 @@ -893,27 +893,27 @@ amap_copy(struct vm_map *map, struct vm_
 	 * of copying it.  Note that we are reading am_ref without lock held
 	 * as the value value can only be one if we have the only reference
 	 * to the amap (via our locked map).  If the value is greater than
 	 * one, then allocate amap and re-check the value.
 	 */
 	if (srcamap->am_ref == 1) {
 		entry->etype &= ~UVM_ET_NEEDSCOPY;
 		UVMHIST_LOG(maphist, "<- done [ref cnt = 1, took it over]",
 , 0, 0, 0);
 		return;
+	}
-	UVMHIST_LOG(maphist,"  amap=%#j, ref=%jd, must copy it",
+	UVMHIST_LOG(maphist,"  amap=%#jx, ref=%jd, must copy it",
 	    (uintptr_t)srcamap, srcamap->am_ref, 0, 0);
 	/*
 	 * Allocate a new amap (note: not initialised, etc).
 	 */
 	AMAP_B2SLOT(slots, len);
 	amap = amap_alloc1(slots, 0, waitf);
 	if (amap == NULL) {
 		UVMHIST_LOG(maphist, "  amap_alloc1 failed", 0,0,0,0);
 		return;
+	}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_aobj.c,v 1.152 2020/11/04 01:30:19 chs Exp $	*/
+/*	$NetBSD: uvm_aobj.c,v 1.153 2021/03/13 15:29:55 skrll Exp $	*/
 /*
  * Copyright (c) 1998 Chuck Silvers, Charles D. Cranor and
  *                    Washington University.
  * 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
 @@ -28,27 +28,27 @@
  * from: Id: uvm_aobj.c,v 1.1.2.5 1998/02/06 05:14:38 chs Exp
  */
 /*
  * uvm_aobj.c: anonymous memory uvm_object pager
+ *
  * author: Chuck Silvers <chuq@chuq.com>
  * started: Jan-1998
+ *
  * - design mostly from Chuck Cranor
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_aobj.c,v 1.152 2020/11/04 01:30:19 chs Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_aobj.c,v 1.153 2021/03/13 15:29:55 skrll Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_uvmhist.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/pool.h>
 #include <sys/atomic.h>
 #include <uvm/uvm.h>
 @@ -800,27 +800,27 @@ uao_put(struct uvm_object *uobj, voff_t
  */
 static int
 uao_get(struct uvm_object *uobj, voff_t offset, struct vm_page **pps,
     int *npagesp, int centeridx, vm_prot_t access_type, int advice, int flags)
+{
 	voff_t current_offset;
 	struct vm_page *ptmp;
 	int lcv, gotpages, maxpages, swslot, pageidx;
 	bool overwrite = ((flags & PGO_OVERWRITE) != 0);
 	struct uvm_page_array a;
 	UVMHIST_FUNC(__func__);
-	UVMHIST_CALLARGS(pdhist, "aobj=%#jx offset=%jd, flags=%jd",
+	UVMHIST_CALLARGS(pdhist, "aobj=%#jx offset=%jd, flags=%#jx",
 		    (uintptr_t)uobj, offset, flags,0);
 	/*
 	 * the object must be locked.  it can only be a read lock when
 	 * processing a read fault with PGO_LOCKED.
 	 */
 	KASSERT(UVM_OBJ_IS_AOBJ(uobj));
 	KASSERT(rw_lock_held(uobj->vmobjlock));
 	KASSERT(rw_write_held(uobj->vmobjlock) ||
 	   ((flags & PGO_LOCKED) != 0 && (access_type & VM_PROT_WRITE) == 0));
 	/*

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_bio.c,v 1.124 2020/11/10 04:27:22 chs Exp $	*/
+/*	$NetBSD: uvm_bio.c,v 1.125 2021/03/13 15:29:55 skrll Exp $	*/
 /*
  * Copyright (c) 1998 Chuck Silvers.
  * 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.
 @@ -24,27 +24,27 @@
  * 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.
+ *
  */
 /*
  * uvm_bio.c: buffered i/o object mapping cache
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_bio.c,v 1.124 2020/11/10 04:27:22 chs Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_bio.c,v 1.125 2021/03/13 15:29:55 skrll Exp $");
 #include "opt_uvmhist.h"
 #include "opt_ubc.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kmem.h>
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/vnode.h>
 #include <sys/bitops.h>		/* for ilog2() */
 #include <uvm/uvm.h>
 @@ -332,27 +332,27 @@ ubc_fault(struct uvm_faultinfo *ufi, vad
 	slot_offset = ubc_offset & (ubc_winsize - 1);
 	/*
 	 * some platforms cannot write to individual bytes atomically, so
 	 * software has to do read/modify/write of larger quantities instead.
 	 * this means that the access_type for "write" operations
 	 * can be VM_PROT_READ, which confuses us mightily.
+	 *
 	 * deal with this by resetting access_type based on the info
 	 * that ubc_alloc() stores for us.
 	 */
 	access_type = umap->writelen ? VM_PROT_WRITE : VM_PROT_READ;
-	UVMHIST_LOG(ubchist, "va 0x%jx ubc_offset 0x%jx access_type %jd",
+	UVMHIST_LOG(ubchist, "va %#jx ubc_offset %#jx access_type %jd",
 	    va, ubc_offset, access_type, 0);
 	if ((access_type & VM_PROT_WRITE) != 0) {
 #ifndef PRIxOFF		/* XXX */
 #define PRIxOFF "jx"	/* XXX */
 #endif			/* XXX */
 		KASSERTMSG((trunc_page(umap->writeoff) <= slot_offset),
 		    "out of range write: slot=%#"PRIxVSIZE" off=%#"PRIxOFF,
 		    slot_offset, (intmax_t)umap->writeoff);
 		KASSERTMSG((slot_offset < umap->writeoff + umap->writelen),
 		    "out of range write: slot=%#"PRIxVADDR
 		        " off=%#"PRIxOFF" len=%#"PRIxVSIZE,
 		    slot_offset, (intmax_t)umap->writeoff, umap->writelen);
 @@ -364,29 +364,29 @@ ubc_fault(struct uvm_faultinfo *ufi, vad
 	if ((access_type & VM_PROT_WRITE) == 0) {
 		npages = (ubc_winsize - slot_offset) >> PAGE_SHIFT;
 	} else {
 		npages = (round_page(umap->offset + umap->writeoff +
 		    umap->writelen) - (umap->offset + slot_offset))
 		    >> PAGE_SHIFT;
 		flags |= PGO_PASTEOF;
+	}
 again:
 	memset(pgs, 0, sizeof (pgs));
 	rw_enter(uobj->vmobjlock, RW_WRITER);
-	UVMHIST_LOG(ubchist, "slot_offset 0x%jx writeoff 0x%jx writelen 0x%jx ",
+	UVMHIST_LOG(ubchist, "slot_offset %#jx writeoff %#jx writelen %#jx ",
 	    slot_offset, umap->writeoff, umap->writelen, 0);
-	UVMHIST_LOG(ubchist, "getpages uobj %#jx offset 0x%jx npages %jd",
+	UVMHIST_LOG(ubchist, "getpages uobj %#jx offset %#jx npages %jd",
 	    (uintptr_t)uobj, umap->offset + slot_offset, npages, 0);
 	error = (*uobj->pgops->pgo_get)(uobj, umap->offset + slot_offset, pgs,
 	    &npages, 0, access_type, umap->advice, flags | PGO_NOBLOCKALLOC |
 	    PGO_NOTIMESTAMP);
 	UVMHIST_LOG(ubchist, "getpages error %jd npages %jd", error, npages, 0,
 );
 	if (error == EAGAIN) {
 		kpause("ubc_fault", false, hz >> 2, NULL);
 		goto again;
+	}
 	if (error) {
 @@ -399,27 +399,27 @@ again:
 	 * since the "compatible alias" trick does not work on such caches.
 	 * Otherwise, we can always map the pages writable.
 	 */
 #ifdef PMAP_CACHE_VIVT
 	prot = VM_PROT_READ | access_type;
 #else
 	prot = VM_PROT_READ | VM_PROT_WRITE;
 #endif
 	va = ufi->orig_rvaddr;
 	eva = ufi->orig_rvaddr + (npages << PAGE_SHIFT);
-	UVMHIST_LOG(ubchist, "va 0x%jx eva 0x%jx", va, eva, 0, 0);
+	UVMHIST_LOG(ubchist, "va %#jx eva %#jx", va, eva, 0, 0);
 	/*
 	 * Note: normally all returned pages would have the same UVM object.
 	 * However, layered file-systems and e.g. tmpfs, may return pages
 	 * which belong to underlying UVM object.  In such case, lock is
 	 * shared amongst the objects.
 	 */
 	rw_enter(uobj->vmobjlock, RW_WRITER);
 	for (i = 0; va < eva; i++, va += PAGE_SIZE) {
 		struct vm_page *pg;
 		UVMHIST_LOG(ubchist, "pgs[%jd] = %#jx", i, (uintptr_t)pgs[i],
 , 0);
 @@ -473,27 +473,27 @@ ubc_find_mapping(struct uvm_object *uobj
 /*
  * ubc_alloc:  allocate a file mapping window
  */
 static void * __noinline
 ubc_alloc(struct uvm_object *uobj, voff_t offset, vsize_t *lenp, int advice,
     int flags, struct vm_page **pgs, int *npagesp)
+{
 	vaddr_t slot_offset, va;
 	struct ubc_map *umap;
 	voff_t umap_offset;
 	int error;
 	UVMHIST_FUNC(__func__);
-	UVMHIST_CALLARGS(ubchist, "uobj %#jx offset 0x%jx len 0x%jx",
+	UVMHIST_CALLARGS(ubchist, "uobj %#jx offset %#jx len %#jx",
 	    (uintptr_t)uobj, offset, *lenp, 0);
 	KASSERT(*lenp > 0);
 	umap_offset = (offset & ~((voff_t)ubc_winsize - 1));
 	slot_offset = (vaddr_t)(offset & ((voff_t)ubc_winsize - 1));
 	*lenp = MIN(*lenp, ubc_winsize - slot_offset);
 	KASSERT(*lenp > 0);
 	rw_enter(ubc_object.uobj.vmobjlock, RW_WRITER);
 again:
 	/*
 	 * The UVM object is already referenced.
 	 * Lock order: UBC object -> ubc_map::uobj.
 @@ -550,27 +550,27 @@ again:
 		TAILQ_REMOVE(UBC_QUEUE(offset), umap, inactive);
+	}
 	if (flags & UBC_WRITE) {
 		KASSERTMSG(umap->writeoff == 0 && umap->writelen == 0,
 		    "ubc_alloc: concurrent writes to uobj %p", uobj);
 		umap->writeoff = slot_offset;
 		umap->writelen = *lenp;
+	}
 	umap->refcount++;
 	umap->advice = advice;
 	rw_exit(ubc_object.uobj.vmobjlock);
-	UVMHIST_LOG(ubchist, "umap %#jx refs %jd va %#jx flags 0x%jx",
+	UVMHIST_LOG(ubchist, "umap %#jx refs %jd va %#jx flags %#jx",
 	    (uintptr_t)umap, umap->refcount, (uintptr_t)va, flags);
 	if (flags & UBC_FAULTBUSY) {
 		int npages = (*lenp + (offset & (PAGE_SIZE - 1)) +
 		    PAGE_SIZE - 1) >> PAGE_SHIFT;
 		int gpflags =
 		    PGO_SYNCIO|PGO_OVERWRITE|PGO_PASTEOF|PGO_NOBLOCKALLOC|
 		    PGO_NOTIMESTAMP;
 		int i;
 		KDASSERT(flags & UBC_WRITE);
 		KASSERT(npages <= *npagesp);
 		KASSERT(umap->refcount == 1);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_device.c,v 1.71 2020/07/09 05:57:15 skrll Exp $	*/
+/*	$NetBSD: uvm_device.c,v 1.72 2021/03/13 15:29:55 skrll Exp $	*/
 /*
  * Copyright (c) 1997 Charles D. Cranor and Washington University.
  * 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.
 @@ -22,27 +22,27 @@
  * 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.
+ *
  * from: Id: uvm_device.c,v 1.1.2.9 1998/02/06 05:11:47 chs Exp
  */
 /*
  * uvm_device.c: the device pager.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_device.c,v 1.71 2020/07/09 05:57:15 skrll Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_device.c,v 1.72 2021/03/13 15:29:55 skrll Exp $");
 #include "opt_uvmhist.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/conf.h>
 #include <sys/proc.h>
 #include <sys/kmem.h>
 #include <uvm/uvm.h>
 #include <uvm/uvm_device.h>
 #include <uvm/uvm_pmap.h>
 @@ -354,27 +354,27 @@ udv_fault(struct uvm_faultinfo *ufi, vad
     int flags)
+{
 	struct vm_map_entry *entry = ufi->entry;
 	struct uvm_object *uobj = entry->object.uvm_obj;
 	struct uvm_device *udv = (struct uvm_device *)uobj;
 	vaddr_t curr_va;
 	off_t curr_offset;
 	paddr_t paddr, mdpgno;
 	u_int mmapflags;
 	int lcv, retval;
 	dev_t device;
 	vm_prot_t mapprot;
 	UVMHIST_FUNC(__func__); UVMHIST_CALLED(maphist);
-	UVMHIST_LOG(maphist,"  flags=%jd", flags,0,0,0);
+	UVMHIST_LOG(maphist,"  flags=%#jx", flags,0,0,0);
 	/*
 	 * we do not allow device mappings to be mapped copy-on-write
 	 * so we kill any attempt to do so here.
 	 */
 	if (UVM_ET_ISCOPYONWRITE(entry)) {
 		UVMHIST_LOG(maphist, "<- failed -- COW entry (etype=%#jx)",
 		    entry->etype, 0,0,0);
 		uvmfault_unlockall(ufi, ufi->entry->aref.ar_amap, uobj);
 		return(EIO);
+	}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_km.c,v 1.159 2020/07/09 05:57:15 skrll Exp $	*/
+/*	$NetBSD: uvm_km.c,v 1.160 2021/03/13 15:29:55 skrll 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:
 @@ -142,27 +142,27 @@
  * kmem_meta_arena:
  *	Imports from kmem_va_meta_arena.  Allocations from this arena are
  *	backed with the pages.
+ *
  * Arena stacking:
+ *
  *	kmem_arena
  *		kmem_va_arena
  *		kmem_va_meta_arena
  *			kmem_meta_arena
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_km.c,v 1.159 2020/07/09 05:57:15 skrll Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_km.c,v 1.160 2021/03/13 15:29:55 skrll Exp $");
 #include "opt_uvmhist.h"
 #include "opt_kmempages.h"
 #ifndef NKMEMPAGES
 #define NKMEMPAGES 0
 #endif
 /*
  * Defaults for lower and upper-bounds for the kmem_arena page count.
  * Can be overridden by kernel config options.
  */
 @@ -608,27 +608,27 @@ uvm_km_alloc(struct vm_map *map, vsize_t
 	KASSERT((flags & UVM_KMF_TYPEMASK) == UVM_KMF_WIRED ||
 		(flags & UVM_KMF_TYPEMASK) == UVM_KMF_PAGEABLE ||
 		(flags & UVM_KMF_TYPEMASK) == UVM_KMF_VAONLY);
 	KASSERT((flags & UVM_KMF_VAONLY) != 0 || (flags & UVM_KMF_COLORMATCH) == 0);
 	KASSERT((flags & UVM_KMF_COLORMATCH) == 0 || (flags & UVM_KMF_VAONLY) != 0);
 	/*
 	 * setup for call
 	 */
 	kva = vm_map_min(map);	/* hint */
 	size = round_page(size);
 	obj = (flags & UVM_KMF_PAGEABLE) ? uvm_kernel_object : NULL;
-	UVMHIST_LOG(maphist,"  (map=%#jx, obj=%#jx, size=%#jx, flags=%jd)",
+	UVMHIST_LOG(maphist,"  (map=%#jx, obj=%#jx, size=%#jx, flags=%#jx)",
 	    (uintptr_t)map, (uintptr_t)obj, size, flags);
 	/*
 	 * allocate some virtual space
 	 */
 	vaprot = (flags & UVM_KMF_EXEC) ? UVM_PROT_ALL : UVM_PROT_RW;
 	if (__predict_false(uvm_map(map, &kva, size, obj, UVM_UNKNOWN_OFFSET,
 	    align, UVM_MAPFLAG(vaprot, UVM_PROT_ALL, UVM_INH_NONE,
 	    UVM_ADV_RANDOM,
 	    (flags & (UVM_KMF_TRYLOCK | UVM_KMF_NOWAIT | UVM_KMF_WAITVA
 	     | UVM_KMF_COLORMATCH)))) != 0)) {
 		UVMHIST_LOG(maphist, "<- done (no VM)",0,0,0,0);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_map.c,v 1.385 2020/07/09 05:57:15 skrll Exp $	*/
+/*	$NetBSD: uvm_map.c,v 1.386 2021/03/13 15:29:55 skrll 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_map.c: uvm map operations
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_map.c,v 1.385 2020/07/09 05:57:15 skrll Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_map.c,v 1.386 2021/03/13 15:29:55 skrll Exp $");
 #include "opt_ddb.h"
 #include "opt_pax.h"
 #include "opt_uvmhist.h"
 #include "opt_uvm.h"
 #include "opt_sysv.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/mman.h>
 #include <sys/proc.h>
 #include <sys/pool.h>
 #include <sys/kernel.h>
 @@ -796,27 +796,27 @@ uvm_mapent_alloc(struct vm_map *map, int
 	UVMHIST_LOG(maphist, "<- new entry=%#jx [kentry=%jd]", (uintptr_t)me,
 	    (map == kernel_map), 0, 0);
 	return me;
+}
 /*
  * uvm_mapent_free: free map entry
  */
 static void
 uvm_mapent_free(struct vm_map_entry *me)
+{
 	UVMHIST_FUNC(__func__);
-	UVMHIST_CALLARGS(maphist,"<- freeing map entry=%#jx [flags=%jd]",
+	UVMHIST_CALLARGS(maphist,"<- freeing map entry=%#jx [flags=%#jx]",
 		(uintptr_t)me, me->flags, 0, 0);
 	pool_cache_put(&uvm_map_entry_cache, me);
+}
 /*
  * uvm_mapent_copy: copy a map entry, preserving flags
  */
 static inline void
 uvm_mapent_copy(struct vm_map_entry *src, struct vm_map_entry *dst)
+{
 	memcpy(dst, src, sizeof(*dst));
 @@ -2105,29 +2105,29 @@ nextgap:
 			entry = entry->next;
 			if (entry == &map->header) {
 				UVMHIST_LOG(maphist, "<- failed (off end)",
 ,0,0,0);
 				goto notfound;
+			}
+		}
+	}
  found:
 	SAVE_HINT(map, map->hint, entry);
 	*result = hint;
 	UVMHIST_LOG(maphist,"<- got it!  (result=%#jx)", hint, 0,0,0);
-	KASSERTMSG( topdown || hint >= orig_hint, "hint: %jx, orig_hint: %jx",
+	KASSERTMSG( topdown || hint >= orig_hint, "hint: %#jx, orig_hint: %#jx",
 	    (uintmax_t)hint, (uintmax_t)orig_hint);
-	KASSERTMSG(!topdown || hint <= orig_hint, "hint: %jx, orig_hint: %jx",
+	KASSERTMSG(!topdown || hint <= orig_hint, "hint: %#jx, orig_hint: %#jx",
 	    (uintmax_t)hint, (uintmax_t)orig_hint);
 	KASSERT(entry->end <= hint);
 	KASSERT(hint + length <= entry->next->start);
 	return (entry);
  wraparound:
 	UVMHIST_LOG(maphist, "<- failed (wrap around)", 0,0,0,0);
 	return (NULL);
  notfound:
 	UVMHIST_LOG(maphist, "<- failed (notfound)", 0,0,0,0);
 @@ -4801,27 +4801,27 @@ do {									\
  * => acquires a reference on the page's owner (uvm_object or vm_anon)
  */
 bool
 uvm_voaddr_acquire(struct vm_map * const map, vaddr_t const va,
     struct uvm_voaddr * const voaddr)
+{
 	struct vm_map_entry *entry;
 	struct vm_anon *anon = NULL;
 	bool result = false;
 	bool exclusive = false;
 	void (*unlock_fn)(struct vm_map *);
 	UVMHIST_FUNC(__func__); UVMHIST_CALLED(maphist);
-	UVMHIST_LOG(maphist,"(map=%#jx,va=%jx)", (uintptr_t)map, va, 0, 0);
+	UVMHIST_LOG(maphist,"(map=%#jx,va=%#jx)", (uintptr_t)map, va, 0, 0);
 	const vaddr_t start = trunc_page(va);
 	const vaddr_t end = round_page(va+1);
  lookup_again:
 	if (__predict_false(exclusive)) {
 		vm_map_lock(map);
 		unlock_fn = vm_map_unlock;
 	} else {
 		vm_map_lock_read(map);
 		unlock_fn = vm_map_unlock_read;
+	}
 @@ -4959,27 +4959,27 @@ uvm_voaddr_acquire(struct vm_map * const
 		struct uvm_object *uobj = entry->object.uvm_obj;
 		KASSERT(uobj != NULL);
 		(*uobj->pgops->pgo_reference)(uobj);
 		UVM_VOADDR_SET_UOBJ(voaddr, uobj);
 		voaddr->offset = entry->offset + (va - entry->start);
 		result = true;
+	}
 	unlock_fn(map);
 	if (result) {
 		UVMHIST_LOG(maphist,
-		    "<- done OK (type=%jd,owner=#%jx,offset=%jx)",
+		    "<- done OK (type=%jd,owner=%#jx,offset=%#jx)",
 		    UVM_VOADDR_GET_TYPE(voaddr),
 		    UVM_VOADDR_GET_OBJECT(voaddr),
 		    voaddr->offset, 0);
 	} else {
 		UVMHIST_LOG(maphist,"<- done (failed)",0,0,0,0);
+	}
 	return result;
+}
 /*
  * uvm_voaddr_release: release the references held by the
  * vitual object address.

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_swap.c,v 1.202 2021/02/19 13:20:43 hannken Exp $	*/
+/*	$NetBSD: uvm_swap.c,v 1.203 2021/03/13 15:29:55 skrll Exp $	*/
 /*
  * Copyright (c) 1995, 1996, 1997, 2009 Matthew R. Green
  * 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.
 @@ -20,27 +20,27 @@
  * 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.
+ *
  * from: NetBSD: vm_swap.c,v 1.52 1997/12/02 13:47:37 pk Exp
  * from: Id: uvm_swap.c,v 1.1.2.42 1998/02/02 20:38:06 chuck Exp
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_swap.c,v 1.202 2021/02/19 13:20:43 hannken Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_swap.c,v 1.203 2021/03/13 15:29:55 skrll Exp $");
 #include "opt_uvmhist.h"
 #include "opt_compat_netbsd.h"
 #include "opt_ddb.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/atomic.h>
 #include <sys/buf.h>
 #include <sys/bufq.h>
 #include <sys/conf.h>
 #include <sys/cprng.h>
 #include <sys/proc.h>
 @@ -923,27 +923,27 @@ swap_on(struct lwp *l, struct swapdev *s
+	}
 	/*
 	 * make sure we have enough blocks for a reasonable sized swap
 	 * area.   we want at least one page.
 	 */
 	if (size < 1) {
 		UVMHIST_LOG(pdhist, "  size <= 1!!", 0, 0, 0, 0);
 		error = EINVAL;
 		goto bad;
+	}
-	UVMHIST_LOG(pdhist, "  dev=%jx: size=%jd addr=%jd", dev, size, addr, 0);
+	UVMHIST_LOG(pdhist, "  dev=%#jx: size=%jd addr=%jd", dev, size, addr, 0);
 	/*
 	 * now we need to allocate an extent to manage this swap device
 	 */
 	sdp->swd_blist = blist_create(npages);
 	/* mark all expect the `saved' region free. */
 	blist_free(sdp->swd_blist, addr, size);
 	/*
 	 * allocate space to for swap encryption state and mark the
 	 * keys uninitialized so we generate them lazily
 	 */
 @@ -1042,27 +1042,27 @@ bad:
 /*
  * swap_off: stop swapping on swapdev
+ *
  * => swap data should be locked, we will unlock.
  */
 static int
 swap_off(struct lwp *l, struct swapdev *sdp)
+{
 	int npages = sdp->swd_npages;
 	int error = 0;
 	UVMHIST_FUNC(__func__);
-	UVMHIST_CALLARGS(pdhist, "  dev=%jx, npages=%jd", sdp->swd_dev,npages, 0, 0);
+	UVMHIST_CALLARGS(pdhist, "  dev=%#jx, npages=%jd", sdp->swd_dev,npages, 0, 0);
 	KASSERT(rw_write_held(&swap_syscall_lock));
 	KASSERT(mutex_owned(&uvm_swap_data_lock));
 	/* disable the swap area being removed */
 	sdp->swd_flags &= ~SWF_ENABLE;
 	uvmexp.swpgavail -= npages;
 	mutex_exit(&uvm_swap_data_lock);
 	/*
 	 * the idea is to find all the pages that are paged out to this
 	 * device, and page them all in.  in uvm, swap-backed pageable
 	 * memory can take two forms: aobjs and anons.  call the
 @@ -1206,27 +1206,27 @@ swstrategy(struct buf *bp)
 		bp->b_resid = bp->b_bcount;
 		biodone(bp);
 		UVMHIST_LOG(pdhist, "  failed to get swap device", 0, 0, 0, 0);
 		return;
+	}
 	/*
 	 * convert drum page number to block number on this swapdev.
 	 */
 	pageno -= sdp->swd_drumoffset;	/* page # on swapdev */
 	bn = btodb((uint64_t)pageno << PAGE_SHIFT); /* convert to diskblock */
-	UVMHIST_LOG(pdhist, "  Rd/Wr (0/1) %jd: mapoff=%jx bn=%jx bcount=%jd",
+	UVMHIST_LOG(pdhist, "  Rd/Wr (0/1) %jd: mapoff=%#jx bn=%#jx bcount=%jd",
 		((bp->b_flags & B_READ) == 0) ? 1 : 0,
 		sdp->swd_drumoffset, bn, bp->b_bcount);
 	/*
 	 * for block devices we finish up here.
 	 * for regular files we have to do more work which we delegate
 	 * to sw_reg_strategy().
 	 */
 	vp = sdp->swd_vp;		/* swapdev vnode pointer */
 	switch (vp->v_type) {
 	default:
 		panic("%s: vnode type 0x%x", __func__, vp->v_type);
 @@ -1269,40 +1269,40 @@ swstrategy(struct buf *bp)
 		return;
+	}
 	/* NOTREACHED */
+}
 /*
  * swread: the read function for the drum (just a call to physio)
  */
 /*ARGSUSED*/
 static int
 swread(dev_t dev, struct uio *uio, int ioflag)
+{
 	UVMHIST_FUNC(__func__);
-	UVMHIST_CALLARGS(pdhist, "  dev=%jx offset=%jx", dev, uio->uio_offset, 0, 0);
+	UVMHIST_CALLARGS(pdhist, "  dev=%#jx offset=%#jx", dev, uio->uio_offset, 0, 0);
 	return (physio(swstrategy, NULL, dev, B_READ, minphys, uio));
+}
 /*
  * swwrite: the write function for the drum (just a call to physio)
  */
 /*ARGSUSED*/
 static int
 swwrite(dev_t dev, struct uio *uio, int ioflag)
+{
 	UVMHIST_FUNC(__func__);
-	UVMHIST_CALLARGS(pdhist, "  dev=%jx offset=%jx", dev, uio->uio_offset, 0, 0);
+	UVMHIST_CALLARGS(pdhist, "  dev=%#jx offset=%#jx", dev, uio->uio_offset, 0, 0);
 	return (physio(swstrategy, NULL, dev, B_WRITE, minphys, uio));
+}
 const struct bdevsw swap_bdevsw = {
 	.d_open = nullopen,
 	.d_close = nullclose,
 	.d_strategy = swstrategy,
 	.d_ioctl = noioctl,
 	.d_dump = nodump,
 	.d_psize = nosize,
 	.d_discard = nodiscard,
 	.d_flag = D_OTHER
 @@ -1398,27 +1398,27 @@ sw_reg_strategy(struct swapdev *sdp, str
 			vnx->vx_error = error;	/* pass error up */
 			goto out;
+		}
 		/*
 		 * compute the size ("sz") of this transfer (in bytes).
 		 */
 		off = byteoff % sdp->swd_bsize;
 		sz = (1 + nra) * sdp->swd_bsize - off;
 		if (sz > resid)
 			sz = resid;
 		UVMHIST_LOG(pdhist, "sw_reg_strategy: "
-		    "vp %#jx/%#jx offset 0x%jx/0x%jx",
+		    "vp %#jx/%#jx offset %#jx/%#jx",
 		    (uintptr_t)sdp->swd_vp, (uintptr_t)vp, byteoff, nbn);
 		/*
 		 * now get a buf structure.   note that the vb_buf is
 		 * at the front of the nbp structure so that you can
 		 * cast pointers between the two structure easily.
 		 */
 		nbp = pool_get(&vndbuf_pool, PR_WAITOK);
 		buf_init(&nbp->vb_buf);
 		nbp->vb_buf.b_flags    = bp->b_flags;
 		nbp->vb_buf.b_cflags   = bp->b_cflags;
 		nbp->vb_buf.b_oflags   = bp->b_oflags;
 		nbp->vb_buf.b_bcount   = sz;
 @@ -1489,27 +1489,27 @@ sw_reg_start(struct swapdev *sdp)
 	/* recursion control */
 	if ((sdp->swd_flags & SWF_BUSY) != 0)
 		return;
 	sdp->swd_flags |= SWF_BUSY;
 	while (sdp->swd_active < sdp->swd_maxactive) {
 		bp = bufq_get(sdp->swd_tab);
 		if (bp == NULL)
 			break;
 		sdp->swd_active++;
 		UVMHIST_LOG(pdhist,
-		    "sw_reg_start:  bp %#jx vp %#jx blkno %#jx cnt %jx",
+		    "sw_reg_start:  bp %#jx vp %#jx blkno %#jx cnt %#jx",
 		    (uintptr_t)bp, (uintptr_t)bp->b_vp, (uintptr_t)bp->b_blkno,
 		    bp->b_bcount);
 		vp = bp->b_vp;
 		KASSERT(bp->b_objlock == vp->v_interlock);
 		if ((bp->b_flags & B_READ) == 0) {
 			mutex_enter(vp->v_interlock);
 			vp->v_numoutput++;
 			mutex_exit(vp->v_interlock);
+		}
 		VOP_STRATEGY(vp, bp);
+	}
 	sdp->swd_flags &= ~SWF_BUSY;
+}
 @@ -1528,30 +1528,30 @@ sw_reg_biodone(struct buf *bp)
+ *
  * => note that we can recover the vndbuf struct by casting the buf ptr
  */
 static void
 sw_reg_iodone(struct work *wk, void *dummy)
+{
 	struct vndbuf *vbp = (void *)wk;
 	struct vndxfer *vnx = vbp->vb_xfer;
 	struct buf *pbp = vnx->vx_bp;		/* parent buffer */
 	struct swapdev	*sdp = vnx->vx_sdp;
 	int s, resid, error;
 	KASSERT(&vbp->vb_buf.b_work == wk);
 	UVMHIST_FUNC(__func__);
-	UVMHIST_CALLARGS(pdhist, "  vbp=%#jx vp=%#jx blkno=%jx addr=%#jx",
+	UVMHIST_CALLARGS(pdhist, "  vbp=%#jx vp=%#jx blkno=%#jx addr=%#jx",
 	    (uintptr_t)vbp, (uintptr_t)vbp->vb_buf.b_vp, vbp->vb_buf.b_blkno,
 	    (uintptr_t)vbp->vb_buf.b_data);
-	UVMHIST_LOG(pdhist, "  cnt=%jx resid=%jx",
+	UVMHIST_LOG(pdhist, "  cnt=%#jx resid=%#jx",
 	    vbp->vb_buf.b_bcount, vbp->vb_buf.b_resid, 0, 0);
 	/*
 	 * protect vbp at splbio and update.
 	 */
 	s = splbio();
 	resid = vbp->vb_buf.b_bcount - vbp->vb_buf.b_resid;
 	pbp->b_resid -= resid;
 	vnx->vx_pending--;
 	if (vbp->vb_buf.b_error != 0) {
 		/* pass error upward */
 @@ -1826,27 +1826,27 @@ uvm_swap_get(struct vm_page *page, int s
 /*
  * uvm_swap_io: do an i/o operation to swap
  */
 static int
 uvm_swap_io(struct vm_page **pps, int startslot, int npages, int flags)
+{
 	daddr_t startblk;
 	struct	buf *bp;
 	vaddr_t kva;
 	int	error, mapinflags;
 	bool write, async, swap_encrypt;
 	UVMHIST_FUNC(__func__);
-	UVMHIST_CALLARGS(pdhist, "<- called, startslot=%jd, npages=%jd, flags=%jd",
+	UVMHIST_CALLARGS(pdhist, "<- called, startslot=%jd, npages=%jd, flags=%#jx",
 	    startslot, npages, flags, 0);
 	write = (flags & B_READ) == 0;
 	async = (flags & B_ASYNC) != 0;
 	swap_encrypt = atomic_load_relaxed(&uvm_swap_encrypt);
 	/*
 	 * allocate a buf for the i/o.
 	 */
 	KASSERT(curlwp != uvm.pagedaemon_lwp || (write && async));
 	bp = getiobuf(swapdev_vp, curlwp != uvm.pagedaemon_lwp);
 	if (bp == NULL) {
 @@ -1957,27 +1957,27 @@ uvm_swap_io(struct vm_page **pps, int st
 	if (async) {
 		bp->b_iodone = uvm_aio_aiodone;
 		UVMHIST_LOG(pdhist, "doing async!", 0, 0, 0, 0);
 		if (curlwp == uvm.pagedaemon_lwp)
 			BIO_SETPRIO(bp, BPRIO_TIMECRITICAL);
 		else
 			BIO_SETPRIO(bp, BPRIO_TIMELIMITED);
 	} else {
 		bp->b_iodone = NULL;
 		BIO_SETPRIO(bp, BPRIO_TIMECRITICAL);
+	}
 	UVMHIST_LOG(pdhist,
-	    "about to start io: data = %#jx blkno = 0x%jx, bcount = %jd",
+	    "about to start io: data = %#jx blkno = %#jx, bcount = %jd",
 	    (uintptr_t)bp->b_data, bp->b_blkno, bp->b_bcount, 0);
 	/*
 	 * now we start the I/O, and if async, return.
 	 */
 	VOP_STRATEGY(swapdev_vp, bp);
 	if (async) {
 		/*
 		 * Reads are always synchronous; if this changes, we
 		 * need to add an asynchronous path for decryption.
 		 */
 		KASSERT(write);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_vnode.c,v 1.117 2020/08/16 00:24:41 chs Exp $	*/
+/*	$NetBSD: uvm_vnode.c,v 1.118 2021/03/13 15:29:55 skrll Exp $	*/
 /*
  * Copyright (c) 1997 Charles D. Cranor and Washington University.
  * Copyright (c) 1991, 1993
  *      The Regents of the University of California.
  * Copyright (c) 1990 University of Utah.
+ *
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * the Systems Programming Group of the University of Utah Computer
  * Science Department.
+ *
 @@ -35,27 +35,27 @@
  * 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.
+ *
  *      @(#)vnode_pager.c       8.8 (Berkeley) 2/13/94
  * from: Id: uvm_vnode.c,v 1.1.2.26 1998/02/02 20:38:07 chuck Exp
  */
 /*
  * uvm_vnode.c: the vnode pager.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_vnode.c,v 1.117 2020/08/16 00:24:41 chs Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_vnode.c,v 1.118 2021/03/13 15:29:55 skrll Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_uvmhist.h"
 #endif
 #include <sys/atomic.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/vnode.h>
 #include <sys/disklabel.h>
 #include <sys/ioctl.h>
 #include <sys/fcntl.h>
 @@ -166,27 +166,27 @@ uvn_put(struct uvm_object *uobj, voff_t
  * => NOTE: caller must check for released pages!!
  */
 static int
 uvn_get(struct uvm_object *uobj, voff_t offset,
     struct vm_page **pps /* IN/OUT */,
     int *npagesp /* IN (OUT if PGO_LOCKED)*/,
     int centeridx, vm_prot_t access_type, int advice, int flags)
+{
 	struct vnode *vp = (struct vnode *)uobj;
 	int error;
 	UVMHIST_FUNC(__func__);
-	UVMHIST_CALLARGS(ubchist, "vp %#jx off 0x%jx", (uintptr_t)vp, offset,
+	UVMHIST_CALLARGS(ubchist, "vp %#jx off %#jx", (uintptr_t)vp, offset,
 , 0);
 	if (vp->v_type == VREG && (access_type & VM_PROT_WRITE) == 0
 	    && (flags & PGO_LOCKED) == 0 && vp->v_tag != VT_TMPFS) {
 		uvn_alloc_ractx(uobj);
 		uvm_ra_request(vp->v_ractx, advice, uobj, offset,
 		    *npagesp << PAGE_SHIFT);
+	}
 	error = VOP_GETPAGES(vp, offset, pps, npagesp, centeridx,
 			     access_type, advice, flags);
 	KASSERT(((flags & PGO_LOCKED) != 0 && rw_lock_held(uobj->vmobjlock)) ||
 @@ -280,27 +280,27 @@ uvn_findpages(struct uvm_object *uobj, v
 /*
  * uvn_findpage: find a single page
+ *
  * if a suitable page was found, put it in *pgp and return 1.
  * otherwise return 0.
  */
 static int
 uvn_findpage(struct uvm_object *uobj, voff_t offset, struct vm_page **pgp,
     unsigned int flags, struct uvm_page_array *a, unsigned int nleft)
+{
 	struct vm_page *pg;
 	UVMHIST_FUNC(__func__);
-	UVMHIST_CALLARGS(ubchist, "vp %#jx off 0x%jx", (uintptr_t)uobj, offset,
+	UVMHIST_CALLARGS(ubchist, "vp %#jx off %#jx", (uintptr_t)uobj, offset,
 , 0);
 	/*
 	 * NOBUSY must come with NOWAIT and NOALLOC.  if NOBUSY is
 	 * specified, this may be called with a reader lock.
 	 */
 	KASSERT(rw_lock_held(uobj->vmobjlock));
 	KASSERT((flags & UFP_NOBUSY) == 0 || (flags & UFP_NOWAIT) != 0);
 	KASSERT((flags & UFP_NOBUSY) == 0 || (flags & UFP_NOALLOC) != 0);
 	KASSERT((flags & UFP_NOBUSY) != 0 || rw_write_held(uobj->vmobjlock));
 	if (*pgp != NULL) {
 @@ -431,27 +431,27 @@ uvn_findpage(struct uvm_object *uobj, vo
  *	vnode in question so that it will not be yanked out from under
  *	us.
  */
 void
 uvm_vnp_setsize(struct vnode *vp, voff_t newsize)
+{
 	struct uvm_object *uobj = &vp->v_uobj;
 	voff_t pgend = round_page(newsize);
 	voff_t oldsize;
 	UVMHIST_FUNC(__func__); UVMHIST_CALLED(ubchist);
 	rw_enter(uobj->vmobjlock, RW_WRITER);
-	UVMHIST_LOG(ubchist, "vp %#jx old 0x%jx new 0x%jx",
+	UVMHIST_LOG(ubchist, "vp %#jx old %#jx new %#jx",
 	    (uintptr_t)vp, vp->v_size, newsize, 0);
 	/*
 	 * now check if the size has changed: if we shrink we had better
 	 * toss some pages...
 	 */
 	KASSERT(newsize != VSIZENOTSET && newsize >= 0);
 	KASSERT(vp->v_size <= vp->v_writesize);
 	KASSERT(vp->v_size == vp->v_writesize ||
 	    newsize == vp->v_writesize || newsize <= vp->v_size);
 	oldsize = vp->v_writesize;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: pmap_segtab.c,v 1.26 2020/10/08 14:02:40 skrll Exp $	*/
+/*	$NetBSD: pmap_segtab.c,v 1.27 2021/03/13 15:29:55 skrll Exp $	*/
 /*-
  * Copyright (c) 1998, 2001 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center and by Chris G. Demetriou.
+ *
  * 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
 @@ -57,27 +57,27 @@
  * 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.
+ *
  *	@(#)pmap.c	8.4 (Berkeley) 1/26/94
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: pmap_segtab.c,v 1.26 2020/10/08 14:02:40 skrll Exp $");
+__KERNEL_RCSID(0, "$NetBSD: pmap_segtab.c,v 1.27 2021/03/13 15:29:55 skrll Exp $");
 /*
  *	Manages physical address maps.
+ *
  *	In addition to hardware address maps, this
  *	module is called upon to provide software-use-only
  *	maps which may or may not be stored in the same
  *	form as hardware maps.  These pseudo-maps are
  *	used to store intermediate results from copy
  *	operations to and from address spaces.
+ *
  *	Since the information managed by this module is
  *	also stored by the logical address mapping module,
 @@ -255,27 +255,27 @@ pmap_segtab_free(pmap_segtab_t *stp)
 	mutex_spin_exit(&pmap_segtab_lock);
+}
 static void
 pmap_segtab_release(pmap_t pmap, pmap_segtab_t **stp_p, bool free_stp,
 	pte_callback_t callback, uintptr_t flags,
 	vaddr_t va, vsize_t vinc)
+{
 	pmap_segtab_t *stp = *stp_p;
 	UVMHIST_FUNC(__func__);
 	UVMHIST_CALLARGS(pmapsegtabhist, "pm=%#jx stpp=%#jx free=%jd",
 	    (uintptr_t)pmap, (uintptr_t)stp_p, free_stp, 0);
-	UVMHIST_LOG(pmapsegtabhist, " callback=%#jx flags=%jx va=%#jx vinc=%#jx",
+	UVMHIST_LOG(pmapsegtabhist, " callback=%#jx flags=%#jx va=%#jx vinc=%#jx",
 	    (uintptr_t)callback, flags, (uintptr_t)va, (uintptr_t)vinc);
 	for (size_t i = (va / vinc) & (PMAP_SEGTABSIZE - 1);
 	     i < PMAP_SEGTABSIZE;
 	     i++, va += vinc) {
 #ifdef _LP64
 		if (vinc > NBSEG) {
 			if (stp->seg_seg[i] != NULL) {
 				UVMHIST_LOG(pmapsegtabhist,
 				    " recursing %jd", i, 0, 0, 0);
 				pmap_segtab_release(pmap, &stp->seg_seg[i],
 				    true, callback, flags, va, vinc / NSEGPG);
 				KASSERT(stp->seg_seg[i] == NULL);
+			}