arch/s390/kvm/pv.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Hosting Protected Virtual Machines
   4  *
   5  * Copyright IBM Corp. 2019, 2020
   6  *    Author(s): Janosch Frank <frankja@linux.ibm.com>
   7  */
   8 #include <linux/kvm.h>
   9 #include <linux/kvm_host.h>
  10 #include <linux/pagemap.h>
  11 #include <linux/sched/signal.h>
  12 #include <asm/gmap.h>
  13 #include <asm/uv.h>
  14 #include <asm/mman.h>
  15 #include "kvm-s390.h"
  16
  17 int kvm_s390_pv_destroy_cpu(struct kvm_vcpu *vcpu, u16 *rc, u16 *rrc)
  18 {
  19         int cc = 0;
  20
  21         if (kvm_s390_pv_cpu_get_handle(vcpu)) {
  22                 cc = uv_cmd_nodata(kvm_s390_pv_cpu_get_handle(vcpu),
  23                                    UVC_CMD_DESTROY_SEC_CPU, rc, rrc);
  24
  25                 KVM_UV_EVENT(vcpu->kvm, 3,
  26                              "PROTVIRT DESTROY VCPU %d: rc %x rrc %x",
  27                              vcpu->vcpu_id, *rc, *rrc);
  28                 WARN_ONCE(cc, "protvirt destroy cpu failed rc %x rrc %x",
  29                           *rc, *rrc);
  30         }
  31         /* Intended memory leak for something that should never happen. */
  32         if (!cc)
  33                 free_pages(vcpu->arch.pv.stor_base,
  34                            get_order(uv_info.guest_cpu_stor_len));
  35
  36         free_page(sida_origin(vcpu->arch.sie_block));
  37         vcpu->arch.sie_block->pv_handle_cpu = 0;
  38         vcpu->arch.sie_block->pv_handle_config = 0;
  39         memset(&vcpu->arch.pv, 0, sizeof(vcpu->arch.pv));
  40         vcpu->arch.sie_block->sdf = 0;
  41         /*
  42          * The sidad field (for sdf == 2) is now the gbea field (for sdf == 0).
  43          * Use the reset value of gbea to avoid leaking the kernel pointer of
  44          * the just freed sida.
  45          */
  46         vcpu->arch.sie_block->gbea = 1;
  47         kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
  48
  49         return cc ? EIO : 0;
  50 }
  51
  52 int kvm_s390_pv_create_cpu(struct kvm_vcpu *vcpu, u16 *rc, u16 *rrc)
  53 {
  54         struct uv_cb_csc uvcb = {
  55                 .header.cmd = UVC_CMD_CREATE_SEC_CPU,
  56                 .header.len = sizeof(uvcb),
  57         };
  58         int cc;
  59
  60         if (kvm_s390_pv_cpu_get_handle(vcpu))
  61                 return -EINVAL;
  62
  63         vcpu->arch.pv.stor_base = __get_free_pages(GFP_KERNEL_ACCOUNT,
  64                                                    get_order(uv_info.guest_cpu_stor_len));
  65         if (!vcpu->arch.pv.stor_base)
  66                 return -ENOMEM;
  67
  68         /* Input */
  69         uvcb.guest_handle = kvm_s390_pv_get_handle(vcpu->kvm);
  70         uvcb.num = vcpu->arch.sie_block->icpua;
  71         uvcb.state_origin = (u64)vcpu->arch.sie_block;
  72         uvcb.stor_origin = (u64)vcpu->arch.pv.stor_base;
  73
  74         /* Alloc Secure Instruction Data Area Designation */
  75         vcpu->arch.sie_block->sidad = __get_free_page(GFP_KERNEL_ACCOUNT | __GFP_ZERO);
  76         if (!vcpu->arch.sie_block->sidad) {
  77                 free_pages(vcpu->arch.pv.stor_base,
  78                            get_order(uv_info.guest_cpu_stor_len));
  79                 return -ENOMEM;
  80         }
  81
  82         cc = uv_call(0, (u64)&uvcb);
  83         *rc = uvcb.header.rc;
  84         *rrc = uvcb.header.rrc;
  85         KVM_UV_EVENT(vcpu->kvm, 3,
  86                      "PROTVIRT CREATE VCPU: cpu %d handle %llx rc %x rrc %x",
  87                      vcpu->vcpu_id, uvcb.cpu_handle, uvcb.header.rc,
  88                      uvcb.header.rrc);
  89
  90         if (cc) {
  91                 u16 dummy;
  92
  93                 kvm_s390_pv_destroy_cpu(vcpu, &dummy, &dummy);
  94                 return -EIO;
  95         }
  96
  97         /* Output */
  98         vcpu->arch.pv.handle = uvcb.cpu_handle;
  99         vcpu->arch.sie_block->pv_handle_cpu = uvcb.cpu_handle;
 100         vcpu->arch.sie_block->pv_handle_config = kvm_s390_pv_get_handle(vcpu->kvm);
 101         vcpu->arch.sie_block->sdf = 2;
 102         kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
 103         return 0;
 104 }
 105
 106 /* only free resources when the destroy was successful */
 107 static void kvm_s390_pv_dealloc_vm(struct kvm *kvm)
 108 {
 109         vfree(kvm->arch.pv.stor_var);
 110         free_pages(kvm->arch.pv.stor_base,
 111                    get_order(uv_info.guest_base_stor_len));
 112         memset(&kvm->arch.pv, 0, sizeof(kvm->arch.pv));
 113 }
 114
 115 static int kvm_s390_pv_alloc_vm(struct kvm *kvm)
 116 {
 117         unsigned long base = uv_info.guest_base_stor_len;
 118         unsigned long virt = uv_info.guest_virt_var_stor_len;
 119         unsigned long npages = 0, vlen = 0;
 120         struct kvm_memory_slot *memslot;
 121
 122         kvm->arch.pv.stor_var = NULL;
 123         kvm->arch.pv.stor_base = __get_free_pages(GFP_KERNEL_ACCOUNT, get_order(base));
 124         if (!kvm->arch.pv.stor_base)
 125                 return -ENOMEM;
 126
 127         /*
 128          * Calculate current guest storage for allocation of the
 129          * variable storage, which is based on the length in MB.
 130          *
 131          * Slots are sorted by GFN
 132          */
 133         mutex_lock(&kvm->slots_lock);
 134         memslot = kvm_memslots(kvm)->memslots;
 135         npages = memslot->base_gfn + memslot->npages;
 136         mutex_unlock(&kvm->slots_lock);
 137
 138         kvm->arch.pv.guest_len = npages * PAGE_SIZE;
 139
 140         /* Allocate variable storage */
 141         vlen = ALIGN(virt * ((npages * PAGE_SIZE) / HPAGE_SIZE), PAGE_SIZE);
 142         vlen += uv_info.guest_virt_base_stor_len;
 143         kvm->arch.pv.stor_var = vzalloc(vlen);
 144         if (!kvm->arch.pv.stor_var)
 145                 goto out_err;
 146         return 0;
 147
 148 out_err:
 149         kvm_s390_pv_dealloc_vm(kvm);
 150         return -ENOMEM;
 151 }
 152
 153 /* this should not fail, but if it does, we must not free the donated memory */
 154 int kvm_s390_pv_deinit_vm(struct kvm *kvm, u16 *rc, u16 *rrc)
 155 {
 156         int cc;
 157
 158         /* make all pages accessible before destroying the guest */
 159         s390_reset_acc(kvm->mm);
 160
 161         cc = uv_cmd_nodata(kvm_s390_pv_get_handle(kvm),
 162                            UVC_CMD_DESTROY_SEC_CONF, rc, rrc);
 163         WRITE_ONCE(kvm->arch.gmap->guest_handle, 0);
 164         atomic_set(&kvm->mm->context.is_protected, 0);
 165         KVM_UV_EVENT(kvm, 3, "PROTVIRT DESTROY VM: rc %x rrc %x", *rc, *rrc);
 166         WARN_ONCE(cc, "protvirt destroy vm failed rc %x rrc %x", *rc, *rrc);
 167         /* Inteded memory leak on "impossible" error */
 168         if (!cc)
 169                 kvm_s390_pv_dealloc_vm(kvm);
 170         return cc ? -EIO : 0;
 171 }
 172
 173 int kvm_s390_pv_init_vm(struct kvm *kvm, u16 *rc, u16 *rrc)
 174 {
 175         struct uv_cb_cgc uvcb = {
 176                 .header.cmd = UVC_CMD_CREATE_SEC_CONF,
 177                 .header.len = sizeof(uvcb)
 178         };
 179         int cc, ret;
 180         u16 dummy;
 181
 182         ret = kvm_s390_pv_alloc_vm(kvm);
 183         if (ret)
 184                 return ret;
 185
 186         /* Inputs */
 187         uvcb.guest_stor_origin = 0; /* MSO is 0 for KVM */
 188         uvcb.guest_stor_len = kvm->arch.pv.guest_len;
 189         uvcb.guest_asce = kvm->arch.gmap->asce;
 190         uvcb.guest_sca = (unsigned long)kvm->arch.sca;
 191         uvcb.conf_base_stor_origin = (u64)kvm->arch.pv.stor_base;
 192         uvcb.conf_virt_stor_origin = (u64)kvm->arch.pv.stor_var;
 193
 194         cc = uv_call(0, (u64)&uvcb);
 195         *rc = uvcb.header.rc;
 196         *rrc = uvcb.header.rrc;
 197         KVM_UV_EVENT(kvm, 3, "PROTVIRT CREATE VM: handle %llx len %llx rc %x rrc %x",
 198                      uvcb.guest_handle, uvcb.guest_stor_len, *rc, *rrc);
 199
 200         /* Outputs */
 201         kvm->arch.pv.handle = uvcb.guest_handle;
 202
 203         if (cc) {
 204                 if (uvcb.header.rc & UVC_RC_NEED_DESTROY)
 205                         kvm_s390_pv_deinit_vm(kvm, &dummy, &dummy);
 206                 else
 207                         kvm_s390_pv_dealloc_vm(kvm);
 208                 return -EIO;
 209         }
 210         kvm->arch.gmap->guest_handle = uvcb.guest_handle;
 211         return 0;
 212 }
 213
 214 int kvm_s390_pv_set_sec_parms(struct kvm *kvm, void *hdr, u64 length, u16 *rc,
 215                               u16 *rrc)
 216 {
 217         struct uv_cb_ssc uvcb = {
 218                 .header.cmd = UVC_CMD_SET_SEC_CONF_PARAMS,
 219                 .header.len = sizeof(uvcb),
 220                 .sec_header_origin = (u64)hdr,
 221                 .sec_header_len = length,
 222                 .guest_handle = kvm_s390_pv_get_handle(kvm),
 223         };
 224         int cc = uv_call(0, (u64)&uvcb);
 225
 226         *rc = uvcb.header.rc;
 227         *rrc = uvcb.header.rrc;
 228         KVM_UV_EVENT(kvm, 3, "PROTVIRT VM SET PARMS: rc %x rrc %x",
 229                      *rc, *rrc);
 230         if (!cc)
 231                 atomic_set(&kvm->mm->context.is_protected, 1);
 232         return cc ? -EINVAL : 0;
 233 }
 234
 235 static int unpack_one(struct kvm *kvm, unsigned long addr, u64 tweak,
 236                       u64 offset, u16 *rc, u16 *rrc)
 237 {
 238         struct uv_cb_unp uvcb = {
 239                 .header.cmd = UVC_CMD_UNPACK_IMG,
 240                 .header.len = sizeof(uvcb),
 241                 .guest_handle = kvm_s390_pv_get_handle(kvm),
 242                 .gaddr = addr,
 243                 .tweak[0] = tweak,
 244                 .tweak[1] = offset,
 245         };
 246         int ret = gmap_make_secure(kvm->arch.gmap, addr, &uvcb);
 247
 248         *rc = uvcb.header.rc;
 249         *rrc = uvcb.header.rrc;
 250
 251         if (ret && ret != -EAGAIN)
 252                 KVM_UV_EVENT(kvm, 3, "PROTVIRT VM UNPACK: failed addr %llx with rc %x rrc %x",
 253                              uvcb.gaddr, *rc, *rrc);
 254         return ret;
 255 }
 256
 257 int kvm_s390_pv_unpack(struct kvm *kvm, unsigned long addr, unsigned long size,
 258                        unsigned long tweak, u16 *rc, u16 *rrc)
 259 {
 260         u64 offset = 0;
 261         int ret = 0;
 262
 263         if (addr & ~PAGE_MASK || !size || size & ~PAGE_MASK)
 264                 return -EINVAL;
 265
 266         KVM_UV_EVENT(kvm, 3, "PROTVIRT VM UNPACK: start addr %lx size %lx",
 267                      addr, size);
 268
 269         while (offset < size) {
 270                 ret = unpack_one(kvm, addr, tweak, offset, rc, rrc);
 271                 if (ret == -EAGAIN) {
 272                         cond_resched();
 273                         if (fatal_signal_pending(current))
 274                                 break;
 275                         continue;
 276                 }
 277                 if (ret)
 278                         break;
 279                 addr += PAGE_SIZE;
 280                 offset += PAGE_SIZE;
 281         }
 282         if (!ret)
 283                 KVM_UV_EVENT(kvm, 3, "%s", "PROTVIRT VM UNPACK: successful");
 284         return ret;
 285 }
 286
 287 int kvm_s390_pv_set_cpu_state(struct kvm_vcpu *vcpu, u8 state)
 288 {
 289         struct uv_cb_cpu_set_state uvcb = {
 290                 .header.cmd     = UVC_CMD_CPU_SET_STATE,
 291                 .header.len     = sizeof(uvcb),
 292                 .cpu_handle     = kvm_s390_pv_cpu_get_handle(vcpu),
 293                 .state          = state,
 294         };
 295         int cc;
 296
 297         cc = uv_call(0, (u64)&uvcb);
 298         KVM_UV_EVENT(vcpu->kvm, 3, "PROTVIRT SET CPU %d STATE %d rc %x rrc %x",
 299                      vcpu->vcpu_id, state, uvcb.header.rc, uvcb.header.rrc);
 300         if (cc)
 301                 return -EINVAL;
 302         return 0;
 303 }