target-ppc: Update external_htab even when HTAB is managed by kernel
PATCH 1/3 target-ppc: Update external_htab even when HTAB is managed by kernel
From: "Aneesh Kumar K.V" <[email protected]>
We will use this in later patches to make sure we use the right load functions when copying hpte entries.
--- hw/ppc/spapr.c | 7 +++++++ 1 file changed, 7 insertions(+)
hw/ppc/spapr.c +7 -0
@@ -716,6 +716,13 @@ static void spapr_cpu_reset(void *opaque) env->spr[SPR_HIOR ] =0 ; env->external_htab = (uint8_t *)spapr->htab; +if (kvm_enabled () && !env->external_htab) { +/* +* HV KVM, set external_htab to 1 so our ppc_hash64_load_hpte* +* functions do the right thing. +*/ + env->external_htab = (void *)1 ; + } env->htab_base =-1 ; env->htab_mask =HTAB_SIZE (spapr) -1 ; env->spr[SPR_SDR1] = (target_ulong)(uintptr_t)spapr->htab |
Signature · 1 line
1.8.3.2
PATCH 2/3 target-ppc: Fix htab_mask calculation
From: "Aneesh Kumar K.V" <[email protected]>
Correctly update the htab_mask using the return value of KVM_PPC_ALLOCATE_HTAB ioctl. Also we don't update sdr1 on GET_SREGS for HV. So don't update htab_mask if sdr1 is found to be zero. Fix the pte index calculation to be same as that found in the kernel
--- hw/ppc/spapr.c | 3 ++- target-ppc/mmu_helper.c | 4 +++- 2 files changed, 5 insertions(+), 2 deletions(-)
hw/ppc/spapr.c +2 -1
@@ -724,7 +724,8 @@ static void spapr_cpu_reset(void *opaque) env->external_htab = (void *)1 ; } env->htab_base =-1 ; - env->htab_mask =HTAB_SIZE (spapr) -1 ; +/* 128 (2**7) bytes in each HPTEG */ + env->htab_mask = (1ULL << ((spapr)->htab_shift -7 )) -1 ; env->spr[SPR_SDR1 ] = (target_ulong )(uintptr_t )spapr->htab | (spapr->htab_shift -18 ); }
target-ppc/mmu_helper.c +3 -1
@@ -2025,7 +2025,9 @@ void ppc_store_sdr1(CPUPPCState *env, target_ulong value) " stored in SDR1\n", htabsize); htabsize = 28; } - env->htab_mask = (1ULL << (htabsize +18 )) -1 ; +if (htabsize) { + env->htab_mask = (1ULL << (htabsize +18 -7 )) -1 ; + } env->htab_base = value &SDR_64_HTABORG ; } else#endif /* defined(TARGET_PPC64) */
Signature · 1 line
1.8.3.2
PATCH 3/3 target-ppc: Fix page table lookup with kvm enabled
In reply to Aneesh Kumar K.VFrom: "Aneesh Kumar K.V" <[email protected]>
With kvm enabled, we store the hash page table information in the hypervisor. Use ioctl to read the htab contents. Without this we get the below error when trying to read the guest address
(gdb) x/10 do_fork
0xc000000000098660 <do_fork>: Cannot access memory at address 0xc000000000098660
(gdb)
---
Changes from V6:
* drop htab_fd argument and use global variable kvmppc_kern_htab instead
hw/ppc/spapr.c | 1 + hw/ppc/spapr_hcall.c | 50 +++++++++++++++++++------------ target-ppc/kvm.c | 53 +++++++++++++++++++++++++++++++++ target-ppc/kvm_ppc.h | 19 ++++++++++++ target-ppc/mmu-hash64.c | 78 ++++++++++++++++++++++++++++++++++++++++--------- target-ppc/mmu-hash64.h | 23 ++++++++++----- 6 files changed, 183 insertions(+), 41 deletions(-)
hw/ppc/spapr.c +1 -0
@@ -662,6 +662,7 @@ static void spapr_reset_htab(sPAPREnvironment *spapr)if (shift >0 ) {/* Kernel handles htab, we don't need to allocate one */ spapr->htab_shift = shift; + kvmppc_kern_htab = true; }else {if (!spapr->htab) {/* Allocate an htab if we don't yet have one */
hw/ppc/spapr_hcall.c +31 -19
113 lines not on this page · raw message
target-ppc/kvm.c +53 -0
62 lines not on this page · raw message
target-ppc/kvm_ppc.h +19 -0
@@ -38,10 +38,13 @@ uint64_t kvmppc_rma_size(uint64_t current_size, unsigned int hash_shift);#endif /* !CONFIG_USER_ONLY */ int kvmppc_fixup_cpu (PowerPCCPU *cpu);bool kvmppc_has_cap_epr (void ); +bool kvmppc_has_cap_htab_fd (void );int kvmppc_get_htab_fd (bool write);int kvmppc_save_htab (QEMUFile *f,int fd,size_t bufsize,int64_t max_ns);int kvmppc_load_htab_chunk (QEMUFile *f,int fd,uint32_t index,uint16_t n_valid,uint16_t n_invalid); +void *kvmppc_hash64_read_pteg (PowerPCCPU *cpu,unsigned long pte_index); +void kvmppc_hash64_free_pteg (void *token);#else
@@ -164,6 +167,11 @@ static inline bool kvmppc_has_cap_epr(void)return false; } +static inline bool kvmppc_has_cap_htab_fd (void ) +{ +return false; +} +static inline int kvmppc_get_htab_fd (bool write) {return -1 ;
@@ -181,6 +189,17 @@ static inline int kvmppc_load_htab_chunk(QEMUFile *f, int fd, uint32_t index, abort(); } +static inline void *kvmppc_hash64_read_pteg (PowerPCCPU *cpu, +unsigned long pte_index) +{ +abort (); +} + +static inline void kvmppc_hash64_free_pteg (void *token) +{ +abort (); +} +#endif #ifndef CONFIG_KVM
target-ppc/mmu-hash64.c +64 -14
122 lines not on this page · raw message
target-ppc/mmu-hash64.h +15 -8
@@ -75,23 +75,30 @@ int ppc_hash64_handle_mmu_fault(CPUPPCState *env, target_ulong address, int rw,#define HPTE64_V_1TB_SEG 0x4000000000000000ULL#define HPTE64_V_VRMA_MASK 0x4001ffffff000000ULL -static inline target_ulong ppc_hash64_load_hpte0 (CPUPPCState *env, -hwaddr pte_offset) + +extern bool kvmppc_kern_htab; +void *ppc_hash64_start_access (PowerPCCPU *cpu,unsigned long pte_index); +void ppc_hash64_stop_access (void *token); + +static inline target_ulong ppc_hash64_load_hpte0 (CPUPPCState *env,void *token, +int index) { + index *=HASH_PTE_SIZE_64 ;if (env->external_htab) { -return ldq_p (env->external_htab + pte_offset); +return ldq_p (token + index); }else { -return ldq_phys (env->htab_base + pte_offset); +return ldq_phys ((uint64_t )(token + index)); } } -static inline target_ulong ppc_hash64_load_hpte1 (CPUPPCState *env, -hwaddr pte_offset) +static inline target_ulong ppc_hash64_load_hpte1 (CPUPPCState *env,void *token, +int index) { + index *=HASH_PTE_SIZE_64 ;if (env->external_htab) { -return ldq_p (env->external_htab + pte_offset +HASH_PTE_SIZE_64 /2 ); +return ldq_p (token + index +HASH_PTE_SIZE_64 /2 ); }else { -return ldq_phys (env->htab_base + pte_offset +HASH_PTE_SIZE_64 /2 ); +return ldq_phys ((uint64_t )(token + index +HASH_PTE_SIZE_64 /2 )); } }
Signature · 1 line
1.8.3.2
Re: [Qemu-devel] [PATCH -V7 3/3] target-ppc: Fix page table lookup with kvm enabled
Quoted 80 lines · Aneesh Kumar K.V
From: "Aneesh Kumar K.V" <[email protected]>
With kvm enabled, we store the hash page table information in the hypervisor. Use ioctl to read the htab contents. Without this we get the below error when trying to read the guest address
(gdb) x/10
do_fork0xc000000000098660<do_fork>: Cannot access memory at address0xc000000000098660
(gdb)Signed-off-by Aneesh Kumar K.V <[email protected]>---
Changes from V6:
* drophtab_fdargument and use global variablekvmppc_kern_htabinsteadhw/ppc/spapr.c | 1 + hw/ppc/spapr_hcall.c | 50 +++++++++++++++++++------------ target-ppc/kvm.c | 53 +++++++++++++++++++++++++++++++++ target-ppc/kvm_ppc.h | 19 ++++++++++++ target-ppc/mmu-hash64.c | 78 ++++++++++++++++++++++++++++++++++++++++--------- target-ppc/mmu-hash64.h | 23 ++++++++++----- 6 files changed, 183 insertions(+), 41 deletions(-)hw/ppc/spapr.c +1
-0@@ -662,6 +662,7 @@ static void spapr_reset_htab(sPAPREnvironment *spapr)if (shift >0 ) {/* Kernel handles htab, we don't need to allocate one */ spapr->htab_shift = shift; + kvmppc_kern_htab = true; }else {if (!spapr->htab) {/* Allocate an htab if we don't yet have one */ hw/ppc/spapr_hcall.c +12
-10@@ -50,8 +50,9 @@ static target_ulong h_enter(PowerPCCPU *cpu, sPAPREnvironment *spapr,target_ulong ptel = args[3 ];target_ulong page_shift =12 ;target_ulong raddr; -target_ulong i; +target_ulong index;hwaddr hpte; +void *token;/* only handle 4k and 16M pages for now */ if (pteh &HPTE64_V_LARGE ) {@@ -94,30 +95,37 @@ static target_ulong h_enter(PowerPCCPU *cpu, sPAPREnvironment *spapr,if ((pte_index *HASH_PTE_SIZE_64 ) & ~env->htab_mask) {return H_PARAMETER ; } + + index =0 ; + hpte = pte_index *HASH_PTE_SIZE_64 ;if (likely ((flags &H_EXACT ) ==0 )) { pte_index &= ~7ULL ; - hpte = pte_index *HASH_PTE_SIZE_64 ; -for (i =0 ; ; ++i) { -if (i ==8 ) { + token =ppc_hash64_start_access (cpu, pte_index); +do { +if (index ==8 ) { +ppc_hash64_stop_access (token);return H_PTEG_FULL ; } -if ((ppc_hash64_load_hpte0 (env, hpte) &HPTE64_V_VALID ) ==0 ) { +if ((ppc_hash64_load_hpte0 (env, token, index) &HPTE64_V_VALID ) ==0 ) {break ; } - hpte +=HASH_PTE_SIZE_64 ; - } + }while (index++); +ppc_hash64_stop_access (token); }else { - i =0 ; - hpte = pte_index *HASH_PTE_SIZE_64 ; -if (ppc_hash64_load_hpte0 (env, hpte) &HPTE64_V_VALID ) {
hw/ppc/spapr_hcall.c static target_ulong h_enter(PowerPCCPU *cpu, sPAPREnvironment *spapr, · line 124
Quoted 10 lines
hw/ppc/spapr_hcall.c +6
-0+ token =ppc_hash64_start_access (cpu, pte_index); +if (ppc_hash64_load_hpte0 (env, token,0 ) &HPTE64_V_VALID ) { +ppc_hash64_stop_access (token);return H_PTEG_FULL ; } +ppc_hash64_stop_access (token); } + hpte += index *HASH_PTE_SIZE_64 ; +ppc_hash64_store_hpte1 (env, hpte, ptel);
I'm not a big fan of fixing the read part, but leaving the write part broken. However I can see value in read only already, so I'm fine if the write part follows later.
Quoted 223 lines
hw/ppc/spapr_hcall.c +13
-9/* eieio(); FIXME: need some sort of barrier for smp? */ ppc_hash64_store_hpte0 (env, hpte, pteh |HPTE64_V_HPTE_DIRTY ); - args[0 ] = pte_index + i; + args[0 ] = pte_index + index;return H_SUCCESS ; }@@ -134,16 +142,17 @@ static RemoveResult remove_hpte(CPUPPCState *env, target_ulong ptex, target_ulong *vp, target_ulong *rp) {hwaddr hpte; +void *token;target_ulong v, r, rb;if ((ptex *HASH_PTE_SIZE_64 ) & ~env->htab_mask) {return REMOVE_PARM ; } - hpte = ptex *HASH_PTE_SIZE_64 ; - - v =ppc_hash64_load_hpte0 (env, hpte); - r =ppc_hash64_load_hpte1 (env, hpte); + token =ppc_hash64_start_access (ppc_env_get_cpu (env), ptex); + v =ppc_hash64_load_hpte0 (env, token,0 ); + r =ppc_hash64_load_hpte1 (env, token,0 ); +ppc_hash64_stop_access (token); if ((v & HPTE64_V_VALID) == 0 || ((flags & H_AVPN) && (v & ~0x7fULL) != avpn) ||@@ -152,6 +161,7 @@ static RemoveResult remove_hpte(CPUPPCState *env, target_ulong ptex, } *vp = v; *rp = r; + hpte = ptex *HASH_PTE_SIZE_64 ;ppc_hash64_store_hpte0 (env, hpte,HPTE64_V_HPTE_DIRTY ); rb =compute_tlbie_rb (v, r, ptex);ppc_tlb_invalidate_one (env, rb);@@ -260,16 +270,17 @@ static target_ulong h_protect(PowerPCCPU *cpu, sPAPREnvironment *spapr,target_ulong pte_index = args[1 ];target_ulong avpn = args[2 ];hwaddr hpte; +void *token;target_ulong v, r, rb;if ((pte_index *HASH_PTE_SIZE_64 ) & ~env->htab_mask) {return H_PARAMETER ; } - hpte = pte_index *HASH_PTE_SIZE_64 ; - - v =ppc_hash64_load_hpte0 (env, hpte); - r =ppc_hash64_load_hpte1 (env, hpte); + token =ppc_hash64_start_access (cpu, pte_index); + v =ppc_hash64_load_hpte0 (env, token,0 ); + r =ppc_hash64_load_hpte1 (env, token,0 ); +ppc_hash64_stop_access (token);if ((v &HPTE64_V_VALID ) ==0 || ((flags &H_AVPN ) && (v & ~0x7fULL ) != avpn)) {@@ -282,6 +293,7 @@ static target_ulong h_protect(PowerPCCPU *cpu, sPAPREnvironment *spapr, r |= (flags <<48 ) &HPTE64_R_KEY_HI ; r |= flags & (HPTE64_R_PP |HPTE64_R_N |HPTE64_R_KEY_LO ); rb =compute_tlbie_rb (v, r, pte_index); + hpte = pte_index *HASH_PTE_SIZE_64 ;ppc_hash64_store_hpte0 (env, hpte, (v & ~HPTE64_V_VALID ) |HPTE64_V_HPTE_DIRTY );ppc_tlb_invalidate_one (env, rb);ppc_hash64_store_hpte1 (env, hpte, r);target-ppc/kvm.c +53
-0@@ -1783,6 +1783,11 @@ bool kvmppc_has_cap_epr(void)return cap_epr; } +bool kvmppc_has_cap_htab_fd (void ) +{ +return cap_htab_fd; +} +static int kvm_ppc_register_host_cpu_type (void ) {TypeInfo type_info = {@@ -1888,3 +1893,51 @@ int kvm_arch_on_sigbus(int code, void *addr)void kvm_arch_init_irq_routing (KVMState *s) { } + +struct kvm_get_htab_buf { +struct kvm_get_htab_header header; +/* +* We required one extra byte for read +*/ +unsigned long hpte[(HPTES_PER_GROUP *2 ) +1 ]; +}; + +void *kvmppc_hash64_read_pteg (PowerPCCPU *cpu,unsigned long pte_index) +{ +int htab_fd; +struct kvm_get_htab_fd ghf; +struct kvm_get_htab_buf *hpte_buf; + + ghf.flags =0 ; + ghf.start_index = pte_index; + htab_fd =kvm_vm_ioctl (kvm_state,KVM_PPC_GET_HTAB_FD , &ghf); +if (htab_fd <0 ) { + goto error_out; + } + + hpte_buf =g_malloc0 (sizeof (*hpte_buf)); +/* +* Read the hpte group +*/ +if (read (htab_fd, hpte_buf,sizeof (*hpte_buf)) <0 ) { + goto out_close; + } + +close (htab_fd); +return hpte_buf->hpte; + +out_close: +g_free (hpte_buf); +close (htab_fd); +error_out: +return NULL ; +} + +void kvmppc_hash64_free_pteg (void *token) +{ +struct kvm_get_htab_buf *htab_buf; + + htab_buf = container_of(token, struct kvm_get_htab_buf, hpte); +g_free (htab_buf); +return ; +}target-ppc/kvm_ppc.h +19
-0@@ -38,10 +38,13 @@ uint64_t kvmppc_rma_size(uint64_t current_size, unsigned int hash_shift);#endif /* !CONFIG_USER_ONLY */ int kvmppc_fixup_cpu (PowerPCCPU *cpu);bool kvmppc_has_cap_epr (void ); +bool kvmppc_has_cap_htab_fd (void );int kvmppc_get_htab_fd (bool write);int kvmppc_save_htab (QEMUFile *f,int fd,size_t bufsize,int64_t max_ns);int kvmppc_load_htab_chunk (QEMUFile *f,int fd,uint32_t index,uint16_t n_valid,uint16_t n_invalid); +void *kvmppc_hash64_read_pteg (PowerPCCPU *cpu,unsigned long pte_index); +void kvmppc_hash64_free_pteg (void *token);#else @@ -164,6 +167,11 @@ static inline bool kvmppc_has_cap_epr(void)return false; } +static inline bool kvmppc_has_cap_htab_fd (void ) +{ +return false; +} +static inline int kvmppc_get_htab_fd (bool write) {return -1 ;@@ -181,6 +189,17 @@ static inline int kvmppc_load_htab_chunk(QEMUFile *f, int fd, uint32_t index, abort(); } +static inline void *kvmppc_hash64_read_pteg (PowerPCCPU *cpu, +unsigned long pte_index) +{ +abort (); +} + +static inline void kvmppc_hash64_free_pteg (void *token) +{ +abort (); +} +#endif #ifndef CONFIG_KVM target-ppc/mmu-hash64.c +23
-1@@ -41,6 +41,11 @@#endif /* +* Used to indicate whether we have allocated htab in the +* host kernel +*/ +bool kvmppc_kern_htab; +/* * SLB handling */ @@ -302,29 +307,76 @@ static int ppc_hash64_amr_prot(CPUPPCState *env, ppc_hash_pte64_t pte)return prot; } -static hwaddr ppc_hash64_pteg_search(CPUPPCState *env, hwaddr pteg_off, +void *ppc_hash64_start_access (PowerPCCPU *cpu,unsigned long pte_index) +{ +void *token =NULL ; +hwaddr pte_offset; + + pte_offset = pte_index *HASH_PTE_SIZE_64 ; +if (kvmppc_kern_htab) { +/* +* HTAB is controlled by KVM. Fetch the PTEG into a new buffer. +*/ + token =kvmppc_hash64_read_pteg (cpu, pte_index); +if (token) { +return token; + } +/* +* pteg read failed, even though we have allocated htab via +* kvmppc_reset_htab. +*/
target-ppc/mmu-hash64.c static int ppc_hash64_amr_prot(CPUPPCState *env, ppc_hash_pte64_t pte) · line 337
Quoted 10 lines
target-ppc/mmu-hash64.c +10
-0+return NULL ; + } +/* +* HTAB is controlled by QEMU. Just point to the internally +* accessible PTEG. +*/ +if (cpu->env.external_htab) { + token = cpu->env.external_htab + pte_offset; + }else if (cpu->env.htab_base) { + token = (uint8_t *) cpu->env.htab_base + pte_offset;
This breaks if you run a 64-bit guest on a 32-bit host trying to access memory beyond 4GB. In that case htab_base is hwaddr (64bit) while uint8_t is only 32bit wide.
Just pass a 64bit token around. That makes it safe and easy.
Alex
Quoted 128 lines
target-ppc/mmu-hash64.c +31
-13+ } +return token; +} + +void ppc_hash64_stop_access (void *token) +{ +if (kvmppc_kern_htab) { +return kvmppc_hash64_free_pteg (token); + } +} + +static hwaddr ppc_hash64_pteg_search (CPUPPCState *env,hwaddr hash,bool secondary,target_ulong ptem,ppc_hash_pte64_t *pte) { - hwaddr pte_offset = pteg_off; -target_ulong pte0, pte1;int i; +void *token; +target_ulong pte0, pte1; +unsigned long pte_index; + pte_index = (hash & env->htab_mask) *HPTES_PER_GROUP ; + token =ppc_hash64_start_access (ppc_env_get_cpu (env), pte_index); +if (!token) { +return -1 ; + }for (i =0 ; i <HPTES_PER_GROUP ; i++) { - pte0 =ppc_hash64_load_hpte0 (env, pte_offset); - pte1 =ppc_hash64_load_hpte1 (env, pte_offset); + pte0 =ppc_hash64_load_hpte0 (env, token, i); + pte1 =ppc_hash64_load_hpte1 (env, token, i);if ((pte0 &HPTE64_V_VALID ) && (secondary == !!(pte0 &HPTE64_V_SECONDARY )) &&HPTE64_V_COMPARE (pte0, ptem)) { pte->pte0 = pte0; pte->pte1 = pte1; -return pte_offset; +ppc_hash64_stop_access (token); +return (pte_index + i) *HASH_PTE_SIZE_64 ; } - - pte_offset +=HASH_PTE_SIZE_64 ; } - +ppc_hash64_stop_access (token); +/* +* We didn't find a valid entry. +*/ return -1 ; }@@ -332,7 +384,7 @@ static hwaddr ppc_hash64_htab_lookup(CPUPPCState *env, ppc_slb_t *slb, target_ulong eaddr, ppc_hash_pte64_t *pte) { - hwaddr pteg_off, pte_offset; + hwaddr pte_offset;hwaddr hash;uint64_t vsid, epnshift, epnmask, epn, ptem;@@ -367,8 +419,7 @@ static hwaddr ppc_hash64_htab_lookup(CPUPPCState *env," vsid=" TARGET_FMT_lx" ptem=" TARGET_FMT_lx" hash=" TARGET_FMT_plx"\n" , env->htab_base, env->htab_mask, vsid, ptem, hash); - pteg_off = (hash *HASH_PTEG_SIZE_64 ) & env->htab_mask; - pte_offset =ppc_hash64_pteg_search (env, pteg_off,0 , ptem, pte); + pte_offset =ppc_hash64_pteg_search (env, hash,0 , ptem, pte);if (pte_offset ==-1 ) {/* Secondary PTEG lookup */ @@ -377,8 +428,7 @@ static hwaddr ppc_hash64_htab_lookup(CPUPPCState *env," hash=" TARGET_FMT_plx"\n" , env->htab_base, env->htab_mask, vsid, ptem, ~hash); - pteg_off = (~hash *HASH_PTEG_SIZE_64 ) & env->htab_mask; - pte_offset =ppc_hash64_pteg_search (env, pteg_off,1 , ptem, pte); + pte_offset =ppc_hash64_pteg_search (env, ~hash,1 , ptem, pte); }return pte_offset;target-ppc/mmu-hash64.h +15
-8@@ -75,23 +75,30 @@ int ppc_hash64_handle_mmu_fault(CPUPPCState *env, target_ulong address, int rw,#define HPTE64_V_1TB_SEG 0x4000000000000000ULL#define HPTE64_V_VRMA_MASK 0x4001ffffff000000ULL -static inline target_ulong ppc_hash64_load_hpte0 (CPUPPCState *env, -hwaddr pte_offset) + +extern bool kvmppc_kern_htab; +void *ppc_hash64_start_access (PowerPCCPU *cpu,unsigned long pte_index); +void ppc_hash64_stop_access (void *token); + +static inline target_ulong ppc_hash64_load_hpte0 (CPUPPCState *env,void *token, +int index) { + index *=HASH_PTE_SIZE_64 ;if (env->external_htab) { -return ldq_p (env->external_htab + pte_offset); +return ldq_p (token + index); }else { -return ldq_phys (env->htab_base + pte_offset); +return ldq_phys ((uint64_t )(token + index)); } } -static inline target_ulong ppc_hash64_load_hpte1 (CPUPPCState *env, -hwaddr pte_offset) +static inline target_ulong ppc_hash64_load_hpte1 (CPUPPCState *env,void *token, +int index) { + index *=HASH_PTE_SIZE_64 ;if (env->external_htab) { -return ldq_p (env->external_htab + pte_offset +HASH_PTE_SIZE_64 /2 ); +return ldq_p (token + index +HASH_PTE_SIZE_64 /2 ); }else { -return ldq_phys (env->htab_base + pte_offset +HASH_PTE_SIZE_64 /2 ); +return ldq_phys ((uint64_t )(token + index +HASH_PTE_SIZE_64 /2 )); } }Signature · 1 line
1.8.3.2
Re: [Qemu-devel] [PATCH -V7 3/3] target-ppc: Fix page table lookup with kvm enabled
Quoted 29 lines · Alexander Graf
Quoted 27 lines · Aneesh Kumar K.V
From: "Aneesh Kumar K.V" <[email protected]>
With kvm enabled, we store the hash page table information in the hypervisor. Use ioctl to read the htab contents. Without this we get the below error when trying to read the guest address
(gdb) x/10
do_fork0xc000000000098660<do_fork>: Cannot access memory at address0xc000000000098660
(gdb)Signed-off-by Aneesh Kumar K.V <[email protected]>---
Changes from V6:
* drophtab_fdargument and use global variablekvmppc_kern_htabinsteadhw/ppc/spapr.c | 1 + hw/ppc/spapr_hcall.c | 50 +++++++++++++++++++------------ target-ppc/kvm.c | 53 +++++++++++++++++++++++++++++++++ target-ppc/kvm_ppc.h | 19 ++++++++++++ target-ppc/mmu-hash64.c | 78 ++++++++++++++++++++++++++++++++++++++++--------- target-ppc/mmu-hash64.h | 23 ++++++++++----- 6 files changed, 183 insertions(+), 41 deletions(-)hw/ppc/spapr.c +0
-0
............
Quoted 7 lines
hw/ppc/spapr.c
Quoted 3 lines
hw/ppc/spapr.c +2
-0+ hpte += index *HASH_PTE_SIZE_64 ; +ppc_hash64_store_hpte1 (env, hpte, ptel);I'm not a big fan of fixing the read part, but leaving the write part broken. However I can see value in read only already, so I'm fine if the write part follows later.
When do we want store support per hpte entry w.r.t to hash page table maintained by the hypervisor. I didn't find a use case while doing this, hence i left that part out.
Quoted 9 lines
Quoted 9 lines
/* eieio(); FIXME: need some sort of barrier for smp? */ ppc_hash64_store_hpte0(env, hpte, pteh | HPTE64_V_HPTE_DIRTY);hw/ppc/spapr.c +1
-1- args[0 ] = pte_index + i; + args[0 ] = pte_index + index;return H_SUCCESS ;}
.....
Quoted 46 lines
Quoted 46 lines
#ifndef
CONFIG_KVMtarget-ppc/mmu-hash64.c +29
-1@@ -41,6 +41,11 @@#endif /* +* Used to indicate whether we have allocated htab in the +* host kernel +*/ +bool kvmppc_kern_htab; +/* * SLB handling */ @@ -302,29 +307,76 @@ static int ppc_hash64_amr_prot(CPUPPCState *env, ppc_hash_pte64_t pte)return prot; } -static hwaddr ppc_hash64_pteg_search(CPUPPCState *env, hwaddr pteg_off, +void *ppc_hash64_start_access (PowerPCCPU *cpu,unsigned long pte_index) +{ +void *token =NULL ; +hwaddr pte_offset; + + pte_offset = pte_index *HASH_PTE_SIZE_64 ; +if (kvmppc_kern_htab) { +/* +* HTAB is controlled by KVM. Fetch the PTEG into a new buffer. +*/ + token =kvmppc_hash64_read_pteg (cpu, pte_index); +if (token) { +return token; + } +/* +* pteg read failed, even though we have allocated htab via +* kvmppc_reset_htab. +*/ +return NULL ; + } +/* +* HTAB is controlled by QEMU. Just point to the internally +* accessible PTEG. +*/
Quoted 8 lines
target-ppc/mmu-hash64.c static int ppc_hash64_amr_prot(CPUPPCState *env, ppc_hash_pte64_t pte) · line 337
Quoted 4 lines
target-ppc/mmu-hash64.c +4
-0+if (cpu->env.external_htab) { + token = cpu->env.external_htab + pte_offset; + }else if (cpu->env.htab_base) { + token = (uint8_t *) cpu->env.htab_base + pte_offset;This breaks if you run a 64-bit guest on a 32-bit host trying to access memory beyond 4GB. In that case
htab_baseis hwaddr (64bit) whileuint8_tis only 32bit wide.
Wow!! didn't know that is possible.
Quoted 3 lines
Just pass a 64bit token around. That makes it safe and easy.
I converted that to uint64_t. How about Patch 1 and 2. Are they ok to go upstream ?
-aneesh
Re: [Qemu-devel] [PATCH -V7 3/3] target-ppc: Fix page table lookup with kvm enabled
Quoted 7 lines · Aneesh Kumar K.V
Quoted 3 lines · Alexander Graf
This breaks if you run a 64-bit guest on a 32-bit host trying to access memory beyond 4GB. In that case
htab_baseis hwaddr (64bit) whileuint8_tis only 32bit wide.Wow!! didn't know that is possible.
I don't believe it is. All of the 64-bit instructions would trap and we don't have code to emulate them (and even if we did, it would be painfully slow given that there would be a lot of them).
Paul.
Re: [Qemu-devel] [PATCH -V7 3/3] target-ppc: Fix page table lookup with kvm enabled
In reply to Aneesh Kumar K.VQuoted 38 lines · Aneesh Kumar K.V
Quoted 29 lines · Alexander Graf
Quoted 27 lines · Aneesh Kumar K.V
From: "Aneesh Kumar K.V" <[email protected]>
With kvm enabled, we store the hash page table information in the hypervisor. Use ioctl to read the htab contents. Without this we get the below error when trying to read the guest address
(gdb) x/10
do_fork0xc000000000098660<do_fork>: Cannot access memory at address0xc000000000098660
(gdb)Signed-off-by Aneesh Kumar K.V <[email protected]>---
Changes from V6:
* drophtab_fdargument and use global variablekvmppc_kern_htabinsteadhw/ppc/spapr.c | 1 + hw/ppc/spapr_hcall.c | 50 +++++++++++++++++++------------ target-ppc/kvm.c | 53 +++++++++++++++++++++++++++++++++ target-ppc/kvm_ppc.h | 19 ++++++++++++ target-ppc/mmu-hash64.c | 78 ++++++++++++++++++++++++++++++++++++++++--------- target-ppc/mmu-hash64.h | 23 ++++++++++----- 6 files changed, 183 insertions(+), 41 deletions(-)hw/ppc/spapr.c +0
-0............
Quoted 4 lines
Quoted 3 lines
hw/ppc/spapr.c +2
-0+ hpte += index *HASH_PTE_SIZE_64 ; +ppc_hash64_store_hpte1 (env, hpte, ptel);
Quoted 7 lines
Quoted 3 lines
I'm not a big fan of fixing the read part, but leaving the write part broken. However I can see value in read only already, so I'm fine if the write part follows later.
When do we want store support per hpte entry w.r.t to hash page table maintained by the hypervisor. I didn't find a use case while doing this, hence i left that part out.
Well, it's mostly a matter of consistency. The only case where it ever matters is if we wanted to emulate H_ENTER in QEMU - for tracing or debugging purposes. But if we leave it halfway implemented like this, you might get the impression it could work, but it doesn't.
Quoted 67 lines
Quoted 10 lines
Quoted 10 lines
/* eieio(); FIXME: need some sort of barrier for smp? */ ppc_hash64_store_hpte0(env, hpte, pteh | HPTE64_V_HPTE_DIRTY);hw/ppc/spapr.c +1
-1- args[0 ] = pte_index + i; + args[0 ] = pte_index + index;return H_SUCCESS ;}
.....
Quoted 46 lines
Quoted 46 lines
#ifndef
CONFIG_KVMtarget-ppc/mmu-hash64.c +29
-1@@ -41,6 +41,11 @@#endif /* +* Used to indicate whether we have allocated htab in the +* host kernel +*/ +bool kvmppc_kern_htab; +/* * SLB handling */ @@ -302,29 +307,76 @@ static int ppc_hash64_amr_prot(CPUPPCState *env, ppc_hash_pte64_t pte)return prot; } -static hwaddr ppc_hash64_pteg_search(CPUPPCState *env, hwaddr pteg_off, +void *ppc_hash64_start_access (PowerPCCPU *cpu,unsigned long pte_index) +{ +void *token =NULL ; +hwaddr pte_offset; + + pte_offset = pte_index *HASH_PTE_SIZE_64 ; +if (kvmppc_kern_htab) { +/* +* HTAB is controlled by KVM. Fetch the PTEG into a new buffer. +*/ + token =kvmppc_hash64_read_pteg (cpu, pte_index); +if (token) { +return token; + } +/* +* pteg read failed, even though we have allocated htab via +* kvmppc_reset_htab. +*/ +return NULL ; + } +/* +* HTAB is controlled by QEMU. Just point to the internally +* accessible PTEG. +*/ Quoted 8 lines
target-ppc/mmu-hash64.c static int ppc_hash64_amr_prot(CPUPPCState *env, ppc_hash_pte64_t pte) · line 337
Quoted 4 lines
target-ppc/mmu-hash64.c +4
-0+if (cpu->env.external_htab) { + token = cpu->env.external_htab + pte_offset; + }else if (cpu->env.htab_base) { + token = (uint8_t *) cpu->env.htab_base + pte_offset;This breaks if you run a 64-bit guest on a 32-bit host trying to access memory beyond 4GB. In that case
htab_baseis hwaddr (64bit) whileuint8_tis only 32bit wide.
Quoted 1 line
Wow!! didn't know that is possible.
Well, with TCG you can run a 64-bit guest on a 32-bit host system, right?
Quoted 7 lines
Quoted 4 lines
Just pass a 64bit token around. That makes it safe and easy.
I converted that to
uint64_t. How about Patch 1 and 2. Are they ok to go upstream ?
Yup. It took me a while to figure out that the patches are doing "the right thing". That code could really use some comments that explain what's going on - like the semantics of htab_mask (mask of the PTEG, will be shifted by 7 for physical address later), what htab_shift really is (log2 of the HTAB size), etc :).
Alex
Re: [Qemu-devel] [PATCH -V7 3/3] target-ppc: Fix page table lookup with kvm enabled
Quoted 130 lines · Alexander Graf
Quoted 38 lines · Aneesh Kumar K.V
Quoted 29 lines · Alexander Graf
Quoted 27 lines · Aneesh Kumar K.V
From: "Aneesh Kumar K.V" <[email protected]>
With kvm enabled, we store the hash page table information in the hypervisor. Use ioctl to read the htab contents. Without this we get the below error when trying to read the guest address
(gdb) x/10
do_fork0xc000000000098660<do_fork>: Cannot access memory at address0xc000000000098660
(gdb)Signed-off-by Aneesh Kumar K.V <[email protected]>---
Changes from V6:
* drophtab_fdargument and use global variablekvmppc_kern_htabinsteadhw/ppc/spapr.c | 1 + hw/ppc/spapr_hcall.c | 50 +++++++++++++++++++------------ target-ppc/kvm.c | 53 +++++++++++++++++++++++++++++++++ target-ppc/kvm_ppc.h | 19 ++++++++++++ target-ppc/mmu-hash64.c | 78 ++++++++++++++++++++++++++++++++++++++++--------- target-ppc/mmu-hash64.h | 23 ++++++++++----- 6 files changed, 183 insertions(+), 41 deletions(-)hw/ppc/spapr.c +0
-0............
Quoted 4 lines
Quoted 3 lines
hw/ppc/spapr.c +2
-0+ hpte += index *HASH_PTE_SIZE_64 ; +ppc_hash64_store_hpte1 (env, hpte, ptel);Quoted 7 lines
Quoted 3 lines
I'm not a big fan of fixing the read part, but leaving the write part broken. However I can see value in read only already, so I'm fine if the write part follows later.
When do we want store support per hpte entry w.r.t to hash page table maintained by the hypervisor. I didn't find a use case while doing this, hence i left that part out.
Well, it's mostly a matter of consistency. The only case where it ever matters is if we wanted to emulate
H_ENTERin QEMU - for tracing or debugging purposes. But if we leave it halfway implemented like this, you might get the impression it could work, but it doesn't.Quoted 67 lines
Quoted 10 lines
Quoted 10 lines
/* eieio(); FIXME: need some sort of barrier for smp? */ ppc_hash64_store_hpte0(env, hpte, pteh | HPTE64_V_HPTE_DIRTY);hw/ppc/spapr.c +1
-1- args[0 ] = pte_index + i; + args[0 ] = pte_index + index;return H_SUCCESS ;}
.....
Quoted 46 lines
Quoted 46 lines
#ifndef
CONFIG_KVMtarget-ppc/mmu-hash64.c +29
-1@@ -41,6 +41,11 @@#endif /* +* Used to indicate whether we have allocated htab in the +* host kernel +*/ +bool kvmppc_kern_htab; +/* * SLB handling */ @@ -302,29 +307,76 @@ static int ppc_hash64_amr_prot(CPUPPCState *env, ppc_hash_pte64_t pte)return prot; } -static hwaddr ppc_hash64_pteg_search(CPUPPCState *env, hwaddr pteg_off, +void *ppc_hash64_start_access (PowerPCCPU *cpu,unsigned long pte_index) +{ +void *token =NULL ; +hwaddr pte_offset; + + pte_offset = pte_index *HASH_PTE_SIZE_64 ; +if (kvmppc_kern_htab) { +/* +* HTAB is controlled by KVM. Fetch the PTEG into a new buffer. +*/ + token =kvmppc_hash64_read_pteg (cpu, pte_index); +if (token) { +return token; + } +/* +* pteg read failed, even though we have allocated htab via +* kvmppc_reset_htab. +*/ +return NULL ; + } +/* +* HTAB is controlled by QEMU. Just point to the internally +* accessible PTEG. +*/ Quoted 8 lines
target-ppc/mmu-hash64.c static int ppc_hash64_amr_prot(CPUPPCState *env, ppc_hash_pte64_t pte) · line 337
Quoted 4 lines
target-ppc/mmu-hash64.c +4
-0+if (cpu->env.external_htab) { + token = cpu->env.external_htab + pte_offset; + }else if (cpu->env.htab_base) { + token = (uint8_t *) cpu->env.htab_base + pte_offset;This breaks if you run a 64-bit guest on a 32-bit host trying to access memory beyond 4GB. In that case
htab_baseis hwaddr (64bit) whileuint8_tis only 32bit wide.Quoted 1 line
Wow!! didn't know that is possible.
Well, with TCG you can run a 64-bit guest on a 32-bit host system, right?
Quoted 5 lines
Quoted 4 lines
Just pass a 64bit token around. That makes it safe and easy.
Quoted 8 lines
Quoted 2 lines
I converted that to
uint64_t. How about Patch 1 and 2. Are they ok to go upstream ?Yup. It took me a while to figure out that the patches are doing "the right thing". That code could really use some comments that explain what's going on - like the semantics of
htab_mask(mask of the PTEG, will be shifted by 7 for physical address later), whathtab_shiftreally is (log2 of the HTAB size), etc :).
How about
/*
* htab_mask is the mask used normalize hash value to PTEG index.
* htab_shift is log2 of hash table size.
* We have 8 hpte per group, and each hpte is 16 bytes.
* ie have 128 bytes per hpte entry.
*/
-aneesh
Re: [Qemu-devel] [PATCH -V7 3/3] target-ppc: Fix page table lookup with kvm enabled
Quoted 142 lines · Aneesh Kumar K.V
Quoted 130 lines · Alexander Graf
Quoted 38 lines · Aneesh Kumar K.V
Quoted 29 lines · Alexander Graf
Quoted 27 lines · Aneesh Kumar K.V
From: "Aneesh Kumar K.V" <[email protected]>
With kvm enabled, we store the hash page table information in the hypervisor. Use ioctl to read the htab contents. Without this we get the below error when trying to read the guest address
(gdb) x/10
do_fork0xc000000000098660<do_fork>: Cannot access memory at address0xc000000000098660
(gdb)Signed-off-by Aneesh Kumar K.V <[email protected]>---
Changes from V6:
* drophtab_fdargument and use global variablekvmppc_kern_htabinsteadhw/ppc/spapr.c | 1 + hw/ppc/spapr_hcall.c | 50 +++++++++++++++++++------------ target-ppc/kvm.c | 53 +++++++++++++++++++++++++++++++++ target-ppc/kvm_ppc.h | 19 ++++++++++++ target-ppc/mmu-hash64.c | 78 ++++++++++++++++++++++++++++++++++++++++--------- target-ppc/mmu-hash64.h | 23 ++++++++++----- 6 files changed, 183 insertions(+), 41 deletions(-)hw/ppc/spapr.c +0
-0............
Quoted 4 lines
Quoted 3 lines
hw/ppc/spapr.c +2
-0+ hpte += index *HASH_PTE_SIZE_64 ; +ppc_hash64_store_hpte1 (env, hpte, ptel);Quoted 7 lines
Quoted 3 lines
I'm not a big fan of fixing the read part, but leaving the write part broken. However I can see value in read only already, so I'm fine if the write part follows later.
When do we want store support per hpte entry w.r.t to hash page table maintained by the hypervisor. I didn't find a use case while doing this, hence i left that part out.
Well, it's mostly a matter of consistency. The only case where it ever matters is if we wanted to emulate
H_ENTERin QEMU - for tracing or debugging purposes. But if we leave it halfway implemented like this, you might get the impression it could work, but it doesn't.Quoted 67 lines
Quoted 10 lines
Quoted 10 lines
/*
eieio(); FIXME: need some sort of barrier for smp? */ppc_hash64_store_hpte0(env, hpte, pteh | HPTE64_V_HPTE_DIRTY);hw/ppc/spapr.c +1
-1- args[0 ] = pte_index + i; + args[0 ] = pte_index + index;return H_SUCCESS ;}
.....
Quoted 46 lines
Quoted 46 lines
#ifndef
CONFIG_KVMtarget-ppc/mmu-hash64.c +29
-1@@ -41,6 +41,11 @@#endif /* +* Used to indicate whether we have allocated htab in the +* host kernel +*/ +bool kvmppc_kern_htab; +/* * SLB handling */ @@ -302,29 +307,76 @@ static int ppc_hash64_amr_prot(CPUPPCState *env, ppc_hash_pte64_t pte)return prot; } -static hwaddr ppc_hash64_pteg_search(CPUPPCState *env, hwaddr pteg_off, +void *ppc_hash64_start_access (PowerPCCPU *cpu,unsigned long pte_index) +{ +void *token =NULL ; +hwaddr pte_offset; + + pte_offset = pte_index *HASH_PTE_SIZE_64 ; +if (kvmppc_kern_htab) { +/* +* HTAB is controlled by KVM. Fetch the PTEG into a new buffer. +*/ + token =kvmppc_hash64_read_pteg (cpu, pte_index); +if (token) { +return token; + } +/* +* pteg read failed, even though we have allocated htab via +* kvmppc_reset_htab. +*/ +return NULL ; + } +/* +* HTAB is controlled by QEMU. Just point to the internally +* accessible PTEG. +*/ Quoted 8 lines
target-ppc/mmu-hash64.c static int ppc_hash64_amr_prot(CPUPPCState *env, ppc_hash_pte64_t pte) · line 337
Quoted 4 lines
target-ppc/mmu-hash64.c +4
-0+if (cpu->env.external_htab) { + token = cpu->env.external_htab + pte_offset; + }else if (cpu->env.htab_base) { + token = (uint8_t *) cpu->env.htab_base + pte_offset;This breaks if you run a 64-bit guest on a 32-bit host trying to access memory beyond 4GB. In that case
htab_baseis hwaddr (64bit) whileuint8_tis only 32bit wide.Quoted 1 line
Wow!! didn't know that is possible.
Well, with TCG you can run a 64-bit guest on a 32-bit host system, right?
Quoted 5 lines
Quoted 4 lines
Just pass a 64bit token around. That makes it safe and easy.
Quoted 8 lines
Quoted 2 lines
I converted that to
uint64_t. How about Patch 1 and 2. Are they ok to go upstream ?Yup. It took me a while to figure out that the patches are doing "the right thing". That code could really use some comments that explain what's going on - like the semantics of
htab_mask(mask of the PTEG, will be shifted by 7 for physical address later), whathtab_shiftreally is (log2 of the HTAB size), etc :).
Quoted 8 lines
How about
/*
*htab_maskis the mask used normalize hash value to PTEG index.
*htab_shiftis log2 of hash table size.
* We have 8 hpte per group, and each hpte is 16 bytes.
* ie have 128 bytes per hpte entry.
*/
I was thinking that maybe the htab_shift and htab_mask names are just confusing. But I haven't managed to come up with really good names either.
Just put some comment on the variable definitions and let's hope that makes us remember what they were supposed to mean next time we have to dig through this code.
Alex