arch/powerpc/kvm/book3s_pr_papr.c

   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 <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         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                 kvm_clear_request(KVM_REQ_UNHALT, vcpu);
 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 }