qemuxml2xmltest.c 43.0 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
static int
testCompareStatusXMLToXMLFiles(const void *opaque)
{
    const struct testInfo *data = opaque;
    virDomainObjPtr obj = NULL;
    char *actual = NULL;
    int ret = -1;

    if (!(obj = virDomainObjParseFile(data->inName, driver.caps, driver.xmlopt,
                                      VIR_DOMAIN_DEF_PARSE_STATUS |
                                      VIR_DOMAIN_DEF_PARSE_ACTUAL_NET |
                                      VIR_DOMAIN_DEF_PARSE_PCI_ORIG_STATES |
                                      VIR_DOMAIN_DEF_PARSE_SKIP_VALIDATE |
                                      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:
98
    virDomainObjEndAPI(&obj);
99 100 101 102 103
    VIR_FREE(actual);
    return ret;
}


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

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

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


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

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

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

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

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


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

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

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

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

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

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

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

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

184
    return 0;
185

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

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

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

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

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

    return 0;

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


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

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

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

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

    setenv("LIBVIRT_FAKE_ROOT_DIR", fakerootdir, 1);

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

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

241 242
    cfg = virQEMUDriverGetConfig(&driver);

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

265 266
# define NONE QEMU_CAPS_LAST

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


271 272 273 274 275

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

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

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

    DO_TEST("clock-utc", NONE);
    DO_TEST("clock-localtime", NONE);
    DO_TEST("cpu-empty", NONE);
    DO_TEST("cpu-kvmclock", NONE);
    DO_TEST("cpu-host-kvmclock", NONE);
    DO_TEST("cpu-host-passthrough-features", NONE);
    DO_TEST("cpu-host-model-features", NONE);
    DO_TEST("clock-catchup", NONE);
    DO_TEST("kvmclock", NONE);
    DO_TEST("clock-timer-hyperv-rtc", NONE);

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

    DO_TEST("hyperv", NONE);
    DO_TEST("hyperv-off", NONE);
    DO_TEST("hyperv-panic", NONE);

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

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

328
    DO_TEST("pages-discard", NONE);
329
    DO_TEST("pages-discard-hugepages", NONE);
330
    DO_TEST("pages-dimm-discard", NONE);
331
    DO_TEST("hugepages-default", NONE);
332
    DO_TEST("hugepages-default-2M", NONE);
333
    DO_TEST("hugepages-default-system-size", NONE);
334
    DO_TEST("hugepages-numa-default-2M", NONE);
335
    DO_TEST("hugepages-numa-default-dimm", NONE);
336
    DO_TEST("hugepages-numa-nodeset", NONE);
337
    DO_TEST("hugepages-numa-nodeset-part", NONE);
338
    DO_TEST("hugepages-shared", NONE);
339
    DO_TEST("hugepages-memaccess", NONE);
340
    DO_TEST("hugepages-memaccess2", NONE);
341 342 343 344 345 346 347 348 349 350
    DO_TEST("nosharepages", NONE);
    DO_TEST("restore-v2", NONE);
    DO_TEST("migrate", NONE);
    DO_TEST("qemu-ns-no-env", NONE);
    DO_TEST("disk-aio", NONE);
    DO_TEST("disk-cdrom", NONE);
    DO_TEST("disk-floppy", NONE);
    DO_TEST("disk-usb-device", NONE);
    DO_TEST("disk-virtio", NONE);
    DO_TEST("floppy-drive-fat", NONE);
351 352 353 354 355
    DO_TEST("disk-virtio-queues", QEMU_CAPS_VIRTIO_BLK_NUM_QUEUES);
    DO_TEST("disk-boot-disk", NONE);
    DO_TEST("disk-boot-cdrom", NONE);
    DO_TEST("disk-error-policy", NONE);
    DO_TEST("disk-fmt-qcow", NONE);
356
    DO_TEST("disk-cache", QEMU_CAPS_SCSI_LSI);
357
    DO_TEST("disk-network-nbd", NONE);
358
    DO_TEST("disk-network-iscsi", QEMU_CAPS_VIRTIO_SCSI);
359 360 361 362 363 364
    DO_TEST("disk-network-gluster", NONE);
    DO_TEST("disk-network-rbd", NONE);
    DO_TEST("disk-network-source-auth", NONE);
    DO_TEST("disk-network-sheepdog", NONE);
    DO_TEST("disk-network-vxhs", NONE);
    DO_TEST("disk-network-tlsx509", NONE);
365
    DO_TEST("disk-scsi-device",
366
            QEMU_CAPS_SCSI_LSI);
367
    DO_TEST("disk-scsi-vscsi", NONE);
368
    DO_TEST("disk-scsi-virtio-scsi",
369
            QEMU_CAPS_VIRTIO_SCSI);
370
    DO_TEST("disk-virtio-scsi-num_queues",
371
            QEMU_CAPS_VIRTIO_SCSI);
372
    DO_TEST("disk-virtio-scsi-reservations",
373
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_PR_MANAGER_HELPER);
374
    DO_TEST("disk-virtio-scsi-cmd_per_lun",
375
            QEMU_CAPS_VIRTIO_SCSI);
376
    DO_TEST("disk-virtio-scsi-max_sectors",
377
            QEMU_CAPS_VIRTIO_SCSI);
378
    DO_TEST("disk-virtio-scsi-ioeventfd",
379
            QEMU_CAPS_VIRTIO_SCSI);
380
    DO_TEST("disk-scsi-megasas",
381
            QEMU_CAPS_SCSI_MEGASAS);
382
    DO_TEST("disk-scsi-mptsas1068",
383
            QEMU_CAPS_SCSI_MPTSAS1068,
384
            QEMU_CAPS_SCSI_DISK_WWN);
385
    DO_TEST("disk-mirror-old", NONE);
386
    DO_TEST("disk-mirror", NONE);
387
    DO_TEST_FULL("disk-active-commit", WHEN_ACTIVE, GIC_NONE, NONE);
388 389 390 391 392 393 394
    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);
395
    cfg->vncAutoUnixSocket = true;
396
    DO_TEST("graphics-vnc-auto-socket-cfg", NONE);
397
    cfg->vncAutoUnixSocket = false;
398 399
    DO_TEST("graphics-vnc-socket", NONE);
    DO_TEST("graphics-vnc-auto-socket", NONE);
400
    DO_TEST("graphics-vnc-egl-headless", NONE);
401 402 403 404 405 406 407 408

    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);
409
    cfg->spiceAutoUnixSocket = true;
410
    DO_TEST("graphics-spice-auto-socket-cfg", NONE);
411
    cfg->spiceAutoUnixSocket = false;
412
    DO_TEST("graphics-spice-egl-headless", NONE);
413

414 415 416 417 418 419 420 421 422 423
    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 已提交
424
    DO_TEST("net-user-addr", NONE);
425 426 427 428 429 430 431
    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);
432
    DO_TEST("net-virtio-rxtxqueuesize", NONE);
433 434 435 436 437 438 439 440 441
    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);
442
    DO_TEST("net-mtu", NONE);
443
    DO_TEST("net-coalesce", NONE);
444

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

456 457
    DO_TEST_FULL("channel-unix-source-path", WHEN_INACTIVE, GIC_NONE, NONE);

458 459 460
    DO_TEST("hostdev-usb-address", NONE);
    DO_TEST("hostdev-pci-address", NONE);
    DO_TEST("hostdev-vfio", NONE);
461
    DO_TEST("hostdev-mdev-precreated", NONE);
462
    DO_TEST("hostdev-mdev-display", QEMU_CAPS_VFIO_PCI_DISPLAY);
463
    DO_TEST("pci-rom", NONE);
464
    DO_TEST("pci-rom-disabled", NONE);
465
    DO_TEST("pci-rom-disabled-invalid", NONE);
466 467
    DO_TEST("pci-serial-dev-chardev", NONE);

468 469
    DO_TEST("encrypted-disk", QEMU_CAPS_QCOW2_LUKS);
    DO_TEST("encrypted-disk-usage", QEMU_CAPS_QCOW2_LUKS);
470
    DO_TEST("luks-disks", NONE);
471
    DO_TEST("luks-disks-source", NONE);
472 473 474 475 476 477 478 479 480
    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);
481
    DO_TEST("vcpu-placement-static",
482 483
            QEMU_CAPS_KVM,
            QEMU_CAPS_OBJECT_IOTHREAD);
484

485 486 487 488 489 490
    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);
491
    DO_TEST("iothreads-disk-virtio-ccw",
492
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
493
    DO_TEST("iothreads-virtio-scsi-pci",
494
            QEMU_CAPS_VIRTIO_SCSI);
495
    DO_TEST("iothreads-virtio-scsi-ccw",
496
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_CCW,
497
            QEMU_CAPS_VIRTIO_S390);
498 499 500 501 502 503 504
    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);

505 506 507 508 509
    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",
510
            QEMU_CAPS_DEVICE_IOH3420,
511 512
            QEMU_CAPS_PCI_OHCI,
            QEMU_CAPS_PIIX3_USB_UHCI,
513 514
            QEMU_CAPS_NEC_USB_XHCI);
    DO_TEST("usb-controller-explicit-q35",
515
            QEMU_CAPS_DEVICE_IOH3420,
516 517
            QEMU_CAPS_PCI_OHCI,
            QEMU_CAPS_PIIX3_USB_UHCI,
518 519
            QEMU_CAPS_NEC_USB_XHCI);
    DO_TEST("ppc64-usb-controller",
520
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
521 522
            QEMU_CAPS_PCI_OHCI);
    DO_TEST("ppc64-usb-controller-legacy",
523
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
524
            QEMU_CAPS_PIIX3_USB_UHCI);
525 526 527 528 529
    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);
530
    DO_TEST("blkdeviotune-max", NONE);
531
    DO_TEST("blkdeviotune-group-num", NONE);
532
    DO_TEST("blkdeviotune-max-length", NONE);
533
    DO_TEST("controller-usb-order", NONE);
534

535 536 537 538
    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);
539
    DO_TEST("seclabel-static", NONE);
540
    DO_TEST_FULL("seclabel-static-labelskip", WHEN_ACTIVE, GIC_NONE, NONE);
541 542 543 544
    DO_TEST("seclabel-none", NONE);
    DO_TEST("seclabel-dac-none", NONE);
    DO_TEST("seclabel-dynamic-none", NONE);
    DO_TEST("seclabel-device-multiple", NONE);
545
    DO_TEST_FULL("seclabel-dynamic-none-relabel", WHEN_INACTIVE, GIC_NONE, NONE);
546
    DO_TEST("numad-static-vcpu-no-numatune", NONE);
547

548
    DO_TEST("disk-scsi-lun-passthrough-sgio",
549
            QEMU_CAPS_SCSI_CD, QEMU_CAPS_SCSI_LSI,
550 551
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_DISK_WWN);
    DO_TEST("disk-scsi-disk-vpd",
552
            QEMU_CAPS_SCSI_CD, QEMU_CAPS_SCSI_LSI,
553
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_DISK_WWN);
554 555
    DO_TEST("disk-source-pool", NONE);
    DO_TEST("disk-source-pool-mode", NONE);
556

557 558
    DO_TEST("disk-discard", NONE);
    DO_TEST("disk-detect-zeroes", NONE);
O
Osier Yang 已提交
559

560 561
    DO_TEST("disk-serial", NONE);

562 563
    DO_TEST("virtio-rng-random", NONE);
    DO_TEST("virtio-rng-egd", NONE);
564

565 566 567 568 569 570
    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);
571

572 573 574 575
    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);
576 577 578 579
    DO_TEST("pseries-phb-numa-node",
            QEMU_CAPS_NUMA,
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
            QEMU_CAPS_SPAPR_PCI_HOST_BRIDGE_NUMA_NODE);
580

581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602
    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);

603
    DO_TEST("pseries-features",
604
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
605
            QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
606
            QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
607 608
            QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT);

609
    DO_TEST("pseries-serial-native",
610
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
611 612
            QEMU_CAPS_DEVICE_SPAPR_VTY);
    DO_TEST("pseries-serial+console-native",
613
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
614 615
            QEMU_CAPS_DEVICE_SPAPR_VTY);
    DO_TEST("pseries-serial-compat",
616
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
617
            QEMU_CAPS_DEVICE_SPAPR_VTY);
618
    DO_TEST("pseries-serial-pci",
619
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
620 621
            QEMU_CAPS_DEVICE_PCI_SERIAL);
    DO_TEST("pseries-serial-usb",
622
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
623 624
            QEMU_CAPS_DEVICE_QEMU_XHCI,
            QEMU_CAPS_DEVICE_USB_SERIAL);
625
    DO_TEST("pseries-console-native",
626
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
627 628
            QEMU_CAPS_DEVICE_SPAPR_VTY);
    DO_TEST("pseries-console-virtio",
629 630 631 632 633
            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);
634 635 636 637 638 639 640 641 642 643 644
    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);
645 646
    DO_TEST("mach-virt-console-native", NONE);
    DO_TEST("mach-virt-console-virtio", NONE);
647

648 649 650 651
    DO_TEST("balloon-device-auto", NONE);
    DO_TEST("balloon-device-period", NONE);
    DO_TEST("channel-virtio-auto", NONE);
    DO_TEST("console-compat-auto", NONE);
652
    DO_TEST("disk-scsi-device-auto",
653
            QEMU_CAPS_SCSI_LSI);
654 655 656 657 658 659 660 661 662 663
    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);
664
    DO_TEST("tpm-passthrough-crb", NONE);
665
    DO_TEST("tpm-emulator", NONE);
666 667 668

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

670
    DO_TEST("pci-bridge",
671 672 673 674 675
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_VNC,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
    DO_TEST("pci-many",
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
676 677 678
    DO_TEST("pci-bridge-many-disks",
            QEMU_CAPS_DEVICE_PCI_BRIDGE);
    DO_TEST("pci-autoadd-addr",
679 680
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
681
    DO_TEST("pci-autoadd-idx",
682 683
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_CIRRUS_VGA);
684
    DO_TEST("pci-autofill-addr", NONE);
685

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

    /* Test automatic and manual setting of pcie-root-port attributes */
849
    DO_TEST("pcie-root-port",
850 851
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
852
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
853
            QEMU_CAPS_DEVICE_QXL);
854 855 856 857 858 859

    /* 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,
860
            QEMU_CAPS_DEVICE_IOH3420);
861
    DO_TEST("pcie-root-port-model-ioh3420",
862
            QEMU_CAPS_DEVICE_IOH3420);
863

864
    DO_TEST("pcie-switch-upstream-port",
865 866 867
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_ICH9_AHCI,
868
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
869
            QEMU_CAPS_DEVICE_QXL);
870
    DO_TEST("pcie-switch-downstream-port",
871 872 873 874
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
            QEMU_CAPS_ICH9_AHCI,
875
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
876
            QEMU_CAPS_DEVICE_QXL);
877
    DO_TEST("pci-expander-bus",
878
            QEMU_CAPS_DEVICE_PXB);
879
    DO_TEST("pcie-expander-bus",
880 881 882 883
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_DEVICE_X3130_UPSTREAM,
            QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
            QEMU_CAPS_DEVICE_PXB_PCIE);
884
    DO_TEST("autoindex",
885 886 887 888 889 890 891
            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,
892
            QEMU_CAPS_NEC_USB_XHCI);
893 894 895 896 897 898 899
    /* 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);
900

901 902
    DO_TEST("hostdev-scsi-vhost-scsi-ccw",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
903
            QEMU_CAPS_DEVICE_SCSI_GENERIC, QEMU_CAPS_CCW);
904 905 906
    DO_TEST("hostdev-scsi-vhost-scsi-pci",
            QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
            QEMU_CAPS_DEVICE_SCSI_GENERIC);
907 908 909 910 911 912
    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);
913 914 915 916 917 918 919 920 921 922 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
    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);

953 954 955 956 957
    DO_TEST("hostdev-subsys-mdev-vfio-ccw",
            QEMU_CAPS_CCW,
            QEMU_CAPS_CCW_CSSID_UNRESTRICTED,
            QEMU_CAPS_DEVICE_VFIO_CCW);

958
    DO_TEST("s390-defaultconsole",
959
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
960
    DO_TEST("s390-panic",
961
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
962
    DO_TEST("s390-panic-missing",
963
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
964
    DO_TEST("s390-panic-no-address",
965
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
966
    DO_TEST("s390-serial",
967
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
968
    DO_TEST("s390-serial-2",
969
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
970
    DO_TEST("s390-serial-console",
971
            QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
972

973 974 975
    DO_TEST("pcihole64", NONE);
    DO_TEST("pcihole64-gib", NONE);
    DO_TEST("pcihole64-none", NONE);
976
    DO_TEST("pcihole64-q35",
977
            QEMU_CAPS_DEVICE_IOH3420,
978 979
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
980
            QEMU_CAPS_DEVICE_QXL,
981
            QEMU_CAPS_Q35_PCI_HOLE64_SIZE);
982

983 984
    DO_TEST("panic", NONE);
    DO_TEST("panic-isa", NONE);
985 986
    DO_TEST("panic-pseries",
            QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
987 988
    DO_TEST("panic-double", NONE);
    DO_TEST("panic-no-address", NONE);
H
Hu Tao 已提交
989

990
    DO_TEST("disk-backing-chains", NONE);
991

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

994 995 996 997 998 999
    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);
1000

1001 1002 1003
    DO_TEST("numatune-auto-prefer", NONE);
    DO_TEST("numatune-memnode", NONE);
    DO_TEST("numatune-memnode-no-memory", NONE);
1004

1005 1006
    DO_TEST("bios-nvram", NONE);
    DO_TEST("bios-nvram-os-interleave", NONE);
1007

1008 1009 1010
    DO_TEST("tap-vhost", NONE);
    DO_TEST("tap-vhost-incorrect", NONE);
    DO_TEST("shmem", NONE);
1011
    DO_TEST("shmem-plain-doorbell", NONE);
1012 1013
    DO_TEST("smbios", NONE);
    DO_TEST("smbios-multiple-type2", NONE);
1014

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

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

1083 1084 1085
    DO_TEST("memory-hotplug", NONE);
    DO_TEST("memory-hotplug-nonuma", NONE);
    DO_TEST("memory-hotplug-dimm", NONE);
M
Michal Privoznik 已提交
1086
    DO_TEST("memory-hotplug-nvdimm", NONE);
1087
    DO_TEST("memory-hotplug-nvdimm-access", NONE);
1088
    DO_TEST("memory-hotplug-nvdimm-label", NONE);
1089
    DO_TEST("net-udp", NONE);
1090

1091 1092 1093
    DO_TEST("video-virtio-gpu-device", NONE);
    DO_TEST("video-virtio-gpu-virgl", NONE);
    DO_TEST("video-virtio-gpu-spice-gl", NONE);
1094
    DO_TEST("video-virtio-gpu-sdl-gl", NONE);
1095 1096
    DO_TEST("virtio-input", NONE);
    DO_TEST("virtio-input-passthrough", NONE);
M
Marc-André Lureau 已提交
1097

1098 1099
    DO_TEST("memorybacking-set", NONE);
    DO_TEST("memorybacking-unset", NONE);
1100
    DO_TEST("virtio-options", QEMU_CAPS_VIRTIO_SCSI);
1101

1102
    virObjectUnref(cfg);
J
Ján Tomko 已提交
1103

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

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

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

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

1150 1151
    DO_TEST("smartcard-host", NONE);
    DO_TEST("smartcard-host-certificates", NONE);
1152
    DO_TEST("smartcard-host-certificates-database", NONE);
1153 1154 1155 1156
    DO_TEST("smartcard-passthrough-tcp", NONE);
    DO_TEST("smartcard-passthrough-spicevmc", NONE);
    DO_TEST("smartcard-controller", NONE);

1157 1158 1159 1160 1161 1162
    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);
1163

1164
    DO_TEST("user-aliases", QEMU_CAPS_QCOW2_LUKS);
1165
    DO_TEST("input-virtio-ccw",
1166
            QEMU_CAPS_CCW,
1167 1168 1169 1170 1171 1172
            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);
1173

1174 1175 1176 1177 1178 1179 1180 1181 1182
    DO_TEST("tseg-explicit-size",
            QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_PCI_BRIDGE,
            QEMU_CAPS_DEVICE_IOH3420,
            QEMU_CAPS_ICH9_AHCI,
            QEMU_CAPS_MACHINE_SMM_OPT,
            QEMU_CAPS_VIRTIO_SCSI,
            QEMU_CAPS_MCH_EXTENDED_TSEG_MBYTES);

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

1207 1208
    DO_TEST("vhost-vsock", QEMU_CAPS_DEVICE_VHOST_VSOCK);
    DO_TEST("vhost-vsock-auto", QEMU_CAPS_DEVICE_VHOST_VSOCK);
1209 1210 1211 1212 1213
    DO_TEST("vhost-vsock-ccw", QEMU_CAPS_DEVICE_VHOST_VSOCK,
            QEMU_CAPS_CCW);
    DO_TEST("vhost-vsock-ccw-auto", QEMU_CAPS_DEVICE_VHOST_VSOCK,
            QEMU_CAPS_CCW);

J
Ján Tomko 已提交
1214

A
Andrea Bolognani 已提交
1215 1216 1217
    if (getenv("LIBVIRT_SKIP_CLEANUP") == NULL)
        virFileDeleteTree(fakerootdir);

1218
    qemuTestDriverFree(&driver);
A
Andrea Bolognani 已提交
1219
    VIR_FREE(fakerootdir);
1220

1221
    return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
1222 1223
}

A
Andrea Bolognani 已提交
1224
VIR_TEST_MAIN_PRELOAD(mymain,
1225 1226
                      abs_builddir "/.libs/virpcimock.so",
                      abs_builddir "/.libs/virrandommock.so")
1227

1228 1229
#else

1230 1231 1232 1233 1234
int
main(void)
{
    return EXIT_AM_SKIP;
}
1235 1236

#endif /* WITH_QEMU */