qemuxml2xmltest.c 44.4 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 19
# define VIR_FROM_THIS VIR_FROM_NONE

20
static virQEMUDriver driver;
21

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

struct testInfo {
    char *inName;
    char *outActiveName;
    char *outInactiveName;
32

33
    virBitmapPtr activeVcpus;
34
    bool blockjobs;
35

36
    virQEMUCapsPtr qemuCaps;
37 38
};

39

40 41 42 43 44
static int
testXML2XMLActive(const void *opaque)
{
    const struct testInfo *info = opaque;

45
    return testCompareDomXML2XMLFiles(driver.caps, driver.xmlopt,
46
                                      info->inName, info->outActiveName, true,
47
                                      0,
48
                                      TEST_COMPARE_DOM_XML2XML_RESULT_SUCCESS);
49 50
}

51

52
static int
53
testXML2XMLInactive(const void *opaque)
54
{
55 56
    const struct testInfo *info = opaque;

57
    return testCompareDomXML2XMLFiles(driver.caps, driver.xmlopt, info->inName,
58
                                      info->outInactiveName, false,
59
                                      0,
60
                                      TEST_COMPARE_DOM_XML2XML_RESULT_SUCCESS);
61
}
62

63

64 65 66 67 68 69 70 71 72 73 74 75 76
static int
testCompareStatusXMLToXMLFiles(const void *opaque)
{
    const struct testInfo *data = opaque;
    virDomainObjPtr obj = NULL;
    char *actual = NULL;
    int ret = -1;

    if (!(obj = virDomainObjParseFile(data->inName, driver.caps, driver.xmlopt,
                                      VIR_DOMAIN_DEF_PARSE_STATUS |
                                      VIR_DOMAIN_DEF_PARSE_ACTUAL_NET |
                                      VIR_DOMAIN_DEF_PARSE_PCI_ORIG_STATES |
                                      VIR_DOMAIN_DEF_PARSE_SKIP_VALIDATE |
77 78
                                      VIR_DOMAIN_DEF_PARSE_ALLOW_POST_PARSE_FAIL))) {
        VIR_TEST_DEBUG("\nfailed to parse '%s'\n", data->inName);
79
        goto cleanup;
80
    }
81 82 83 84 85 86

    if (!(actual = virDomainObjFormat(driver.xmlopt, obj, NULL,
                                      VIR_DOMAIN_DEF_FORMAT_SECURE |
                                      VIR_DOMAIN_DEF_FORMAT_STATUS |
                                      VIR_DOMAIN_DEF_FORMAT_ACTUAL_NET |
                                      VIR_DOMAIN_DEF_FORMAT_PCI_ORIG_STATES |
87 88
                                      VIR_DOMAIN_DEF_FORMAT_CLOCK_ADJUST))) {
        VIR_TEST_DEBUG("\nfailed to format back '%s'\n", data->inName);
89
        goto cleanup;
90
    }
91 92 93 94 95 96 97

    if (virTestCompareToFile(actual, data->outActiveName) < 0)
        goto cleanup;

    ret = 0;

 cleanup:
98
    virDomainObjEndAPI(&obj);
99 100 101 102 103
    VIR_FREE(actual);
    return ret;
}


104
static void
105
testInfoClear(struct testInfo *info)
106 107 108 109
{
    VIR_FREE(info->inName);
    VIR_FREE(info->outActiveName);
    VIR_FREE(info->outInactiveName);
110

111 112 113
    virBitmapFree(info->activeVcpus);
    info->activeVcpus = NULL;

114
    virObjectUnref(info->qemuCaps);
115 116 117 118
}


static int
119 120
testInfoSetCommon(struct testInfo *info,
                  int gic)
121
{
122 123 124
    if (!(info->qemuCaps = virQEMUCapsNew()))
        goto error;

125 126 127
    if (testQemuCapsSetGIC(info->qemuCaps, gic) < 0)
        goto error;

128
    if (qemuTestCapsCacheInsert(driver.qemuCapsCache, info->qemuCaps) < 0)
129 130
        goto error;

131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
    return 0;

 error:
    testInfoClear(info);
    return -1;
}


static int
testInfoSet(struct testInfo *info,
            const char *name,
            int when,
            int gic)
{
    if (testInfoSetCommon(info, gic) < 0)
        return -1;

148
    if (virAsprintf(&info->inName, "%s/qemuxml2argvdata/%s.xml",
149 150 151 152
                    abs_srcdir, name) < 0)
        goto error;

    if (when & WHEN_INACTIVE) {
153
        if (virAsprintf(&info->outInactiveName,
154
                        "%s/qemuxml2xmloutdata/%s-inactive.xml",
155 156
                        abs_srcdir, name) < 0)
            goto error;
157

158 159
        if (!virFileExists(info->outInactiveName)) {
            VIR_FREE(info->outInactiveName);
160

161
            if (virAsprintf(&info->outInactiveName,
162
                            "%s/qemuxml2xmloutdata/%s.xml",
163
                            abs_srcdir, name) < 0)
164 165
                goto error;
        }
166
    }
167

168
    if (when & WHEN_ACTIVE) {
169
        if (virAsprintf(&info->outActiveName,
170
                        "%s/qemuxml2xmloutdata/%s-active.xml",
171 172
                        abs_srcdir, name) < 0)
            goto error;
173

174 175
        if (!virFileExists(info->outActiveName)) {
            VIR_FREE(info->outActiveName);
176

177
            if (virAsprintf(&info->outActiveName,
178
                            "%s/qemuxml2xmloutdata/%s.xml",
179
                            abs_srcdir, name) < 0)
180 181
                goto error;
        }
182
    }
183

184
    return 0;
185

186
 error:
187
    testInfoClear(info);
188
    return -1;
189 190
}

191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213

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

static int
testInfoSetStatus(struct testInfo *info,
                  const char *name,
                  int gic)
{
    if (testInfoSetCommon(info, gic) < 0)
        return -1;

    if (virAsprintf(&info->inName, "%s%s-in.xml", statusPath, name) < 0 ||
        virAsprintf(&info->outActiveName, "%s%s-out.xml", statusPath, name) < 0)
        goto error;

    return 0;

 error:
    testInfoClear(info);
    return -1;
}


A
Andrea Bolognani 已提交
214
# define FAKEROOTDIRTEMPLATE abs_builddir "/fakerootdir-XXXXXX"
215

216
static int
E
Eric Blake 已提交
217
mymain(void)
218 219
{
    int ret = 0;
A
Andrea Bolognani 已提交
220
    char *fakerootdir;
221
    struct testInfo info;
222
    virQEMUDriverConfigPtr cfg = NULL;
223

A
Andrea Bolognani 已提交
224 225 226 227 228 229 230 231 232 233 234 235
    if (VIR_STRDUP_QUIET(fakerootdir, FAKEROOTDIRTEMPLATE) < 0) {
        fprintf(stderr, "Out of memory\n");
        abort();
    }

    if (!mkdtemp(fakerootdir)) {
        fprintf(stderr, "Cannot create fakerootdir");
        abort();
    }

    setenv("LIBVIRT_FAKE_ROOT_DIR", fakerootdir, 1);

236 237
    memset(&info, 0, sizeof(info));

238
    if (qemuTestDriverInit(&driver) < 0)
239
        return EXIT_FAILURE;
240

241 242
    cfg = virQEMUDriverGetConfig(&driver);

243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
# define DO_TEST_FULL(name, when, gic, ...) \
    do { \
        if (testInfoSet(&info, name, when, gic) < 0) { \
            VIR_TEST_DEBUG("Failed to generate test data for '%s'", name); \
            return -1; \
        } \
        virQEMUCapsSetList(info.qemuCaps, __VA_ARGS__, QEMU_CAPS_LAST); \
 \
        if (info.outInactiveName) { \
            if (virTestRun("QEMU XML-2-XML-inactive " name, \
                            testXML2XMLInactive, &info) < 0) \
                ret = -1; \
        } \
 \
        if (info.outActiveName) { \
            if (virTestRun("QEMU XML-2-XML-active " name, \
                            testXML2XMLActive, &info) < 0) \
                ret = -1; \
        } \
262
        testInfoClear(&info); \
263 264
    } while (0)

265 266
# define NONE QEMU_CAPS_LAST

267 268
# define DO_TEST(name, ...) \
    DO_TEST_FULL(name, WHEN_BOTH, GIC_NONE, __VA_ARGS__)
269 270


271 272 273 274 275

    /* 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);
276

277
    DO_TEST("minimal", NONE);
278 279
    DO_TEST("genid", NONE);
    DO_TEST("genid-auto", NONE);
280 281
    DO_TEST("machine-core-on", NONE);
    DO_TEST("machine-core-off", NONE);
282
    DO_TEST("machine-loadparm-multiple-disks-nets-s390", NONE);
283 284 285 286 287
    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);
288 289 290
    DO_TEST("boot-floppy-q35",
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI);
291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
    DO_TEST("boot-multi", NONE);
    DO_TEST("boot-menu-enable-with-timeout", NONE);
    DO_TEST("boot-menu-disable", NONE);
    DO_TEST("boot-menu-disable-with-timeout", NONE);
    DO_TEST("boot-order", NONE);

    DO_TEST("reboot-timeout-enabled", NONE);
    DO_TEST("reboot-timeout-disabled", NONE);

    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);
    DO_TEST("clock-catchup", NONE);
    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);

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

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

328
    DO_TEST("pages-discard", NONE);
329
    DO_TEST("pages-discard-hugepages", NONE);
330
    DO_TEST("pages-dimm-discard", NONE);
331
    DO_TEST("hugepages-default", NONE);
332
    DO_TEST("hugepages-default-2M", NONE);
333
    DO_TEST("hugepages-default-system-size", NONE);
334
    DO_TEST("hugepages-nodeset", NONE);
335
    DO_TEST("hugepages-numa-default-2M", NONE);
336
    DO_TEST("hugepages-numa-default-dimm", NONE);
337
    DO_TEST("hugepages-numa-nodeset", NONE);
338
    DO_TEST("hugepages-numa-nodeset-part", NONE);
339
    DO_TEST("hugepages-shared", NONE);
340
    DO_TEST("hugepages-memaccess", NONE);
341
    DO_TEST("hugepages-memaccess2", NONE);
342
    DO_TEST("hugepages-nvdimm", NONE);
343 344 345 346 347 348 349 350 351 352
    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);
    DO_TEST("disk-floppy", NONE);
    DO_TEST("disk-usb-device", NONE);
    DO_TEST("disk-virtio", NONE);
    DO_TEST("floppy-drive-fat", NONE);
353 354 355 356 357
    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);
358
    DO_TEST("disk-cache", QEMU_CAPS_SCSI_LSI);
359
    DO_TEST("disk-network-nbd", NONE);
360
    DO_TEST("disk-network-iscsi", QEMU_CAPS_VIRTIO_SCSI);
361 362 363 364 365 366
    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);
367
    DO_TEST("disk-scsi-device",
368
            QEMU_CAPS_SCSI_LSI);
369
    DO_TEST("disk-scsi-vscsi", NONE);
370
    DO_TEST("disk-virtio-scsi-reservations",
371
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_PR_MANAGER_HELPER);
372
    DO_TEST("controller-virtio-scsi", QEMU_CAPS_VIRTIO_SCSI);
373 374 375
    DO_TEST("disk-virtio-s390-zpci",
            QEMU_CAPS_DEVICE_ZPCI,
            QEMU_CAPS_CCW);
376
    DO_TEST("disk-scsi-megasas",
377
            QEMU_CAPS_SCSI_MEGASAS);
378
    DO_TEST("disk-scsi-mptsas1068",
379
            QEMU_CAPS_SCSI_MPTSAS1068,
380
            QEMU_CAPS_SCSI_DISK_WWN);
381
    DO_TEST("disk-mirror-old", NONE);
382
    DO_TEST("disk-mirror", NONE);
383
    DO_TEST_FULL("disk-active-commit", WHEN_ACTIVE, GIC_NONE, NONE);
384 385 386 387 388 389 390
    DO_TEST("graphics-listen-network", NONE);
    DO_TEST("graphics-vnc", NONE);
    DO_TEST("graphics-vnc-websocket", NONE);
    DO_TEST("graphics-vnc-sasl", NONE);
    DO_TEST("graphics-vnc-tls", NONE);
    DO_TEST("graphics-vnc-no-listen-attr", NONE);
    DO_TEST("graphics-vnc-remove-generated-socket", NONE);
391
    cfg->vncAutoUnixSocket = true;
392
    DO_TEST("graphics-vnc-auto-socket-cfg", NONE);
393
    cfg->vncAutoUnixSocket = false;
394 395
    DO_TEST("graphics-vnc-socket", NONE);
    DO_TEST("graphics-vnc-auto-socket", NONE);
396 397
    DO_TEST("graphics-vnc-egl-headless",
            QEMU_CAPS_EGL_HEADLESS);
398 399 400 401 402 403 404 405

    DO_TEST("graphics-sdl", NONE);
    DO_TEST("graphics-sdl-fullscreen", NONE);
    DO_TEST("graphics-spice", NONE);
    DO_TEST("graphics-spice-compression", NONE);
    DO_TEST("graphics-spice-qxl-vga", NONE);
    DO_TEST("graphics-spice-socket", NONE);
    DO_TEST("graphics-spice-auto-socket", NONE);
406
    cfg->spiceAutoUnixSocket = true;
407
    DO_TEST("graphics-spice-auto-socket-cfg", NONE);
408
    cfg->spiceAutoUnixSocket = false;
409 410
    DO_TEST("graphics-spice-egl-headless",
            QEMU_CAPS_EGL_HEADLESS);
411

412 413 414
    DO_TEST("graphics-egl-headless-rendernode",
            QEMU_CAPS_EGL_HEADLESS,
            QEMU_CAPS_EGL_HEADLESS_RENDERNODE);
415

416 417 418 419 420 421 422 423 424 425
    DO_TEST("input-usbmouse", NONE);
    DO_TEST("input-usbtablet", NONE);
    DO_TEST("misc-acpi", NONE);
    DO_TEST("misc-disable-s3", NONE);
    DO_TEST("misc-disable-suspends", NONE);
    DO_TEST("misc-enable-s4", NONE);
    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 已提交
426
    DO_TEST("net-user-addr", NONE);
427 428 429 430 431 432 433
    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);
    DO_TEST("net-virtio-network-portgroup", NONE);
434
    DO_TEST("net-virtio-rxtxqueuesize", NONE);
435
    DO_TEST("net-hostdev", NONE);
436
    DO_TEST("net-hostdev-bootorder", NONE);
437 438 439 440 441 442 443 444
    DO_TEST("net-hostdev-vfio", NONE);
    DO_TEST("net-midonet", NONE);
    DO_TEST("net-openvswitch", NONE);
    DO_TEST("sound", NONE);
    DO_TEST("sound-device", NONE);
    DO_TEST("watchdog", NONE);
    DO_TEST("net-bandwidth", NONE);
    DO_TEST("net-bandwidth2", NONE);
445
    DO_TEST("net-mtu", NONE);
446
    DO_TEST("net-coalesce", NONE);
447

448
    DO_TEST("serial-tcp-tlsx509-chardev", NONE);
449
    DO_TEST("serial-tcp-tlsx509-chardev-notls", NONE);
450 451 452 453 454 455 456 457 458
    DO_TEST("serial-spiceport", NONE);
    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);

459 460
    DO_TEST_FULL("channel-unix-source-path", WHEN_INACTIVE, GIC_NONE, NONE);

461 462 463
    DO_TEST("hostdev-usb-address", NONE);
    DO_TEST("hostdev-pci-address", NONE);
    DO_TEST("hostdev-vfio", NONE);
464 465 466
    DO_TEST("hostdev-vfio-zpci",
            QEMU_CAPS_DEVICE_ZPCI,
            QEMU_CAPS_CCW);
467 468 469 470 471 472 473 474 475 476 477
    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);
478
    DO_TEST("hostdev-mdev-precreated", NONE);
479
    DO_TEST("hostdev-mdev-display", QEMU_CAPS_VFIO_PCI_DISPLAY);
480
    DO_TEST("pci-rom", NONE);
481
    DO_TEST("pci-rom-disabled", NONE);
482
    DO_TEST("pci-rom-disabled-invalid", NONE);
483 484
    DO_TEST("pci-serial-dev-chardev", NONE);

485 486
    DO_TEST("encrypted-disk", QEMU_CAPS_QCOW2_LUKS);
    DO_TEST("encrypted-disk-usage", QEMU_CAPS_QCOW2_LUKS);
487
    DO_TEST("luks-disks", NONE);
488
    DO_TEST("luks-disks-source", NONE);
489 490 491 492 493 494 495 496 497
    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);
498
    DO_TEST("vcpu-placement-static",
499 500
            QEMU_CAPS_KVM,
            QEMU_CAPS_OBJECT_IOTHREAD);
501

502 503 504 505 506 507
    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);
508
    DO_TEST("iothreads-disk-virtio-ccw",
509
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
510
    DO_TEST("iothreads-virtio-scsi-pci",
511
            QEMU_CAPS_VIRTIO_SCSI);
512
    DO_TEST("iothreads-virtio-scsi-ccw",
513
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_CCW,
514
            QEMU_CAPS_VIRTIO_S390);
515 516 517 518 519 520 521
    DO_TEST("lease", NONE);
    DO_TEST("event_idx", NONE);
    DO_TEST("vhost_queues", NONE);
    DO_TEST("interface-driver", NONE);
    DO_TEST("interface-server", NONE);
    DO_TEST("virtio-lun", NONE);

522 523 524 525 526
    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",
527
            QEMU_CAPS_DEVICE_IOH3420,
528 529
            QEMU_CAPS_PCI_OHCI,
            QEMU_CAPS_PIIX3_USB_UHCI,
530 531
            QEMU_CAPS_NEC_USB_XHCI);
    DO_TEST("usb-controller-explicit-q35",
532
            QEMU_CAPS_DEVICE_IOH3420,
533 534
            QEMU_CAPS_PCI_OHCI,
            QEMU_CAPS_PIIX3_USB_UHCI,
535 536
            QEMU_CAPS_NEC_USB_XHCI);
    DO_TEST("ppc64-usb-controller",
537
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
538 539
            QEMU_CAPS_PCI_OHCI);
    DO_TEST("ppc64-usb-controller-legacy",
540
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
541
            QEMU_CAPS_PIIX3_USB_UHCI);
542 543 544 545 546
    DO_TEST("usb-port-missing", NONE);
    DO_TEST("usb-redir", NONE);
    DO_TEST("usb-redir-filter", NONE);
    DO_TEST("usb-redir-filter-version", NONE);
    DO_TEST("blkdeviotune", NONE);
547
    DO_TEST("blkdeviotune-max", NONE);
548
    DO_TEST("blkdeviotune-group-num", NONE);
549
    DO_TEST("blkdeviotune-max-length", NONE);
550
    DO_TEST("controller-usb-order", NONE);
551

552 553 554 555
    DO_TEST_FULL("seclabel-dynamic-baselabel", WHEN_INACTIVE, GIC_NONE, NONE);
    DO_TEST_FULL("seclabel-dynamic-override", WHEN_INACTIVE, GIC_NONE, NONE);
    DO_TEST_FULL("seclabel-dynamic-labelskip", WHEN_INACTIVE, GIC_NONE, NONE);
    DO_TEST_FULL("seclabel-dynamic-relabel", WHEN_INACTIVE, GIC_NONE, NONE);
556
    DO_TEST("seclabel-static", NONE);
557
    DO_TEST_FULL("seclabel-static-labelskip", WHEN_ACTIVE, GIC_NONE, NONE);
558 559 560 561
    DO_TEST("seclabel-none", NONE);
    DO_TEST("seclabel-dac-none", NONE);
    DO_TEST("seclabel-dynamic-none", NONE);
    DO_TEST("seclabel-device-multiple", NONE);
562
    DO_TEST_FULL("seclabel-dynamic-none-relabel", WHEN_INACTIVE, GIC_NONE, NONE);
563
    DO_TEST("numad-static-vcpu-no-numatune", NONE);
564

565
    DO_TEST("disk-scsi-lun-passthrough-sgio",
566
            QEMU_CAPS_SCSI_CD, QEMU_CAPS_SCSI_LSI,
567 568
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_DISK_WWN);
    DO_TEST("disk-scsi-disk-vpd",
569
            QEMU_CAPS_SCSI_CD, QEMU_CAPS_SCSI_LSI,
570
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_DISK_WWN);
571 572
    DO_TEST("disk-source-pool", NONE);
    DO_TEST("disk-source-pool-mode", NONE);
573

574 575
    DO_TEST("disk-discard", NONE);
    DO_TEST("disk-detect-zeroes", NONE);
O
Osier Yang 已提交
576

577 578
    DO_TEST("disk-serial", NONE);

579 580 581 582
    DO_TEST("virtio-rng-random",
            QEMU_CAPS_DEVICE_VIRTIO_RNG);
    DO_TEST("virtio-rng-egd",
            QEMU_CAPS_DEVICE_VIRTIO_RNG);
583

584 585 586 587 588 589
    DO_TEST("pseries-nvram",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
    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);
590

591 592 593 594
    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);
595 596 597 598
    DO_TEST("pseries-phb-numa-node",
            QEMU_CAPS_NUMA,
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_SPAPR_PCI_HOST_BRIDGE_NUMA_NODE);
599

600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
    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);

622
    DO_TEST("pseries-features",
623
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
624
            QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
625
            QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
626
            QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
627 628
            QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT);

629
    DO_TEST("pseries-serial-native",
630
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
631 632
            QEMU_CAPS_DEVICE_SPAPR_VTY);
    DO_TEST("pseries-serial+console-native",
633
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
634 635
            QEMU_CAPS_DEVICE_SPAPR_VTY);
    DO_TEST("pseries-serial-compat",
636
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
637
            QEMU_CAPS_DEVICE_SPAPR_VTY);
638
    DO_TEST("pseries-serial-pci",
639
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
640 641
            QEMU_CAPS_DEVICE_PCI_SERIAL);
    DO_TEST("pseries-serial-usb",
642
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
643 644
            QEMU_CAPS_DEVICE_QEMU_XHCI,
            QEMU_CAPS_DEVICE_USB_SERIAL);
645
    DO_TEST("pseries-console-native",
646
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
647 648
            QEMU_CAPS_DEVICE_SPAPR_VTY);
    DO_TEST("pseries-console-virtio",
649 650 651 652 653
            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);
654 655 656 657 658 659 660 661 662 663 664
    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);
665 666 667 668
    DO_TEST("mach-virt-console-native",
            QEMU_CAPS_DEVICE_PL011);
    DO_TEST("mach-virt-console-virtio",
            QEMU_CAPS_DEVICE_VIRTIO_MMIO);
669

670 671 672 673
    DO_TEST("balloon-device-auto", NONE);
    DO_TEST("balloon-device-period", NONE);
    DO_TEST("channel-virtio-auto", NONE);
    DO_TEST("console-compat-auto", NONE);
674
    DO_TEST("disk-scsi-device-auto",
675
            QEMU_CAPS_SCSI_LSI);
676 677 678 679 680 681 682 683 684 685
    DO_TEST("console-virtio", NONE);
    DO_TEST("serial-target-port-auto", NONE);
    DO_TEST("graphics-listen-network2", NONE);
    DO_TEST("graphics-spice-timeout", NONE);
    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);
    DO_TEST("tpm-passthrough", NONE);
686
    DO_TEST("tpm-passthrough-crb", NONE);
687
    DO_TEST("tpm-emulator", NONE);
688 689 690

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

692
    DO_TEST("pci-bridge",
693 694 695 696 697
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
    DO_TEST("pci-many",
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
698 699 700
    DO_TEST("pci-bridge-many-disks",
            QEMU_CAPS_DEVICE_PCI_BRIDGE);
    DO_TEST("pci-autoadd-addr",
701 702
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
703
    DO_TEST("pci-autoadd-idx",
704 705
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
706
    DO_TEST("pci-autofill-addr", NONE);
707

708
    DO_TEST("q35",
709 710
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
711
            QEMU_CAPS_DEVICE_IOH3420,
712 713 714
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
715
            QEMU_CAPS_DEVICE_QXL);
716 717 718
    DO_TEST("q35-usb2",
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
719
            QEMU_CAPS_DEVICE_IOH3420,
720
            QEMU_CAPS_ICH9_AHCI,
721
            QEMU_CAPS_ICH9_USB_EHCI1,
722
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
723
            QEMU_CAPS_DEVICE_QXL);
724
    DO_TEST("q35-usb2-multi",
725 726
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
727
            QEMU_CAPS_DEVICE_IOH3420,
728 729 730
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
731
            QEMU_CAPS_DEVICE_QXL);
732
    DO_TEST("q35-usb2-reorder",
733 734
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
735
            QEMU_CAPS_DEVICE_IOH3420,
736 737 738
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_ICH9_USB_EHCI1,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
739
            QEMU_CAPS_DEVICE_QXL);
740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756
    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,
757
            QEMU_CAPS_NEC_USB_XHCI,
758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776
            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,
777
            QEMU_CAPS_NEC_USB_XHCI,
778
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
779 780 781 782 783 784 785 786 787
    /* 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,
788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806
            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,
807 808 809 810 811 812 813 814 815 816
            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,
817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835
            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,
836
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
837
    DO_TEST("q35-virt-manager-basic",
838 839 840
            QEMU_CAPS_KVM,
            QEMU_CAPS_ICH9_DISABLE_S3,
            QEMU_CAPS_ICH9_DISABLE_S4,
841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858
            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,
859 860 861 862 863
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_SPICE,
            QEMU_CAPS_DEVICE_QXL,
            QEMU_CAPS_HDA_DUPLEX,
            QEMU_CAPS_USB_REDIR);
864
    DO_TEST("pcie-root",
865 866
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
867
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
868
            QEMU_CAPS_DEVICE_QXL);
869 870

    /* Test automatic and manual setting of pcie-root-port attributes */
871
    DO_TEST("pcie-root-port",
872 873
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
874
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
875
            QEMU_CAPS_DEVICE_QXL);
876 877 878 879 880 881

    /* 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,
882
            QEMU_CAPS_DEVICE_IOH3420);
883
    DO_TEST("pcie-root-port-model-ioh3420",
884
            QEMU_CAPS_DEVICE_IOH3420);
885

886
    DO_TEST("pcie-switch-upstream-port",
887 888 889
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_ICH9_AHCI,
890
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
891
            QEMU_CAPS_DEVICE_QXL);
892
    DO_TEST("pcie-switch-downstream-port",
893 894 895 896
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
            QEMU_CAPS_ICH9_AHCI,
897
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
898
            QEMU_CAPS_DEVICE_QXL);
899
    DO_TEST("pci-expander-bus",
900
            QEMU_CAPS_DEVICE_PXB);
901
    DO_TEST("pcie-expander-bus",
902 903 904 905
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
            QEMU_CAPS_DEVICE_PXB_PCIE);
906
    DO_TEST("autoindex",
907 908 909 910 911 912 913
            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,
914
            QEMU_CAPS_NEC_USB_XHCI);
915 916 917 918 919 920 921
    /* 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);
922

923 924
    DO_TEST("hostdev-scsi-vhost-scsi-ccw",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
925
            QEMU_CAPS_CCW);
926
    DO_TEST("hostdev-scsi-vhost-scsi-pci",
927 928
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_DEVICE_VHOST_SCSI);
929 930 931 932 933
    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);
934
    DO_TEST("hostdev-scsi-lsi",
935 936
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
937
    DO_TEST("hostdev-scsi-virtio-scsi",
938 939
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
940
    DO_TEST("hostdev-scsi-readonly",
941 942
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
943 944

    DO_TEST("hostdev-scsi-shareable",
945 946
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
947
    DO_TEST("hostdev-scsi-sgio",
948 949
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
950
    DO_TEST("hostdev-scsi-rawio",
951 952
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
953 954

    DO_TEST("hostdev-scsi-autogen-address",
955 956
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
957
    DO_TEST("hostdev-scsi-large-unit",
958 959
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
960 961

    DO_TEST("hostdev-scsi-lsi-iscsi",
962 963
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
964
    DO_TEST("hostdev-scsi-lsi-iscsi-auth",
965 966
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
967
    DO_TEST("hostdev-scsi-virtio-iscsi",
968 969
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
970
    DO_TEST("hostdev-scsi-virtio-iscsi-auth",
971 972
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_SCSI_LSI);
973

974 975 976 977 978
    DO_TEST("hostdev-subsys-mdev-vfio-ccw",
            QEMU_CAPS_CCW,
            QEMU_CAPS_CCW_CSSID_UNRESTRICTED,
            QEMU_CAPS_DEVICE_VFIO_CCW);

979
    DO_TEST("s390-defaultconsole",
980
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
981
    DO_TEST("s390-panic",
982
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
983
    DO_TEST("s390-panic-missing",
984
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
985
    DO_TEST("s390-panic-no-address",
986
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
987
    DO_TEST("s390-serial",
988
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
989
    DO_TEST("s390-serial-2",
990
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
991
    DO_TEST("s390-serial-console",
992
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
993

994 995 996
    DO_TEST("pcihole64", NONE);
    DO_TEST("pcihole64-gib", NONE);
    DO_TEST("pcihole64-none", NONE);
997
    DO_TEST("pcihole64-q35",
998
            QEMU_CAPS_DEVICE_IOH3420,
999 1000
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
1001
            QEMU_CAPS_DEVICE_QXL,
1002
            QEMU_CAPS_Q35_PCI_HOLE64_SIZE);
1003

1004 1005
    DO_TEST("panic", NONE);
    DO_TEST("panic-isa", NONE);
1006 1007
    DO_TEST("panic-pseries",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
1008 1009
    DO_TEST("panic-double", NONE);
    DO_TEST("panic-no-address", NONE);
H
Hu Tao 已提交
1010

1011
    DO_TEST("disk-backing-chains", NONE);
1012 1013
    DO_TEST("disk-backing-chains-index", NONE);
    DO_TEST("disk-backing-chains-noindex", NONE);
1014

1015 1016
    DO_TEST("chardev-label",
            QEMU_CAPS_DEVICE_VIRTIO_RNG);
J
Ján Tomko 已提交
1017

1018 1019 1020 1021 1022 1023
    DO_TEST("cpu-numa1", NONE);
    DO_TEST("cpu-numa2", NONE);
    DO_TEST("cpu-numa-no-memory-element", NONE);
    DO_TEST("cpu-numa-disordered", NONE);
    DO_TEST("cpu-numa-disjoint", NONE);
    DO_TEST("cpu-numa-memshared", NONE);
1024

1025 1026 1027
    DO_TEST("numatune-auto-prefer", NONE);
    DO_TEST("numatune-memnode", NONE);
    DO_TEST("numatune-memnode-no-memory", NONE);
1028

1029 1030
    DO_TEST("bios-nvram", NONE);
    DO_TEST("bios-nvram-os-interleave", NONE);
1031

1032 1033 1034
    DO_TEST("tap-vhost", NONE);
    DO_TEST("tap-vhost-incorrect", NONE);
    DO_TEST("shmem", NONE);
1035
    DO_TEST("shmem-plain-doorbell", NONE);
1036 1037
    DO_TEST("smbios", NONE);
    DO_TEST("smbios-multiple-type2", NONE);
1038

1039
    DO_TEST("aarch64-aavmf-virtio-mmio",
1040 1041
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM);
1042
    DO_TEST("aarch64-virtio-pci-default",
1043
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
1044 1045 1046
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_OBJECT_GPEX, QEMU_CAPS_DEVICE_PCI_BRIDGE,
1047 1048 1049
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_VIRTIO_SCSI);
1050
    DO_TEST("aarch64-virtio-pci-manual-addresses",
1051 1052 1053
            QEMU_CAPS_DEVICE_VIRTIO_MMIO,
            QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM,
            QEMU_CAPS_OBJECT_GPEX, QEMU_CAPS_DEVICE_PCI_BRIDGE,
1054 1055 1056
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_VIRTIO_SCSI);
1057
    DO_TEST("aarch64-video-virtio-gpu-pci",
1058
            QEMU_CAPS_OBJECT_GPEX,
1059
            QEMU_CAPS_DEVICE_PCI_BRIDGE, QEMU_CAPS_DEVICE_IOH3420,
1060
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
1061
            QEMU_CAPS_DEVICE_VIRTIO_GPU);
1062 1063 1064 1065 1066 1067 1068
    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);
1069 1070 1071 1072
    DO_TEST("aarch64-traditional-pci",
            QEMU_CAPS_OBJECT_GPEX,
            QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
1073
            QEMU_CAPS_DEVICE_PCIE_PCI_BRIDGE,
1074 1075
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_PCI_SERIAL);
1076 1077 1078 1079 1080 1081 1082 1083
    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);
1084

1085 1086 1087 1088
    DO_TEST_FULL("aarch64-gic-none", WHEN_BOTH, GIC_NONE, NONE);
    DO_TEST_FULL("aarch64-gic-none-v2", WHEN_BOTH, GIC_V2, NONE);
    DO_TEST_FULL("aarch64-gic-none-v3", WHEN_BOTH, GIC_V3, NONE);
    DO_TEST_FULL("aarch64-gic-none-both", WHEN_BOTH, GIC_BOTH, NONE);
1089
    DO_TEST_FULL("aarch64-gic-none-tcg", WHEN_BOTH, GIC_BOTH, NONE);
1090
    DO_TEST_FULL("aarch64-gic-default", WHEN_BOTH, GIC_NONE, NONE);
A
Andrea Bolognani 已提交
1091 1092 1093
    DO_TEST_FULL("aarch64-gic-default-v2", WHEN_BOTH, GIC_V2, NONE);
    DO_TEST_FULL("aarch64-gic-default-v3", WHEN_BOTH, GIC_V3, NONE);
    DO_TEST_FULL("aarch64-gic-default-both", WHEN_BOTH, GIC_BOTH, NONE);
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105
    DO_TEST_FULL("aarch64-gic-v2", WHEN_BOTH, GIC_NONE, NONE);
    DO_TEST_FULL("aarch64-gic-v2", WHEN_BOTH, GIC_V2, NONE);
    DO_TEST_FULL("aarch64-gic-v2", WHEN_BOTH, GIC_V3, NONE);
    DO_TEST_FULL("aarch64-gic-v2", WHEN_BOTH, GIC_BOTH, NONE);
    DO_TEST_FULL("aarch64-gic-v3", WHEN_BOTH, GIC_NONE, NONE);
    DO_TEST_FULL("aarch64-gic-v3", WHEN_BOTH, GIC_V2, NONE);
    DO_TEST_FULL("aarch64-gic-v3", WHEN_BOTH, GIC_V3, NONE);
    DO_TEST_FULL("aarch64-gic-v3", WHEN_BOTH, GIC_BOTH, NONE);
    DO_TEST_FULL("aarch64-gic-host", WHEN_BOTH, GIC_NONE, NONE);
    DO_TEST_FULL("aarch64-gic-host", WHEN_BOTH, GIC_V2, NONE);
    DO_TEST_FULL("aarch64-gic-host", WHEN_BOTH, GIC_V3, NONE);
    DO_TEST_FULL("aarch64-gic-host", WHEN_BOTH, GIC_BOTH, NONE);
1106

1107 1108 1109
    DO_TEST("memory-hotplug", NONE);
    DO_TEST("memory-hotplug-nonuma", NONE);
    DO_TEST("memory-hotplug-dimm", NONE);
M
Michal Privoznik 已提交
1110
    DO_TEST("memory-hotplug-nvdimm", NONE);
1111
    DO_TEST("memory-hotplug-nvdimm-access", NONE);
1112
    DO_TEST("memory-hotplug-nvdimm-label", NONE);
1113
    DO_TEST("memory-hotplug-nvdimm-align", NONE);
1114
    DO_TEST("memory-hotplug-nvdimm-pmem", NONE);
1115
    DO_TEST("memory-hotplug-nvdimm-readonly", NONE);
1116
    DO_TEST("net-udp", NONE);
1117

1118 1119 1120
    DO_TEST("video-virtio-gpu-device", NONE);
    DO_TEST("video-virtio-gpu-virgl", NONE);
    DO_TEST("video-virtio-gpu-spice-gl", NONE);
1121
    DO_TEST("video-virtio-gpu-sdl-gl", NONE);
1122 1123 1124 1125 1126 1127 1128

    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 已提交
1129

1130 1131
    DO_TEST("memorybacking-set", NONE);
    DO_TEST("memorybacking-unset", NONE);
1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145

    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,
            QEMU_CAPS_VIRTIO_PCI_ATS);
1146

1147
    virObjectUnref(cfg);
J
Ján Tomko 已提交
1148

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

1151 1152 1153 1154 1155
    DO_TEST("video-device-pciaddr-default",
            QEMU_CAPS_KVM,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_DEVICE_QXL);
1156 1157
    DO_TEST("video-qxl-heads", NONE);
    DO_TEST("video-qxl-noheads", NONE);
1158
    DO_TEST("video-virtio-gpu-secondary", NONE);
1159
    DO_TEST("video-virtio-gpu-ccw",
1160
            QEMU_CAPS_CCW,
1161 1162 1163 1164 1165
            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);
1166
    DO_TEST("video-virtio-gpu-ccw-auto",
1167
            QEMU_CAPS_CCW,
1168 1169 1170 1171 1172
            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);
1173
    DO_TEST("video-none-device", NONE);
1174

1175
    DO_TEST("intel-iommu",
1176 1177 1178
            QEMU_CAPS_DEVICE_INTEL_IOMMU);
    DO_TEST("intel-iommu-machine",
            QEMU_CAPS_MACHINE_IOMMU);
1179 1180 1181 1182
    DO_TEST("intel-iommu-caching-mode",
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420);
1183
    DO_TEST("intel-iommu-eim", NONE);
J
Ján Tomko 已提交
1184
    DO_TEST("intel-iommu-device-iotlb", NONE);
J
Ján Tomko 已提交
1185

1186 1187 1188 1189 1190 1191 1192
    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 已提交
1193
    DO_TEST("vmcoreinfo", NONE);
1194

1195 1196
    DO_TEST("smartcard-host", NONE);
    DO_TEST("smartcard-host-certificates", NONE);
1197
    DO_TEST("smartcard-host-certificates-database", NONE);
1198 1199 1200 1201
    DO_TEST("smartcard-passthrough-tcp", NONE);
    DO_TEST("smartcard-passthrough-spicevmc", NONE);
    DO_TEST("smartcard-controller", NONE);

1202 1203 1204 1205 1206 1207
    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);
1208

1209
    DO_TEST("user-aliases", QEMU_CAPS_QCOW2_LUKS);
1210
    DO_TEST("input-virtio-ccw",
1211
            QEMU_CAPS_CCW,
1212 1213 1214 1215 1216 1217
            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);
1218

1219 1220 1221 1222 1223 1224 1225 1226 1227
    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);

1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244
# define DO_TEST_STATUS(name) \
    do { \
        if (testInfoSetStatus(&info, name, GIC_NONE) < 0) { \
            VIR_TEST_DEBUG("Failed to generate status test data for '%s'", name); \
            return -1; \
        } \
\
        if (virTestRun("QEMU status XML-2-XML " name, \
                       testCompareStatusXMLToXMLFiles, &info) < 0) \
            ret = -1; \
\
        testInfoClear(&info); \
    } while (0)


    DO_TEST_STATUS("blockjob-mirror");
    DO_TEST_STATUS("vcpus-multi");
1245
    DO_TEST_STATUS("modern");
1246
    DO_TEST_STATUS("migration-out-nbd");
1247 1248
    DO_TEST_STATUS("migration-in-params");
    DO_TEST_STATUS("migration-out-params");
1249
    DO_TEST_STATUS("migration-out-nbd-tls");
1250
    DO_TEST_STATUS("disk-secinfo-upgrade");
1251

1252 1253
    DO_TEST("vhost-vsock", QEMU_CAPS_DEVICE_VHOST_VSOCK);
    DO_TEST("vhost-vsock-auto", QEMU_CAPS_DEVICE_VHOST_VSOCK);
1254 1255 1256 1257 1258
    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 已提交
1259 1260
    DO_TEST("riscv64-virt",
            QEMU_CAPS_DEVICE_VIRTIO_MMIO);
1261 1262
    DO_TEST("riscv64-virt-pci",
            QEMU_CAPS_OBJECT_GPEX);
J
Ján Tomko 已提交
1263

A
Andrea Bolognani 已提交
1264 1265 1266
    if (getenv("LIBVIRT_SKIP_CLEANUP") == NULL)
        virFileDeleteTree(fakerootdir);

1267
    qemuTestDriverFree(&driver);
A
Andrea Bolognani 已提交
1268
    VIR_FREE(fakerootdir);
1269

1270
    return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1271 1272
}

A
Andrea Bolognani 已提交
1273
VIR_TEST_MAIN_PRELOAD(mymain,
1274 1275
                      abs_builddir "/.libs/virpcimock.so",
                      abs_builddir "/.libs/virrandommock.so")
1276

1277 1278
#else

1279 1280 1281 1282 1283
int
main(void)
{
    return EXIT_AM_SKIP;
}
1284 1285

#endif /* WITH_QEMU */