hw/ppc/pef.c

   1 /*
   2  * PEF (Protected Execution Facility) for POWER support
   3  *
   4  * Copyright Red Hat.
   5  *
   6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   7  * See the COPYING file in the top-level directory.
   8  *
   9  */
  10
  11 #include "qemu/osdep.h"
  12
  13 #include "qapi/error.h"
  14 #include "qom/object_interfaces.h"
  15 #include "sysemu/kvm.h"
  16 #include "migration/blocker.h"
  17 #include "exec/confidential-guest-support.h"
  18 #include "hw/ppc/pef.h"
  19
  20 #define TYPE_PEF_GUEST "pef-guest"
  21 OBJECT_DECLARE_SIMPLE_TYPE(PefGuest, PEF_GUEST)
  22
  23 typedef struct PefGuest PefGuest;
  24 typedef struct PefGuestClass PefGuestClass;
  25
  26 struct PefGuestClass {
  27     ConfidentialGuestSupportClass parent_class;
  28 };
  29
  30 /**
  31  * PefGuest:
  32  *
  33  * The PefGuest object is used for creating and managing a PEF
  34  * guest.
  35  *
  36  * # $QEMU \
  37  *         -object pef-guest,id=pef0 \
  38  *         -machine ...,confidential-guest-support=pef0
  39  */
  40 struct PefGuest {
  41     ConfidentialGuestSupport parent_obj;
  42 };
  43
  44 static int kvmppc_svm_init(ConfidentialGuestSupport *cgs, Error **errp)
  45 {
  46 #ifdef CONFIG_KVM
  47     static Error *pef_mig_blocker;
  48
  49     if (!kvm_check_extension(kvm_state, KVM_CAP_PPC_SECURE_GUEST)) {
  50         error_setg(errp,
  51                    "KVM implementation does not support Secure VMs (is an ultravisor running?)");
  52         return -1;
  53     } else {
  54         int ret = kvm_vm_enable_cap(kvm_state, KVM_CAP_PPC_SECURE_GUEST, 0, 1);
  55
  56         if (ret < 0) {
  57             error_setg(errp,
  58                        "Error enabling PEF with KVM");
  59             return -1;
  60         }
  61     }
  62
  63     /* add migration blocker */
  64     error_setg(&pef_mig_blocker, "PEF: Migration is not implemented");
  65     /* NB: This can fail if --only-migratable is used */
  66     migrate_add_blocker(pef_mig_blocker, &error_fatal);
  67
  68     cgs->ready = true;
  69
  70     return 0;
  71 #else
  72     g_assert_not_reached();
  73 #endif
  74 }
  75
  76 /*
  77  * Don't set error if KVM_PPC_SVM_OFF ioctl is invoked on kernels
  78  * that don't support this ioctl.
  79  */
  80 static int kvmppc_svm_off(Error **errp)
  81 {
  82 #ifdef CONFIG_KVM
  83     int rc;
  84
  85     rc = kvm_vm_ioctl(KVM_STATE(current_accel()), KVM_PPC_SVM_OFF);
  86     if (rc && rc != -ENOTTY) {
  87         error_setg_errno(errp, -rc, "KVM_PPC_SVM_OFF ioctl failed");
  88         return rc;
  89     }
  90     return 0;
  91 #else
  92     g_assert_not_reached();
  93 #endif
  94 }
  95
  96 int pef_kvm_init(ConfidentialGuestSupport *cgs, Error **errp)
  97 {
  98     if (!object_dynamic_cast(OBJECT(cgs), TYPE_PEF_GUEST)) {
  99         return 0;
 100     }
 101
 102     if (!kvm_enabled()) {
 103         error_setg(errp, "PEF requires KVM");
 104         return -1;
 105     }
 106
 107     return kvmppc_svm_init(cgs, errp);
 108 }
 109
 110 int pef_kvm_reset(ConfidentialGuestSupport *cgs, Error **errp)
 111 {
 112     if (!object_dynamic_cast(OBJECT(cgs), TYPE_PEF_GUEST)) {
 113         return 0;
 114     }
 115
 116     /*
 117      * If we don't have KVM we should never have been able to
 118      * initialize PEF, so we should never get this far
 119      */
 120     assert(kvm_enabled());
 121
 122     return kvmppc_svm_off(errp);
 123 }
 124
 125 OBJECT_DEFINE_TYPE_WITH_INTERFACES(PefGuest,
 126                                    pef_guest,
 127                                    PEF_GUEST,
 128                                    CONFIDENTIAL_GUEST_SUPPORT,
 129                                    { TYPE_USER_CREATABLE },
 130                                    { NULL })
 131
 132 static void pef_guest_class_init(ObjectClass *oc, void *data)
 133 {
 134 }
 135
 136 static void pef_guest_init(Object *obj)
 137 {
 138 }
 139
 140 static void pef_guest_finalize(Object *obj)
 141 {
 142 }