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