 @@ -1,14 +1,14 @@
-/*	$NetBSD: pmap.c,v 1.76 2010/06/21 14:43:34 skrll Exp $	*/
+/*	$NetBSD: pmap.c,v 1.77 2010/10/30 17:20:43 uebayasi 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,52 +55,54 @@
  * 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.76 2010/06/21 14:43:34 skrll Exp $");
+__KERNEL_RCSID(0, "$NetBSD: pmap.c,v 1.77 2010/10/30 17:20:43 uebayasi Exp $");
 #include "opt_cputype.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/malloc.h>
 #include <sys/proc.h>
 #include <uvm/uvm.h>
 #include <machine/reg.h>
 #include <machine/psl.h>
 #include <machine/cpu.h>
 #include <machine/pmap.h>
 #include <machine/pte.h>
 #include <machine/cpufunc.h>
 #include <machine/iomod.h>
 #include <hppa/hppa/hpt.h>
 #include <hppa/hppa/machdep.h>
 #if defined(DDB)
 #include <ddb/db_output.h>
 #endif
 #define	VM_PAGE_TO_MD(pg)	(&(pg)->mdpage)
 #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
 @@ -487,47 +489,50 @@ pmap_dump_table(pa_space_t space, vaddr_
 			snprintb(buf, sizeof(buf), TLB_BITS,
 			   TLB_PROT(pte & PAGE_MASK));
 			db_printf("0x%08lx-0x%08x:%s\n", va, pte & ~PAGE_MASK,
 			    buf);
+		}
 		va += PAGE_SIZE;
 	} while (va != 0);
+}
 void
 pmap_dump_pv(paddr_t pa)
+{
 	struct vm_page *pg;
 	struct vm_page_md *md;
 	struct pv_entry *pve;
 	pg = PHYS_TO_VM_PAGE(pa);
-	mutex_enter(&pg->mdpage.pvh_lock);
+	md = VM_PAGE_TO_MD(pg);
-	db_printf("pg %p attr 0x%08x aliases %d\n", pg, pg->mdpage.pvh_attrs,
+	mutex_enter(&md->pvh_lock);
-	    pg->mdpage.pvh_aliases);
+	db_printf("pg %p attr 0x%08x aliases %d\n", pg, md->pvh_attrs,
-	for (pve = pg->mdpage.pvh_list; pve; pve = pve->pv_next)
+	    md->pvh_aliases);
 	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);
-	mutex_exit(&pg->mdpage.pvh_lock);
+	mutex_exit(&md->pvh_lock);
+}
 #endif
 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;
 	/* check for non-equ aliased mappings */
-	for (pve = pg->mdpage.pvh_list; pve; pve = pve->pv_next) {
+	for (pve = md->pvh_list; pve; pve = pve->pv_next) {
 		vaddr_t pva = pve->pv_va & PV_VAMASK;
 		pte |= pmap_vp_find(pve->pv_pmap, pva);
 		if ((va & HPPA_PGAOFF) != (pva & HPPA_PGAOFF) &&
 		    (pte & PTE_PROT(TLB_WRITE))) {
 			DPRINTF(PDB_FOLLOW|PDB_ALIAS,
                             ("%s: aliased writable mapping 0x%x:0x%lx\n",
                             __func__, pve->pv_pmap->pm_space, pve->pv_va));
 			ret++;
+		}
+	}
 @@ -556,46 +561,49 @@ 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",
 	    __func__, pg, pve, pm, va, pdep, flags));
-	KASSERT(mutex_owned(&pg->mdpage.pvh_lock));
+	KASSERT(mutex_owned(&md->pvh_lock));
 	pve->pv_pmap = pm;
 	pve->pv_va = va | flags;
 	pve->pv_ptp = pdep;
-	pve->pv_next = pg->mdpage.pvh_list;
+	pve->pv_next = md->pvh_list;
-	pg->mdpage.pvh_list = pve;
+	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(mutex_owned(&pg->mdpage.pvh_lock));
+	KASSERT(mutex_owned(&md->pvh_lock));
-	for (pv = *(pve = &pg->mdpage.pvh_list);
+	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;
+		}
 	return (pv);
+}
 #define	FIRST_16M atop(16 * 1024 * 1024)
 static void
 pmap_page_physload(paddr_t spa, paddr_t epa)
+{
 @@ -1099,41 +1107,42 @@ pmap_destroy(pmap_t pmap)
 			continue;
 		DPRINTF(PDB_FOLLOW, ("%s(%p): stray ptp "
 		    "0x%lx w/ %d ents:", __func__, pmap, VM_PAGE_TO_PHYS(pg),
 		    pg->wire_count - 1));
 		pde = (pt_entry_t *)VM_PAGE_TO_PHYS(pg);
 		epde = (pt_entry_t *)(VM_PAGE_TO_PHYS(pg) + PAGE_SIZE);
 		for (; pde < epde; pde++) {
 			if (*pde == 0)
 				continue;
 			sheep = PHYS_TO_VM_PAGE(PTE_PAGE(*pde));
-			for (haggis = sheep->mdpage.pvh_list; haggis != NULL; )
+			struct vm_page_md * const md = VM_PAGE_TO_MD(sheep);
 			for (haggis = md->pvh_list; haggis != NULL; )
 				if (haggis->pv_pmap == pmap) {
 					DPRINTF(PDB_FOLLOW, (" 0x%lx",
 					    haggis->pv_va));
 					pmap_remove(pmap,
 					    haggis->pv_va & PV_VAMASK,
 					    haggis->pv_va + PAGE_SIZE);
 					/*
 					 * exploit the sacred knowledge of
 					 * lambeous ozzmosis
 					 */
-					haggis = sheep->mdpage.pvh_list;
+					haggis = md->pvh_list;
 				} else
 					haggis = haggis->pv_next;
+		}
 		DPRINTF(PDB_FOLLOW, ("\n"));
+	}
 #endif
 	pmap_sdir_set(pmap->pm_space, 0);
 	mutex_enter(&pmap->pm_lock);
 	pmap_pagefree(pmap->pm_pdir_pg);
 	mutex_exit(&pmap->pm_lock);
 	mutex_destroy(&pmap->pm_lock);
 	pmap->pm_pdir_pg = NULL;
 	pool_put(&pmap_pool, pmap);
 @@ -1196,58 +1205,60 @@ pmap_enter(pmap_t pmap, vaddr_t va, padd
 		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--;
 		if (PTE_PAGE(pte) == pa) {
 			DPRINTF(PDB_FOLLOW|PDB_ENTER,
 			    ("%s: same page\n", __func__));
 			goto enter;
+		}
 		pg = PHYS_TO_VM_PAGE(PTE_PAGE(pte));
-		mutex_enter(&pg->mdpage.pvh_lock);
+		struct vm_page_md * const md = VM_PAGE_TO_MD(pg);
 		mutex_enter(&md->pvh_lock);
 		pve = pmap_pv_remove(pg, pmap, va);
-		pg->mdpage.pvh_attrs |= pmap_pvh_attrs(pte);
+		md->pvh_attrs |= pmap_pvh_attrs(pte);
-		mutex_exit(&pg->mdpage.pvh_lock);
+		mutex_exit(&md->pvh_lock);
 	} else {
 		DPRINTF(PDB_ENTER, ("%s: new mapping 0x%lx -> 0x%lx\n",
 		    __func__, va, pa));
 		pte = PTE_PROT(TLB_REFTRAP);
 		pve = NULL;
 		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))) {
 		struct vm_page_md * const md = VM_PAGE_TO_MD(pg);
 		if (!pve && !(pve = pmap_pv_alloc())) {
 			if (flags & PMAP_CANFAIL) {
- 				mutex_exit(&pg->mdpage.pvh_lock);
+ 				mutex_exit(&md->pvh_lock);
  				PMAP_UNLOCK(pmap);
 				return (ENOMEM);
+			}
 			panic("%s: no pv entries available", __func__);
+		}
                 pte |= PTE_PROT(pmap_prot(pmap, prot));
-		mutex_enter(&pg->mdpage.pvh_lock);
+		mutex_enter(&md->pvh_lock);
 		if (pmap_check_alias(pg, va, pte))
 			pmap_page_remove_locked(pg);
 		pmap_pv_enter(pg, pve, pmap, va, ptp, 0);
-		mutex_exit(&pg->mdpage.pvh_lock);
+		mutex_exit(&md->pvh_lock);
 	} else if (pve) {
 		pmap_pv_free(pve);
+	}
 enter:
 	/* preserve old ref & mod */
 	pte = pa | PTE_PROT(pmap_prot(pmap, prot)) |
 	    (pte & PTE_PROT(TLB_UNCACHEABLE|TLB_DIRTY|TLB_REFTRAP));
 	if (wired)
 		pte |= PTE_PROT(TLB_WIRED);
 	pmap_pte_set(pde, va, pte);
 	PMAP_UNLOCK(pmap);
 @@ -1294,33 +1305,34 @@ pmap_remove(pmap_t pmap, vaddr_t sva, va
 			 * in case of non-complete pde fill
 			 */
 			pmap_pte_flush(pmap, sva, pte);
 			if (pte & PTE_PROT(TLB_WIRED))
 				pmap->pm_stats.wired_count--;
 			pmap->pm_stats.resident_count--;
 			/* iff properly accounted pde will be dropped anyway */
 			if (!batch)
 				pmap_pte_set(pde, sva, 0);
 			if (pmap_initialized &&
 			    (pg = PHYS_TO_VM_PAGE(PTE_PAGE(pte)))) {
 				struct vm_page_md * const md = VM_PAGE_TO_MD(pg);
-				mutex_enter(&pg->mdpage.pvh_lock);
+				mutex_enter(&md->pvh_lock);
 				pve = pmap_pv_remove(pg, pmap, sva);
-				pg->mdpage.pvh_attrs |= pmap_pvh_attrs(pte);
+				md->pvh_attrs |= pmap_pvh_attrs(pte);
-				mutex_exit(&pg->mdpage.pvh_lock);
+				mutex_exit(&md->pvh_lock);
 				if (pve != NULL)
 					pmap_pv_free(pve);
+			}
+		}
+	}
 	PMAP_UNLOCK(pmap);
 	DPRINTF(PDB_FOLLOW|PDB_REMOVE, ("%s: leaving\n", __func__));
+}
 @@ -1350,81 +1362,84 @@ pmap_write_protect(pmap_t pmap, vaddr_t
+		}
 		if ((pte = pmap_pte_get(pde, sva))) {
 			DPRINTF(PDB_PMAP,
 			    ("%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));
-			mutex_enter(&pg->mdpage.pvh_lock);
+			struct vm_page_md * const md = VM_PAGE_TO_MD(pg);
-			pg->mdpage.pvh_attrs |= pmap_pvh_attrs(pte);
+			mutex_enter(&md->pvh_lock);
-			mutex_exit(&pg->mdpage.pvh_lock);
+			md->pvh_attrs |= pmap_pvh_attrs(pte);
 			mutex_exit(&md->pvh_lock);
 			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)
+{
 	struct vm_page_md * const md = VM_PAGE_TO_MD(pg);
-	mutex_enter(&pg->mdpage.pvh_lock);
+	mutex_enter(&md->pvh_lock);
 	pmap_page_remove_locked(pg);
-	mutex_exit(&pg->mdpage.pvh_lock);
+	mutex_exit(&md->pvh_lock);
+}
 void
 pmap_page_remove_locked(struct vm_page *pg)
+{
 	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 (pg->mdpage.pvh_list == NULL)
+	if (md->pvh_list == NULL)
 		return;
-	pvp = &pg->mdpage.pvh_list;
+	pvp = &md->pvh_list;
-	for (pve = pg->mdpage.pvh_list; pve; pve = npve) {
+	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);
 		pde = pmap_pde_get(pmap->pm_pdir, va);
 		pte = pmap_pte_get(pde, va);
 		npve = pve->pv_next;
 		/*
 		 * If this was an unmanaged mapping, it must be preserved. Move
 		 * it back on the list and advance the end-of-list pointer.
 		 */
 		if (pve->pv_va & PV_KENTER) {
 			*pvp = pve;
 			pvp = &pve->pv_next;
 		} else
-			pg->mdpage.pvh_attrs |= pmap_pvh_attrs(pte);
+			md->pvh_attrs |= pmap_pvh_attrs(pte);
 		pmap_pte_flush(pmap, va, pte);
 		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);
+	}
 	*pvp = NULL;
 @@ -1460,99 +1475,101 @@ pmap_unwire(pmap_t pmap, vaddr_t va)
 			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__));
+}
 bool
 pmap_changebit(struct vm_page *pg, u_int set, u_int 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 & ~(PVF_REF|PVF_UNCACHEABLE)) == 0);
 	KASSERT((clear & ~(PVF_MOD|PVF_WRITE|PVF_UNCACHEABLE)) == 0);
-	mutex_enter(&pg->mdpage.pvh_lock);
+	mutex_enter(&md->pvh_lock);
 	/* preserve other bits */
-	res = pg->mdpage.pvh_attrs & (set | clear);
+	res = md->pvh_attrs & (set | clear);
-	pg->mdpage.pvh_attrs ^= res;
+	md->pvh_attrs ^= res;
-	for (pve = pg->mdpage.pvh_list; pve; pve = pve->pv_next) {
+	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
 			if (!pte) {
 				DPRINTF(PDB_FOLLOW|PDB_BITS,
 				    ("%s: zero pte for 0x%lx\n", __func__,
 				    va));
 				continue;
+			}
 #endif
 			pte &= ~clear;
 			pte |= set;
 			if (!(pve->pv_va & PV_KENTER)) {
-				pg->mdpage.pvh_attrs |= pmap_pvh_attrs(pte);
+				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);
+			}
+		}
+	}
-	mutex_exit(&pg->mdpage.pvh_lock);
+	mutex_exit(&md->pvh_lock);
 	return ((res & (clear | set)) != 0);
+}
 bool
 pmap_testbit(struct vm_page *pg, u_int bit)
+{
 	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));
-	mutex_enter(&pg->mdpage.pvh_lock);
+	mutex_enter(&md->pvh_lock);
-	for (pve = pg->mdpage.pvh_list; !(pg->mdpage.pvh_attrs & bit) && pve;
+	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;
-		pg->mdpage.pvh_attrs |= pmap_pvh_attrs(pte);
+		md->pvh_attrs |= pmap_pvh_attrs(pte);
+	}
-	ret = ((pg->mdpage.pvh_attrs & bit) != 0);
+	ret = ((md->pvh_attrs & bit) != 0);
-	mutex_exit(&pg->mdpage.pvh_lock);
+	mutex_exit(&md->pvh_lock);
 	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)
 @@ -1591,32 +1608,33 @@ pmap_activate(struct lwp *l)
 	/* space is cached for the copy{in,out}'s pleasure */
 	pcb->pcb_space = space;
 	fdcache(HPPA_SID_KERNEL, (vaddr_t)pcb, sizeof(struct pcb));
 	if (p == curproc)
 		mtctl(pmap->pm_pid, CR_PIDR2);
+}
 static inline void
 pmap_flush_page(struct vm_page *pg, bool purge)
+{
 	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 = pg->mdpage.pvh_list; pve; pve = pve->pv_next) {
+	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);
 		pitlb(sp, va);
 #endif
 @@ -1624,52 +1642,52 @@ pmap_flush_page(struct vm_page *pg, bool
+}
 /*
  * 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));
-	KASSERT(PHYS_TO_VM_PAGE(pa)->mdpage.pvh_list == NULL);
+	KASSERT(VM_PAGE_TO_MD(PHYS_TO_VM_PAGE(pa))->pvh_list == NULL);
 	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);
 	DPRINTF(PDB_FOLLOW|PDB_PHYS, ("%s(%lx, %lx)\n", __func__, spa, dpa));
-	KASSERT(PHYS_TO_VM_PAGE(dpa)->mdpage.pvh_list == NULL);
+	KASSERT(VM_PAGE_TO_MD(PHYS_TO_VM_PAGE(dpa))->pvh_list == NULL);
 	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);
 @@ -1707,44 +1725,46 @@ pmap_kenter_pa(vaddr_t va, paddr_t pa, v
 	    pmap_prot(pmap_kernel(), prot & VM_PROT_ALL));
 	if (pa >= HPPA_IOBEGIN || (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);
 	if (pmap_initialized) {
 		struct vm_page *pg;
 		pg = PHYS_TO_VM_PAGE(PTE_PAGE(pte));
 		if (pg != NULL) {
 			struct vm_page_md * const md = VM_PAGE_TO_MD(pg);
 			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", __func__,
 			    va, pa, pte));
-			mutex_enter(&pg->mdpage.pvh_lock);
+			mutex_enter(&md->pvh_lock);
 			if (pmap_check_alias(pg, va, pte))
 				pmap_page_remove_locked(pg);
 			pmap_pv_enter(pg, pve, pmap_kernel(), va, NULL,
 			    PV_KENTER);
-			mutex_exit(&pg->mdpage.pvh_lock);
+			mutex_exit(&md->pvh_lock);
+		}
+	}
 	pmap_pte_set(pde, va, pte);
 	DPRINTF(PDB_FOLLOW|PDB_ENTER, ("%s: leaving\n", __func__));
 #ifdef PMAPDEBUG
 	pmapdebug = opmapdebug;
 #endif /* PMAPDEBUG */
+}
 void
 pmap_kremove(vaddr_t va, vsize_t size)
 @@ -1793,32 +1813,33 @@ pmap_kremove(vaddr_t va, vsize_t size)
 				continue;
+			}
+		}
 		if (!(pte = pmap_pte_get(pde, va))) {
 			DPRINTF(PDB_FOLLOW|PDB_REMOVE,
 			    ("%s: unmapping unmapped 0x%lx\n", __func__,
 			    va));
 			continue;
+		}
 		pmap_pte_flush(pmap, va, pte);
 		pmap_pte_set(pde, va, 0);
 		if (pmap_initialized && (pg = PHYS_TO_VM_PAGE(PTE_PAGE(pte)))) {
 			struct vm_page_md * const md = VM_PAGE_TO_MD(pg);
-			mutex_enter(&pg->mdpage.pvh_lock);
+			mutex_enter(&md->pvh_lock);
 			pve = pmap_pv_remove(pg, pmap, va);
-			mutex_exit(&pg->mdpage.pvh_lock);
+			mutex_exit(&md->pvh_lock);
 			if (pve != NULL)
 				pmap_pv_free(pve);
+		}
+	}
 	DPRINTF(PDB_FOLLOW|PDB_REMOVE, ("%s: leaving\n", __func__));
 #ifdef PMAPDEBUG
 	pmapdebug = opmapdebug;
 #endif /* PMAPDEBUG */
+}
 #if defined(USE_HPT)
 #if defined(DDB)