target/i386/sev.c

   1 /*
   2  * QEMU SEV support
   3  *
   4  * Copyright Advanced Micro Devices 2016-2018
   5  *
   6  * Author:
   7  *      Brijesh Singh <brijesh.singh@amd.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  *
  12  */
  13
  14 #include "qemu/osdep.h"
  15
  16 #include <linux/kvm.h>
  17 #include <linux/psp-sev.h>
  18
  19 #include <sys/ioctl.h>
  20
  21 #include "qapi/error.h"
  22 #include "qom/object_interfaces.h"
  23 #include "qemu/base64.h"
  24 #include "qemu/module.h"
  25 #include "qemu/uuid.h"
  26 #include "sysemu/kvm.h"
  27 #include "sev_i386.h"
  28 #include "sysemu/sysemu.h"
  29 #include "sysemu/runstate.h"
  30 #include "trace.h"
  31 #include "migration/blocker.h"
  32 #include "qom/object.h"
  33 #include "exec/address-spaces.h"
  34 #include "monitor/monitor.h"
  35 #include "exec/confidential-guest-support.h"
  36 #include "hw/i386/pc.h"
  37
  38 #define TYPE_SEV_GUEST "sev-guest"
  39 OBJECT_DECLARE_SIMPLE_TYPE(SevGuestState, SEV_GUEST)
  40
  41
  42 /**
  43  * SevGuestState:
  44  *
  45  * The SevGuestState object is used for creating and managing a SEV
  46  * guest.
  47  *
  48  * # $QEMU \
  49  *         -object sev-guest,id=sev0 \
  50  *         -machine ...,memory-encryption=sev0
  51  */
  52 struct SevGuestState {
  53     ConfidentialGuestSupport parent_obj;
  54
  55     /* configuration parameters */
  56     char *sev_device;
  57     uint32_t policy;
  58     char *dh_cert_file;
  59     char *session_file;
  60     uint32_t cbitpos;
  61     uint32_t reduced_phys_bits;
  62
  63     /* runtime state */
  64     uint32_t handle;
  65     uint8_t api_major;
  66     uint8_t api_minor;
  67     uint8_t build_id;
  68     uint64_t me_mask;
  69     int sev_fd;
  70     SevState state;
  71     gchar *measurement;
  72
  73     uint32_t reset_cs;
  74     uint32_t reset_ip;
  75     bool reset_data_valid;
  76 };
  77
  78 #define DEFAULT_GUEST_POLICY    0x1 /* disable debug */
  79 #define DEFAULT_SEV_DEVICE      "/dev/sev"
  80
  81 #define SEV_INFO_BLOCK_GUID     "00f771de-1a7e-4fcb-890e-68c77e2fb44e"
  82 typedef struct __attribute__((__packed__)) SevInfoBlock {
  83     /* SEV-ES Reset Vector Address */
  84     uint32_t reset_addr;
  85 } SevInfoBlock;
  86
  87 static SevGuestState *sev_guest;
  88 static Error *sev_mig_blocker;
  89
  90 static const char *const sev_fw_errlist[] = {
  91     "",
  92     "Platform state is invalid",
  93     "Guest state is invalid",
  94     "Platform configuration is invalid",
  95     "Buffer too small",
  96     "Platform is already owned",
  97     "Certificate is invalid",
  98     "Policy is not allowed",
  99     "Guest is not active",
 100     "Invalid address",
 101     "Bad signature",
 102     "Bad measurement",
 103     "Asid is already owned",
 104     "Invalid ASID",
 105     "WBINVD is required",
 106     "DF_FLUSH is required",
 107     "Guest handle is invalid",
 108     "Invalid command",
 109     "Guest is active",
 110     "Hardware error",
 111     "Hardware unsafe",
 112     "Feature not supported",
 113     "Invalid parameter"
 114 };
 115
 116 #define SEV_FW_MAX_ERROR      ARRAY_SIZE(sev_fw_errlist)
 117
 118 static int
 119 sev_ioctl(int fd, int cmd, void *data, int *error)
 120 {
 121     int r;
 122     struct kvm_sev_cmd input;
 123
 124     memset(&input, 0x0, sizeof(input));
 125
 126     input.id = cmd;
 127     input.sev_fd = fd;
 128     input.data = (__u64)(unsigned long)data;
 129
 130     r = kvm_vm_ioctl(kvm_state, KVM_MEMORY_ENCRYPT_OP, &input);
 131
 132     if (error) {
 133         *error = input.error;
 134     }
 135
 136     return r;
 137 }
 138
 139 static int
 140 sev_platform_ioctl(int fd, int cmd, void *data, int *error)
 141 {
 142     int r;
 143     struct sev_issue_cmd arg;
 144
 145     arg.cmd = cmd;
 146     arg.data = (unsigned long)data;
 147     r = ioctl(fd, SEV_ISSUE_CMD, &arg);
 148     if (error) {
 149         *error = arg.error;
 150     }
 151
 152     return r;
 153 }
 154
 155 static const char *
 156 fw_error_to_str(int code)
 157 {
 158     if (code < 0 || code >= SEV_FW_MAX_ERROR) {
 159         return "unknown error";
 160     }
 161
 162     return sev_fw_errlist[code];
 163 }
 164
 165 static bool
 166 sev_check_state(const SevGuestState *sev, SevState state)
 167 {
 168     assert(sev);
 169     return sev->state == state ? true : false;
 170 }
 171
 172 static void
 173 sev_set_guest_state(SevGuestState *sev, SevState new_state)
 174 {
 175     assert(new_state < SEV_STATE__MAX);
 176     assert(sev);
 177
 178     trace_kvm_sev_change_state(SevState_str(sev->state),
 179                                SevState_str(new_state));
 180     sev->state = new_state;
 181 }
 182
 183 static void
 184 sev_ram_block_added(RAMBlockNotifier *n, void *host, size_t size)
 185 {
 186     int r;
 187     struct kvm_enc_region range;
 188     ram_addr_t offset;
 189     MemoryRegion *mr;
 190
 191     /*
 192      * The RAM device presents a memory region that should be treated
 193      * as IO region and should not be pinned.
 194      */
 195     mr = memory_region_from_host(host, &offset);
 196     if (mr && memory_region_is_ram_device(mr)) {
 197         return;
 198     }
 199
 200     range.addr = (__u64)(unsigned long)host;
 201     range.size = size;
 202
 203     trace_kvm_memcrypt_register_region(host, size);
 204     r = kvm_vm_ioctl(kvm_state, KVM_MEMORY_ENCRYPT_REG_REGION, &range);
 205     if (r) {
 206         error_report("%s: failed to register region (%p+%#zx) error '%s'",
 207                      __func__, host, size, strerror(errno));
 208         exit(1);
 209     }
 210 }
 211
 212 static void
 213 sev_ram_block_removed(RAMBlockNotifier *n, void *host, size_t size)
 214 {
 215     int r;
 216     struct kvm_enc_region range;
 217     ram_addr_t offset;
 218     MemoryRegion *mr;
 219
 220     /*
 221      * The RAM device presents a memory region that should be treated
 222      * as IO region and should not have been pinned.
 223      */
 224     mr = memory_region_from_host(host, &offset);
 225     if (mr && memory_region_is_ram_device(mr)) {
 226         return;
 227     }
 228
 229     range.addr = (__u64)(unsigned long)host;
 230     range.size = size;
 231
 232     trace_kvm_memcrypt_unregister_region(host, size);
 233     r = kvm_vm_ioctl(kvm_state, KVM_MEMORY_ENCRYPT_UNREG_REGION, &range);
 234     if (r) {
 235         error_report("%s: failed to unregister region (%p+%#zx)",
 236                      __func__, host, size);
 237     }
 238 }
 239
 240 static struct RAMBlockNotifier sev_ram_notifier = {
 241     .ram_block_added = sev_ram_block_added,
 242     .ram_block_removed = sev_ram_block_removed,
 243 };
 244
 245 static void
 246 sev_guest_finalize(Object *obj)
 247 {
 248 }
 249
 250 static char *
 251 sev_guest_get_session_file(Object *obj, Error **errp)
 252 {
 253     SevGuestState *s = SEV_GUEST(obj);
 254
 255     return s->session_file ? g_strdup(s->session_file) : NULL;
 256 }
 257
 258 static void
 259 sev_guest_set_session_file(Object *obj, const char *value, Error **errp)
 260 {
 261     SevGuestState *s = SEV_GUEST(obj);
 262
 263     s->session_file = g_strdup(value);
 264 }
 265
 266 static char *
 267 sev_guest_get_dh_cert_file(Object *obj, Error **errp)
 268 {
 269     SevGuestState *s = SEV_GUEST(obj);
 270
 271     return g_strdup(s->dh_cert_file);
 272 }
 273
 274 static void
 275 sev_guest_set_dh_cert_file(Object *obj, const char *value, Error **errp)
 276 {
 277     SevGuestState *s = SEV_GUEST(obj);
 278
 279     s->dh_cert_file = g_strdup(value);
 280 }
 281
 282 static char *
 283 sev_guest_get_sev_device(Object *obj, Error **errp)
 284 {
 285     SevGuestState *sev = SEV_GUEST(obj);
 286
 287     return g_strdup(sev->sev_device);
 288 }
 289
 290 static void
 291 sev_guest_set_sev_device(Object *obj, const char *value, Error **errp)
 292 {
 293     SevGuestState *sev = SEV_GUEST(obj);
 294
 295     sev->sev_device = g_strdup(value);
 296 }
 297
 298 static void
 299 sev_guest_class_init(ObjectClass *oc, void *data)
 300 {
 301     object_class_property_add_str(oc, "sev-device",
 302                                   sev_guest_get_sev_device,
 303                                   sev_guest_set_sev_device);
 304     object_class_property_set_description(oc, "sev-device",
 305             "SEV device to use");
 306     object_class_property_add_str(oc, "dh-cert-file",
 307                                   sev_guest_get_dh_cert_file,
 308                                   sev_guest_set_dh_cert_file);
 309     object_class_property_set_description(oc, "dh-cert-file",
 310             "guest owners DH certificate (encoded with base64)");
 311     object_class_property_add_str(oc, "session-file",
 312                                   sev_guest_get_session_file,
 313                                   sev_guest_set_session_file);
 314     object_class_property_set_description(oc, "session-file",
 315             "guest owners session parameters (encoded with base64)");
 316 }
 317
 318 static void
 319 sev_guest_instance_init(Object *obj)
 320 {
 321     SevGuestState *sev = SEV_GUEST(obj);
 322
 323     sev->sev_device = g_strdup(DEFAULT_SEV_DEVICE);
 324     sev->policy = DEFAULT_GUEST_POLICY;
 325     object_property_add_uint32_ptr(obj, "policy", &sev->policy,
 326                                    OBJ_PROP_FLAG_READWRITE);
 327     object_property_add_uint32_ptr(obj, "handle", &sev->handle,
 328                                    OBJ_PROP_FLAG_READWRITE);
 329     object_property_add_uint32_ptr(obj, "cbitpos", &sev->cbitpos,
 330                                    OBJ_PROP_FLAG_READWRITE);
 331     object_property_add_uint32_ptr(obj, "reduced-phys-bits",
 332                                    &sev->reduced_phys_bits,
 333                                    OBJ_PROP_FLAG_READWRITE);
 334 }
 335
 336 /* sev guest info */
 337 static const TypeInfo sev_guest_info = {
 338     .parent = TYPE_CONFIDENTIAL_GUEST_SUPPORT,
 339     .name = TYPE_SEV_GUEST,
 340     .instance_size = sizeof(SevGuestState),
 341     .instance_finalize = sev_guest_finalize,
 342     .class_init = sev_guest_class_init,
 343     .instance_init = sev_guest_instance_init,
 344     .interfaces = (InterfaceInfo[]) {
 345         { TYPE_USER_CREATABLE },
 346         { }
 347     }
 348 };
 349
 350 bool
 351 sev_enabled(void)
 352 {
 353     return !!sev_guest;
 354 }
 355
 356 bool
 357 sev_es_enabled(void)
 358 {
 359     return sev_enabled() && (sev_guest->policy & SEV_POLICY_ES);
 360 }
 361
 362 uint64_t
 363 sev_get_me_mask(void)
 364 {
 365     return sev_guest ? sev_guest->me_mask : ~0;
 366 }
 367
 368 uint32_t
 369 sev_get_cbit_position(void)
 370 {
 371     return sev_guest ? sev_guest->cbitpos : 0;
 372 }
 373
 374 uint32_t
 375 sev_get_reduced_phys_bits(void)
 376 {
 377     return sev_guest ? sev_guest->reduced_phys_bits : 0;
 378 }
 379
 380 SevInfo *
 381 sev_get_info(void)
 382 {
 383     SevInfo *info;
 384
 385     info = g_new0(SevInfo, 1);
 386     info->enabled = sev_enabled();
 387
 388     if (info->enabled) {
 389         info->api_major = sev_guest->api_major;
 390         info->api_minor = sev_guest->api_minor;
 391         info->build_id = sev_guest->build_id;
 392         info->policy = sev_guest->policy;
 393         info->state = sev_guest->state;
 394         info->handle = sev_guest->handle;
 395     }
 396
 397     return info;
 398 }
 399
 400 static int
 401 sev_get_pdh_info(int fd, guchar **pdh, size_t *pdh_len, guchar **cert_chain,
 402                  size_t *cert_chain_len, Error **errp)
 403 {
 404     guchar *pdh_data = NULL;
 405     guchar *cert_chain_data = NULL;
 406     struct sev_user_data_pdh_cert_export export = {};
 407     int err, r;
 408
 409     /* query the certificate length */
 410     r = sev_platform_ioctl(fd, SEV_PDH_CERT_EXPORT, &export, &err);
 411     if (r < 0) {
 412         if (err != SEV_RET_INVALID_LEN) {
 413             error_setg(errp, "failed to export PDH cert ret=%d fw_err=%d (%s)",
 414                        r, err, fw_error_to_str(err));
 415             return 1;
 416         }
 417     }
 418
 419     pdh_data = g_new(guchar, export.pdh_cert_len);
 420     cert_chain_data = g_new(guchar, export.cert_chain_len);
 421     export.pdh_cert_address = (unsigned long)pdh_data;
 422     export.cert_chain_address = (unsigned long)cert_chain_data;
 423
 424     r = sev_platform_ioctl(fd, SEV_PDH_CERT_EXPORT, &export, &err);
 425     if (r < 0) {
 426         error_setg(errp, "failed to export PDH cert ret=%d fw_err=%d (%s)",
 427                    r, err, fw_error_to_str(err));
 428         goto e_free;
 429     }
 430
 431     *pdh = pdh_data;
 432     *pdh_len = export.pdh_cert_len;
 433     *cert_chain = cert_chain_data;
 434     *cert_chain_len = export.cert_chain_len;
 435     return 0;
 436
 437 e_free:
 438     g_free(pdh_data);
 439     g_free(cert_chain_data);
 440     return 1;
 441 }
 442
 443 SevCapability *
 444 sev_get_capabilities(Error **errp)
 445 {
 446     SevCapability *cap = NULL;
 447     guchar *pdh_data = NULL;
 448     guchar *cert_chain_data = NULL;
 449     size_t pdh_len = 0, cert_chain_len = 0;
 450     uint32_t ebx;
 451     int fd;
 452
 453     if (!kvm_enabled()) {
 454         error_setg(errp, "KVM not enabled");
 455         return NULL;
 456     }
 457     if (kvm_vm_ioctl(kvm_state, KVM_MEMORY_ENCRYPT_OP, NULL) < 0) {
 458         error_setg(errp, "SEV is not enabled in KVM");
 459         return NULL;
 460     }
 461
 462     fd = open(DEFAULT_SEV_DEVICE, O_RDWR);
 463     if (fd < 0) {
 464         error_setg_errno(errp, errno, "Failed to open %s",
 465                          DEFAULT_SEV_DEVICE);
 466         return NULL;
 467     }
 468
 469     if (sev_get_pdh_info(fd, &pdh_data, &pdh_len,
 470                          &cert_chain_data, &cert_chain_len, errp)) {
 471         goto out;
 472     }
 473
 474     cap = g_new0(SevCapability, 1);
 475     cap->pdh = g_base64_encode(pdh_data, pdh_len);
 476     cap->cert_chain = g_base64_encode(cert_chain_data, cert_chain_len);
 477
 478     host_cpuid(0x8000001F, 0, NULL, &ebx, NULL, NULL);
 479     cap->cbitpos = ebx & 0x3f;
 480
 481     /*
 482      * When SEV feature is enabled, we loose one bit in guest physical
 483      * addressing.
 484      */
 485     cap->reduced_phys_bits = 1;
 486
 487 out:
 488     g_free(pdh_data);
 489     g_free(cert_chain_data);
 490     close(fd);
 491     return cap;
 492 }
 493
 494 static int
 495 sev_read_file_base64(const char *filename, guchar **data, gsize *len)
 496 {
 497     gsize sz;
 498     gchar *base64;
 499     GError *error = NULL;
 500
 501     if (!g_file_get_contents(filename, &base64, &sz, &error)) {
 502         error_report("failed to read '%s' (%s)", filename, error->message);
 503         g_error_free(error);
 504         return -1;
 505     }
 506
 507     *data = g_base64_decode(base64, len);
 508     return 0;
 509 }
 510
 511 static int
 512 sev_launch_start(SevGuestState *sev)
 513 {
 514     gsize sz;
 515     int ret = 1;
 516     int fw_error, rc;
 517     struct kvm_sev_launch_start *start;
 518     guchar *session = NULL, *dh_cert = NULL;
 519
 520     start = g_new0(struct kvm_sev_launch_start, 1);
 521
 522     start->handle = sev->handle;
 523     start->policy = sev->policy;
 524     if (sev->session_file) {
 525         if (sev_read_file_base64(sev->session_file, &session, &sz) < 0) {
 526             goto out;
 527         }
 528         start->session_uaddr = (unsigned long)session;
 529         start->session_len = sz;
 530     }
 531
 532     if (sev->dh_cert_file) {
 533         if (sev_read_file_base64(sev->dh_cert_file, &dh_cert, &sz) < 0) {
 534             goto out;
 535         }
 536         start->dh_uaddr = (unsigned long)dh_cert;
 537         start->dh_len = sz;
 538     }
 539
 540     trace_kvm_sev_launch_start(start->policy, session, dh_cert);
 541     rc = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_START, start, &fw_error);
 542     if (rc < 0) {
 543         error_report("%s: LAUNCH_START ret=%d fw_error=%d '%s'",
 544                 __func__, ret, fw_error, fw_error_to_str(fw_error));
 545         goto out;
 546     }
 547
 548     sev_set_guest_state(sev, SEV_STATE_LAUNCH_UPDATE);
 549     sev->handle = start->handle;
 550     ret = 0;
 551
 552 out:
 553     g_free(start);
 554     g_free(session);
 555     g_free(dh_cert);
 556     return ret;
 557 }
 558
 559 static int
 560 sev_launch_update_data(SevGuestState *sev, uint8_t *addr, uint64_t len)
 561 {
 562     int ret, fw_error;
 563     struct kvm_sev_launch_update_data update;
 564
 565     if (!addr || !len) {
 566         return 1;
 567     }
 568
 569     update.uaddr = (__u64)(unsigned long)addr;
 570     update.len = len;
 571     trace_kvm_sev_launch_update_data(addr, len);
 572     ret = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_UPDATE_DATA,
 573                     &update, &fw_error);
 574     if (ret) {
 575         error_report("%s: LAUNCH_UPDATE ret=%d fw_error=%d '%s'",
 576                 __func__, ret, fw_error, fw_error_to_str(fw_error));
 577     }
 578
 579     return ret;
 580 }
 581
 582 static int
 583 sev_launch_update_vmsa(SevGuestState *sev)
 584 {
 585     int ret, fw_error;
 586
 587     ret = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_UPDATE_VMSA, NULL, &fw_error);
 588     if (ret) {
 589         error_report("%s: LAUNCH_UPDATE_VMSA ret=%d fw_error=%d '%s'",
 590                 __func__, ret, fw_error, fw_error_to_str(fw_error));
 591     }
 592
 593     return ret;
 594 }
 595
 596 static void
 597 sev_launch_get_measure(Notifier *notifier, void *unused)
 598 {
 599     SevGuestState *sev = sev_guest;
 600     int ret, error;
 601     guchar *data;
 602     struct kvm_sev_launch_measure *measurement;
 603
 604     if (!sev_check_state(sev, SEV_STATE_LAUNCH_UPDATE)) {
 605         return;
 606     }
 607
 608     if (sev_es_enabled()) {
 609         /* measure all the VM save areas before getting launch_measure */
 610         ret = sev_launch_update_vmsa(sev);
 611         if (ret) {
 612             exit(1);
 613         }
 614     }
 615
 616     measurement = g_new0(struct kvm_sev_launch_measure, 1);
 617
 618     /* query the measurement blob length */
 619     ret = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_MEASURE,
 620                     measurement, &error);
 621     if (!measurement->len) {
 622         error_report("%s: LAUNCH_MEASURE ret=%d fw_error=%d '%s'",
 623                      __func__, ret, error, fw_error_to_str(errno));
 624         goto free_measurement;
 625     }
 626
 627     data = g_new0(guchar, measurement->len);
 628     measurement->uaddr = (unsigned long)data;
 629
 630     /* get the measurement blob */
 631     ret = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_MEASURE,
 632                     measurement, &error);
 633     if (ret) {
 634         error_report("%s: LAUNCH_MEASURE ret=%d fw_error=%d '%s'",
 635                      __func__, ret, error, fw_error_to_str(errno));
 636         goto free_data;
 637     }
 638
 639     sev_set_guest_state(sev, SEV_STATE_LAUNCH_SECRET);
 640
 641     /* encode the measurement value and emit the event */
 642     sev->measurement = g_base64_encode(data, measurement->len);
 643     trace_kvm_sev_launch_measurement(sev->measurement);
 644
 645 free_data:
 646     g_free(data);
 647 free_measurement:
 648     g_free(measurement);
 649 }
 650
 651 char *
 652 sev_get_launch_measurement(void)
 653 {
 654     if (sev_guest &&
 655         sev_guest->state >= SEV_STATE_LAUNCH_SECRET) {
 656         return g_strdup(sev_guest->measurement);
 657     }
 658
 659     return NULL;
 660 }
 661
 662 static Notifier sev_machine_done_notify = {
 663     .notify = sev_launch_get_measure,
 664 };
 665
 666 static void
 667 sev_launch_finish(SevGuestState *sev)
 668 {
 669     int ret, error;
 670     Error *local_err = NULL;
 671
 672     trace_kvm_sev_launch_finish();
 673     ret = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_FINISH, 0, &error);
 674     if (ret) {
 675         error_report("%s: LAUNCH_FINISH ret=%d fw_error=%d '%s'",
 676                      __func__, ret, error, fw_error_to_str(error));
 677         exit(1);
 678     }
 679
 680     sev_set_guest_state(sev, SEV_STATE_RUNNING);
 681
 682     /* add migration blocker */
 683     error_setg(&sev_mig_blocker,
 684                "SEV: Migration is not implemented");
 685     ret = migrate_add_blocker(sev_mig_blocker, &local_err);
 686     if (local_err) {
 687         error_report_err(local_err);
 688         error_free(sev_mig_blocker);
 689         exit(1);
 690     }
 691 }
 692
 693 static void
 694 sev_vm_state_change(void *opaque, int running, RunState state)
 695 {
 696     SevGuestState *sev = opaque;
 697
 698     if (running) {
 699         if (!sev_check_state(sev, SEV_STATE_RUNNING)) {
 700             sev_launch_finish(sev);
 701         }
 702     }
 703 }
 704
 705 int sev_kvm_init(ConfidentialGuestSupport *cgs, Error **errp)
 706 {
 707     SevGuestState *sev
 708         = (SevGuestState *)object_dynamic_cast(OBJECT(cgs), TYPE_SEV_GUEST);
 709     char *devname;
 710     int ret, fw_error, cmd;
 711     uint32_t ebx;
 712     uint32_t host_cbitpos;
 713     struct sev_user_data_status status = {};
 714
 715     if (!sev) {
 716         return 0;
 717     }
 718
 719     ret = ram_block_discard_disable(true);
 720     if (ret) {
 721         error_report("%s: cannot disable RAM discard", __func__);
 722         return -1;
 723     }
 724
 725     sev_guest = sev;
 726     sev->state = SEV_STATE_UNINIT;
 727
 728     host_cpuid(0x8000001F, 0, NULL, &ebx, NULL, NULL);
 729     host_cbitpos = ebx & 0x3f;
 730
 731     if (host_cbitpos != sev->cbitpos) {
 732         error_setg(errp, "%s: cbitpos check failed, host '%d' requested '%d'",
 733                    __func__, host_cbitpos, sev->cbitpos);
 734         goto err;
 735     }
 736
 737     if (sev->reduced_phys_bits < 1) {
 738         error_setg(errp, "%s: reduced_phys_bits check failed, it should be >=1,"
 739                    " requested '%d'", __func__, sev->reduced_phys_bits);
 740         goto err;
 741     }
 742
 743     sev->me_mask = ~(1UL << sev->cbitpos);
 744
 745     devname = object_property_get_str(OBJECT(sev), "sev-device", NULL);
 746     sev->sev_fd = open(devname, O_RDWR);
 747     if (sev->sev_fd < 0) {
 748         error_setg(errp, "%s: Failed to open %s '%s'", __func__,
 749                    devname, strerror(errno));
 750         g_free(devname);
 751         goto err;
 752     }
 753     g_free(devname);
 754
 755     ret = sev_platform_ioctl(sev->sev_fd, SEV_PLATFORM_STATUS, &status,
 756                              &fw_error);
 757     if (ret) {
 758         error_setg(errp, "%s: failed to get platform status ret=%d "
 759                    "fw_error='%d: %s'", __func__, ret, fw_error,
 760                    fw_error_to_str(fw_error));
 761         goto err;
 762     }
 763     sev->build_id = status.build;
 764     sev->api_major = status.api_major;
 765     sev->api_minor = status.api_minor;
 766
 767     if (sev_es_enabled()) {
 768         if (!kvm_kernel_irqchip_allowed()) {
 769             error_report("%s: SEV-ES guests require in-kernel irqchip support",
 770                          __func__);
 771             goto err;
 772         }
 773
 774         if (!(status.flags & SEV_STATUS_FLAGS_CONFIG_ES)) {
 775             error_report("%s: guest policy requires SEV-ES, but "
 776                          "host SEV-ES support unavailable",
 777                          __func__);
 778             goto err;
 779         }
 780         cmd = KVM_SEV_ES_INIT;
 781     } else {
 782         cmd = KVM_SEV_INIT;
 783     }
 784
 785     trace_kvm_sev_init();
 786     ret = sev_ioctl(sev->sev_fd, cmd, NULL, &fw_error);
 787     if (ret) {
 788         error_setg(errp, "%s: failed to initialize ret=%d fw_error=%d '%s'",
 789                    __func__, ret, fw_error, fw_error_to_str(fw_error));
 790         goto err;
 791     }
 792
 793     ret = sev_launch_start(sev);
 794     if (ret) {
 795         error_setg(errp, "%s: failed to create encryption context", __func__);
 796         goto err;
 797     }
 798
 799     ram_block_notifier_add(&sev_ram_notifier);
 800     qemu_add_machine_init_done_notifier(&sev_machine_done_notify);
 801     qemu_add_vm_change_state_handler(sev_vm_state_change, sev);
 802
 803     cgs->ready = true;
 804
 805     return 0;
 806 err:
 807     sev_guest = NULL;
 808     ram_block_discard_disable(false);
 809     return -1;
 810 }
 811
 812 int
 813 sev_encrypt_flash(uint8_t *ptr, uint64_t len, Error **errp)
 814 {
 815     if (!sev_guest) {
 816         return 0;
 817     }
 818
 819     /* if SEV is in update state then encrypt the data else do nothing */
 820     if (sev_check_state(sev_guest, SEV_STATE_LAUNCH_UPDATE)) {
 821         int ret = sev_launch_update_data(sev_guest, ptr, len);
 822         if (ret < 0) {
 823             error_setg(errp, "failed to encrypt pflash rom");
 824             return ret;
 825         }
 826     }
 827
 828     return 0;
 829 }
 830
 831 int sev_inject_launch_secret(const char *packet_hdr, const char *secret,
 832                              uint64_t gpa, Error **errp)
 833 {
 834     struct kvm_sev_launch_secret input;
 835     g_autofree guchar *data = NULL, *hdr = NULL;
 836     int error, ret = 1;
 837     void *hva;
 838     gsize hdr_sz = 0, data_sz = 0;
 839     MemoryRegion *mr = NULL;
 840
 841     if (!sev_guest) {
 842         error_setg(errp, "SEV: SEV not enabled.");
 843         return 1;
 844     }
 845
 846     /* secret can be injected only in this state */
 847     if (!sev_check_state(sev_guest, SEV_STATE_LAUNCH_SECRET)) {
 848         error_setg(errp, "SEV: Not in correct state. (LSECRET) %x",
 849                      sev_guest->state);
 850         return 1;
 851     }
 852
 853     hdr = g_base64_decode(packet_hdr, &hdr_sz);
 854     if (!hdr || !hdr_sz) {
 855         error_setg(errp, "SEV: Failed to decode sequence header");
 856         return 1;
 857     }
 858
 859     data = g_base64_decode(secret, &data_sz);
 860     if (!data || !data_sz) {
 861         error_setg(errp, "SEV: Failed to decode data");
 862         return 1;
 863     }
 864
 865     hva = gpa2hva(&mr, gpa, data_sz, errp);
 866     if (!hva) {
 867         error_prepend(errp, "SEV: Failed to calculate guest address: ");
 868         return 1;
 869     }
 870
 871     input.hdr_uaddr = (uint64_t)(unsigned long)hdr;
 872     input.hdr_len = hdr_sz;
 873
 874     input.trans_uaddr = (uint64_t)(unsigned long)data;
 875     input.trans_len = data_sz;
 876
 877     input.guest_uaddr = (uint64_t)(unsigned long)hva;
 878     input.guest_len = data_sz;
 879
 880     trace_kvm_sev_launch_secret(gpa, input.guest_uaddr,
 881                                 input.trans_uaddr, input.trans_len);
 882
 883     ret = sev_ioctl(sev_guest->sev_fd, KVM_SEV_LAUNCH_SECRET,
 884                     &input, &error);
 885     if (ret) {
 886         error_setg(errp, "SEV: failed to inject secret ret=%d fw_error=%d '%s'",
 887                      ret, error, fw_error_to_str(error));
 888         return ret;
 889     }
 890
 891     return 0;
 892 }
 893
 894 static int
 895 sev_es_parse_reset_block(SevInfoBlock *info, uint32_t *addr)
 896 {
 897     if (!info->reset_addr) {
 898         error_report("SEV-ES reset address is zero");
 899         return 1;
 900     }
 901
 902     *addr = info->reset_addr;
 903
 904     return 0;
 905 }
 906
 907 static int
 908 sev_es_find_reset_vector(void *flash_ptr, uint64_t flash_size,
 909                          uint32_t *addr)
 910 {
 911     QemuUUID info_guid, *guid;
 912     SevInfoBlock *info;
 913     uint8_t *data;
 914     uint16_t *len;
 915
 916     /*
 917      * Initialize the address to zero. An address of zero with a successful
 918      * return code indicates that SEV-ES is not active.
 919      */
 920     *addr = 0;
 921
 922     /*
 923      * Extract the AP reset vector for SEV-ES guests by locating the SEV GUID.
 924      * The SEV GUID is located on its own (original implementation) or within
 925      * the Firmware GUID Table (new implementation), either of which are
 926      * located 32 bytes from the end of the flash.
 927      *
 928      * Check the Firmware GUID Table first.
 929      */
 930     if (pc_system_ovmf_table_find(SEV_INFO_BLOCK_GUID, &data, NULL)) {
 931         return sev_es_parse_reset_block((SevInfoBlock *)data, addr);
 932     }
 933
 934     /*
 935      * SEV info block not found in the Firmware GUID Table (or there isn't
 936      * a Firmware GUID Table), fall back to the original implementation.
 937      */
 938     data = flash_ptr + flash_size - 0x20;
 939
 940     qemu_uuid_parse(SEV_INFO_BLOCK_GUID, &info_guid);
 941     info_guid = qemu_uuid_bswap(info_guid); /* GUIDs are LE */
 942
 943     guid = (QemuUUID *)(data - sizeof(info_guid));
 944     if (!qemu_uuid_is_equal(guid, &info_guid)) {
 945         error_report("SEV information block/Firmware GUID Table block not found in pflash rom");
 946         return 1;
 947     }
 948
 949     len = (uint16_t *)((uint8_t *)guid - sizeof(*len));
 950     info = (SevInfoBlock *)(data - le16_to_cpu(*len));
 951
 952     return sev_es_parse_reset_block(info, addr);
 953 }
 954
 955 void sev_es_set_reset_vector(CPUState *cpu)
 956 {
 957     X86CPU *x86;
 958     CPUX86State *env;
 959
 960     /* Only update if we have valid reset information */
 961     if (!sev_guest || !sev_guest->reset_data_valid) {
 962         return;
 963     }
 964
 965     /* Do not update the BSP reset state */
 966     if (cpu->cpu_index == 0) {
 967         return;
 968     }
 969
 970     x86 = X86_CPU(cpu);
 971     env = &x86->env;
 972
 973     cpu_x86_load_seg_cache(env, R_CS, 0xf000, sev_guest->reset_cs, 0xffff,
 974                            DESC_P_MASK | DESC_S_MASK | DESC_CS_MASK |
 975                            DESC_R_MASK | DESC_A_MASK);
 976
 977     env->eip = sev_guest->reset_ip;
 978 }
 979
 980 int sev_es_save_reset_vector(void *flash_ptr, uint64_t flash_size)
 981 {
 982     CPUState *cpu;
 983     uint32_t addr;
 984     int ret;
 985
 986     if (!sev_es_enabled()) {
 987         return 0;
 988     }
 989
 990     addr = 0;
 991     ret = sev_es_find_reset_vector(flash_ptr, flash_size,
 992                                    &addr);
 993     if (ret) {
 994         return ret;
 995     }
 996
 997     if (addr) {
 998         sev_guest->reset_cs = addr & 0xffff0000;
 999         sev_guest->reset_ip = addr & 0x0000ffff;
1000         sev_guest->reset_data_valid = true;
1001
1002         CPU_FOREACH(cpu) {
1003             sev_es_set_reset_vector(cpu);
1004         }
1005     }
1006
1007     return 0;
1008 }
1009
1010 static void
1011 sev_register_types(void)
1012 {
1013     type_register_static(&sev_guest_info);
1014 }
1015
1016 type_init(sev_register_types);