 @@ -1,14 +1,14 @@
-/*	$NetBSD: pmap.c,v 1.108 2020/04/15 15:22:37 skrll Exp $	*/
+/*	$NetBSD: pmap.c,v 1.109 2020/04/15 15:50:15 skrll 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.108 2020/04/15 15:22:37 skrll Exp $");
+__KERNEL_RCSID(0, "$NetBSD: pmap.c,v 1.109 2020/04/15 15:50:15 skrll Exp $");
 #include "opt_cputype.h"
 #include <sys/param.h>
 #include <sys/mutex.h>
 #include <sys/proc.h>
 #include <sys/rwlock.h>
 #include <sys/systm.h>
 #include <uvm/uvm.h>
 #include <uvm/uvm_page_array.h>
 #include <machine/cpu.h>
 @@ -84,72 +84,26 @@ __KERNEL_RCSID(0, "$NetBSD: pmap.c,v 1.1
 #include <machine/pcb.h>
 #include <machine/pmap.h>
 #include <machine/pte.h>
 #include <machine/psl.h>
 #include <machine/reg.h>
 #include <hppa/hppa/hpt.h>
 #include <hppa/hppa/machdep.h>
 #if defined(DDB)
 #include <ddb/db_output.h>
 #endif
 #ifdef PMAPDEBUG
 #define	static	/**/
 #define	inline	/**/
 #define	DPRINTF(l,s)	do {		\
 	if ((pmapdebug & (l)) == (l))	\
 		printf s;		\
 } while(0)
 #define	PDB_FOLLOW	0x00000001
 #define	PDB_INIT	0x00000002
 #define	PDB_ENTER	0x00000004
 #define	PDB_REMOVE	0x00000008
 #define	PDB_CREATE	0x00000010
 #define	PDB_PTPAGE	0x00000020
 #define	PDB_CACHE	0x00000040
 #define	PDB_BITS	0x00000080
 #define	PDB_COLLECT	0x00000100
 #define	PDB_PROTECT	0x00000200
 #define	PDB_EXTRACT	0x00000400
 #define	PDB_VP		0x00000800
 #define	PDB_PV		0x00001000
 #define	PDB_PARANOIA	0x00002000
 #define	PDB_WIRING	0x00004000
 #define	PDB_PMAP	0x00008000
 #define	PDB_STEAL	0x00010000
 #define	PDB_PHYS	0x00020000
 #define	PDB_POOL	0x00040000
 #define	PDB_ALIAS	0x00080000
 int pmapdebug = 0
 	| PDB_INIT
 	| PDB_FOLLOW
 	| PDB_VP
 	| PDB_PV
 	| PDB_ENTER
 	| PDB_REMOVE
 	| PDB_STEAL
 	| PDB_PROTECT
 	| PDB_PHYS
 	| PDB_ALIAS
 #else
 #define	DPRINTF(l,s)	/* */
 #endif
 int		pmap_hptsize = 16 * PAGE_SIZE;	/* patchable */
 vaddr_t		pmap_hpt;
 static struct pmap	kernel_pmap_store;
 struct pmap		*const kernel_pmap_ptr = &kernel_pmap_store;
 int		hppa_sid_max = HPPA_SID_MAX;
 struct pool	pmap_pool;
 struct pool	pmap_pv_pool;
 int		pmap_pvlowat = 252;
 bool		pmap_initialized = false;
 static kmutex_t	pmaps_lock;
 @@ -321,128 +275,142 @@ pmap_sdir_get(pa_space_t space)
 	return ((uint32_t *)vtop[space]);
+}
 static inline volatile pt_entry_t *
 pmap_pde_get(volatile uint32_t *pd, vaddr_t va)
+{
 	return ((pt_entry_t *)pd[va >> 22]);
+}
 static inline void
 pmap_pde_set(pmap_t pm, vaddr_t va, paddr_t ptp)
+{
 	UVMHIST_FUNC(__func__);
-	DPRINTF(PDB_FOLLOW|PDB_VP,
+	UVMHIST_CALLARGS(maphist, "pm %#jx va %#jx ptp %#jx", (uintptr_t)pm,
-	    ("%s(%p, 0x%lx, 0x%lx)\n", __func__, pm, va, ptp));
+	    va, ptp, 0);
 	KASSERT((ptp & PGOFSET) == 0);
 	pm->pm_pdir[va >> 22] = ptp;
+}
 static inline pt_entry_t *
 pmap_pde_alloc(pmap_t pm, vaddr_t va, struct vm_page **pdep)
+{
 	struct vm_page *pg;
 	paddr_t pa;
-	DPRINTF(PDB_FOLLOW|PDB_VP,
+	UVMHIST_FUNC(__func__);
-	    ("%s(%p, 0x%lx, %p)\n", __func__, pm, va, pdep));
+	UVMHIST_CALLARGS(maphist, "pm %#jx va %#jx pdep %#jx", (uintptr_t)pm,
 	    va, (uintptr_t)pdep, 0);
 	KASSERT(pm != pmap_kernel());
 	KASSERT(rw_write_held(pm->pm_lock));
 	pg = pmap_pagealloc(&pm->pm_obj, va);
 	if (pg == NULL)
 		return NULL;
 	pa = VM_PAGE_TO_PHYS(pg);
-	DPRINTF(PDB_FOLLOW|PDB_VP, ("%s: pde %lx\n", __func__, pa));
+	UVMHIST_LOG(maphist, "pde %#jx", pa, 0, 0, 0);
 	pg->flags &= ~PG_BUSY;		/* never busy */
 	pg->wire_count = 1;		/* no mappings yet */
 	pmap_pde_set(pm, va, pa);
 	pm->pm_stats.resident_count++;	/* count PTP as resident */
 	pm->pm_ptphint = pg;
 	if (pdep)
 		*pdep = pg;
 	return ((pt_entry_t *)pa);
+}
 static inline struct vm_page *
 pmap_pde_ptp(pmap_t pm, volatile pt_entry_t *pde)
+{
 	paddr_t pa = (paddr_t)pde;
-	DPRINTF(PDB_FOLLOW|PDB_PV, ("%s(%p, %p)\n", __func__, pm, pde));
+	UVMHIST_FUNC(__func__);
 	UVMHIST_CALLARGS(maphist, "pm %#jx va %#jx pdep %#jx", (uintptr_t)pm,
 	    (uintptr_t)pde, 0, 0);
 	if (pm->pm_ptphint && VM_PAGE_TO_PHYS(pm->pm_ptphint) == pa)
 		return (pm->pm_ptphint);
-	DPRINTF(PDB_FOLLOW|PDB_PV, ("%s: lookup 0x%lx\n", __func__, pa));
+	UVMHIST_LOG(maphist, "<--- done (%#jx)",
 	    (uintptr_t)PHYS_TO_VM_PAGE(pa), 0, 0, 0);
 	return (PHYS_TO_VM_PAGE(pa));
+}
 static inline void
 pmap_pde_release(pmap_t pmap, vaddr_t va, struct vm_page *ptp)
+{
 	UVMHIST_FUNC(__func__);
-	DPRINTF(PDB_FOLLOW|PDB_PV,
+	UVMHIST_CALLARGS(maphist, "pm %#jx va %#jx ptp %#jx", (uintptr_t)pmap,
-	    ("%s(%p, 0x%lx, %p)\n", __func__, pmap, va, ptp));
+	    va, (uintptr_t)ptp, 0);
 	KASSERT(pmap != pmap_kernel());
 	if (--ptp->wire_count <= 1) {
-		DPRINTF(PDB_FOLLOW|PDB_PV,
+		UVMHIST_LOG(maphist, "disposing ptp %#jx", (uintptr_t)ptp, 0,
-		    ("%s: disposing ptp %p\n", __func__, ptp));
+, 0);
 		pmap_pde_set(pmap, va, 0);
 		pmap->pm_stats.resident_count--;
 		if (pmap->pm_ptphint == ptp)
 			pmap->pm_ptphint = NULL;
 		ptp->wire_count = 0;
 		KASSERT((ptp->flags & PG_BUSY) == 0);
 		pmap_pagefree(ptp);
+	}
+}
 static inline pt_entry_t
 pmap_pte_get(volatile pt_entry_t *pde, vaddr_t va)
+{
 	return (pde[(va >> 12) & 0x3ff]);
+}
 static inline void
 pmap_pte_set(volatile pt_entry_t *pde, vaddr_t va, pt_entry_t pte)
+{
-	DPRINTF(PDB_FOLLOW|PDB_VP, ("%s(%p, 0x%lx, 0x%x)\n",
+	/* too verbose due to hppa_pagezero_{,un}map */
-	    __func__, pde, va, pte));
+#if 0
 	UVMHIST_FUNC(__func__);
 	UVMHIST_CALLARGS(maphist, "pdep %#jx va %#jx pte %#jx", (uintptr_t)pde,
 	    va, pte, 0);
 #endif
 	KASSERT(pde != NULL);
 	KASSERT(((paddr_t)pde & PGOFSET) == 0);
 	pde[(va >> 12) & 0x3ff] = pte;
+}
 void
 pmap_pte_flush(pmap_t pmap, vaddr_t va, pt_entry_t pte)
+{
 	UVMHIST_FUNC(__func__);
 	if (pmap != pmap_kernel() && va != 0) {
 		UVMHIST_CALLARGS(maphist, "pm %#jx va %#jx pte %#jx",
 		    (uintptr_t)pmap, va, (uintptr_t)pte, 0);
+	}
 	fdcache(pmap->pm_space, va, PAGE_SIZE);
 	if (pte & PTE_PROT(TLB_EXECUTE)) {
 		ficache(pmap->pm_space, va, PAGE_SIZE);
 		pitlb(pmap->pm_space, va);
+	}
 	pdtlb(pmap->pm_space, va);
 #ifdef USE_HPT
 	if (pmap_hpt) {
 		struct hpt_entry *hpt;
 		hpt = pmap_hash(pmap, va);
 		if (hpt->hpt_valid &&
 		    hpt->hpt_space == pmap->pm_space &&
 		    hpt->hpt_vpn == ((va >> 1) & 0x7fff0000))
 @@ -518,93 +486,105 @@ pmap_dump_pv(paddr_t pa)
 	for (pve = md->pvh_list; pve; pve = pve->pv_next)
 		db_printf("%x:%lx\n", pve->pv_pmap->pm_space,
 		    pve->pv_va & PV_VAMASK);
+}
 #endif
 static int
 pmap_check_alias(struct vm_page *pg, vaddr_t va, pt_entry_t pte)
+{
 	struct vm_page_md * const md = VM_PAGE_TO_MD(pg);
 	struct pv_entry *pve;
 	int ret = 0;
 	UVMHIST_FUNC(__func__);
 	UVMHIST_CALLARGS(maphist, "pg %#jx va %#jx pte %#jx", (uintptr_t)pg,
 	    va, pte, 0);
 	/* check for non-equ aliased mappings */
 	for (pve = md->pvh_list; pve; pve = pve->pv_next) {
 		vaddr_t pva = pve->pv_va & PV_VAMASK;
 		UVMHIST_LOG(maphist, "... pm %#jx va %#jx",
 		    (uintptr_t)pve->pv_pmap, pva, 0, 0);
 		pte |= pmap_vp_find(pve->pv_pmap, pva);
 		if ((va & HPPA_PGAOFF) != (pva & HPPA_PGAOFF) &&
 		    (pte & PTE_PROT(TLB_WRITE))) {
 			UVMHIST_LOG(maphist,
 			    "aliased writable mapping %#jx:%#jx",
 			    pve->pv_pmap->pm_space, pve->pv_va, 0, 0);
 			DPRINTF(PDB_FOLLOW|PDB_ALIAS,
 			    ("%s: aliased writable mapping 0x%x:0x%lx\n",
 			    __func__, pve->pv_pmap->pm_space, pve->pv_va));
 			ret++;
+		}
+	}
 	UVMHIST_LOG(maphist, "<--- done (%jd)", ret, 0, 0, 0);
 	return (ret);
+}
 /*
  * This allocates and returns a new struct pv_entry.
  */
 static inline struct pv_entry *
 pmap_pv_alloc(void)
+{
 	struct pv_entry *pv;
 	DPRINTF(PDB_FOLLOW|PDB_PV, ("%s()\n", __func__));
 	pv = pool_get(&pmap_pv_pool, PR_NOWAIT);
 	DPRINTF(PDB_FOLLOW|PDB_PV, ("%s: %p\n", __func__, pv));
 	return (pv);
+}
 static inline void
 pmap_pv_free(struct pv_entry *pv)
+{
 	if (pv->pv_ptp)
 		pmap_pde_release(pv->pv_pmap, pv->pv_va & PV_VAMASK,
 		    pv->pv_ptp);
 	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",
+	UVMHIST_FUNC(__func__);
-	    __func__, pg, pve, pm, va, pdep, flags));
+	UVMHIST_CALLARGS(maphist, "pg %#jx pve %#jx pm %#jx va %#jx",
 	    (uintptr_t)pg, (uintptr_t)pve, (uintptr_t)pm, va);
 	UVMHIST_LOG(maphist, "...pdep %#jx flags %#jx",
 	    (uintptr_t)pdep, flags, 0, 0);
 	KASSERT(pm == pmap_kernel() || uvm_page_owner_locked_p(pg, true));
 	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)
+{
 	UVMHIST_FUNC(__func__);
 	UVMHIST_CALLARGS(maphist, "pg %#jx pm %#jx va %#jx",
 	    (uintptr_t)pg, (uintptr_t)pmap, va, 0);
 	struct vm_page_md * const md = VM_PAGE_TO_MD(pg);
 	struct pv_entry **pve, *pv;
 	KASSERT(pmap == pmap_kernel() || uvm_page_owner_locked_p(pg, true));
 	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;
+		}
+	}
 @@ -616,80 +596,68 @@ pmap_pv_remove(struct vm_page *pg, pmap_
+		}
+	}
 	return (pv);
+}
 #define	FIRST_16M atop(16 * 1024 * 1024)
 static void
 pmap_page_physload(paddr_t spa, paddr_t epa)
+{
 	if (spa < FIRST_16M && epa <= FIRST_16M) {
 		DPRINTF(PDB_INIT, ("%s: phys segment 0x%05lx 0x%05lx\n",
 		    __func__, spa, epa));
 		uvm_page_physload(spa, epa, spa, epa, VM_FREELIST_ISADMA);
 	} else if (spa < FIRST_16M && epa > FIRST_16M) {
 		DPRINTF(PDB_INIT, ("%s: phys segment 0x%05lx 0x%05lx\n",
 		    __func__, spa, FIRST_16M));
 		uvm_page_physload(spa, FIRST_16M, spa, FIRST_16M,
 		    VM_FREELIST_ISADMA);
 		DPRINTF(PDB_INIT, ("%s: phys segment 0x%05lx 0x%05lx\n",
 		    __func__, FIRST_16M, epa));
 		uvm_page_physload(FIRST_16M, epa, FIRST_16M, epa,
 		    VM_FREELIST_DEFAULT);
 	} else {
 		DPRINTF(PDB_INIT, ("%s: phys segment 0x%05lx 0x%05lx\n",
 		    __func__, spa, epa));
 		uvm_page_physload(spa, epa, spa, epa, VM_FREELIST_DEFAULT);
+	}
 	availphysmem += epa - spa;
+}
 /*
  * Bootstrap the system enough to run with virtual memory.
  * Map the kernel's code, data and bss, and allocate the system page table.
  * Called with mapping OFF.
+ *
  * Parameters:
  * vstart	PA of first available physical page
  */
 void
 pmap_bootstrap(vaddr_t vstart)
+{
 	UVMHIST_FUNC(__func__);
 	UVMHIST_CALLED(maphist);
 	vaddr_t va, addr;
 	vsize_t size;
 	extern paddr_t hppa_vtop;
 	pmap_t kpm;
 	int npdes, nkpdes;
 	extern int resvphysmem;
 	vsize_t btlb_entry_min, btlb_entry_max, btlb_entry_got;
 	paddr_t ksrx, kerx, ksro, kero, ksrw, kerw;
 	extern int usebtlb;
 	/* Provided by the linker script */
 	extern int kernel_text, etext;
 	extern int __rodata_start, __rodata_end;
 	extern int __data_start;
 	DPRINTF(PDB_FOLLOW|PDB_INIT, ("%s(0x%lx)\n", __func__, vstart));
 	uvm_md_init();
 	hppa_prot[UVM_PROT_NONE]  = TLB_AR_NA;
 	hppa_prot[UVM_PROT_READ]  = TLB_AR_R;
 	hppa_prot[UVM_PROT_WRITE] = TLB_AR_RW;
 	hppa_prot[UVM_PROT_RW]    = TLB_AR_RW;
 	hppa_prot[UVM_PROT_EXEC]  = TLB_AR_RX;
 	hppa_prot[UVM_PROT_RX]    = TLB_AR_RX;
 	hppa_prot[UVM_PROT_WX]    = TLB_AR_RWX;
 	hppa_prot[UVM_PROT_RWX]   = TLB_AR_RWX;
 	/*
 	 * Initialize kernel pmap
 @@ -709,28 +677,26 @@ pmap_bootstrap(vaddr_t vstart)
 	memset((void *)addr, 0, PAGE_SIZE);
 	fdcache(HPPA_SID_KERNEL, addr, PAGE_SIZE);
 	addr += PAGE_SIZE;
 	/*
 	 * Allocate various tables and structures.
 	 */
 	mtctl(addr, CR_VTOP);
 	hppa_vtop = addr;
 	size = round_page((hppa_sid_max + 1) * 4);
 	memset((void *)addr, 0, size);
 	fdcache(HPPA_SID_KERNEL, addr, size);
 	DPRINTF(PDB_INIT, ("%s: vtop 0x%lx @ 0x%lx\n", __func__, size,
 	    addr));
 	addr += size;
 	pmap_sdir_set(HPPA_SID_KERNEL, kpm->pm_pdir);
 	/*
 	 * cpuid() found out how big the HPT should be, so align addr to
 	 * what will be its beginning.  We don't waste the pages skipped
 	 * for the alignment.
 	 */
 #ifdef USE_HPT
 	if (pmap_hptsize) {
 		struct hpt_entry *hptp;
 		int i, error;
 @@ -739,65 +705,66 @@ pmap_bootstrap(vaddr_t vstart)
 			addr += pmap_hptsize;
 		addr &= ~(pmap_hptsize - 1);
 		memset((void *)addr, 0, pmap_hptsize);
 		hptp = (struct hpt_entry *)addr;
 		for (i = pmap_hptsize / sizeof(struct hpt_entry); i--; ) {
 			hptp[i].hpt_valid = 0;
 			hptp[i].hpt_space = 0xffff;
 			hptp[i].hpt_vpn = 0;
+		}
 		pmap_hpt = addr;
 		addr += pmap_hptsize;
-		DPRINTF(PDB_INIT, ("%s: hpt_table 0x%x @ 0x%lx\n", __func__,
+		UVMHIST_LOG(maphist, "hpt_table %#jx @ %#jx\n",
-		    pmap_hptsize, addr));
+		    pmap_hptsize, addr, 0, 0);
 		if ((error = (cpu_hpt_init)(pmap_hpt, pmap_hptsize)) < 0) {
 			printf("WARNING: HPT init error %d -- DISABLED\n",
 			    error);
 			pmap_hpt = 0;
-		} else
+		} else {
-			DPRINTF(PDB_INIT,
+			UVMHIST_LOG(maphist,
-			    ("%s: HPT installed for %ld entries @ 0x%lx\n",
+			    "HPT installed for %jd entries @ %#jx",
-			    __func__, pmap_hptsize / sizeof(struct hpt_entry),
+			    pmap_hptsize / sizeof(struct hpt_entry), addr, 0,
-			    addr));
+);
+		}
+	}
 #endif
 	/* Setup vtop in lwp0 trapframe. */
 	lwp0.l_md.md_regs->tf_vtop = hppa_vtop;
 	/* Pre-allocate PDEs for kernel virtual */
 	nkpdes = (VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS) / PDE_SIZE;
 	/* ... and io space too */
 	nkpdes += HPPA_IOLEN / PDE_SIZE;
 	/* ... and all physmem (VA == PA) */
 	npdes = nkpdes + (physmem + atop(PDE_SIZE) - 1) / atop(PDE_SIZE);
-	DPRINTF(PDB_INIT, ("%s: npdes %d\n", __func__, npdes));
+	UVMHIST_LOG(maphist, "npdes %jd", npdes, 0, 0, 0);
 	/* map the pdes */
 	for (va = 0; npdes--; va += PDE_SIZE, addr += PAGE_SIZE) {
 		/* last nkpdes are for the kernel virtual */
 		if (npdes == nkpdes - 1)
 			va = SYSCALLGATE;
 		if (npdes == HPPA_IOLEN / PDE_SIZE - 1)
 			va = HPPA_IOBEGIN;
 		/* now map the pde for the physmem */
 		memset((void *)addr, 0, PAGE_SIZE);
 		DPRINTF(PDB_INIT|PDB_VP,
-		    ("%s: pde premap 0x%08lx 0x%08lx\n", __func__, va,
+		UVMHIST_LOG(maphist, "pde premap 0x%08jx 0x%08jx", va,
-		    addr));
+		    addr, 0, 0);
 		pmap_pde_set(kpm, va, addr);
 		kpm->pm_stats.resident_count++; /* count PTP as resident */
+	}
 	/*
 	 * At this point we've finished reserving memory for the kernel.
 	 */
 	/* XXXNH */
 	resvphysmem = atop(addr);
 	ksrx = (paddr_t) &kernel_text;
 	kerx = (paddr_t) &etext;
 	ksro = (paddr_t) &__rodata_start;
 @@ -846,29 +813,29 @@ pmap_bootstrap(vaddr_t vstart)
 		int btlb_entry_vm_prot[BTLB_SET_SIZE];
 		int btlb_i;
 		int btlb_j;
 		/*
 		 * Now make BTLB entries to direct-map the kernel text
 		 * read- and execute-only as much as possible.  Note that
 		 * if the data segment isn't nicely aligned, the last
 		 * BTLB entry for the kernel text may also cover some of
 		 * the data segment, meaning it will have to allow writing.
 		 */
 		addr = ksrx;
-		DPRINTF(PDB_INIT,
+		UVMHIST_LOG(maphist,
-		    ("%s: BTLB mapping text and rodata @ %p - %p\n", __func__,
+		    "BTLB mapping text and rodata @ %#jx - %#jx", addr, kero,
-		    (void *)addr, (void *)kero));
+, 0);
 		btlb_j = 0;
 		while (addr < (vaddr_t) kero) {
 			/* Set up the next BTLB entry. */
 			KASSERT(btlb_j < BTLB_SET_SIZE);
 			btlb_entry_start[btlb_j] = addr;
 			btlb_entry_size[btlb_j] = btlb_entry_min;
 			btlb_entry_vm_prot[btlb_j] =
 			    VM_PROT_READ | VM_PROT_EXECUTE;
 			if (addr + btlb_entry_min > kero)
 				btlb_entry_vm_prot[btlb_j] |= VM_PROT_WRITE;
 @@ -893,28 +860,28 @@ pmap_bootstrap(vaddr_t vstart)
 		/*
 		 * Now make BTLB entries to direct-map the kernel data,
 		 * bss, and all of the preallocated space read-write.
+		 *
 		 * Note that, unlike above, we're not concerned with
 		 * making these BTLB entries such that they finish as
 		 * close as possible to the end of the space we need
 		 * them to map.  Instead, to minimize the number of BTLB
 		 * entries we need, we make them as large as possible.
 		 * The only thing this wastes is kernel virtual space,
 		 * which is plentiful.
 		 */
-		DPRINTF(PDB_INIT, ("%s: mapping data, bss, etc @ %p - %p\n",
+		UVMHIST_LOG(maphist, "mapping data, bss, etc @ %#jx - %#jx",
-		    __func__, (void *)addr, (void *)kerw));
+		    addr, kerw, 0, 0);
 		while (addr < kerw) {
 			/* Make the next BTLB entry. */
 			KASSERT(btlb_j < BTLB_SET_SIZE);
 			size = btlb_entry_min;
 			while ((addr + size) < kerw &&
 				(size << 1) < btlb_entry_max &&
 			    !(addr & ((size << 1) - 1)))
 				size <<= 1;
 			btlb_entry_start[btlb_j] = addr;
 			btlb_entry_size[btlb_j] = size;
 			btlb_entry_vm_prot[btlb_j] =
 @@ -974,46 +941,45 @@ pmap_bootstrap(vaddr_t vstart)
 			prot = UVM_PROT_RX;
 		else if (va >= ksrx && va < kerx)
 			prot = UVM_PROT_RX;
 		else if (va >= ksro && va < kero)
 			prot = UVM_PROT_R;
 #ifdef DIAGNOSTIC
 		else if (va == uvm_lwp_getuarea(&lwp0) + USPACE - PAGE_SIZE)
 			prot = UVM_PROT_NONE;
 #endif
 		pmap_kenter_pa(va, va, prot, 0);
+	}
 	/* XXXNH update */
-	DPRINTF(PDB_INIT, ("%s: mapped 0x%lx - 0x%lx\n", __func__, ksro,
+	UVMHIST_LOG(maphist, "mapped %#jx - %#jx", ksro, kero, 0, 0);
-	    kero));
+	UVMHIST_LOG(maphist, "mapped %#jx - %#jx", ksrw, kerw, 0, 0);
 	DPRINTF(PDB_INIT, ("%s: mapped 0x%lx - 0x%lx\n", __func__, ksrw,
 	    kerw));
+}
 /*
  * Finishes the initialization of the pmap module.
  * This procedure is called from uvm_init() in uvm/uvm_init.c
  * to initialize any remaining data structures that the pmap module
  * needs to map virtual memory (VM is already ON).
  */
 void
 pmap_init(void)
+{
 	extern void gateway_page(void);
 	volatile pt_entry_t *pde;
-	DPRINTF(PDB_FOLLOW|PDB_INIT, ("%s()\n", __func__));
+	UVMHIST_FUNC(__func__)
 	UVMHIST_CALLED(maphist);
 	sid_counter = HPPA_SID_KERNEL;
 	pool_init(&pmap_pool, sizeof(struct pmap), 0, 0, 0, "pmappl",
 	    &pool_allocator_nointr, IPL_NONE);
 	pool_init(&pmap_pv_pool, sizeof(struct pv_entry), 0, 0, 0, "pmappv",
 	    &pool_allocator_nointr, IPL_NONE);
 	pool_setlowat(&pmap_pv_pool, pmap_pvlowat);
 	pool_sethiwat(&pmap_pv_pool, pmap_pvlowat * 32);
 	/*
 	 * map SysCall gateway page once for everybody
 @@ -1021,55 +987,58 @@ pmap_init(void)
 	 *     if we have any at SYSCALLGATE address (;
+	 *
 	 * no spls since no interrupts
 	 */
 	if (!(pde = pmap_pde_get(pmap_kernel()->pm_pdir, SYSCALLGATE)) &&
 	    !(pde = pmap_pde_alloc(pmap_kernel(), SYSCALLGATE, NULL)))
 		panic("pmap_init: cannot allocate pde");
 	pmap_pte_set(pde, SYSCALLGATE, (paddr_t)&gateway_page |
 	    PTE_PROT(TLB_GATE_PROT));
 	pmap_initialized = true;
-	DPRINTF(PDB_FOLLOW|PDB_INIT, ("%s(): done\n", __func__));
+	UVMHIST_LOG(maphist, "<--- done", 0, 0, 0, 0);
+}
 /*
  * How much virtual space does this kernel have?
  */
 void
 pmap_virtual_space(vaddr_t *startp, vaddr_t *endp)
+{
 	*startp = SYSCALLGATE + PAGE_SIZE;
 	*endp = VM_MAX_KERNEL_ADDRESS;
+}
 /*
  * pmap_create()
+ *
  * Create and return a physical map.
  * The map is an actual physical map, and may be referenced by the hardware.
  */
 pmap_t
 pmap_create(void)
+{
 	pmap_t pmap;
 	pa_space_t space;
 	UVMHIST_FUNC(__func__)
 	UVMHIST_CALLED(maphist);
 	pmap = pool_get(&pmap_pool, PR_WAITOK);
-	DPRINTF(PDB_FOLLOW|PDB_PMAP, ("%s: pmap = %p\n", __func__, pmap));
+	UVMHIST_LOG(maphist, "pm %#jx", (uintptr_t)pmap, 0, 0, 0);
 	rw_init(&pmap->pm_obj_lock);
 	uvm_obj_init(&pmap->pm_obj, &pmap_pager, false, 1);
 	uvm_obj_setlock(&pmap->pm_obj, &pmap->pm_obj_lock);
 	mutex_enter(&pmaps_lock);
 	/*
 	 * Allocate space IDs for the pmap; we get the protection ID from this.
 	 * If all are allocated, there is nothing we can do.
 	 */
 	/* XXXNH can't this loop forever??? */
 	for (space = sid_counter; pmap_sdir_get(space);
 @@ -1080,122 +1049,122 @@ pmap_create(void)
 		panic("pmap_create: no pages");
 	pmap->pm_ptphint = NULL;
 	pmap->pm_pdir = (uint32_t *)VM_PAGE_TO_PHYS(pmap->pm_pdir_pg);
 	pmap_sdir_set(space, pmap->pm_pdir);
 	pmap->pm_space = space;
 	pmap->pm_pid = (space + 1) << 1;
 	pmap->pm_stats.resident_count = 1;
 	pmap->pm_stats.wired_count = 0;
 	mutex_exit(&pmaps_lock);
-	DPRINTF(PDB_FOLLOW|PDB_PMAP, ("%s: pm = %p, space = %d, pid = %d\n",
+	UVMHIST_LOG(maphist, "pm %#jx, space %jd, pid %jd",
-	    __func__, pmap, space, pmap->pm_pid));
+	    (uintptr_t)pmap, space, pmap->pm_pid, 0);
 	return (pmap);
+}
 /*
  * pmap_destroy(pmap)
  *	Gives up a reference to the specified pmap.  When the reference count
  *	reaches zero the pmap structure is added to the pmap free list.
  *	Should only be called if the map contains no valid mappings.
  */
 void
 pmap_destroy(pmap_t pmap)
+{
 	UVMHIST_FUNC(__func__)
 	UVMHIST_CALLARGS(maphist, "pm %#jx", (uintptr_t)pmap, 0, 0, 0);
 #ifdef DIAGNOSTIC
 	struct uvm_page_array a;
 	struct vm_page *pg;
 	off_t off;
 #endif
 	int refs;
 	DPRINTF(PDB_FOLLOW|PDB_PMAP, ("%s(%p)\n", __func__, pmap));
 	rw_enter(pmap->pm_lock, RW_WRITER);
 	refs = --pmap->pm_obj.uo_refs;
 	rw_exit(pmap->pm_lock);
 	if (refs > 0)
 		return;
 #ifdef DIAGNOSTIC
 	uvm_page_array_init(&a);
 	off = 0;
 	rw_enter(pmap->pm_lock, RW_WRITER);
 	while ((pg = uvm_page_array_fill_and_peek(&a, &pmap->pm_obj, off, 0, 0))
 	    != NULL) {
 		pt_entry_t *pde, *epde;
 		struct vm_page *spg;
 		struct pv_entry *pv, *npv;
 		paddr_t pa;
 		off = pg->offset + PAGE_SIZE;
 		uvm_page_array_advance(&a);
 		KASSERT(pg != pmap->pm_pdir_pg);
 		pa = VM_PAGE_TO_PHYS(pg);
-		DPRINTF(PDB_FOLLOW, ("%s(%p): stray ptp "
+		UVMHIST_LOG(maphist, "pm %#jx: stray ptp %#jx w/ %jd entries:",
-		    "0x%lx w/ %d ents:", __func__, pmap, pa,
+		    (uintptr_t)pmap, pa, pg->wire_count - 1, 0);
 		    pg->wire_count - 1));
 		pde = (pt_entry_t *)pa;
 		epde = (pt_entry_t *)(pa + PAGE_SIZE);
 		for (; pde < epde; pde++) {
 			if (*pde == 0)
 				continue;
 			spg = PHYS_TO_VM_PAGE(PTE_PAGE(*pde));
 			if (spg == NULL)
 				continue;
 			struct vm_page_md * const md = VM_PAGE_TO_MD(spg);
 			for (pv = md->pvh_list; pv != NULL; pv = npv) {
 				npv = pv->pv_next;
 				if (pv->pv_pmap != pmap)
 					continue;
-				DPRINTF(PDB_FOLLOW, (" 0x%lx", pv->pv_va));
+				UVMHIST_LOG(maphist, " %#jx", pv->pv_va, 0, 0,
 );
 				pmap_remove(pmap, pv->pv_va & PV_VAMASK,
 				    (pv->pv_va & PV_VAMASK) + PAGE_SIZE);
+			}
+		}
 		DPRINTF(PDB_FOLLOW, ("\n"));
+	}
 	rw_exit(pmap->pm_lock);
 	uvm_page_array_fini(&a);
 #endif
 	pmap_sdir_set(pmap->pm_space, 0);
 	rw_enter(pmap->pm_lock, RW_WRITER);
 	pmap_pagefree(pmap->pm_pdir_pg);
 	rw_exit(pmap->pm_lock);
 	uvm_obj_destroy(&pmap->pm_obj, false);
 	rw_destroy(&pmap->pm_obj_lock);
 	pool_put(&pmap_pool, pmap);
+}
 /*
  * Add a reference to the specified pmap.
  */
 void
 pmap_reference(pmap_t pmap)
+{
 	UVMHIST_FUNC(__func__)
-	DPRINTF(PDB_FOLLOW|PDB_PMAP, ("%s(%p)\n", __func__, pmap));
+	UVMHIST_CALLARGS(maphist, "pm %#jx", (uintptr_t)pmap, 0, 0, 0);
 	rw_enter(pmap->pm_lock, RW_WRITER);
 	pmap->pm_obj.uo_refs++;
 	rw_exit(pmap->pm_lock);
+}
 void
 pmap_syncicache_page(struct vm_page *pg, pmap_t pm, vaddr_t va)
+{
 	struct vm_page_md * const md = VM_PAGE_TO_MD(pg);
 	struct pv_entry *pve = md->pvh_list;
 @@ -1223,72 +1192,70 @@ pmap_syncicache_page(struct vm_page *pg,
  *	address (pa) in the pmap with the protection requested. If the
  *	translation is wired then we can not allow a page fault to occur
  *	for this mapping.
  */
 int
 pmap_enter(pmap_t pmap, vaddr_t va, paddr_t pa, vm_prot_t prot, u_int flags)
+{
 	volatile pt_entry_t *pde;
 	pt_entry_t pte;
 	struct vm_page *pg = NULL, *ptp = NULL;
 	struct pv_entry *pve = NULL;
 	bool wired = (flags & PMAP_WIRED) != 0;
-	DPRINTF(PDB_FOLLOW|PDB_ENTER,
+	UVMHIST_FUNC(__func__);
-	    ("%s(%p, 0x%lx, 0x%lx, 0x%x, 0x%x)\n", __func__, pmap, va, pa,
+	UVMHIST_CALLARGS(maphist, "pm %#jx va %#jx pa %#jx prot %#jx",
-	    prot, flags));
+	    (uintptr_t)pmap, va, pa, prot);
 	UVMHIST_LOG(maphist, "...flags %#jx", flags, 0, 0, 0);
 	PMAP_LOCK(pmap);
 	if (!(pde = pmap_pde_get(pmap->pm_pdir, va)) &&
 	    !(pde = pmap_pde_alloc(pmap, va, &ptp))) {
 		if (flags & PMAP_CANFAIL) {
 			PMAP_UNLOCK(pmap);
 			return (ENOMEM);
+		}
 		panic("pmap_enter: cannot allocate pde");
+	}
 	if (!ptp)
 		ptp = pmap_pde_ptp(pmap, pde);
 	if ((pte = pmap_pte_get(pde, va))) {
 		UVMHIST_LOG(maphist, "remapping %#jx -> %#jx", pte, pa, 0, 0);
 		DPRINTF(PDB_ENTER,
 		    ("%s: remapping 0x%x -> 0x%lx\n", __func__, pte, pa));
 		pmap_pte_flush(pmap, va, pte);
 		if (wired && !(pte & PTE_PROT(TLB_WIRED)))
 			pmap->pm_stats.wired_count++;
 		else if (!wired && (pte & PTE_PROT(TLB_WIRED)))
 			pmap->pm_stats.wired_count--;
 		pg = PHYS_TO_VM_PAGE(PTE_PAGE(pte));
 		if (PTE_PAGE(pte) == pa) {
-			DPRINTF(PDB_FOLLOW|PDB_ENTER,
+			UVMHIST_LOG(maphist, "same page", 0, 0, 0, 0);
 			    ("%s: same page\n", __func__));
 			goto enter;
+		}
 		if (pg != NULL) {
 			pve = pmap_pv_remove(pg, pmap, va);
 			struct vm_page_md * const md = VM_PAGE_TO_MD(pg);
 			md->pvh_attrs |= pmap_pvh_attrs(pte);
+		}
 	} else {
-		DPRINTF(PDB_ENTER, ("%s: new mapping 0x%lx -> 0x%lx\n",
+		UVMHIST_LOG(maphist, "new mapping %#jx -> %#jx",
-		    __func__, va, pa));
+		    va, pa, 0, 0);
 		pte = PTE_PROT(TLB_REFTRAP);
 		pmap->pm_stats.resident_count++;
 		if (wired)
 			pmap->pm_stats.wired_count++;
 		if (ptp)
 			ptp->wire_count++;
+	}
 	if (pmap_initialized && (pg = PHYS_TO_VM_PAGE(pa))) {
 		if (!pve && !(pve = pmap_pv_alloc())) {
 			if (flags & PMAP_CANFAIL) {
  				PMAP_UNLOCK(pmap);
 				return (ENOMEM);
 @@ -1316,51 +1283,52 @@ enter:
 			pmap_syncicache_page(pg, pmap, va);
 			md->pvh_attrs |= PVF_EXEC;
+		}
+	}
 	if (IS_IOPAGE_P(pa))
 		pte |= PTE_PROT(TLB_UNCACHEABLE);
 	if (wired)
 		pte |= PTE_PROT(TLB_WIRED);
 	pmap_pte_set(pde, va, pte);
 	PMAP_UNLOCK(pmap);
-	DPRINTF(PDB_FOLLOW|PDB_ENTER, ("%s: leaving\n", __func__));
+	UVMHIST_LOG(maphist, "<--- done (0)", 0, 0, 0, 0);
 	return (0);
+}
 /*
  * pmap_remove(pmap, sva, eva)
  *	unmaps all virtual addresses in the virtual address
  *	range determined by [sva, eva) and pmap.
  *	sva and eva must be on machine independent page boundaries and
  *	sva must be less than or equal to eva.
  */
 void
 pmap_remove(pmap_t pmap, vaddr_t sva, vaddr_t eva)
+{
 	UVMHIST_FUNC(__func__);
 	UVMHIST_CALLARGS(maphist, "sva %#jx eva %#jx", sva, eva, 0, 0);
 	struct pv_entry *pve;
 	volatile pt_entry_t *pde = NULL;
 	pt_entry_t pte;
 	struct vm_page *pg, *ptp;
 	vaddr_t pdemask;
 	int batch;
 	DPRINTF(PDB_FOLLOW|PDB_REMOVE,
 	    ("%s(%p, 0x%lx, 0x%lx)\n", __func__, pmap, sva, eva));
 	PMAP_LOCK(pmap);
 	for (batch = 0; sva < eva; sva += PAGE_SIZE) {
 		pdemask = sva & PDE_MASK;
 		if (!(pde = pmap_pde_get(pmap->pm_pdir, sva))) {
 			sva = pdemask + PDE_SIZE - PAGE_SIZE;
 			continue;
+		}
 		batch = pdemask == sva && sva + PDE_SIZE <= eva;
 		if ((pte = pmap_pte_get(pde, sva))) {
 			/* TODO measure here the speed tradeoff
 @@ -1389,57 +1357,57 @@ pmap_remove(pmap_t pmap, vaddr_t sva, va
 			} else {
 				if (IS_IOPAGE_P(PTE_PAGE(pte))) {
 					ptp = pmap_pde_ptp(pmap, pde);
 					if (ptp != NULL)
 						pmap_pde_release(pmap, sva,
 						    ptp);
+				}
+			}
+		}
+	}
 	PMAP_UNLOCK(pmap);
-	DPRINTF(PDB_FOLLOW|PDB_REMOVE, ("%s: leaving\n", __func__));
+	UVMHIST_LOG(maphist, "<--- done", 0, 0, 0, 0);
+}
 void
 pmap_write_protect(pmap_t pmap, vaddr_t sva, vaddr_t eva, vm_prot_t prot)
+{
 	UVMHIST_FUNC(__func__);
 	UVMHIST_CALLARGS(maphist, "pm %#jx sva %#jx eva %#jx prot %#jx",
 	    (uintptr_t)pmap, sva, eva, prot);
 	struct vm_page *pg;
 	volatile pt_entry_t *pde = NULL;
 	pt_entry_t pte;
 	u_int pteprot, pdemask;
 	DPRINTF(PDB_FOLLOW|PDB_PMAP,
 	    ("%s(%p, %lx, %lx, %x)\n", __func__, pmap, sva, eva, prot));
 	sva = trunc_page(sva);
 	pteprot = PTE_PROT(pmap_prot(pmap, prot));
 	PMAP_LOCK(pmap);
 	for (pdemask = 1; sva < eva; sva += PAGE_SIZE) {
 		if (pdemask != (sva & PDE_MASK)) {
 			pdemask = sva & PDE_MASK;
 			if (!(pde = pmap_pde_get(pmap->pm_pdir, sva))) {
 				sva = pdemask + PDE_SIZE - PAGE_SIZE;
 				continue;
+			}
+		}
 		if ((pte = pmap_pte_get(pde, sva))) {
 			UVMHIST_LOG(maphist, "va% #jx pte %#jx", sva, pte,
-			DPRINTF(PDB_PMAP,
+, 0);
 			    ("%s: va=0x%lx pte=0x%x\n", __func__, sva,  pte));
 			/*
 			 * Determine if mapping is changing.
 			 * If not, nothing to do.
 			 */
 			if ((pte & PTE_PROT(TLB_AR_MASK)) == pteprot)
 				continue;
 			pg = PHYS_TO_VM_PAGE(PTE_PAGE(pte));
 			if (pg != NULL) {
 				struct vm_page_md * const md =
 				    VM_PAGE_TO_MD(pg);
 				md->pvh_attrs |= pmap_pvh_attrs(pte);
 @@ -1449,31 +1417,32 @@ pmap_write_protect(pmap_t pmap, vaddr_t
 			pmap_pte_flush(pmap, sva, pte);
 			pte &= ~PTE_PROT(TLB_AR_MASK);
 			pte |= pteprot;
 			pmap_pte_set(pde, sva, pte);
+		}
+	}
 	PMAP_UNLOCK(pmap);
+}
 void
 pmap_page_remove(struct vm_page *pg)
+{
 	UVMHIST_FUNC(__func__)
 	UVMHIST_CALLARGS(maphist, "pg %#jx", (uintptr_t)pg, 0, 0, 0);
 	struct vm_page_md * const md = VM_PAGE_TO_MD(pg);
 	struct pv_entry *pve, *npve, **pvp;
 	DPRINTF(PDB_FOLLOW|PDB_PV, ("%s(%p)\n", __func__, pg));
 	if (md->pvh_list == NULL) {
 		KASSERT((md->pvh_attrs & PVF_EXEC) == 0);
 		return;
+	}
 	pvp = &md->pvh_list;
 	for (pve = md->pvh_list; pve; pve = npve) {
 		pmap_t pmap = pve->pv_pmap;
 		vaddr_t va = pve->pv_va & PV_VAMASK;
 		volatile pt_entry_t *pde;
 		pt_entry_t pte;
 		PMAP_LOCK(pmap);
 @@ -1496,154 +1465,158 @@ pmap_page_remove(struct vm_page *pg)
 		if (pte & PTE_PROT(TLB_WIRED))
 			pmap->pm_stats.wired_count--;
 		pmap->pm_stats.resident_count--;
 		if (!(pve->pv_va & PV_KENTER)) {
 			pmap_pte_set(pde, va, 0);
 			pmap_pv_free(pve);
+		}
 		PMAP_UNLOCK(pmap);
+	}
 	md->pvh_attrs &= ~PVF_EXEC;
 	*pvp = NULL;
-	DPRINTF(PDB_FOLLOW|PDB_PV, ("%s: leaving\n", __func__));
+	UVMHIST_LOG(maphist, "<--- done", 0, 0, 0, 0);
+}
 /*
  *	Routine:	pmap_unwire
  *	Function:	Change the wiring attribute for a map/virtual-address
  *			pair.
  *	In/out conditions:
  *			The mapping must already exist in the pmap.
+ *
  * Change the wiring for a given virtual page. This routine currently is
  * only used to unwire pages and hence the mapping entry will exist.
  */
 void
 pmap_unwire(pmap_t pmap, vaddr_t va)
+{
 	UVMHIST_FUNC(__func__);
 	UVMHIST_CALLARGS(maphist, "pm %#jx va %#jx", (uintptr_t)pmap, va, 0, 0);
 	volatile pt_entry_t *pde;
 	pt_entry_t pte = 0;
 	DPRINTF(PDB_FOLLOW|PDB_PMAP, ("%s(%p, 0x%lx)\n", __func__, pmap, va));
 	PMAP_LOCK(pmap);
 	if ((pde = pmap_pde_get(pmap->pm_pdir, va))) {
 		pte = pmap_pte_get(pde, va);
 		KASSERT(pte);
 		if (pte & PTE_PROT(TLB_WIRED)) {
 			pte &= ~PTE_PROT(TLB_WIRED);
 			pmap->pm_stats.wired_count--;
 			pmap_pte_set(pde, va, pte);
+		}
+	}
 	PMAP_UNLOCK(pmap);
-	DPRINTF(PDB_FOLLOW|PDB_PMAP, ("%s: leaving\n", __func__));
+	UVMHIST_LOG(maphist, "<--- done", 0, 0, 0, 0);
+}
 bool
 pmap_changebit(struct vm_page *pg, u_int set, u_int clear)
+{
 	UVMHIST_FUNC(__func__);
 	UVMHIST_CALLARGS(maphist, "pg %#jx (md %#jx) set %#jx clear %#jx",
 	    (uintptr_t)pg, (uintptr_t)VM_PAGE_TO_MD(pg), set, clear);
 	struct vm_page_md * const md = VM_PAGE_TO_MD(pg);
 	struct pv_entry *pve;
 	int res;
 	DPRINTF(PDB_FOLLOW|PDB_BITS,
 	    ("%s(%p, %x, %x)\n", __func__, pg, set, clear));
 	KASSERT((set & clear) == 0);
 	KASSERT((set & ~(PVF_REF|PVF_UNCACHEABLE)) == 0);
 	KASSERT((clear & ~(PVF_MOD|PVF_WRITE|PVF_UNCACHEABLE)) == 0);
 	/* preserve other bits */
 	res = md->pvh_attrs & (set | clear);
 	md->pvh_attrs ^= res;
 	for (pve = md->pvh_list; pve; pve = pve->pv_next) {
 		pmap_t pmap = pve->pv_pmap;
 		vaddr_t va = pve->pv_va & PV_VAMASK;
 		volatile pt_entry_t *pde;
 		pt_entry_t opte, pte;
 		if ((pde = pmap_pde_get(pmap->pm_pdir, va))) {
 			opte = pte = pmap_pte_get(pde, va);
-#ifdef PMAPDEBUG
+#ifdef DEBUG
 			if (!pte) {
-				DPRINTF(PDB_FOLLOW|PDB_BITS,
+				UVMHIST_LOG(maphist, "zero pte for %#jx",
-				    ("%s: zero pte for 0x%lx\n", __func__,
+				    va, 0, 0, 0);
 				    va));
 				continue;
+			}
 #endif
 			pte &= ~clear;
 			pte |= set;
 			if (!(pve->pv_va & PV_KENTER)) {
 				md->pvh_attrs |= pmap_pvh_attrs(pte);
 				res |= pmap_pvh_attrs(opte);
+			}
 			if (opte != pte) {
 				pmap_pte_flush(pmap, va, opte);
 				pmap_pte_set(pde, va, pte);
+			}
+		}
+	}
 	return ((res & (clear | set)) != 0);
+}
 bool
 pmap_testbit(struct vm_page *pg, u_int bit)
+{
 	UVMHIST_FUNC(__func__);
 	UVMHIST_CALLARGS(maphist, "pg %#jx (md %#jx) bit %#jx",
 	    (uintptr_t)pg, (uintptr_t)VM_PAGE_TO_MD(pg), bit, 0);
 	struct vm_page_md * const md = VM_PAGE_TO_MD(pg);
 	struct pv_entry *pve;
 	pt_entry_t pte;
 	int ret;
 	DPRINTF(PDB_FOLLOW|PDB_BITS, ("%s(%p, %x)\n", __func__, pg, bit));
 	for (pve = md->pvh_list; !(md->pvh_attrs & bit) && pve;
 	    pve = pve->pv_next) {
 		pmap_t pm = pve->pv_pmap;
 		pte = pmap_vp_find(pm, pve->pv_va & PV_VAMASK);
 		if (pve->pv_va & PV_KENTER)
 			continue;
 		md->pvh_attrs |= pmap_pvh_attrs(pte);
+	}
 	ret = ((md->pvh_attrs & bit) != 0);
 	return ret;
+}
 /*
  * pmap_extract(pmap, va, pap)
  *	fills in the physical address corresponding to the
  *	virtual address specified by pmap and va into the
  *	storage pointed to by pap and returns true if the
  *	virtual address is mapped. returns false in not mapped.
  */
 bool
 pmap_extract(pmap_t pmap, vaddr_t va, paddr_t *pap)
+{
-	pt_entry_t pte;
+	UVMHIST_FUNC(__func__);
 	UVMHIST_CALLARGS(maphist, "pm %#jx va %#jx", (uintptr_t)pmap, va, 0, 0);
-	DPRINTF(PDB_FOLLOW|PDB_EXTRACT, ("%s(%p, %lx)\n", __func__, pmap, va));
+	pt_entry_t pte;
 	PMAP_LOCK(pmap);
 	pte = pmap_vp_find(pmap, va);
 	PMAP_UNLOCK(pmap);
 	if (pte) {
 		if (pap)
 			*pap = (pte & ~PGOFSET) | (va & PGOFSET);
 		return true;
+	}
 	return false;
+}
 @@ -1672,31 +1645,33 @@ pmap_activate(struct lwp *l)
 void
 pmap_procwr(struct proc *p, vaddr_t va, size_t len)
+{
 	pmap_t pmap = p->p_vmspace->vm_map.pmap;
 	fdcache(pmap->pm_space, va, len);
 	ficache(pmap->pm_space, va, len);
+}
 static inline void
 pmap_flush_page(struct vm_page *pg, bool purge)
+{
 	UVMHIST_FUNC(__func__);
 	UVMHIST_CALLARGS(maphist, "pg %#jx (md %#jx) purge %jd",
 	    (uintptr_t)pg, (uintptr_t)VM_PAGE_TO_MD(pg), purge, 0);
 	struct vm_page_md * const md = VM_PAGE_TO_MD(pg);
 	struct pv_entry *pve;
 	DPRINTF(PDB_FOLLOW|PDB_CACHE, ("%s(%p, %d)\n", __func__, pg, purge));
 	/* purge cache for all possible mappings for the pa */
 	for (pve = md->pvh_list; pve; pve = pve->pv_next) {
 		vaddr_t va = pve->pv_va & PV_VAMASK;
 		pa_space_t sp = pve->pv_pmap->pm_space;
 		if (purge)
 			pdcache(sp, va, PAGE_SIZE);
 		else
 			fdcache(sp, va, PAGE_SIZE);
 #if defined(HP8000_CPU) || defined(HP8200_CPU) || \
     defined(HP8500_CPU) || defined(HP8600_CPU)
 		ficache(sp, va, PAGE_SIZE);
 		pdtlb(sp, va);
 @@ -1704,205 +1679,190 @@ pmap_flush_page(struct vm_page *pg, bool
 #endif
+	}
+}
 /*
  * pmap_zero_page(pa)
+ *
  * Zeros the specified page.
  */
 void
 pmap_zero_page(paddr_t pa)
+{
-	DPRINTF(PDB_FOLLOW|PDB_PHYS, ("%s(%lx)\n", __func__, pa));
+	UVMHIST_FUNC(__func__);
 	UVMHIST_CALLARGS(maphist, "pa %#jx (pg %#jx)", pa,
 	    (uintptr_t)PHYS_TO_VM_PAGE(pa), 0, 0);
 	KASSERT(VM_PAGE_TO_MD(PHYS_TO_VM_PAGE(pa))->pvh_list == NULL);
 	KASSERT((VM_PAGE_TO_MD(PHYS_TO_VM_PAGE(pa))->pvh_attrs & PVF_EXEC) == 0);
 	memset((void *)pa, 0, PAGE_SIZE);
 	fdcache(HPPA_SID_KERNEL, pa, PAGE_SIZE);
 #if defined(HP8000_CPU) || defined(HP8200_CPU) || \
     defined(HP8500_CPU) || defined(HP8600_CPU)
 	ficache(HPPA_SID_KERNEL, pa, PAGE_SIZE);
 	pdtlb(HPPA_SID_KERNEL, pa);
 	pitlb(HPPA_SID_KERNEL, pa);
 #endif
+}
 /*
  * pmap_copy_page(src, dst)
+ *
  * pmap_copy_page copies the source page to the destination page.
  */
 void
 pmap_copy_page(paddr_t spa, paddr_t dpa)
+{
-	struct vm_page *srcpg = PHYS_TO_VM_PAGE(spa);
+	UVMHIST_FUNC(__func__);
 	UVMHIST_CALLARGS(maphist, "spa %#jx (pg %#jx) dpa %#jx (pg %#jx)",
 	    spa, (uintptr_t)PHYS_TO_VM_PAGE(spa),
 	    dpa, (uintptr_t)PHYS_TO_VM_PAGE(dpa));
-	DPRINTF(PDB_FOLLOW|PDB_PHYS, ("%s(%lx, %lx)\n", __func__, spa, dpa));
+	struct vm_page *srcpg = PHYS_TO_VM_PAGE(spa);
 	KASSERT(VM_PAGE_TO_MD(PHYS_TO_VM_PAGE(dpa))->pvh_list == NULL);
 	KASSERT((VM_PAGE_TO_MD(PHYS_TO_VM_PAGE(dpa))->pvh_attrs & PVF_EXEC) == 0);
 	pmap_flush_page(srcpg, false);
 	memcpy((void *)dpa, (void *)spa, PAGE_SIZE);
 	pdcache(HPPA_SID_KERNEL, spa, PAGE_SIZE);
 	fdcache(HPPA_SID_KERNEL, dpa, PAGE_SIZE);
 #if defined(HP8000_CPU) || defined(HP8200_CPU) || \
     defined(HP8500_CPU) || defined(HP8600_CPU)
 	ficache(HPPA_SID_KERNEL, spa, PAGE_SIZE);
 	ficache(HPPA_SID_KERNEL, dpa, PAGE_SIZE);
 	pdtlb(HPPA_SID_KERNEL, spa);
 	pdtlb(HPPA_SID_KERNEL, dpa);
 	pitlb(HPPA_SID_KERNEL, spa);
 	pitlb(HPPA_SID_KERNEL, dpa);
 #endif
+}
 void
 pmap_kenter_pa(vaddr_t va, paddr_t pa, vm_prot_t prot, u_int flags)
+{
 	UVMHIST_FUNC(__func__);
 	if (va != 0) {
 		UVMHIST_CALLARGS(maphist, "va %#jx pa %#jx prot %#jx flags %#jx",
 		    va, pa, prot, flags);
+	}
 	volatile pt_entry_t *pde;
 	pt_entry_t pte, opte;
 	struct vm_page *pg;
 #ifdef PMAPDEBUG
 	int opmapdebug = pmapdebug;
 	/*
 	 * If we're being told to map page zero, we can't call printf() at all,
 	 * because doing so would lead to an infinite recursion on this call.
 	 * (printf requires page zero to be mapped).
 	 */
 	if (va == 0)
 		pmapdebug = 0;
 #endif /* PMAPDEBUG */
 	DPRINTF(PDB_FOLLOW|PDB_ENTER,
 	    ("%s(%lx, %lx, %x)\n", __func__, va, pa, prot));
 	if (!(pde = pmap_pde_get(pmap_kernel()->pm_pdir, va)) &&
 	    !(pde = pmap_pde_alloc(pmap_kernel(), va, NULL)))
 		panic("pmap_kenter_pa: cannot allocate pde for va=0x%lx", va);
 	opte = pmap_pte_get(pde, va);
 	pte = pa | PTE_PROT(TLB_WIRED | TLB_REFTRAP |
 	    pmap_prot(pmap_kernel(), prot & VM_PROT_ALL));
 	if (IS_IOPAGE_P(pa) || (flags & PMAP_NOCACHE))
 		pte |= PTE_PROT(TLB_UNCACHEABLE);
 	pmap_kernel()->pm_stats.wired_count++;
 	pmap_kernel()->pm_stats.resident_count++;
 	if (opte)
 		pmap_pte_flush(pmap_kernel(), va, opte);
 	pg = pmap_initialized ? PHYS_TO_VM_PAGE(PTE_PAGE(pte)) : NULL;
 	if (pg != NULL) {
 		KASSERT(pa < HPPA_IOBEGIN);
 		struct pv_entry *pve;
 		pve = pmap_pv_alloc();
 		if (!pve)
 			panic("%s: no pv entries available", __func__);
-		DPRINTF(PDB_FOLLOW|PDB_ENTER, ("%s(%lx, %lx, %x) TLB_KENTER\n",
+		UVMHIST_LOG(maphist, "va %#jx pa %#jx pte %#jx TLB_KENTER",
-		    __func__, va, pa, pte));
+		    va, pa, pte, 0);
 		if (pmap_check_alias(pg, va, pte))
 			pmap_page_remove(pg);
 		pmap_pv_enter(pg, pve, pmap_kernel(), va, NULL, PV_KENTER);
+	}
 	pmap_pte_set(pde, va, pte);
-	DPRINTF(PDB_FOLLOW|PDB_ENTER, ("%s: leaving\n", __func__));
+	if (va != 0) {
 		UVMHIST_LOG(maphist, "<--- done", 0, 0, 0, 0);
+	}
 #ifdef PMAPDEBUG
 	pmapdebug = opmapdebug;
 #endif /* PMAPDEBUG */
+}
 void
 pmap_kremove(vaddr_t va, vsize_t size)
+{
 	UVMHIST_FUNC(__func__);
 	bool pzero = false;
 	if (va != 0) {
 		UVMHIST_CALLARGS(maphist, "va %#jx...%#jx", va, va + size, 0,
 );
 		pzero = true;
+	}
 	struct pv_entry *pve;
 	vaddr_t eva, pdemask;
 	volatile pt_entry_t *pde = NULL;
 	pt_entry_t pte;
 	struct vm_page *pg;
 	pmap_t pmap = pmap_kernel();
 #ifdef PMAPDEBUG
 	int opmapdebug = pmapdebug;
 	/*
 	 * If we're being told to unmap page zero, we can't call printf() at
 	 * all as printf requires page zero to be mapped.
 	 */
 	if (va == 0)
 		pmapdebug = 0;
 #endif /* PMAPDEBUG */
 	DPRINTF(PDB_FOLLOW|PDB_REMOVE,
 	    ("%s(%lx, %lx)\n", __func__, va, size));
 #ifdef PMAPDEBUG
 #ifdef DEBUG
 	/*
 	 * Don't allow the VA == PA mappings, apart from page zero, to be
 	 * removed. Page zero is given special treatment so that we get TLB
 	 * faults when the kernel tries to de-reference NULL or anything else
 	 * in the first page when it shouldn't.
 	 */
 	if (va != 0 && va < ptoa(physmem)) {
-		DPRINTF(PDB_FOLLOW|PDB_REMOVE,
+		UVMHIST_LOG(maphist, "va %#jx size %#jx: unmapping physmem", va,
-		    ("%s(%lx, %lx): unmapping physmem\n", __func__, va,
+		    size, 0, 0);
 		    size));
 		pmapdebug = opmapdebug;
 		return;
+	}
 #endif
 	for (pdemask = 1, eva = va + size; va < eva; va += PAGE_SIZE) {
 		if (pdemask != (va & PDE_MASK)) {
 			pdemask = va & PDE_MASK;
 			if (!(pde = pmap_pde_get(pmap->pm_pdir, va))) {
 				va = pdemask + PDE_SIZE - PAGE_SIZE;
 				continue;
+			}
+		}
 		if (!(pte = pmap_pte_get(pde, va))) {
-			DPRINTF(PDB_FOLLOW|PDB_REMOVE,
+			UVMHIST_LOG(maphist, "unmapping unmapped %#jx",
-			    ("%s: unmapping unmapped 0x%lx\n", __func__,
+			    va, 0, 0, 0);
 			    va));
 			continue;
+		}
 		pmap_pte_flush(pmap, va, pte);
 		pmap_pte_set(pde, va, 0);
 		pg = pmap_initialized ? PHYS_TO_VM_PAGE(PTE_PAGE(pte)) : NULL;
 		if (pg != NULL) {
 			pve = pmap_pv_remove(pg, pmap, va);
 			if (pve != NULL)
 				pmap_pv_free(pve);
+		}
+	}
-	DPRINTF(PDB_FOLLOW|PDB_REMOVE, ("%s: leaving\n", __func__));
+	if (pzero) {
 		UVMHIST_LOG(maphist, "<--- done", 0, 0, 0, 0);
 #ifdef PMAPDEBUG
 	pmapdebug = opmapdebug;
 #endif /* PMAPDEBUG */
+}
 #if defined(USE_HPT)
 #if defined(DDB)
 /*
  * prints whole va->pa (aka HPT or HVT)
  */
 void
 pmap_hptdump(void)
+{
 	struct hpt_entry *hpt, *ehpt;
 	hpt = (struct hpt_entry *)pmap_hpt;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: if_ie_gsc.c,v 1.4 2019/04/25 10:08:45 msaitoh Exp $	*/
+/*	$NetBSD: if_ie_gsc.c,v 1.5 2020/04/15 15:50:15 skrll Exp $	*/
 /*	$OpenBSD: if_ie_gsc.c,v 1.6 2001/01/12 22:57:04 mickey Exp $	*/
 /*
  * Copyright (c) 1998-2004 Michael Shalayeff
  * 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
 @@ -28,27 +28,27 @@
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Referencies:
  * 1. 82596DX and 82596SX High-Performance 32-bit Local Area Network Coprocessor
  *    Intel Corporation, November 1996, Order Number: 290219-006
+ *
  * 2. 712 I/O Subsystem ERS Rev 1.0
  *    Hewlett-Packard, June 17 1992, Dwg No. A-A2263-66510-31
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_ie_gsc.c,v 1.4 2019/04/25 10:08:45 msaitoh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_ie_gsc.c,v 1.5 2020/04/15 15:50:15 skrll Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/socket.h>
 #include <sys/sockio.h>
 #include <uvm/uvm_extern.h>
 #include <net/if.h>
 #include <net/if_dl.h>
 #include <net/if_ether.h>
 #include <net/if_types.h>
 @@ -368,31 +368,26 @@ ie_gsc_probe(device_t parent, cfdata_t m
 	return 1;
+}
 void
 ie_gsc_attach(device_t parent, device_t self, void *aux)
+{
 	struct ie_gsc_softc *gsc = device_private(self);
 	struct ie_softc *sc = &gsc->ie;
 	struct gsc_attach_args *ga = aux;
 	bus_dma_segment_t seg;
 	int rseg;
 	int rv;
 	uint8_t myaddr[ETHER_ADDR_LEN];
 #ifdef PMAPDEBUG
 	extern int pmapdebug;
 	int opmapdebug = pmapdebug;
 	pmapdebug = 0;
 #endif
 	if (ga->ga_type.iodc_sv_model == HPPA_FIO_GLAN)
 		gsc->flags |= IEGSC_GECKO;
 	/* Map the GSC registers. */
 	if (bus_space_map(ga->ga_iot, ga->ga_hpa,
 			  IE_GSC_BANK_SZ, 0, &gsc->ioh)) {
 		printf(": can't map i/o space\n");
 		return;
+	}
 	/* Set up some initial glue. */
 	sc->sc_dev = self;
 @@ -496,29 +491,26 @@ ie_gsc_attach(device_t parent, device_t
 	/* The remainder of the memory is for buffers. */
 	sc->buf_area = IE_GSC_ALIGN(sc->scb + IE_SCB_SZ);
 	sc->buf_area_sz = sc->sc_msize - sc->buf_area;
 	/* Finally, we can probe the chip. */
 	rv = i82596_probe(sc);
 	if (!rv) {
 		bus_dmamap_destroy(gsc->iemt, sc->sc_dmamap);
 		bus_dmamem_unmap(gsc->iemt,
 				 (void *)sc->sc_maddr, sc->sc_msize);
 		bus_dmamem_free(gsc->iemt, &seg, rseg);
 		return;
+	}
 #ifdef PMAPDEBUG
 	pmapdebug = opmapdebug;
 #endif
 	if (!rv)
 		return;
 	/* Get our Ethernet address. */
 	memcpy(myaddr, ga->ga_ether_address, ETHER_ADDR_LEN);
 	/* Set up the SCP. */
 	sc->ie_bus_write16(sc, IE_SCP_BUS_USE(sc->scp), IE_GSC_SYSBUS);
 	sc->ie_bus_write24(sc, IE_SCP_ISCP(sc->scp), sc->iscp);
 	/* Set up the ISCP. */
 	sc->ie_bus_write16(sc, IE_ISCP_SCB(sc->iscp), sc->scb);
 	sc->ie_bus_write24(sc, IE_ISCP_BASE(sc->iscp), 0);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: machdep.c,v 1.12 2019/12/31 13:07:10 ad Exp $	*/
+/*	$NetBSD: machdep.c,v 1.13 2020/04/15 15:50:15 skrll 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.
 @@ -48,27 +48,27 @@
  * 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 OR HIS RELATIVES 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 MIND, 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: machdep.c,v 1.12 2019/12/31 13:07:10 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: machdep.c,v 1.13 2020/04/15 15:50:15 skrll Exp $");
 #include "opt_cputype.h"
 #include "opt_ddb.h"
 #include "opt_kgdb.h"
 #include "opt_modular.h"
 #include "opt_useleds.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/signalvar.h>
 #include <sys/kernel.h>
 #include <sys/proc.h>
 #include <sys/buf.h>
 @@ -116,30 +116,26 @@ __KERNEL_RCSID(0, "$NetBSD: machdep.c,v
 #endif
 #ifdef DDB
 #include <machine/db_machdep.h>
 #include <ddb/db_access.h>
 #include <ddb/db_sym.h>
 #include <ddb/db_extern.h>
 #endif
 #include <hppa/hppa/machdep.h>
 #include <hppa/hppa/pim.h>
 #include <hppa/dev/cpudevs.h>
 #ifdef PMAPDEBUG
 #include <hppa/hppa/hpt.h>
 #endif
 #include "ksyms.h"
 #include "lcd.h"
 #ifdef MACHDEPDEBUG
 #define	DPRINTF(s)	do {		\
 	if (machdepdebug)		\
 		printf s;		\
 } while(0)
 #define	DPRINTFN(l,s)	do {		\
 	if (machdepdebug >= (1))	\
 		printf s;		\
 @@ -888,32 +884,27 @@ cpu_model_cpuid(int modelno)
 	case HPPA_BOARD_HP725_50:
 	case HPPA_BOARD_HP725_75:
 	case HPPA_BOARD_HP725_99:
 		return hpcxt;
+	}
 	return hpc_unknown;
+}
 void
 cpu_startup(void)
+{
 	vaddr_t minaddr, maxaddr;
 	char pbuf[3][9];
 #ifdef PMAPDEBUG
 	extern int pmapdebug;
 	int opmapdebug = pmapdebug;
 	pmapdebug = 0;
 #endif
 	/* Initialize the message buffer. */
 	initmsgbuf(msgbufaddr, MSGBUFSIZE);
 	/*
 	 * i won't understand a friend of mine,
 	 * who sat in a room full of artificial ice,
 	 * fogging the air w/ humid cries --
 	 *	WELCOME TO SUMMER!
 	 */
 	printf("%s%s", copyright, version);
 	/* identify system type */
 	printf("%s\n", cpu_getmodel());
 @@ -930,29 +921,26 @@ cpu_startup(void)
 		format_bytes(pbuf[0], sizeof(pbuf[0]), ptoa(totalphysmem - physmem));
 		DPRINTF(("lost mem = %s\n", pbuf[0]));
+	}
 #endif
 	minaddr = 0;
 	/*
 	 * Allocate a submap for physio
 	 */
 	phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
 	    VM_PHYS_SIZE, 0, false, NULL);
 #ifdef PMAPDEBUG
 	pmapdebug = opmapdebug;
 #endif
 	format_bytes(pbuf[0], sizeof(pbuf[0]), ptoa(uvm_availmem()));
 	printf("avail mem = %s\n", pbuf[0]);
+}
 /*
  * compute CPU clock ratio such as:
  *	cpu_ticksnum / cpu_ticksdenom = t + delta
  *	delta -> 0
  */
 void
 delay_init(void)
+{
 	u_int num, denom, delta, mdelta;