1 /* 2 * Copyright (C) 2011. Freescale Inc. All rights reserved. 3 * 4 * Authors: 5 * Alexander Graf <agraf@suse.de> 6 * Paul Mackerras <paulus@samba.org> 7 * 8 * Description: 9 * 10 * Hypercall handling for running PAPR guests in PR KVM on Book 3S 11 * processors. 12 * 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License, version 2, as 15 * published by the Free Software Foundation. 16 */ 17 18 #include <linux/anon_inodes.h> 19 20 #include <asm/uaccess.h> 21 #include <asm/kvm_ppc.h> 22 #include <asm/kvm_book3s.h> 23 24 #define HPTE_SIZE 16 /* bytes per HPT entry */ 25 26 static unsigned long get_pteg_addr(struct kvm_vcpu *vcpu, long pte_index) 27 { 28 struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu); 29 unsigned long pteg_addr; 30 31 pte_index <<= 4; 32 pte_index &= ((1 << ((vcpu_book3s->sdr1 & 0x1f) + 11)) - 1) << 7 | 0x70; 33 pteg_addr = vcpu_book3s->sdr1 & 0xfffffffffffc0000ULL; 34 pteg_addr |= pte_index; 35 36 return pteg_addr; 37 } 38 39 static int kvmppc_h_pr_enter(struct kvm_vcpu *vcpu) 40 { 41 long flags = kvmppc_get_gpr(vcpu, 4); 42 long pte_index = kvmppc_get_gpr(vcpu, 5); 43 unsigned long pteg[2 * 8]; 44 unsigned long pteg_addr, i, *hpte; 45 long int ret; 46 47 i = pte_index & 7; 48 pte_index &= ~7UL; 49 pteg_addr = get_pteg_addr(vcpu, pte_index); 50 51 mutex_lock(&vcpu->kvm->arch.hpt_mutex); 52 copy_from_user(pteg, (void __user *)pteg_addr, sizeof(pteg)); 53 hpte = pteg; 54 55 ret = H_PTEG_FULL; 56 if (likely((flags & H_EXACT) == 0)) { 57 for (i = 0; ; ++i) { 58 if (i == 8) 59 goto done; 60 if ((be64_to_cpu(*hpte) & HPTE_V_VALID) == 0) 61 break; 62 hpte += 2; 63 } 64 } else { 65 hpte += i * 2; 66 if (*hpte & HPTE_V_VALID) 67 goto done; 68 } 69 70 hpte[0] = cpu_to_be64(kvmppc_get_gpr(vcpu, 6)); 71 hpte[1] = cpu_to_be64(kvmppc_get_gpr(vcpu, 7)); 72 pteg_addr += i * HPTE_SIZE; 73 copy_to_user((void __user *)pteg_addr, hpte, HPTE_SIZE); 74 kvmppc_set_gpr(vcpu, 4, pte_index | i); 75 ret = H_SUCCESS; 76 77 done: 78 mutex_unlock(&vcpu->kvm->arch.hpt_mutex); 79 kvmppc_set_gpr(vcpu, 3, ret); 80 81 return EMULATE_DONE; 82 } 83 84 static int kvmppc_h_pr_remove(struct kvm_vcpu *vcpu) 85 { 86 unsigned long flags= kvmppc_get_gpr(vcpu, 4); 87 unsigned long pte_index = kvmppc_get_gpr(vcpu, 5); 88 unsigned long avpn = kvmppc_get_gpr(vcpu, 6); 89 unsigned long v = 0, pteg, rb; 90 unsigned long pte[2]; 91 long int ret; 92 93 pteg = get_pteg_addr(vcpu, pte_index); 94 mutex_lock(&vcpu->kvm->arch.hpt_mutex); 95 copy_from_user(pte, (void __user *)pteg, sizeof(pte)); 96 pte[0] = be64_to_cpu(pte[0]); 97 pte[1] = be64_to_cpu(pte[1]); 98 99 ret = H_NOT_FOUND; 100 if ((pte[0] & HPTE_V_VALID) == 0 || 101 ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn) || 102 ((flags & H_ANDCOND) && (pte[0] & avpn) != 0)) 103 goto done; 104 105 copy_to_user((void __user *)pteg, &v, sizeof(v)); 106 107 rb = compute_tlbie_rb(pte[0], pte[1], pte_index); 108 vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false); 109 110 ret = H_SUCCESS; 111 kvmppc_set_gpr(vcpu, 4, pte[0]); 112 kvmppc_set_gpr(vcpu, 5, pte[1]); 113 114 done: 115 mutex_unlock(&vcpu->kvm->arch.hpt_mutex); 116 kvmppc_set_gpr(vcpu, 3, ret); 117 118 return EMULATE_DONE; 119 } 120 121 /* Request defs for kvmppc_h_pr_bulk_remove() */ 122 #define H_BULK_REMOVE_TYPE 0xc000000000000000ULL 123 #define H_BULK_REMOVE_REQUEST 0x4000000000000000ULL 124 #define H_BULK_REMOVE_RESPONSE 0x8000000000000000ULL 125 #define H_BULK_REMOVE_END 0xc000000000000000ULL 126 #define H_BULK_REMOVE_CODE 0x3000000000000000ULL 127 #define H_BULK_REMOVE_SUCCESS 0x0000000000000000ULL 128 #define H_BULK_REMOVE_NOT_FOUND 0x1000000000000000ULL 129 #define H_BULK_REMOVE_PARM 0x2000000000000000ULL 130 #define H_BULK_REMOVE_HW 0x3000000000000000ULL 131 #define H_BULK_REMOVE_RC 0x0c00000000000000ULL 132 #define H_BULK_REMOVE_FLAGS 0x0300000000000000ULL 133 #define H_BULK_REMOVE_ABSOLUTE 0x0000000000000000ULL 134 #define H_BULK_REMOVE_ANDCOND 0x0100000000000000ULL 135 #define H_BULK_REMOVE_AVPN 0x0200000000000000ULL 136 #define H_BULK_REMOVE_PTEX 0x00ffffffffffffffULL 137 #define H_BULK_REMOVE_MAX_BATCH 4 138 139 static int kvmppc_h_pr_bulk_remove(struct kvm_vcpu *vcpu) 140 { 141 int i; 142 int paramnr = 4; 143 int ret = H_SUCCESS; 144 145 mutex_lock(&vcpu->kvm->arch.hpt_mutex); 146 for (i = 0; i < H_BULK_REMOVE_MAX_BATCH; i++) { 147 unsigned long tsh = kvmppc_get_gpr(vcpu, paramnr+(2*i)); 148 unsigned long tsl = kvmppc_get_gpr(vcpu, paramnr+(2*i)+1); 149 unsigned long pteg, rb, flags; 150 unsigned long pte[2]; 151 unsigned long v = 0; 152 153 if ((tsh & H_BULK_REMOVE_TYPE) == H_BULK_REMOVE_END) { 154 break; /* Exit success */ 155 } else if ((tsh & H_BULK_REMOVE_TYPE) != 156 H_BULK_REMOVE_REQUEST) { 157 ret = H_PARAMETER; 158 break; /* Exit fail */ 159 } 160 161 tsh &= H_BULK_REMOVE_PTEX | H_BULK_REMOVE_FLAGS; 162 tsh |= H_BULK_REMOVE_RESPONSE; 163 164 if ((tsh & H_BULK_REMOVE_ANDCOND) && 165 (tsh & H_BULK_REMOVE_AVPN)) { 166 tsh |= H_BULK_REMOVE_PARM; 167 kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh); 168 ret = H_PARAMETER; 169 break; /* Exit fail */ 170 } 171 172 pteg = get_pteg_addr(vcpu, tsh & H_BULK_REMOVE_PTEX); 173 copy_from_user(pte, (void __user *)pteg, sizeof(pte)); 174 pte[0] = be64_to_cpu(pte[0]); 175 pte[1] = be64_to_cpu(pte[1]); 176 177 /* tsl = AVPN */ 178 flags = (tsh & H_BULK_REMOVE_FLAGS) >> 26; 179 180 if ((pte[0] & HPTE_V_VALID) == 0 || 181 ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != tsl) || 182 ((flags & H_ANDCOND) && (pte[0] & tsl) != 0)) { 183 tsh |= H_BULK_REMOVE_NOT_FOUND; 184 } else { 185 /* Splat the pteg in (userland) hpt */ 186 copy_to_user((void __user *)pteg, &v, sizeof(v)); 187 188 rb = compute_tlbie_rb(pte[0], pte[1], 189 tsh & H_BULK_REMOVE_PTEX); 190 vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false); 191 tsh |= H_BULK_REMOVE_SUCCESS; 192 tsh |= (pte[1] & (HPTE_R_C | HPTE_R_R)) << 43; 193 } 194 kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh); 195 } 196 mutex_unlock(&vcpu->kvm->arch.hpt_mutex); 197 kvmppc_set_gpr(vcpu, 3, ret); 198 199 return EMULATE_DONE; 200 } 201 202 static int kvmppc_h_pr_protect(struct kvm_vcpu *vcpu) 203 { 204 unsigned long flags = kvmppc_get_gpr(vcpu, 4); 205 unsigned long pte_index = kvmppc_get_gpr(vcpu, 5); 206 unsigned long avpn = kvmppc_get_gpr(vcpu, 6); 207 unsigned long rb, pteg, r, v; 208 unsigned long pte[2]; 209 long int ret; 210 211 pteg = get_pteg_addr(vcpu, pte_index); 212 mutex_lock(&vcpu->kvm->arch.hpt_mutex); 213 copy_from_user(pte, (void __user *)pteg, sizeof(pte)); 214 pte[0] = be64_to_cpu(pte[0]); 215 pte[1] = be64_to_cpu(pte[1]); 216 217 ret = H_NOT_FOUND; 218 if ((pte[0] & HPTE_V_VALID) == 0 || 219 ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn)) 220 goto done; 221 222 v = pte[0]; 223 r = pte[1]; 224 r &= ~(HPTE_R_PP0 | HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_HI | 225 HPTE_R_KEY_LO); 226 r |= (flags << 55) & HPTE_R_PP0; 227 r |= (flags << 48) & HPTE_R_KEY_HI; 228 r |= flags & (HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_LO); 229 230 pte[1] = r; 231 232 rb = compute_tlbie_rb(v, r, pte_index); 233 vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false); 234 pte[0] = cpu_to_be64(pte[0]); 235 pte[1] = cpu_to_be64(pte[1]); 236 copy_to_user((void __user *)pteg, pte, sizeof(pte)); 237 ret = H_SUCCESS; 238 239 done: 240 mutex_unlock(&vcpu->kvm->arch.hpt_mutex); 241 kvmppc_set_gpr(vcpu, 3, ret); 242 243 return EMULATE_DONE; 244 } 245 246 static int kvmppc_h_pr_put_tce(struct kvm_vcpu *vcpu) 247 { 248 unsigned long liobn = kvmppc_get_gpr(vcpu, 4); 249 unsigned long ioba = kvmppc_get_gpr(vcpu, 5); 250 unsigned long tce = kvmppc_get_gpr(vcpu, 6); 251 long rc; 252 253 rc = kvmppc_h_put_tce(vcpu, liobn, ioba, tce); 254 if (rc == H_TOO_HARD) 255 return EMULATE_FAIL; 256 kvmppc_set_gpr(vcpu, 3, rc); 257 return EMULATE_DONE; 258 } 259 260 static int kvmppc_h_pr_xics_hcall(struct kvm_vcpu *vcpu, u32 cmd) 261 { 262 long rc = kvmppc_xics_hcall(vcpu, cmd); 263 kvmppc_set_gpr(vcpu, 3, rc); 264 return EMULATE_DONE; 265 } 266 267 int kvmppc_h_pr(struct kvm_vcpu *vcpu, unsigned long cmd) 268 { 269 switch (cmd) { 270 case H_ENTER: 271 return kvmppc_h_pr_enter(vcpu); 272 case H_REMOVE: 273 return kvmppc_h_pr_remove(vcpu); 274 case H_PROTECT: 275 return kvmppc_h_pr_protect(vcpu); 276 case H_BULK_REMOVE: 277 return kvmppc_h_pr_bulk_remove(vcpu); 278 case H_PUT_TCE: 279 return kvmppc_h_pr_put_tce(vcpu); 280 case H_CEDE: 281 kvmppc_set_msr_fast(vcpu, kvmppc_get_msr(vcpu) | MSR_EE); 282 kvm_vcpu_block(vcpu); 283 clear_bit(KVM_REQ_UNHALT, &vcpu->requests); 284 vcpu->stat.halt_wakeup++; 285 return EMULATE_DONE; 286 case H_XIRR: 287 case H_CPPR: 288 case H_EOI: 289 case H_IPI: 290 case H_IPOLL: 291 case H_XIRR_X: 292 if (kvmppc_xics_enabled(vcpu)) 293 return kvmppc_h_pr_xics_hcall(vcpu, cmd); 294 break; 295 case H_RTAS: 296 if (list_empty(&vcpu->kvm->arch.rtas_tokens)) 297 return RESUME_HOST; 298 if (kvmppc_rtas_hcall(vcpu)) 299 break; 300 kvmppc_set_gpr(vcpu, 3, 0); 301 return EMULATE_DONE; 302 } 303 304 return EMULATE_FAIL; 305 } 306