From e897cc1bb16367c15a8078c82f0549cbe47cccff Mon Sep 17 00:00:00 2001 From: kettenis Date: Tue, 4 Apr 2017 12:56:24 +0000 Subject: [PATCH] Cleanup the code further. Get rid of the remaining C++-style comments, remove some debug printfs, get rid of STATIC and __inline defines and remove a bit more unused code. ok drahn@, visa@ --- sys/arch/arm64/arm64/pmap.c | 299 +++++++++++------------------------- 1 file changed, 90 insertions(+), 209 deletions(-) diff --git a/sys/arch/arm64/arm64/pmap.c b/sys/arch/arm64/arm64/pmap.c index 5fa7fdc2cff..5e994f07b78 100644 --- a/sys/arch/arm64/arm64/pmap.c +++ b/sys/arch/arm64/arm64/pmap.c @@ -1,4 +1,4 @@ -/* $OpenBSD: pmap.c,v 1.30 2017/04/02 18:06:57 kettenis Exp $ */ +/* $OpenBSD: pmap.c,v 1.31 2017/04/04 12:56:24 kettenis Exp $ */ /* * Copyright (c) 2008-2009,2014-2016 Dale Rahn * @@ -34,22 +34,15 @@ #include #include -#if 0 -#define STATIC /* static */ -#define __inline /* inline */ -#else -#define STATIC static -#define __inline inline - -#endif - void pmap_setttb(struct proc *p); void arm64_tlbi_asid(vaddr_t va, int asid); void pmap_free_asid(pmap_t pm); -// using PHYS_TO_VM_PAGE does not do what is desired, so instead of -// using that API, create our own which will store ranges of memory -// and default to caching those pages when mapped +/* + * using PHYS_TO_VM_PAGE does not do what is desired, so instead of + * using that API, create our own which will store ranges of memory + * and default to caching those pages when mapped + */ struct { uint64_t start; @@ -62,7 +55,7 @@ int pmap_pa_is_mem(uint64_t pa) { int i; - // NOTE THIS REQUIRES TABLE TO BE SORTED + /* NOTE THIS REQUIRES TABLE TO BE SORTED */ for (i = 0; i < pmap_memcount; i++) { if (pa < pmap_memregions[i].start) return 0; @@ -72,18 +65,18 @@ pmap_pa_is_mem(uint64_t pa) return 0; } -STATIC __inline void +static inline void ttlb_flush(pmap_t pm, vaddr_t va) { arm64_tlbi_asid(va, pm->pm_asid); } -STATIC __inline void +static inline void ttlb_flush_range(pmap_t pm, vaddr_t va, vsize_t size) { vaddr_t eva = va + size; - // if size is over 512 pages, just flush the entire cache !?!?! + /* if size is over 512 pages, just flush the entire cache !?!?! */ if (size >= (512 * PAGE_SIZE)) { cpu_tlb_flush(); return; @@ -122,6 +115,7 @@ struct pte_desc { int pmap_vp_enter(pmap_t pm, vaddr_t va, struct pte_desc *pted, int flags); struct pte_desc *pmap_vp_remove(pmap_t pm, vaddr_t va); void pmap_vp_destroy(pmap_t pm); +void pmap_vp_destroy_l2_l3(pmap_t pm, struct pmapvp1 *vp1); struct pte_desc *pmap_vp_lookup(pmap_t pm, vaddr_t va, uint64_t **); /* PV routines */ @@ -174,8 +168,6 @@ void pmap_pte_update(struct pte_desc *pted, uint64_t *pl3); void pmap_kenter_cache(vaddr_t va, paddr_t pa, vm_prot_t prot, int cacheable); void pmap_pinit(pmap_t pm); void pmap_release(pmap_t pm); -//vaddr_t pmap_steal_memory(vsize_t size, vaddr_t *start, vaddr_t *end); -paddr_t arm_kvm_stolen; paddr_t pmap_steal_avail(size_t size, int align, void **kva); void pmap_remove_avail(paddr_t base, paddr_t end); vaddr_t pmap_map_stolen(vaddr_t); @@ -206,55 +198,30 @@ uint64_t pmap_avail_kvo; /* virtual to physical helpers */ -STATIC __inline int +static inline int VP_IDX0(vaddr_t va) { return (va >> VP_IDX0_POS) & VP_IDX0_MASK; } -STATIC __inline int +static inline int VP_IDX1(vaddr_t va) { return (va >> VP_IDX1_POS) & VP_IDX1_MASK; } -STATIC __inline int +static inline int VP_IDX2(vaddr_t va) { return (va >> VP_IDX2_POS) & VP_IDX2_MASK; } -STATIC __inline int +static inline int VP_IDX3(vaddr_t va) { return (va >> VP_IDX3_POS) & VP_IDX3_MASK; } -#if 0 -STATIC __inline vaddr_t -VP_IDXTOVA(int kern, int idx0, int idx1, int idx2, int idx3, - int mask) -{ - vaddr_t va = 0; - if (kern) - va |= 0xffffff8000000000ULL; - va |= (long)(idx0 & VP_IDX0_MASK) << VP_IDX0_POS; - va |= (long)(idx1 & VP_IDX1_MASK) << VP_IDX1_POS; - va |= (long)(idx2 & VP_IDX2_MASK) << VP_IDX2_POS; - va |= (long)(idx3 & VP_IDX3_MASK) << VP_IDX3_POS; - va |= mask & 0xfff; // page offset; - - return va; -} -#endif - -const struct kmem_pa_mode kp_lN = { - .kp_constraint = &no_constraint, - .kp_maxseg = 1, - .kp_align = 4096, - .kp_zero = 1, -}; - const uint64_t ap_bits_user[8] = { [PROT_NONE] = ATTR_nG|ATTR_PXN|ATTR_UXN|ATTR_AP(2), [PROT_READ] = ATTR_nG|ATTR_PXN|ATTR_UXN|ATTR_AF|ATTR_AP(3), @@ -479,11 +446,12 @@ PTED_VALID(struct pte_desc *pted) void pmap_enter_pv(struct pte_desc *pted, struct vm_page *pg) { - // XXX does this test mean that some pages try to be managed, - // but this is called too soon? - if (__predict_false(!pmap_initialized)) { + /* + * XXX does this test mean that some pages try to be managed, + * but this is called too soon? + */ + if (__predict_false(!pmap_initialized)) return; - } LIST_INSERT_HEAD(&(pg->mdpage.pv_list), pted, pted_pv_list); pted->pted_va |= PTED_VA_MANAGED_M; @@ -503,8 +471,6 @@ pmap_enter(pmap_t pm, vaddr_t va, paddr_t pa, vm_prot_t prot, int flags) int s, cache, error; int need_sync = 0; - //if (!cold) printf("%s: %x %x %x %x %x %x\n", __func__, va, pa, prot, flags, pm, pmap_kernel()); - /* MP - Acquire lock for this pmap */ s = splvm(); @@ -667,13 +633,9 @@ pmap_remove_pted(pmap_t pm, struct pte_desc *pted) void _pmap_kenter_pa(vaddr_t va, paddr_t pa, vm_prot_t prot, int flags, int cache) { + pmap_t pm = pmap_kernel(); struct pte_desc *pted; int s; - pmap_t pm; - - //if (!cold) printf("%s: %x %x %x %x %x\n", __func__, va, pa, prot, flags, cache); - - pm = pmap_kernel(); /* MP - lock pmap. */ s = splvm(); @@ -735,13 +697,10 @@ pmap_kenter_cache(vaddr_t va, paddr_t pa, vm_prot_t prot, int cacheable) void pmap_kremove_pg(vaddr_t va) { + pmap_t pm = pmap_kernel(); struct pte_desc *pted; - pmap_t pm; int s; - //if (!cold) printf("%s: %x\n", __func__, va); - - pm = pmap_kernel(); pted = pmap_vp_lookup(pm, va, NULL); if (pted == NULL) return; @@ -784,7 +743,6 @@ pmap_kremove_pg(vaddr_t va) void pmap_kremove(vaddr_t va, vsize_t len) { - //if (!cold) printf("%s: %x %x\n", __func__, va, len); for (len >>= PAGE_SHIFT; len >0; len--, va += PAGE_SIZE) pmap_kremove_pg(va); } @@ -847,16 +805,13 @@ pmap_collect(pmap_t pm) void pmap_zero_page(struct vm_page *pg) { - //printf("%s\n", __func__); paddr_t pa = VM_PAGE_TO_PHYS(pg); - /* simple_lock(&pmap_zero_page_lock); */ pmap_kenter_pa(zero_page, pa, PROT_READ|PROT_WRITE); - // XXX use better zero operation? + /* XXX use better zero operation? */ bzero((void *)zero_page, PAGE_SIZE); - // XXX better way to unmap this? pmap_kremove_pg(zero_page); } @@ -867,10 +822,8 @@ pmap_zero_page(struct vm_page *pg) void pmap_copy_page(struct vm_page *srcpg, struct vm_page *dstpg) { - //printf("%s\n", __func__); paddr_t srcpa = VM_PAGE_TO_PHYS(srcpg); paddr_t dstpa = VM_PAGE_TO_PHYS(dstpg); - /* simple_lock(&pmap_copy_page_lock); */ pmap_kenter_pa(copy_src_page, srcpa, PROT_READ); pmap_kenter_pa(copy_dst_page, dstpa, PROT_READ|PROT_WRITE); @@ -879,15 +832,11 @@ pmap_copy_page(struct vm_page *srcpg, struct vm_page *dstpg) pmap_kremove_pg(copy_src_page); pmap_kremove_pg(copy_dst_page); - /* simple_unlock(&pmap_copy_page_lock); */ } void pmap_pinit(pmap_t pm) { - // Build time asserts on some data structs. (vp3 is not same size) - - bzero(pm, sizeof (struct pmap)); vaddr_t l0va; /* Allocate a full L0/L1 table. */ @@ -896,25 +845,24 @@ pmap_pinit(pmap_t pm) pm->pm_vp.l0 = pool_get(&pmap_vp_pool, PR_WAITOK | PR_ZERO); } - l0va = (vaddr_t) pm->pm_vp.l0->l0; // top level is l0 + l0va = (vaddr_t)pm->pm_vp.l0->l0; /* top level is l0 */ } else { while (pm->pm_vp.l1 == NULL) { pm->pm_vp.l1 = pool_get(&pmap_vp_pool, PR_WAITOK | PR_ZERO); } - l0va = (vaddr_t) pm->pm_vp.l1->l1; // top level is l1 + l0va = (vaddr_t)pm->pm_vp.l1->l1; /* top level is l1 */ } - pmap_allocate_asid(pm); - pmap_extract(pmap_kernel(), l0va, (paddr_t *)&pm->pm_pt0pa); + pmap_allocate_asid(pm); pmap_reference(pm); } -int pmap_vp_poolcache = 0; // force vp poolcache to allocate late. +int pmap_vp_poolcache = 0; /* force vp poolcache to allocate late */ /* * Create and return a physical map. @@ -924,7 +872,7 @@ pmap_create(void) { pmap_t pmap; - pmap = pool_get(&pmap_pmap_pool, PR_WAITOK); + pmap = pool_get(&pmap_pmap_pool, PR_WAITOK | PR_ZERO); pmap_pinit(pmap); if (pmap_vp_poolcache == 0) { pool_setlowat(&pmap_vp_pool, 20); @@ -939,9 +887,7 @@ pmap_create(void) void pmap_reference(pmap_t pm) { - /* simple_lock(&pmap->pm_obj.vmobjlock); */ pm->pm_refs++; - /* simple_unlock(&pmap->pm_obj.vmobjlock); */ } /* @@ -953,18 +899,15 @@ pmap_destroy(pmap_t pm) { int refs; - /* simple_lock(&pmap->pm_obj.vmobjlock); */ refs = --pm->pm_refs; - /* simple_unlock(&pmap->pm_obj.vmobjlock); */ if (refs > 0) return; - pmap_free_asid(pm); - /* * reference count is zero, free pmap resources and free pmap. */ pmap_release(pm); + pmap_free_asid(pm); pool_put(&pmap_pmap_pool, pm); } @@ -978,34 +921,33 @@ pmap_release(pmap_t pm) pmap_vp_destroy(pm); } -void pmap_vp_destroy_l2_l3(pmap_t pm, struct pmapvp1 *vp1); void pmap_vp_destroy_l2_l3(pmap_t pm, struct pmapvp1 *vp1) { - int j, k, l, s; struct pmapvp2 *vp2; struct pmapvp3 *vp3; struct pte_desc *pted; + int j, k, l; for (j = 0; j < VP_IDX1_CNT; j++) { vp2 = vp1->vp[j]; if (vp2 == NULL) continue; vp1->vp[j] = NULL; + for (k = 0; k < VP_IDX2_CNT; k++) { vp3 = vp2->vp[k]; if (vp3 == NULL) continue; vp2->vp[k] = NULL; + for (l = 0; l < VP_IDX3_CNT; l++) { pted = vp3->vp[l]; if (pted == NULL) continue; vp3->vp[l] = NULL; - s = splvm(); pool_put(&pmap_pted_pool, pted); - splx(s); } pool_put(&pmap_vp_pool, vp3); } @@ -1016,12 +958,15 @@ pmap_vp_destroy_l2_l3(pmap_t pm, struct pmapvp1 *vp1) void pmap_vp_destroy(pmap_t pm) { - int i; struct pmapvp0 *vp0; struct pmapvp1 *vp1; + int i; - // Is there a better way to share this code between 3 and 4 level tables - // split the lower levels into a different function? + /* + * XXX Is there a better way to share this code between 3 and + * 4 level tables? Split the lower levels into a different + * function? + */ if (!pm->have_4_level_pt) { pmap_vp_destroy_l2_l3(pm, pm->pm_vp.l1); pool_put(&pmap_vp_pool, pm->pm_vp.l1); @@ -1034,14 +979,13 @@ pmap_vp_destroy(pmap_t pm) vp1 = vp0->vp[i]; if (vp1 == NULL) continue; + vp0->vp[i] = NULL; pmap_vp_destroy_l2_l3(pm, vp1); - - vp0->vp[i] = NULL; pool_put(&pmap_vp_pool, vp1); } - pm->pm_vp.l0 = NULL; pool_put(&pmap_vp_pool, vp0); + pm->pm_vp.l0 = NULL; } /* @@ -1051,11 +995,11 @@ pmap_vp_destroy(pmap_t pm) vaddr_t pmap_steal_memory(vsize_t size, vaddr_t *start, vaddr_t *end) { - int segno; - u_int npg; + struct vm_physseg *seg; vaddr_t va; paddr_t pa; - struct vm_physseg *seg; + int segno; + u_int npg; size = round_page(size); npg = atop(size); @@ -1112,11 +1056,13 @@ pmap_steal_memory(vsize_t size, vaddr_t *start, vaddr_t *end) vaddr_t virtual_avail, virtual_end; -STATIC __inline uint64_t +static inline uint64_t VP_Lx(paddr_t pa) { - // This function takes the pa address given and manipulates it - // into the form that should be inserted into the VM table; + /* + * This function takes the pa address given and manipulates it + * into the form that should be inserted into the VM table. + */ return pa | Lx_TYPE_PT; } @@ -1151,35 +1097,37 @@ pmap_bootstrap(long kvo, paddr_t lpt1, long kernelstart, long kernelend, pmap_setup_avail(ram_start, ram_end, kvo); - /* in theory we could start with just the memory in the kernel, - * however this could 'allocate' the bootloader and bootstrap - * vm table, which we may need to preserve until later. - * pmap_remove_avail(kernelstart-kvo, kernelend-kvo); + /* + * in theory we could start with just the memory in the + * kernel, however this could 'allocate' the bootloader and + * bootstrap vm table, which we may need to preserve until + * later. */ - printf("removing %llx-%llx\n", ram_start, kernelstart+kvo); // preserve bootloader? - pmap_remove_avail(ram_start, kernelstart+kvo); // preserve bootloader? + printf("removing %llx-%llx\n", ram_start, kernelstart+kvo); + pmap_remove_avail(ram_start, kernelstart+kvo); printf("removing %llx-%llx\n", kernelstart+kvo, kernelend+kvo); pmap_remove_avail(kernelstart+kvo, kernelend+kvo); + /* + * KERNEL IS ASSUMED TO BE 39 bits (or less), start from L1, + * not L0 ALSO kernel mappings may not cover enough ram to + * bootstrap so all accesses initializing tables must be done + * via physical pointers + */ - // KERNEL IS ASSUMED TO BE 39 bits (or less), start from L1, not L0 - // ALSO kernel mappings may not cover enough ram to bootstrap - // so all accesses initializing tables must be done via physical - // pointers - - pt1pa = pmap_steal_avail(sizeof (struct pmapvp1), Lx_TABLE_ALIGN, &va); + pt1pa = pmap_steal_avail(sizeof(struct pmapvp1), Lx_TABLE_ALIGN, &va); vp1 = (struct pmapvp1 *)pt1pa; pmap_kernel()->pm_vp.l1 = (struct pmapvp1 *)va; pmap_kernel()->pm_asid = 0; - // allocate Lx entries + /* allocate Lx entries */ for (i = VP_IDX1(VM_MIN_KERNEL_ADDRESS); i <= VP_IDX1(VM_MAX_KERNEL_ADDRESS); i++) { mappings_allocated++; - pa = pmap_steal_avail(sizeof (struct pmapvp2), Lx_TABLE_ALIGN, + pa = pmap_steal_avail(sizeof(struct pmapvp2), Lx_TABLE_ALIGN, &va); - vp2 = (struct pmapvp2 *)pa; // indexed physically + vp2 = (struct pmapvp2 *)pa; /* indexed physically */ vp1->vp[i] = va; vp1->l1[i] = VP_Lx(pa); @@ -1195,19 +1143,19 @@ pmap_bootstrap(long kvo, paddr_t lpt1, long kernelstart, long kernelend, } for (j = lb_idx2; j <= ub_idx2; j++) { mappings_allocated++; - pa = pmap_steal_avail(sizeof (struct pmapvp3), + pa = pmap_steal_avail(sizeof(struct pmapvp3), Lx_TABLE_ALIGN, &va); - vp3 = (struct pmapvp3 *)pa; // indexed physically + vp3 = (struct pmapvp3 *)pa; /* indexed physically */ vp2->vp[j] = va; vp2->l2[j] = VP_Lx(pa); } } - // allocate Lx entries + /* allocate Lx entries */ for (i = VP_IDX1(VM_MIN_KERNEL_ADDRESS); i <= VP_IDX1(VM_MAX_KERNEL_ADDRESS); i++) { - // access must be performed physical + /* access must be performed physical */ vp2 = (void *)((long)vp1->vp[i] + kvo); if (i == VP_IDX1(VM_MIN_KERNEL_ADDRESS)) { @@ -1221,7 +1169,7 @@ pmap_bootstrap(long kvo, paddr_t lpt1, long kernelstart, long kernelend, ub_idx2 = VP_IDX2_CNT-1; } for (j = lb_idx2; j <= ub_idx2; j++) { - // access must be performed physical + /* access must be performed physical */ vp3 = (void *)((long)vp2->vp[j] + kvo); for (k = 0; k <= VP_IDX3_CNT-1; k++) { @@ -1241,15 +1189,17 @@ pmap_bootstrap(long kvo, paddr_t lpt1, long kernelstart, long kernelend, /* now that we have mapping space for everything, lets map it */ /* all of these mappings are ram -> kernel va */ - // enable mappings for existing 'allocated' mapping in the bootstrap - // page tables + /* + * enable mappings for existing 'allocated' mapping in the bootstrap + * page tables + */ extern uint64_t *pagetable; extern char _end[]; vp2 = (void *)((long)&pagetable + kvo); struct mem_region *mp; ssize_t size; for (mp = pmap_allocated; mp->size != 0; mp++) { - // bounds may be kinda messed up + /* bounds may be kinda messed up */ for (pa = mp->start, size = mp->size & ~0xfff; size > 0; pa+= L2_SIZE, size -= L2_SIZE) @@ -1292,8 +1242,6 @@ pmap_bootstrap(long kvo, paddr_t lpt1, long kernelstart, long kernelend, printf("all mapped\n"); - printf("stolen 0x%x memory\n", arm_kvm_stolen); - return vstart; } @@ -1468,8 +1416,6 @@ pmap_page_protect(struct vm_page *pg, vm_prot_t prot) int s; struct pte_desc *pted; - //if (!cold) printf("%s: prot %x\n", __func__, prot); - /* need to lock for this pv */ s = splvm(); @@ -1493,9 +1439,8 @@ pmap_page_protect(struct vm_page *pg, vm_prot_t prot) void pmap_protect(pmap_t pm, vaddr_t sva, vaddr_t eva, vm_prot_t prot) { - //if (!cold) printf("%s\n", __func__); - int s; + if (prot & (PROT_READ | PROT_EXEC)) { s = splvm(); while (sva < eva) { @@ -1531,7 +1476,7 @@ pmap_init(void) pool_setlowat(&pmap_pted_pool, 20); pool_init(&pmap_vp_pool, sizeof(struct pmapvp2), PAGE_SIZE, IPL_VM, 0, "vp", NULL); - //pool_setlowat(&pmap_vp_pool, 20); + /* pool_setlowat(&pmap_vp_pool, 20); */ pmap_initialized = 1; } @@ -1647,27 +1592,21 @@ pmap_fault_fixup(pmap_t pm, vaddr_t va, vm_prot_t ftype, int user) struct pte_desc *pted; struct vm_page *pg; paddr_t pa; - // pl3 is pointer to the L3 entry to update for this mapping. - // will be valid if a pted exists. uint64_t *pl3 = NULL; int need_sync = 0; - //printf("fault pm %x va %x ftype %x user %x\n", pm, va, ftype, user); - /* Every VA needs a pted, even unmanaged ones. */ pted = pmap_vp_lookup(pm, va, &pl3); - if (!pted || !PTED_VALID(pted)) { + if (!pted || !PTED_VALID(pted)) return 0; - } /* There has to be a PA for the VA, get it. */ pa = (pted->pted_pte & PTE_RPGN); /* If it's unmanaged, it must not fault. */ pg = PHYS_TO_VM_PAGE(pa); - if (pg == NULL) { + if (pg == NULL) return 0; - } /* * Check based on fault type for mod/ref emulation. @@ -1753,49 +1692,6 @@ pmap_postinit(void) { } -void -pmap_map_section(vaddr_t l1_addr, vaddr_t va, paddr_t pa, int flags, int cache) -{ -panic("%s called", __func__); -#if 0 - uint64_t *l1 = (uint64_t *)l1_addr; - uint64_t cache_bits; - int ap_flag; - - switch (flags) { - case PROT_READ: - ap_flag = L1_S_AP2|L1_S_AP0|L1_S_XN; - break; - case PROT_READ | PROT_WRITE: - ap_flag = L1_S_AP0|L1_S_XN; - break; - } - - switch (cache) { - case PMAP_CACHE_WB: - cache_bits = L1_MODE_MEMORY; - break; - case PMAP_CACHE_WT: /* for the momemnt treating this as uncached */ - cache_bits = L1_MODE_DISPLAY; - break; - case PMAP_CACHE_CI: - cache_bits = L1_MODE_DEV; - break; - } - - l1[va>>VP_IDX1_POS] = (pa & L1_S_RPGN) | ap_flag | cache_bits | L1_TYPE_S; -#endif -} - -void pmap_map_entry(vaddr_t l1, vaddr_t va, paddr_t pa, int i0, int i1) {} -vsize_t pmap_map_chunk(vaddr_t l1, vaddr_t va, paddr_t pa, vsize_t sz, int prot, int cache) -{ - for (; sz > 0; sz -= PAGE_SIZE, va += PAGE_SIZE, pa += PAGE_SIZE) { - pmap_kenter_cache(va, pa, prot, cache); - } - return 0; -} - void pmap_update(pmap_t pm) { @@ -1823,9 +1719,6 @@ pmap_clear_modify(struct vm_page *pg) { struct pte_desc *pted; uint64_t *pl3 = NULL; - - //printf("%s\n", __func__); - // XXX locks int s; s = splvm(); @@ -1853,10 +1746,6 @@ int pmap_clear_reference(struct vm_page *pg) { struct pte_desc *pted; - - //printf("%s\n", __func__); - - // XXX locks int s; s = splvm(); @@ -1885,8 +1774,6 @@ pmap_unwire(pmap_t pm, vaddr_t va) { struct pte_desc *pted; - //printf("%s\n", __func__); - pted = pmap_vp_lookup(pm, va, NULL); if ((pted != NULL) && (pted->pted_va & PTED_VA_WIRED_M)) { pm->pm_stats.wired_count--; @@ -1926,7 +1813,7 @@ pmap_setup_avail(uint64_t ram_start, uint64_t ram_end, uint64_t kvo) pmap_avail[0].start = ram_start; pmap_avail[0].size = ram_end-ram_start; - // XXX - support more than one region + /* XXX - support more than one region */ pmap_memregions[0].start = ram_start; pmap_memregions[0].end = ram_end; pmap_memcount = 1; @@ -2056,7 +1943,6 @@ pmap_steal_avail(size_t size, int align, void **kva) struct mem_region *mp; long start; long remsize; - arm_kvm_stolen += size; // debug only for (mp = pmap_avail; mp->size; mp++) { if (mp->size > size) { @@ -2074,7 +1960,6 @@ pmap_steal_avail(size_t size, int align, void **kva) } panic ("unable to allocate region with size %x align %x", size, align); - return 0; // XXX - only here because of ifdef } vaddr_t @@ -2142,49 +2027,45 @@ pmap_show_mapping(uint64_t va) struct pmapvp2 *vp2; struct pmapvp3 *vp3; struct pte_desc *pted; - printf("showing mapping of %llx\n", va); struct pmap *pm; - if (va & 1ULL << 63) { + uint64_t ttbr0, tcr; + + printf("showing mapping of %llx\n", va); + + if (va & 1ULL << 63) pm = pmap_kernel(); - } else { + else pm = curproc->p_vmspace->vm_map.pmap; - } if (pm->have_4_level_pt) { printf(" vp0 = %llx off %x\n", pm->pm_vp.l0, VP_IDX0(va)*8); vp1 = pm->pm_vp.l0->vp[VP_IDX0(va)]; - if (vp1 == NULL) { + if (vp1 == NULL) return; - } } else { vp1 = pm->pm_vp.l1; } - uint64_t ttbr0, tcr; + __asm volatile ("mrs %x0, ttbr0_el1" : "=r"(ttbr0)); __asm volatile ("mrs %x0, tcr_el1" : "=r"(tcr)); - printf(" ttbr0 %llx %llx tcr %llx\n", ttbr0, pm->pm_pt0pa, tcr); printf(" vp1 = %llx\n", vp1); vp2 = vp1->vp[VP_IDX1(va)]; printf(" vp2 = %llx lp2 = %llx idx1 off %x\n", vp2, vp1->l1[VP_IDX1(va)], VP_IDX1(va)*8); - if (vp2 == NULL) { + if (vp2 == NULL) return; - } vp3 = vp2->vp[VP_IDX2(va)]; printf(" vp3 = %llx lp3 = %llx idx2 off %x\n", vp3, vp2->l2[VP_IDX2(va)], VP_IDX2(va)*8); - if (vp3 == NULL) { + if (vp3 == NULL) return; - } pted = vp3->vp[VP_IDX3(va)]; printf(" pted = %p lp3 = %llx idx3 off %x\n", pted, vp3->l3[VP_IDX3(va)], VP_IDX3(va)*8); - - return; } #define NUM_ASID (1 << 16) -- 2.20.1