qemuxml2xmltest.c 54.6 KB
Newer Older
1
#include <config.h>
2 3

#include <unistd.h>
4 5 6 7

#include <sys/types.h>
#include <fcntl.h>

8 9
#include "testutils.h"

10 11
#ifdef WITH_QEMU

12
# include "internal.h"
J
Ján Tomko 已提交
13
# include "qemu/qemu_domain_address.h"
M
Matthias Bolte 已提交
14
# include "qemu/qemu_domain.h"
15
# include "testutilsqemu.h"
16
# include "virstring.h"
17 18
# include "virfilewrapper.h"
# include "configmake.h"
19

20 21
# define VIR_FROM_THIS VIR_FROM_NONE

22
static virQEMUDriver driver;
23

24 25 26 27 28 29
enum {
    WHEN_INACTIVE = 1,
    WHEN_ACTIVE = 2,
    WHEN_BOTH = 3,
};

30

31 32 33
static int
testXML2XMLActive(const void *opaque)
{
34
    const struct testQemuInfo *info = opaque;
35

36
    return testCompareDomXML2XMLFiles(driver.caps, driver.xmlopt,
37
                                      info->infile, info->outfile, true, 0,
38
                                      TEST_COMPARE_DOM_XML2XML_RESULT_SUCCESS);
39 40
}

41

42
static int
43
testXML2XMLInactive(const void *opaque)
44
{
45
    const struct testQemuInfo *info = opaque;
46

47 48
    return testCompareDomXML2XMLFiles(driver.caps, driver.xmlopt,
                                      info->infile, info->outfile, false, 0,
49
                                      TEST_COMPARE_DOM_XML2XML_RESULT_SUCCESS);
50
}
51

52

53 54 55
static int
testCompareStatusXMLToXMLFiles(const void *opaque)
{
56
    const struct testQemuInfo *data = opaque;
57 58 59 60
    virDomainObjPtr obj = NULL;
    char *actual = NULL;
    int ret = -1;

61
    if (!(obj = virDomainObjParseFile(data->infile, driver.xmlopt,
62 63 64 65
                                      VIR_DOMAIN_DEF_PARSE_STATUS |
                                      VIR_DOMAIN_DEF_PARSE_ACTUAL_NET |
                                      VIR_DOMAIN_DEF_PARSE_PCI_ORIG_STATES |
                                      VIR_DOMAIN_DEF_PARSE_SKIP_VALIDATE |
66
                                      VIR_DOMAIN_DEF_PARSE_ALLOW_POST_PARSE_FAIL))) {
67
        VIR_TEST_DEBUG("\nfailed to parse '%s'", data->infile);
68
        goto cleanup;
69
    }
70

71
    if (!(actual = virDomainObjFormat(obj, driver.xmlopt,
72 73 74 75
                                      VIR_DOMAIN_DEF_FORMAT_SECURE |
                                      VIR_DOMAIN_DEF_FORMAT_STATUS |
                                      VIR_DOMAIN_DEF_FORMAT_ACTUAL_NET |
                                      VIR_DOMAIN_DEF_FORMAT_PCI_ORIG_STATES |
76
                                      VIR_DOMAIN_DEF_FORMAT_CLOCK_ADJUST))) {
77
        VIR_TEST_DEBUG("\nfailed to format back '%s'", data->infile);
78
        goto cleanup;
79
    }
80

81
    if (virTestCompareToFile(actual, data->outfile) < 0)
82 83 84 85 86
        goto cleanup;

    ret = 0;

 cleanup:
87
    virDomainObjEndAPI(&obj);
88 89 90 91 92 93
    VIR_FREE(actual);
    return ret;
}


static int
94
testInfoSetPaths(struct testQemuInfo *info,
95
                 const char *suffix,
96
                 int when)
97
{
98 99 100
    VIR_FREE(info->infile);
    VIR_FREE(info->outfile);

101 102
    info->infile = g_strdup_printf("%s/qemuxml2argvdata/%s.xml", abs_srcdir,
                                   info->name);
103

104 105 106
    info->outfile = g_strdup_printf("%s/qemuxml2xmloutdata/%s-%s%s.xml",
                                    abs_srcdir, info->name,
                                    when == WHEN_ACTIVE ? "active" : "inactive", suffix);
107

108 109
    if (!virFileExists(info->outfile)) {
        VIR_FREE(info->outfile);
110

111 112
        info->outfile = g_strdup_printf("%s/qemuxml2xmloutdata/%s%s.xml",
                                        abs_srcdir, info->name, suffix);
113
    }
114

115
    return 0;
116 117
}

118 119 120

static const char *statusPath = abs_srcdir "/qemustatusxml2xmldata/";

121
static void
122
testInfoSetStatusPaths(struct testQemuInfo *info)
123
{
124 125
    info->infile = g_strdup_printf("%s%s-in.xml", statusPath, info->name);
    info->outfile = g_strdup_printf("%s%s-out.xml", statusPath, info->name);
126 127 128
}


A
Andrea Bolognani 已提交
129
# define FAKEROOTDIRTEMPLATE abs_builddir "/fakerootdir-XXXXXX"
130

131
static int
E
Eric Blake 已提交
132
mymain(void)
133 134
{
    int ret = 0;
A
Andrea Bolognani 已提交
135
    char *fakerootdir;
136
    virQEMUDriverConfigPtr cfg = NULL;
137 138 139 140 141
    virHashTablePtr capslatest = NULL;

    capslatest = testQemuGetLatestCaps();
    if (!capslatest)
        return EXIT_FAILURE;
142

143
    fakerootdir = g_strdup(FAKEROOTDIRTEMPLATE);
A
Andrea Bolognani 已提交
144

J
Ján Tomko 已提交
145
    if (!g_mkdtemp(fakerootdir)) {
A
Andrea Bolognani 已提交
146 147 148 149 150 151
        fprintf(stderr, "Cannot create fakerootdir");
        abort();
    }

    setenv("LIBVIRT_FAKE_ROOT_DIR", fakerootdir, 1);

152 153 154 155 156 157 158 159 160
    /* Required for tpm-emulator tests
     */
    virFileWrapperAddPrefix(SYSCONFDIR "/qemu/firmware",
                            abs_srcdir "/qemufirmwaredata/etc/qemu/firmware");
    virFileWrapperAddPrefix(PREFIX "/share/qemu/firmware",
                            abs_srcdir "/qemufirmwaredata/usr/share/qemu/firmware");
    virFileWrapperAddPrefix("/home/user/.config/qemu/firmware",
                            abs_srcdir "/qemufirmwaredata/home/user/.config/qemu/firmware");

161
    if (qemuTestDriverInit(&driver) < 0)
162
        return EXIT_FAILURE;
163

164 165
    cfg = virQEMUDriverGetConfig(&driver);

166
# define DO_TEST_INTERNAL(_name, suffix, when, ...) \
167
    do { \
168 169 170
        static struct testQemuInfo info = { \
            .name = _name, \
        }; \
171
        if (testQemuInfoSetArgs(&info, capslatest, \
172
                                __VA_ARGS__, \
173 174
                                ARG_END) < 0 || \
            qemuTestCapsCacheInsert(driver.qemuCapsCache, info.qemuCaps) < 0) { \
175
            VIR_TEST_DEBUG("Failed to generate test data for '%s'", _name); \
176 177 178
            return -1; \
        } \
 \
179
        if (when & WHEN_INACTIVE) { \
180
            if (testInfoSetPaths(&info, suffix, WHEN_INACTIVE) < 0) { \
181
                VIR_TEST_DEBUG("Failed to generate inactive paths for '%s'", _name); \
182 183
                return -1; \
            } \
184
            if (virTestRun("QEMU XML-2-XML-inactive " _name, \
185 186 187 188
                            testXML2XMLInactive, &info) < 0) \
                ret = -1; \
        } \
 \
189
        if (when & WHEN_ACTIVE) { \
190
            if (testInfoSetPaths(&info, suffix, WHEN_ACTIVE) < 0) { \
191
                VIR_TEST_DEBUG("Failed to generate active paths for '%s'", _name); \
192 193
                return -1; \
            } \
194
            if (virTestRun("QEMU XML-2-XML-active " _name, \
195 196 197
                            testXML2XMLActive, &info) < 0) \
                ret = -1; \
        } \
198
        testQemuInfoClear(&info); \
199 200
    } while (0)

201 202 203 204 205 206 207 208 209
# define DO_TEST_CAPS_INTERNAL(name, arch, ver, ...) \
    DO_TEST_INTERNAL(name, "." arch "-" ver, WHEN_BOTH, \
                     ARG_CAPS_ARCH, arch, \
                     ARG_CAPS_VER, ver, \
                     __VA_ARGS__)

# define DO_TEST_CAPS_ARCH_LATEST_FULL(name, arch, ...) \
    DO_TEST_CAPS_INTERNAL(name, arch, "latest", __VA_ARGS__)

210 211 212
# define DO_TEST_CAPS_ARCH_VER_FULL(name, arch, ver, ...) \
    DO_TEST_CAPS_INTERNAL(name, arch, ver, __VA_ARGS__)

213 214 215
# define DO_TEST_CAPS_ARCH_LATEST(name, arch) \
    DO_TEST_CAPS_ARCH_LATEST_FULL(name, arch, ARG_END)

216
# define DO_TEST_CAPS_ARCH_VER(name, arch, ver) \
217
    DO_TEST_CAPS_ARCH_VER_FULL(name, arch, ver, ARG_END)
218

219 220
# define DO_TEST_CAPS_LATEST(name) \
    DO_TEST_CAPS_ARCH_LATEST(name, "x86_64")
221

222 223 224 225 226 227 228 229 230 231 232
# define DO_TEST_CAPS_VER(name, ver) \
    DO_TEST_CAPS_ARCH_VER(name, "x86_64", ver)

# define DO_TEST_FULL(name, when, ...) \
    DO_TEST_INTERNAL(name, "", when, __VA_ARGS__)

# define DO_TEST(name, ...) \
    DO_TEST_FULL(name, WHEN_BOTH, \
                 ARG_QEMU_CAPS, __VA_ARGS__, QEMU_CAPS_LAST)

# define NONE QEMU_CAPS_LAST
233 234 235 236 237

    /* Unset or set all envvars here that are copied in qemudBuildCommandLine
     * using ADD_ENV_COPY, otherwise these tests may fail due to unexpected
     * values for these envvars */
    setenv("PATH", "/bin", 1);
238

239
    DO_TEST("minimal", NONE);
240 241
    DO_TEST_CAPS_LATEST("genid");
    DO_TEST_CAPS_LATEST("genid-auto");
242 243
    DO_TEST("machine-core-on", NONE);
    DO_TEST("machine-core-off", NONE);
244
    DO_TEST("machine-loadparm-multiple-disks-nets-s390", NONE);
245 246 247 248 249
    DO_TEST("default-kvm-host-arch", NONE);
    DO_TEST("default-qemu-host-arch", NONE);
    DO_TEST("boot-cdrom", NONE);
    DO_TEST("boot-network", NONE);
    DO_TEST("boot-floppy", NONE);
250 251 252
    DO_TEST("boot-floppy-q35",
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI);
253
    DO_TEST("boot-multi", NONE);
254
    DO_TEST("boot-menu-enable-with-timeout", QEMU_CAPS_SPLASH_TIMEOUT);
255 256 257 258
    DO_TEST("boot-menu-disable", NONE);
    DO_TEST("boot-menu-disable-with-timeout", NONE);
    DO_TEST("boot-order", NONE);

259 260
    DO_TEST("reboot-timeout-enabled", QEMU_CAPS_REBOOT_TIMEOUT);
    DO_TEST("reboot-timeout-disabled", QEMU_CAPS_REBOOT_TIMEOUT);
261 262 263 264 265 266 267 268

    DO_TEST("clock-utc", NONE);
    DO_TEST("clock-localtime", NONE);
    DO_TEST("cpu-empty", NONE);
    DO_TEST("cpu-kvmclock", NONE);
    DO_TEST("cpu-host-kvmclock", NONE);
    DO_TEST("cpu-host-passthrough-features", NONE);
    DO_TEST("cpu-host-model-features", NONE);
269
    DO_TEST("clock-catchup", QEMU_CAPS_KVM_PIT_TICK_POLICY);
270 271 272 273 274 275 276 277 278 279 280 281 282
    DO_TEST("kvmclock", NONE);
    DO_TEST("clock-timer-hyperv-rtc", NONE);

    DO_TEST("cpu-eoi-disabled", NONE);
    DO_TEST("cpu-eoi-enabled", NONE);
    DO_TEST("eoi-disabled", NONE);
    DO_TEST("eoi-enabled", NONE);
    DO_TEST("pv-spinlock-disabled", NONE);
    DO_TEST("pv-spinlock-enabled", NONE);

    DO_TEST("hyperv", NONE);
    DO_TEST("hyperv-off", NONE);
    DO_TEST("hyperv-panic", NONE);
283
    DO_TEST("hyperv-stimer-direct", NONE);
284 285 286 287 288 289 290

    DO_TEST("kvm-features", NONE);
    DO_TEST("kvm-features-off", NONE);

    DO_TEST("pmu-feature", NONE);
    DO_TEST("pmu-feature-off", NONE);

291
    DO_TEST("pages-discard", NONE);
292
    DO_TEST("pages-discard-hugepages", QEMU_CAPS_OBJECT_MEMORY_FILE);
293
    DO_TEST("pages-dimm-discard", NONE);
294 295
    DO_TEST("hugepages-default", QEMU_CAPS_OBJECT_MEMORY_FILE);
    DO_TEST("hugepages-default-2M", QEMU_CAPS_OBJECT_MEMORY_FILE);
296
    DO_TEST("hugepages-default-system-size", NONE);
297 298 299 300 301 302 303 304 305 306
    DO_TEST("hugepages-nodeset", QEMU_CAPS_OBJECT_MEMORY_FILE);
    DO_TEST("hugepages-numa-default-2M", QEMU_CAPS_OBJECT_MEMORY_FILE);
    DO_TEST("hugepages-numa-default-dimm", QEMU_CAPS_OBJECT_MEMORY_FILE);
    DO_TEST("hugepages-numa-nodeset", QEMU_CAPS_OBJECT_MEMORY_FILE);
    DO_TEST("hugepages-numa-nodeset-part", QEMU_CAPS_OBJECT_MEMORY_FILE);
    DO_TEST("hugepages-shared", QEMU_CAPS_OBJECT_MEMORY_FILE);
    DO_TEST("hugepages-memaccess", QEMU_CAPS_OBJECT_MEMORY_FILE);
    DO_TEST("hugepages-memaccess2", QEMU_CAPS_OBJECT_MEMORY_FILE);
    DO_TEST("hugepages-nvdimm", QEMU_CAPS_DEVICE_NVDIMM,
            QEMU_CAPS_OBJECT_MEMORY_FILE);
307 308 309 310 311 312
    DO_TEST("nosharepages", NONE);
    DO_TEST("restore-v2", NONE);
    DO_TEST("migrate", NONE);
    DO_TEST("qemu-ns-no-env", NONE);
    DO_TEST("disk-aio", NONE);
    DO_TEST("disk-cdrom", NONE);
313
    DO_TEST_CAPS_LATEST("disk-cdrom-empty-network-invalid");
314
    DO_TEST("disk-cdrom-bus-other", NONE);
315 316 317 318
    DO_TEST("disk-floppy", NONE);
    DO_TEST("disk-usb-device", NONE);
    DO_TEST("disk-virtio", NONE);
    DO_TEST("floppy-drive-fat", NONE);
319 320 321 322 323
    DO_TEST("disk-virtio-queues", QEMU_CAPS_VIRTIO_BLK_NUM_QUEUES);
    DO_TEST("disk-boot-disk", NONE);
    DO_TEST("disk-boot-cdrom", NONE);
    DO_TEST("disk-error-policy", NONE);
    DO_TEST("disk-fmt-qcow", NONE);
324
    DO_TEST("disk-cache", QEMU_CAPS_SCSI_LSI);
325
    DO_TEST("disk-network-nbd", NONE);
326
    DO_TEST("disk-network-iscsi", QEMU_CAPS_VIRTIO_SCSI);
327 328 329 330 331 332
    DO_TEST("disk-network-gluster", NONE);
    DO_TEST("disk-network-rbd", NONE);
    DO_TEST("disk-network-source-auth", NONE);
    DO_TEST("disk-network-sheepdog", NONE);
    DO_TEST("disk-network-vxhs", NONE);
    DO_TEST("disk-network-tlsx509", NONE);
333
    DO_TEST("disk-nvme", QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_QCOW2_LUKS);
334 335
    DO_TEST("disk-scsi", QEMU_CAPS_SCSI_LSI, QEMU_CAPS_SCSI_MEGASAS,
            QEMU_CAPS_SCSI_MPTSAS1068, QEMU_CAPS_SCSI_DISK_WWN);
336
    DO_TEST("disk-virtio-scsi-reservations",
337
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_PR_MANAGER_HELPER);
338
    DO_TEST("controller-virtio-scsi", QEMU_CAPS_VIRTIO_SCSI);
339 340 341
    DO_TEST("disk-virtio-s390-zpci",
            QEMU_CAPS_DEVICE_ZPCI,
            QEMU_CAPS_CCW);
342
    DO_TEST("disk-mirror-old", NONE);
343
    DO_TEST("disk-mirror", NONE);
344
    DO_TEST("disk-active-commit", NONE);
345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365
    DO_TEST("graphics-listen-network",
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_VNC);
    DO_TEST("graphics-vnc",
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_VNC);
    DO_TEST("graphics-vnc-websocket",
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_VNC);
    DO_TEST("graphics-vnc-sasl",
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_VNC);
    DO_TEST("graphics-vnc-tls",
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_VNC);
    DO_TEST("graphics-vnc-no-listen-attr",
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_VNC);
    DO_TEST("graphics-vnc-remove-generated-socket",
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_VNC);
366
    cfg->vncAutoUnixSocket = true;
367 368 369
    DO_TEST("graphics-vnc-auto-socket-cfg",
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_VNC);
370
    cfg->vncAutoUnixSocket = false;
371 372 373 374 375 376
    DO_TEST("graphics-vnc-socket",
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_VNC);
    DO_TEST("graphics-vnc-auto-socket",
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_VNC);
377
    DO_TEST("graphics-vnc-egl-headless",
378 379 380
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_EGL_HEADLESS,
            QEMU_CAPS_VNC);
381

382 383 384 385
    DO_TEST_CAPS_ARCH_LATEST("default-video-type-aarch64", "aarch64");
    DO_TEST_CAPS_ARCH_LATEST("default-video-type-ppc64", "ppc64");
    DO_TEST_CAPS_ARCH_LATEST("default-video-type-riscv64", "riscv64");
    DO_TEST_CAPS_ARCH_LATEST("default-video-type-s390x", "s390x");
386 387 388 389 390 391
    DO_TEST("default-video-type-x86_64-caps-test-0",
            QEMU_CAPS_DEVICE_VGA,
            QEMU_CAPS_SPICE);
    DO_TEST("default-video-type-x86_64-caps-test-1",
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_SPICE);
392

393 394
    DO_TEST("graphics-sdl", QEMU_CAPS_DEVICE_VGA);
    DO_TEST("graphics-sdl-fullscreen", QEMU_CAPS_DEVICE_CIRRUS_VGA);
395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414

    cfg->spiceTLS = true;
    DO_TEST("graphics-spice",
            QEMU_CAPS_DEVICE_QXL,
            QEMU_CAPS_SPICE,
            QEMU_CAPS_SPICE_FILE_XFER_DISABLE);
    DO_TEST("graphics-spice-compression",
            QEMU_CAPS_DEVICE_QXL,
            QEMU_CAPS_SPICE);
    DO_TEST("graphics-spice-qxl-vga",
            QEMU_CAPS_DEVICE_QXL,
            QEMU_CAPS_SPICE);
    DO_TEST("graphics-spice-socket",
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_SPICE,
            QEMU_CAPS_SPICE_UNIX);
    DO_TEST("graphics-spice-auto-socket",
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_SPICE,
            QEMU_CAPS_SPICE_UNIX);
415
    cfg->spiceAutoUnixSocket = true;
416 417 418
    DO_TEST("graphics-spice-auto-socket-cfg",
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_SPICE);
419
    cfg->spiceAutoUnixSocket = false;
420
    cfg->spiceTLS = false;
421
    DO_TEST("graphics-spice-egl-headless",
422
            QEMU_CAPS_DEVICE_QXL,
423 424
            QEMU_CAPS_EGL_HEADLESS,
            QEMU_CAPS_SPICE);
425

426
    DO_TEST("graphics-egl-headless-rendernode",
427
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
428
            QEMU_CAPS_EGL_HEADLESS,
429 430
            QEMU_CAPS_EGL_HEADLESS_RENDERNODE,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
431

432 433 434
    DO_TEST("input-usbmouse", NONE);
    DO_TEST("input-usbtablet", NONE);
    DO_TEST("misc-acpi", NONE);
435 436 437 438 439
    DO_TEST("misc-disable-s3", QEMU_CAPS_PIIX_DISABLE_S3);
    DO_TEST("misc-disable-suspends",
            QEMU_CAPS_PIIX_DISABLE_S3,
            QEMU_CAPS_PIIX_DISABLE_S4);
    DO_TEST("misc-enable-s4", QEMU_CAPS_PIIX_DISABLE_S4);
440 441 442 443
    DO_TEST("misc-no-reboot", NONE);
    DO_TEST("misc-uuid", NONE);
    DO_TEST("net-vhostuser", NONE);
    DO_TEST("net-user", NONE);
J
Ján Tomko 已提交
444
    DO_TEST("net-user-addr", NONE);
445 446 447 448 449 450
    DO_TEST("net-virtio", NONE);
    DO_TEST("net-virtio-device", NONE);
    DO_TEST("net-virtio-disable-offloads", NONE);
    DO_TEST("net-eth", NONE);
    DO_TEST("net-eth-ifname", NONE);
    DO_TEST("net-eth-hostip", NONE);
451
    DO_TEST("net-eth-unmanaged-tap", NONE);
452
    DO_TEST("net-virtio-network-portgroup", NONE);
453
    DO_TEST("net-virtio-rxtxqueuesize", NONE);
454
    DO_TEST("net-hostdev", NONE);
455
    DO_TEST("net-hostdev-bootorder", NONE);
456
    DO_TEST("net-hostdev-vfio", QEMU_CAPS_DEVICE_VFIO_PCI);
457 458 459
    DO_TEST("net-midonet", NONE);
    DO_TEST("net-openvswitch", NONE);
    DO_TEST("sound", NONE);
460 461
    DO_TEST("sound-device",
            QEMU_CAPS_DEVICE_ICH9_INTEL_HDA,
462 463 464 465
            QEMU_CAPS_OBJECT_USB_AUDIO,
            QEMU_CAPS_HDA_MICRO,
            QEMU_CAPS_HDA_DUPLEX,
            QEMU_CAPS_HDA_OUTPUT);
466
    DO_TEST("watchdog", NONE);
467 468
    DO_TEST("net-bandwidth", QEMU_CAPS_DEVICE_VGA, QEMU_CAPS_VNC);
    DO_TEST("net-bandwidth2", QEMU_CAPS_DEVICE_VGA, QEMU_CAPS_VNC);
469
    DO_TEST("net-mtu", NONE);
470
    DO_TEST("net-coalesce", NONE);
471
    DO_TEST("net-many-models", NONE);
472

473
    DO_TEST("serial-tcp-tlsx509-chardev", NONE);
474
    DO_TEST("serial-tcp-tlsx509-chardev-notls", NONE);
475 476 477 478 479 480 481

    cfg->spiceTLS = true;
    DO_TEST("serial-spiceport",
            QEMU_CAPS_DEVICE_QXL,
            QEMU_CAPS_SPICE);
    cfg->spiceTLS = false;

482 483 484 485 486 487 488 489
    DO_TEST("serial-spiceport-nospice", NONE);
    DO_TEST("console-compat", NONE);
    DO_TEST("console-compat2", NONE);
    DO_TEST("console-virtio-many", NONE);
    DO_TEST("channel-guestfwd", NONE);
    DO_TEST("channel-virtio", NONE);
    DO_TEST("channel-virtio-state", NONE);

490
    DO_TEST("channel-unix-source-path", NONE);
491

492 493
    DO_TEST("hostdev-usb-address", NONE);
    DO_TEST("hostdev-pci-address", NONE);
494 495
    DO_TEST("hostdev-pci-multifunction", QEMU_CAPS_DEVICE_VFIO_PCI);
    DO_TEST("hostdev-vfio", QEMU_CAPS_DEVICE_VFIO_PCI);
496
    DO_TEST("hostdev-vfio-zpci",
497
            QEMU_CAPS_DEVICE_VFIO_PCI,
498 499
            QEMU_CAPS_DEVICE_ZPCI,
            QEMU_CAPS_CCW);
500 501 502 503 504 505 506 507 508 509 510
    DO_TEST("hostdev-vfio-zpci-multidomain-many",
            QEMU_CAPS_DEVICE_VFIO_PCI,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_ZPCI);
    DO_TEST("hostdev-vfio-zpci-autogenerate",
            QEMU_CAPS_DEVICE_VFIO_PCI,
            QEMU_CAPS_DEVICE_ZPCI);
    DO_TEST("hostdev-vfio-zpci-boundaries",
            QEMU_CAPS_DEVICE_VFIO_PCI,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_ZPCI);
511
    DO_TEST("hostdev-mdev-precreated", QEMU_CAPS_DEVICE_VFIO_PCI);
512 513
    DO_TEST("hostdev-mdev-display",
            QEMU_CAPS_DEVICE_QXL,
514
            QEMU_CAPS_VFIO_PCI_DISPLAY,
515 516
            QEMU_CAPS_DEVICE_VFIO_PCI,
            QEMU_CAPS_VNC);
517
    DO_TEST("pci-rom", NONE);
518
    DO_TEST("pci-rom-disabled", NONE);
519
    DO_TEST("pci-rom-disabled-invalid", NONE);
520 521
    DO_TEST("pci-serial-dev-chardev", NONE);

522 523
    DO_TEST("encrypted-disk", QEMU_CAPS_QCOW2_LUKS);
    DO_TEST("encrypted-disk-usage", QEMU_CAPS_QCOW2_LUKS);
524
    DO_TEST("luks-disks", NONE);
525
    DO_TEST("luks-disks-source", NONE);
526 527 528 529 530 531 532 533 534
    DO_TEST("memtune", NONE);
    DO_TEST("memtune-unlimited", NONE);
    DO_TEST("blkiotune", NONE);
    DO_TEST("blkiotune-device", NONE);
    DO_TEST("cputune", NONE);
    DO_TEST("cputune-zero-shares", NONE);
    DO_TEST("cputune-iothreadsched", NONE);
    DO_TEST("cputune-iothreadsched-zeropriority", NONE);
    DO_TEST("cputune-numatune", NONE);
535
    DO_TEST("vcpu-placement-static",
536 537
            QEMU_CAPS_KVM,
            QEMU_CAPS_OBJECT_IOTHREAD);
538

539 540 541 542 543 544
    DO_TEST("smp", NONE);
    DO_TEST("iothreads", NONE);
    DO_TEST("iothreads-ids", NONE);
    DO_TEST("iothreads-ids-partial", NONE);
    DO_TEST("cputune-iothreads", NONE);
    DO_TEST("iothreads-disk", NONE);
545
    DO_TEST("iothreads-disk-virtio-ccw",
546
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
547
    DO_TEST("iothreads-virtio-scsi-pci",
548
            QEMU_CAPS_VIRTIO_SCSI);
549
    DO_TEST("iothreads-virtio-scsi-ccw",
550
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_CCW,
551
            QEMU_CAPS_VIRTIO_S390);
552 553 554 555
    DO_TEST("lease", NONE);
    DO_TEST("event_idx", NONE);
    DO_TEST("vhost_queues", NONE);
    DO_TEST("interface-driver", NONE);
556
    DO_TEST("interface-server", QEMU_CAPS_DEVICE_CIRRUS_VGA,
557 558
            QEMU_CAPS_OBJECT_MEMORY_FILE,
            QEMU_CAPS_PIIX_DISABLE_S3,
559 560
            QEMU_CAPS_PIIX_DISABLE_S4,
            QEMU_CAPS_VNC);
561 562
    DO_TEST("virtio-lun", NONE);

563 564 565 566 567
    DO_TEST("usb-none", NONE);
    DO_TEST("usb-controller", NONE);
    DO_TEST("usb-piix3-controller",
            QEMU_CAPS_PIIX3_USB_UHCI);
    DO_TEST("usb-controller-default-q35",
568
            QEMU_CAPS_DEVICE_IOH3420,
569 570
            QEMU_CAPS_PCI_OHCI,
            QEMU_CAPS_PIIX3_USB_UHCI,
571 572
            QEMU_CAPS_NEC_USB_XHCI);
    DO_TEST("usb-controller-explicit-q35",
573
            QEMU_CAPS_DEVICE_IOH3420,
574 575
            QEMU_CAPS_PCI_OHCI,
            QEMU_CAPS_PIIX3_USB_UHCI,
576 577
            QEMU_CAPS_NEC_USB_XHCI);
    DO_TEST("ppc64-usb-controller",
578
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
579 580
            QEMU_CAPS_PCI_OHCI);
    DO_TEST("ppc64-usb-controller-legacy",
581
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
582
            QEMU_CAPS_PIIX3_USB_UHCI);
583
    DO_TEST("usb-port-missing", QEMU_CAPS_USB_HUB);
584 585 586 587
    DO_TEST("usb-redir", NONE);
    DO_TEST("usb-redir-filter", NONE);
    DO_TEST("usb-redir-filter-version", NONE);
    DO_TEST("blkdeviotune", NONE);
588
    DO_TEST("blkdeviotune-max", NONE);
589
    DO_TEST("blkdeviotune-group-num", NONE);
590
    DO_TEST("blkdeviotune-max-length", NONE);
591 592 593
    DO_TEST("controller-usb-order",
            QEMU_CAPS_PIIX_DISABLE_S3,
            QEMU_CAPS_PIIX_DISABLE_S4);
594

595 596 597 598 599 600 601 602
    DO_TEST_FULL("seclabel-dynamic-baselabel", WHEN_INACTIVE,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("seclabel-dynamic-override", WHEN_INACTIVE,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("seclabel-dynamic-labelskip", WHEN_INACTIVE,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("seclabel-dynamic-relabel", WHEN_INACTIVE,
                 ARG_QEMU_CAPS, NONE);
603
    DO_TEST("seclabel-static", NONE);
604
    DO_TEST("seclabel-static-labelskip", NONE);
605 606 607 608
    DO_TEST("seclabel-none", NONE);
    DO_TEST("seclabel-dac-none", NONE);
    DO_TEST("seclabel-dynamic-none", NONE);
    DO_TEST("seclabel-device-multiple", NONE);
609
    DO_TEST_FULL("seclabel-dynamic-none-relabel", WHEN_INACTIVE,
610
                 ARG_QEMU_CAPS, QEMU_CAPS_DEVICE_CIRRUS_VGA,
611 612
                 QEMU_CAPS_OBJECT_MEMORY_FILE,
                 QEMU_CAPS_SPICE, NONE);
613
    DO_TEST("numad-static-vcpu-no-numatune", NONE);
614

615
    DO_TEST("disk-scsi-lun-passthrough-sgio",
616
            QEMU_CAPS_SCSI_LSI, QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_DISK_WWN);
617
    DO_TEST("disk-scsi-disk-vpd",
618
            QEMU_CAPS_SCSI_LSI, QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_DISK_WWN);
619 620
    DO_TEST("disk-source-pool", NONE);
    DO_TEST("disk-source-pool-mode", NONE);
621

622 623
    DO_TEST("disk-discard", NONE);
    DO_TEST("disk-detect-zeroes", NONE);
O
Osier Yang 已提交
624

625 626
    DO_TEST("disk-serial", NONE);

627 628 629 630
    DO_TEST("virtio-rng-random",
            QEMU_CAPS_DEVICE_VIRTIO_RNG);
    DO_TEST("virtio-rng-egd",
            QEMU_CAPS_DEVICE_VIRTIO_RNG);
631

632
    DO_TEST("pseries-nvram",
633 634
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_DEVICE_NVRAM);
635 636 637 638
    DO_TEST("pseries-panic-missing",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
    DO_TEST("pseries-panic-no-address",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
639

640 641 642 643
    DO_TEST("pseries-phb-simple",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
    DO_TEST("pseries-phb-default-missing",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
644 645 646
    DO_TEST("pseries-phb-numa-node",
            QEMU_CAPS_NUMA,
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
647 648
            QEMU_CAPS_SPAPR_PCI_HOST_BRIDGE_NUMA_NODE,
            QEMU_CAPS_OBJECT_MEMORY_FILE);
649

650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671
    DO_TEST("pseries-many-devices",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST("pseries-many-buses-1",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST("pseries-many-buses-2",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_VIRTIO_SCSI);
    DO_TEST("pseries-hostdevs-1",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_VFIO_PCI);
    DO_TEST("pseries-hostdevs-2",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_VFIO_PCI);
    DO_TEST("pseries-hostdevs-3",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_VFIO_PCI);

672
    DO_TEST("pseries-features",
673
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
674
            QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
675
            QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
676
            QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
677
            QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST,
678 679
            QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT);

680
    DO_TEST("pseries-serial-native",
681
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
682 683
            QEMU_CAPS_DEVICE_SPAPR_VTY);
    DO_TEST("pseries-serial+console-native",
684
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
685 686
            QEMU_CAPS_DEVICE_SPAPR_VTY);
    DO_TEST("pseries-serial-compat",
687
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
688
            QEMU_CAPS_DEVICE_SPAPR_VTY);
689
    DO_TEST("pseries-serial-pci",
690
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
691 692
            QEMU_CAPS_DEVICE_PCI_SERIAL);
    DO_TEST("pseries-serial-usb",
693
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
694 695
            QEMU_CAPS_DEVICE_QEMU_XHCI,
            QEMU_CAPS_DEVICE_USB_SERIAL);
696
    DO_TEST("pseries-console-native",
697
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
698 699
            QEMU_CAPS_DEVICE_SPAPR_VTY);
    DO_TEST("pseries-console-virtio",
700 701 702 703 704
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);

    DO_TEST("mach-virt-serial-native", NONE);
    DO_TEST("mach-virt-serial+console-native", NONE);
    DO_TEST("mach-virt-serial-compat", NONE);
705 706 707 708 709 710 711 712 713 714 715
    DO_TEST("mach-virt-serial-pci",
            QEMU_CAPS_OBJECT_GPEX,
            QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_PCI_SERIAL);
    DO_TEST("mach-virt-serial-usb",
            QEMU_CAPS_OBJECT_GPEX,
            QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
            QEMU_CAPS_DEVICE_QEMU_XHCI,
            QEMU_CAPS_DEVICE_USB_SERIAL);
716 717 718 719
    DO_TEST("mach-virt-console-native",
            QEMU_CAPS_DEVICE_PL011);
    DO_TEST("mach-virt-console-virtio",
            QEMU_CAPS_DEVICE_VIRTIO_MMIO);
720

721 722 723 724
    DO_TEST("balloon-device-auto", NONE);
    DO_TEST("balloon-device-period", NONE);
    DO_TEST("channel-virtio-auto", NONE);
    DO_TEST("console-compat-auto", NONE);
725
    DO_TEST("disk-scsi-device-auto",
726
            QEMU_CAPS_SCSI_LSI);
727 728
    DO_TEST("console-virtio", NONE);
    DO_TEST("serial-target-port-auto", NONE);
729 730 731
    DO_TEST("graphics-listen-network2",
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
            QEMU_CAPS_VNC);
732 733 734
    DO_TEST("graphics-spice-timeout",
            QEMU_CAPS_DEVICE_VGA,
            QEMU_CAPS_SPICE);
735 736 737 738 739
    DO_TEST("numad-auto-vcpu-no-numatune", NONE);
    DO_TEST("numad-auto-memory-vcpu-no-cpuset-and-placement", NONE);
    DO_TEST("numad-auto-memory-vcpu-cpuset", NONE);
    DO_TEST("usb-ich9-ehci-addr", NONE);
    DO_TEST("disk-copy_on_read", NONE);
740 741 742 743 744
    DO_TEST_CAPS_LATEST("tpm-passthrough");
    DO_TEST_CAPS_LATEST("tpm-passthrough-crb");
    DO_TEST_CAPS_LATEST("tpm-emulator");
    DO_TEST_CAPS_LATEST("tpm-emulator-tpm2");
    DO_TEST_CAPS_LATEST("tpm-emulator-tpm2-enc");
745 746 747

    DO_TEST("metadata", NONE);
    DO_TEST("metadata-duplicate", NONE);
748

749
    DO_TEST("pci-bridge",
750 751 752 753 754
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
    DO_TEST("pci-many",
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
755 756 757
    DO_TEST("pci-bridge-many-disks",
            QEMU_CAPS_DEVICE_PCI_BRIDGE);
    DO_TEST("pci-autoadd-addr",
758 759
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
760
    DO_TEST("pci-autoadd-idx",
761 762
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
763
    DO_TEST("pci-autofill-addr", QEMU_CAPS_DEVICE_CIRRUS_VGA);
764

765
    DO_TEST("q35",
766 767
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
768
            QEMU_CAPS_DEVICE_IOH3420,
769 770 771
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
772
            QEMU_CAPS_DEVICE_QXL);
773 774 775
    DO_TEST("q35-usb2",
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
776
            QEMU_CAPS_DEVICE_IOH3420,
777
            QEMU_CAPS_ICH9_AHCI,
778
            QEMU_CAPS_ICH9_USB_EHCI1,
779
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
780
            QEMU_CAPS_DEVICE_QXL);
781
    DO_TEST("q35-usb2-multi",
782 783
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
784
            QEMU_CAPS_DEVICE_IOH3420,
785 786 787
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
788
            QEMU_CAPS_DEVICE_QXL);
789
    DO_TEST("q35-usb2-reorder",
790 791
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
792
            QEMU_CAPS_DEVICE_IOH3420,
793 794 795
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
796
            QEMU_CAPS_DEVICE_QXL);
797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813
    DO_TEST("q35-pcie",
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
814
            QEMU_CAPS_NEC_USB_XHCI,
815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
    /* same XML as q35-pcie, but don't set
       QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY */
    DO_TEST("q35-virtio-pci",
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
834
            QEMU_CAPS_NEC_USB_XHCI,
835
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
836 837 838 839 840 841 842 843 844
    /* same as q35-pcie, but all PCI controllers are added automatically */
    DO_TEST("q35-pcie-autoadd",
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_NEC_USB_XHCI,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
    DO_TEST("q35-default-devices-only",
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
864 865 866 867 868 869 870 871 872 873
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_NEC_USB_XHCI,
874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
    DO_TEST("q35-multifunction",
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_NEC_USB_XHCI,
893
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
894
    DO_TEST("q35-virt-manager-basic",
895 896 897
            QEMU_CAPS_KVM,
            QEMU_CAPS_ICH9_DISABLE_S3,
            QEMU_CAPS_ICH9_DISABLE_S4,
898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_DEVICE_VIRTIO_NET,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_NEC_USB_XHCI,
            QEMU_CAPS_DEVICE_ICH9_INTEL_HDA,
916 917 918 919
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_SPICE,
            QEMU_CAPS_DEVICE_QXL,
            QEMU_CAPS_HDA_DUPLEX,
920 921
            QEMU_CAPS_USB_REDIR,
            QEMU_CAPS_MACHINE_VMPORT_OPT);
922
    DO_TEST("pcie-root",
923 924
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
925
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
926
            QEMU_CAPS_DEVICE_QXL);
927 928

    /* Test automatic and manual setting of pcie-root-port attributes */
929
    DO_TEST("pcie-root-port",
930 931
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
932
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
933
            QEMU_CAPS_DEVICE_QXL);
934 935 936 937 938 939

    /* Make sure the default model for PCIe Root Ports is picked correctly
     * based on QEMU binary capabilities. We use x86/q35 for the test, but
     * any PCIe machine type (such as aarch64/virt) will behave the same */
    DO_TEST("pcie-root-port-model-generic",
            QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
940
            QEMU_CAPS_DEVICE_IOH3420);
941
    DO_TEST("pcie-root-port-model-ioh3420",
942
            QEMU_CAPS_DEVICE_IOH3420);
943

944
    DO_TEST("pcie-switch-upstream-port",
945 946 947
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_ICH9_AHCI,
948
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
949
            QEMU_CAPS_DEVICE_QXL);
950
    DO_TEST("pcie-switch-downstream-port",
951 952 953 954
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
            QEMU_CAPS_ICH9_AHCI,
955
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
956
            QEMU_CAPS_DEVICE_QXL);
957
    DO_TEST("pci-expander-bus",
958
            QEMU_CAPS_DEVICE_PXB);
959
    DO_TEST("pcie-expander-bus",
960 961 962 963
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
            QEMU_CAPS_DEVICE_PXB_PCIE);
964
    DO_TEST("autoindex",
965 966 967 968 969 970 971
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
972
            QEMU_CAPS_NEC_USB_XHCI);
973 974 975 976 977 978 979
    /* Make sure the user can always override libvirt's default device
     * placement policy by providing an explicit PCI address */
    DO_TEST("q35-pci-force-address",
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_HDA_DUPLEX);
980

981 982
    DO_TEST("hostdev-scsi-vhost-scsi-ccw",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
983
            QEMU_CAPS_CCW);
984
    DO_TEST("hostdev-scsi-vhost-scsi-pci",
985 986
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_VHOST_SCSI);
987 988 989 990 991
    DO_TEST("hostdev-scsi-vhost-scsi-pcie",
            QEMU_CAPS_KVM,
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
            QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY);
992
    DO_TEST("hostdev-scsi-lsi",
993 994
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
995
    DO_TEST("hostdev-scsi-virtio-scsi",
996 997
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
998
    DO_TEST("hostdev-scsi-readonly",
999 1000
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
1001 1002

    DO_TEST("hostdev-scsi-shareable",
1003 1004
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
1005
    DO_TEST("hostdev-scsi-sgio",
1006 1007
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
1008
    DO_TEST("hostdev-scsi-rawio",
1009 1010
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
1011 1012

    DO_TEST("hostdev-scsi-autogen-address",
1013 1014
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
1015
    DO_TEST("hostdev-scsi-large-unit",
1016 1017
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
1018 1019

    DO_TEST("hostdev-scsi-lsi-iscsi",
1020 1021
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
1022
    DO_TEST("hostdev-scsi-lsi-iscsi-auth",
1023 1024
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
1025
    DO_TEST("hostdev-scsi-virtio-iscsi",
1026 1027
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
1028
    DO_TEST("hostdev-scsi-virtio-iscsi-auth",
1029 1030
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
1031

1032 1033 1034 1035
    DO_TEST("hostdev-subsys-mdev-vfio-ccw",
            QEMU_CAPS_CCW,
            QEMU_CAPS_CCW_CSSID_UNRESTRICTED,
            QEMU_CAPS_DEVICE_VFIO_CCW);
1036 1037
    DO_TEST_CAPS_ARCH_LATEST("hostdev-subsys-mdev-vfio-ccw-boot",
                             "s390x");
B
Boris Fiuczynski 已提交
1038 1039 1040 1041
    DO_TEST("hostdev-subsys-mdev-vfio-ap",
            QEMU_CAPS_CCW,
            QEMU_CAPS_CCW_CSSID_UNRESTRICTED,
            QEMU_CAPS_DEVICE_VFIO_AP);
1042

1043
    DO_TEST("s390-defaultconsole",
1044
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
1045
    DO_TEST("s390-panic",
1046
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
1047
    DO_TEST("s390-panic-missing",
1048
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
1049
    DO_TEST("s390-panic-no-address",
1050
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
1051
    DO_TEST("s390-serial",
1052
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
1053
    DO_TEST("s390-serial-2",
1054
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
1055
    DO_TEST("s390-serial-console",
1056
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
1057

1058 1059 1060
    DO_TEST("pcihole64", QEMU_CAPS_I440FX_PCI_HOLE64_SIZE);
    DO_TEST("pcihole64-gib", QEMU_CAPS_I440FX_PCI_HOLE64_SIZE);
    DO_TEST("pcihole64-none", QEMU_CAPS_I440FX_PCI_HOLE64_SIZE);
1061
    DO_TEST("pcihole64-q35",
1062
            QEMU_CAPS_DEVICE_IOH3420,
1063 1064
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
1065
            QEMU_CAPS_DEVICE_QXL,
1066
            QEMU_CAPS_Q35_PCI_HOLE64_SIZE);
1067

1068 1069
    DO_TEST("panic", NONE);
    DO_TEST("panic-isa", NONE);
1070 1071
    DO_TEST("panic-pseries",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
1072 1073
    DO_TEST("panic-double", NONE);
    DO_TEST("panic-no-address", NONE);
H
Hu Tao 已提交
1074

1075
    DO_TEST("disk-backing-chains", NONE);
1076 1077
    DO_TEST("disk-backing-chains-index", NONE);
    DO_TEST("disk-backing-chains-noindex", NONE);
1078

1079 1080
    DO_TEST("chardev-label",
            QEMU_CAPS_DEVICE_VIRTIO_RNG);
J
Ján Tomko 已提交
1081

1082 1083 1084 1085
    DO_TEST("cpu-numa1", NONE);
    DO_TEST("cpu-numa2", NONE);
    DO_TEST("cpu-numa-no-memory-element", NONE);
    DO_TEST("cpu-numa-disordered", NONE);
1086 1087
    DO_TEST("cpu-numa-disjoint", QEMU_CAPS_NUMA);
    DO_TEST("cpu-numa-memshared", QEMU_CAPS_OBJECT_MEMORY_FILE);
1088

1089
    DO_TEST("numatune-auto-prefer", NONE);
1090 1091
    DO_TEST("numatune-memnode", QEMU_CAPS_NUMA, QEMU_CAPS_OBJECT_MEMORY_FILE);
    DO_TEST("numatune-memnode-no-memory", QEMU_CAPS_OBJECT_MEMORY_FILE);
1092

1093 1094
    DO_TEST("bios-nvram", NONE);
    DO_TEST("bios-nvram-os-interleave", NONE);
1095

1096 1097 1098
    DO_TEST("tap-vhost", NONE);
    DO_TEST("tap-vhost-incorrect", NONE);
    DO_TEST("shmem", NONE);
1099
    DO_TEST("shmem-plain-doorbell", NONE);
1100 1101
    DO_TEST("smbios", NONE);
    DO_TEST("smbios-multiple-type2", NONE);
1102

1103 1104 1105
    DO_TEST_CAPS_LATEST("os-firmware-bios");
    DO_TEST_CAPS_LATEST("os-firmware-efi");
    DO_TEST_CAPS_LATEST("os-firmware-efi-secboot");
1106

1107
    DO_TEST("aarch64-aavmf-virtio-mmio",
1108 1109
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM);
1110
    DO_TEST_CAPS_ARCH_LATEST("aarch64-os-firmware-efi", "aarch64");
1111
    DO_TEST("aarch64-virtio-pci-default",
1112
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
1113 1114 1115
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_OBJECT_GPEX, QEMU_CAPS_DEVICE_PCI_BRIDGE,
1116 1117 1118
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_VIRTIO_SCSI);
1119
    DO_TEST("aarch64-virtio-pci-manual-addresses",
1120 1121 1122
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_OBJECT_GPEX, QEMU_CAPS_DEVICE_PCI_BRIDGE,
1123 1124 1125
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_VIRTIO_SCSI);
1126
    DO_TEST("aarch64-video-virtio-gpu-pci",
1127
            QEMU_CAPS_OBJECT_GPEX,
1128
            QEMU_CAPS_DEVICE_PCI_BRIDGE, QEMU_CAPS_DEVICE_IOH3420,
1129
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
1130
            QEMU_CAPS_DEVICE_VIRTIO_GPU);
1131 1132 1133 1134 1135 1136 1137
    DO_TEST("aarch64-pci-serial",
            QEMU_CAPS_DEVICE_PCI_SERIAL,
            QEMU_CAPS_CHARDEV_LOGFILE,
            QEMU_CAPS_OBJECT_GPEX,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_PCIE_ROOT_PORT);
1138 1139 1140 1141
    DO_TEST("aarch64-traditional-pci",
            QEMU_CAPS_OBJECT_GPEX,
            QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
1142
            QEMU_CAPS_DEVICE_PCIE_PCI_BRIDGE,
1143 1144
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_PCI_SERIAL);
1145 1146 1147 1148 1149 1150 1151 1152
    DO_TEST("aarch64-video-default",
            QEMU_CAPS_OBJECT_GPEX,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_VNC);
1153

1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
    DO_TEST_FULL("aarch64-gic-none", WHEN_BOTH,
                 ARG_GIC, GIC_NONE,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-none-v2", WHEN_BOTH,
                 ARG_GIC, GIC_V2,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-none-v3", WHEN_BOTH,
                 ARG_GIC, GIC_V3,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-none-both", WHEN_BOTH,
                 ARG_GIC, GIC_BOTH,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-none-tcg", WHEN_BOTH,
                 ARG_GIC, GIC_BOTH,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-default", WHEN_BOTH,
                 ARG_GIC, GIC_NONE,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-default-v2", WHEN_BOTH,
                 ARG_GIC, GIC_V2,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-default-v3", WHEN_BOTH,
                 ARG_GIC, GIC_V3,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-default-both", WHEN_BOTH,
                 ARG_GIC, GIC_BOTH,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-v2", WHEN_BOTH,
                 ARG_GIC, GIC_NONE,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-v2", WHEN_BOTH,
                 ARG_GIC, GIC_V2,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-v2", WHEN_BOTH,
                 ARG_GIC, GIC_V3,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-v2", WHEN_BOTH,
                 ARG_GIC, GIC_BOTH,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-v3", WHEN_BOTH,
                 ARG_GIC, GIC_NONE,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-v3", WHEN_BOTH,
                 ARG_GIC, GIC_V2,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-v3", WHEN_BOTH,
                 ARG_GIC, GIC_V3,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-v3", WHEN_BOTH,
                 ARG_GIC, GIC_BOTH,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-host", WHEN_BOTH,
                 ARG_GIC, GIC_NONE,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-host", WHEN_BOTH,
                 ARG_GIC, GIC_V2,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-host", WHEN_BOTH,
                 ARG_GIC, GIC_V3,
                 ARG_QEMU_CAPS, NONE);
    DO_TEST_FULL("aarch64-gic-host", WHEN_BOTH,
                 ARG_GIC, GIC_BOTH,
                 ARG_QEMU_CAPS, NONE);
1217

1218 1219 1220
    /* SVE aarch64 CPU features work on modern QEMU */
    DO_TEST_CAPS_ARCH_LATEST("aarch64-features-sve", "aarch64");

1221 1222 1223
    DO_TEST("memory-hotplug", NONE);
    DO_TEST("memory-hotplug-nonuma", NONE);
    DO_TEST("memory-hotplug-dimm", NONE);
M
Michal Privoznik 已提交
1224
    DO_TEST("memory-hotplug-nvdimm", NONE);
1225
    DO_TEST("memory-hotplug-nvdimm-access", NONE);
1226
    DO_TEST("memory-hotplug-nvdimm-label", NONE);
1227
    DO_TEST("memory-hotplug-nvdimm-align", NONE);
1228
    DO_TEST("memory-hotplug-nvdimm-pmem", NONE);
1229
    DO_TEST("memory-hotplug-nvdimm-readonly", NONE);
1230
    DO_TEST("net-udp", NONE);
1231

1232 1233 1234 1235 1236 1237
    DO_TEST("video-virtio-gpu-device", QEMU_CAPS_DEVICE_VIRTIO_GPU);
    DO_TEST("video-virtio-gpu-virgl",
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL);
    DO_TEST("video-virtio-gpu-spice-gl",
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
1238 1239 1240 1241 1242
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_SPICE,
            QEMU_CAPS_SPICE_FILE_XFER_DISABLE,
            QEMU_CAPS_SPICE_GL,
            QEMU_CAPS_SPICE_RENDERNODE);
1243 1244
    DO_TEST("video-virtio-gpu-sdl-gl",
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
1245 1246
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_SDL_GL);
1247 1248 1249 1250 1251 1252 1253

    DO_TEST("virtio-input",
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET);
    DO_TEST("virtio-input-passthrough",
            QEMU_CAPS_VIRTIO_INPUT_HOST);
M
Marc-André Lureau 已提交
1254

1255 1256
    DO_TEST("memorybacking-set", NONE);
    DO_TEST("memorybacking-unset", NONE);
1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269

    DO_TEST("virtio-options",
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_VIRTIO_INPUT_HOST,
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_VIRTIO_GPU_VIRGL,
            QEMU_CAPS_DEVICE_VIRTIO_RNG,
            QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_VIRTIO_PCI_IOMMU_PLATFORM,
1270 1271
            QEMU_CAPS_VIRTIO_PCI_ATS,
            QEMU_CAPS_DEVICE_VHOST_USER_GPU);
1272

1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284
    DO_TEST("fd-memory-numa-topology", QEMU_CAPS_OBJECT_MEMORY_FILE,
            QEMU_CAPS_KVM);
    DO_TEST("fd-memory-numa-topology2", QEMU_CAPS_OBJECT_MEMORY_FILE,
            QEMU_CAPS_KVM);
    DO_TEST("fd-memory-numa-topology3", QEMU_CAPS_OBJECT_MEMORY_FILE,
            QEMU_CAPS_KVM);

    DO_TEST("fd-memory-no-numa-topology", QEMU_CAPS_OBJECT_MEMORY_FILE,
            QEMU_CAPS_KVM);

    DO_TEST("memfd-memory-numa",
            QEMU_CAPS_OBJECT_MEMORY_MEMFD,
1285 1286
            QEMU_CAPS_OBJECT_MEMORY_MEMFD_HUGETLB,
            QEMU_CAPS_OBJECT_MEMORY_FILE);
1287 1288
    DO_TEST("memfd-memory-default-hugepage",
            QEMU_CAPS_OBJECT_MEMORY_MEMFD,
1289 1290
            QEMU_CAPS_OBJECT_MEMORY_MEMFD_HUGETLB,
            QEMU_CAPS_OBJECT_MEMORY_FILE);
1291

1292
    DO_TEST("acpi-table", NONE);
J
Ján Tomko 已提交
1293

1294 1295 1296 1297 1298
    DO_TEST("video-device-pciaddr-default",
            QEMU_CAPS_KVM,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_DEVICE_QXL);
1299 1300 1301 1302
    DO_TEST("video-qxl-heads", QEMU_CAPS_DEVICE_QXL);
    DO_TEST("video-qxl-noheads", QEMU_CAPS_DEVICE_QXL);
    DO_TEST("video-qxl-resolution", QEMU_CAPS_DEVICE_QXL);
    DO_TEST("video-virtio-gpu-secondary", QEMU_CAPS_DEVICE_VIRTIO_GPU);
1303
    DO_TEST("video-virtio-gpu-ccw",
1304
            QEMU_CAPS_CCW,
1305 1306 1307 1308 1309
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_VIRTIO_GPU_MAX_OUTPUTS,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_VIRTIO_GPU_CCW);
1310
    DO_TEST("video-virtio-gpu-ccw-auto",
1311
            QEMU_CAPS_CCW,
1312 1313 1314 1315 1316
            QEMU_CAPS_DEVICE_VIRTIO_GPU,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_VIRTIO_GPU_MAX_OUTPUTS,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_VIRTIO_GPU_CCW);
1317
    DO_TEST("video-none-device", QEMU_CAPS_VNC);
1318

1319 1320 1321 1322 1323
    DO_TEST_CAPS_LATEST("intel-iommu");
    DO_TEST_CAPS_VER("intel-iommu", "2.6.0");
    DO_TEST_CAPS_LATEST("intel-iommu-caching-mode");
    DO_TEST_CAPS_LATEST("intel-iommu-eim");
    DO_TEST_CAPS_LATEST("intel-iommu-device-iotlb");
1324
    DO_TEST_CAPS_ARCH_LATEST("iommu-smmuv3", "aarch64");
J
Ján Tomko 已提交
1325

1326 1327 1328 1329 1330 1331 1332
    DO_TEST("cpu-check-none", NONE);
    DO_TEST("cpu-check-partial", NONE);
    DO_TEST("cpu-check-full", NONE);
    DO_TEST("cpu-check-default-none", NONE);
    DO_TEST("cpu-check-default-none2", NONE);
    DO_TEST("cpu-check-default-partial", NONE);
    DO_TEST("cpu-check-default-partial2", NONE);
M
Marc-André Lureau 已提交
1333
    DO_TEST("vmcoreinfo", NONE);
1334

1335 1336
    DO_TEST("smartcard-host", NONE);
    DO_TEST("smartcard-host-certificates", NONE);
1337
    DO_TEST("smartcard-host-certificates-database", NONE);
1338 1339 1340 1341
    DO_TEST("smartcard-passthrough-tcp", NONE);
    DO_TEST("smartcard-passthrough-spicevmc", NONE);
    DO_TEST("smartcard-controller", NONE);

1342 1343 1344 1345 1346 1347
    DO_TEST("pseries-cpu-compat-power9",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
    DO_TEST("pseries-cpu-compat",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
    DO_TEST("pseries-cpu-exact",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
1348

1349 1350
    DO_TEST("user-aliases",
            QEMU_CAPS_DEVICE_CIRRUS_VGA,
1351
            QEMU_CAPS_QCOW2_LUKS,
1352 1353
            QEMU_CAPS_OBJECT_MEMORY_FILE,
            QEMU_CAPS_PIIX_DISABLE_S3,
1354 1355
            QEMU_CAPS_PIIX_DISABLE_S4,
            QEMU_CAPS_VNC);
1356
    DO_TEST("input-virtio-ccw",
1357
            QEMU_CAPS_CCW,
1358 1359 1360 1361 1362 1363
            QEMU_CAPS_VIRTIO_KEYBOARD,
            QEMU_CAPS_VIRTIO_MOUSE,
            QEMU_CAPS_VIRTIO_TABLET,
            QEMU_CAPS_DEVICE_VIRTIO_KEYBOARD_CCW,
            QEMU_CAPS_DEVICE_VIRTIO_MOUSE_CCW,
            QEMU_CAPS_DEVICE_VIRTIO_TABLET_CCW);
1364

1365 1366 1367 1368 1369 1370 1371 1372 1373
    DO_TEST("tseg-explicit-size",
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_MACHINE_SMM_OPT,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_MCH_EXTENDED_TSEG_MBYTES);

1374
# define DO_TEST_STATUS(_name) \
1375
    do { \
1376 1377 1378
        static struct testQemuInfo info = { \
            .name = _name, \
        }; \
1379 1380 1381
        if (testQemuInfoSetArgs(&info, capslatest, \
                                ARG_QEMU_CAPS, QEMU_CAPS_LAST, \
                                ARG_END) < 0 || \
1382
            qemuTestCapsCacheInsert(driver.qemuCapsCache, info.qemuCaps) < 0) { \
1383
            VIR_TEST_DEBUG("Failed to generate status test data for '%s'", _name); \
1384 1385
            return -1; \
        } \
1386
        testInfoSetStatusPaths(&info); \
1387
\
1388
        if (virTestRun("QEMU status XML-2-XML " _name, \
1389 1390 1391
                       testCompareStatusXMLToXMLFiles, &info) < 0) \
            ret = -1; \
\
1392
        testQemuInfoClear(&info); \
1393 1394 1395 1396 1397
    } while (0)


    DO_TEST_STATUS("blockjob-mirror");
    DO_TEST_STATUS("vcpus-multi");
1398
    DO_TEST_STATUS("modern");
1399
    DO_TEST_STATUS("migration-out-nbd");
1400 1401
    DO_TEST_STATUS("migration-in-params");
    DO_TEST_STATUS("migration-out-params");
1402
    DO_TEST_STATUS("migration-out-nbd-tls");
1403
    DO_TEST_STATUS("disk-secinfo-upgrade");
1404

1405 1406
    DO_TEST_STATUS("blockjob-blockdev");

1407 1408
    DO_TEST_STATUS("backup-pull");

1409 1410
    DO_TEST("vhost-vsock", QEMU_CAPS_DEVICE_VHOST_VSOCK);
    DO_TEST("vhost-vsock-auto", QEMU_CAPS_DEVICE_VHOST_VSOCK);
1411 1412 1413 1414 1415
    DO_TEST("vhost-vsock-ccw", QEMU_CAPS_DEVICE_VHOST_VSOCK,
            QEMU_CAPS_CCW);
    DO_TEST("vhost-vsock-ccw-auto", QEMU_CAPS_DEVICE_VHOST_VSOCK,
            QEMU_CAPS_CCW);

L
Lubomir Rintel 已提交
1416 1417
    DO_TEST("riscv64-virt",
            QEMU_CAPS_DEVICE_VIRTIO_MMIO);
1418 1419
    DO_TEST("riscv64-virt-pci",
            QEMU_CAPS_OBJECT_GPEX);
J
Ján Tomko 已提交
1420

1421 1422
    DO_TEST_CAPS_LATEST("virtio-transitional");
    DO_TEST_CAPS_LATEST("virtio-non-transitional");
1423

1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439
    /* Simple headless guests for various architectures */
    DO_TEST_CAPS_ARCH_LATEST("aarch64-virt-headless", "aarch64");
    DO_TEST_CAPS_ARCH_LATEST("ppc64-pseries-headless", "ppc64");
    DO_TEST_CAPS_ARCH_LATEST("riscv64-virt-headless", "riscv64");
    DO_TEST_CAPS_ARCH_LATEST("s390x-ccw-headless", "s390x");
    DO_TEST_CAPS_ARCH_LATEST("x86_64-pc-headless", "x86_64");
    DO_TEST_CAPS_ARCH_LATEST("x86_64-q35-headless", "x86_64");

    /* Simple guests with graphics for various architectures */
    DO_TEST_CAPS_ARCH_LATEST("aarch64-virt-graphics", "aarch64");
    DO_TEST_CAPS_ARCH_LATEST("ppc64-pseries-graphics", "ppc64");
    DO_TEST_CAPS_ARCH_LATEST("riscv64-virt-graphics", "riscv64");
    DO_TEST_CAPS_ARCH_LATEST("s390x-ccw-graphics", "s390x");
    DO_TEST_CAPS_ARCH_LATEST("x86_64-pc-graphics", "x86_64");
    DO_TEST_CAPS_ARCH_LATEST("x86_64-q35-graphics", "x86_64");

1440 1441 1442
    DO_TEST_CAPS_VER("cpu-Icelake-Server-pconfig", "3.1.0");
    DO_TEST_CAPS_LATEST("cpu-Icelake-Server-pconfig");

1443 1444
    DO_TEST_CAPS_ARCH_LATEST("aarch64-default-cpu-kvm-virt-4.2", "aarch64");
    DO_TEST_CAPS_ARCH_LATEST("aarch64-default-cpu-tcg-virt-4.2", "aarch64");
1445 1446 1447 1448 1449 1450
    DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-kvm-pseries-2.7", "ppc64");
    DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-tcg-pseries-2.7", "ppc64");
    DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-kvm-pseries-3.1", "ppc64");
    DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-tcg-pseries-3.1", "ppc64");
    DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-kvm-pseries-4.2", "ppc64");
    DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-tcg-pseries-4.2", "ppc64");
1451 1452
    DO_TEST_CAPS_ARCH_LATEST("s390-default-cpu-kvm-ccw-virtio-4.2", "s390x");
    DO_TEST_CAPS_ARCH_LATEST("s390-default-cpu-tcg-ccw-virtio-4.2", "s390x");
1453 1454 1455 1456
    DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-kvm-pc-4.2", "x86_64");
    DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-tcg-pc-4.2", "x86_64");
    DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-kvm-q35-4.2", "x86_64");
    DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-tcg-q35-4.2", "x86_64");
1457

A
Andrea Bolognani 已提交
1458 1459 1460
    if (getenv("LIBVIRT_SKIP_CLEANUP") == NULL)
        virFileDeleteTree(fakerootdir);

1461
    virHashFree(capslatest);
1462
    qemuTestDriverFree(&driver);
A
Andrea Bolognani 已提交
1463
    VIR_FREE(fakerootdir);
1464
    virFileWrapperClearPrefixes();
1465

1466
    return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1467 1468
}

A
Andrea Bolognani 已提交
1469
VIR_TEST_MAIN_PRELOAD(mymain,
1470 1471
                      VIR_TEST_MOCK("virpci"),
                      VIR_TEST_MOCK("virrandom"),
M
Michal Privoznik 已提交
1472
                      VIR_TEST_MOCK("domaincaps"),
1473
                      VIR_TEST_MOCK("virdeterministichash"))
1474

1475 1476
#else

1477 1478 1479 1480 1481
int
main(void)
{
    return EXIT_AM_SKIP;
}
1482 1483

#endif /* WITH_QEMU */