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 <asm/uaccess.h>
  21 #include <asm/kvm_ppc.h>
  22 #include <asm/kvm_book3s.h>
  23
  24 static unsigned long get_pteg_addr(struct kvm_vcpu *vcpu, long pte_index)
  25 {
  26         struct kvmppc_vcpu_book3s *vcpu_book3s = to_book3s(vcpu);
  27         unsigned long pteg_addr;
  28
  29         pte_index <<= 4;
  30         pte_index &= ((1 << ((vcpu_book3s->sdr1 & 0x1f) + 11)) - 1) << 7 | 0x70;
  31         pteg_addr = vcpu_book3s->sdr1 & 0xfffffffffffc0000ULL;
  32         pteg_addr |= pte_index;
  33
  34         return pteg_addr;
  35 }
  36
  37 static int kvmppc_h_pr_enter(struct kvm_vcpu *vcpu)
  38 {
  39         long flags = kvmppc_get_gpr(vcpu, 4);
  40         long pte_index = kvmppc_get_gpr(vcpu, 5);
  41         unsigned long pteg[2 * 8];
  42         unsigned long pteg_addr, i, *hpte;
  43
  44         pte_index &= ~7UL;
  45         pteg_addr = get_pteg_addr(vcpu, pte_index);
  46
  47         copy_from_user(pteg, (void __user *)pteg_addr, sizeof(pteg));
  48         hpte = pteg;
  49
  50         if (likely((flags & H_EXACT) == 0)) {
  51                 pte_index &= ~7UL;
  52                 for (i = 0; ; ++i) {
  53                         if (i == 8)
  54                                 return H_PTEG_FULL;
  55                         if ((*hpte & HPTE_V_VALID) == 0)
  56                                 break;
  57                         hpte += 2;
  58                 }
  59         } else {
  60                 i = kvmppc_get_gpr(vcpu, 5) & 7UL;
  61                 hpte += i * 2;
  62         }
  63
  64         hpte[0] = kvmppc_get_gpr(vcpu, 6);
  65         hpte[1] = kvmppc_get_gpr(vcpu, 7);
  66         copy_to_user((void __user *)pteg_addr, pteg, sizeof(pteg));
  67         kvmppc_set_gpr(vcpu, 3, H_SUCCESS);
  68         kvmppc_set_gpr(vcpu, 4, pte_index | i);
  69
  70         return EMULATE_DONE;
  71 }
  72
  73 static int kvmppc_h_pr_remove(struct kvm_vcpu *vcpu)
  74 {
  75         unsigned long flags= kvmppc_get_gpr(vcpu, 4);
  76         unsigned long pte_index = kvmppc_get_gpr(vcpu, 5);
  77         unsigned long avpn = kvmppc_get_gpr(vcpu, 6);
  78         unsigned long v = 0, pteg, rb;
  79         unsigned long pte[2];
  80
  81         pteg = get_pteg_addr(vcpu, pte_index);
  82         copy_from_user(pte, (void __user *)pteg, sizeof(pte));
  83
  84         if ((pte[0] & HPTE_V_VALID) == 0 ||
  85             ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn) ||
  86             ((flags & H_ANDCOND) && (pte[0] & avpn) != 0)) {
  87                 kvmppc_set_gpr(vcpu, 3, H_NOT_FOUND);
  88                 return EMULATE_DONE;
  89         }
  90
  91         copy_to_user((void __user *)pteg, &v, sizeof(v));
  92
  93         rb = compute_tlbie_rb(pte[0], pte[1], pte_index);
  94         vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
  95
  96         kvmppc_set_gpr(vcpu, 3, H_SUCCESS);
  97         kvmppc_set_gpr(vcpu, 4, pte[0]);
  98         kvmppc_set_gpr(vcpu, 5, pte[1]);
  99
 100         return EMULATE_DONE;
 101 }
 102
 103 /* Request defs for kvmppc_h_pr_bulk_remove() */
 104 #define H_BULK_REMOVE_TYPE             0xc000000000000000ULL
 105 #define   H_BULK_REMOVE_REQUEST        0x4000000000000000ULL
 106 #define   H_BULK_REMOVE_RESPONSE       0x8000000000000000ULL
 107 #define   H_BULK_REMOVE_END            0xc000000000000000ULL
 108 #define H_BULK_REMOVE_CODE             0x3000000000000000ULL
 109 #define   H_BULK_REMOVE_SUCCESS        0x0000000000000000ULL
 110 #define   H_BULK_REMOVE_NOT_FOUND      0x1000000000000000ULL
 111 #define   H_BULK_REMOVE_PARM           0x2000000000000000ULL
 112 #define   H_BULK_REMOVE_HW             0x3000000000000000ULL
 113 #define H_BULK_REMOVE_RC               0x0c00000000000000ULL
 114 #define H_BULK_REMOVE_FLAGS            0x0300000000000000ULL
 115 #define   H_BULK_REMOVE_ABSOLUTE       0x0000000000000000ULL
 116 #define   H_BULK_REMOVE_ANDCOND        0x0100000000000000ULL
 117 #define   H_BULK_REMOVE_AVPN           0x0200000000000000ULL
 118 #define H_BULK_REMOVE_PTEX             0x00ffffffffffffffULL
 119 #define H_BULK_REMOVE_MAX_BATCH        4
 120
 121 static int kvmppc_h_pr_bulk_remove(struct kvm_vcpu *vcpu)
 122 {
 123         int i;
 124         int paramnr = 4;
 125         int ret = H_SUCCESS;
 126
 127         for (i = 0; i < H_BULK_REMOVE_MAX_BATCH; i++) {
 128                 unsigned long tsh = kvmppc_get_gpr(vcpu, paramnr+(2*i));
 129                 unsigned long tsl = kvmppc_get_gpr(vcpu, paramnr+(2*i)+1);
 130                 unsigned long pteg, rb, flags;
 131                 unsigned long pte[2];
 132                 unsigned long v = 0;
 133
 134                 if ((tsh & H_BULK_REMOVE_TYPE) == H_BULK_REMOVE_END) {
 135                         break; /* Exit success */
 136                 } else if ((tsh & H_BULK_REMOVE_TYPE) !=
 137                            H_BULK_REMOVE_REQUEST) {
 138                         ret = H_PARAMETER;
 139                         break; /* Exit fail */
 140                 }
 141
 142                 tsh &= H_BULK_REMOVE_PTEX | H_BULK_REMOVE_FLAGS;
 143                 tsh |= H_BULK_REMOVE_RESPONSE;
 144
 145                 if ((tsh & H_BULK_REMOVE_ANDCOND) &&
 146                     (tsh & H_BULK_REMOVE_AVPN)) {
 147                         tsh |= H_BULK_REMOVE_PARM;
 148                         kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh);
 149                         ret = H_PARAMETER;
 150                         break; /* Exit fail */
 151                 }
 152
 153                 pteg = get_pteg_addr(vcpu, tsh & H_BULK_REMOVE_PTEX);
 154                 copy_from_user(pte, (void __user *)pteg, sizeof(pte));
 155
 156                 /* tsl = AVPN */
 157                 flags = (tsh & H_BULK_REMOVE_FLAGS) >> 26;
 158
 159                 if ((pte[0] & HPTE_V_VALID) == 0 ||
 160                     ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != tsl) ||
 161                     ((flags & H_ANDCOND) && (pte[0] & tsl) != 0)) {
 162                         tsh |= H_BULK_REMOVE_NOT_FOUND;
 163                 } else {
 164                         /* Splat the pteg in (userland) hpt */
 165                         copy_to_user((void __user *)pteg, &v, sizeof(v));
 166
 167                         rb = compute_tlbie_rb(pte[0], pte[1],
 168                                               tsh & H_BULK_REMOVE_PTEX);
 169                         vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
 170                         tsh |= H_BULK_REMOVE_SUCCESS;
 171                         tsh |= (pte[1] & (HPTE_R_C | HPTE_R_R)) << 43;
 172                 }
 173                 kvmppc_set_gpr(vcpu, paramnr+(2*i), tsh);
 174         }
 175         kvmppc_set_gpr(vcpu, 3, ret);
 176
 177         return EMULATE_DONE;
 178 }
 179
 180 static int kvmppc_h_pr_protect(struct kvm_vcpu *vcpu)
 181 {
 182         unsigned long flags = kvmppc_get_gpr(vcpu, 4);
 183         unsigned long pte_index = kvmppc_get_gpr(vcpu, 5);
 184         unsigned long avpn = kvmppc_get_gpr(vcpu, 6);
 185         unsigned long rb, pteg, r, v;
 186         unsigned long pte[2];
 187
 188         pteg = get_pteg_addr(vcpu, pte_index);
 189         copy_from_user(pte, (void __user *)pteg, sizeof(pte));
 190
 191         if ((pte[0] & HPTE_V_VALID) == 0 ||
 192             ((flags & H_AVPN) && (pte[0] & ~0x7fUL) != avpn)) {
 193                 kvmppc_set_gpr(vcpu, 3, H_NOT_FOUND);
 194                 return EMULATE_DONE;
 195         }
 196
 197         v = pte[0];
 198         r = pte[1];
 199         r &= ~(HPTE_R_PP0 | HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_HI |
 200                HPTE_R_KEY_LO);
 201         r |= (flags << 55) & HPTE_R_PP0;
 202         r |= (flags << 48) & HPTE_R_KEY_HI;
 203         r |= flags & (HPTE_R_PP | HPTE_R_N | HPTE_R_KEY_LO);
 204
 205         pte[1] = r;
 206
 207         rb = compute_tlbie_rb(v, r, pte_index);
 208         vcpu->arch.mmu.tlbie(vcpu, rb, rb & 1 ? true : false);
 209         copy_to_user((void __user *)pteg, pte, sizeof(pte));
 210
 211         kvmppc_set_gpr(vcpu, 3, H_SUCCESS);
 212
 213         return EMULATE_DONE;
 214 }
 215
 216 static int kvmppc_h_pr_put_tce(struct kvm_vcpu *vcpu)
 217 {
 218         unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
 219         unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
 220         unsigned long tce = kvmppc_get_gpr(vcpu, 6);
 221         long rc;
 222
 223         rc = kvmppc_h_put_tce(vcpu, liobn, ioba, tce);
 224         if (rc == H_TOO_HARD)
 225                 return EMULATE_FAIL;
 226         kvmppc_set_gpr(vcpu, 3, rc);
 227         return EMULATE_DONE;
 228 }
 229
 230 int kvmppc_h_pr(struct kvm_vcpu *vcpu, unsigned long cmd)
 231 {
 232         switch (cmd) {
 233         case H_ENTER:
 234                 return kvmppc_h_pr_enter(vcpu);
 235         case H_REMOVE:
 236                 return kvmppc_h_pr_remove(vcpu);
 237         case H_PROTECT:
 238                 return kvmppc_h_pr_protect(vcpu);
 239         case H_BULK_REMOVE:
 240                 return kvmppc_h_pr_bulk_remove(vcpu);
 241         case H_PUT_TCE:
 242                 return kvmppc_h_pr_put_tce(vcpu);
 243         case H_CEDE:
 244                 vcpu->arch.shared->msr |= MSR_EE;
 245                 kvm_vcpu_block(vcpu);
 246                 clear_bit(KVM_REQ_UNHALT, &vcpu->requests);
 247                 vcpu->stat.halt_wakeup++;
 248                 return EMULATE_DONE;
 249         }
 250
 251         return EMULATE_FAIL;
 252 }