| /* |
| * vmlaunchupdate device fwcfg test. |
| * |
| * Copyright (c) 2026 Red Hat, Inc. |
| * |
| * Author: |
| * Ani Sinha <anisinha@redhat.com> |
| * |
| * SPDX-License-Identifier: GPL-2.0-or-later |
| */ |
| |
| #include "qemu/osdep.h" |
| #include "libqos/libqos-pc.h" |
| #include "libqtest.h" |
| #include "standard-headers/linux/qemu_fw_cfg.h" |
| #include "libqos/fw_cfg.h" |
| #include "qemu/bswap.h" |
| #include "hw/misc/vmlaunchupdate.h" |
| |
| #define WAIT_SEC 10 |
| static bool debug; |
| static bool trace; |
| static bool confidential; |
| |
| static void test_vm_launch_update_capability(void) |
| { |
| QFWCFG *fw_cfg; |
| QTestState *s; |
| VMLaunchUpdate launch_update; |
| size_t filesize; |
| uint64_t capabilities; |
| |
| if (!qtest_has_device("vm-launch-update")) { |
| g_test_skip("Device vm-launch-update is not available"); |
| return; |
| } |
| |
| s = qtest_init("-device vm-launch-update"); |
| fw_cfg = pc_fw_cfg_init(s); |
| |
| filesize = qfw_cfg_get_file(fw_cfg, FILE_VMLAUNCHUPDATE, |
| &launch_update, sizeof(launch_update)); |
| g_assert_cmpint(filesize, ==, sizeof(launch_update)); |
| capabilities = le64_to_cpu(launch_update.capabilities); |
| g_assert_cmpint(capabilities, ==, VM_LAUNCHUPDATE_FORMAT_IGVM); |
| pc_fw_cfg_uninit(fw_cfg); |
| qtest_quit(s); |
| } |
| |
| |
| static void test_vm_launch_update_disable(void) |
| { |
| QFWCFG *fw_cfg; |
| QOSState *qs; |
| VMLaunchUpdate launch_update; |
| uint64_t control; |
| size_t filesize; |
| |
| if (!qtest_has_device("vm-launch-update")) { |
| g_test_skip("Device vm-launch-update is not available"); |
| return; |
| } |
| |
| /* use default accelerator */ |
| qs = qtest_pc_boot("-device vm-launch-update"); |
| |
| fw_cfg = pc_fw_cfg_init(qs->qts); |
| |
| filesize = qfw_cfg_get_file(fw_cfg, FILE_VMLAUNCHUPDATE, |
| &launch_update, sizeof(launch_update)); |
| g_assert_cmpint(filesize, ==, sizeof(launch_update)); |
| control = le64_to_cpu(launch_update.control); |
| g_assert_cmpint(VM_LAUNCHUPDATE_CTL_DISABLE & control, ==, 0); |
| |
| /* disable the device */ |
| memset(&launch_update, 0, sizeof(launch_update)); |
| launch_update.control |= VM_LAUNCHUPDATE_CTL_DISABLE; |
| |
| filesize = qfw_cfg_write_file(fw_cfg, qs, FILE_VMLAUNCHUPDATE, |
| &launch_update, sizeof(launch_update)); |
| g_assert_cmpint(filesize, ==, sizeof(launch_update)); |
| |
| /* try to clear the dsable flag */ |
| memset(&launch_update, 0, sizeof(launch_update)); |
| |
| filesize = qfw_cfg_write_file(fw_cfg, qs, FILE_VMLAUNCHUPDATE, |
| &launch_update, sizeof(launch_update)); |
| g_assert_cmpint(filesize, ==, sizeof(launch_update)); |
| |
| /* check if the device is still disabled */ |
| filesize = qfw_cfg_get_file(fw_cfg, FILE_VMLAUNCHUPDATE, |
| &launch_update, sizeof(launch_update)); |
| g_assert_cmpint(filesize, ==, sizeof(launch_update)); |
| control = le64_to_cpu(launch_update.control); |
| g_assert_cmpint(VM_LAUNCHUPDATE_CTL_DISABLE & control, ==, 1); |
| |
| pc_fw_cfg_uninit(fw_cfg); |
| qtest_shutdown(qs); |
| } |
| |
| static void check_error(void) |
| { |
| QFWCFG *fw_cfg; |
| QOSState *qs; |
| VMLaunchUpdate launch_update; |
| uint16_t status; |
| size_t filesize; |
| |
| if (!qtest_has_device("vm-launch-update")) { |
| g_test_skip("Device vm-launch-update is not available"); |
| return; |
| } |
| |
| /* guest not started with IGVM and with default accelerator */ |
| qs = qtest_pc_boot("-device vm-launch-update"); |
| |
| fw_cfg = pc_fw_cfg_init(qs->qts); |
| |
| memset(&launch_update, 0, sizeof(launch_update)); |
| launch_update.fw_image_size = 50; |
| launch_update.fw_image_addr = cpu_to_le64(0xdeadbeef); |
| launch_update.control |= VM_LAUNCHUPDATE_FORMAT_IGVM; |
| |
| filesize = qfw_cfg_write_file(fw_cfg, qs, FILE_VMLAUNCHUPDATE, |
| &launch_update, sizeof(launch_update)); |
| g_assert_cmpint(filesize, ==, sizeof(launch_update)); |
| |
| memset(&launch_update, 0, sizeof(launch_update)); |
| filesize = qfw_cfg_get_file(fw_cfg, FILE_VMLAUNCHUPDATE, |
| &launch_update, sizeof(launch_update)); |
| g_assert_cmpint(filesize, ==, sizeof(launch_update)); |
| status = le64_to_cpu(launch_update.status); |
| /* should fail with NOT_IGVM_INIT */ |
| g_assert_cmpint(status, ==, VM_LAUNCHUPDATE_NOT_IGVM_INIT); |
| |
| memset(&launch_update, 0, sizeof(launch_update)); |
| launch_update.fw_image_size = 50; |
| launch_update.fw_image_addr = cpu_to_le64(0xdeadbeef); |
| /* control set to 0, not VM_LAUNCHUPDATE_FORMAT_IGVM */ |
| |
| filesize = qfw_cfg_write_file(fw_cfg, qs, FILE_VMLAUNCHUPDATE, |
| &launch_update, sizeof(launch_update)); |
| g_assert_cmpint(filesize, ==, sizeof(launch_update)); |
| |
| memset(&launch_update, 0, sizeof(launch_update)); |
| filesize = qfw_cfg_get_file(fw_cfg, FILE_VMLAUNCHUPDATE, |
| &launch_update, sizeof(launch_update)); |
| g_assert_cmpint(filesize, ==, sizeof(launch_update)); |
| status = le64_to_cpu(launch_update.status); |
| /* should fail with LOAD_FAIL since it was not IGVM format */ |
| g_assert_cmpint(status, ==, VM_LAUNCHUPDATE_LOAD_FAIL); |
| } |
| |
| static int64_t get_image_size(const char *filename) |
| { |
| int fd; |
| int64_t size; |
| fd = open(filename, O_RDONLY | O_BINARY); |
| g_assert_true(fd > 0); |
| size = lseek(fd, 0, SEEK_END); |
| close(fd); |
| return size; |
| } |
| |
| static ssize_t load_image(const char *igvm_f, void **addr, size_t *size) |
| { |
| ssize_t actsize = 0, l = 0; |
| int f_igvm_f; |
| size_t l_size; |
| |
| f_igvm_f = open(igvm_f, O_RDONLY | O_BINARY); |
| g_assert_true(f_igvm_f); |
| l_size = get_image_size(igvm_f); |
| g_assert_true(l_size > 0); |
| *addr = g_malloc0(l_size); |
| g_assert_true(*addr); |
| |
| while (l < l_size) { |
| actsize = read(f_igvm_f, *addr + l, 1); |
| if (actsize < 0) { |
| break; |
| } |
| l += actsize; |
| } |
| |
| close(f_igvm_f); |
| *size = l_size; |
| return actsize < 0 ? -1 : l; |
| } |
| |
| static guint32 match_string(char *serial_f, const char *exp_out) |
| { |
| GError *error = NULL; |
| g_autofree gchar *f_contents = NULL; |
| g_autofree GRegex *regex = NULL; |
| g_autofree GMatchInfo *match_info = NULL; |
| gsize len; |
| guint32 count = 0; |
| gboolean ret; |
| |
| ret = g_file_get_contents(serial_f, &f_contents, &len, &error); |
| g_assert(ret); |
| g_assert_no_error(error); |
| |
| regex = g_regex_new(exp_out, G_REGEX_CASELESS, 0, &error); |
| g_assert_no_error(error); |
| |
| ret = g_regex_match_full(regex, f_contents, -1, 0, 0, &match_info, &error); |
| g_assert_no_error(error); |
| |
| while (g_match_info_matches(match_info)) { |
| gchar *word = g_match_info_fetch(match_info, 0); |
| g_free(word); |
| g_match_info_next(match_info, &error); |
| count++; |
| } |
| g_regex_unref(regex); |
| return count; |
| } |
| |
| static int wait_for_match(char *serial_f, |
| const char *exp_out, int64_t timeout_s, |
| guint32 count) |
| { |
| time_t start, delta; |
| int ret = -1; |
| |
| start = time(NULL); |
| while (1) { |
| if (match_string(serial_f, exp_out) == count) { |
| ret = 0; |
| break; |
| } |
| |
| delta = time(NULL) - start; |
| if (delta >= timeout_s) { |
| fprintf(stderr, "timed out waiting to read serial output\n"); |
| break; |
| } |
| |
| /* wait 20 ms before trying again */ |
| if (false) { |
| fprintf(stderr, |
| "sleeping 20 ms before checking serial output again.\n"); |
| } |
| g_usleep(20000); |
| } |
| return ret; |
| } |
| |
| static void set_test_params(const char **igvm_f, const char **igvm_init, |
| const char **snp, const char **cgs) |
| { |
| if (confidential) { |
| *snp = "-object \'{\"qom-type\":\"sev-snp-guest\",\"id\":\"lsec0\"," |
| "\"cbitpos\":51,\"reduced-phys-bits\":1,\"policy\":196608}\'"; |
| *cgs = "confidential-guest-support=lsec0"; |
| /* |
| * The following two IGVM files can be built from the source |
| * present in https://gitlab.com/anisinha/virt-firmware-rs . |
| * Typing 'make' from the top of this repository will build the |
| * IGVM files for both confidential and |
| * non-confidential tests. The IGVM files for the non-coco |
| * case has been checked-in into the QEMU repository for |
| * convenience and easy CI pipeline testing. |
| */ |
| *igvm_f = "tests/data/igvm/snptest.igvm"; /* prints 'hello world' */ |
| *igvm_init = "tests/data/igvm/snptest-nohello.igvm"; |
| } else { |
| *igvm_f = "tests/data/igvm/hello.igvm"; |
| *igvm_init = "tests/data/igvm/qemuinit.igvm"; |
| *snp = ""; |
| *cgs = ""; |
| } |
| |
| return; |
| } |
| |
| static void set_expected_out(const char **exp_out, const char **exp_out2, |
| const char **exp_out3) |
| { |
| *exp_out = "Hello world!"; |
| *exp_out2 = "Test succeeded!"; |
| *exp_out3 = "boot process complete with initial igvm"; |
| |
| return; |
| } |
| |
| static QOSState *set_qemu_args(const char *cgs, const char *tp, char *serialf, |
| const char *igvm_init, const char *snp) |
| { |
| QOSState *qs; |
| |
| if (tp) { |
| qs = qtest_pc_boot("-machine q35,igvm-cfg=igvm0,%s -m 1G -accel kvm " |
| "-device vm-launch-update %s " |
| "-chardev file,id=serial0,path=%s " |
| "-serial chardev:serial0 " |
| "-object igvm-cfg,id=igvm0,file=%s %s", |
| cgs, tp, serialf, igvm_init, snp); |
| } else { |
| qs = qtest_pc_boot("-machine q35,igvm-cfg=igvm0,%s -m 1G -accel kvm " |
| "-device vm-launch-update " |
| "-chardev file,id=serial0,path=%s " |
| "-serial chardev:serial0 " |
| "-object igvm-cfg,id=igvm0,file=%s %s", |
| cgs, serialf, igvm_init, snp); |
| } |
| |
| return qs; |
| } |
| |
| static void test_load_igvm(void) |
| { |
| const char *igvm_f; |
| const char *igvm_init; |
| int ser_fd; |
| g_autofree void *igvm_blob = NULL; |
| g_autofree char *serialtmp = NULL; |
| const char *exp_out; |
| const char *exp_out2; |
| const char *exp_out3; |
| const char *tracepoints = "--trace memory_region_finalize " |
| "--trace qigvm_cleanup_memory -D /tmp/qemu-debug.log "; |
| const char *snp, *cgs; |
| uint64_t gaddr; |
| size_t igvm_sz; |
| size_t filesize; |
| QFWCFG *fw_cfg; |
| QOSState *qs; |
| VMLaunchUpdate launch_update; |
| |
| if (!trace) { |
| tracepoints = ""; |
| } |
| |
| if (!qtest_has_machine("q35")) { |
| g_test_skip("q35 machine not available"); |
| return; |
| } |
| |
| if (!qtest_has_accel("kvm")) { |
| g_test_skip("No KVM accelerator available"); |
| return; |
| } |
| |
| if (!qtest_has_device("vm-launch-update")) { |
| g_test_skip("Device vm-launch-update is not available"); |
| return; |
| } |
| |
| set_test_params(&igvm_f, &igvm_init, &snp, &cgs); |
| set_expected_out(&exp_out, &exp_out2, &exp_out3); |
| |
| if (!g_file_test(igvm_f, G_FILE_TEST_EXISTS) || |
| !g_file_test(igvm_init, G_FILE_TEST_EXISTS)) { |
| g_test_skip("igvm file bundle(s) does not exist!"); |
| return; |
| } |
| |
| ser_fd = g_file_open_tmp("launchupdate-qtest-serial-sXXXXXX", |
| &serialtmp, NULL); |
| g_assert_true(ser_fd != -1); |
| |
| if (debug) { |
| fprintf(stderr, "serial console file is %s\n", serialtmp); |
| } |
| |
| qs = set_qemu_args(cgs, tracepoints, serialtmp, igvm_init, snp); |
| |
| fw_cfg = pc_fw_cfg_init(qs->qts); |
| |
| if (debug) { |
| fprintf(stderr, "target endianness: %s\n", |
| qtest_big_endian(qs->qts) ? "big" : "little"); |
| } |
| |
| /* exp_out3 should be printed once from initial boot */ |
| g_assert_true(wait_for_match(serialtmp, exp_out3, WAIT_SEC, 1) == 0); |
| |
| if (debug) { |
| fprintf(stderr, "initially booted with host igvm\n"); |
| } |
| |
| g_assert_true(load_image(igvm_f, &igvm_blob, &igvm_sz) == igvm_sz); |
| |
| /* create a data buffer in guest memory */ |
| gaddr = guest_alloc(&qs->alloc, igvm_sz); |
| |
| if (debug) { |
| fprintf(stderr, "guest paddr: %"PRIx64 " igvm size: %lu\n", |
| gaddr, igvm_sz); |
| } |
| |
| if (debug) { |
| fprintf(stderr, "writing igvm file into the guest memory\n"); |
| } |
| |
| qtest_bufwrite(qs->qts, gaddr, igvm_blob, igvm_sz); |
| |
| if (debug) { |
| fprintf(stderr, |
| "tell hypervisor where igvm is loaded in guest memory\n"); |
| } |
| |
| /* now tell hypervisor where we loaded the bios */ |
| memset(&launch_update, 0, sizeof(launch_update)); |
| launch_update.fw_image_size = cpu_to_le64(igvm_sz); |
| launch_update.fw_image_addr = cpu_to_le64(gaddr); |
| launch_update.control |= VM_LAUNCHUPDATE_FORMAT_IGVM; |
| |
| filesize = qfw_cfg_write_file(fw_cfg, qs, FILE_VMLAUNCHUPDATE, |
| &launch_update, sizeof(launch_update)); |
| g_assert_cmpint(filesize, ==, sizeof(launch_update)); |
| |
| if (debug) { |
| fprintf(stderr, "resetting the virtual machine now\n"); |
| } |
| |
| qtest_system_reset(qs->qts); |
| |
| /* expected string should be printed on the console */ |
| g_assert_true(wait_for_match(serialtmp, exp_out, WAIT_SEC, 1) == 0); |
| g_assert_true(wait_for_match(serialtmp, exp_out2, WAIT_SEC, 1) == 0); |
| |
| if (debug) { |
| fprintf(stderr, "hello world found on console\n"); |
| } |
| |
| /* check if VM_LAUNCHUPDATE_CTL_HOST_IGVM function works */ |
| |
| /* set only VM_LAUNCHUPDATE_CTL_HOST_IGVM control without IGVM bundle */ |
| memset(&launch_update, 0, sizeof(launch_update)); |
| launch_update.control |= VM_LAUNCHUPDATE_CTL_HOST_IGVM; |
| |
| filesize = qfw_cfg_write_file(fw_cfg, qs, FILE_VMLAUNCHUPDATE, |
| &launch_update, sizeof(launch_update)); |
| g_assert_cmpint(filesize, ==, sizeof(launch_update)); |
| |
| /* now reset the guest */ |
| if (debug) { |
| fprintf(stderr, |
| "resetting again in order to restore host provided IGVM\n"); |
| } |
| qtest_system_reset(qs->qts); |
| |
| /* |
| * exp_out3 should be printed twice, once from initial boot, |
| * once from restoring host igvm. |
| */ |
| g_assert_true(wait_for_match(serialtmp, exp_out3, WAIT_SEC, 2) == 0); |
| |
| if (debug) { |
| fprintf(stderr, "booted with host igvm again\n"); |
| } |
| |
| close(ser_fd); |
| guest_free(&qs->alloc, gaddr); |
| pc_fw_cfg_uninit(fw_cfg); |
| /* qtest_quit() kils QEMU, first by sending SIGTERM, then SIGKILL */ |
| qtest_quit(qs->qts); |
| } |
| |
| static void test_set_ctrl_once_and_reset_to_host_igvm(void) |
| { |
| const char *igvm_f; |
| const char *igvm_init; |
| int ser_fd; |
| g_autofree void *igvm_blob = NULL; |
| g_autofree char *serialtmp = NULL; |
| const char *exp_out; |
| const char *exp_out2; |
| const char *exp_out3; |
| const char *snp, *cgs; |
| uint64_t gaddr; |
| size_t igvm_sz; |
| size_t filesize; |
| QFWCFG *fw_cfg; |
| QOSState *qs; |
| VMLaunchUpdate launch_update; |
| |
| if (!qtest_has_machine("q35")) { |
| g_test_skip("q35 machine not available"); |
| return; |
| } |
| |
| if (!qtest_has_accel("kvm")) { |
| g_test_skip("No KVM accelerator available"); |
| return; |
| } |
| |
| if (!qtest_has_device("vm-launch-update")) { |
| g_test_skip("Device vm-launch-update is not available"); |
| return; |
| } |
| |
| set_test_params(&igvm_f, &igvm_init, &snp, &cgs); |
| set_expected_out(&exp_out, &exp_out2, &exp_out3); |
| |
| if (!g_file_test(igvm_f, G_FILE_TEST_EXISTS) || |
| !g_file_test(igvm_init, G_FILE_TEST_EXISTS)) { |
| g_test_skip("igvm file bundle(s) does not exist!"); |
| return; |
| } |
| |
| ser_fd = g_file_open_tmp("launchupdate-qtest-serial-sXXXXXX", |
| &serialtmp, NULL); |
| g_assert_true(ser_fd != -1); |
| |
| if (debug) { |
| fprintf(stderr, "serial console file is %s\n", serialtmp); |
| } |
| |
| qs = set_qemu_args(cgs, NULL, serialtmp, igvm_init, snp); |
| |
| fw_cfg = pc_fw_cfg_init(qs->qts); |
| |
| g_assert_true(wait_for_match(serialtmp, exp_out3, WAIT_SEC, 1) == 0); |
| |
| if (debug) { |
| fprintf(stderr, "initially booted with host igvm\n"); |
| } |
| |
| g_assert_true(load_image(igvm_f, &igvm_blob, &igvm_sz) == igvm_sz); |
| |
| /* create a data buffer in guest memory */ |
| gaddr = guest_alloc(&qs->alloc, igvm_sz); |
| |
| if (debug) { |
| fprintf(stderr, "guest paddr: %"PRIx64 " igvm size: %lu\n", |
| gaddr, igvm_sz); |
| } |
| |
| if (debug) { |
| fprintf(stderr, "writing igvm file into the guest memory\n"); |
| } |
| |
| qtest_bufwrite(qs->qts, gaddr, igvm_blob, igvm_sz); |
| |
| if (debug) { |
| fprintf(stderr, |
| "tell hypervisor where igvm is loaded in guest memory\n"); |
| } |
| |
| /* now tell hypervisor where we loaded the bios */ |
| memset(&launch_update, 0, sizeof(launch_update)); |
| launch_update.fw_image_size = cpu_to_le64(igvm_sz); |
| launch_update.fw_image_addr = cpu_to_le64(gaddr); |
| |
| /* set both host ctrl and format_igvm ctrl once */ |
| launch_update.control |= VM_LAUNCHUPDATE_FORMAT_IGVM; |
| launch_update.control |= VM_LAUNCHUPDATE_CTL_HOST_IGVM; |
| |
| filesize = qfw_cfg_write_file(fw_cfg, qs, FILE_VMLAUNCHUPDATE, |
| &launch_update, sizeof(launch_update)); |
| g_assert_cmpint(filesize, ==, sizeof(launch_update)); |
| |
| if (debug) { |
| fprintf(stderr, "resetting the virtual machine. This should load " |
| "user provided igvm.\n"); |
| } |
| |
| qtest_system_reset(qs->qts); |
| |
| /* expected string should be printed on the console */ |
| g_assert_true(wait_for_match(serialtmp, exp_out, WAIT_SEC, 1) == 0); |
| g_assert_true(wait_for_match(serialtmp, exp_out2, WAIT_SEC, 1) == 0); |
| |
| if (debug) { |
| fprintf(stderr, "hello world found on console\n"); |
| fprintf(stderr, "Now resetting again in order to reset to host igvm\n"); |
| } |
| |
| qtest_system_reset(qs->qts); |
| |
| /* |
| * exp_out3 should be printed twice, once from initial boot, |
| * once from restoring host igvm. |
| */ |
| g_assert_true(wait_for_match(serialtmp, exp_out3, WAIT_SEC, 2) == 0); |
| |
| if (debug) { |
| fprintf(stderr, "booted with host igvm\n"); |
| } |
| |
| close(ser_fd); |
| guest_free(&qs->alloc, gaddr); |
| pc_fw_cfg_uninit(fw_cfg); |
| /* qtest_quit() kils QEMU, first by sending SIGTERM, then SIGKILL */ |
| qtest_quit(qs->qts); |
| } |
| |
| int main(int argc, char **argv) |
| { |
| const char *arch = qtest_get_arch(); |
| |
| g_test_init(&argc, &argv, NULL); |
| |
| if (strcmp(arch, "x86_64")) { |
| g_test_skip("vmlaunchupdate tests are only available on x86_64\n"); |
| return 0; |
| } |
| |
| g_test_add_func("/vm-launch-update/cap", test_vm_launch_update_capability); |
| g_test_add_func("/vm-launch-update/disabled", |
| test_vm_launch_update_disable); |
| |
| g_test_add_func("/vm-launch-update/errorcheck", check_error); |
| g_test_add_func("/vm-launch-update/load_igvm", |
| test_load_igvm); |
| g_test_add_func("/vm-launch-update/ctrl_set_once", |
| test_set_ctrl_once_and_reset_to_host_igvm); |
| |
| if (getenv("LAUNCHUPDATE_DEBUG")) { |
| debug = true; |
| } |
| if (getenv("LAUNCHUPDATE_TRACE")) { |
| trace = true; |
| } |
| if (getenv("COCO")) { |
| confidential = true; |
| } |
| |
| return g_test_run(); |
| } |
