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 __be64 pteg[2 * 8]; 44 __be64 *hpte; 45 unsigned long pteg_addr, i; 46 long int ret; 47 48 i = pte_index & 7; 49 pte_index &= ~7UL; 50 pteg_addr = get_pteg_addr(vcpu, pte_index); 51 52 mutex_lock(&vcpu->kvm->arch.hpt_mutex); 53 copy_from_user(pteg, (void __user *)pteg_addr, sizeof(pteg)); 54 hpte = pteg; 55 56 ret = H_PTEG_FULL; 57 if (likely((flags & H_EXACT) == 0)) { 58 for (i = 0; ; ++i) { 59 if (i == 8) 60 goto done; 61 if ((be64_to_cpu(*hpte) & HPTE_V_VALID) == 0) 62 break; 63 hpte += 2; 64 } 65 } else { 66 hpte += i * 2; 67 if (*hpte & HPTE_V_VALID) 68 goto done; 69 } 70 71 hpte[0] = cpu_to_be64(kvmppc_get_gpr(vcpu, 6)); 72 hpte[1] = cpu_to_be64(kvmppc_get_gpr(vcpu, 7)); 73 pteg_addr += i * HPTE_SIZE; 74 copy_to_user((void __user *)pteg_addr, hpte, HPTE_SIZE); 75 kvmppc_set_gpr(vcpu, 4, pte_index | i); 76 ret = H_SUCCESS; 77 78 done: 79 mutex_unlock(&vcpu->kvm->arch.hpt_mutex); 80 kvmppc_set_gpr(vcpu, 3, ret); 81 82 return EMULATE_DONE; 83 } 84 85 static int kvmppc_h_pr_remove(struct kvm_vcpu *vcpu) 86 { 87 unsigned long flags= kvmppc_get_gpr(vcpu, 4); 88 unsigned long pte_index = kvmppc_get_gpr(vcpu, 5); 89 unsigned long avpn = kvmppc_get_gpr(vcpu, 6); 90 unsigned long v = 0, pteg, rb; 91 unsigned long pte[2]; 92 long int ret; 93 94 pteg = get_pteg_addr(vcpu, pte_index); 95 mutex_lock(&vcpu->kvm->arch.hpt_mutex); 96 copy_from_user(pte, (void __user *)pteg, sizeof(pte)); 97 pte[0] = be64_to_cpu((__force __be64)pte[0]); 98 pte[1] = be64_to_cpu((__force __be64)pte[1]); 99 100 ret = H_NOT_FOUND; 101 if ((pte[0] & HPTE_V_VALID) == 0 || 102 ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn) || 103 ((flags & H_ANDCOND) && (pte[0] & avpn) != 0)) 104 goto done; 105 106 copy_to_user((void __user *)pteg, &v, sizeof(v)); 107 108 rb = compute_tlbie_rb(pte[0], pte[1], pte_index); 109 vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false); 110 111 ret = H_SUCCESS; 112 kvmppc_set_gpr(vcpu, 4, pte[0]); 113 kvmppc_set_gpr(vcpu, 5, pte[1]); 114 115 done: 116 mutex_unlock(&vcpu->kvm->arch.hpt_mutex); 117 kvmppc_set_gpr(vcpu, 3, ret); 118 119 return EMULATE_DONE; 120 } 121 122 /* Request defs for kvmppc_h_pr_bulk_remove() */ 123 #define H_BULK_REMOVE_TYPE 0xc000000000000000ULL 124 #define H_BULK_REMOVE_REQUEST 0x4000000000000000ULL 125 #define H_BULK_REMOVE_RESPONSE 0x8000000000000000ULL 126 #define H_BULK_REMOVE_END 0xc000000000000000ULL 127 #define H_BULK_REMOVE_CODE 0x3000000000000000ULL 128 #define H_BULK_REMOVE_SUCCESS 0x0000000000000000ULL 129 #define H_BULK_REMOVE_NOT_FOUND 0x1000000000000000ULL 130 #define H_BULK_REMOVE_PARM 0x2000000000000000ULL 131 #define H_BULK_REMOVE_HW 0x3000000000000000ULL 132 #define H_BULK_REMOVE_RC 0x0c00000000000000ULL 133 #define H_BULK_REMOVE_FLAGS 0x0300000000000000ULL 134 #define H_BULK_REMOVE_ABSOLUTE 0x0000000000000000ULL 135 #define H_BULK_REMOVE_ANDCOND 0x0100000000000000ULL 136 #define H_BULK_REMOVE_AVPN 0x0200000000000000ULL 137 #define H_BULK_REMOVE_PTEX 0x00ffffffffffffffULL 138 #define H_BULK_REMOVE_MAX_BATCH 4 139 140 static int kvmppc_h_pr_bulk_remove(struct kvm_vcpu *vcpu) 141 { 142 int i; 143 int paramnr = 4; 144 int ret = H_SUCCESS; 145 146 mutex_lock(&vcpu->kvm->arch.hpt_mutex); 147 for (i = 0; i < H_BULK_REMOVE_MAX_BATCH; i++) { 148 unsigned long tsh = kvmppc_get_gpr(vcpu, paramnr+(2*i)); 149 unsigned long tsl = kvmppc_get_gpr(vcpu, paramnr+(2*i)+1); 150 unsigned long pteg, rb, flags; 151 unsigned long pte[2]; 152 unsigned long v = 0; 153 154 if ((tsh & H_BULK_REMOVE_TYPE) == H_BULK_REMOVE_END) { 155 break; /* Exit success */ 156 } else if ((tsh & H_BULK_REMOVE_TYPE) != 157 H_BULK_REMOVE_REQUEST) { 158 ret = H_PARAMETER; 159 break; /* Exit fail */ 160 } 161 162 tsh &= H_BULK_REMOVE_PTEX | H_BULK_REMOVE_FLAGS; 163 tsh |= H_BULK_REMOVE_RESPONSE; 164 165 if ((tsh & H_BULK_REMOVE_ANDCOND) && 166 (tsh & H_BULK_REMOVE_AVPN)) { 167 tsh |= H_BULK_REMOVE_PARM; 168 kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh); 169 ret = H_PARAMETER; 170 break; /* Exit fail */ 171 } 172 173 pteg = get_pteg_addr(vcpu, tsh & H_BULK_REMOVE_PTEX); 174 copy_from_user(pte, (void __user *)pteg, sizeof(pte)); 175 pte[0] = be64_to_cpu((__force __be64)pte[0]); 176 pte[1] = be64_to_cpu((__force __be64)pte[1]); 177 178 /* tsl = AVPN */ 179 flags = (tsh & H_BULK_REMOVE_FLAGS) >> 26; 180 181 if ((pte[0] & HPTE_V_VALID) == 0 || 182 ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != tsl) || 183 ((flags & H_ANDCOND) && (pte[0] & tsl) != 0)) { 184 tsh |= H_BULK_REMOVE_NOT_FOUND; 185 } else { 186 /* Splat the pteg in (userland) hpt */ 187 copy_to_user((void __user *)pteg, &v, sizeof(v)); 188 189 rb = compute_tlbie_rb(pte[0], pte[1], 190 tsh & H_BULK_REMOVE_PTEX); 191 vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false); 192 tsh |= H_BULK_REMOVE_SUCCESS; 193 tsh |= (pte[1] & (HPTE_R_C | HPTE_R_R)) << 43; 194 } 195 kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh); 196 } 197 mutex_unlock(&vcpu->kvm->arch.hpt_mutex); 198 kvmppc_set_gpr(vcpu, 3, ret); 199 200 return EMULATE_DONE; 201 } 202 203 static int kvmppc_h_pr_protect(struct kvm_vcpu *vcpu) 204 { 205 unsigned long flags = kvmppc_get_gpr(vcpu, 4); 206 unsigned long pte_index = kvmppc_get_gpr(vcpu, 5); 207 unsigned long avpn = kvmppc_get_gpr(vcpu, 6); 208 unsigned long rb, pteg, r, v; 209 unsigned long pte[2]; 210 long int ret; 211 212 pteg = get_pteg_addr(vcpu, pte_index); 213 mutex_lock(&vcpu->kvm->arch.hpt_mutex); 214 copy_from_user(pte, (void __user *)pteg, sizeof(pte)); 215 pte[0] = be64_to_cpu((__force __be64)pte[0]); 216 pte[1] = be64_to_cpu((__force __be64)pte[1]); 217 218 ret = H_NOT_FOUND; 219 if ((pte[0] & HPTE_V_VALID) == 0 || 220 ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn)) 221 goto done; 222 223 v = pte[0]; 224 r = pte[1]; 225 r &= ~(HPTE_R_PP0 | HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_HI | 226 HPTE_R_KEY_LO); 227 r |= (flags << 55) & HPTE_R_PP0; 228 r |= (flags << 48) & HPTE_R_KEY_HI; 229 r |= flags & (HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_LO); 230 231 pte[1] = r; 232 233 rb = compute_tlbie_rb(v, r, pte_index); 234 vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false); 235 pte[0] = (__force u64)cpu_to_be64(pte[0]); 236 pte[1] = (__force u64)cpu_to_be64(pte[1]); 237 copy_to_user((void __user *)pteg, pte, sizeof(pte)); 238 ret = H_SUCCESS; 239 240 done: 241 mutex_unlock(&vcpu->kvm->arch.hpt_mutex); 242 kvmppc_set_gpr(vcpu, 3, ret); 243 244 return EMULATE_DONE; 245 } 246 247 static int kvmppc_h_pr_put_tce(struct kvm_vcpu *vcpu) 248 { 249 unsigned long liobn = kvmppc_get_gpr(vcpu, 4); 250 unsigned long ioba = kvmppc_get_gpr(vcpu, 5); 251 unsigned long tce = kvmppc_get_gpr(vcpu, 6); 252 long rc; 253 254 rc = kvmppc_h_put_tce(vcpu, liobn, ioba, tce); 255 if (rc == H_TOO_HARD) 256 return EMULATE_FAIL; 257 kvmppc_set_gpr(vcpu, 3, rc); 258 return EMULATE_DONE; 259 } 260 261 static int kvmppc_h_pr_logical_ci_load(struct kvm_vcpu *vcpu) 262 { 263 long rc; 264 265 rc = kvmppc_h_logical_ci_load(vcpu); 266 if (rc == H_TOO_HARD) 267 return EMULATE_FAIL; 268 kvmppc_set_gpr(vcpu, 3, rc); 269 return EMULATE_DONE; 270 } 271 272 static int kvmppc_h_pr_logical_ci_store(struct kvm_vcpu *vcpu) 273 { 274 long rc; 275 276 rc = kvmppc_h_logical_ci_store(vcpu); 277 if (rc == H_TOO_HARD) 278 return EMULATE_FAIL; 279 kvmppc_set_gpr(vcpu, 3, rc); 280 return EMULATE_DONE; 281 } 282 283 static int kvmppc_h_pr_put_tce_indirect(struct kvm_vcpu *vcpu) 284 { 285 unsigned long liobn = kvmppc_get_gpr(vcpu, 4); 286 unsigned long ioba = kvmppc_get_gpr(vcpu, 5); 287 unsigned long tce = kvmppc_get_gpr(vcpu, 6); 288 unsigned long npages = kvmppc_get_gpr(vcpu, 7); 289 long rc; 290 291 rc = kvmppc_h_put_tce_indirect(vcpu, liobn, ioba, 292 tce, npages); 293 if (rc == H_TOO_HARD) 294 return EMULATE_FAIL; 295 kvmppc_set_gpr(vcpu, 3, rc); 296 return EMULATE_DONE; 297 } 298 299 static int kvmppc_h_pr_stuff_tce(struct kvm_vcpu *vcpu) 300 { 301 unsigned long liobn = kvmppc_get_gpr(vcpu, 4); 302 unsigned long ioba = kvmppc_get_gpr(vcpu, 5); 303 unsigned long tce_value = kvmppc_get_gpr(vcpu, 6); 304 unsigned long npages = kvmppc_get_gpr(vcpu, 7); 305 long rc; 306 307 rc = kvmppc_h_stuff_tce(vcpu, liobn, ioba, tce_value, npages); 308 if (rc == H_TOO_HARD) 309 return EMULATE_FAIL; 310 kvmppc_set_gpr(vcpu, 3, rc); 311 return EMULATE_DONE; 312 } 313 314 static int kvmppc_h_pr_xics_hcall(struct kvm_vcpu *vcpu, u32 cmd) 315 { 316 long rc = kvmppc_xics_hcall(vcpu, cmd); 317 kvmppc_set_gpr(vcpu, 3, rc); 318 return EMULATE_DONE; 319 } 320 321 int kvmppc_h_pr(struct kvm_vcpu *vcpu, unsigned long cmd) 322 { 323 int rc, idx; 324 325 if (cmd <= MAX_HCALL_OPCODE && 326 !test_bit(cmd/4, vcpu->kvm->arch.enabled_hcalls)) 327 return EMULATE_FAIL; 328 329 switch (cmd) { 330 case H_ENTER: 331 return kvmppc_h_pr_enter(vcpu); 332 case H_REMOVE: 333 return kvmppc_h_pr_remove(vcpu); 334 case H_PROTECT: 335 return kvmppc_h_pr_protect(vcpu); 336 case H_BULK_REMOVE: 337 return kvmppc_h_pr_bulk_remove(vcpu); 338 case H_PUT_TCE: 339 return kvmppc_h_pr_put_tce(vcpu); 340 case H_PUT_TCE_INDIRECT: 341 return kvmppc_h_pr_put_tce_indirect(vcpu); 342 case H_STUFF_TCE: 343 return kvmppc_h_pr_stuff_tce(vcpu); 344 case H_CEDE: 345 kvmppc_set_msr_fast(vcpu, kvmppc_get_msr(vcpu) | MSR_EE); 346 kvm_vcpu_block(vcpu); 347 clear_bit(KVM_REQ_UNHALT, &vcpu->requests); 348 vcpu->stat.halt_wakeup++; 349 return EMULATE_DONE; 350 case H_LOGICAL_CI_LOAD: 351 return kvmppc_h_pr_logical_ci_load(vcpu); 352 case H_LOGICAL_CI_STORE: 353 return kvmppc_h_pr_logical_ci_store(vcpu); 354 case H_XIRR: 355 case H_CPPR: 356 case H_EOI: 357 case H_IPI: 358 case H_IPOLL: 359 case H_XIRR_X: 360 if (kvmppc_xics_enabled(vcpu)) 361 return kvmppc_h_pr_xics_hcall(vcpu, cmd); 362 break; 363 case H_RTAS: 364 if (list_empty(&vcpu->kvm->arch.rtas_tokens)) 365 break; 366 idx = srcu_read_lock(&vcpu->kvm->srcu); 367 rc = kvmppc_rtas_hcall(vcpu); 368 srcu_read_unlock(&vcpu->kvm->srcu, idx); 369 if (rc) 370 break; 371 kvmppc_set_gpr(vcpu, 3, 0); 372 return EMULATE_DONE; 373 } 374 375 return EMULATE_FAIL; 376 } 377 378 int kvmppc_hcall_impl_pr(unsigned long cmd) 379 { 380 switch (cmd) { 381 case H_ENTER: 382 case H_REMOVE: 383 case H_PROTECT: 384 case H_BULK_REMOVE: 385 case H_PUT_TCE: 386 case H_CEDE: 387 case H_LOGICAL_CI_LOAD: 388 case H_LOGICAL_CI_STORE: 389 #ifdef CONFIG_KVM_XICS 390 case H_XIRR: 391 case H_CPPR: 392 case H_EOI: 393 case H_IPI: 394 case H_IPOLL: 395 case H_XIRR_X: 396 #endif 397 return 1; 398 } 399 return 0; 400 } 401 402 /* 403 * List of hcall numbers to enable by default. 404 * For compatibility with old userspace, we enable by default 405 * all hcalls that were implemented before the hcall-enabling 406 * facility was added. Note this list should not include H_RTAS. 407 */ 408 static unsigned int default_hcall_list[] = { 409 H_ENTER, 410 H_REMOVE, 411 H_PROTECT, 412 H_BULK_REMOVE, 413 H_PUT_TCE, 414 H_CEDE, 415 #ifdef CONFIG_KVM_XICS 416 H_XIRR, 417 H_CPPR, 418 H_EOI, 419 H_IPI, 420 H_IPOLL, 421 H_XIRR_X, 422 #endif 423 0 424 }; 425 426 void kvmppc_pr_init_default_hcalls(struct kvm *kvm) 427 { 428 int i; 429 unsigned int hcall; 430 431 for (i = 0; default_hcall_list[i]; ++i) { 432 hcall = default_hcall_list[i]; 433 WARN_ON(!kvmppc_hcall_impl_pr(hcall)); 434 __set_bit(hcall / 4, kvm->arch.enabled_hcalls); 435 } 436 } 437