qemuxml2xmltest.c 42.7 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 279 280
    DO_TEST("minimal", NONE);
    DO_TEST("machine-core-on", NONE);
    DO_TEST("machine-core-off", NONE);
281
    DO_TEST("machine-loadparm-multiple-disks-nets-s390", NONE);
282 283 284 285 286
    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);
287 288 289 290 291
    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 已提交
292
            QEMU_CAPS_ICH9_AHCI,
293
            QEMU_CAPS_BOOTINDEX);
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
    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);
335 336 337
    DO_TEST("hugepages-pages4", NONE);
    DO_TEST("hugepages-pages5", NONE);
    DO_TEST("hugepages-pages6", NONE);
338
    DO_TEST("hugepages-pages7", NONE);
339
    DO_TEST("hugepages-shared", NONE);
340
    DO_TEST("hugepages-memaccess", NONE);
341
    DO_TEST("hugepages-memaccess2", NONE);
342 343 344 345 346 347 348 349 350 351 352 353
    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 已提交
354
    DO_TEST("disk-virtio-drive-queues", QEMU_CAPS_VIRTIO_BLK_NUM_QUEUES);
355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
    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);
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-vxhs", 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-cmd_per_lun",
391
            QEMU_CAPS_VIRTIO_SCSI);
392
    DO_TEST("disk-virtio-scsi-max_sectors",
393
            QEMU_CAPS_VIRTIO_SCSI);
394
    DO_TEST("disk-virtio-scsi-ioeventfd",
395
            QEMU_CAPS_VIRTIO_SCSI);
396
    DO_TEST("disk-scsi-megasas",
397
            QEMU_CAPS_SCSI_MEGASAS);
398
    DO_TEST("disk-scsi-mptsas1068",
399
            QEMU_CAPS_SCSI_MPTSAS1068,
400
            QEMU_CAPS_SCSI_DISK_WWN);
401
    DO_TEST("disk-mirror-old", NONE);
402
    DO_TEST("disk-mirror", NONE);
403
    DO_TEST_FULL("disk-active-commit", WHEN_ACTIVE, GIC_NONE, NONE);
404 405 406 407 408 409 410
    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);
411
    cfg->vncAutoUnixSocket = true;
412
    DO_TEST("graphics-vnc-auto-socket-cfg", NONE);
413
    cfg->vncAutoUnixSocket = false;
414 415 416 417 418 419 420 421 422 423
    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);
424
    cfg->spiceAutoUnixSocket = true;
425
    DO_TEST("graphics-spice-auto-socket-cfg", NONE);
426 427
    cfg->spiceAutoUnixSocket = false;

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

459
    DO_TEST("serial-tcp-tlsx509-chardev", NONE);
460
    DO_TEST("serial-tcp-tlsx509-chardev-notls", NONE);
461 462 463 464 465 466 467 468 469
    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);

470 471
    DO_TEST_FULL("channel-unix-source-path", WHEN_INACTIVE, GIC_NONE, NONE);

472 473 474
    DO_TEST("hostdev-usb-address", NONE);
    DO_TEST("hostdev-pci-address", NONE);
    DO_TEST("hostdev-vfio", NONE);
475
    DO_TEST("hostdev-mdev-precreated", NONE);
476
    DO_TEST("pci-rom", NONE);
477
    DO_TEST("pci-rom-disabled", NONE);
478
    DO_TEST("pci-rom-disabled-invalid", NONE);
479 480 481 482 483
    DO_TEST("pci-serial-dev-chardev", NONE);

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

498 499 500 501 502 503
    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);
504 505 506
    DO_TEST("iothreads-disk-virtio-ccw",
            QEMU_CAPS_VIRTIO_CCW, QEMU_CAPS_VIRTIO_S390);
    DO_TEST("iothreads-virtio-scsi-pci",
507
            QEMU_CAPS_VIRTIO_SCSI);
508 509 510
    DO_TEST("iothreads-virtio-scsi-ccw",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_VIRTIO_CCW,
            QEMU_CAPS_VIRTIO_S390);
511 512 513 514 515 516 517
    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);

518 519 520 521 522
    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",
523
            QEMU_CAPS_DEVICE_IOH3420,
524 525
            QEMU_CAPS_PCI_OHCI,
            QEMU_CAPS_PIIX3_USB_UHCI,
526 527
            QEMU_CAPS_NEC_USB_XHCI);
    DO_TEST("usb-controller-explicit-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("ppc64-usb-controller",
533
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
534 535
            QEMU_CAPS_PCI_OHCI);
    DO_TEST("ppc64-usb-controller-legacy",
536
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
537
            QEMU_CAPS_PIIX3_USB_UHCI);
538 539 540 541 542
    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);
543
    DO_TEST("blkdeviotune-max", NONE);
544
    DO_TEST("blkdeviotune-group-num", NONE);
545
    DO_TEST("blkdeviotune-max-length", NONE);
546
    DO_TEST("controller-usb-order", NONE);
547

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

561
    DO_TEST("disk-scsi-lun-passthrough-sgio",
562
            QEMU_CAPS_SCSI_CD, QEMU_CAPS_SCSI_LSI,
563 564
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_DISK_WWN);
    DO_TEST("disk-scsi-disk-vpd",
565
            QEMU_CAPS_SCSI_CD, QEMU_CAPS_SCSI_LSI,
566
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_DISK_WWN);
567 568
    DO_TEST("disk-source-pool", NONE);
    DO_TEST("disk-source-pool-mode", NONE);
569

570 571
    DO_TEST("disk-drive-discard", NONE);
    DO_TEST("disk-drive-detect-zeroes", NONE);
O
Osier Yang 已提交
572

573 574
    DO_TEST("disk-serial", NONE);

575 576
    DO_TEST("virtio-rng-random", NONE);
    DO_TEST("virtio-rng-egd", NONE);
577

578 579 580 581 582 583
    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);
584

585 586 587 588
    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);
589 590 591 592
    DO_TEST("pseries-phb-numa-node",
            QEMU_CAPS_NUMA,
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_SPAPR_PCI_HOST_BRIDGE_NUMA_NODE);
593

594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
    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);

616
    DO_TEST("pseries-features",
617
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
618 619
            QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT);

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

659 660 661 662
    DO_TEST("balloon-device-auto", NONE);
    DO_TEST("balloon-device-period", NONE);
    DO_TEST("channel-virtio-auto", NONE);
    DO_TEST("console-compat-auto", NONE);
663
    DO_TEST("disk-scsi-device-auto",
664
            QEMU_CAPS_SCSI_LSI);
665 666 667 668 669 670 671 672 673 674 675 676 677
    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);

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

679
    DO_TEST("pci-bridge",
680 681 682 683 684
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
    DO_TEST("pci-many",
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
685 686 687
    DO_TEST("pci-bridge-many-disks",
            QEMU_CAPS_DEVICE_PCI_BRIDGE);
    DO_TEST("pci-autoadd-addr",
688 689
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
690
    DO_TEST("pci-autoadd-idx",
691 692
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
693
    DO_TEST("pci-autofill-addr", NONE);
694

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

    /* Test automatic and manual setting of pcie-root-port attributes */
859
    DO_TEST("pcie-root-port",
860 861
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
862
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
863
            QEMU_CAPS_DEVICE_QXL);
864 865 866 867 868 869

    /* 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,
870
            QEMU_CAPS_DEVICE_IOH3420);
871
    DO_TEST("pcie-root-port-model-ioh3420",
872
            QEMU_CAPS_DEVICE_IOH3420);
873

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

911 912 913 914 915 916
    DO_TEST("hostdev-scsi-vhost-scsi-ccw",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC, QEMU_CAPS_VIRTIO_CCW);
    DO_TEST("hostdev-scsi-vhost-scsi-pci",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
917 918 919 920 921 922
    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);
923 924 925 926 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 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);

    DO_TEST("s390-defaultconsole",
            QEMU_CAPS_VIRTIO_CCW, QEMU_CAPS_VIRTIO_S390);
    DO_TEST("s390-panic",
            QEMU_CAPS_VIRTIO_CCW, QEMU_CAPS_VIRTIO_S390);
    DO_TEST("s390-panic-missing",
            QEMU_CAPS_VIRTIO_CCW, QEMU_CAPS_VIRTIO_S390);
    DO_TEST("s390-panic-no-address",
            QEMU_CAPS_VIRTIO_CCW, QEMU_CAPS_VIRTIO_S390);
971 972 973 974 975 976
    DO_TEST("s390-serial",
            QEMU_CAPS_VIRTIO_CCW, QEMU_CAPS_VIRTIO_S390);
    DO_TEST("s390-serial-2",
            QEMU_CAPS_VIRTIO_CCW, QEMU_CAPS_VIRTIO_S390);
    DO_TEST("s390-serial-console",
            QEMU_CAPS_VIRTIO_CCW, QEMU_CAPS_VIRTIO_S390);
977

978 979 980
    DO_TEST("pcihole64", NONE);
    DO_TEST("pcihole64-gib", NONE);
    DO_TEST("pcihole64-none", NONE);
981
    DO_TEST("pcihole64-q35",
982
            QEMU_CAPS_DEVICE_IOH3420,
983 984
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
985
            QEMU_CAPS_DEVICE_QXL,
986
            QEMU_CAPS_Q35_PCI_HOLE64_SIZE);
987

988 989
    DO_TEST("panic", NONE);
    DO_TEST("panic-isa", NONE);
990 991
    DO_TEST("panic-pseries",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
992 993
    DO_TEST("panic-double", NONE);
    DO_TEST("panic-no-address", NONE);
H
Hu Tao 已提交
994

995
    DO_TEST("disk-backing-chains", NONE);
996

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

999 1000 1001 1002 1003 1004
    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);
1005

1006 1007 1008
    DO_TEST("numatune-auto-prefer", NONE);
    DO_TEST("numatune-memnode", NONE);
    DO_TEST("numatune-memnode-no-memory", NONE);
1009

1010 1011
    DO_TEST("bios-nvram", NONE);
    DO_TEST("bios-nvram-os-interleave", NONE);
1012

1013 1014 1015
    DO_TEST("tap-vhost", NONE);
    DO_TEST("tap-vhost-incorrect", NONE);
    DO_TEST("shmem", NONE);
1016
    DO_TEST("shmem-plain-doorbell", NONE);
1017 1018
    DO_TEST("smbios", NONE);
    DO_TEST("smbios-multiple-type2", NONE);
1019

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

1066 1067 1068 1069
    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);
1070
    DO_TEST_FULL("aarch64-gic-none-tcg", WHEN_BOTH, GIC_BOTH, NONE);
1071
    DO_TEST_FULL("aarch64-gic-default", WHEN_BOTH, GIC_NONE, NONE);
A
Andrea Bolognani 已提交
1072 1073 1074
    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);
1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
    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);
1087

1088 1089 1090
    DO_TEST("memory-hotplug", NONE);
    DO_TEST("memory-hotplug-nonuma", NONE);
    DO_TEST("memory-hotplug-dimm", NONE);
M
Michal Privoznik 已提交
1091
    DO_TEST("memory-hotplug-nvdimm", NONE);
1092
    DO_TEST("memory-hotplug-nvdimm-access", NONE);
1093
    DO_TEST("memory-hotplug-nvdimm-label", NONE);
1094
    DO_TEST("net-udp", NONE);
1095

1096 1097 1098 1099 1100
    DO_TEST("video-virtio-gpu-device", NONE);
    DO_TEST("video-virtio-gpu-virgl", NONE);
    DO_TEST("video-virtio-gpu-spice-gl", NONE);
    DO_TEST("virtio-input", NONE);
    DO_TEST("virtio-input-passthrough", NONE);
M
Marc-André Lureau 已提交
1101

1102 1103
    DO_TEST("memorybacking-set", NONE);
    DO_TEST("memorybacking-unset", NONE);
1104
    DO_TEST("virtio-options", QEMU_CAPS_VIRTIO_SCSI);
1105

1106
    virObjectUnref(cfg);
J
Ján Tomko 已提交
1107

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

1110 1111 1112 1113 1114
    DO_TEST("video-device-pciaddr-default",
            QEMU_CAPS_KVM,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
            QEMU_CAPS_DEVICE_QXL);
1115 1116
    DO_TEST("video-qxl-heads", NONE);
    DO_TEST("video-qxl-noheads", NONE);
1117
    DO_TEST("video-virtio-gpu-secondary", NONE);
1118 1119 1120 1121 1122 1123 1124
    DO_TEST("video-virtio-gpu-ccw",
            QEMU_CAPS_VIRTIO_CCW,
            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);
1125 1126 1127 1128 1129 1130 1131
    DO_TEST("video-virtio-gpu-ccw-auto",
            QEMU_CAPS_VIRTIO_CCW,
            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);
1132

1133
    DO_TEST("intel-iommu",
1134 1135 1136
            QEMU_CAPS_DEVICE_INTEL_IOMMU);
    DO_TEST("intel-iommu-machine",
            QEMU_CAPS_MACHINE_IOMMU);
1137 1138 1139 1140
    DO_TEST("intel-iommu-caching-mode",
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420);
1141
    DO_TEST("intel-iommu-eim", NONE);
J
Ján Tomko 已提交
1142
    DO_TEST("intel-iommu-device-iotlb", NONE);
J
Ján Tomko 已提交
1143

1144 1145 1146 1147 1148 1149 1150
    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 已提交
1151
    DO_TEST("vmcoreinfo", NONE);
1152

1153 1154 1155 1156 1157 1158
    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);

1159 1160 1161 1162 1163 1164
    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);
1165

1166
    DO_TEST("user-aliases", NONE);
1167 1168 1169 1170 1171 1172 1173 1174
    DO_TEST("input-virtio-ccw",
            QEMU_CAPS_VIRTIO_CCW,
            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);
1175

1176 1177 1178 1179 1180 1181
    /* 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;

1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198
# 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");
1199
    DO_TEST_STATUS("modern");
1200
    DO_TEST_STATUS("migration-out-nbd");
1201 1202
    DO_TEST_STATUS("migration-in-params");
    DO_TEST_STATUS("migration-out-params");
1203

A
Andrea Bolognani 已提交
1204 1205 1206
    if (getenv("LIBVIRT_SKIP_CLEANUP") == NULL)
        virFileDeleteTree(fakerootdir);

1207
    qemuTestDriverFree(&driver);
A
Andrea Bolognani 已提交
1208
    VIR_FREE(fakerootdir);
1209

1210
    return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1211 1212
}

A
Andrea Bolognani 已提交
1213 1214
VIR_TEST_MAIN_PRELOAD(mymain,
                      abs_builddir "/.libs/virpcimock.so")
1215

1216 1217
#else

1218 1219 1220 1221 1222
int
main(void)
{
    return EXIT_AM_SKIP;
}
1223 1224

#endif /* WITH_QEMU */