version 1.11, 2007/10/25 13:03:04 |
version 1.12, 2008/03/20 09:09:20 |
Line 128 static uint64_t pmap_ptc_e_count1 = 3; |
|
Line 128 static uint64_t pmap_ptc_e_count1 = 3; |
|
static uint64_t pmap_ptc_e_count2 = 2; |
static uint64_t pmap_ptc_e_count2 = 2; |
static uint64_t pmap_ptc_e_stride1 = 0x2000; |
static uint64_t pmap_ptc_e_stride1 = 0x2000; |
static uint64_t pmap_ptc_e_stride2 = 0x100000000; |
static uint64_t pmap_ptc_e_stride2 = 0x100000000; |
struct lock pmap_ptc_lock; |
kmutex_t pmap_ptc_lock; /* Global PTC lock */ |
|
|
/* VHPT Base */ |
/* VHPT Base */ |
|
|
Line 137 vaddr_t pmap_vhpt_log2size; |
|
Line 137 vaddr_t pmap_vhpt_log2size; |
|
|
|
struct ia64_bucket *pmap_vhpt_bucket; |
struct ia64_bucket *pmap_vhpt_bucket; |
int pmap_vhpt_nbuckets; |
int pmap_vhpt_nbuckets; |
struct lock pmap_vhptlock; |
kmutex_t pmap_vhptlock; /* VHPT collision chain lock */ |
|
|
int pmap_vhpt_inserts; |
int pmap_vhpt_inserts; |
int pmap_vhpt_resident; |
int pmap_vhpt_resident; |
Line 155 static int pmap_rididx; |
|
Line 155 static int pmap_rididx; |
|
static int pmap_ridmapsz; |
static int pmap_ridmapsz; |
static int pmap_ridmax; |
static int pmap_ridmax; |
static uint64_t *pmap_ridmap; |
static uint64_t *pmap_ridmap; |
struct lock pmap_rid_lock; |
kmutex_t pmap_rid_lock; /* RID allocator lock */ |
|
|
|
|
bool pmap_initialized; /* Has pmap_init completed? */ |
bool pmap_initialized; /* Has pmap_init completed? */ |
Line 204 struct pool pmap_pmap_pool; |
|
Line 204 struct pool pmap_pmap_pool; |
|
struct pool pmap_ia64_lpte_pool; |
struct pool pmap_ia64_lpte_pool; |
struct pool pmap_pv_pool; |
struct pool pmap_pv_pool; |
|
|
struct lock pmap_main_lock; |
kmutex_t pmap_main_lock; |
struct simplelock pmap_all_pmaps_slock; |
kmutex_t pmap_all_pmaps_slock; |
|
|
#if defined(MULTIPROCESSOR) || defined(LOCKDEBUG) |
#if defined(MULTIPROCESSOR) || defined(LOCKDEBUG) |
|
/* XXX(kochi) need to use only spin lock? */ |
#define PMAP_MAP_TO_HEAD_LOCK() \ |
#define PMAP_MAP_TO_HEAD_LOCK() \ |
spinlockmgr(&pmap_main_lock, LK_SHARED, NULL) |
spinlockmgr(&pmap_main_lock, LK_SHARED, NULL) |
#define PMAP_MAP_TO_HEAD_UNLOCK() \ |
#define PMAP_MAP_TO_HEAD_UNLOCK() \ |
Line 244 struct simplelock pmap_all_pmaps_slock; |
|
Line 245 struct simplelock pmap_all_pmaps_slock; |
|
* The VHPT bucket head structure. |
* The VHPT bucket head structure. |
*/ |
*/ |
struct ia64_bucket { |
struct ia64_bucket { |
uint64_t chain; |
uint64_t chain; |
struct lock lock; |
kmutex_t lock; |
u_int length; |
u_int length; |
}; |
}; |
|
|
|
|
Line 384 pmap_steal_memory(vsize_t size, vaddr_t |
|
Line 385 pmap_steal_memory(vsize_t size, vaddr_t |
|
va = IA64_PHYS_TO_RR7(pa); |
va = IA64_PHYS_TO_RR7(pa); |
memset((void *)va, 0, size); |
memset((void *)va, 0, size); |
pmap_pages_stolen += npgs; |
pmap_pages_stolen += npgs; |
return (va); |
return va; |
} |
} |
|
|
/* |
/* |
Line 517 pmap_steal_vhpt_memory(vsize_t size) |
|
Line 518 pmap_steal_vhpt_memory(vsize_t size) |
|
va = IA64_PHYS_TO_RR7(pa); |
va = IA64_PHYS_TO_RR7(pa); |
memset((void *)va, 0, size); |
memset((void *)va, 0, size); |
pmap_pages_stolen += npgs; |
pmap_pages_stolen += npgs; |
return (va); |
return va; |
} |
} |
|
|
|
|
Line 561 pmap_bootstrap() |
|
Line 562 pmap_bootstrap() |
|
pmap_ptc_e_count2, |
pmap_ptc_e_count2, |
pmap_ptc_e_stride1, |
pmap_ptc_e_stride1, |
pmap_ptc_e_stride2); |
pmap_ptc_e_stride2); |
spinlockinit(&pmap_ptc_lock, "Global PTC lock", LK_RECURSE_FAIL); |
mutex_init(&pmap_ptc_lock, MUTEX_SPIN, IPL_VM); |
|
|
/* |
/* |
* Setup RIDs. RIDs 0..7 are reserved for the kernel. |
* Setup RIDs. RIDs 0..7 are reserved for the kernel. |
Line 609 pmap_bootstrap() |
|
Line 610 pmap_bootstrap() |
|
* mtx_init(&pmap_ridmutex, "RID allocator lock", NULL, MTX_DEF); |
* mtx_init(&pmap_ridmutex, "RID allocator lock", NULL, MTX_DEF); |
* MTX_DEF can *sleep*. |
* MTX_DEF can *sleep*. |
*/ |
*/ |
lockinit(&pmap_rid_lock, 0, "RID allocator lock", 0, LK_RECURSEFAIL); |
mutex_init(&pmap_rid_lock, MUTEX_ADAPTIVE, IPL_VM); |
|
|
|
|
/* |
/* |
Line 713 pmap_bootstrap() |
|
Line 714 pmap_bootstrap() |
|
if (bootverbose) |
if (bootverbose) |
printf("Putting VHPT at 0x%lx\n", base); |
printf("Putting VHPT at 0x%lx\n", base); |
|
|
spinlockinit(&pmap_vhptlock, "VHPT collision chain lock", LK_RECURSEFAIL); |
mutex_init(&pmap_vhptlock, MUTEX_SPIN, IPL_VM); |
|
|
__asm __volatile("mov cr.pta=%0;; srlz.i;;" :: |
__asm __volatile("mov cr.pta=%0;; srlz.i;;" :: |
"r" (vhpt_base + (1<<8) + (pmap_vhpt_log2size<<2) + 1)); |
"r" (vhpt_base + (1<<8) + (pmap_vhpt_log2size<<2) + 1)); |
Line 740 pmap_bootstrap() |
|
Line 741 pmap_bootstrap() |
|
pte[i].tag = 1UL << 63; /* Invalid tag */ |
pte[i].tag = 1UL << 63; /* Invalid tag */ |
pte[i].chain = (uintptr_t)(pmap_vhpt_bucket + i); |
pte[i].chain = (uintptr_t)(pmap_vhpt_bucket + i); |
/* Stolen memory is zeroed! */ |
/* Stolen memory is zeroed! */ |
spinlockinit(&pmap_vhpt_bucket[i].lock, "VHPT bucket lock", LK_RECURSEFAIL); |
mutex_init(&pmap_vhpt_bucket[i].lock, MUTEX_SPIN, |
|
IPL_VM); |
} |
} |
|
|
/* |
/* |
* Initialize the locks. |
* Initialize the locks. |
*/ |
*/ |
spinlockinit(&pmap_main_lock, "pmaplk", 0); |
mutex_init(&pmap_main_lock, MUTEX_ADAPTIVE, IPL_VM); |
simple_lock_init(&pmap_all_pmaps_slock); |
mutex_init(&pmap_all_pmaps_slock, MUTEX_SPIN, IPL_VM); |
|
|
/* |
/* |
* Initialize the kernel pmap (which is statically allocated). |
* Initialize the kernel pmap (which is statically allocated). |
*/ |
*/ |
memset(pmap_kernel(), 0, sizeof(struct pmap)); |
memset(pmap_kernel(), 0, sizeof(struct pmap)); |
|
|
simple_lock_init(pmap_kernel()->pm_slock); |
mutex_init(&pmap_kernel()->pm_slock, MUTEX_SPIN, IPL_VM); |
for (i = 0; i < 5; i++) |
for (i = 0; i < 5; i++) |
pmap_kernel()->pm_rid[i] = 0; |
pmap_kernel()->pm_rid[i] = 0; |
pmap_kernel()->pm_active = 1; |
pmap_kernel()->pm_active = 1; |
|
|
paddr_t pa; |
paddr_t pa; |
|
|
if (pmap_extract(pmap_kernel(), va, &pa) == true) |
if (pmap_extract(pmap_kernel(), va, &pa) == true) |
return (pa); |
return pa; |
return (0); |
return 0; |
} |
} |
|
|
/* |
/* |
Line 1108 pmap_create(void) |
|
Line 1109 pmap_create(void) |
|
TAILQ_INIT(&pmap->pm_pvlist); |
TAILQ_INIT(&pmap->pm_pvlist); |
memset(&pmap->pm_stats, 0, sizeof (pmap->pm_stats) ); |
memset(&pmap->pm_stats, 0, sizeof (pmap->pm_stats) ); |
|
|
simple_lock_init(&pmap->pm_slock); |
mutex_init(&pmap->pm_slock, MUTEX_SPIN, IPL_VM); |
|
|
simple_lock(&pmap_all_pmaps_slock); |
mutex_enter(&pmap_all_pmaps_slock); |
TAILQ_INSERT_TAIL(&pmap_all_pmaps, pmap, pm_list); |
TAILQ_INSERT_TAIL(&pmap_all_pmaps, pmap, pm_list); |
simple_unlock(&pmap_all_pmaps_slock); |
mutex_exit(&pmap_all_pmaps_slock); |
|
|
return (pmap); |
return pmap; |
} |
} |
|
|
/* |
/* |
Line 1138 pmap_destroy(pmap_t pmap) |
|
Line 1139 pmap_destroy(pmap_t pmap) |
|
/* |
/* |
* Remove it from the global list of all pmaps. |
* Remove it from the global list of all pmaps. |
*/ |
*/ |
simple_lock(&pmap_all_pmaps_slock); |
mutex_enter(&pmap_all_pmaps_slock); |
TAILQ_REMOVE(&pmap_all_pmaps, pmap, pm_list); |
TAILQ_REMOVE(&pmap_all_pmaps, pmap, pm_list); |
simple_unlock(&pmap_all_pmaps_slock); |
mutex_exit(&pmap_all_pmaps_slock); |
|
|
pool_put(&pmap_pmap_pool, pmap); |
pool_put(&pmap_pmap_pool, pmap); |
|
|
Line 1205 pmap_protect(pmap_t pmap, vaddr_t sva, v |
|
Line 1206 pmap_protect(pmap_t pmap, vaddr_t sva, v |
|
if ((sva & PAGE_MASK) || (eva & PAGE_MASK)) |
if ((sva & PAGE_MASK) || (eva & PAGE_MASK)) |
panic("pmap_protect: unaligned addresses"); |
panic("pmap_protect: unaligned addresses"); |
|
|
uvm_lock_pageq(); |
//uvm_lock_pageq(); |
PMAP_LOCK(pmap); |
PMAP_LOCK(pmap); |
oldpmap = pmap_install(pmap); |
oldpmap = pmap_install(pmap); |
while (sva < eva) { |
while (sva < eva) { |
Line 1233 pmap_protect(pmap_t pmap, vaddr_t sva, v |
|
Line 1234 pmap_protect(pmap_t pmap, vaddr_t sva, v |
|
|
|
sva += PAGE_SIZE; |
sva += PAGE_SIZE; |
} |
} |
uvm_unlock_pageq(); |
//uvm_unlock_pageq(); |
pmap_install(oldpmap); |
pmap_install(oldpmap); |
PMAP_UNLOCK(pmap); |
PMAP_UNLOCK(pmap); |
} |
} |
Line 1253 pmap_extract(pmap_t pmap, vaddr_t va, pa |
|
Line 1254 pmap_extract(pmap_t pmap, vaddr_t va, pa |
|
paddr_t pa; |
paddr_t pa; |
|
|
pa = 0; |
pa = 0; |
simple_lock(pmap->pm_slock); |
mutex_enter(&pmap->pm_slock); |
oldpmap = pmap_install(pmap); /* XXX: isn't this a little inefficient ? */ |
oldpmap = pmap_install(pmap); /* XXX: isn't this a little inefficient ? */ |
pte = pmap_find_vhpt(va); |
pte = pmap_find_vhpt(va); |
if (pte != NULL && pmap_present(pte)) |
if (pte != NULL && pmap_present(pte)) |
Line 1261 pmap_extract(pmap_t pmap, vaddr_t va, pa |
|
Line 1262 pmap_extract(pmap_t pmap, vaddr_t va, pa |
|
else |
else |
return false; |
return false; |
pmap_install(oldpmap); |
pmap_install(oldpmap); |
simple_unlock(pmap->pm_slock); |
mutex_exit(&pmap->pm_slock); |
return true; |
return true; |
|
|
} |
} |
Line 1328 pmap_page_protect(struct vm_page *pg, vm |
|
Line 1329 pmap_page_protect(struct vm_page *pg, vm |
|
PMAP_UNLOCK(pmap); |
PMAP_UNLOCK(pmap); |
} |
} |
|
|
UVM_LOCK_ASSERT_PAGEQ(); |
//UVM_LOCK_ASSERT_PAGEQ(); |
|
|
pg->flags |= PG_RDONLY; |
pg->flags |= PG_RDONLY; |
} else { |
} else { |
Line 1362 pmap_reference(pmap_t pmap) |
|
Line 1363 pmap_reference(pmap_t pmap) |
|
bool |
bool |
pmap_clear_reference(struct vm_page *pg) |
pmap_clear_reference(struct vm_page *pg) |
{ |
{ |
return (false); |
return false; |
} |
} |
|
|
/* |
/* |
|
|
pmap_phys_address(paddr_t ppn) |
pmap_phys_address(paddr_t ppn) |
{ |
{ |
|
|
return (ia64_ptob(ppn)); |
return ia64_ptob(ppn); |
} |
} |
|
|
|
|
Line 1546 pmap_page_purge(struct vm_page * pg) |
|
Line 1547 pmap_page_purge(struct vm_page * pg) |
|
panic("pmap_page_protect: illegal for unmanaged page, va: 0x%lx", VM_PAGE_TO_PHYS(pg)); |
panic("pmap_page_protect: illegal for unmanaged page, va: 0x%lx", VM_PAGE_TO_PHYS(pg)); |
} |
} |
#endif |
#endif |
UVM_LOCK_ASSERT_PAGEQ(); |
//UVM_LOCK_ASSERT_PAGEQ(); |
|
|
while ((pv = TAILQ_FIRST(&pg->mdpage.pv_list)) != NULL) { |
while ((pv = TAILQ_FIRST(&pg->mdpage.pv_list)) != NULL) { |
struct ia64_lpte *pte; |
struct ia64_lpte *pte; |
Line 1564 pmap_page_purge(struct vm_page * pg) |
|
Line 1565 pmap_page_purge(struct vm_page * pg) |
|
PMAP_UNLOCK(pmap); |
PMAP_UNLOCK(pmap); |
} |
} |
|
|
UVM_LOCK_ASSERT_PAGEQ(); |
//UVM_LOCK_ASSERT_PAGEQ(); |
pg->flags |= PG_RDONLY; |
pg->flags |= PG_RDONLY; |
|
|
} |
} |
Line 1576 pmap_switch(pmap_t pm) |
|
Line 1577 pmap_switch(pmap_t pm) |
|
pmap_t prevpm; |
pmap_t prevpm; |
int i; |
int i; |
|
|
LOCK_ASSERT(simple_lock_held(&sched_lock)); |
//LOCK_ASSERT(simple_lock_held(&sched_lock)); |
|
|
prevpm = curcpu()->ci_pmap; |
prevpm = curcpu()->ci_pmap; |
if (prevpm == pm) |
if (prevpm == pm) |
return (prevpm); |
return prevpm; |
// if (prevpm != NULL) |
// if (prevpm != NULL) |
// atomic_clear_32(&prevpm->pm_active, PCPU_GET(cpumask)); |
// atomic_clear_32(&prevpm->pm_active, PCPU_GET(cpumask)); |
if (pm == NULL) { |
if (pm == NULL) { |
Line 1597 pmap_switch(pmap_t pm) |
|
Line 1598 pmap_switch(pmap_t pm) |
|
} |
} |
curcpu()->ci_pmap = pm; |
curcpu()->ci_pmap = pm; |
__asm __volatile("srlz.d"); |
__asm __volatile("srlz.d"); |
return (prevpm); |
return prevpm; |
} |
} |
|
|
static pmap_t |
static pmap_t |
Line 1610 pmap_install(pmap_t pm) |
|
Line 1611 pmap_install(pmap_t pm) |
|
splsched = splsched(); |
splsched = splsched(); |
prevpm = pmap_switch(pm); |
prevpm = pmap_switch(pm); |
splx(splsched); |
splx(splsched); |
return (prevpm); |
return prevpm; |
} |
} |
|
|
static uint32_t |
static uint32_t |
Line 1619 pmap_allocate_rid(void) |
|
Line 1620 pmap_allocate_rid(void) |
|
uint64_t bit, bits; |
uint64_t bit, bits; |
int rid; |
int rid; |
|
|
lockmgr(&pmap_rid_lock, LK_EXCLUSIVE, NULL); |
mutex_enter(&pmap_rid_lock); |
if (pmap_ridcount == pmap_ridmax) |
if (pmap_ridcount == pmap_ridmax) |
panic("pmap_allocate_rid: All Region IDs used"); |
panic("pmap_allocate_rid: All Region IDs used"); |
|
|
Line 1640 pmap_allocate_rid(void) |
|
Line 1641 pmap_allocate_rid(void) |
|
|
|
pmap_ridmap[pmap_rididx] |= bit; |
pmap_ridmap[pmap_rididx] |= bit; |
pmap_ridcount++; |
pmap_ridcount++; |
lockmgr(&pmap_rid_lock, LK_RELEASE, NULL); |
mutex_exit(&pmap_rid_lock); |
|
|
return rid; |
return rid; |
} |
} |
Line 1654 pmap_free_rid(uint32_t rid) |
|
Line 1655 pmap_free_rid(uint32_t rid) |
|
idx = rid / 64; |
idx = rid / 64; |
bit = ~(1UL << (rid & 63)); |
bit = ~(1UL << (rid & 63)); |
|
|
simple_lock(&pmap_rid_lock); |
mutex_enter(&pmap_rid_lock); |
pmap_ridmap[idx] &= bit; |
pmap_ridmap[idx] &= bit; |
pmap_ridcount--; |
pmap_ridcount--; |
simple_unlock(&pmap_rid_lock); |
mutex_exit(&pmap_rid_lock); |
} |
} |
|
|
/*************************************************** |
/*************************************************** |
Line 1717 pmap_find_kpte(vaddr_t va) |
|
Line 1718 pmap_find_kpte(vaddr_t va) |
|
{ |
{ |
KASSERT((va >> 61) == 5); |
KASSERT((va >> 61) == 5); |
KASSERT(IA64_RR_MASK(va) < (nkpt * PAGE_SIZE * NKPTEPG)); |
KASSERT(IA64_RR_MASK(va) < (nkpt * PAGE_SIZE * NKPTEPG)); |
return (&ia64_kptdir[KPTE_DIR_INDEX(va)][KPTE_PTE_INDEX(va)]); |
return &ia64_kptdir[KPTE_DIR_INDEX(va)][KPTE_PTE_INDEX(va)]; |
} |
} |
|
|
|
|
Line 1888 get_pv_entry(pmap_t locked_pmap) |
|
Line 1889 get_pv_entry(pmap_t locked_pmap) |
|
{ |
{ |
pv_entry_t allocated_pv; |
pv_entry_t allocated_pv; |
|
|
LOCK_ASSERT(simple_lock_held(locked_pmap->slock)); |
//LOCK_ASSERT(simple_lock_held(locked_pmap->slock)); |
UVM_LOCK_ASSERT_PAGEQ(); |
//UVM_LOCK_ASSERT_PAGEQ(); |
allocated_pv = pool_get(&pmap_pv_pool, PR_NOWAIT); |
allocated_pv = pool_get(&pmap_pv_pool, PR_NOWAIT); |
return (allocated_pv); |
return allocated_pv; |
|
|
|
|
/* XXX: Nice to have all this stuff later: |
/* XXX: Nice to have all this stuff later: |
Line 1927 pmap_enter_vhpt(struct ia64_lpte *pte, v |
|
Line 1928 pmap_enter_vhpt(struct ia64_lpte *pte, v |
|
vhpte = (struct ia64_lpte *)ia64_thash(va); |
vhpte = (struct ia64_lpte *)ia64_thash(va); |
bckt = (struct ia64_bucket *)vhpte->chain; |
bckt = (struct ia64_bucket *)vhpte->chain; |
/* XXX: fixme */ |
/* XXX: fixme */ |
KASSERT(!spinlockmgr(&bckt->lock, LK_EXCLUSIVE, NULL)); |
mutex_enter(&bckt->lock); |
pte->chain = bckt->chain; |
pte->chain = bckt->chain; |
ia64_mf(); |
ia64_mf(); |
bckt->chain = pte_pa; |
bckt->chain = pte_pa; |
Line 1935 pmap_enter_vhpt(struct ia64_lpte *pte, v |
|
Line 1936 pmap_enter_vhpt(struct ia64_lpte *pte, v |
|
pmap_vhpt_inserts++; |
pmap_vhpt_inserts++; |
bckt->length++; |
bckt->length++; |
/*XXX : fixme */ |
/*XXX : fixme */ |
KASSERT(!spinlockmgr(&bckt->lock, LK_RELEASE, NULL)); |
mutex_exit(&bckt->lock); |
|
|
} |
} |
|
|
Line 1957 pmap_remove_vhpt(vaddr_t va) |
|
Line 1958 pmap_remove_vhpt(vaddr_t va) |
|
bckt = (struct ia64_bucket *)vhpte->chain; |
bckt = (struct ia64_bucket *)vhpte->chain; |
|
|
lpte = NULL; |
lpte = NULL; |
KASSERT(!spinlockmgr(&bckt->lock, LK_EXCLUSIVE, NULL)); |
mutex_enter(&bckt->lock); |
|
|
|
|
chain = bckt->chain; |
chain = bckt->chain; |
Line 1968 pmap_remove_vhpt(vaddr_t va) |
|
Line 1969 pmap_remove_vhpt(vaddr_t va) |
|
pte = (struct ia64_lpte *)IA64_PHYS_TO_RR7(chain); |
pte = (struct ia64_lpte *)IA64_PHYS_TO_RR7(chain); |
} |
} |
if (chain == 0) { |
if (chain == 0) { |
KASSERT(!spinlockmgr(&bckt->lock, LK_RELEASE, NULL)); |
mutex_exit(&bckt->lock); |
return (ENOENT); |
return ENOENT; |
} |
} |
|
|
/* Snip this pv_entry out of the collision chain. */ |
/* Snip this pv_entry out of the collision chain. */ |
Line 1980 pmap_remove_vhpt(vaddr_t va) |
|
Line 1981 pmap_remove_vhpt(vaddr_t va) |
|
ia64_mf(); |
ia64_mf(); |
|
|
bckt->length--; |
bckt->length--; |
KASSERT(!spinlockmgr(&bckt->lock, LK_RELEASE, NULL)); |
mutex_exit(&bckt->lock); |
return (0); |
return 0; |
} |
} |
|
|
|
|
Line 1999 pmap_find_vhpt(vaddr_t va) |
|
Line 2000 pmap_find_vhpt(vaddr_t va) |
|
pte = (struct ia64_lpte *)ia64_thash(va); |
pte = (struct ia64_lpte *)ia64_thash(va); |
bckt = (struct ia64_bucket *)pte->chain; |
bckt = (struct ia64_bucket *)pte->chain; |
|
|
KASSERT(!spinlockmgr(&bckt->lock, LK_EXCLUSIVE, NULL)); |
mutex_enter(&bckt->lock); |
chain = bckt->chain; |
chain = bckt->chain; |
pte = (struct ia64_lpte *)IA64_PHYS_TO_RR7(chain); |
pte = (struct ia64_lpte *)IA64_PHYS_TO_RR7(chain); |
while (chain != 0 && pte->tag != tag) { |
while (chain != 0 && pte->tag != tag) { |
chain = pte->chain; |
chain = pte->chain; |
pte = (struct ia64_lpte *)IA64_PHYS_TO_RR7(chain); |
pte = (struct ia64_lpte *)IA64_PHYS_TO_RR7(chain); |
} |
} |
KASSERT(!spinlockmgr(&bckt->lock, LK_EXCLUSIVE, NULL)); |
mutex_exit(&bckt->lock); |
return ((chain != 0) ? pte : NULL); |
return (chain != 0) ? pte : NULL; |
} |
} |
|
|
|
|
Line 2035 pmap_remove_entry(pmap_t pmap, struct vm |
|
Line 2036 pmap_remove_entry(pmap_t pmap, struct vm |
|
TAILQ_REMOVE(&pg->mdpage.pv_list, pv, pv_list); |
TAILQ_REMOVE(&pg->mdpage.pv_list, pv, pv_list); |
pg->mdpage.pv_list_count--; |
pg->mdpage.pv_list_count--; |
if (TAILQ_FIRST(&pg->mdpage.pv_list) == NULL) { |
if (TAILQ_FIRST(&pg->mdpage.pv_list) == NULL) { |
UVM_LOCK_ASSERT_PAGEQ(); |
//UVM_LOCK_ASSERT_PAGEQ(); |
pg->flags |= PG_RDONLY; |
pg->flags |= PG_RDONLY; |
} |
} |
|
|
Line 2061 pmap_insert_entry(pmap_t pmap, vaddr_t v |
|
Line 2062 pmap_insert_entry(pmap_t pmap, vaddr_t v |
|
pv->pv_pmap = pmap; |
pv->pv_pmap = pmap; |
pv->pv_va = va; |
pv->pv_va = va; |
|
|
LOCK_ASSERT(simple_lock_held(pmap->slock)); |
//LOCK_ASSERT(simple_lock_held(pmap->slock)); |
UVM_LOCK_ASSERT_PAGEQ(); |
//UVM_LOCK_ASSERT_PAGEQ(); |
TAILQ_INSERT_TAIL(&pmap->pm_pvlist, pv, pv_plist); |
TAILQ_INSERT_TAIL(&pmap->pm_pvlist, pv, pv_plist); |
TAILQ_INSERT_TAIL(&pg->mdpage.pv_list, pv, pv_list); |
TAILQ_INSERT_TAIL(&pg->mdpage.pv_list, pv, pv_list); |
pg->mdpage.pv_list_count++; |
pg->mdpage.pv_list_count++; |
Line 2100 pmap_pv_page_alloc(struct pool *pp, int |
|
Line 2101 pmap_pv_page_alloc(struct pool *pp, int |
|
paddr_t pg; |
paddr_t pg; |
|
|
if (pmap_poolpage_alloc(&pg)) |
if (pmap_poolpage_alloc(&pg)) |
return ((void *)IA64_PHYS_TO_RR7(pg)); |
return (void *)IA64_PHYS_TO_RR7(pg); |
return (NULL); |
return NULL; |
} |
} |
|
|
/* |
/* |
Line 2135 pmap_poolpage_alloc(paddr_t *pap) |
|
Line 2136 pmap_poolpage_alloc(paddr_t *pap) |
|
pa = VM_PAGE_TO_PHYS(pg); |
pa = VM_PAGE_TO_PHYS(pg); |
|
|
#ifdef DEBUG |
#ifdef DEBUG |
simple_lock(&pg->mdpage.pv_slock); |
mutex_enter(&pg->mdpage.pv_mutex); |
if (pg->wire_count != 0) { |
if (pg->wire_count != 0) { |
printf("pmap_physpage_alloc: page 0x%lx has " |
printf("pmap_physpage_alloc: page 0x%lx has " |
"%d references\n", pa, pg->wire_count); |
"%d references\n", pa, pg->wire_count); |
panic("pmap_physpage_alloc"); |
panic("pmap_physpage_alloc"); |
} |
} |
simple_unlock(&pg->mdpage.pv_slock); |
mutex_exit(&pg->mdpage.pv_mutex); |
#endif |
#endif |
*pap = pa; |
*pap = pa; |
return (true); |
return true; |
} |
} |
return (false); |
return false; |
} |
} |
|
|
/* |
/* |
Line 2163 pmap_poolpage_free(paddr_t pa) |
|
Line 2164 pmap_poolpage_free(paddr_t pa) |
|
panic("pmap_physpage_free: bogus physical page address"); |
panic("pmap_physpage_free: bogus physical page address"); |
|
|
#ifdef DEBUG |
#ifdef DEBUG |
simple_lock(&pg->mdpage.pv_slock); |
mutex_enter(&pg->mdpage.pv_mutex); |
if (pg->wire_count != 0) |
if (pg->wire_count != 0) |
panic("pmap_physpage_free: page still has references"); |
panic("pmap_physpage_free: page still has references"); |
simple_unlock(&pg->mdpage.pv_slock); |
mutex_exit(&pg->mdpage.pv_mutex); |
#endif |
#endif |
|
|
uvm_pagefree(pg); |
uvm_pagefree(pg); |