qemuxml2xmltest.c 43.3 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 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380
    DO_TEST("disk-drive-boot-disk", NONE);
    DO_TEST("disk-drive-boot-cdrom", NONE);
    DO_TEST("disk-drive-error-policy-stop", NONE);
    DO_TEST("disk-drive-error-policy-enospace", NONE);
    DO_TEST("disk-drive-error-policy-wreport-rignore", NONE);
    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);
381
    DO_TEST("disk-drive-network-source-auth", NONE);
382
    DO_TEST("disk-drive-network-sheepdog", NONE);
383
    DO_TEST("disk-drive-network-vxhs", NONE);
384
    DO_TEST("disk-drive-network-tlsx509-vxhs", NONE);
385
    DO_TEST("disk-scsi-device",
386
            QEMU_CAPS_SCSI_LSI);
387
    DO_TEST("disk-scsi-vscsi", NONE);
388
    DO_TEST("disk-scsi-virtio-scsi",
389
            QEMU_CAPS_VIRTIO_SCSI);
390
    DO_TEST("disk-virtio-scsi-num_queues",
391
            QEMU_CAPS_VIRTIO_SCSI);
392
    DO_TEST("disk-virtio-scsi-reservations",
393
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_PR_MANAGER_HELPER);
394
    DO_TEST("disk-virtio-scsi-cmd_per_lun",
395
            QEMU_CAPS_VIRTIO_SCSI);
396
    DO_TEST("disk-virtio-scsi-max_sectors",
397
            QEMU_CAPS_VIRTIO_SCSI);
398
    DO_TEST("disk-virtio-scsi-ioeventfd",
399
            QEMU_CAPS_VIRTIO_SCSI);
400
    DO_TEST("disk-scsi-megasas",
401
            QEMU_CAPS_SCSI_MEGASAS);
402
    DO_TEST("disk-scsi-mptsas1068",
403
            QEMU_CAPS_SCSI_MPTSAS1068,
404
            QEMU_CAPS_SCSI_DISK_WWN);
405
    DO_TEST("disk-mirror-old", NONE);
406
    DO_TEST("disk-mirror", NONE);
407
    DO_TEST_FULL("disk-active-commit", WHEN_ACTIVE, GIC_NONE, NONE);
408 409 410 411 412 413 414
    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);
415
    cfg->vncAutoUnixSocket = true;
416
    DO_TEST("graphics-vnc-auto-socket-cfg", NONE);
417
    cfg->vncAutoUnixSocket = false;
418 419 420 421 422 423 424 425 426 427
    DO_TEST("graphics-vnc-socket", NONE);
    DO_TEST("graphics-vnc-auto-socket", NONE);

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

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("pci-rom", NONE);
481
    DO_TEST("pci-rom-disabled", NONE);
482
    DO_TEST("pci-rom-disabled-invalid", NONE);
483 484 485 486 487
    DO_TEST("pci-serial-dev-chardev", NONE);

    DO_TEST("encrypted-disk", NONE);
    DO_TEST("encrypted-disk-usage", NONE);
    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-drive-discard", NONE);
    DO_TEST("disk-drive-detect-zeroes", NONE);
O
Osier Yang 已提交
576

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

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

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

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

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

620
    DO_TEST("pseries-features",
621
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
622 623
            QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT);

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

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

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

684
    DO_TEST("pci-bridge",
685 686 687 688 689
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
    DO_TEST("pci-many",
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
690 691 692
    DO_TEST("pci-bridge-many-disks",
            QEMU_CAPS_DEVICE_PCI_BRIDGE);
    DO_TEST("pci-autoadd-addr",
693 694
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
695
    DO_TEST("pci-autoadd-idx",
696 697
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
698
    DO_TEST("pci-autofill-addr", NONE);
699

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

    /* Test automatic and manual setting of pcie-root-port attributes */
863
    DO_TEST("pcie-root-port",
864 865
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
866
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
867
            QEMU_CAPS_DEVICE_QXL);
868 869 870 871 872 873

    /* 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,
874
            QEMU_CAPS_DEVICE_IOH3420);
875
    DO_TEST("pcie-root-port-model-ioh3420",
876
            QEMU_CAPS_DEVICE_IOH3420);
877

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

915 916
    DO_TEST("hostdev-scsi-vhost-scsi-ccw",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
917
            QEMU_CAPS_DEVICE_SCSI_GENERIC, QEMU_CAPS_CCW);
918 919 920
    DO_TEST("hostdev-scsi-vhost-scsi-pci",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
921 922 923 924 925 926
    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);
927 928 929 930 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
    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);

967 968 969 970 971
    DO_TEST("hostdev-subsys-mdev-vfio-ccw",
            QEMU_CAPS_CCW,
            QEMU_CAPS_CCW_CSSID_UNRESTRICTED,
            QEMU_CAPS_DEVICE_VFIO_CCW);

972
    DO_TEST("s390-defaultconsole",
973
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
974
    DO_TEST("s390-panic",
975
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
976
    DO_TEST("s390-panic-missing",
977
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
978
    DO_TEST("s390-panic-no-address",
979
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
980
    DO_TEST("s390-serial",
981
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
982
    DO_TEST("s390-serial-2",
983
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
984
    DO_TEST("s390-serial-console",
985
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
986

987 988 989
    DO_TEST("pcihole64", NONE);
    DO_TEST("pcihole64-gib", NONE);
    DO_TEST("pcihole64-none", NONE);
990
    DO_TEST("pcihole64-q35",
991
            QEMU_CAPS_DEVICE_IOH3420,
992 993
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
994
            QEMU_CAPS_DEVICE_QXL,
995
            QEMU_CAPS_Q35_PCI_HOLE64_SIZE);
996

997 998
    DO_TEST("panic", NONE);
    DO_TEST("panic-isa", NONE);
999 1000
    DO_TEST("panic-pseries",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
1001 1002
    DO_TEST("panic-double", NONE);
    DO_TEST("panic-no-address", NONE);
H
Hu Tao 已提交
1003

1004
    DO_TEST("disk-backing-chains", NONE);
1005

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

1008 1009 1010 1011 1012 1013
    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);
1014

1015 1016 1017
    DO_TEST("numatune-auto-prefer", NONE);
    DO_TEST("numatune-memnode", NONE);
    DO_TEST("numatune-memnode-no-memory", NONE);
1018

1019 1020
    DO_TEST("bios-nvram", NONE);
    DO_TEST("bios-nvram-os-interleave", NONE);
1021

1022 1023 1024
    DO_TEST("tap-vhost", NONE);
    DO_TEST("tap-vhost-incorrect", NONE);
    DO_TEST("shmem", NONE);
1025
    DO_TEST("shmem-plain-doorbell", NONE);
1026 1027
    DO_TEST("smbios", NONE);
    DO_TEST("smbios-multiple-type2", NONE);
1028

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

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

1097 1098 1099
    DO_TEST("memory-hotplug", NONE);
    DO_TEST("memory-hotplug-nonuma", NONE);
    DO_TEST("memory-hotplug-dimm", NONE);
M
Michal Privoznik 已提交
1100
    DO_TEST("memory-hotplug-nvdimm", NONE);
1101
    DO_TEST("memory-hotplug-nvdimm-access", NONE);
1102
    DO_TEST("memory-hotplug-nvdimm-label", NONE);
1103
    DO_TEST("net-udp", NONE);
1104

1105 1106 1107
    DO_TEST("video-virtio-gpu-device", NONE);
    DO_TEST("video-virtio-gpu-virgl", NONE);
    DO_TEST("video-virtio-gpu-spice-gl", NONE);
1108
    DO_TEST("video-virtio-gpu-sdl-gl", NONE);
1109 1110
    DO_TEST("virtio-input", NONE);
    DO_TEST("virtio-input-passthrough", NONE);
M
Marc-André Lureau 已提交
1111

1112 1113
    DO_TEST("memorybacking-set", NONE);
    DO_TEST("memorybacking-unset", NONE);
1114
    DO_TEST("virtio-options", QEMU_CAPS_VIRTIO_SCSI);
1115

1116
    virObjectUnref(cfg);
J
Ján Tomko 已提交
1117

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

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

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

1154 1155 1156 1157 1158 1159 1160
    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 已提交
1161
    DO_TEST("vmcoreinfo", NONE);
1162

1163 1164 1165 1166 1167 1168
    DO_TEST("smartcard-host", NONE);
    DO_TEST("smartcard-host-certificates", NONE);
    DO_TEST("smartcard-passthrough-tcp", NONE);
    DO_TEST("smartcard-passthrough-spicevmc", NONE);
    DO_TEST("smartcard-controller", NONE);

1169 1170 1171 1172 1173 1174
    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);
1175

1176
    DO_TEST("user-aliases", QEMU_CAPS_QCOW2_LUKS);
1177
    DO_TEST("input-virtio-ccw",
1178
            QEMU_CAPS_CCW,
1179 1180 1181 1182 1183 1184
            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);
1185

1186 1187 1188 1189 1190 1191
    /* Test disks with format probing enabled for legacy reasons.
     * New tests should not go in this section. */
    driver.config->allowDiskFormatProbing = true;
    DO_TEST("disk-many-format-probing", NONE);
    driver.config->allowDiskFormatProbing = false;

1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208
# 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");
1209
    DO_TEST_STATUS("modern");
1210
    DO_TEST_STATUS("migration-out-nbd");
1211 1212
    DO_TEST_STATUS("migration-in-params");
    DO_TEST_STATUS("migration-out-params");
1213
    DO_TEST_STATUS("migration-out-nbd-tls");
1214

1215 1216
    DO_TEST("vhost-vsock", QEMU_CAPS_DEVICE_VHOST_VSOCK);
    DO_TEST("vhost-vsock-auto", QEMU_CAPS_DEVICE_VHOST_VSOCK);
J
Ján Tomko 已提交
1217

A
Andrea Bolognani 已提交
1218 1219 1220
    if (getenv("LIBVIRT_SKIP_CLEANUP") == NULL)
        virFileDeleteTree(fakerootdir);

1221
    qemuTestDriverFree(&driver);
A
Andrea Bolognani 已提交
1222
    VIR_FREE(fakerootdir);
1223

1224
    return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1225 1226
}

A
Andrea Bolognani 已提交
1227
VIR_TEST_MAIN_PRELOAD(mymain,
1228 1229
                      abs_builddir "/.libs/virpcimock.so",
                      abs_builddir "/.libs/virrandommock.so")
1230

1231 1232
#else

1233 1234 1235 1236 1237
int
main(void)
{
    return EXIT_AM_SKIP;
}
1238 1239

#endif /* WITH_QEMU */