arch/powerpc/kvm/book3s_pr_papr.c

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