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 "qemu/error-report.h" 27 #include "crypto/hash.h" 28 #include "sysemu/kvm.h" 29 #include "sev.h" 30 #include "sysemu/sysemu.h" 31 #include "sysemu/runstate.h" 32 #include "trace.h" 33 #include "migration/blocker.h" 34 #include "qom/object.h" 35 #include "monitor/monitor.h" 36 #include "monitor/hmp-target.h" 37 #include "qapi/qapi-commands-misc-target.h" 38 #include "exec/confidential-guest-support.h" 39 #include "hw/i386/pc.h" 40 #include "exec/address-spaces.h" 41 42 #define TYPE_SEV_GUEST "sev-guest" 43 OBJECT_DECLARE_SIMPLE_TYPE(SevGuestState, SEV_GUEST) 44 45 46 /** 47 * SevGuestState: 48 * 49 * The SevGuestState object is used for creating and managing a SEV 50 * guest. 51 * 52 * # $QEMU \ 53 * -object sev-guest,id=sev0 \ 54 * -machine ...,memory-encryption=sev0 55 */ 56 struct SevGuestState { 57 ConfidentialGuestSupport parent_obj; 58 59 /* configuration parameters */ 60 char *sev_device; 61 uint32_t policy; 62 char *dh_cert_file; 63 char *session_file; 64 uint32_t cbitpos; 65 uint32_t reduced_phys_bits; 66 bool kernel_hashes; 67 68 /* runtime state */ 69 uint32_t handle; 70 uint8_t api_major; 71 uint8_t api_minor; 72 uint8_t build_id; 73 int sev_fd; 74 SevState state; 75 gchar *measurement; 76 77 uint32_t reset_cs; 78 uint32_t reset_ip; 79 bool reset_data_valid; 80 }; 81 82 #define DEFAULT_GUEST_POLICY 0x1 /* disable debug */ 83 #define DEFAULT_SEV_DEVICE "/dev/sev" 84 85 #define SEV_INFO_BLOCK_GUID "00f771de-1a7e-4fcb-890e-68c77e2fb44e" 86 typedef struct __attribute__((__packed__)) SevInfoBlock { 87 /* SEV-ES Reset Vector Address */ 88 uint32_t reset_addr; 89 } SevInfoBlock; 90 91 #define SEV_HASH_TABLE_RV_GUID "7255371f-3a3b-4b04-927b-1da6efa8d454" 92 typedef struct QEMU_PACKED SevHashTableDescriptor { 93 /* SEV hash table area guest address */ 94 uint32_t base; 95 /* SEV hash table area size (in bytes) */ 96 uint32_t size; 97 } SevHashTableDescriptor; 98 99 /* hard code sha256 digest size */ 100 #define HASH_SIZE 32 101 102 typedef struct QEMU_PACKED SevHashTableEntry { 103 QemuUUID guid; 104 uint16_t len; 105 uint8_t hash[HASH_SIZE]; 106 } SevHashTableEntry; 107 108 typedef struct QEMU_PACKED SevHashTable { 109 QemuUUID guid; 110 uint16_t len; 111 SevHashTableEntry cmdline; 112 SevHashTableEntry initrd; 113 SevHashTableEntry kernel; 114 } SevHashTable; 115 116 /* 117 * Data encrypted by sev_encrypt_flash() must be padded to a multiple of 118 * 16 bytes. 119 */ 120 typedef struct QEMU_PACKED PaddedSevHashTable { 121 SevHashTable ht; 122 uint8_t padding[ROUND_UP(sizeof(SevHashTable), 16) - sizeof(SevHashTable)]; 123 } PaddedSevHashTable; 124 125 QEMU_BUILD_BUG_ON(sizeof(PaddedSevHashTable) % 16 != 0); 126 127 static SevGuestState *sev_guest; 128 static Error *sev_mig_blocker; 129 130 static const char *const sev_fw_errlist[] = { 131 [SEV_RET_SUCCESS] = "", 132 [SEV_RET_INVALID_PLATFORM_STATE] = "Platform state is invalid", 133 [SEV_RET_INVALID_GUEST_STATE] = "Guest state is invalid", 134 [SEV_RET_INAVLID_CONFIG] = "Platform configuration is invalid", 135 [SEV_RET_INVALID_LEN] = "Buffer too small", 136 [SEV_RET_ALREADY_OWNED] = "Platform is already owned", 137 [SEV_RET_INVALID_CERTIFICATE] = "Certificate is invalid", 138 [SEV_RET_POLICY_FAILURE] = "Policy is not allowed", 139 [SEV_RET_INACTIVE] = "Guest is not active", 140 [SEV_RET_INVALID_ADDRESS] = "Invalid address", 141 [SEV_RET_BAD_SIGNATURE] = "Bad signature", 142 [SEV_RET_BAD_MEASUREMENT] = "Bad measurement", 143 [SEV_RET_ASID_OWNED] = "ASID is already owned", 144 [SEV_RET_INVALID_ASID] = "Invalid ASID", 145 [SEV_RET_WBINVD_REQUIRED] = "WBINVD is required", 146 [SEV_RET_DFFLUSH_REQUIRED] = "DF_FLUSH is required", 147 [SEV_RET_INVALID_GUEST] = "Guest handle is invalid", 148 [SEV_RET_INVALID_COMMAND] = "Invalid command", 149 [SEV_RET_ACTIVE] = "Guest is active", 150 [SEV_RET_HWSEV_RET_PLATFORM] = "Hardware error", 151 [SEV_RET_HWSEV_RET_UNSAFE] = "Hardware unsafe", 152 [SEV_RET_UNSUPPORTED] = "Feature not supported", 153 [SEV_RET_INVALID_PARAM] = "Invalid parameter", 154 [SEV_RET_RESOURCE_LIMIT] = "Required firmware resource depleted", 155 [SEV_RET_SECURE_DATA_INVALID] = "Part-specific integrity check failure", 156 }; 157 158 #define SEV_FW_MAX_ERROR ARRAY_SIZE(sev_fw_errlist) 159 160 static int 161 sev_ioctl(int fd, int cmd, void *data, int *error) 162 { 163 int r; 164 struct kvm_sev_cmd input; 165 166 memset(&input, 0x0, sizeof(input)); 167 168 input.id = cmd; 169 input.sev_fd = fd; 170 input.data = (uintptr_t)data; 171 172 r = kvm_vm_ioctl(kvm_state, KVM_MEMORY_ENCRYPT_OP, &input); 173 174 if (error) { 175 *error = input.error; 176 } 177 178 return r; 179 } 180 181 static int 182 sev_platform_ioctl(int fd, int cmd, void *data, int *error) 183 { 184 int r; 185 struct sev_issue_cmd arg; 186 187 arg.cmd = cmd; 188 arg.data = (unsigned long)data; 189 r = ioctl(fd, SEV_ISSUE_CMD, &arg); 190 if (error) { 191 *error = arg.error; 192 } 193 194 return r; 195 } 196 197 static const char * 198 fw_error_to_str(int code) 199 { 200 if (code < 0 || code >= SEV_FW_MAX_ERROR) { 201 return "unknown error"; 202 } 203 204 return sev_fw_errlist[code]; 205 } 206 207 static bool 208 sev_check_state(const SevGuestState *sev, SevState state) 209 { 210 assert(sev); 211 return sev->state == state ? true : false; 212 } 213 214 static void 215 sev_set_guest_state(SevGuestState *sev, SevState new_state) 216 { 217 assert(new_state < SEV_STATE__MAX); 218 assert(sev); 219 220 trace_kvm_sev_change_state(SevState_str(sev->state), 221 SevState_str(new_state)); 222 sev->state = new_state; 223 } 224 225 static void 226 sev_ram_block_added(RAMBlockNotifier *n, void *host, size_t size, 227 size_t max_size) 228 { 229 int r; 230 struct kvm_enc_region range; 231 ram_addr_t offset; 232 MemoryRegion *mr; 233 234 /* 235 * The RAM device presents a memory region that should be treated 236 * as IO region and should not be pinned. 237 */ 238 mr = memory_region_from_host(host, &offset); 239 if (mr && memory_region_is_ram_device(mr)) { 240 return; 241 } 242 243 range.addr = (uintptr_t)host; 244 range.size = max_size; 245 246 trace_kvm_memcrypt_register_region(host, max_size); 247 r = kvm_vm_ioctl(kvm_state, KVM_MEMORY_ENCRYPT_REG_REGION, &range); 248 if (r) { 249 error_report("%s: failed to register region (%p+%#zx) error '%s'", 250 __func__, host, max_size, strerror(errno)); 251 exit(1); 252 } 253 } 254 255 static void 256 sev_ram_block_removed(RAMBlockNotifier *n, void *host, size_t size, 257 size_t max_size) 258 { 259 int r; 260 struct kvm_enc_region range; 261 ram_addr_t offset; 262 MemoryRegion *mr; 263 264 /* 265 * The RAM device presents a memory region that should be treated 266 * as IO region and should not have been pinned. 267 */ 268 mr = memory_region_from_host(host, &offset); 269 if (mr && memory_region_is_ram_device(mr)) { 270 return; 271 } 272 273 range.addr = (uintptr_t)host; 274 range.size = max_size; 275 276 trace_kvm_memcrypt_unregister_region(host, max_size); 277 r = kvm_vm_ioctl(kvm_state, KVM_MEMORY_ENCRYPT_UNREG_REGION, &range); 278 if (r) { 279 error_report("%s: failed to unregister region (%p+%#zx)", 280 __func__, host, max_size); 281 } 282 } 283 284 static struct RAMBlockNotifier sev_ram_notifier = { 285 .ram_block_added = sev_ram_block_added, 286 .ram_block_removed = sev_ram_block_removed, 287 }; 288 289 static void 290 sev_guest_finalize(Object *obj) 291 { 292 } 293 294 static char * 295 sev_guest_get_session_file(Object *obj, Error **errp) 296 { 297 SevGuestState *s = SEV_GUEST(obj); 298 299 return s->session_file ? g_strdup(s->session_file) : NULL; 300 } 301 302 static void 303 sev_guest_set_session_file(Object *obj, const char *value, Error **errp) 304 { 305 SevGuestState *s = SEV_GUEST(obj); 306 307 s->session_file = g_strdup(value); 308 } 309 310 static char * 311 sev_guest_get_dh_cert_file(Object *obj, Error **errp) 312 { 313 SevGuestState *s = SEV_GUEST(obj); 314 315 return g_strdup(s->dh_cert_file); 316 } 317 318 static void 319 sev_guest_set_dh_cert_file(Object *obj, const char *value, Error **errp) 320 { 321 SevGuestState *s = SEV_GUEST(obj); 322 323 s->dh_cert_file = g_strdup(value); 324 } 325 326 static char * 327 sev_guest_get_sev_device(Object *obj, Error **errp) 328 { 329 SevGuestState *sev = SEV_GUEST(obj); 330 331 return g_strdup(sev->sev_device); 332 } 333 334 static void 335 sev_guest_set_sev_device(Object *obj, const char *value, Error **errp) 336 { 337 SevGuestState *sev = SEV_GUEST(obj); 338 339 sev->sev_device = g_strdup(value); 340 } 341 342 static bool sev_guest_get_kernel_hashes(Object *obj, Error **errp) 343 { 344 SevGuestState *sev = SEV_GUEST(obj); 345 346 return sev->kernel_hashes; 347 } 348 349 static void sev_guest_set_kernel_hashes(Object *obj, bool value, Error **errp) 350 { 351 SevGuestState *sev = SEV_GUEST(obj); 352 353 sev->kernel_hashes = value; 354 } 355 356 bool 357 sev_enabled(void) 358 { 359 return !!sev_guest; 360 } 361 362 bool 363 sev_es_enabled(void) 364 { 365 return sev_enabled() && (sev_guest->policy & SEV_POLICY_ES); 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 static SevInfo *sev_get_info(void) 381 { 382 SevInfo *info; 383 384 info = g_new0(SevInfo, 1); 385 info->enabled = sev_enabled(); 386 387 if (info->enabled) { 388 info->api_major = sev_guest->api_major; 389 info->api_minor = sev_guest->api_minor; 390 info->build_id = sev_guest->build_id; 391 info->policy = sev_guest->policy; 392 info->state = sev_guest->state; 393 info->handle = sev_guest->handle; 394 } 395 396 return info; 397 } 398 399 SevInfo *qmp_query_sev(Error **errp) 400 { 401 SevInfo *info; 402 403 info = sev_get_info(); 404 if (!info) { 405 error_setg(errp, "SEV feature is not available"); 406 return NULL; 407 } 408 409 return info; 410 } 411 412 void hmp_info_sev(Monitor *mon, const QDict *qdict) 413 { 414 SevInfo *info = sev_get_info(); 415 416 if (info && info->enabled) { 417 monitor_printf(mon, "handle: %d\n", info->handle); 418 monitor_printf(mon, "state: %s\n", SevState_str(info->state)); 419 monitor_printf(mon, "build: %d\n", info->build_id); 420 monitor_printf(mon, "api version: %d.%d\n", 421 info->api_major, info->api_minor); 422 monitor_printf(mon, "debug: %s\n", 423 info->policy & SEV_POLICY_NODBG ? "off" : "on"); 424 monitor_printf(mon, "key-sharing: %s\n", 425 info->policy & SEV_POLICY_NOKS ? "off" : "on"); 426 } else { 427 monitor_printf(mon, "SEV is not enabled\n"); 428 } 429 430 qapi_free_SevInfo(info); 431 } 432 433 static int 434 sev_get_pdh_info(int fd, guchar **pdh, size_t *pdh_len, guchar **cert_chain, 435 size_t *cert_chain_len, Error **errp) 436 { 437 guchar *pdh_data = NULL; 438 guchar *cert_chain_data = NULL; 439 struct sev_user_data_pdh_cert_export export = {}; 440 int err, r; 441 442 /* query the certificate length */ 443 r = sev_platform_ioctl(fd, SEV_PDH_CERT_EXPORT, &export, &err); 444 if (r < 0) { 445 if (err != SEV_RET_INVALID_LEN) { 446 error_setg(errp, "SEV: Failed to export PDH cert" 447 " ret=%d fw_err=%d (%s)", 448 r, err, fw_error_to_str(err)); 449 return 1; 450 } 451 } 452 453 pdh_data = g_new(guchar, export.pdh_cert_len); 454 cert_chain_data = g_new(guchar, export.cert_chain_len); 455 export.pdh_cert_address = (unsigned long)pdh_data; 456 export.cert_chain_address = (unsigned long)cert_chain_data; 457 458 r = sev_platform_ioctl(fd, SEV_PDH_CERT_EXPORT, &export, &err); 459 if (r < 0) { 460 error_setg(errp, "SEV: Failed to export PDH cert ret=%d fw_err=%d (%s)", 461 r, err, fw_error_to_str(err)); 462 goto e_free; 463 } 464 465 *pdh = pdh_data; 466 *pdh_len = export.pdh_cert_len; 467 *cert_chain = cert_chain_data; 468 *cert_chain_len = export.cert_chain_len; 469 return 0; 470 471 e_free: 472 g_free(pdh_data); 473 g_free(cert_chain_data); 474 return 1; 475 } 476 477 static int sev_get_cpu0_id(int fd, guchar **id, size_t *id_len, Error **errp) 478 { 479 guchar *id_data; 480 struct sev_user_data_get_id2 get_id2 = {}; 481 int err, r; 482 483 /* query the ID length */ 484 r = sev_platform_ioctl(fd, SEV_GET_ID2, &get_id2, &err); 485 if (r < 0 && err != SEV_RET_INVALID_LEN) { 486 error_setg(errp, "SEV: Failed to get ID ret=%d fw_err=%d (%s)", 487 r, err, fw_error_to_str(err)); 488 return 1; 489 } 490 491 id_data = g_new(guchar, get_id2.length); 492 get_id2.address = (unsigned long)id_data; 493 494 r = sev_platform_ioctl(fd, SEV_GET_ID2, &get_id2, &err); 495 if (r < 0) { 496 error_setg(errp, "SEV: Failed to get ID ret=%d fw_err=%d (%s)", 497 r, err, fw_error_to_str(err)); 498 goto err; 499 } 500 501 *id = id_data; 502 *id_len = get_id2.length; 503 return 0; 504 505 err: 506 g_free(id_data); 507 return 1; 508 } 509 510 static SevCapability *sev_get_capabilities(Error **errp) 511 { 512 SevCapability *cap = NULL; 513 guchar *pdh_data = NULL; 514 guchar *cert_chain_data = NULL; 515 guchar *cpu0_id_data = NULL; 516 size_t pdh_len = 0, cert_chain_len = 0, cpu0_id_len = 0; 517 uint32_t ebx; 518 int fd; 519 520 if (!kvm_enabled()) { 521 error_setg(errp, "KVM not enabled"); 522 return NULL; 523 } 524 if (kvm_vm_ioctl(kvm_state, KVM_MEMORY_ENCRYPT_OP, NULL) < 0) { 525 error_setg(errp, "SEV is not enabled in KVM"); 526 return NULL; 527 } 528 529 fd = open(DEFAULT_SEV_DEVICE, O_RDWR); 530 if (fd < 0) { 531 error_setg_errno(errp, errno, "SEV: Failed to open %s", 532 DEFAULT_SEV_DEVICE); 533 return NULL; 534 } 535 536 if (sev_get_pdh_info(fd, &pdh_data, &pdh_len, 537 &cert_chain_data, &cert_chain_len, errp)) { 538 goto out; 539 } 540 541 if (sev_get_cpu0_id(fd, &cpu0_id_data, &cpu0_id_len, errp)) { 542 goto out; 543 } 544 545 cap = g_new0(SevCapability, 1); 546 cap->pdh = g_base64_encode(pdh_data, pdh_len); 547 cap->cert_chain = g_base64_encode(cert_chain_data, cert_chain_len); 548 cap->cpu0_id = g_base64_encode(cpu0_id_data, cpu0_id_len); 549 550 host_cpuid(0x8000001F, 0, NULL, &ebx, NULL, NULL); 551 cap->cbitpos = ebx & 0x3f; 552 553 /* 554 * When SEV feature is enabled, we loose one bit in guest physical 555 * addressing. 556 */ 557 cap->reduced_phys_bits = 1; 558 559 out: 560 g_free(cpu0_id_data); 561 g_free(pdh_data); 562 g_free(cert_chain_data); 563 close(fd); 564 return cap; 565 } 566 567 SevCapability *qmp_query_sev_capabilities(Error **errp) 568 { 569 return sev_get_capabilities(errp); 570 } 571 572 static SevAttestationReport *sev_get_attestation_report(const char *mnonce, 573 Error **errp) 574 { 575 struct kvm_sev_attestation_report input = {}; 576 SevAttestationReport *report = NULL; 577 SevGuestState *sev = sev_guest; 578 g_autofree guchar *data = NULL; 579 g_autofree guchar *buf = NULL; 580 gsize len; 581 int err = 0, ret; 582 583 if (!sev_enabled()) { 584 error_setg(errp, "SEV is not enabled"); 585 return NULL; 586 } 587 588 /* lets decode the mnonce string */ 589 buf = g_base64_decode(mnonce, &len); 590 if (!buf) { 591 error_setg(errp, "SEV: failed to decode mnonce input"); 592 return NULL; 593 } 594 595 /* verify the input mnonce length */ 596 if (len != sizeof(input.mnonce)) { 597 error_setg(errp, "SEV: mnonce must be %zu bytes (got %" G_GSIZE_FORMAT ")", 598 sizeof(input.mnonce), len); 599 return NULL; 600 } 601 602 /* Query the report length */ 603 ret = sev_ioctl(sev->sev_fd, KVM_SEV_GET_ATTESTATION_REPORT, 604 &input, &err); 605 if (ret < 0) { 606 if (err != SEV_RET_INVALID_LEN) { 607 error_setg(errp, "SEV: Failed to query the attestation report" 608 " length ret=%d fw_err=%d (%s)", 609 ret, err, fw_error_to_str(err)); 610 return NULL; 611 } 612 } 613 614 data = g_malloc(input.len); 615 input.uaddr = (unsigned long)data; 616 memcpy(input.mnonce, buf, sizeof(input.mnonce)); 617 618 /* Query the report */ 619 ret = sev_ioctl(sev->sev_fd, KVM_SEV_GET_ATTESTATION_REPORT, 620 &input, &err); 621 if (ret) { 622 error_setg_errno(errp, errno, "SEV: Failed to get attestation report" 623 " ret=%d fw_err=%d (%s)", ret, err, fw_error_to_str(err)); 624 return NULL; 625 } 626 627 report = g_new0(SevAttestationReport, 1); 628 report->data = g_base64_encode(data, input.len); 629 630 trace_kvm_sev_attestation_report(mnonce, report->data); 631 632 return report; 633 } 634 635 SevAttestationReport *qmp_query_sev_attestation_report(const char *mnonce, 636 Error **errp) 637 { 638 return sev_get_attestation_report(mnonce, errp); 639 } 640 641 static int 642 sev_read_file_base64(const char *filename, guchar **data, gsize *len) 643 { 644 gsize sz; 645 g_autofree gchar *base64 = NULL; 646 GError *error = NULL; 647 648 if (!g_file_get_contents(filename, &base64, &sz, &error)) { 649 error_report("SEV: Failed to read '%s' (%s)", filename, error->message); 650 g_error_free(error); 651 return -1; 652 } 653 654 *data = g_base64_decode(base64, len); 655 return 0; 656 } 657 658 static int 659 sev_launch_start(SevGuestState *sev) 660 { 661 gsize sz; 662 int ret = 1; 663 int fw_error, rc; 664 struct kvm_sev_launch_start start = { 665 .handle = sev->handle, .policy = sev->policy 666 }; 667 guchar *session = NULL, *dh_cert = NULL; 668 669 if (sev->session_file) { 670 if (sev_read_file_base64(sev->session_file, &session, &sz) < 0) { 671 goto out; 672 } 673 start.session_uaddr = (unsigned long)session; 674 start.session_len = sz; 675 } 676 677 if (sev->dh_cert_file) { 678 if (sev_read_file_base64(sev->dh_cert_file, &dh_cert, &sz) < 0) { 679 goto out; 680 } 681 start.dh_uaddr = (unsigned long)dh_cert; 682 start.dh_len = sz; 683 } 684 685 trace_kvm_sev_launch_start(start.policy, session, dh_cert); 686 rc = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_START, &start, &fw_error); 687 if (rc < 0) { 688 error_report("%s: LAUNCH_START ret=%d fw_error=%d '%s'", 689 __func__, ret, fw_error, fw_error_to_str(fw_error)); 690 goto out; 691 } 692 693 sev_set_guest_state(sev, SEV_STATE_LAUNCH_UPDATE); 694 sev->handle = start.handle; 695 ret = 0; 696 697 out: 698 g_free(session); 699 g_free(dh_cert); 700 return ret; 701 } 702 703 static int 704 sev_launch_update_data(SevGuestState *sev, uint8_t *addr, uint64_t len) 705 { 706 int ret, fw_error; 707 struct kvm_sev_launch_update_data update; 708 709 if (!addr || !len) { 710 return 1; 711 } 712 713 update.uaddr = (uintptr_t)addr; 714 update.len = len; 715 trace_kvm_sev_launch_update_data(addr, len); 716 ret = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_UPDATE_DATA, 717 &update, &fw_error); 718 if (ret) { 719 error_report("%s: LAUNCH_UPDATE ret=%d fw_error=%d '%s'", 720 __func__, ret, fw_error, fw_error_to_str(fw_error)); 721 } 722 723 return ret; 724 } 725 726 static int 727 sev_launch_update_vmsa(SevGuestState *sev) 728 { 729 int ret, fw_error; 730 731 ret = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_UPDATE_VMSA, NULL, &fw_error); 732 if (ret) { 733 error_report("%s: LAUNCH_UPDATE_VMSA ret=%d fw_error=%d '%s'", 734 __func__, ret, fw_error, fw_error_to_str(fw_error)); 735 } 736 737 return ret; 738 } 739 740 static void 741 sev_launch_get_measure(Notifier *notifier, void *unused) 742 { 743 SevGuestState *sev = sev_guest; 744 int ret, error; 745 g_autofree guchar *data = NULL; 746 struct kvm_sev_launch_measure measurement = {}; 747 748 if (!sev_check_state(sev, SEV_STATE_LAUNCH_UPDATE)) { 749 return; 750 } 751 752 if (sev_es_enabled()) { 753 /* measure all the VM save areas before getting launch_measure */ 754 ret = sev_launch_update_vmsa(sev); 755 if (ret) { 756 exit(1); 757 } 758 kvm_mark_guest_state_protected(); 759 } 760 761 /* query the measurement blob length */ 762 ret = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_MEASURE, 763 &measurement, &error); 764 if (!measurement.len) { 765 error_report("%s: LAUNCH_MEASURE ret=%d fw_error=%d '%s'", 766 __func__, ret, error, fw_error_to_str(errno)); 767 return; 768 } 769 770 data = g_new0(guchar, measurement.len); 771 measurement.uaddr = (unsigned long)data; 772 773 /* get the measurement blob */ 774 ret = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_MEASURE, 775 &measurement, &error); 776 if (ret) { 777 error_report("%s: LAUNCH_MEASURE ret=%d fw_error=%d '%s'", 778 __func__, ret, error, fw_error_to_str(errno)); 779 return; 780 } 781 782 sev_set_guest_state(sev, SEV_STATE_LAUNCH_SECRET); 783 784 /* encode the measurement value and emit the event */ 785 sev->measurement = g_base64_encode(data, measurement.len); 786 trace_kvm_sev_launch_measurement(sev->measurement); 787 } 788 789 static char *sev_get_launch_measurement(void) 790 { 791 if (sev_guest && 792 sev_guest->state >= SEV_STATE_LAUNCH_SECRET) { 793 return g_strdup(sev_guest->measurement); 794 } 795 796 return NULL; 797 } 798 799 SevLaunchMeasureInfo *qmp_query_sev_launch_measure(Error **errp) 800 { 801 char *data; 802 SevLaunchMeasureInfo *info; 803 804 data = sev_get_launch_measurement(); 805 if (!data) { 806 error_setg(errp, "SEV launch measurement is not available"); 807 return NULL; 808 } 809 810 info = g_malloc0(sizeof(*info)); 811 info->data = data; 812 813 return info; 814 } 815 816 static Notifier sev_machine_done_notify = { 817 .notify = sev_launch_get_measure, 818 }; 819 820 static void 821 sev_launch_finish(SevGuestState *sev) 822 { 823 int ret, error; 824 825 trace_kvm_sev_launch_finish(); 826 ret = sev_ioctl(sev->sev_fd, KVM_SEV_LAUNCH_FINISH, 0, &error); 827 if (ret) { 828 error_report("%s: LAUNCH_FINISH ret=%d fw_error=%d '%s'", 829 __func__, ret, error, fw_error_to_str(error)); 830 exit(1); 831 } 832 833 sev_set_guest_state(sev, SEV_STATE_RUNNING); 834 835 /* add migration blocker */ 836 error_setg(&sev_mig_blocker, 837 "SEV: Migration is not implemented"); 838 migrate_add_blocker(&sev_mig_blocker, &error_fatal); 839 } 840 841 static void 842 sev_vm_state_change(void *opaque, bool running, RunState state) 843 { 844 SevGuestState *sev = opaque; 845 846 if (running) { 847 if (!sev_check_state(sev, SEV_STATE_RUNNING)) { 848 sev_launch_finish(sev); 849 } 850 } 851 } 852 853 static int sev_kvm_init(ConfidentialGuestSupport *cgs, Error **errp) 854 { 855 SevGuestState *sev = SEV_GUEST(cgs); 856 char *devname; 857 int ret, fw_error, cmd; 858 uint32_t ebx; 859 uint32_t host_cbitpos; 860 struct sev_user_data_status status = {}; 861 862 ret = ram_block_discard_disable(true); 863 if (ret) { 864 error_report("%s: cannot disable RAM discard", __func__); 865 return -1; 866 } 867 868 sev_guest = sev; 869 sev->state = SEV_STATE_UNINIT; 870 871 host_cpuid(0x8000001F, 0, NULL, &ebx, NULL, NULL); 872 host_cbitpos = ebx & 0x3f; 873 874 /* 875 * The cbitpos value will be placed in bit positions 5:0 of the EBX 876 * register of CPUID 0x8000001F. No need to verify the range as the 877 * comparison against the host value accomplishes that. 878 */ 879 if (host_cbitpos != sev->cbitpos) { 880 error_setg(errp, "%s: cbitpos check failed, host '%d' requested '%d'", 881 __func__, host_cbitpos, sev->cbitpos); 882 goto err; 883 } 884 885 /* 886 * The reduced-phys-bits value will be placed in bit positions 11:6 of 887 * the EBX register of CPUID 0x8000001F, so verify the supplied value 888 * is in the range of 1 to 63. 889 */ 890 if (sev->reduced_phys_bits < 1 || sev->reduced_phys_bits > 63) { 891 error_setg(errp, "%s: reduced_phys_bits check failed," 892 " it should be in the range of 1 to 63, requested '%d'", 893 __func__, sev->reduced_phys_bits); 894 goto err; 895 } 896 897 devname = object_property_get_str(OBJECT(sev), "sev-device", NULL); 898 sev->sev_fd = open(devname, O_RDWR); 899 if (sev->sev_fd < 0) { 900 error_setg(errp, "%s: Failed to open %s '%s'", __func__, 901 devname, strerror(errno)); 902 g_free(devname); 903 goto err; 904 } 905 g_free(devname); 906 907 ret = sev_platform_ioctl(sev->sev_fd, SEV_PLATFORM_STATUS, &status, 908 &fw_error); 909 if (ret) { 910 error_setg(errp, "%s: failed to get platform status ret=%d " 911 "fw_error='%d: %s'", __func__, ret, fw_error, 912 fw_error_to_str(fw_error)); 913 goto err; 914 } 915 sev->build_id = status.build; 916 sev->api_major = status.api_major; 917 sev->api_minor = status.api_minor; 918 919 if (sev_es_enabled()) { 920 if (!kvm_kernel_irqchip_allowed()) { 921 error_report("%s: SEV-ES guests require in-kernel irqchip support", 922 __func__); 923 goto err; 924 } 925 926 if (!(status.flags & SEV_STATUS_FLAGS_CONFIG_ES)) { 927 error_report("%s: guest policy requires SEV-ES, but " 928 "host SEV-ES support unavailable", 929 __func__); 930 goto err; 931 } 932 cmd = KVM_SEV_ES_INIT; 933 } else { 934 cmd = KVM_SEV_INIT; 935 } 936 937 trace_kvm_sev_init(); 938 ret = sev_ioctl(sev->sev_fd, cmd, NULL, &fw_error); 939 if (ret) { 940 error_setg(errp, "%s: failed to initialize ret=%d fw_error=%d '%s'", 941 __func__, ret, fw_error, fw_error_to_str(fw_error)); 942 goto err; 943 } 944 945 ret = sev_launch_start(sev); 946 if (ret) { 947 error_setg(errp, "%s: failed to create encryption context", __func__); 948 goto err; 949 } 950 951 ram_block_notifier_add(&sev_ram_notifier); 952 qemu_add_machine_init_done_notifier(&sev_machine_done_notify); 953 qemu_add_vm_change_state_handler(sev_vm_state_change, sev); 954 955 cgs->ready = true; 956 957 return 0; 958 err: 959 sev_guest = NULL; 960 ram_block_discard_disable(false); 961 return -1; 962 } 963 964 int 965 sev_encrypt_flash(uint8_t *ptr, uint64_t len, Error **errp) 966 { 967 if (!sev_guest) { 968 return 0; 969 } 970 971 /* if SEV is in update state then encrypt the data else do nothing */ 972 if (sev_check_state(sev_guest, SEV_STATE_LAUNCH_UPDATE)) { 973 int ret = sev_launch_update_data(sev_guest, ptr, len); 974 if (ret < 0) { 975 error_setg(errp, "SEV: Failed to encrypt pflash rom"); 976 return ret; 977 } 978 } 979 980 return 0; 981 } 982 983 int sev_inject_launch_secret(const char *packet_hdr, const char *secret, 984 uint64_t gpa, Error **errp) 985 { 986 ERRP_GUARD(); 987 struct kvm_sev_launch_secret input; 988 g_autofree guchar *data = NULL, *hdr = NULL; 989 int error, ret = 1; 990 void *hva; 991 gsize hdr_sz = 0, data_sz = 0; 992 MemoryRegion *mr = NULL; 993 994 if (!sev_guest) { 995 error_setg(errp, "SEV not enabled for guest"); 996 return 1; 997 } 998 999 /* secret can be injected only in this state */ 1000 if (!sev_check_state(sev_guest, SEV_STATE_LAUNCH_SECRET)) { 1001 error_setg(errp, "SEV: Not in correct state. (LSECRET) %x", 1002 sev_guest->state); 1003 return 1; 1004 } 1005 1006 hdr = g_base64_decode(packet_hdr, &hdr_sz); 1007 if (!hdr || !hdr_sz) { 1008 error_setg(errp, "SEV: Failed to decode sequence header"); 1009 return 1; 1010 } 1011 1012 data = g_base64_decode(secret, &data_sz); 1013 if (!data || !data_sz) { 1014 error_setg(errp, "SEV: Failed to decode data"); 1015 return 1; 1016 } 1017 1018 hva = gpa2hva(&mr, gpa, data_sz, errp); 1019 if (!hva) { 1020 error_prepend(errp, "SEV: Failed to calculate guest address: "); 1021 return 1; 1022 } 1023 1024 input.hdr_uaddr = (uint64_t)(unsigned long)hdr; 1025 input.hdr_len = hdr_sz; 1026 1027 input.trans_uaddr = (uint64_t)(unsigned long)data; 1028 input.trans_len = data_sz; 1029 1030 input.guest_uaddr = (uint64_t)(unsigned long)hva; 1031 input.guest_len = data_sz; 1032 1033 trace_kvm_sev_launch_secret(gpa, input.guest_uaddr, 1034 input.trans_uaddr, input.trans_len); 1035 1036 ret = sev_ioctl(sev_guest->sev_fd, KVM_SEV_LAUNCH_SECRET, 1037 &input, &error); 1038 if (ret) { 1039 error_setg(errp, "SEV: failed to inject secret ret=%d fw_error=%d '%s'", 1040 ret, error, fw_error_to_str(error)); 1041 return ret; 1042 } 1043 1044 return 0; 1045 } 1046 1047 #define SEV_SECRET_GUID "4c2eb361-7d9b-4cc3-8081-127c90d3d294" 1048 struct sev_secret_area { 1049 uint32_t base; 1050 uint32_t size; 1051 }; 1052 1053 void qmp_sev_inject_launch_secret(const char *packet_hdr, 1054 const char *secret, 1055 bool has_gpa, uint64_t gpa, 1056 Error **errp) 1057 { 1058 if (!sev_enabled()) { 1059 error_setg(errp, "SEV not enabled for guest"); 1060 return; 1061 } 1062 if (!has_gpa) { 1063 uint8_t *data; 1064 struct sev_secret_area *area; 1065 1066 if (!pc_system_ovmf_table_find(SEV_SECRET_GUID, &data, NULL)) { 1067 error_setg(errp, "SEV: no secret area found in OVMF," 1068 " gpa must be specified."); 1069 return; 1070 } 1071 area = (struct sev_secret_area *)data; 1072 gpa = area->base; 1073 } 1074 1075 sev_inject_launch_secret(packet_hdr, secret, gpa, errp); 1076 } 1077 1078 static int 1079 sev_es_parse_reset_block(SevInfoBlock *info, uint32_t *addr) 1080 { 1081 if (!info->reset_addr) { 1082 error_report("SEV-ES reset address is zero"); 1083 return 1; 1084 } 1085 1086 *addr = info->reset_addr; 1087 1088 return 0; 1089 } 1090 1091 static int 1092 sev_es_find_reset_vector(void *flash_ptr, uint64_t flash_size, 1093 uint32_t *addr) 1094 { 1095 QemuUUID info_guid, *guid; 1096 SevInfoBlock *info; 1097 uint8_t *data; 1098 uint16_t *len; 1099 1100 /* 1101 * Initialize the address to zero. An address of zero with a successful 1102 * return code indicates that SEV-ES is not active. 1103 */ 1104 *addr = 0; 1105 1106 /* 1107 * Extract the AP reset vector for SEV-ES guests by locating the SEV GUID. 1108 * The SEV GUID is located on its own (original implementation) or within 1109 * the Firmware GUID Table (new implementation), either of which are 1110 * located 32 bytes from the end of the flash. 1111 * 1112 * Check the Firmware GUID Table first. 1113 */ 1114 if (pc_system_ovmf_table_find(SEV_INFO_BLOCK_GUID, &data, NULL)) { 1115 return sev_es_parse_reset_block((SevInfoBlock *)data, addr); 1116 } 1117 1118 /* 1119 * SEV info block not found in the Firmware GUID Table (or there isn't 1120 * a Firmware GUID Table), fall back to the original implementation. 1121 */ 1122 data = flash_ptr + flash_size - 0x20; 1123 1124 qemu_uuid_parse(SEV_INFO_BLOCK_GUID, &info_guid); 1125 info_guid = qemu_uuid_bswap(info_guid); /* GUIDs are LE */ 1126 1127 guid = (QemuUUID *)(data - sizeof(info_guid)); 1128 if (!qemu_uuid_is_equal(guid, &info_guid)) { 1129 error_report("SEV information block/Firmware GUID Table block not found in pflash rom"); 1130 return 1; 1131 } 1132 1133 len = (uint16_t *)((uint8_t *)guid - sizeof(*len)); 1134 info = (SevInfoBlock *)(data - le16_to_cpu(*len)); 1135 1136 return sev_es_parse_reset_block(info, addr); 1137 } 1138 1139 void sev_es_set_reset_vector(CPUState *cpu) 1140 { 1141 X86CPU *x86; 1142 CPUX86State *env; 1143 1144 /* Only update if we have valid reset information */ 1145 if (!sev_guest || !sev_guest->reset_data_valid) { 1146 return; 1147 } 1148 1149 /* Do not update the BSP reset state */ 1150 if (cpu->cpu_index == 0) { 1151 return; 1152 } 1153 1154 x86 = X86_CPU(cpu); 1155 env = &x86->env; 1156 1157 cpu_x86_load_seg_cache(env, R_CS, 0xf000, sev_guest->reset_cs, 0xffff, 1158 DESC_P_MASK | DESC_S_MASK | DESC_CS_MASK | 1159 DESC_R_MASK | DESC_A_MASK); 1160 1161 env->eip = sev_guest->reset_ip; 1162 } 1163 1164 int sev_es_save_reset_vector(void *flash_ptr, uint64_t flash_size) 1165 { 1166 CPUState *cpu; 1167 uint32_t addr; 1168 int ret; 1169 1170 if (!sev_es_enabled()) { 1171 return 0; 1172 } 1173 1174 addr = 0; 1175 ret = sev_es_find_reset_vector(flash_ptr, flash_size, 1176 &addr); 1177 if (ret) { 1178 return ret; 1179 } 1180 1181 if (addr) { 1182 sev_guest->reset_cs = addr & 0xffff0000; 1183 sev_guest->reset_ip = addr & 0x0000ffff; 1184 sev_guest->reset_data_valid = true; 1185 1186 CPU_FOREACH(cpu) { 1187 sev_es_set_reset_vector(cpu); 1188 } 1189 } 1190 1191 return 0; 1192 } 1193 1194 static const QemuUUID sev_hash_table_header_guid = { 1195 .data = UUID_LE(0x9438d606, 0x4f22, 0x4cc9, 0xb4, 0x79, 0xa7, 0x93, 1196 0xd4, 0x11, 0xfd, 0x21) 1197 }; 1198 1199 static const QemuUUID sev_kernel_entry_guid = { 1200 .data = UUID_LE(0x4de79437, 0xabd2, 0x427f, 0xb8, 0x35, 0xd5, 0xb1, 1201 0x72, 0xd2, 0x04, 0x5b) 1202 }; 1203 static const QemuUUID sev_initrd_entry_guid = { 1204 .data = UUID_LE(0x44baf731, 0x3a2f, 0x4bd7, 0x9a, 0xf1, 0x41, 0xe2, 1205 0x91, 0x69, 0x78, 0x1d) 1206 }; 1207 static const QemuUUID sev_cmdline_entry_guid = { 1208 .data = UUID_LE(0x97d02dd8, 0xbd20, 0x4c94, 0xaa, 0x78, 0xe7, 0x71, 1209 0x4d, 0x36, 0xab, 0x2a) 1210 }; 1211 1212 /* 1213 * Add the hashes of the linux kernel/initrd/cmdline to an encrypted guest page 1214 * which is included in SEV's initial memory measurement. 1215 */ 1216 bool sev_add_kernel_loader_hashes(SevKernelLoaderContext *ctx, Error **errp) 1217 { 1218 uint8_t *data; 1219 SevHashTableDescriptor *area; 1220 SevHashTable *ht; 1221 PaddedSevHashTable *padded_ht; 1222 uint8_t cmdline_hash[HASH_SIZE]; 1223 uint8_t initrd_hash[HASH_SIZE]; 1224 uint8_t kernel_hash[HASH_SIZE]; 1225 uint8_t *hashp; 1226 size_t hash_len = HASH_SIZE; 1227 hwaddr mapped_len = sizeof(*padded_ht); 1228 MemTxAttrs attrs = { 0 }; 1229 bool ret = true; 1230 1231 /* 1232 * Only add the kernel hashes if the sev-guest configuration explicitly 1233 * stated kernel-hashes=on. 1234 */ 1235 if (!sev_guest->kernel_hashes) { 1236 return false; 1237 } 1238 1239 if (!pc_system_ovmf_table_find(SEV_HASH_TABLE_RV_GUID, &data, NULL)) { 1240 error_setg(errp, "SEV: kernel specified but guest firmware " 1241 "has no hashes table GUID"); 1242 return false; 1243 } 1244 area = (SevHashTableDescriptor *)data; 1245 if (!area->base || area->size < sizeof(PaddedSevHashTable)) { 1246 error_setg(errp, "SEV: guest firmware hashes table area is invalid " 1247 "(base=0x%x size=0x%x)", area->base, area->size); 1248 return false; 1249 } 1250 1251 /* 1252 * Calculate hash of kernel command-line with the terminating null byte. If 1253 * the user doesn't supply a command-line via -append, the 1-byte "\0" will 1254 * be used. 1255 */ 1256 hashp = cmdline_hash; 1257 if (qcrypto_hash_bytes(QCRYPTO_HASH_ALG_SHA256, ctx->cmdline_data, 1258 ctx->cmdline_size, &hashp, &hash_len, errp) < 0) { 1259 return false; 1260 } 1261 assert(hash_len == HASH_SIZE); 1262 1263 /* 1264 * Calculate hash of initrd. If the user doesn't supply an initrd via 1265 * -initrd, an empty buffer will be used (ctx->initrd_size == 0). 1266 */ 1267 hashp = initrd_hash; 1268 if (qcrypto_hash_bytes(QCRYPTO_HASH_ALG_SHA256, ctx->initrd_data, 1269 ctx->initrd_size, &hashp, &hash_len, errp) < 0) { 1270 return false; 1271 } 1272 assert(hash_len == HASH_SIZE); 1273 1274 /* Calculate hash of the kernel */ 1275 hashp = kernel_hash; 1276 struct iovec iov[2] = { 1277 { .iov_base = ctx->setup_data, .iov_len = ctx->setup_size }, 1278 { .iov_base = ctx->kernel_data, .iov_len = ctx->kernel_size } 1279 }; 1280 if (qcrypto_hash_bytesv(QCRYPTO_HASH_ALG_SHA256, iov, ARRAY_SIZE(iov), 1281 &hashp, &hash_len, errp) < 0) { 1282 return false; 1283 } 1284 assert(hash_len == HASH_SIZE); 1285 1286 /* 1287 * Populate the hashes table in the guest's memory at the OVMF-designated 1288 * area for the SEV hashes table 1289 */ 1290 padded_ht = address_space_map(&address_space_memory, area->base, 1291 &mapped_len, true, attrs); 1292 if (!padded_ht || mapped_len != sizeof(*padded_ht)) { 1293 error_setg(errp, "SEV: cannot map hashes table guest memory area"); 1294 return false; 1295 } 1296 ht = &padded_ht->ht; 1297 1298 ht->guid = sev_hash_table_header_guid; 1299 ht->len = sizeof(*ht); 1300 1301 ht->cmdline.guid = sev_cmdline_entry_guid; 1302 ht->cmdline.len = sizeof(ht->cmdline); 1303 memcpy(ht->cmdline.hash, cmdline_hash, sizeof(ht->cmdline.hash)); 1304 1305 ht->initrd.guid = sev_initrd_entry_guid; 1306 ht->initrd.len = sizeof(ht->initrd); 1307 memcpy(ht->initrd.hash, initrd_hash, sizeof(ht->initrd.hash)); 1308 1309 ht->kernel.guid = sev_kernel_entry_guid; 1310 ht->kernel.len = sizeof(ht->kernel); 1311 memcpy(ht->kernel.hash, kernel_hash, sizeof(ht->kernel.hash)); 1312 1313 /* zero the excess data so the measurement can be reliably calculated */ 1314 memset(padded_ht->padding, 0, sizeof(padded_ht->padding)); 1315 1316 if (sev_encrypt_flash((uint8_t *)padded_ht, sizeof(*padded_ht), errp) < 0) { 1317 ret = false; 1318 } 1319 1320 address_space_unmap(&address_space_memory, padded_ht, 1321 mapped_len, true, mapped_len); 1322 1323 return ret; 1324 } 1325 1326 static void 1327 sev_guest_class_init(ObjectClass *oc, void *data) 1328 { 1329 ConfidentialGuestSupportClass *klass = CONFIDENTIAL_GUEST_SUPPORT_CLASS(oc); 1330 1331 klass->kvm_init = sev_kvm_init; 1332 1333 object_class_property_add_str(oc, "sev-device", 1334 sev_guest_get_sev_device, 1335 sev_guest_set_sev_device); 1336 object_class_property_set_description(oc, "sev-device", 1337 "SEV device to use"); 1338 object_class_property_add_str(oc, "dh-cert-file", 1339 sev_guest_get_dh_cert_file, 1340 sev_guest_set_dh_cert_file); 1341 object_class_property_set_description(oc, "dh-cert-file", 1342 "guest owners DH certificate (encoded with base64)"); 1343 object_class_property_add_str(oc, "session-file", 1344 sev_guest_get_session_file, 1345 sev_guest_set_session_file); 1346 object_class_property_set_description(oc, "session-file", 1347 "guest owners session parameters (encoded with base64)"); 1348 object_class_property_add_bool(oc, "kernel-hashes", 1349 sev_guest_get_kernel_hashes, 1350 sev_guest_set_kernel_hashes); 1351 object_class_property_set_description(oc, "kernel-hashes", 1352 "add kernel hashes to guest firmware for measured Linux boot"); 1353 } 1354 1355 static void 1356 sev_guest_instance_init(Object *obj) 1357 { 1358 SevGuestState *sev = SEV_GUEST(obj); 1359 1360 sev->sev_device = g_strdup(DEFAULT_SEV_DEVICE); 1361 sev->policy = DEFAULT_GUEST_POLICY; 1362 object_property_add_uint32_ptr(obj, "policy", &sev->policy, 1363 OBJ_PROP_FLAG_READWRITE); 1364 object_property_add_uint32_ptr(obj, "handle", &sev->handle, 1365 OBJ_PROP_FLAG_READWRITE); 1366 object_property_add_uint32_ptr(obj, "cbitpos", &sev->cbitpos, 1367 OBJ_PROP_FLAG_READWRITE); 1368 object_property_add_uint32_ptr(obj, "reduced-phys-bits", 1369 &sev->reduced_phys_bits, 1370 OBJ_PROP_FLAG_READWRITE); 1371 } 1372 1373 /* sev guest info */ 1374 static const TypeInfo sev_guest_info = { 1375 .parent = TYPE_CONFIDENTIAL_GUEST_SUPPORT, 1376 .name = TYPE_SEV_GUEST, 1377 .instance_size = sizeof(SevGuestState), 1378 .instance_finalize = sev_guest_finalize, 1379 .class_init = sev_guest_class_init, 1380 .instance_init = sev_guest_instance_init, 1381 .interfaces = (InterfaceInfo[]) { 1382 { TYPE_USER_CREATABLE }, 1383 { } 1384 } 1385 }; 1386 1387 static void 1388 sev_register_types(void) 1389 { 1390 type_register_static(&sev_guest_info); 1391 } 1392 1393 type_init(sev_register_types); 1394