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/kvm_para.h>
18 #include <linux/psp-sev.h>
19
20 #include <sys/ioctl.h>
21
22 #include "qapi/error.h"
23 #include "qom/object_interfaces.h"
24 #include "qemu/base64.h"
25 #include "qemu/module.h"
26 #include "qemu/uuid.h"
27 #include "qemu/error-report.h"
28 #include "crypto/hash.h"
29 #include "sysemu/kvm.h"
30 #include "kvm/kvm_i386.h"
31 #include "sev.h"
32 #include "sysemu/sysemu.h"
33 #include "sysemu/runstate.h"
34 #include "trace.h"
35 #include "migration/blocker.h"
36 #include "qom/object.h"
37 #include "monitor/monitor.h"
38 #include "monitor/hmp-target.h"
39 #include "qapi/qapi-commands-misc-target.h"
40 #include "confidential-guest.h"
41 #include "hw/i386/pc.h"
42 #include "exec/address-spaces.h"
43 #include "qemu/queue.h"
44
45 OBJECT_DECLARE_TYPE(SevCommonState, SevCommonStateClass, SEV_COMMON)
46 OBJECT_DECLARE_TYPE(SevGuestState, SevCommonStateClass, SEV_GUEST)
47 OBJECT_DECLARE_TYPE(SevSnpGuestState, SevCommonStateClass, SEV_SNP_GUEST)
48
49 /* hard code sha256 digest size */
50 #define HASH_SIZE 32
51
52 typedef struct QEMU_PACKED SevHashTableEntry {
53 QemuUUID guid;
54 uint16_t len;
55 uint8_t hash[HASH_SIZE];
56 } SevHashTableEntry;
57
58 typedef struct QEMU_PACKED SevHashTable {
59 QemuUUID guid;
60 uint16_t len;
61 SevHashTableEntry cmdline;
62 SevHashTableEntry initrd;
63 SevHashTableEntry kernel;
64 } SevHashTable;
65
66 /*
67 * Data encrypted by sev_encrypt_flash() must be padded to a multiple of
68 * 16 bytes.
69 */
70 typedef struct QEMU_PACKED PaddedSevHashTable {
71 SevHashTable ht;
72 uint8_t padding[ROUND_UP(sizeof(SevHashTable), 16) - sizeof(SevHashTable)];
73 } PaddedSevHashTable;
74
75 QEMU_BUILD_BUG_ON(sizeof(PaddedSevHashTable) % 16 != 0);
76
77 #define SEV_INFO_BLOCK_GUID "00f771de-1a7e-4fcb-890e-68c77e2fb44e"
78 typedef struct __attribute__((__packed__)) SevInfoBlock {
79 /* SEV-ES Reset Vector Address */
80 uint32_t reset_addr;
81 } SevInfoBlock;
82
83 #define SEV_HASH_TABLE_RV_GUID "7255371f-3a3b-4b04-927b-1da6efa8d454"
84 typedef struct QEMU_PACKED SevHashTableDescriptor {
85 /* SEV hash table area guest address */
86 uint32_t base;
87 /* SEV hash table area size (in bytes) */
88 uint32_t size;
89 } SevHashTableDescriptor;
90
91 struct SevCommonState {
92 X86ConfidentialGuest parent_obj;
93
94 int kvm_type;
95
96 /* configuration parameters */
97 char *sev_device;
98 uint32_t cbitpos;
99 uint32_t reduced_phys_bits;
100 bool kernel_hashes;
101
102 /* runtime state */
103 uint8_t api_major;
104 uint8_t api_minor;
105 uint8_t build_id;
106 int sev_fd;
107 SevState state;
108
109 uint32_t reset_cs;
110 uint32_t reset_ip;
111 bool reset_data_valid;
112 };
113
114 struct SevCommonStateClass {
115 X86ConfidentialGuestClass parent_class;
116
117 /* public */
118 bool (*build_kernel_loader_hashes)(SevCommonState *sev_common,
119 SevHashTableDescriptor *area,
120 SevKernelLoaderContext *ctx,
121 Error **errp);
122 int (*launch_start)(SevCommonState *sev_common);
123 void (*launch_finish)(SevCommonState *sev_common);
124 int (*launch_update_data)(SevCommonState *sev_common, hwaddr gpa, uint8_t *ptr, size_t len);
125 int (*kvm_init)(ConfidentialGuestSupport *cgs, Error **errp);
126 };
127
128 /**
129 * SevGuestState:
130 *
131 * The SevGuestState object is used for creating and managing a SEV
132 * guest.
133 *
134 * # $QEMU \
135 * -object sev-guest,id=sev0 \
136 * -machine ...,memory-encryption=sev0
137 */
138 struct SevGuestState {
139 SevCommonState parent_obj;
140 gchar *measurement;
141
142 /* configuration parameters */
143 uint32_t handle;
144 uint32_t policy;
145 char *dh_cert_file;
146 char *session_file;
147 OnOffAuto legacy_vm_type;
148 };
149
150 struct SevSnpGuestState {
151 SevCommonState parent_obj;
152
153 /* configuration parameters */
154 char *guest_visible_workarounds;
155 char *id_block_base64;
156 uint8_t *id_block;
157 char *id_auth_base64;
158 uint8_t *id_auth;
159 char *host_data;
160
161 struct kvm_sev_snp_launch_start kvm_start_conf;
162 struct kvm_sev_snp_launch_finish kvm_finish_conf;
163
164 uint32_t kernel_hashes_offset;
165 PaddedSevHashTable *kernel_hashes_data;
166 };
167
168 #define DEFAULT_GUEST_POLICY 0x1 /* disable debug */
169 #define DEFAULT_SEV_DEVICE "/dev/sev"
170 #define DEFAULT_SEV_SNP_POLICY 0x30000
171
172 typedef struct SevLaunchUpdateData {
173 QTAILQ_ENTRY(SevLaunchUpdateData) next;
174 hwaddr gpa;
175 void *hva;
176 size_t len;
177 int type;
178 } SevLaunchUpdateData;
179
180 static QTAILQ_HEAD(, SevLaunchUpdateData) launch_update;
181
182 static Error *sev_mig_blocker;
183
184 static const char *const sev_fw_errlist[] = {
185 [SEV_RET_SUCCESS] = "",
186 [SEV_RET_INVALID_PLATFORM_STATE] = "Platform state is invalid",
187 [SEV_RET_INVALID_GUEST_STATE] = "Guest state is invalid",
188 [SEV_RET_INAVLID_CONFIG] = "Platform configuration is invalid",
189 [SEV_RET_INVALID_LEN] = "Buffer too small",
190 [SEV_RET_ALREADY_OWNED] = "Platform is already owned",
191 [SEV_RET_INVALID_CERTIFICATE] = "Certificate is invalid",
192 [SEV_RET_POLICY_FAILURE] = "Policy is not allowed",
193 [SEV_RET_INACTIVE] = "Guest is not active",
194 [SEV_RET_INVALID_ADDRESS] = "Invalid address",
195 [SEV_RET_BAD_SIGNATURE] = "Bad signature",
196 [SEV_RET_BAD_MEASUREMENT] = "Bad measurement",
197 [SEV_RET_ASID_OWNED] = "ASID is already owned",
198 [SEV_RET_INVALID_ASID] = "Invalid ASID",
199 [SEV_RET_WBINVD_REQUIRED] = "WBINVD is required",
200 [SEV_RET_DFFLUSH_REQUIRED] = "DF_FLUSH is required",
201 [SEV_RET_INVALID_GUEST] = "Guest handle is invalid",
202 [SEV_RET_INVALID_COMMAND] = "Invalid command",
203 [SEV_RET_ACTIVE] = "Guest is active",
204 [SEV_RET_HWSEV_RET_PLATFORM] = "Hardware error",
205 [SEV_RET_HWSEV_RET_UNSAFE] = "Hardware unsafe",
206 [SEV_RET_UNSUPPORTED] = "Feature not supported",
207 [SEV_RET_INVALID_PARAM] = "Invalid parameter",
208 [SEV_RET_RESOURCE_LIMIT] = "Required firmware resource depleted",
209 [SEV_RET_SECURE_DATA_INVALID] = "Part-specific integrity check failure",
210 };
211
212 #define SEV_FW_MAX_ERROR ARRAY_SIZE(sev_fw_errlist)
213
214 /* <linux/kvm.h> doesn't expose this, so re-use the max from kvm.c */
215 #define KVM_MAX_CPUID_ENTRIES 100
216
217 typedef struct KvmCpuidInfo {
218 struct kvm_cpuid2 cpuid;
219 struct kvm_cpuid_entry2 entries[KVM_MAX_CPUID_ENTRIES];
220 } KvmCpuidInfo;
221
222 #define SNP_CPUID_FUNCTION_MAXCOUNT 64
223 #define SNP_CPUID_FUNCTION_UNKNOWN 0xFFFFFFFF
224
225 typedef struct {
226 uint32_t eax_in;
227 uint32_t ecx_in;
228 uint64_t xcr0_in;
229 uint64_t xss_in;
230 uint32_t eax;
231 uint32_t ebx;
232 uint32_t ecx;
233 uint32_t edx;
234 uint64_t reserved;
235 } __attribute__((packed)) SnpCpuidFunc;
236
237 typedef struct {
238 uint32_t count;
239 uint32_t reserved1;
240 uint64_t reserved2;
241 SnpCpuidFunc entries[SNP_CPUID_FUNCTION_MAXCOUNT];
242 } __attribute__((packed)) SnpCpuidInfo;
243
244 static int
sev_ioctl(int fd,int cmd,void * data,int * error)245 sev_ioctl(int fd, int cmd, void *data, int *error)
246 {
247 int r;
248 struct kvm_sev_cmd input;
249
250 memset(&input, 0x0, sizeof(input));
251
252 input.id = cmd;
253 input.sev_fd = fd;
254 input.data = (uintptr_t)data;
255
256 r = kvm_vm_ioctl(kvm_state, KVM_MEMORY_ENCRYPT_OP, &input);
257
258 if (error) {
259 *error = input.error;
260 }
261
262 return r;
263 }
264
265 static int
sev_platform_ioctl(int fd,int cmd,void * data,int * error)266 sev_platform_ioctl(int fd, int cmd, void *data, int *error)
267 {
268 int r;
269 struct sev_issue_cmd arg;
270
271 arg.cmd = cmd;
272 arg.data = (unsigned long)data;
273 r = ioctl(fd, SEV_ISSUE_CMD, &arg);
274 if (error) {
275 *error = arg.error;
276 }
277
278 return r;
279 }
280
281 static const char *
fw_error_to_str(int code)282 fw_error_to_str(int code)
283 {
284 if (code < 0 || code >= SEV_FW_MAX_ERROR) {
285 return "unknown error";
286 }
287
288 return sev_fw_errlist[code];
289 }
290
291 static bool
sev_check_state(const SevCommonState * sev_common,SevState state)292 sev_check_state(const SevCommonState *sev_common, SevState state)
293 {
294 assert(sev_common);
295 return sev_common->state == state ? true : false;
296 }
297
298 static void
sev_set_guest_state(SevCommonState * sev_common,SevState new_state)299 sev_set_guest_state(SevCommonState *sev_common, SevState new_state)
300 {
301 assert(new_state < SEV_STATE__MAX);
302 assert(sev_common);
303
304 trace_kvm_sev_change_state(SevState_str(sev_common->state),
305 SevState_str(new_state));
306 sev_common->state = new_state;
307 }
308
309 static void
sev_ram_block_added(RAMBlockNotifier * n,void * host,size_t size,size_t max_size)310 sev_ram_block_added(RAMBlockNotifier *n, void *host, size_t size,
311 size_t max_size)
312 {
313 int r;
314 struct kvm_enc_region range;
315 ram_addr_t offset;
316 MemoryRegion *mr;
317
318 /*
319 * The RAM device presents a memory region that should be treated
320 * as IO region and should not be pinned.
321 */
322 mr = memory_region_from_host(host, &offset);
323 if (mr && memory_region_is_ram_device(mr)) {
324 return;
325 }
326
327 range.addr = (uintptr_t)host;
328 range.size = max_size;
329
330 trace_kvm_memcrypt_register_region(host, max_size);
331 r = kvm_vm_ioctl(kvm_state, KVM_MEMORY_ENCRYPT_REG_REGION, &range);
332 if (r) {
333 error_report("%s: failed to register region (%p+%#zx) error '%s'",
334 __func__, host, max_size, strerror(errno));
335 exit(1);
336 }
337 }
338
339 static void
sev_ram_block_removed(RAMBlockNotifier * n,void * host,size_t size,size_t max_size)340 sev_ram_block_removed(RAMBlockNotifier *n, void *host, size_t size,
341 size_t max_size)
342 {
343 int r;
344 struct kvm_enc_region range;
345 ram_addr_t offset;
346 MemoryRegion *mr;
347
348 /*
349 * The RAM device presents a memory region that should be treated
350 * as IO region and should not have been pinned.
351 */
352 mr = memory_region_from_host(host, &offset);
353 if (mr && memory_region_is_ram_device(mr)) {
354 return;
355 }
356
357 range.addr = (uintptr_t)host;
358 range.size = max_size;
359
360 trace_kvm_memcrypt_unregister_region(host, max_size);
361 r = kvm_vm_ioctl(kvm_state, KVM_MEMORY_ENCRYPT_UNREG_REGION, &range);
362 if (r) {
363 error_report("%s: failed to unregister region (%p+%#zx)",
364 __func__, host, max_size);
365 }
366 }
367
368 static struct RAMBlockNotifier sev_ram_notifier = {
369 .ram_block_added = sev_ram_block_added,
370 .ram_block_removed = sev_ram_block_removed,
371 };
372
373 bool
sev_enabled(void)374 sev_enabled(void)
375 {
376 ConfidentialGuestSupport *cgs = MACHINE(qdev_get_machine())->cgs;
377
378 return !!object_dynamic_cast(OBJECT(cgs), TYPE_SEV_COMMON);
379 }
380
381 bool
sev_snp_enabled(void)382 sev_snp_enabled(void)
383 {
384 ConfidentialGuestSupport *cgs = MACHINE(qdev_get_machine())->cgs;
385
386 return !!object_dynamic_cast(OBJECT(cgs), TYPE_SEV_SNP_GUEST);
387 }
388
389 bool
sev_es_enabled(void)390 sev_es_enabled(void)
391 {
392 ConfidentialGuestSupport *cgs = MACHINE(qdev_get_machine())->cgs;
393
394 return sev_snp_enabled() ||
395 (sev_enabled() && SEV_GUEST(cgs)->policy & SEV_POLICY_ES);
396 }
397
398 uint32_t
sev_get_cbit_position(void)399 sev_get_cbit_position(void)
400 {
401 SevCommonState *sev_common = SEV_COMMON(MACHINE(qdev_get_machine())->cgs);
402
403 return sev_common ? sev_common->cbitpos : 0;
404 }
405
406 uint32_t
sev_get_reduced_phys_bits(void)407 sev_get_reduced_phys_bits(void)
408 {
409 SevCommonState *sev_common = SEV_COMMON(MACHINE(qdev_get_machine())->cgs);
410
411 return sev_common ? sev_common->reduced_phys_bits : 0;
412 }
413
sev_get_info(void)414 static SevInfo *sev_get_info(void)
415 {
416 SevInfo *info;
417 SevCommonState *sev_common = SEV_COMMON(MACHINE(qdev_get_machine())->cgs);
418
419 info = g_new0(SevInfo, 1);
420 info->enabled = sev_enabled();
421
422 if (info->enabled) {
423 info->api_major = sev_common->api_major;
424 info->api_minor = sev_common->api_minor;
425 info->build_id = sev_common->build_id;
426 info->state = sev_common->state;
427
428 if (sev_snp_enabled()) {
429 info->sev_type = SEV_GUEST_TYPE_SEV_SNP;
430 info->u.sev_snp.snp_policy =
431 object_property_get_uint(OBJECT(sev_common), "policy", NULL);
432 } else {
433 info->sev_type = SEV_GUEST_TYPE_SEV;
434 info->u.sev.handle = SEV_GUEST(sev_common)->handle;
435 info->u.sev.policy =
436 (uint32_t)object_property_get_uint(OBJECT(sev_common),
437 "policy", NULL);
438 }
439 }
440
441 return info;
442 }
443
qmp_query_sev(Error ** errp)444 SevInfo *qmp_query_sev(Error **errp)
445 {
446 SevInfo *info;
447
448 info = sev_get_info();
449 if (!info) {
450 error_setg(errp, "SEV feature is not available");
451 return NULL;
452 }
453
454 return info;
455 }
456
hmp_info_sev(Monitor * mon,const QDict * qdict)457 void hmp_info_sev(Monitor *mon, const QDict *qdict)
458 {
459 SevInfo *info = sev_get_info();
460
461 if (!info || !info->enabled) {
462 monitor_printf(mon, "SEV is not enabled\n");
463 goto out;
464 }
465
466 monitor_printf(mon, "SEV type: %s\n", SevGuestType_str(info->sev_type));
467 monitor_printf(mon, "state: %s\n", SevState_str(info->state));
468 monitor_printf(mon, "build: %d\n", info->build_id);
469 monitor_printf(mon, "api version: %d.%d\n", info->api_major,
470 info->api_minor);
471
472 if (sev_snp_enabled()) {
473 monitor_printf(mon, "debug: %s\n",
474 info->u.sev_snp.snp_policy & SEV_SNP_POLICY_DBG ? "on"
475 : "off");
476 monitor_printf(mon, "SMT allowed: %s\n",
477 info->u.sev_snp.snp_policy & SEV_SNP_POLICY_SMT ? "on"
478 : "off");
479 } else {
480 monitor_printf(mon, "handle: %d\n", info->u.sev.handle);
481 monitor_printf(mon, "debug: %s\n",
482 info->u.sev.policy & SEV_POLICY_NODBG ? "off" : "on");
483 monitor_printf(mon, "key-sharing: %s\n",
484 info->u.sev.policy & SEV_POLICY_NOKS ? "off" : "on");
485 }
486
487 out:
488 qapi_free_SevInfo(info);
489 }
490
491 static int
sev_get_pdh_info(int fd,guchar ** pdh,size_t * pdh_len,guchar ** cert_chain,size_t * cert_chain_len,Error ** errp)492 sev_get_pdh_info(int fd, guchar **pdh, size_t *pdh_len, guchar **cert_chain,
493 size_t *cert_chain_len, Error **errp)
494 {
495 guchar *pdh_data = NULL;
496 guchar *cert_chain_data = NULL;
497 struct sev_user_data_pdh_cert_export export = {};
498 int err, r;
499
500 /* query the certificate length */
501 r = sev_platform_ioctl(fd, SEV_PDH_CERT_EXPORT, &export, &err);
502 if (r < 0) {
503 if (err != SEV_RET_INVALID_LEN) {
504 error_setg(errp, "SEV: Failed to export PDH cert"
505 " ret=%d fw_err=%d (%s)",
506 r, err, fw_error_to_str(err));
507 return 1;
508 }
509 }
510
511 pdh_data = g_new(guchar, export.pdh_cert_len);
512 cert_chain_data = g_new(guchar, export.cert_chain_len);
513 export.pdh_cert_address = (unsigned long)pdh_data;
514 export.cert_chain_address = (unsigned long)cert_chain_data;
515
516 r = sev_platform_ioctl(fd, SEV_PDH_CERT_EXPORT, &export, &err);
517 if (r < 0) {
518 error_setg(errp, "SEV: Failed to export PDH cert ret=%d fw_err=%d (%s)",
519 r, err, fw_error_to_str(err));
520 goto e_free;
521 }
522
523 *pdh = pdh_data;
524 *pdh_len = export.pdh_cert_len;
525 *cert_chain = cert_chain_data;
526 *cert_chain_len = export.cert_chain_len;
527 return 0;
528
529 e_free:
530 g_free(pdh_data);
531 g_free(cert_chain_data);
532 return 1;
533 }
534
sev_get_cpu0_id(int fd,guchar ** id,size_t * id_len,Error ** errp)535 static int sev_get_cpu0_id(int fd, guchar **id, size_t *id_len, Error **errp)
536 {
537 guchar *id_data;
538 struct sev_user_data_get_id2 get_id2 = {};
539 int err, r;
540
541 /* query the ID length */
542 r = sev_platform_ioctl(fd, SEV_GET_ID2, &get_id2, &err);
543 if (r < 0 && err != SEV_RET_INVALID_LEN) {
544 error_setg(errp, "SEV: Failed to get ID ret=%d fw_err=%d (%s)",
545 r, err, fw_error_to_str(err));
546 return 1;
547 }
548
549 id_data = g_new(guchar, get_id2.length);
550 get_id2.address = (unsigned long)id_data;
551
552 r = sev_platform_ioctl(fd, SEV_GET_ID2, &get_id2, &err);
553 if (r < 0) {
554 error_setg(errp, "SEV: Failed to get ID ret=%d fw_err=%d (%s)",
555 r, err, fw_error_to_str(err));
556 goto err;
557 }
558
559 *id = id_data;
560 *id_len = get_id2.length;
561 return 0;
562
563 err:
564 g_free(id_data);
565 return 1;
566 }
567
sev_get_capabilities(Error ** errp)568 static SevCapability *sev_get_capabilities(Error **errp)
569 {
570 SevCapability *cap = NULL;
571 guchar *pdh_data = NULL;
572 guchar *cert_chain_data = NULL;
573 guchar *cpu0_id_data = NULL;
574 size_t pdh_len = 0, cert_chain_len = 0, cpu0_id_len = 0;
575 uint32_t ebx;
576 int fd;
577 SevCommonState *sev_common;
578 char *sev_device;
579
580 if (!kvm_enabled()) {
581 error_setg(errp, "KVM not enabled");
582 return NULL;
583 }
584 if (kvm_vm_ioctl(kvm_state, KVM_MEMORY_ENCRYPT_OP, NULL) < 0) {
585 error_setg(errp, "SEV is not enabled in KVM");
586 return NULL;
587 }
588
589 sev_common = SEV_COMMON(MACHINE(qdev_get_machine())->cgs);
590 if (sev_common) {
591 sev_device = object_property_get_str(OBJECT(sev_common), "sev-device",
592 &error_abort);
593 } else {
594 sev_device = g_strdup(DEFAULT_SEV_DEVICE);
595 }
596
597 fd = open(sev_device, O_RDWR);
598 if (fd < 0) {
599 error_setg_errno(errp, errno, "SEV: Failed to open %s",
600 sev_device);
601 g_free(sev_device);
602 return NULL;
603 }
604 g_free(sev_device);
605
606 if (sev_get_pdh_info(fd, &pdh_data, &pdh_len,
607 &cert_chain_data, &cert_chain_len, errp)) {
608 goto out;
609 }
610
611 if (sev_get_cpu0_id(fd, &cpu0_id_data, &cpu0_id_len, errp)) {
612 goto out;
613 }
614
615 cap = g_new0(SevCapability, 1);
616 cap->pdh = g_base64_encode(pdh_data, pdh_len);
617 cap->cert_chain = g_base64_encode(cert_chain_data, cert_chain_len);
618 cap->cpu0_id = g_base64_encode(cpu0_id_data, cpu0_id_len);
619
620 host_cpuid(0x8000001F, 0, NULL, &ebx, NULL, NULL);
621 cap->cbitpos = ebx & 0x3f;
622
623 /*
624 * When SEV feature is enabled, we loose one bit in guest physical
625 * addressing.
626 */
627 cap->reduced_phys_bits = 1;
628
629 out:
630 g_free(cpu0_id_data);
631 g_free(pdh_data);
632 g_free(cert_chain_data);
633 close(fd);
634 return cap;
635 }
636
qmp_query_sev_capabilities(Error ** errp)637 SevCapability *qmp_query_sev_capabilities(Error **errp)
638 {
639 return sev_get_capabilities(errp);
640 }
641
642 static OvmfSevMetadata *ovmf_sev_metadata_table;
643
644 #define OVMF_SEV_META_DATA_GUID "dc886566-984a-4798-A75e-5585a7bf67cc"
645 typedef struct __attribute__((__packed__)) OvmfSevMetadataOffset {
646 uint32_t offset;
647 } OvmfSevMetadataOffset;
648
pc_system_get_ovmf_sev_metadata_ptr(void)649 OvmfSevMetadata *pc_system_get_ovmf_sev_metadata_ptr(void)
650 {
651 return ovmf_sev_metadata_table;
652 }
653
pc_system_parse_sev_metadata(uint8_t * flash_ptr,size_t flash_size)654 void pc_system_parse_sev_metadata(uint8_t *flash_ptr, size_t flash_size)
655 {
656 OvmfSevMetadata *metadata;
657 OvmfSevMetadataOffset *data;
658
659 if (!pc_system_ovmf_table_find(OVMF_SEV_META_DATA_GUID, (uint8_t **)&data,
660 NULL)) {
661 return;
662 }
663
664 metadata = (OvmfSevMetadata *)(flash_ptr + flash_size - data->offset);
665 if (memcmp(metadata->signature, "ASEV", 4) != 0 ||
666 metadata->len < sizeof(OvmfSevMetadata) ||
667 metadata->len > flash_size - data->offset) {
668 return;
669 }
670
671 ovmf_sev_metadata_table = g_memdup2(metadata, metadata->len);
672 }
673
sev_get_attestation_report(const char * mnonce,Error ** errp)674 static SevAttestationReport *sev_get_attestation_report(const char *mnonce,
675 Error **errp)
676 {
677 struct kvm_sev_attestation_report input = {};
678 SevAttestationReport *report = NULL;
679 SevCommonState *sev_common;
680 g_autofree guchar *data = NULL;
681 g_autofree guchar *buf = NULL;
682 gsize len;
683 int err = 0, ret;
684
685 if (!sev_enabled()) {
686 error_setg(errp, "SEV is not enabled");
687 return NULL;
688 }
689
690 /* lets decode the mnonce string */
691 buf = g_base64_decode(mnonce, &len);
692 if (!buf) {
693 error_setg(errp, "SEV: failed to decode mnonce input");
694 return NULL;
695 }
696
697 /* verify the input mnonce length */
698 if (len != sizeof(input.mnonce)) {
699 error_setg(errp, "SEV: mnonce must be %zu bytes (got %" G_GSIZE_FORMAT ")",
700 sizeof(input.mnonce), len);
701 return NULL;
702 }
703
704 sev_common = SEV_COMMON(MACHINE(qdev_get_machine())->cgs);
705
706 /* Query the report length */
707 ret = sev_ioctl(sev_common->sev_fd, KVM_SEV_GET_ATTESTATION_REPORT,
708 &input, &err);
709 if (ret < 0) {
710 if (err != SEV_RET_INVALID_LEN) {
711 error_setg(errp, "SEV: Failed to query the attestation report"
712 " length ret=%d fw_err=%d (%s)",
713 ret, err, fw_error_to_str(err));
714 return NULL;
715 }
716 }
717
718 data = g_malloc(input.len);
719 input.uaddr = (unsigned long)data;
720 memcpy(input.mnonce, buf, sizeof(input.mnonce));
721
722 /* Query the report */
723 ret = sev_ioctl(sev_common->sev_fd, KVM_SEV_GET_ATTESTATION_REPORT,
724 &input, &err);
725 if (ret) {
726 error_setg_errno(errp, errno, "SEV: Failed to get attestation report"
727 " ret=%d fw_err=%d (%s)", ret, err, fw_error_to_str(err));
728 return NULL;
729 }
730
731 report = g_new0(SevAttestationReport, 1);
732 report->data = g_base64_encode(data, input.len);
733
734 trace_kvm_sev_attestation_report(mnonce, report->data);
735
736 return report;
737 }
738
qmp_query_sev_attestation_report(const char * mnonce,Error ** errp)739 SevAttestationReport *qmp_query_sev_attestation_report(const char *mnonce,
740 Error **errp)
741 {
742 return sev_get_attestation_report(mnonce, errp);
743 }
744
745 static int
sev_read_file_base64(const char * filename,guchar ** data,gsize * len)746 sev_read_file_base64(const char *filename, guchar **data, gsize *len)
747 {
748 gsize sz;
749 g_autofree gchar *base64 = NULL;
750 GError *error = NULL;
751
752 if (!g_file_get_contents(filename, &base64, &sz, &error)) {
753 error_report("SEV: Failed to read '%s' (%s)", filename, error->message);
754 g_error_free(error);
755 return -1;
756 }
757
758 *data = g_base64_decode(base64, len);
759 return 0;
760 }
761
762 static int
sev_snp_launch_start(SevCommonState * sev_common)763 sev_snp_launch_start(SevCommonState *sev_common)
764 {
765 int fw_error, rc;
766 SevSnpGuestState *sev_snp_guest = SEV_SNP_GUEST(sev_common);
767 struct kvm_sev_snp_launch_start *start = &sev_snp_guest->kvm_start_conf;
768
769 trace_kvm_sev_snp_launch_start(start->policy,
770 sev_snp_guest->guest_visible_workarounds);
771
772 if (!kvm_enable_hypercall(BIT_ULL(KVM_HC_MAP_GPA_RANGE))) {
773 return 1;
774 }
775
776 rc = sev_ioctl(sev_common->sev_fd, KVM_SEV_SNP_LAUNCH_START,
777 start, &fw_error);
778 if (rc < 0) {
779 error_report("%s: SNP_LAUNCH_START ret=%d fw_error=%d '%s'",
780 __func__, rc, fw_error, fw_error_to_str(fw_error));
781 return 1;
782 }
783
784 QTAILQ_INIT(&launch_update);
785
786 sev_set_guest_state(sev_common, SEV_STATE_LAUNCH_UPDATE);
787
788 return 0;
789 }
790
791 static int
sev_launch_start(SevCommonState * sev_common)792 sev_launch_start(SevCommonState *sev_common)
793 {
794 gsize sz;
795 int ret = 1;
796 int fw_error, rc;
797 SevGuestState *sev_guest = SEV_GUEST(sev_common);
798 struct kvm_sev_launch_start start = {
799 .handle = sev_guest->handle, .policy = sev_guest->policy
800 };
801 guchar *session = NULL, *dh_cert = NULL;
802
803 if (sev_guest->session_file) {
804 if (sev_read_file_base64(sev_guest->session_file, &session, &sz) < 0) {
805 goto out;
806 }
807 start.session_uaddr = (unsigned long)session;
808 start.session_len = sz;
809 }
810
811 if (sev_guest->dh_cert_file) {
812 if (sev_read_file_base64(sev_guest->dh_cert_file, &dh_cert, &sz) < 0) {
813 goto out;
814 }
815 start.dh_uaddr = (unsigned long)dh_cert;
816 start.dh_len = sz;
817 }
818
819 trace_kvm_sev_launch_start(start.policy, session, dh_cert);
820 rc = sev_ioctl(sev_common->sev_fd, KVM_SEV_LAUNCH_START, &start, &fw_error);
821 if (rc < 0) {
822 error_report("%s: LAUNCH_START ret=%d fw_error=%d '%s'",
823 __func__, ret, fw_error, fw_error_to_str(fw_error));
824 goto out;
825 }
826
827 sev_set_guest_state(sev_common, SEV_STATE_LAUNCH_UPDATE);
828 sev_guest->handle = start.handle;
829 ret = 0;
830
831 out:
832 g_free(session);
833 g_free(dh_cert);
834 return ret;
835 }
836
837 static void
sev_snp_cpuid_report_mismatches(SnpCpuidInfo * old,SnpCpuidInfo * new)838 sev_snp_cpuid_report_mismatches(SnpCpuidInfo *old,
839 SnpCpuidInfo *new)
840 {
841 size_t i;
842
843 if (old->count != new->count) {
844 error_report("SEV-SNP: CPUID validation failed due to count mismatch, "
845 "provided: %d, expected: %d", old->count, new->count);
846 return;
847 }
848
849 for (i = 0; i < old->count; i++) {
850 SnpCpuidFunc *old_func, *new_func;
851
852 old_func = &old->entries[i];
853 new_func = &new->entries[i];
854
855 if (memcmp(old_func, new_func, sizeof(SnpCpuidFunc))) {
856 error_report("SEV-SNP: CPUID validation failed for function 0x%x, index: 0x%x, "
857 "provided: eax:0x%08x, ebx: 0x%08x, ecx: 0x%08x, edx: 0x%08x, "
858 "expected: eax:0x%08x, ebx: 0x%08x, ecx: 0x%08x, edx: 0x%08x",
859 old_func->eax_in, old_func->ecx_in,
860 old_func->eax, old_func->ebx, old_func->ecx, old_func->edx,
861 new_func->eax, new_func->ebx, new_func->ecx, new_func->edx);
862 }
863 }
864 }
865
866 static const char *
snp_page_type_to_str(int type)867 snp_page_type_to_str(int type)
868 {
869 switch (type) {
870 case KVM_SEV_SNP_PAGE_TYPE_NORMAL: return "Normal";
871 case KVM_SEV_SNP_PAGE_TYPE_ZERO: return "Zero";
872 case KVM_SEV_SNP_PAGE_TYPE_UNMEASURED: return "Unmeasured";
873 case KVM_SEV_SNP_PAGE_TYPE_SECRETS: return "Secrets";
874 case KVM_SEV_SNP_PAGE_TYPE_CPUID: return "Cpuid";
875 default: return "unknown";
876 }
877 }
878
879 static int
sev_snp_launch_update(SevSnpGuestState * sev_snp_guest,SevLaunchUpdateData * data)880 sev_snp_launch_update(SevSnpGuestState *sev_snp_guest,
881 SevLaunchUpdateData *data)
882 {
883 int ret, fw_error;
884 SnpCpuidInfo snp_cpuid_info;
885 struct kvm_sev_snp_launch_update update = {0};
886
887 if (!data->hva || !data->len) {
888 error_report("SNP_LAUNCH_UPDATE called with invalid address"
889 "/ length: %p / %zx",
890 data->hva, data->len);
891 return 1;
892 }
893
894 if (data->type == KVM_SEV_SNP_PAGE_TYPE_CPUID) {
895 /* Save a copy for comparison in case the LAUNCH_UPDATE fails */
896 memcpy(&snp_cpuid_info, data->hva, sizeof(snp_cpuid_info));
897 }
898
899 update.uaddr = (__u64)(unsigned long)data->hva;
900 update.gfn_start = data->gpa >> TARGET_PAGE_BITS;
901 update.len = data->len;
902 update.type = data->type;
903
904 /*
905 * KVM_SEV_SNP_LAUNCH_UPDATE requires that GPA ranges have the private
906 * memory attribute set in advance.
907 */
908 ret = kvm_set_memory_attributes_private(data->gpa, data->len);
909 if (ret) {
910 error_report("SEV-SNP: failed to configure initial"
911 "private guest memory");
912 goto out;
913 }
914
915 while (update.len || ret == -EAGAIN) {
916 trace_kvm_sev_snp_launch_update(update.uaddr, update.gfn_start <<
917 TARGET_PAGE_BITS, update.len,
918 snp_page_type_to_str(update.type));
919
920 ret = sev_ioctl(SEV_COMMON(sev_snp_guest)->sev_fd,
921 KVM_SEV_SNP_LAUNCH_UPDATE,
922 &update, &fw_error);
923 if (ret && ret != -EAGAIN) {
924 error_report("SNP_LAUNCH_UPDATE ret=%d fw_error=%d '%s'",
925 ret, fw_error, fw_error_to_str(fw_error));
926
927 if (data->type == KVM_SEV_SNP_PAGE_TYPE_CPUID) {
928 sev_snp_cpuid_report_mismatches(&snp_cpuid_info, data->hva);
929 error_report("SEV-SNP: failed update CPUID page");
930 }
931 break;
932 }
933 }
934
935 out:
936 if (!ret && update.gfn_start << TARGET_PAGE_BITS != data->gpa + data->len) {
937 error_report("SEV-SNP: expected update of GPA range %"
938 HWADDR_PRIx "-%" HWADDR_PRIx ","
939 "got GPA range %" HWADDR_PRIx "-%llx",
940 data->gpa, data->gpa + data->len, data->gpa,
941 update.gfn_start << TARGET_PAGE_BITS);
942 ret = -EIO;
943 }
944
945 return ret;
946 }
947
948 static uint32_t
sev_snp_mask_cpuid_features(X86ConfidentialGuest * cg,uint32_t feature,uint32_t index,int reg,uint32_t value)949 sev_snp_mask_cpuid_features(X86ConfidentialGuest *cg, uint32_t feature, uint32_t index,
950 int reg, uint32_t value)
951 {
952 switch (feature) {
953 case 1:
954 if (reg == R_ECX) {
955 return value & ~CPUID_EXT_TSC_DEADLINE_TIMER;
956 }
957 break;
958 case 7:
959 if (index == 0 && reg == R_EBX) {
960 return value & ~CPUID_7_0_EBX_TSC_ADJUST;
961 }
962 if (index == 0 && reg == R_EDX) {
963 return value & ~(CPUID_7_0_EDX_SPEC_CTRL |
964 CPUID_7_0_EDX_STIBP |
965 CPUID_7_0_EDX_FLUSH_L1D |
966 CPUID_7_0_EDX_ARCH_CAPABILITIES |
967 CPUID_7_0_EDX_CORE_CAPABILITY |
968 CPUID_7_0_EDX_SPEC_CTRL_SSBD);
969 }
970 break;
971 case 0x80000008:
972 if (reg == R_EBX) {
973 return value & ~CPUID_8000_0008_EBX_VIRT_SSBD;
974 }
975 break;
976 }
977 return value;
978 }
979
980 static int
sev_launch_update_data(SevCommonState * sev_common,hwaddr gpa,uint8_t * addr,size_t len)981 sev_launch_update_data(SevCommonState *sev_common, hwaddr gpa,
982 uint8_t *addr, size_t len)
983 {
984 int ret, fw_error;
985 struct kvm_sev_launch_update_data update;
986
987 if (!addr || !len) {
988 return 1;
989 }
990
991 update.uaddr = (uintptr_t)addr;
992 update.len = len;
993 trace_kvm_sev_launch_update_data(addr, len);
994 ret = sev_ioctl(sev_common->sev_fd, KVM_SEV_LAUNCH_UPDATE_DATA,
995 &update, &fw_error);
996 if (ret) {
997 error_report("%s: LAUNCH_UPDATE ret=%d fw_error=%d '%s'",
998 __func__, ret, fw_error, fw_error_to_str(fw_error));
999 }
1000
1001 return ret;
1002 }
1003
1004 static int
sev_launch_update_vmsa(SevGuestState * sev_guest)1005 sev_launch_update_vmsa(SevGuestState *sev_guest)
1006 {
1007 int ret, fw_error;
1008
1009 ret = sev_ioctl(SEV_COMMON(sev_guest)->sev_fd, KVM_SEV_LAUNCH_UPDATE_VMSA,
1010 NULL, &fw_error);
1011 if (ret) {
1012 error_report("%s: LAUNCH_UPDATE_VMSA ret=%d fw_error=%d '%s'",
1013 __func__, ret, fw_error, fw_error_to_str(fw_error));
1014 }
1015
1016 return ret;
1017 }
1018
1019 static void
sev_launch_get_measure(Notifier * notifier,void * unused)1020 sev_launch_get_measure(Notifier *notifier, void *unused)
1021 {
1022 SevCommonState *sev_common = SEV_COMMON(MACHINE(qdev_get_machine())->cgs);
1023 SevGuestState *sev_guest = SEV_GUEST(sev_common);
1024 int ret, error;
1025 g_autofree guchar *data = NULL;
1026 struct kvm_sev_launch_measure measurement = {};
1027
1028 if (!sev_check_state(sev_common, SEV_STATE_LAUNCH_UPDATE)) {
1029 return;
1030 }
1031
1032 if (sev_es_enabled()) {
1033 /* measure all the VM save areas before getting launch_measure */
1034 ret = sev_launch_update_vmsa(sev_guest);
1035 if (ret) {
1036 exit(1);
1037 }
1038 kvm_mark_guest_state_protected();
1039 }
1040
1041 /* query the measurement blob length */
1042 ret = sev_ioctl(sev_common->sev_fd, KVM_SEV_LAUNCH_MEASURE,
1043 &measurement, &error);
1044 if (!measurement.len) {
1045 error_report("%s: LAUNCH_MEASURE ret=%d fw_error=%d '%s'",
1046 __func__, ret, error, fw_error_to_str(errno));
1047 return;
1048 }
1049
1050 data = g_new0(guchar, measurement.len);
1051 measurement.uaddr = (unsigned long)data;
1052
1053 /* get the measurement blob */
1054 ret = sev_ioctl(sev_common->sev_fd, KVM_SEV_LAUNCH_MEASURE,
1055 &measurement, &error);
1056 if (ret) {
1057 error_report("%s: LAUNCH_MEASURE ret=%d fw_error=%d '%s'",
1058 __func__, ret, error, fw_error_to_str(errno));
1059 return;
1060 }
1061
1062 sev_set_guest_state(sev_common, SEV_STATE_LAUNCH_SECRET);
1063
1064 /* encode the measurement value and emit the event */
1065 sev_guest->measurement = g_base64_encode(data, measurement.len);
1066 trace_kvm_sev_launch_measurement(sev_guest->measurement);
1067 }
1068
sev_get_launch_measurement(void)1069 static char *sev_get_launch_measurement(void)
1070 {
1071 ConfidentialGuestSupport *cgs = MACHINE(qdev_get_machine())->cgs;
1072 SevGuestState *sev_guest =
1073 (SevGuestState *)object_dynamic_cast(OBJECT(cgs), TYPE_SEV_GUEST);
1074
1075 if (sev_guest &&
1076 SEV_COMMON(sev_guest)->state >= SEV_STATE_LAUNCH_SECRET) {
1077 return g_strdup(sev_guest->measurement);
1078 }
1079
1080 return NULL;
1081 }
1082
qmp_query_sev_launch_measure(Error ** errp)1083 SevLaunchMeasureInfo *qmp_query_sev_launch_measure(Error **errp)
1084 {
1085 char *data;
1086 SevLaunchMeasureInfo *info;
1087
1088 data = sev_get_launch_measurement();
1089 if (!data) {
1090 error_setg(errp, "SEV launch measurement is not available");
1091 return NULL;
1092 }
1093
1094 info = g_malloc0(sizeof(*info));
1095 info->data = data;
1096
1097 return info;
1098 }
1099
1100 static Notifier sev_machine_done_notify = {
1101 .notify = sev_launch_get_measure,
1102 };
1103
1104 static void
sev_launch_finish(SevCommonState * sev_common)1105 sev_launch_finish(SevCommonState *sev_common)
1106 {
1107 int ret, error;
1108
1109 trace_kvm_sev_launch_finish();
1110 ret = sev_ioctl(sev_common->sev_fd, KVM_SEV_LAUNCH_FINISH, 0,
1111 &error);
1112 if (ret) {
1113 error_report("%s: LAUNCH_FINISH ret=%d fw_error=%d '%s'",
1114 __func__, ret, error, fw_error_to_str(error));
1115 exit(1);
1116 }
1117
1118 sev_set_guest_state(sev_common, SEV_STATE_RUNNING);
1119
1120 /* add migration blocker */
1121 error_setg(&sev_mig_blocker,
1122 "SEV: Migration is not implemented");
1123 migrate_add_blocker(&sev_mig_blocker, &error_fatal);
1124 }
1125
1126 static int
snp_launch_update_data(uint64_t gpa,void * hva,size_t len,int type)1127 snp_launch_update_data(uint64_t gpa, void *hva, size_t len, int type)
1128 {
1129 SevLaunchUpdateData *data;
1130
1131 data = g_new0(SevLaunchUpdateData, 1);
1132 data->gpa = gpa;
1133 data->hva = hva;
1134 data->len = len;
1135 data->type = type;
1136
1137 QTAILQ_INSERT_TAIL(&launch_update, data, next);
1138
1139 return 0;
1140 }
1141
1142 static int
sev_snp_launch_update_data(SevCommonState * sev_common,hwaddr gpa,uint8_t * ptr,size_t len)1143 sev_snp_launch_update_data(SevCommonState *sev_common, hwaddr gpa,
1144 uint8_t *ptr, size_t len)
1145 {
1146 int ret = snp_launch_update_data(gpa, ptr, len,
1147 KVM_SEV_SNP_PAGE_TYPE_NORMAL);
1148 return ret;
1149 }
1150
1151 static int
sev_snp_cpuid_info_fill(SnpCpuidInfo * snp_cpuid_info,const KvmCpuidInfo * kvm_cpuid_info)1152 sev_snp_cpuid_info_fill(SnpCpuidInfo *snp_cpuid_info,
1153 const KvmCpuidInfo *kvm_cpuid_info)
1154 {
1155 size_t i;
1156
1157 if (kvm_cpuid_info->cpuid.nent > SNP_CPUID_FUNCTION_MAXCOUNT) {
1158 error_report("SEV-SNP: CPUID entry count (%d) exceeds max (%d)",
1159 kvm_cpuid_info->cpuid.nent, SNP_CPUID_FUNCTION_MAXCOUNT);
1160 return -1;
1161 }
1162
1163 memset(snp_cpuid_info, 0, sizeof(*snp_cpuid_info));
1164
1165 for (i = 0; i < kvm_cpuid_info->cpuid.nent; i++) {
1166 const struct kvm_cpuid_entry2 *kvm_cpuid_entry;
1167 SnpCpuidFunc *snp_cpuid_entry;
1168
1169 kvm_cpuid_entry = &kvm_cpuid_info->entries[i];
1170 snp_cpuid_entry = &snp_cpuid_info->entries[i];
1171
1172 snp_cpuid_entry->eax_in = kvm_cpuid_entry->function;
1173 if (kvm_cpuid_entry->flags == KVM_CPUID_FLAG_SIGNIFCANT_INDEX) {
1174 snp_cpuid_entry->ecx_in = kvm_cpuid_entry->index;
1175 }
1176 snp_cpuid_entry->eax = kvm_cpuid_entry->eax;
1177 snp_cpuid_entry->ebx = kvm_cpuid_entry->ebx;
1178 snp_cpuid_entry->ecx = kvm_cpuid_entry->ecx;
1179 snp_cpuid_entry->edx = kvm_cpuid_entry->edx;
1180
1181 /*
1182 * Guest kernels will calculate EBX themselves using the 0xD
1183 * subfunctions corresponding to the individual XSAVE areas, so only
1184 * encode the base XSAVE size in the initial leaves, corresponding
1185 * to the initial XCR0=1 state.
1186 */
1187 if (snp_cpuid_entry->eax_in == 0xD &&
1188 (snp_cpuid_entry->ecx_in == 0x0 || snp_cpuid_entry->ecx_in == 0x1)) {
1189 snp_cpuid_entry->ebx = 0x240;
1190 snp_cpuid_entry->xcr0_in = 1;
1191 snp_cpuid_entry->xss_in = 0;
1192 }
1193 }
1194
1195 snp_cpuid_info->count = i;
1196
1197 return 0;
1198 }
1199
1200 static int
snp_launch_update_cpuid(uint32_t cpuid_addr,void * hva,size_t cpuid_len)1201 snp_launch_update_cpuid(uint32_t cpuid_addr, void *hva, size_t cpuid_len)
1202 {
1203 KvmCpuidInfo kvm_cpuid_info = {0};
1204 SnpCpuidInfo snp_cpuid_info;
1205 CPUState *cs = first_cpu;
1206 int ret;
1207 uint32_t i = 0;
1208
1209 assert(sizeof(snp_cpuid_info) <= cpuid_len);
1210
1211 /* get the cpuid list from KVM */
1212 do {
1213 kvm_cpuid_info.cpuid.nent = ++i;
1214 ret = kvm_vcpu_ioctl(cs, KVM_GET_CPUID2, &kvm_cpuid_info);
1215 } while (ret == -E2BIG);
1216
1217 if (ret) {
1218 error_report("SEV-SNP: unable to query CPUID values for CPU: '%s'",
1219 strerror(-ret));
1220 return 1;
1221 }
1222
1223 ret = sev_snp_cpuid_info_fill(&snp_cpuid_info, &kvm_cpuid_info);
1224 if (ret) {
1225 error_report("SEV-SNP: failed to generate CPUID table information");
1226 return 1;
1227 }
1228
1229 memcpy(hva, &snp_cpuid_info, sizeof(snp_cpuid_info));
1230
1231 return snp_launch_update_data(cpuid_addr, hva, cpuid_len,
1232 KVM_SEV_SNP_PAGE_TYPE_CPUID);
1233 }
1234
1235 static int
snp_launch_update_kernel_hashes(SevSnpGuestState * sev_snp,uint32_t addr,void * hva,uint32_t len)1236 snp_launch_update_kernel_hashes(SevSnpGuestState *sev_snp, uint32_t addr,
1237 void *hva, uint32_t len)
1238 {
1239 int type = KVM_SEV_SNP_PAGE_TYPE_ZERO;
1240 if (sev_snp->parent_obj.kernel_hashes) {
1241 assert(sev_snp->kernel_hashes_data);
1242 assert((sev_snp->kernel_hashes_offset +
1243 sizeof(*sev_snp->kernel_hashes_data)) <= len);
1244 memset(hva, 0, len);
1245 memcpy(hva + sev_snp->kernel_hashes_offset, sev_snp->kernel_hashes_data,
1246 sizeof(*sev_snp->kernel_hashes_data));
1247 type = KVM_SEV_SNP_PAGE_TYPE_NORMAL;
1248 }
1249 return snp_launch_update_data(addr, hva, len, type);
1250 }
1251
1252 static int
snp_metadata_desc_to_page_type(int desc_type)1253 snp_metadata_desc_to_page_type(int desc_type)
1254 {
1255 switch (desc_type) {
1256 /* Add the umeasured prevalidated pages as a zero page */
1257 case SEV_DESC_TYPE_SNP_SEC_MEM: return KVM_SEV_SNP_PAGE_TYPE_ZERO;
1258 case SEV_DESC_TYPE_SNP_SECRETS: return KVM_SEV_SNP_PAGE_TYPE_SECRETS;
1259 case SEV_DESC_TYPE_CPUID: return KVM_SEV_SNP_PAGE_TYPE_CPUID;
1260 default:
1261 return KVM_SEV_SNP_PAGE_TYPE_ZERO;
1262 }
1263 }
1264
1265 static void
snp_populate_metadata_pages(SevSnpGuestState * sev_snp,OvmfSevMetadata * metadata)1266 snp_populate_metadata_pages(SevSnpGuestState *sev_snp,
1267 OvmfSevMetadata *metadata)
1268 {
1269 OvmfSevMetadataDesc *desc;
1270 int type, ret, i;
1271 void *hva;
1272 MemoryRegion *mr = NULL;
1273
1274 for (i = 0; i < metadata->num_desc; i++) {
1275 desc = &metadata->descs[i];
1276
1277 type = snp_metadata_desc_to_page_type(desc->type);
1278
1279 hva = gpa2hva(&mr, desc->base, desc->len, NULL);
1280 if (!hva) {
1281 error_report("%s: Failed to get HVA for GPA 0x%x sz 0x%x",
1282 __func__, desc->base, desc->len);
1283 exit(1);
1284 }
1285
1286 if (type == KVM_SEV_SNP_PAGE_TYPE_CPUID) {
1287 ret = snp_launch_update_cpuid(desc->base, hva, desc->len);
1288 } else if (desc->type == SEV_DESC_TYPE_SNP_KERNEL_HASHES) {
1289 ret = snp_launch_update_kernel_hashes(sev_snp, desc->base, hva,
1290 desc->len);
1291 } else {
1292 ret = snp_launch_update_data(desc->base, hva, desc->len, type);
1293 }
1294
1295 if (ret) {
1296 error_report("%s: Failed to add metadata page gpa 0x%x+%x type %d",
1297 __func__, desc->base, desc->len, desc->type);
1298 exit(1);
1299 }
1300 }
1301 }
1302
1303 static void
sev_snp_launch_finish(SevCommonState * sev_common)1304 sev_snp_launch_finish(SevCommonState *sev_common)
1305 {
1306 int ret, error;
1307 Error *local_err = NULL;
1308 OvmfSevMetadata *metadata;
1309 SevLaunchUpdateData *data;
1310 SevSnpGuestState *sev_snp = SEV_SNP_GUEST(sev_common);
1311 struct kvm_sev_snp_launch_finish *finish = &sev_snp->kvm_finish_conf;
1312
1313 /*
1314 * To boot the SNP guest, the hypervisor is required to populate the CPUID
1315 * and Secrets page before finalizing the launch flow. The location of
1316 * the secrets and CPUID page is available through the OVMF metadata GUID.
1317 */
1318 metadata = pc_system_get_ovmf_sev_metadata_ptr();
1319 if (metadata == NULL) {
1320 error_report("%s: Failed to locate SEV metadata header", __func__);
1321 exit(1);
1322 }
1323
1324 /* Populate all the metadata pages */
1325 snp_populate_metadata_pages(sev_snp, metadata);
1326
1327 QTAILQ_FOREACH(data, &launch_update, next) {
1328 ret = sev_snp_launch_update(sev_snp, data);
1329 if (ret) {
1330 exit(1);
1331 }
1332 }
1333
1334 trace_kvm_sev_snp_launch_finish(sev_snp->id_block_base64, sev_snp->id_auth_base64,
1335 sev_snp->host_data);
1336 ret = sev_ioctl(sev_common->sev_fd, KVM_SEV_SNP_LAUNCH_FINISH,
1337 finish, &error);
1338 if (ret) {
1339 error_report("SNP_LAUNCH_FINISH ret=%d fw_error=%d '%s'",
1340 ret, error, fw_error_to_str(error));
1341 exit(1);
1342 }
1343
1344 kvm_mark_guest_state_protected();
1345 sev_set_guest_state(sev_common, SEV_STATE_RUNNING);
1346
1347 /* add migration blocker */
1348 error_setg(&sev_mig_blocker,
1349 "SEV-SNP: Migration is not implemented");
1350 ret = migrate_add_blocker(&sev_mig_blocker, &local_err);
1351 if (local_err) {
1352 error_report_err(local_err);
1353 error_free(sev_mig_blocker);
1354 exit(1);
1355 }
1356 }
1357
1358
1359 static void
sev_vm_state_change(void * opaque,bool running,RunState state)1360 sev_vm_state_change(void *opaque, bool running, RunState state)
1361 {
1362 SevCommonState *sev_common = opaque;
1363 SevCommonStateClass *klass = SEV_COMMON_GET_CLASS(opaque);
1364
1365 if (running) {
1366 if (!sev_check_state(sev_common, SEV_STATE_RUNNING)) {
1367 klass->launch_finish(sev_common);
1368 }
1369 }
1370 }
1371
1372 /*
1373 * This helper is to examine sev-guest properties and determine if any options
1374 * have been set which rely on the newer KVM_SEV_INIT2 interface and associated
1375 * KVM VM types.
1376 */
sev_init2_required(SevGuestState * sev_guest)1377 static bool sev_init2_required(SevGuestState *sev_guest)
1378 {
1379 /* Currently no KVM_SEV_INIT2-specific options are exposed via QEMU */
1380 return false;
1381 }
1382
sev_kvm_type(X86ConfidentialGuest * cg)1383 static int sev_kvm_type(X86ConfidentialGuest *cg)
1384 {
1385 SevCommonState *sev_common = SEV_COMMON(cg);
1386 SevGuestState *sev_guest = SEV_GUEST(sev_common);
1387 int kvm_type;
1388
1389 if (sev_common->kvm_type != -1) {
1390 goto out;
1391 }
1392
1393 /* These are the only cases where legacy VM types can be used. */
1394 if (sev_guest->legacy_vm_type == ON_OFF_AUTO_ON ||
1395 (sev_guest->legacy_vm_type == ON_OFF_AUTO_AUTO &&
1396 !sev_init2_required(sev_guest))) {
1397 sev_common->kvm_type = KVM_X86_DEFAULT_VM;
1398 goto out;
1399 }
1400
1401 /*
1402 * Newer VM types are required, either explicitly via legacy-vm-type=on, or
1403 * implicitly via legacy-vm-type=auto along with additional sev-guest
1404 * properties that require the newer VM types.
1405 */
1406 kvm_type = (sev_guest->policy & SEV_POLICY_ES) ?
1407 KVM_X86_SEV_ES_VM : KVM_X86_SEV_VM;
1408 if (!kvm_is_vm_type_supported(kvm_type)) {
1409 if (sev_guest->legacy_vm_type == ON_OFF_AUTO_AUTO) {
1410 error_report("SEV: host kernel does not support requested %s VM type, which is required "
1411 "for the set of options specified. To allow use of the legacy "
1412 "KVM_X86_DEFAULT_VM VM type, please disable any options that are not "
1413 "compatible with the legacy VM type, or upgrade your kernel.",
1414 kvm_type == KVM_X86_SEV_VM ? "KVM_X86_SEV_VM" : "KVM_X86_SEV_ES_VM");
1415 } else {
1416 error_report("SEV: host kernel does not support requested %s VM type. To allow use of "
1417 "the legacy KVM_X86_DEFAULT_VM VM type, the 'legacy-vm-type' argument "
1418 "must be set to 'on' or 'auto' for the sev-guest object.",
1419 kvm_type == KVM_X86_SEV_VM ? "KVM_X86_SEV_VM" : "KVM_X86_SEV_ES_VM");
1420 }
1421
1422 return -1;
1423 }
1424
1425 sev_common->kvm_type = kvm_type;
1426 out:
1427 return sev_common->kvm_type;
1428 }
1429
sev_snp_kvm_type(X86ConfidentialGuest * cg)1430 static int sev_snp_kvm_type(X86ConfidentialGuest *cg)
1431 {
1432 return KVM_X86_SNP_VM;
1433 }
1434
sev_common_kvm_init(ConfidentialGuestSupport * cgs,Error ** errp)1435 static int sev_common_kvm_init(ConfidentialGuestSupport *cgs, Error **errp)
1436 {
1437 char *devname;
1438 int ret, fw_error, cmd;
1439 uint32_t ebx;
1440 uint32_t host_cbitpos;
1441 struct sev_user_data_status status = {};
1442 SevCommonState *sev_common = SEV_COMMON(cgs);
1443 SevCommonStateClass *klass = SEV_COMMON_GET_CLASS(cgs);
1444 X86ConfidentialGuestClass *x86_klass =
1445 X86_CONFIDENTIAL_GUEST_GET_CLASS(cgs);
1446
1447 sev_common->state = SEV_STATE_UNINIT;
1448
1449 host_cpuid(0x8000001F, 0, NULL, &ebx, NULL, NULL);
1450 host_cbitpos = ebx & 0x3f;
1451
1452 /*
1453 * The cbitpos value will be placed in bit positions 5:0 of the EBX
1454 * register of CPUID 0x8000001F. No need to verify the range as the
1455 * comparison against the host value accomplishes that.
1456 */
1457 if (host_cbitpos != sev_common->cbitpos) {
1458 error_setg(errp, "%s: cbitpos check failed, host '%d' requested '%d'",
1459 __func__, host_cbitpos, sev_common->cbitpos);
1460 return -1;
1461 }
1462
1463 /*
1464 * The reduced-phys-bits value will be placed in bit positions 11:6 of
1465 * the EBX register of CPUID 0x8000001F, so verify the supplied value
1466 * is in the range of 1 to 63.
1467 */
1468 if (sev_common->reduced_phys_bits < 1 ||
1469 sev_common->reduced_phys_bits > 63) {
1470 error_setg(errp, "%s: reduced_phys_bits check failed,"
1471 " it should be in the range of 1 to 63, requested '%d'",
1472 __func__, sev_common->reduced_phys_bits);
1473 return -1;
1474 }
1475
1476 devname = object_property_get_str(OBJECT(sev_common), "sev-device", NULL);
1477 sev_common->sev_fd = open(devname, O_RDWR);
1478 if (sev_common->sev_fd < 0) {
1479 error_setg(errp, "%s: Failed to open %s '%s'", __func__,
1480 devname, strerror(errno));
1481 g_free(devname);
1482 return -1;
1483 }
1484 g_free(devname);
1485
1486 ret = sev_platform_ioctl(sev_common->sev_fd, SEV_PLATFORM_STATUS, &status,
1487 &fw_error);
1488 if (ret) {
1489 error_setg(errp, "%s: failed to get platform status ret=%d "
1490 "fw_error='%d: %s'", __func__, ret, fw_error,
1491 fw_error_to_str(fw_error));
1492 return -1;
1493 }
1494 sev_common->build_id = status.build;
1495 sev_common->api_major = status.api_major;
1496 sev_common->api_minor = status.api_minor;
1497
1498 if (sev_es_enabled()) {
1499 if (!kvm_kernel_irqchip_allowed()) {
1500 error_setg(errp, "%s: SEV-ES guests require in-kernel irqchip"
1501 "support", __func__);
1502 return -1;
1503 }
1504 }
1505
1506 if (sev_es_enabled() && !sev_snp_enabled()) {
1507 if (!(status.flags & SEV_STATUS_FLAGS_CONFIG_ES)) {
1508 error_setg(errp, "%s: guest policy requires SEV-ES, but "
1509 "host SEV-ES support unavailable",
1510 __func__);
1511 return -1;
1512 }
1513 }
1514
1515 trace_kvm_sev_init();
1516 switch (x86_klass->kvm_type(X86_CONFIDENTIAL_GUEST(sev_common))) {
1517 case KVM_X86_DEFAULT_VM:
1518 cmd = sev_es_enabled() ? KVM_SEV_ES_INIT : KVM_SEV_INIT;
1519
1520 ret = sev_ioctl(sev_common->sev_fd, cmd, NULL, &fw_error);
1521 break;
1522 case KVM_X86_SEV_VM:
1523 case KVM_X86_SEV_ES_VM:
1524 case KVM_X86_SNP_VM: {
1525 struct kvm_sev_init args = { 0 };
1526
1527 ret = sev_ioctl(sev_common->sev_fd, KVM_SEV_INIT2, &args, &fw_error);
1528 break;
1529 }
1530 default:
1531 error_setg(errp, "%s: host kernel does not support the requested SEV configuration.",
1532 __func__);
1533 return -1;
1534 }
1535
1536 if (ret) {
1537 error_setg(errp, "%s: failed to initialize ret=%d fw_error=%d '%s'",
1538 __func__, ret, fw_error, fw_error_to_str(fw_error));
1539 return -1;
1540 }
1541
1542 ret = klass->launch_start(sev_common);
1543
1544 if (ret) {
1545 error_setg(errp, "%s: failed to create encryption context", __func__);
1546 return -1;
1547 }
1548
1549 if (klass->kvm_init && klass->kvm_init(cgs, errp)) {
1550 return -1;
1551 }
1552
1553 qemu_add_vm_change_state_handler(sev_vm_state_change, sev_common);
1554
1555 cgs->ready = true;
1556
1557 return 0;
1558 }
1559
sev_kvm_init(ConfidentialGuestSupport * cgs,Error ** errp)1560 static int sev_kvm_init(ConfidentialGuestSupport *cgs, Error **errp)
1561 {
1562 int ret;
1563
1564 /*
1565 * SEV/SEV-ES rely on pinned memory to back guest RAM so discarding
1566 * isn't actually possible. With SNP, only guest_memfd pages are used
1567 * for private guest memory, so discarding of shared memory is still
1568 * possible..
1569 */
1570 ret = ram_block_discard_disable(true);
1571 if (ret) {
1572 error_setg(errp, "%s: cannot disable RAM discard", __func__);
1573 return -1;
1574 }
1575
1576 /*
1577 * SEV uses these notifiers to register/pin pages prior to guest use,
1578 * but SNP relies on guest_memfd for private pages, which has its
1579 * own internal mechanisms for registering/pinning private memory.
1580 */
1581 ram_block_notifier_add(&sev_ram_notifier);
1582
1583 /*
1584 * The machine done notify event is used for SEV guests to get the
1585 * measurement of the encrypted images. When SEV-SNP is enabled, the
1586 * measurement is part of the guest attestation process where it can
1587 * be collected without any reliance on the VMM. So skip registering
1588 * the notifier for SNP in favor of using guest attestation instead.
1589 */
1590 qemu_add_machine_init_done_notifier(&sev_machine_done_notify);
1591
1592 return 0;
1593 }
1594
sev_snp_kvm_init(ConfidentialGuestSupport * cgs,Error ** errp)1595 static int sev_snp_kvm_init(ConfidentialGuestSupport *cgs, Error **errp)
1596 {
1597 MachineState *ms = MACHINE(qdev_get_machine());
1598 X86MachineState *x86ms = X86_MACHINE(ms);
1599
1600 if (x86ms->smm == ON_OFF_AUTO_AUTO) {
1601 x86ms->smm = ON_OFF_AUTO_OFF;
1602 } else if (x86ms->smm == ON_OFF_AUTO_ON) {
1603 error_setg(errp, "SEV-SNP does not support SMM.");
1604 return -1;
1605 }
1606
1607 return 0;
1608 }
1609
1610 int
sev_encrypt_flash(hwaddr gpa,uint8_t * ptr,uint64_t len,Error ** errp)1611 sev_encrypt_flash(hwaddr gpa, uint8_t *ptr, uint64_t len, Error **errp)
1612 {
1613 SevCommonState *sev_common = SEV_COMMON(MACHINE(qdev_get_machine())->cgs);
1614 SevCommonStateClass *klass;
1615
1616 if (!sev_common) {
1617 return 0;
1618 }
1619 klass = SEV_COMMON_GET_CLASS(sev_common);
1620
1621 /* if SEV is in update state then encrypt the data else do nothing */
1622 if (sev_check_state(sev_common, SEV_STATE_LAUNCH_UPDATE)) {
1623 int ret;
1624
1625 ret = klass->launch_update_data(sev_common, gpa, ptr, len);
1626 if (ret < 0) {
1627 error_setg(errp, "SEV: Failed to encrypt pflash rom");
1628 return ret;
1629 }
1630 }
1631
1632 return 0;
1633 }
1634
sev_inject_launch_secret(const char * packet_hdr,const char * secret,uint64_t gpa,Error ** errp)1635 int sev_inject_launch_secret(const char *packet_hdr, const char *secret,
1636 uint64_t gpa, Error **errp)
1637 {
1638 ERRP_GUARD();
1639 struct kvm_sev_launch_secret input;
1640 g_autofree guchar *data = NULL, *hdr = NULL;
1641 int error, ret = 1;
1642 void *hva;
1643 gsize hdr_sz = 0, data_sz = 0;
1644 MemoryRegion *mr = NULL;
1645 SevCommonState *sev_common = SEV_COMMON(MACHINE(qdev_get_machine())->cgs);
1646
1647 if (!sev_common) {
1648 error_setg(errp, "SEV not enabled for guest");
1649 return 1;
1650 }
1651
1652 /* secret can be injected only in this state */
1653 if (!sev_check_state(sev_common, SEV_STATE_LAUNCH_SECRET)) {
1654 error_setg(errp, "SEV: Not in correct state. (LSECRET) %x",
1655 sev_common->state);
1656 return 1;
1657 }
1658
1659 hdr = g_base64_decode(packet_hdr, &hdr_sz);
1660 if (!hdr || !hdr_sz) {
1661 error_setg(errp, "SEV: Failed to decode sequence header");
1662 return 1;
1663 }
1664
1665 data = g_base64_decode(secret, &data_sz);
1666 if (!data || !data_sz) {
1667 error_setg(errp, "SEV: Failed to decode data");
1668 return 1;
1669 }
1670
1671 hva = gpa2hva(&mr, gpa, data_sz, errp);
1672 if (!hva) {
1673 error_prepend(errp, "SEV: Failed to calculate guest address: ");
1674 return 1;
1675 }
1676
1677 input.hdr_uaddr = (uint64_t)(unsigned long)hdr;
1678 input.hdr_len = hdr_sz;
1679
1680 input.trans_uaddr = (uint64_t)(unsigned long)data;
1681 input.trans_len = data_sz;
1682
1683 input.guest_uaddr = (uint64_t)(unsigned long)hva;
1684 input.guest_len = data_sz;
1685
1686 trace_kvm_sev_launch_secret(gpa, input.guest_uaddr,
1687 input.trans_uaddr, input.trans_len);
1688
1689 ret = sev_ioctl(sev_common->sev_fd, KVM_SEV_LAUNCH_SECRET,
1690 &input, &error);
1691 if (ret) {
1692 error_setg(errp, "SEV: failed to inject secret ret=%d fw_error=%d '%s'",
1693 ret, error, fw_error_to_str(error));
1694 return ret;
1695 }
1696
1697 return 0;
1698 }
1699
1700 #define SEV_SECRET_GUID "4c2eb361-7d9b-4cc3-8081-127c90d3d294"
1701 struct sev_secret_area {
1702 uint32_t base;
1703 uint32_t size;
1704 };
1705
qmp_sev_inject_launch_secret(const char * packet_hdr,const char * secret,bool has_gpa,uint64_t gpa,Error ** errp)1706 void qmp_sev_inject_launch_secret(const char *packet_hdr,
1707 const char *secret,
1708 bool has_gpa, uint64_t gpa,
1709 Error **errp)
1710 {
1711 if (!sev_enabled()) {
1712 error_setg(errp, "SEV not enabled for guest");
1713 return;
1714 }
1715 if (!has_gpa) {
1716 uint8_t *data;
1717 struct sev_secret_area *area;
1718
1719 if (!pc_system_ovmf_table_find(SEV_SECRET_GUID, &data, NULL)) {
1720 error_setg(errp, "SEV: no secret area found in OVMF,"
1721 " gpa must be specified.");
1722 return;
1723 }
1724 area = (struct sev_secret_area *)data;
1725 gpa = area->base;
1726 }
1727
1728 sev_inject_launch_secret(packet_hdr, secret, gpa, errp);
1729 }
1730
1731 static int
sev_es_parse_reset_block(SevInfoBlock * info,uint32_t * addr)1732 sev_es_parse_reset_block(SevInfoBlock *info, uint32_t *addr)
1733 {
1734 if (!info->reset_addr) {
1735 error_report("SEV-ES reset address is zero");
1736 return 1;
1737 }
1738
1739 *addr = info->reset_addr;
1740
1741 return 0;
1742 }
1743
1744 static int
sev_es_find_reset_vector(void * flash_ptr,uint64_t flash_size,uint32_t * addr)1745 sev_es_find_reset_vector(void *flash_ptr, uint64_t flash_size,
1746 uint32_t *addr)
1747 {
1748 QemuUUID info_guid, *guid;
1749 SevInfoBlock *info;
1750 uint8_t *data;
1751 uint16_t *len;
1752
1753 /*
1754 * Initialize the address to zero. An address of zero with a successful
1755 * return code indicates that SEV-ES is not active.
1756 */
1757 *addr = 0;
1758
1759 /*
1760 * Extract the AP reset vector for SEV-ES guests by locating the SEV GUID.
1761 * The SEV GUID is located on its own (original implementation) or within
1762 * the Firmware GUID Table (new implementation), either of which are
1763 * located 32 bytes from the end of the flash.
1764 *
1765 * Check the Firmware GUID Table first.
1766 */
1767 if (pc_system_ovmf_table_find(SEV_INFO_BLOCK_GUID, &data, NULL)) {
1768 return sev_es_parse_reset_block((SevInfoBlock *)data, addr);
1769 }
1770
1771 /*
1772 * SEV info block not found in the Firmware GUID Table (or there isn't
1773 * a Firmware GUID Table), fall back to the original implementation.
1774 */
1775 data = flash_ptr + flash_size - 0x20;
1776
1777 qemu_uuid_parse(SEV_INFO_BLOCK_GUID, &info_guid);
1778 info_guid = qemu_uuid_bswap(info_guid); /* GUIDs are LE */
1779
1780 guid = (QemuUUID *)(data - sizeof(info_guid));
1781 if (!qemu_uuid_is_equal(guid, &info_guid)) {
1782 error_report("SEV information block/Firmware GUID Table block not found in pflash rom");
1783 return 1;
1784 }
1785
1786 len = (uint16_t *)((uint8_t *)guid - sizeof(*len));
1787 info = (SevInfoBlock *)(data - le16_to_cpu(*len));
1788
1789 return sev_es_parse_reset_block(info, addr);
1790 }
1791
sev_es_set_reset_vector(CPUState * cpu)1792 void sev_es_set_reset_vector(CPUState *cpu)
1793 {
1794 X86CPU *x86;
1795 CPUX86State *env;
1796 ConfidentialGuestSupport *cgs = MACHINE(qdev_get_machine())->cgs;
1797 SevCommonState *sev_common = SEV_COMMON(
1798 object_dynamic_cast(OBJECT(cgs), TYPE_SEV_COMMON));
1799
1800 /* Only update if we have valid reset information */
1801 if (!sev_common || !sev_common->reset_data_valid) {
1802 return;
1803 }
1804
1805 /* Do not update the BSP reset state */
1806 if (cpu->cpu_index == 0) {
1807 return;
1808 }
1809
1810 x86 = X86_CPU(cpu);
1811 env = &x86->env;
1812
1813 cpu_x86_load_seg_cache(env, R_CS, 0xf000, sev_common->reset_cs, 0xffff,
1814 DESC_P_MASK | DESC_S_MASK | DESC_CS_MASK |
1815 DESC_R_MASK | DESC_A_MASK);
1816
1817 env->eip = sev_common->reset_ip;
1818 }
1819
sev_es_save_reset_vector(void * flash_ptr,uint64_t flash_size)1820 int sev_es_save_reset_vector(void *flash_ptr, uint64_t flash_size)
1821 {
1822 CPUState *cpu;
1823 uint32_t addr;
1824 int ret;
1825 SevCommonState *sev_common = SEV_COMMON(MACHINE(qdev_get_machine())->cgs);
1826
1827 if (!sev_es_enabled()) {
1828 return 0;
1829 }
1830
1831 addr = 0;
1832 ret = sev_es_find_reset_vector(flash_ptr, flash_size,
1833 &addr);
1834 if (ret) {
1835 return ret;
1836 }
1837
1838 if (addr) {
1839 sev_common->reset_cs = addr & 0xffff0000;
1840 sev_common->reset_ip = addr & 0x0000ffff;
1841 sev_common->reset_data_valid = true;
1842
1843 CPU_FOREACH(cpu) {
1844 sev_es_set_reset_vector(cpu);
1845 }
1846 }
1847
1848 return 0;
1849 }
1850
1851 static const QemuUUID sev_hash_table_header_guid = {
1852 .data = UUID_LE(0x9438d606, 0x4f22, 0x4cc9, 0xb4, 0x79, 0xa7, 0x93,
1853 0xd4, 0x11, 0xfd, 0x21)
1854 };
1855
1856 static const QemuUUID sev_kernel_entry_guid = {
1857 .data = UUID_LE(0x4de79437, 0xabd2, 0x427f, 0xb8, 0x35, 0xd5, 0xb1,
1858 0x72, 0xd2, 0x04, 0x5b)
1859 };
1860 static const QemuUUID sev_initrd_entry_guid = {
1861 .data = UUID_LE(0x44baf731, 0x3a2f, 0x4bd7, 0x9a, 0xf1, 0x41, 0xe2,
1862 0x91, 0x69, 0x78, 0x1d)
1863 };
1864 static const QemuUUID sev_cmdline_entry_guid = {
1865 .data = UUID_LE(0x97d02dd8, 0xbd20, 0x4c94, 0xaa, 0x78, 0xe7, 0x71,
1866 0x4d, 0x36, 0xab, 0x2a)
1867 };
1868
build_kernel_loader_hashes(PaddedSevHashTable * padded_ht,SevKernelLoaderContext * ctx,Error ** errp)1869 static bool build_kernel_loader_hashes(PaddedSevHashTable *padded_ht,
1870 SevKernelLoaderContext *ctx,
1871 Error **errp)
1872 {
1873 SevHashTable *ht;
1874 uint8_t cmdline_hash[HASH_SIZE];
1875 uint8_t initrd_hash[HASH_SIZE];
1876 uint8_t kernel_hash[HASH_SIZE];
1877 uint8_t *hashp;
1878 size_t hash_len = HASH_SIZE;
1879
1880 /*
1881 * Calculate hash of kernel command-line with the terminating null byte. If
1882 * the user doesn't supply a command-line via -append, the 1-byte "\0" will
1883 * be used.
1884 */
1885 hashp = cmdline_hash;
1886 if (qcrypto_hash_bytes(QCRYPTO_HASH_ALG_SHA256, ctx->cmdline_data,
1887 ctx->cmdline_size, &hashp, &hash_len, errp) < 0) {
1888 return false;
1889 }
1890 assert(hash_len == HASH_SIZE);
1891
1892 /*
1893 * Calculate hash of initrd. If the user doesn't supply an initrd via
1894 * -initrd, an empty buffer will be used (ctx->initrd_size == 0).
1895 */
1896 hashp = initrd_hash;
1897 if (qcrypto_hash_bytes(QCRYPTO_HASH_ALG_SHA256, ctx->initrd_data,
1898 ctx->initrd_size, &hashp, &hash_len, errp) < 0) {
1899 return false;
1900 }
1901 assert(hash_len == HASH_SIZE);
1902
1903 /* Calculate hash of the kernel */
1904 hashp = kernel_hash;
1905 struct iovec iov[2] = {
1906 { .iov_base = ctx->setup_data, .iov_len = ctx->setup_size },
1907 { .iov_base = ctx->kernel_data, .iov_len = ctx->kernel_size }
1908 };
1909 if (qcrypto_hash_bytesv(QCRYPTO_HASH_ALG_SHA256, iov, ARRAY_SIZE(iov),
1910 &hashp, &hash_len, errp) < 0) {
1911 return false;
1912 }
1913 assert(hash_len == HASH_SIZE);
1914
1915 ht = &padded_ht->ht;
1916
1917 ht->guid = sev_hash_table_header_guid;
1918 ht->len = sizeof(*ht);
1919
1920 ht->cmdline.guid = sev_cmdline_entry_guid;
1921 ht->cmdline.len = sizeof(ht->cmdline);
1922 memcpy(ht->cmdline.hash, cmdline_hash, sizeof(ht->cmdline.hash));
1923
1924 ht->initrd.guid = sev_initrd_entry_guid;
1925 ht->initrd.len = sizeof(ht->initrd);
1926 memcpy(ht->initrd.hash, initrd_hash, sizeof(ht->initrd.hash));
1927
1928 ht->kernel.guid = sev_kernel_entry_guid;
1929 ht->kernel.len = sizeof(ht->kernel);
1930 memcpy(ht->kernel.hash, kernel_hash, sizeof(ht->kernel.hash));
1931
1932 /* zero the excess data so the measurement can be reliably calculated */
1933 memset(padded_ht->padding, 0, sizeof(padded_ht->padding));
1934
1935 return true;
1936 }
1937
sev_snp_build_kernel_loader_hashes(SevCommonState * sev_common,SevHashTableDescriptor * area,SevKernelLoaderContext * ctx,Error ** errp)1938 static bool sev_snp_build_kernel_loader_hashes(SevCommonState *sev_common,
1939 SevHashTableDescriptor *area,
1940 SevKernelLoaderContext *ctx,
1941 Error **errp)
1942 {
1943 /*
1944 * SNP: Populate the hashes table in an area that later in
1945 * snp_launch_update_kernel_hashes() will be copied to the guest memory
1946 * and encrypted.
1947 */
1948 SevSnpGuestState *sev_snp_guest = SEV_SNP_GUEST(sev_common);
1949 sev_snp_guest->kernel_hashes_offset = area->base & ~TARGET_PAGE_MASK;
1950 sev_snp_guest->kernel_hashes_data = g_new0(PaddedSevHashTable, 1);
1951 return build_kernel_loader_hashes(sev_snp_guest->kernel_hashes_data, ctx, errp);
1952 }
1953
sev_build_kernel_loader_hashes(SevCommonState * sev_common,SevHashTableDescriptor * area,SevKernelLoaderContext * ctx,Error ** errp)1954 static bool sev_build_kernel_loader_hashes(SevCommonState *sev_common,
1955 SevHashTableDescriptor *area,
1956 SevKernelLoaderContext *ctx,
1957 Error **errp)
1958 {
1959 PaddedSevHashTable *padded_ht;
1960 hwaddr mapped_len = sizeof(*padded_ht);
1961 MemTxAttrs attrs = { 0 };
1962 bool ret = true;
1963
1964 /*
1965 * Populate the hashes table in the guest's memory at the OVMF-designated
1966 * area for the SEV hashes table
1967 */
1968 padded_ht = address_space_map(&address_space_memory, area->base,
1969 &mapped_len, true, attrs);
1970 if (!padded_ht || mapped_len != sizeof(*padded_ht)) {
1971 error_setg(errp, "SEV: cannot map hashes table guest memory area");
1972 return false;
1973 }
1974
1975 if (build_kernel_loader_hashes(padded_ht, ctx, errp)) {
1976 if (sev_encrypt_flash(area->base, (uint8_t *)padded_ht,
1977 sizeof(*padded_ht), errp) < 0) {
1978 ret = false;
1979 }
1980 } else {
1981 ret = false;
1982 }
1983
1984 address_space_unmap(&address_space_memory, padded_ht,
1985 mapped_len, true, mapped_len);
1986
1987 return ret;
1988 }
1989
1990 /*
1991 * Add the hashes of the linux kernel/initrd/cmdline to an encrypted guest page
1992 * which is included in SEV's initial memory measurement.
1993 */
sev_add_kernel_loader_hashes(SevKernelLoaderContext * ctx,Error ** errp)1994 bool sev_add_kernel_loader_hashes(SevKernelLoaderContext *ctx, Error **errp)
1995 {
1996 uint8_t *data;
1997 SevHashTableDescriptor *area;
1998 SevCommonState *sev_common = SEV_COMMON(MACHINE(qdev_get_machine())->cgs);
1999 SevCommonStateClass *klass = SEV_COMMON_GET_CLASS(sev_common);
2000
2001 /*
2002 * Only add the kernel hashes if the sev-guest configuration explicitly
2003 * stated kernel-hashes=on.
2004 */
2005 if (!sev_common->kernel_hashes) {
2006 return false;
2007 }
2008
2009 if (!pc_system_ovmf_table_find(SEV_HASH_TABLE_RV_GUID, &data, NULL)) {
2010 error_setg(errp, "SEV: kernel specified but guest firmware "
2011 "has no hashes table GUID");
2012 return false;
2013 }
2014
2015 area = (SevHashTableDescriptor *)data;
2016 if (!area->base || area->size < sizeof(PaddedSevHashTable)) {
2017 error_setg(errp, "SEV: guest firmware hashes table area is invalid "
2018 "(base=0x%x size=0x%x)", area->base, area->size);
2019 return false;
2020 }
2021
2022 return klass->build_kernel_loader_hashes(sev_common, area, ctx, errp);
2023 }
2024
2025 static char *
sev_common_get_sev_device(Object * obj,Error ** errp)2026 sev_common_get_sev_device(Object *obj, Error **errp)
2027 {
2028 return g_strdup(SEV_COMMON(obj)->sev_device);
2029 }
2030
2031 static void
sev_common_set_sev_device(Object * obj,const char * value,Error ** errp)2032 sev_common_set_sev_device(Object *obj, const char *value, Error **errp)
2033 {
2034 SEV_COMMON(obj)->sev_device = g_strdup(value);
2035 }
2036
sev_common_get_kernel_hashes(Object * obj,Error ** errp)2037 static bool sev_common_get_kernel_hashes(Object *obj, Error **errp)
2038 {
2039 return SEV_COMMON(obj)->kernel_hashes;
2040 }
2041
sev_common_set_kernel_hashes(Object * obj,bool value,Error ** errp)2042 static void sev_common_set_kernel_hashes(Object *obj, bool value, Error **errp)
2043 {
2044 SEV_COMMON(obj)->kernel_hashes = value;
2045 }
2046
2047 static void
sev_common_class_init(ObjectClass * oc,void * data)2048 sev_common_class_init(ObjectClass *oc, void *data)
2049 {
2050 ConfidentialGuestSupportClass *klass = CONFIDENTIAL_GUEST_SUPPORT_CLASS(oc);
2051
2052 klass->kvm_init = sev_common_kvm_init;
2053
2054 object_class_property_add_str(oc, "sev-device",
2055 sev_common_get_sev_device,
2056 sev_common_set_sev_device);
2057 object_class_property_set_description(oc, "sev-device",
2058 "SEV device to use");
2059 object_class_property_add_bool(oc, "kernel-hashes",
2060 sev_common_get_kernel_hashes,
2061 sev_common_set_kernel_hashes);
2062 object_class_property_set_description(oc, "kernel-hashes",
2063 "add kernel hashes to guest firmware for measured Linux boot");
2064 }
2065
2066 static void
sev_common_instance_init(Object * obj)2067 sev_common_instance_init(Object *obj)
2068 {
2069 SevCommonState *sev_common = SEV_COMMON(obj);
2070
2071 sev_common->kvm_type = -1;
2072
2073 sev_common->sev_device = g_strdup(DEFAULT_SEV_DEVICE);
2074
2075 object_property_add_uint32_ptr(obj, "cbitpos", &sev_common->cbitpos,
2076 OBJ_PROP_FLAG_READWRITE);
2077 object_property_add_uint32_ptr(obj, "reduced-phys-bits",
2078 &sev_common->reduced_phys_bits,
2079 OBJ_PROP_FLAG_READWRITE);
2080 }
2081
2082 /* sev guest info common to sev/sev-es/sev-snp */
2083 static const TypeInfo sev_common_info = {
2084 .parent = TYPE_X86_CONFIDENTIAL_GUEST,
2085 .name = TYPE_SEV_COMMON,
2086 .instance_size = sizeof(SevCommonState),
2087 .instance_init = sev_common_instance_init,
2088 .class_size = sizeof(SevCommonStateClass),
2089 .class_init = sev_common_class_init,
2090 .abstract = true,
2091 .interfaces = (InterfaceInfo[]) {
2092 { TYPE_USER_CREATABLE },
2093 { }
2094 }
2095 };
2096
2097 static char *
sev_guest_get_dh_cert_file(Object * obj,Error ** errp)2098 sev_guest_get_dh_cert_file(Object *obj, Error **errp)
2099 {
2100 return g_strdup(SEV_GUEST(obj)->dh_cert_file);
2101 }
2102
2103 static void
sev_guest_set_dh_cert_file(Object * obj,const char * value,Error ** errp)2104 sev_guest_set_dh_cert_file(Object *obj, const char *value, Error **errp)
2105 {
2106 SEV_GUEST(obj)->dh_cert_file = g_strdup(value);
2107 }
2108
2109 static char *
sev_guest_get_session_file(Object * obj,Error ** errp)2110 sev_guest_get_session_file(Object *obj, Error **errp)
2111 {
2112 SevGuestState *sev_guest = SEV_GUEST(obj);
2113
2114 return sev_guest->session_file ? g_strdup(sev_guest->session_file) : NULL;
2115 }
2116
2117 static void
sev_guest_set_session_file(Object * obj,const char * value,Error ** errp)2118 sev_guest_set_session_file(Object *obj, const char *value, Error **errp)
2119 {
2120 SEV_GUEST(obj)->session_file = g_strdup(value);
2121 }
2122
sev_guest_get_legacy_vm_type(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)2123 static void sev_guest_get_legacy_vm_type(Object *obj, Visitor *v,
2124 const char *name, void *opaque,
2125 Error **errp)
2126 {
2127 SevGuestState *sev_guest = SEV_GUEST(obj);
2128 OnOffAuto legacy_vm_type = sev_guest->legacy_vm_type;
2129
2130 visit_type_OnOffAuto(v, name, &legacy_vm_type, errp);
2131 }
2132
sev_guest_set_legacy_vm_type(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)2133 static void sev_guest_set_legacy_vm_type(Object *obj, Visitor *v,
2134 const char *name, void *opaque,
2135 Error **errp)
2136 {
2137 SevGuestState *sev_guest = SEV_GUEST(obj);
2138
2139 visit_type_OnOffAuto(v, name, &sev_guest->legacy_vm_type, errp);
2140 }
2141
2142 static void
sev_guest_class_init(ObjectClass * oc,void * data)2143 sev_guest_class_init(ObjectClass *oc, void *data)
2144 {
2145 SevCommonStateClass *klass = SEV_COMMON_CLASS(oc);
2146 X86ConfidentialGuestClass *x86_klass = X86_CONFIDENTIAL_GUEST_CLASS(oc);
2147
2148 klass->build_kernel_loader_hashes = sev_build_kernel_loader_hashes;
2149 klass->launch_start = sev_launch_start;
2150 klass->launch_finish = sev_launch_finish;
2151 klass->launch_update_data = sev_launch_update_data;
2152 klass->kvm_init = sev_kvm_init;
2153 x86_klass->kvm_type = sev_kvm_type;
2154
2155 object_class_property_add_str(oc, "dh-cert-file",
2156 sev_guest_get_dh_cert_file,
2157 sev_guest_set_dh_cert_file);
2158 object_class_property_set_description(oc, "dh-cert-file",
2159 "guest owners DH certificate (encoded with base64)");
2160 object_class_property_add_str(oc, "session-file",
2161 sev_guest_get_session_file,
2162 sev_guest_set_session_file);
2163 object_class_property_set_description(oc, "session-file",
2164 "guest owners session parameters (encoded with base64)");
2165 object_class_property_add(oc, "legacy-vm-type", "OnOffAuto",
2166 sev_guest_get_legacy_vm_type,
2167 sev_guest_set_legacy_vm_type, NULL, NULL);
2168 object_class_property_set_description(oc, "legacy-vm-type",
2169 "use legacy VM type to maintain measurement compatibility with older QEMU or kernel versions.");
2170 }
2171
2172 static void
sev_guest_instance_init(Object * obj)2173 sev_guest_instance_init(Object *obj)
2174 {
2175 SevGuestState *sev_guest = SEV_GUEST(obj);
2176
2177 sev_guest->policy = DEFAULT_GUEST_POLICY;
2178 object_property_add_uint32_ptr(obj, "handle", &sev_guest->handle,
2179 OBJ_PROP_FLAG_READWRITE);
2180 object_property_add_uint32_ptr(obj, "policy", &sev_guest->policy,
2181 OBJ_PROP_FLAG_READWRITE);
2182 object_apply_compat_props(obj);
2183
2184 sev_guest->legacy_vm_type = ON_OFF_AUTO_AUTO;
2185 }
2186
2187 /* guest info specific sev/sev-es */
2188 static const TypeInfo sev_guest_info = {
2189 .parent = TYPE_SEV_COMMON,
2190 .name = TYPE_SEV_GUEST,
2191 .instance_size = sizeof(SevGuestState),
2192 .instance_init = sev_guest_instance_init,
2193 .class_init = sev_guest_class_init,
2194 };
2195
2196 static void
sev_snp_guest_get_policy(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)2197 sev_snp_guest_get_policy(Object *obj, Visitor *v, const char *name,
2198 void *opaque, Error **errp)
2199 {
2200 visit_type_uint64(v, name,
2201 (uint64_t *)&SEV_SNP_GUEST(obj)->kvm_start_conf.policy,
2202 errp);
2203 }
2204
2205 static void
sev_snp_guest_set_policy(Object * obj,Visitor * v,const char * name,void * opaque,Error ** errp)2206 sev_snp_guest_set_policy(Object *obj, Visitor *v, const char *name,
2207 void *opaque, Error **errp)
2208 {
2209 visit_type_uint64(v, name,
2210 (uint64_t *)&SEV_SNP_GUEST(obj)->kvm_start_conf.policy,
2211 errp);
2212 }
2213
2214 static char *
sev_snp_guest_get_guest_visible_workarounds(Object * obj,Error ** errp)2215 sev_snp_guest_get_guest_visible_workarounds(Object *obj, Error **errp)
2216 {
2217 return g_strdup(SEV_SNP_GUEST(obj)->guest_visible_workarounds);
2218 }
2219
2220 static void
sev_snp_guest_set_guest_visible_workarounds(Object * obj,const char * value,Error ** errp)2221 sev_snp_guest_set_guest_visible_workarounds(Object *obj, const char *value,
2222 Error **errp)
2223 {
2224 SevSnpGuestState *sev_snp_guest = SEV_SNP_GUEST(obj);
2225 struct kvm_sev_snp_launch_start *start = &sev_snp_guest->kvm_start_conf;
2226 g_autofree guchar *blob;
2227 gsize len;
2228
2229 g_free(sev_snp_guest->guest_visible_workarounds);
2230
2231 /* store the base64 str so we don't need to re-encode in getter */
2232 sev_snp_guest->guest_visible_workarounds = g_strdup(value);
2233
2234 blob = qbase64_decode(sev_snp_guest->guest_visible_workarounds,
2235 -1, &len, errp);
2236 if (!blob) {
2237 return;
2238 }
2239
2240 if (len != sizeof(start->gosvw)) {
2241 error_setg(errp, "parameter length of %" G_GSIZE_FORMAT
2242 " exceeds max of %zu",
2243 len, sizeof(start->gosvw));
2244 return;
2245 }
2246
2247 memcpy(start->gosvw, blob, len);
2248 }
2249
2250 static char *
sev_snp_guest_get_id_block(Object * obj,Error ** errp)2251 sev_snp_guest_get_id_block(Object *obj, Error **errp)
2252 {
2253 SevSnpGuestState *sev_snp_guest = SEV_SNP_GUEST(obj);
2254
2255 return g_strdup(sev_snp_guest->id_block_base64);
2256 }
2257
2258 static void
sev_snp_guest_set_id_block(Object * obj,const char * value,Error ** errp)2259 sev_snp_guest_set_id_block(Object *obj, const char *value, Error **errp)
2260 {
2261 SevSnpGuestState *sev_snp_guest = SEV_SNP_GUEST(obj);
2262 struct kvm_sev_snp_launch_finish *finish = &sev_snp_guest->kvm_finish_conf;
2263 gsize len;
2264
2265 finish->id_block_en = 0;
2266 g_free(sev_snp_guest->id_block);
2267 g_free(sev_snp_guest->id_block_base64);
2268
2269 /* store the base64 str so we don't need to re-encode in getter */
2270 sev_snp_guest->id_block_base64 = g_strdup(value);
2271 sev_snp_guest->id_block =
2272 qbase64_decode(sev_snp_guest->id_block_base64, -1, &len, errp);
2273
2274 if (!sev_snp_guest->id_block) {
2275 return;
2276 }
2277
2278 if (len != KVM_SEV_SNP_ID_BLOCK_SIZE) {
2279 error_setg(errp, "parameter length of %" G_GSIZE_FORMAT
2280 " not equal to %u",
2281 len, KVM_SEV_SNP_ID_BLOCK_SIZE);
2282 return;
2283 }
2284
2285 finish->id_block_en = 1;
2286 finish->id_block_uaddr = (uintptr_t)sev_snp_guest->id_block;
2287 }
2288
2289 static char *
sev_snp_guest_get_id_auth(Object * obj,Error ** errp)2290 sev_snp_guest_get_id_auth(Object *obj, Error **errp)
2291 {
2292 SevSnpGuestState *sev_snp_guest = SEV_SNP_GUEST(obj);
2293
2294 return g_strdup(sev_snp_guest->id_auth_base64);
2295 }
2296
2297 static void
sev_snp_guest_set_id_auth(Object * obj,const char * value,Error ** errp)2298 sev_snp_guest_set_id_auth(Object *obj, const char *value, Error **errp)
2299 {
2300 SevSnpGuestState *sev_snp_guest = SEV_SNP_GUEST(obj);
2301 struct kvm_sev_snp_launch_finish *finish = &sev_snp_guest->kvm_finish_conf;
2302 gsize len;
2303
2304 finish->id_auth_uaddr = 0;
2305 g_free(sev_snp_guest->id_auth);
2306 g_free(sev_snp_guest->id_auth_base64);
2307
2308 /* store the base64 str so we don't need to re-encode in getter */
2309 sev_snp_guest->id_auth_base64 = g_strdup(value);
2310 sev_snp_guest->id_auth =
2311 qbase64_decode(sev_snp_guest->id_auth_base64, -1, &len, errp);
2312
2313 if (!sev_snp_guest->id_auth) {
2314 return;
2315 }
2316
2317 if (len > KVM_SEV_SNP_ID_AUTH_SIZE) {
2318 error_setg(errp, "parameter length:ID_AUTH %" G_GSIZE_FORMAT
2319 " exceeds max of %u",
2320 len, KVM_SEV_SNP_ID_AUTH_SIZE);
2321 return;
2322 }
2323
2324 finish->id_auth_uaddr = (uintptr_t)sev_snp_guest->id_auth;
2325 }
2326
2327 static bool
sev_snp_guest_get_author_key_enabled(Object * obj,Error ** errp)2328 sev_snp_guest_get_author_key_enabled(Object *obj, Error **errp)
2329 {
2330 SevSnpGuestState *sev_snp_guest = SEV_SNP_GUEST(obj);
2331
2332 return !!sev_snp_guest->kvm_finish_conf.auth_key_en;
2333 }
2334
2335 static void
sev_snp_guest_set_author_key_enabled(Object * obj,bool value,Error ** errp)2336 sev_snp_guest_set_author_key_enabled(Object *obj, bool value, Error **errp)
2337 {
2338 SevSnpGuestState *sev_snp_guest = SEV_SNP_GUEST(obj);
2339
2340 sev_snp_guest->kvm_finish_conf.auth_key_en = value;
2341 }
2342
2343 static bool
sev_snp_guest_get_vcek_disabled(Object * obj,Error ** errp)2344 sev_snp_guest_get_vcek_disabled(Object *obj, Error **errp)
2345 {
2346 SevSnpGuestState *sev_snp_guest = SEV_SNP_GUEST(obj);
2347
2348 return !!sev_snp_guest->kvm_finish_conf.vcek_disabled;
2349 }
2350
2351 static void
sev_snp_guest_set_vcek_disabled(Object * obj,bool value,Error ** errp)2352 sev_snp_guest_set_vcek_disabled(Object *obj, bool value, Error **errp)
2353 {
2354 SevSnpGuestState *sev_snp_guest = SEV_SNP_GUEST(obj);
2355
2356 sev_snp_guest->kvm_finish_conf.vcek_disabled = value;
2357 }
2358
2359 static char *
sev_snp_guest_get_host_data(Object * obj,Error ** errp)2360 sev_snp_guest_get_host_data(Object *obj, Error **errp)
2361 {
2362 SevSnpGuestState *sev_snp_guest = SEV_SNP_GUEST(obj);
2363
2364 return g_strdup(sev_snp_guest->host_data);
2365 }
2366
2367 static void
sev_snp_guest_set_host_data(Object * obj,const char * value,Error ** errp)2368 sev_snp_guest_set_host_data(Object *obj, const char *value, Error **errp)
2369 {
2370 SevSnpGuestState *sev_snp_guest = SEV_SNP_GUEST(obj);
2371 struct kvm_sev_snp_launch_finish *finish = &sev_snp_guest->kvm_finish_conf;
2372 g_autofree guchar *blob;
2373 gsize len;
2374
2375 g_free(sev_snp_guest->host_data);
2376
2377 /* store the base64 str so we don't need to re-encode in getter */
2378 sev_snp_guest->host_data = g_strdup(value);
2379
2380 blob = qbase64_decode(sev_snp_guest->host_data, -1, &len, errp);
2381
2382 if (!blob) {
2383 return;
2384 }
2385
2386 if (len != sizeof(finish->host_data)) {
2387 error_setg(errp, "parameter length of %" G_GSIZE_FORMAT
2388 " not equal to %zu",
2389 len, sizeof(finish->host_data));
2390 return;
2391 }
2392
2393 memcpy(finish->host_data, blob, len);
2394 }
2395
2396 static void
sev_snp_guest_class_init(ObjectClass * oc,void * data)2397 sev_snp_guest_class_init(ObjectClass *oc, void *data)
2398 {
2399 SevCommonStateClass *klass = SEV_COMMON_CLASS(oc);
2400 X86ConfidentialGuestClass *x86_klass = X86_CONFIDENTIAL_GUEST_CLASS(oc);
2401
2402 klass->build_kernel_loader_hashes = sev_snp_build_kernel_loader_hashes;
2403 klass->launch_start = sev_snp_launch_start;
2404 klass->launch_finish = sev_snp_launch_finish;
2405 klass->launch_update_data = sev_snp_launch_update_data;
2406 klass->kvm_init = sev_snp_kvm_init;
2407 x86_klass->mask_cpuid_features = sev_snp_mask_cpuid_features;
2408 x86_klass->kvm_type = sev_snp_kvm_type;
2409
2410 object_class_property_add(oc, "policy", "uint64",
2411 sev_snp_guest_get_policy,
2412 sev_snp_guest_set_policy, NULL, NULL);
2413 object_class_property_add_str(oc, "guest-visible-workarounds",
2414 sev_snp_guest_get_guest_visible_workarounds,
2415 sev_snp_guest_set_guest_visible_workarounds);
2416 object_class_property_add_str(oc, "id-block",
2417 sev_snp_guest_get_id_block,
2418 sev_snp_guest_set_id_block);
2419 object_class_property_add_str(oc, "id-auth",
2420 sev_snp_guest_get_id_auth,
2421 sev_snp_guest_set_id_auth);
2422 object_class_property_add_bool(oc, "author-key-enabled",
2423 sev_snp_guest_get_author_key_enabled,
2424 sev_snp_guest_set_author_key_enabled);
2425 object_class_property_add_bool(oc, "vcek-disabled",
2426 sev_snp_guest_get_vcek_disabled,
2427 sev_snp_guest_set_vcek_disabled);
2428 object_class_property_add_str(oc, "host-data",
2429 sev_snp_guest_get_host_data,
2430 sev_snp_guest_set_host_data);
2431 }
2432
2433 static void
sev_snp_guest_instance_init(Object * obj)2434 sev_snp_guest_instance_init(Object *obj)
2435 {
2436 ConfidentialGuestSupport *cgs = CONFIDENTIAL_GUEST_SUPPORT(obj);
2437 SevSnpGuestState *sev_snp_guest = SEV_SNP_GUEST(obj);
2438
2439 cgs->require_guest_memfd = true;
2440
2441 /* default init/start/finish params for kvm */
2442 sev_snp_guest->kvm_start_conf.policy = DEFAULT_SEV_SNP_POLICY;
2443 }
2444
2445 /* guest info specific to sev-snp */
2446 static const TypeInfo sev_snp_guest_info = {
2447 .parent = TYPE_SEV_COMMON,
2448 .name = TYPE_SEV_SNP_GUEST,
2449 .instance_size = sizeof(SevSnpGuestState),
2450 .class_init = sev_snp_guest_class_init,
2451 .instance_init = sev_snp_guest_instance_init,
2452 };
2453
2454 static void
sev_register_types(void)2455 sev_register_types(void)
2456 {
2457 type_register_static(&sev_common_info);
2458 type_register_static(&sev_guest_info);
2459 type_register_static(&sev_snp_guest_info);
2460 }
2461
2462 type_init(sev_register_types);
2463