src/sys/arch/m68k/m68k/pmap_motorola.c - diff

Return to pmap_motorola.c CVS log

Up to [cvs.NetBSD.org] / src / sys / arch / m68k / m68k

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/arch/m68k/m68k/pmap_motorola.c between version 1.17 and 1.17.2.1

version 1.17, 2005/06/03 08:55:33

version 1.17.2.1, 2006/12/30 20:46:25

Line 276 pt_entry_t *caddr2_pte; /* PTE for CADDR

struct pool pmap_pmap_pool; /* memory pool for pmap structures */

struct pv_entry *pmap_alloc_pv __P((void));

struct pv_entry *pmap_alloc_pv(void);

void pmap_free_pv __P((struct pv_entry *));

void pmap_free_pv(struct pv_entry *);

void pmap_collect_pv __P((void));

void pmap_collect_pv(void);

#ifdef COMPAT_HPUX

int pmap_mapmulti __P((pmap_t, vaddr_t));

int pmap_mapmulti(pmap_t, vaddr_t);

#endif /* COMPAT_HPUX */

#define PAGE_IS_MANAGED(pa) (pmap_initialized && \

Line 288 int pmap_mapmulti __P((pmap_t, vaddr_t))

#define pa_to_pvh(pa) \

({ \

int bank_, pg_; \

int bank_, pg_ = 0; /* XXX gcc4 -Wuninitialized */ \

bank_ = vm_physseg_find(atop((pa)), &pg_); \

&vm_physmem[bank_].pmseg.pvent[pg_]; \

Line 296 int pmap_mapmulti __P((pmap_t, vaddr_t))

#define pa_to_attribute(pa) \

({ \

int bank_, pg_; \

int bank_, pg_ = 0; /* XXX gcc4 -Wuninitialized */ \

bank_ = vm_physseg_find(atop((pa)), &pg_); \

&vm_physmem[bank_].pmseg.attrs[pg_]; \

Line 305 int pmap_mapmulti __P((pmap_t, vaddr_t))

* Internal routines

void pmap_remove_mapping __P((pmap_t, vaddr_t, pt_entry_t *, int));

void pmap_remove_mapping(pmap_t, vaddr_t, pt_entry_t *, int);

void pmap_do_remove __P((pmap_t, vaddr_t, vaddr_t, int));

void pmap_do_remove(pmap_t, vaddr_t, vaddr_t, int);

boolean_t pmap_testbit __P((paddr_t, int));

boolean_t pmap_testbit(paddr_t, int);

boolean_t pmap_changebit __P((paddr_t, int, int));

boolean_t pmap_changebit(paddr_t, int, int);

void pmap_enter_ptpage __P((pmap_t, vaddr_t));

boolean_t pmap_enter_ptpage(pmap_t, vaddr_t, boolean_t);

void pmap_ptpage_addref __P((vaddr_t));

void pmap_ptpage_addref(vaddr_t);

int pmap_ptpage_delref __P((vaddr_t));

int pmap_ptpage_delref(vaddr_t);

void pmap_collect1 __P((pmap_t, paddr_t, paddr_t));

void pmap_collect1(pmap_t, paddr_t, paddr_t);

void pmap_pinit __P((pmap_t));

void pmap_pinit(pmap_t);

void pmap_release __P((pmap_t));

void pmap_release(pmap_t);

#ifdef DEBUG

void pmap_pvdump __P((paddr_t));

void pmap_pvdump(paddr_t);

void pmap_check_wiring __P((const char *, vaddr_t));

void pmap_check_wiring(const char *, vaddr_t);

#endif

/* pmap_remove_mapping flags */

Line 355 pmap_virtual_space(vstartp, vendp)

* Note: no locking is necessary in this function.

void

pmap_init()

pmap_init(void)

{

vaddr_t addr, addr2;

vsize_t s;

Line 395 pmap_init()

if (addr == 0)

panic("pmap_init: can't allocate data structures");

Segtabzero = (st_entry_t *) addr;

Segtabzero = (st_entry_t *)addr;

(void) pmap_extract(pmap_kernel(), addr, (paddr_t *)(void *)&Segtabzeropa);

(void)pmap_extract(pmap_kernel(), addr,

(paddr_t *)(void *)&Segtabzeropa);

addr += M68K_STSIZE;

pv_table = (struct pv_entry *) addr;

addr += page_cnt * sizeof(struct pv_entry);

pmap_attributes = (char *) addr;

pmap_attributes = (char *)addr;

PMAP_DPRINTF(PDB_INIT, ("pmap_init: %lx bytes: page_cnt %x s0 %p(%p) "

"tbl %p atr %p\n",

Line 436 pmap_init()

Line 437 pmap_init()

addr = 0;

rv = uvm_map(kernel_map, &addr, s, NULL, UVM_UNKNOWN_OFFSET, 0,

UVM_MAPFLAG(UVM_PROT_NONE, UVM_PROT_NONE, UVM_INH_NONE,

UVM_ADV_RANDOM, UVM_FLAG_NOMERGE));

if (rv != 0 || (addr + s) >= (vaddr_t)Sysmap)

panic("pmap_init: kernel PT too small");

uvm_unmap(kernel_map, addr, addr + s);

Line 543 pmap_init()

Line 544 pmap_init()

* Allocate a pv_entry.

struct pv_entry *

pmap_alloc_pv()

pmap_alloc_pv(void)

{

struct pv_page *pvp;

struct pv_entry *pv;

Line 583 pmap_alloc_pv()

Line 584 pmap_alloc_pv()

* Free a pv_entry.

void

pmap_free_pv(pv)

pmap_free_pv(struct pv_entry *pv)

struct pv_entry *pv;

{

struct pv_page *pvp;

pvp = (struct pv_page *) trunc_page((vaddr_t)pv);

pvp = (struct pv_page *)trunc_page((vaddr_t)pv);

switch (++pvp->pvp_pgi.pgi_nfree) {

case 1:

TAILQ_INSERT_TAIL(&pv_page_freelist, pvp, pvp_pgi.pgi_list);

Line 611 pmap_free_pv(pv)

* Perform compaction on the PV list, called via pmap_collect().

void

pmap_collect_pv()

pmap_collect_pv(void)

{

struct pv_page_list pv_page_collectlist;

struct pv_page *pvp, *npvp;

Line 651 pmap_collect_pv()

npv = pvp->pvp_pgi.pgi_freelist;

#ifdef DIAGNOSTIC

if (npv == 0)

panic("pmap_collect_pv: pgi_nfree inconsistent");

panic("pmap_collect_pv: "

"pgi_nfree inconsistent");

#endif

pvp->pvp_pgi.pgi_freelist = npv->pv_next;

*npv = *pv;

Line 681 pmap_collect_pv()

Line 682 pmap_collect_pv()

* Note: THIS FUNCTION IS DEPRECATED, AND SHOULD BE REMOVED!

vaddr_t

pmap_map(va, spa, epa, prot)

pmap_map(vaddr_t va, paddr_t spa, paddr_t epa, int prot)

vaddr_t va;

paddr_t spa, epa;

int prot;

{

PMAP_DPRINTF(PDB_FOLLOW,

Line 696 pmap_map(va, spa, epa, prot)

Line 694 pmap_map(va, spa, epa, prot)

spa += PAGE_SIZE;

}

pmap_update(pmap_kernel());

return (va);

return va;

}

Line 707 pmap_map(va, spa, epa, prot)

Line 705 pmap_map(va, spa, epa, prot)

* Note: no locking is necessary in this function.

pmap_t

pmap_create()

pmap_create(void)

{

struct pmap *pmap;

Line 717 pmap_create()

Line 715 pmap_create()

pmap = pool_get(&pmap_pmap_pool, PR_WAITOK);

memset(pmap, 0, sizeof(*pmap));

pmap_pinit(pmap);

return (pmap);

return pmap;

}

Line 728 pmap_create()

Line 726 pmap_create()

* Note: THIS FUNCTION SHOULD BE MOVED INTO pmap_create()!

void

pmap_pinit(pmap)

pmap_pinit(struct pmap *pmap)

struct pmap *pmap;

{

PMAP_DPRINTF(PDB_FOLLOW|PDB_CREATE,

Line 760 pmap_pinit(pmap)

Line 757 pmap_pinit(pmap)

* all resources if the reference count drops to zero.

void

pmap_destroy(pmap)

pmap_destroy(pmap_t pmap)

struct pmap *pmap;

{

int count;

Line 784 pmap_destroy(pmap)

Line 780 pmap_destroy(pmap)

* Note: THIS FUNCTION SHOULD BE MOVED INTO pmap_destroy().

void

pmap_release(pmap)

pmap_release(pmap_t pmap)

struct pmap *pmap;

{

PMAP_DPRINTF(PDB_FOLLOW, ("pmap_release(%p)\n", pmap));

Line 814 pmap_release(pmap)

Line 809 pmap_release(pmap)

* Add a reference to the specified pmap.

void

pmap_reference(pmap)

pmap_reference(pmap_t pmap)

pmap_t pmap;

{

PMAP_DPRINTF(PDB_FOLLOW, ("pmap_reference(%p)\n", pmap));

Line 835 pmap_reference(pmap)

Line 829 pmap_reference(pmap)

* by a critical section in cpu_switch()!

void

pmap_activate(l)

pmap_activate(struct lwp *l)

struct lwp *l;

{

struct pmap *pmap = l->l_proc->p_vmspace->vm_map.pmap;

pmap_t pmap = l->l_proc->p_vmspace->vm_map.pmap;

PMAP_DPRINTF(PDB_FOLLOW|PDB_SEGTAB,

("pmap_activate(%p)\n", l));

Line 856 pmap_activate(l)

Line 849 pmap_activate(l)

* as well.

void

pmap_deactivate(l)

pmap_deactivate(struct lwp *l)

struct lwp *l;

{

/* No action necessary in this pmap implementation. */

Line 872 pmap_deactivate(l)

Line 864 pmap_deactivate(l)

* rounded to the page size.

void

pmap_remove(pmap, sva, eva)

pmap_remove(pmap_t pmap, vaddr_t sva, vaddr_t eva)

struct pmap *pmap;

vaddr_t sva, eva;

{

pmap_do_remove(pmap, sva, eva, 1);

}

void

pmap_do_remove(pmap, sva, eva, remove_wired)

pmap_do_remove(pmap_t pmap, vaddr_t sva, vaddr_t eva, int remove_wired)

struct pmap *pmap;

vaddr_t sva, eva;

int remove_wired;

{

vaddr_t nssva;

pt_entry_t *pte;

Line 993 pmap_do_remove(pmap, sva, eva, remove_wi

Line 980 pmap_do_remove(pmap, sva, eva, remove_wi

* the permissions specified.

void

pmap_page_protect(pg, prot)

pmap_page_protect(struct vm_page *pg, vm_prot_t prot)

struct vm_page *pg;

vm_prot_t prot;

{

paddr_t pa = VM_PAGE_TO_PHYS(pg);

struct pv_entry *pv;

Line 1047 pmap_page_protect(pg, prot)

Line 1032 pmap_page_protect(pg, prot)

* as requested.

void

pmap_protect(pmap, sva, eva, prot)

pmap_protect(pmap_t pmap, vaddr_t sva, vaddr_t eva, vm_prot_t prot)

pmap_t pmap;

vaddr_t sva, eva;

vm_prot_t prot;

{

vaddr_t nssva;

pt_entry_t *pte;

Line 1154 pmap_protect(pmap, sva, eva, prot)

Line 1136 pmap_protect(pmap, sva, eva, prot)

* insert this page into the given map NOW.

int

pmap_enter(pmap, va, pa, prot, flags)

pmap_enter(pmap_t pmap, vaddr_t va, paddr_t pa, vm_prot_t prot, int flags)

struct pmap *pmap;

vaddr_t va;

paddr_t pa;

vm_prot_t prot;

int flags;

{

pt_entry_t *pte;

int npte;

Line 1167 pmap_enter(pmap, va, pa, prot, flags)

Line 1144 pmap_enter(pmap, va, pa, prot, flags)

boolean_t cacheable = TRUE;

boolean_t checkpv = TRUE;

boolean_t wired = (flags & PMAP_WIRED) != 0;

boolean_t can_fail = (flags & PMAP_CANFAIL) != 0;

PMAP_DPRINTF(PDB_FOLLOW|PDB_ENTER,

("pmap_enter(%p, %lx, %lx, %x, %x)\n",

Line 1184 pmap_enter(pmap, va, pa, prot, flags)

Line 1162 pmap_enter(pmap, va, pa, prot, flags)

* For user mapping, allocate kernel VM resources if necessary.

if (pmap->pm_ptab == NULL)

if (pmap->pm_ptab == NULL) {

pmap->pm_ptab = (pt_entry_t *)

uvm_km_alloc(pt_map, M68K_MAX_PTSIZE, 0,

UVM_KMF_VAONLY | UVM_KMF_WAITVA);

UVM_KMF_VAONLY |

(can_fail ? UVM_KMF_NOWAIT : UVM_KMF_WAITVA));

if (pmap->pm_ptab == NULL)

return ENOMEM;

}

* Segment table entry not valid, we need a new PT page

if (!pmap_ste_v(pmap, va))

if (!pmap_ste_v(pmap, va)) {

pmap_enter_ptpage(pmap, va);

int err = pmap_enter_ptpage(pmap, va, can_fail);

if (err)

return err;

}

pa = m68k_trunc_page(pa);

pte = pmap_pte(pmap, va);

Line 1454 validate:

Line 1439 validate:

}

void

pmap_kenter_pa(va, pa, prot)

pmap_kenter_pa(vaddr_t va, paddr_t pa, vm_prot_t prot)

vaddr_t va;

paddr_t pa;

vm_prot_t prot;

{

struct pmap *pmap = pmap_kernel();

pmap_t pmap = pmap_kernel();

pt_entry_t *pte;

int s, npte;

Line 1472 pmap_kenter_pa(va, pa, prot)

Line 1454 pmap_kenter_pa(va, pa, prot)

if (!pmap_ste_v(pmap, va)) {

s = splvm();

pmap_enter_ptpage(pmap, va);

pmap_enter_ptpage(pmap, va, FALSE);

splx(s);

}

Line 1513 pmap_kenter_pa(va, pa, prot)

Line 1495 pmap_kenter_pa(va, pa, prot)

}

void

pmap_kremove(va, size)

pmap_kremove(vaddr_t va, vsize_t size)

vaddr_t va;

vsize_t size;

{

struct pmap *pmap = pmap_kernel();

pmap_t pmap = pmap_kernel();

pt_entry_t *pte;

vaddr_t nssva;

vaddr_t eva = va + size;

Line 1620 pmap_kremove(va, size)

Line 1600 pmap_kremove(va, size)

* The mapping must already exist in the pmap.

void

pmap_unwire(pmap, va)

pmap_unwire(pmap_t pmap, vaddr_t va)

pmap_t pmap;

vaddr_t va;

{

pt_entry_t *pte;

Line 1650 pmap_unwire(pmap, va)

Line 1628 pmap_unwire(pmap, va)

* pmap/virtual address pair.

boolean_t

pmap_extract(pmap, va, pap)

pmap_extract(pmap_t pmap, vaddr_t va, paddr_t *pap)

pmap_t pmap;

vaddr_t va;

paddr_t *pap;

{

paddr_t pa;

u_int pte;

Line 1671 pmap_extract(pmap, va, pap)

Line 1646 pmap_extract(pmap, va, pap)

if (pmapdebug & PDB_FOLLOW)

printf("%lx\n", pa);

#endif

return (TRUE);

return TRUE;

}

#ifdef DEBUG

if (pmapdebug & PDB_FOLLOW)

printf("failed\n");

#endif

return (FALSE);

return FALSE;

}

Line 1691 pmap_extract(pmap, va, pap)

Line 1666 pmap_extract(pmap, va, pap)

* This routine is only advisory and need not do anything.

void

pmap_copy(dst_pmap, src_pmap, dst_addr, len, src_addr)

pmap_copy(pmap_t dst_pmap, pmap_t src_pmap, vaddr_t dst_addr, vsize_t len,

pmap_t dst_pmap;

vaddr_t src_addr)

pmap_t src_pmap;

vaddr_t dst_addr;

vsize_t len;

vaddr_t src_addr;

{

PMAP_DPRINTF(PDB_FOLLOW,

Line 1715 pmap_copy(dst_pmap, src_pmap, dst_addr,

Line 1686 pmap_copy(dst_pmap, src_pmap, dst_addr,

* Called by the pageout daemon when pages are scarce.

void

pmap_collect(pmap)

pmap_collect(pmap_t pmap)

pmap_t pmap;

{

PMAP_DPRINTF(PDB_FOLLOW, ("pmap_collect(%p)\n", pmap));

Line 1761 pmap_collect(pmap)

Line 1731 pmap_collect(pmap)

* WAY OF HANDLING PT PAGES!

void

pmap_collect1(pmap, startpa, endpa)

pmap_collect1(pmap_t pmap, paddr_t startpa, paddr_t endpa)

pmap_t pmap;

paddr_t startpa, endpa;

{

paddr_t pa;

struct pv_entry *pv;

Line 1808 pmap_collect1(pmap, startpa, endpa)

Line 1776 pmap_collect1(pmap, startpa, endpa)

#ifdef DEBUG

if (pmapdebug & (PDB_PTPAGE|PDB_COLLECT)) {

printf("collect: freeing KPT page at %lx (ste %x@%p)\n",

pv->pv_va, *pv->pv_ptste, pv->pv_ptste);

opmapdebug = pmapdebug;

pmapdebug |= PDB_PTPAGE;

}

Line 1841 pmap_collect1(pmap, startpa, endpa)

Line 1809 pmap_collect1(pmap, startpa, endpa)

panic("pmap_collect: lost a KPT page");

if (pmapdebug & (PDB_PTPAGE|PDB_COLLECT))

printf("collect: %lx (%lx) to free list\n",

kpt->kpt_va, kpa);

#endif

*pkpt = kpt->kpt_next;

kpt->kpt_next = kpt_free_list;

Line 1852 pmap_collect1(pmap, startpa, endpa)

Line 1820 pmap_collect1(pmap, startpa, endpa)

if (*ste != SG_NV)

printf("collect: kernel STE at %p still valid (%x)\n",

ste, *ste);

ste = &Sysptmap[ste - pmap_ste(pmap_kernel(), 0)];

if (*ste != SG_NV)

printf("collect: kernel PTmap at %p still valid (%x)\n",

ste, *ste);

#endif

}

Line 1873 pmap_collect1(pmap, startpa, endpa)

Line 1841 pmap_collect1(pmap, startpa, endpa)

* support multiple processors, this is sufficient.)

void

pmap_zero_page(phys)

pmap_zero_page(paddr_t phys)

paddr_t phys;

{

int npte;

Line 1931 pmap_zero_page(phys)

Line 1898 pmap_zero_page(phys)

* support multiple processors, this is sufficient.)

void

pmap_copy_page(src, dst)

pmap_copy_page(paddr_t src, paddr_t dst)

paddr_t src, dst;

{

int npte1, npte2;

Line 1992 pmap_copy_page(src, dst)

Line 1958 pmap_copy_page(src, dst)

* Clear the modify bits on the specified physical page.

boolean_t

pmap_clear_modify(pg)

pmap_clear_modify(struct vm_page *pg)

struct vm_page *pg;

{

paddr_t pa = VM_PAGE_TO_PHYS(pg);

Line 2008 pmap_clear_modify(pg)

Line 1973 pmap_clear_modify(pg)

* Clear the reference bit on the specified physical page.

boolean_t

pmap_clear_reference(pg)

pmap_clear_reference(struct vm_page *pg)

struct vm_page *pg;

{

paddr_t pa = VM_PAGE_TO_PHYS(pg);

Line 2025 pmap_clear_reference(pg)

Line 1989 pmap_clear_reference(pg)

* by any physical maps.

boolean_t

pmap_is_referenced(pg)

pmap_is_referenced(struct vm_page *pg)

struct vm_page *pg;

{

paddr_t pa = VM_PAGE_TO_PHYS(pg);

return (pmap_testbit(pa, PG_U));

return pmap_testbit(pa, PG_U);

}

Line 2040 pmap_is_referenced(pg)

Line 2003 pmap_is_referenced(pg)

* by any physical maps.

boolean_t

pmap_is_modified(pg)

pmap_is_modified(struct vm_page *pg)

struct vm_page *pg;

{

paddr_t pa = VM_PAGE_TO_PHYS(pg);

return (pmap_testbit(pa, PG_M));

return pmap_testbit(pa, PG_M);

}

Line 2058 pmap_is_modified(pg)

Line 2020 pmap_is_modified(pg)

* Note: no locking is necessary in this function.

paddr_t

pmap_phys_address(ppn)

pmap_phys_address(int ppn)

int ppn;

{

return(m68k_ptob(ppn));

return m68k_ptob(ppn);

}

#ifdef M68K_MMU_HP

Line 2072 pmap_phys_address(ppn)

Line 2033 pmap_phys_address(ppn)

* cause a virtually-addressed cache alias problem.

void

pmap_prefer(foff, vap)

pmap_prefer(vaddr_t foff, vaddr_t *vap)

vaddr_t foff, *vap;

{

vaddr_t va;

vsize_t d;

Line 2102 pmap_prefer(foff, vap)

Line 2062 pmap_prefer(foff, vap)

* VM knows nothing about it.

int

pmap_mapmulti(pmap, va)

pmap_mapmulti(pmap_t pmap, vaddr_t va)

struct pmap *pmap;

vaddr_t va;

{

st_entry_t *ste, *bste;

Line 2112 pmap_mapmulti(pmap, va)

Line 2070 pmap_mapmulti(pmap, va)

if (pmapdebug & PDB_MULTIMAP) {

ste = pmap_ste(pmap, HPMMBASEADDR(va));

printf("pmap_mapmulti(%p, %lx): bste %p(%x)",

pmap, va, ste, *ste);

ste = pmap_ste(pmap, va);

printf(" ste %p(%x)\n", ste, *ste);

}

Line 2149 pmap_mapmulti(pmap, va)

Line 2107 pmap_mapmulti(pmap, va)

/* static */

void

pmap_remove_mapping(pmap, va, pte, flags)

pmap_remove_mapping(pmap_t pmap, vaddr_t va, pt_entry_t *pte, int flags)

struct pmap *pmap;

vaddr_t va;

pt_entry_t *pte;

int flags;

{

paddr_t pa;

struct pv_entry *pv, *npv;

Line 2274 pmap_remove_mapping(pmap, va, pte, flags

Line 2228 pmap_remove_mapping(pmap, va, pte, flags

#endif

pmap_remove_mapping(pmap_kernel(), ptpva,

NULL, PRM_TFLUSH|PRM_CFLUSH);

simple_lock(&uvm.kernel_object->vmobjlock);

uvm_pagefree(PHYS_TO_VM_PAGE(ptppa));

simple_unlock(&uvm.kernel_object->vmobjlock);

PMAP_DPRINTF(PDB_REMOVE|PDB_PTPAGE,

("remove: PT page 0x%lx (0x%lx) freed\n",

ptpva, ptppa));

Line 2441 pmap_remove_mapping(pmap, va, pte, flags

Line 2397 pmap_remove_mapping(pmap, va, pte, flags

/* static */

boolean_t

pmap_testbit(pa, bit)

pmap_testbit(paddr_t pa, int bit)

paddr_t pa;

int bit;

{

struct pv_entry *pv;

pt_entry_t *pte;

Line 2458 pmap_testbit(pa, bit)

Line 2412 pmap_testbit(pa, bit)

if (*pa_to_attribute(pa) & bit) {

splx(s);

return(TRUE);

return TRUE;

}

#ifdef M68K_MMU_HP

Line 2482 pmap_testbit(pa, bit)

Line 2436 pmap_testbit(pa, bit)

if (*pte & bit) {

*pa_to_attribute(pa) |= bit;

splx(s);

return (TRUE);

return TRUE;

}

splx(s);

return (FALSE);

return FALSE;

}

Line 2498 pmap_testbit(pa, bit)

Line 2452 pmap_testbit(pa, bit)

/* static */

boolean_t

pmap_changebit(pa, set, mask)

pmap_changebit(paddr_t pa, int set, int mask)

paddr_t pa;

int set, mask;

{

struct pv_entry *pv;

pt_entry_t *pte, npte;

Line 2581 pmap_changebit(pa, set, mask)

Line 2533 pmap_changebit(pa, set, mask)

}

splx(s);

return(r);

return r;

}

Line 2590 pmap_changebit(pa, set, mask)

Line 2542 pmap_changebit(pa, set, mask)

* Allocate and map a PT page for the specified pmap/va pair.

/* static */

void

int

pmap_enter_ptpage(pmap, va)

pmap_enter_ptpage(pmap_t pmap, vaddr_t va, boolean_t can_fail)

struct pmap *pmap;

vaddr_t va;

{

paddr_t ptpa;

struct vm_page *pg;

Line 2614 pmap_enter_ptpage(pmap, va)

Line 2564 pmap_enter_ptpage(pmap, va)

if (pmap->pm_stab == Segtabzero) {

pmap->pm_stab = (st_entry_t *)

uvm_km_alloc(st_map, M68K_STSIZE, 0,

UVM_KMF_WIRED | UVM_KMF_ZERO);

UVM_KMF_WIRED | UVM_KMF_ZERO |

(can_fail ? UVM_KMF_NOWAIT : 0));

if (pmap->pm_stab == NULL) {

pmap->pm_stab = Segtabzero;

return ENOMEM;

}

(void) pmap_extract(pmap_kernel(), (vaddr_t)pmap->pm_stab,

(paddr_t *)&pmap->pm_stpa);

#if defined(M68040) || defined(M68060)

Line 2622 pmap_enter_ptpage(pmap, va)

Line 2577 pmap_enter_ptpage(pmap, va)

if (mmutype == MMU_68040)

#endif

{

if (pmap_changebit((paddr_t)pmap->pm_stpa,

pt_entry_t *pte;

PG_CI, ~PG_CCB))

DCIS();

pte = pmap_pte(pmap_kernel(), pmap->pm_stab);

*pte = (*pte & ~PG_CMASK) | PG_CI;

pmap->pm_stfree = protostfree;

}

#endif

Line 2715 pmap_enter_ptpage(pmap, va)

Line 2671 pmap_enter_ptpage(pmap, va)

int ix = pmap_ste(pmap, va) - pmap_ste(pmap, 0);

printf("enter: add &Sysptmap[%d]: %x (KPT page %lx)\n",

ix, Sysptmap[ix], kpt->kpt_va);

}

#endif

splx(s);

Line 2734 pmap_enter_ptpage(pmap, va)

Line 2690 pmap_enter_ptpage(pmap, va)

pmap->pm_sref++;

PMAP_DPRINTF(PDB_ENTER|PDB_PTPAGE,

("enter: about to alloc UPT pg at %lx\n", va));

simple_lock(&uvm.kernel_object->vmobjlock);

while ((pg = uvm_pagealloc(uvm.kernel_object,

va - vm_map_min(kernel_map),

NULL, UVM_PGA_ZERO)) == NULL) {

simple_unlock(&uvm.kernel_object->vmobjlock);

uvm_wait("ptpage");

simple_lock(&uvm.kernel_object->vmobjlock);

}

simple_unlock(&uvm.kernel_object->vmobjlock);

pg->flags &= ~(PG_BUSY|PG_FAKE);

UVM_PAGE_OWN(pg, NULL);

ptpa = VM_PAGE_TO_PHYS(pg);

Line 2760 pmap_enter_ptpage(pmap, va)

Line 2720 pmap_enter_ptpage(pmap, va)

pt_entry_t *pte = pmap_pte(pmap_kernel(), va);

if ((pmapdebug & PDB_PARANOIA) && (*pte & PG_CCB) == 0)

printf("%s PT no CCB: kva=%lx ptpa=%lx pte@%p=%x\n",

pmap == pmap_kernel() ? "Kernel" : "User",

va, ptpa, pte, *pte);

#endif

if (pmap_changebit(ptpa, PG_CI, ~PG_CCB))

DCIS();

Line 2832 pmap_enter_ptpage(pmap, va)

Line 2792 pmap_enter_ptpage(pmap, va)

TBIAU();

pmap->pm_ptpages++;

splx(s);

return 0;

}

Line 2840 pmap_enter_ptpage(pmap, va)

Line 2802 pmap_enter_ptpage(pmap, va)

* Add a reference to the specified PT page.

void

pmap_ptpage_addref(ptpva)

pmap_ptpage_addref(vaddr_t ptpva)

vaddr_t ptpva;

{

struct vm_page *pg;

Line 2860 pmap_ptpage_addref(ptpva)

Line 2821 pmap_ptpage_addref(ptpva)

* Delete a reference to the specified PT page.

int

pmap_ptpage_delref(ptpva)

pmap_ptpage_delref(vaddr_t ptpva)

vaddr_t ptpva;

{

struct vm_page *pg;

int rv;

Line 2873 pmap_ptpage_delref(ptpva)

Line 2833 pmap_ptpage_delref(ptpva)

("ptpage delref: pg %p now %d\n",

pg, pg->wire_count));

simple_unlock(&uvm.kernel_object->vmobjlock);

return (rv);

return rv;

}

Line 2883 pmap_ptpage_delref(ptpva)

Line 2843 pmap_ptpage_delref(ptpva)

* Synchronize caches corresponding to [addr, addr + len) in p.

void

pmap_procwr(p, va, len)

pmap_procwr(struct proc *p, vaddr_t va, size_t len)

struct proc *p;

vaddr_t va;

size_t len;

{

(void)cachectl1(0x80000004, va, len, p);

}

#ifdef mvme68k

void

_pmap_set_page_cacheable(pm, va)

_pmap_set_page_cacheable(pmap_t pmap, vaddr_t va)

struct pmap *pm;

vaddr_t va;

{

if (!pmap_ste_v(pm, va))

if (!pmap_ste_v(pmap, va))

return;

#if defined(M68040) || defined(M68060)

#if defined(M68020) || defined(M68030)

if (mmutype == MMU_68040)

if (mmutype == MMU_68040) {

{

#endif

if (pmap_changebit(pmap_pte_pa(pmap_pte(pm, va)), PG_CCB, ~PG_CI))

if (pmap_changebit(pmap_pte_pa(pmap_pte(pmap, va)), PG_CCB, ~PG_CI))

DCIS();

#if defined(M68020) || defined(M68030)

} else

pmap_changebit(pmap_pte_pa(pmap_pte(pm, va)), 0, ~PG_CI);

pmap_changebit(pmap_pte_pa(pmap_pte(pmap, va)), 0, ~PG_CI);

#endif

#else

pmap_changebit(pmap_pte_pa(pmap_pte(pm, va)), 0, ~PG_CI);

pmap_changebit(pmap_pte_pa(pmap_pte(pmap, va)), 0, ~PG_CI);

#endif

}

void

_pmap_set_page_cacheinhibit(pm, va)

_pmap_set_page_cacheinhibit(pmap_t pmap, vaddr_t va)

struct pmap *pm;

vaddr_t va;

{

if (!pmap_ste_v(pm, va))

if (!pmap_ste_v(pmap, va))

return;

#if defined(M68040) || defined(M68060)

#if defined(M68020) || defined(M68030)

if (mmutype == MMU_68040)

if (mmutype == MMU_68040) {

{

#endif

if (pmap_changebit(pmap_pte_pa(pmap_pte(pm, va)), PG_CI, ~PG_CCB))

if (pmap_changebit(pmap_pte_pa(pmap_pte(pmap, va)), PG_CI, ~PG_CCB))

DCIS();

#if defined(M68020) || defined(M68030)

} else

pmap_changebit(pmap_pte_pa(pmap_pte(pm, va)), PG_CI, ~0);

pmap_changebit(pmap_pte_pa(pmap_pte(pmap, va)), PG_CI, ~0);

#endif

#else

pmap_changebit(pmap_pte_pa(pmap_pte(pm, va)), PG_CI, ~0);

pmap_changebit(pmap_pte_pa(pmap_pte(pmap, va)), PG_CI, ~0);

#endif

}

int

_pmap_page_is_cacheable(pm, va)

_pmap_page_is_cacheable(pmap_t pmap, vaddr_t va)

struct pmap *pm;

vaddr_t va;

{

if (!pmap_ste_v(pm, va))

if (!pmap_ste_v(pmap, va))

return (0);

return 0;

return ((pmap_pte_ci(pmap_pte(pm, va)) == 0) ? 1 : 0);

return (pmap_pte_ci(pmap_pte(pmap, va)) == 0) ? 1 : 0;

}

#endif /* mvme68k */

Line 2965 _pmap_page_is_cacheable(pm, va)

Line 2915 _pmap_page_is_cacheable(pm, va)

* Dump the contents of the PV list for the specified physical page.

void

pmap_pvdump(pa)

pmap_pvdump(paddr_t pa)

paddr_t pa;

{

struct pv_entry *pv;

printf("pa %lx", pa);

for (pv = pa_to_pvh(pa); pv; pv = pv->pv_next)

printf(" -> pmap %p, va %lx, ptste %p, ptpmap %p, flags %x",

pv->pv_pmap, pv->pv_va, pv->pv_ptste, pv->pv_ptpmap,

pv->pv_flags);

printf("\n");

}

Line 2986 pmap_pvdump(pa)

Line 2935 pmap_pvdump(pa)

* to that page that the VM system has.

void

pmap_check_wiring(str, va)

pmap_check_wiring(const char *str, vaddr_t va)

const char *str;

vaddr_t va;

{

pt_entry_t *pte;

paddr_t pa;

CVSweb <webmaster@jp.NetBSD.org>