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

3
#include <stdio.h>
4 5
#include <stdlib.h>
#include <unistd.h>
6 7 8 9 10
#include <string.h>

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

11 12
#include "testutils.h"

13 14
#ifdef WITH_QEMU

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

21 22
# define VIR_FROM_THIS VIR_FROM_NONE

23
static virQEMUDriver driver;
24

25 26 27 28 29 30 31 32 33 34
enum {
    WHEN_INACTIVE = 1,
    WHEN_ACTIVE = 2,
    WHEN_BOTH = 3,
};

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

36
    virBitmapPtr activeVcpus;
37
    bool blockjobs;
38

39
    virQEMUCapsPtr qemuCaps;
40 41
};

42

43 44 45 46 47
static int
testXML2XMLActive(const void *opaque)
{
    const struct testInfo *info = opaque;

48
    return testCompareDomXML2XMLFiles(driver.caps, driver.xmlopt,
49
                                      info->inName, info->outActiveName, true,
50
                                      0,
51
                                      TEST_COMPARE_DOM_XML2XML_RESULT_SUCCESS);
52 53
}

54

55
static int
56
testXML2XMLInactive(const void *opaque)
57
{
58 59
    const struct testInfo *info = opaque;

60
    return testCompareDomXML2XMLFiles(driver.caps, driver.xmlopt, info->inName,
61
                                      info->outInactiveName, false,
62
                                      0,
63
                                      TEST_COMPARE_DOM_XML2XML_RESULT_SUCCESS);
64
}
65

66

67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
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_OSTYPE_CHECKS |
                                      VIR_DOMAIN_DEF_PARSE_SKIP_VALIDATE |
                                      VIR_DOMAIN_DEF_PARSE_ALLOW_POST_PARSE_FAIL)))
        goto cleanup;

    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 |
                                      VIR_DOMAIN_DEF_FORMAT_CLOCK_ADJUST)))

        goto cleanup;

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

    ret = 0;

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


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

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

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


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

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

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

132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
    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;

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

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

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

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

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

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

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

185
    return 0;
186

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

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

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 已提交
215
# define FAKEROOTDIRTEMPLATE abs_builddir "/fakerootdir-XXXXXX"
216

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

A
Andrea Bolognani 已提交
225 226 227 228 229 230 231 232 233 234 235 236
    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);

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

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

242 243
    cfg = virQEMUDriverGetConfig(&driver);

244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
# 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; \
        } \
263
        testInfoClear(&info); \
264 265
    } while (0)

266 267
# define NONE QEMU_CAPS_LAST

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


272 273 274 275 276

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

278
    DO_TEST("minimal", NONE);
279 280
    DO_TEST("genid", NONE);
    DO_TEST("genid-auto", NONE);
281 282
    DO_TEST("machine-core-on", NONE);
    DO_TEST("machine-core-off", NONE);
283
    DO_TEST("machine-loadparm-multiple-disks-nets-s390", NONE);
284 285 286 287 288
    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);
289 290 291 292 293
    DO_TEST("boot-floppy-q35",
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI);
    DO_TEST("bootindex-floppy-q35",
            QEMU_CAPS_DEVICE_IOH3420,
J
Ján Tomko 已提交
294
            QEMU_CAPS_ICH9_AHCI,
295
            QEMU_CAPS_BOOTINDEX);
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 328 329 330 331 332 333 334 335 336
    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);

    DO_TEST("hugepages", NONE);
    DO_TEST("hugepages-pages", NONE);
    DO_TEST("hugepages-pages2", NONE);
    DO_TEST("hugepages-pages3", NONE);
337 338 339
    DO_TEST("hugepages-pages4", NONE);
    DO_TEST("hugepages-pages5", NONE);
    DO_TEST("hugepages-pages6", NONE);
340
    DO_TEST("hugepages-pages7", NONE);
341
    DO_TEST("hugepages-shared", NONE);
342
    DO_TEST("hugepages-memaccess", NONE);
343
    DO_TEST("hugepages-memaccess2", NONE);
344 345 346 347 348 349 350 351 352 353 354 355
    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-cdrom-empty", NONE);
    DO_TEST("disk-floppy", NONE);
    DO_TEST("disk-many", NONE);
    DO_TEST("disk-usb-device", NONE);
    DO_TEST("disk-virtio", NONE);
    DO_TEST("floppy-drive-fat", NONE);
L
Lin Ma 已提交
356
    DO_TEST("disk-virtio-drive-queues", QEMU_CAPS_VIRTIO_BLK_NUM_QUEUES);
357 358
    DO_TEST("disk-drive-boot-disk", NONE);
    DO_TEST("disk-drive-boot-cdrom", NONE);
359
    DO_TEST("disk-drive-error-policy", NONE);
360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
    DO_TEST("disk-drive-fmt-qcow", NONE);
    DO_TEST("disk-drive-copy-on-read", NONE);
    DO_TEST("disk-drive-cache-v2-wt", NONE);
    DO_TEST("disk-drive-cache-v2-wb", NONE);
    DO_TEST("disk-drive-cache-v2-none", NONE);
    DO_TEST("disk-drive-cache-directsync", NONE);
    DO_TEST("disk-drive-cache-unsafe", NONE);
    DO_TEST("disk-drive-network-nbd", NONE);
    DO_TEST("disk-drive-network-nbd-export", NONE);
    DO_TEST("disk-drive-network-nbd-ipv6", NONE);
    DO_TEST("disk-drive-network-nbd-ipv6-export", NONE);
    DO_TEST("disk-drive-network-nbd-unix", NONE);
    DO_TEST("disk-drive-network-iscsi", NONE);
    DO_TEST("disk-drive-network-iscsi-auth", NONE);
    DO_TEST("disk-drive-network-gluster", NONE);
    DO_TEST("disk-drive-network-rbd", NONE);
    DO_TEST("disk-drive-network-rbd-auth", NONE);
    DO_TEST("disk-drive-network-rbd-ipv6", NONE);
    DO_TEST("disk-drive-network-rbd-ceph-env", NONE);
379
    DO_TEST("disk-drive-network-source-auth", NONE);
380
    DO_TEST("disk-drive-network-sheepdog", NONE);
381
    DO_TEST("disk-drive-network-vxhs", NONE);
382
    DO_TEST("disk-drive-network-tlsx509", NONE);
383
    DO_TEST("disk-scsi-device",
384
            QEMU_CAPS_SCSI_LSI);
385
    DO_TEST("disk-scsi-vscsi", NONE);
386
    DO_TEST("disk-scsi-virtio-scsi",
387
            QEMU_CAPS_VIRTIO_SCSI);
388
    DO_TEST("disk-virtio-scsi-num_queues",
389
            QEMU_CAPS_VIRTIO_SCSI);
390
    DO_TEST("disk-virtio-scsi-reservations",
391
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_PR_MANAGER_HELPER);
392
    DO_TEST("disk-virtio-scsi-cmd_per_lun",
393
            QEMU_CAPS_VIRTIO_SCSI);
394
    DO_TEST("disk-virtio-scsi-max_sectors",
395
            QEMU_CAPS_VIRTIO_SCSI);
396
    DO_TEST("disk-virtio-scsi-ioeventfd",
397
            QEMU_CAPS_VIRTIO_SCSI);
398
    DO_TEST("disk-scsi-megasas",
399
            QEMU_CAPS_SCSI_MEGASAS);
400
    DO_TEST("disk-scsi-mptsas1068",
401
            QEMU_CAPS_SCSI_MPTSAS1068,
402
            QEMU_CAPS_SCSI_DISK_WWN);
403
    DO_TEST("disk-mirror-old", NONE);
404
    DO_TEST("disk-mirror", NONE);
405
    DO_TEST_FULL("disk-active-commit", WHEN_ACTIVE, GIC_NONE, NONE);
406 407 408 409 410 411 412
    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);
413
    cfg->vncAutoUnixSocket = true;
414
    DO_TEST("graphics-vnc-auto-socket-cfg", NONE);
415
    cfg->vncAutoUnixSocket = false;
416 417
    DO_TEST("graphics-vnc-socket", NONE);
    DO_TEST("graphics-vnc-auto-socket", NONE);
418
    DO_TEST("graphics-vnc-egl-headless", NONE);
419 420 421 422 423 424 425 426

    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);
427
    cfg->spiceAutoUnixSocket = true;
428
    DO_TEST("graphics-spice-auto-socket-cfg", NONE);
429
    cfg->spiceAutoUnixSocket = false;
430
    DO_TEST("graphics-spice-egl-headless", NONE);
431

432 433 434 435 436 437 438 439 440 441
    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 已提交
442
    DO_TEST("net-user-addr", NONE);
443 444 445 446 447 448 449
    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);
450
    DO_TEST("net-virtio-rxtxqueuesize", NONE);
451 452 453 454 455 456 457 458 459
    DO_TEST("net-hostdev", NONE);
    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);
460
    DO_TEST("net-mtu", NONE);
461
    DO_TEST("net-coalesce", NONE);
462

463
    DO_TEST("serial-tcp-tlsx509-chardev", NONE);
464
    DO_TEST("serial-tcp-tlsx509-chardev-notls", NONE);
465 466 467 468 469 470 471 472 473
    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);

474 475
    DO_TEST_FULL("channel-unix-source-path", WHEN_INACTIVE, GIC_NONE, NONE);

476 477 478
    DO_TEST("hostdev-usb-address", NONE);
    DO_TEST("hostdev-pci-address", NONE);
    DO_TEST("hostdev-vfio", NONE);
479
    DO_TEST("hostdev-mdev-precreated", NONE);
480
    DO_TEST("hostdev-mdev-display", QEMU_CAPS_VFIO_PCI_DISPLAY);
481
    DO_TEST("pci-rom", NONE);
482
    DO_TEST("pci-rom-disabled", NONE);
483
    DO_TEST("pci-rom-disabled-invalid", NONE);
484 485
    DO_TEST("pci-serial-dev-chardev", NONE);

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

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

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

553 554 555 556
    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);
557
    DO_TEST("seclabel-static", NONE);
558
    DO_TEST_FULL("seclabel-static-labelskip", WHEN_ACTIVE, GIC_NONE, NONE);
559 560 561 562
    DO_TEST("seclabel-none", NONE);
    DO_TEST("seclabel-dac-none", NONE);
    DO_TEST("seclabel-dynamic-none", NONE);
    DO_TEST("seclabel-device-multiple", NONE);
563
    DO_TEST_FULL("seclabel-dynamic-none-relabel", WHEN_INACTIVE, GIC_NONE, NONE);
564
    DO_TEST("numad-static-vcpu-no-numatune", NONE);
565

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

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

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

580 581
    DO_TEST("virtio-rng-random", NONE);
    DO_TEST("virtio-rng-egd", NONE);
582

583 584 585 586 587 588
    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);
589

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

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

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

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

666 667 668 669
    DO_TEST("balloon-device-auto", NONE);
    DO_TEST("balloon-device-period", NONE);
    DO_TEST("channel-virtio-auto", NONE);
    DO_TEST("console-compat-auto", NONE);
670
    DO_TEST("disk-scsi-device-auto",
671
            QEMU_CAPS_SCSI_LSI);
672 673 674 675 676 677 678 679 680 681
    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);
682
    DO_TEST("tpm-passthrough-crb", NONE);
683
    DO_TEST("tpm-emulator", NONE);
684 685 686

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

688
    DO_TEST("pci-bridge",
689 690 691 692 693
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
    DO_TEST("pci-many",
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
694 695 696
    DO_TEST("pci-bridge-many-disks",
            QEMU_CAPS_DEVICE_PCI_BRIDGE);
    DO_TEST("pci-autoadd-addr",
697 698
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
699
    DO_TEST("pci-autoadd-idx",
700 701
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
702
    DO_TEST("pci-autofill-addr", NONE);
703

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

    /* Test automatic and manual setting of pcie-root-port attributes */
867
    DO_TEST("pcie-root-port",
868 869
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
870
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
871
            QEMU_CAPS_DEVICE_QXL);
872 873 874 875 876 877

    /* 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,
878
            QEMU_CAPS_DEVICE_IOH3420);
879
    DO_TEST("pcie-root-port-model-ioh3420",
880
            QEMU_CAPS_DEVICE_IOH3420);
881

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

919 920
    DO_TEST("hostdev-scsi-vhost-scsi-ccw",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
921
            QEMU_CAPS_DEVICE_SCSI_GENERIC, QEMU_CAPS_CCW);
922 923 924
    DO_TEST("hostdev-scsi-vhost-scsi-pci",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
925 926 927 928 929 930
    DO_TEST("hostdev-scsi-vhost-scsi-pcie",
            QEMU_CAPS_KVM,
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC,
            QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
            QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY);
931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970
    DO_TEST("hostdev-scsi-lsi",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
    DO_TEST("hostdev-scsi-virtio-scsi",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
    DO_TEST("hostdev-scsi-readonly",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);

    DO_TEST("hostdev-scsi-shareable",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
    DO_TEST("hostdev-scsi-sgio",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
    DO_TEST("hostdev-scsi-rawio",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);

    DO_TEST("hostdev-scsi-autogen-address",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
    DO_TEST("hostdev-scsi-large-unit",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);

    DO_TEST("hostdev-scsi-lsi-iscsi",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
    DO_TEST("hostdev-scsi-lsi-iscsi-auth",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
    DO_TEST("hostdev-scsi-virtio-iscsi",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
    DO_TEST("hostdev-scsi-virtio-iscsi-auth",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_LSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);

971 972 973 974 975
    DO_TEST("hostdev-subsys-mdev-vfio-ccw",
            QEMU_CAPS_CCW,
            QEMU_CAPS_CCW_CSSID_UNRESTRICTED,
            QEMU_CAPS_DEVICE_VFIO_CCW);

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

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

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

1008
    DO_TEST("disk-backing-chains", NONE);
1009

1010
    DO_TEST("chardev-label", NONE);
J
Ján Tomko 已提交
1011

1012 1013 1014 1015 1016 1017
    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);
1018

1019 1020 1021
    DO_TEST("numatune-auto-prefer", NONE);
    DO_TEST("numatune-memnode", NONE);
    DO_TEST("numatune-memnode-no-memory", NONE);
1022

1023 1024
    DO_TEST("bios-nvram", NONE);
    DO_TEST("bios-nvram-os-interleave", NONE);
1025

1026 1027 1028
    DO_TEST("tap-vhost", NONE);
    DO_TEST("tap-vhost-incorrect", NONE);
    DO_TEST("shmem", NONE);
1029
    DO_TEST("shmem-plain-doorbell", NONE);
1030 1031
    DO_TEST("smbios", NONE);
    DO_TEST("smbios-multiple-type2", NONE);
1032

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

1079 1080 1081 1082
    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);
1083
    DO_TEST_FULL("aarch64-gic-none-tcg", WHEN_BOTH, GIC_BOTH, NONE);
1084
    DO_TEST_FULL("aarch64-gic-default", WHEN_BOTH, GIC_NONE, NONE);
A
Andrea Bolognani 已提交
1085 1086 1087
    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);
1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099
    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);
1100

1101 1102 1103
    DO_TEST("memory-hotplug", NONE);
    DO_TEST("memory-hotplug-nonuma", NONE);
    DO_TEST("memory-hotplug-dimm", NONE);
M
Michal Privoznik 已提交
1104
    DO_TEST("memory-hotplug-nvdimm", NONE);
1105
    DO_TEST("memory-hotplug-nvdimm-access", NONE);
1106
    DO_TEST("memory-hotplug-nvdimm-label", NONE);
1107
    DO_TEST("net-udp", NONE);
1108

1109 1110 1111
    DO_TEST("video-virtio-gpu-device", NONE);
    DO_TEST("video-virtio-gpu-virgl", NONE);
    DO_TEST("video-virtio-gpu-spice-gl", NONE);
1112
    DO_TEST("video-virtio-gpu-sdl-gl", NONE);
1113 1114
    DO_TEST("virtio-input", NONE);
    DO_TEST("virtio-input-passthrough", NONE);
M
Marc-André Lureau 已提交
1115

1116 1117
    DO_TEST("memorybacking-set", NONE);
    DO_TEST("memorybacking-unset", NONE);
1118
    DO_TEST("virtio-options", QEMU_CAPS_VIRTIO_SCSI);
1119

1120
    virObjectUnref(cfg);
J
Ján Tomko 已提交
1121

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

1124 1125 1126 1127 1128
    DO_TEST("video-device-pciaddr-default",
            QEMU_CAPS_KVM,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_DEVICE_QXL);
1129 1130
    DO_TEST("video-qxl-heads", NONE);
    DO_TEST("video-qxl-noheads", NONE);
1131
    DO_TEST("video-virtio-gpu-secondary", NONE);
1132
    DO_TEST("video-virtio-gpu-ccw",
1133
            QEMU_CAPS_CCW,
1134 1135 1136 1137 1138
            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);
1139
    DO_TEST("video-virtio-gpu-ccw-auto",
1140
            QEMU_CAPS_CCW,
1141 1142 1143 1144 1145
            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);
1146

1147
    DO_TEST("intel-iommu",
1148 1149 1150
            QEMU_CAPS_DEVICE_INTEL_IOMMU);
    DO_TEST("intel-iommu-machine",
            QEMU_CAPS_MACHINE_IOMMU);
1151 1152 1153 1154
    DO_TEST("intel-iommu-caching-mode",
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420);
1155
    DO_TEST("intel-iommu-eim", NONE);
J
Ján Tomko 已提交
1156
    DO_TEST("intel-iommu-device-iotlb", NONE);
J
Ján Tomko 已提交
1157

1158 1159 1160 1161 1162 1163 1164
    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 已提交
1165
    DO_TEST("vmcoreinfo", NONE);
1166

1167 1168
    DO_TEST("smartcard-host", NONE);
    DO_TEST("smartcard-host-certificates", NONE);
1169
    DO_TEST("smartcard-host-certificates-database", NONE);
1170 1171 1172 1173
    DO_TEST("smartcard-passthrough-tcp", NONE);
    DO_TEST("smartcard-passthrough-spicevmc", NONE);
    DO_TEST("smartcard-controller", NONE);

1174 1175 1176 1177 1178 1179
    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);
1180

1181
    DO_TEST("user-aliases", QEMU_CAPS_QCOW2_LUKS);
1182
    DO_TEST("input-virtio-ccw",
1183
            QEMU_CAPS_CCW,
1184 1185 1186 1187 1188 1189
            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);
1190

1191 1192 1193 1194 1195 1196 1197 1198 1199
    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);

1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
# 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");
1217
    DO_TEST_STATUS("modern");
1218
    DO_TEST_STATUS("migration-out-nbd");
1219 1220
    DO_TEST_STATUS("migration-in-params");
    DO_TEST_STATUS("migration-out-params");
1221
    DO_TEST_STATUS("migration-out-nbd-tls");
1222
    DO_TEST_STATUS("disk-secinfo-upgrade");
1223

1224 1225
    DO_TEST("vhost-vsock", QEMU_CAPS_DEVICE_VHOST_VSOCK);
    DO_TEST("vhost-vsock-auto", QEMU_CAPS_DEVICE_VHOST_VSOCK);
J
Ján Tomko 已提交
1226

A
Andrea Bolognani 已提交
1227 1228 1229
    if (getenv("LIBVIRT_SKIP_CLEANUP") == NULL)
        virFileDeleteTree(fakerootdir);

1230
    qemuTestDriverFree(&driver);
A
Andrea Bolognani 已提交
1231
    VIR_FREE(fakerootdir);
1232

1233
    return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1234 1235
}

A
Andrea Bolognani 已提交
1236
VIR_TEST_MAIN_PRELOAD(mymain,
1237 1238
                      abs_builddir "/.libs/virpcimock.so",
                      abs_builddir "/.libs/virrandommock.so")
1239

1240 1241
#else

1242 1243 1244 1245 1246
int
main(void)
{
    return EXIT_AM_SKIP;
}
1247 1248

#endif /* WITH_QEMU */