qemuxml2argvtest.c 29.5 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
#ifdef WITH_QEMU

13 14
# include "internal.h"
# include "testutils.h"
15
# include "util/memory.h"
16 17
# include "qemu/qemu_capabilities.h"
# include "qemu/qemu_command.h"
M
Matthias Bolte 已提交
18
# include "qemu/qemu_domain.h"
19
# include "datatypes.h"
20
# include "cpu/cpu_map.h"
21

22
# include "testutilsqemu.h"
23

24
static const char *abs_top_srcdir;
25
static struct qemud_driver driver;
26

27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
static unsigned char *
fakeSecretGetValue(virSecretPtr obj ATTRIBUTE_UNUSED,
                   size_t *value_size,
                   unsigned int fakeflags ATTRIBUTE_UNUSED,
                   unsigned int internalFlags ATTRIBUTE_UNUSED)
{
    char *secret = strdup("AQCVn5hO6HzFAhAAq0NCv8jtJcIcE+HOBlMQ1A");
    *value_size = strlen(secret);
    return (unsigned char *) secret;
}

static virSecretPtr
fakeSecretLookupByUsage(virConnectPtr conn,
                        int usageType ATTRIBUTE_UNUSED,
                        const char *usageID)
{
    virSecretPtr ret = NULL;
    int err;
    if (STRNEQ(usageID, "mycluster_myname"))
        return NULL;
    err = VIR_ALLOC(ret);
    if (err < 0)
        return NULL;
    ret->magic = VIR_SECRET_MAGIC;
    ret->refs = 1;
    ret->usageID = strdup(usageID);
    if (!ret->usageID)
        return NULL;
    ret->conn = conn;
    conn->refs++;
    return ret;
}

static int
fakeSecretClose(virConnectPtr conn ATTRIBUTE_UNUSED)
{
    return 0;
}

static virSecretDriver fakeSecretDriver = {
    .name = "fake_secret",
    .open = NULL,
    .close = fakeSecretClose,
    .numOfSecrets = NULL,
    .listSecrets = NULL,
    .lookupByUUID = NULL,
    .lookupByUsage = fakeSecretLookupByUsage,
    .defineXML = NULL,
    .getXMLDesc = NULL,
    .setValue = NULL,
    .getValue = fakeSecretGetValue,
    .undefine = NULL,
};

81
static int testCompareXMLToArgvFiles(const char *xml,
E
Eric Blake 已提交
82
                                     const char *cmdline,
83
                                     virBitmapPtr extraFlags,
J
Jiri Denemark 已提交
84
                                     const char *migrateFrom,
85
                                     int migrateFd,
86
                                     bool json,
87 88
                                     bool expectError,
                                     bool expectFailure)
89 90
{
    char *expectargv = NULL;
E
Eric Blake 已提交
91
    int len;
92
    char *actualargv = NULL;
E
Eric Blake 已提交
93
    int ret = -1;
94
    virDomainDefPtr vmdef = NULL;
95
    virDomainChrSourceDef monitor_chr;
96
    virConnectPtr conn;
J
Jiri Denemark 已提交
97
    char *log = NULL;
98
    char *emulator = NULL;
E
Eric Blake 已提交
99
    virCommandPtr cmd = NULL;
100 101

    if (!(conn = virGetConnect()))
102
        goto out;
103
    conn->secretDriver = &fakeSecretDriver;
104

105
    if (!(vmdef = virDomainDefParseFile(driver.caps, xml,
M
Matthias Bolte 已提交
106
                                        QEMU_EXPECTED_VIRT_TYPES,
107
                                        VIR_DOMAIN_XML_INACTIVE)))
108
        goto out;
109

110 111 112 113 114 115 116 117 118 119 120 121
    /*
     * For test purposes, we may want to fake emulator's output by providing
     * our own script instead of a real emulator. For this to work we need to
     * specify a relative path in <emulator/> element, which, however, is not
     * allowed by RelaxNG schema for domain XML. To work around it we add an
     * extra '/' at the beginning of relative emulator path so that it looks
     * like, e.g., "/./qemu.sh" or "/../emulator/qemu.sh" instead of
     * "./qemu.sh" or "../emulator/qemu.sh" respectively. The following code
     * detects such paths, strips the extra '/' and makes the path absolute.
     */
    if (vmdef->emulator && STRPREFIX(vmdef->emulator, "/.")) {
        if (!(emulator = strdup(vmdef->emulator + 1)))
122
            goto out;
123
        VIR_FREE(vmdef->emulator);
124 125 126
        vmdef->emulator = NULL;
        if (virAsprintf(&vmdef->emulator, "%s/qemuxml2argvdata/%s",
                        abs_srcdir, emulator) < 0)
127
            goto out;
128 129
    }

130
    if (qemuCapsGet(extraFlags, QEMU_CAPS_DOMID))
131
        vmdef->id = 6;
132
    else
133
        vmdef->id = -1;
134

135
    memset(&monitor_chr, 0, sizeof(monitor_chr));
136 137 138
    monitor_chr.type = VIR_DOMAIN_CHR_TYPE_UNIX;
    monitor_chr.data.nix.path = (char *)"/tmp/test-monitor";
    monitor_chr.data.nix.listen = true;
139

140 141 142
    qemuCapsSetList(extraFlags,
                    QEMU_CAPS_VNC_COLON,
                    QEMU_CAPS_NO_REBOOT,
143
                    QEMU_CAPS_NO_ACPI,
144
                    QEMU_CAPS_LAST);
145

146
    if (qemudCanonicalizeMachine(&driver, vmdef) < 0)
147
        goto out;
148

149
    if (qemuCapsGet(extraFlags, QEMU_CAPS_DEVICE)) {
150
        qemuDomainPCIAddressSetPtr pciaddrs;
151 152 153 154

        if (qemuDomainAssignSpaprVIOAddresses(vmdef)) {
            if (expectError)
                goto ok;
155
            goto out;
156 157
        }

158
        if (!(pciaddrs = qemuDomainPCIAddressSetCreate(vmdef)))
159
            goto out;
160 161

        if (qemuAssignDevicePCISlots(vmdef, pciaddrs) < 0)
162
            goto out;
163 164 165 166

        qemuDomainPCIAddressSetFree(pciaddrs);
    }

167 168
    log = virtTestLogContentAndReset();
    VIR_FREE(log);
169
    virResetLastError();
J
Jiri Denemark 已提交
170

171
    /* We do not call qemuCapsExtractVersionInfo() before calling
172
     * qemuBuildCommandLine(), so we should set QEMU_CAPS_PCI_MULTIBUS for
173 174 175 176
     * x86_64 and i686 architectures here.
     */
    if (STREQLEN(vmdef->os.arch, "x86_64", 6) ||
        STREQLEN(vmdef->os.arch, "i686", 4)) {
177
        qemuCapsSet(extraFlags, QEMU_CAPS_PCI_MULTIBUS);
178 179
    }

180
    if (qemuAssignDeviceAliases(vmdef, extraFlags) < 0)
181
        goto out;
182

183
    if (!(cmd = qemuBuildCommandLine(conn, &driver,
184
                                     vmdef, &monitor_chr, json, extraFlags,
185
                                     migrateFrom, migrateFd, NULL,
186 187 188 189 190 191 192 193 194 195 196
                                     VIR_NETDEV_VPORT_PROFILE_OP_NO_OP))) {
        if (expectFailure) {
            ret = 0;
            virResetLastError();
        }
        goto out;
    } else if (expectFailure) {
        if (virTestGetDebug())
            fprintf(stderr, "qemuBuildCommandLine should have failed\n");
        goto out;
    }
197

198 199
    if (!!virGetLastError() != expectError) {
        if (virTestGetDebug() && (log = virtTestLogContentAndReset()))
J
Jiri Denemark 已提交
200
            fprintf(stderr, "\n%s", log);
201
        goto out;
J
Jiri Denemark 已提交
202 203
    }

E
Eric Blake 已提交
204
    if (!(actualargv = virCommandToString(cmd)))
205
        goto out;
E
Eric Blake 已提交
206 207 208 209 210 211

    if (emulator) {
        /* Skip the abs_srcdir portion of replacement emulator.  */
        char *start_skip = strstr(actualargv, abs_srcdir);
        char *end_skip = strstr(actualargv, emulator);
        if (!start_skip || !end_skip)
212
            goto out;
E
Eric Blake 已提交
213
        memmove(start_skip, end_skip, strlen(end_skip) + 1);
214 215
    }

216 217 218 219 220 221
    len = virtTestLoadFile(cmdline, &expectargv);
    if (len < 0)
        goto out;
    if (len && expectargv[len - 1] == '\n')
        expectargv[len - 1] = '\0';

222 223
    if (STRNEQ(expectargv, actualargv)) {
        virtTestDifference(stderr, expectargv, actualargv);
224
        goto out;
225 226
    }

227 228 229 230 231 232
 ok:
    if (expectError) {
        /* need to suppress the errors */
        virResetLastError();
    }

233 234
    ret = 0;

235
out:
236 237 238 239
    VIR_FREE(log);
    VIR_FREE(emulator);
    VIR_FREE(expectargv);
    VIR_FREE(actualargv);
E
Eric Blake 已提交
240
    virCommandFree(cmd);
241
    virDomainDefFree(vmdef);
242
    virUnrefConnect(conn);
243 244 245 246
    return ret;
}


247 248
struct testInfo {
    const char *name;
249
    virBitmapPtr extraFlags;
250
    const char *migrateFrom;
251
    int migrateFd;
J
Jiri Denemark 已提交
252
    bool expectError;
253
    bool expectFailure;
254 255
};

256 257 258 259
static int
testCompareXMLToArgvHelper(const void *data)
{
    int result = -1;
260
    const struct testInfo *info = data;
261 262 263 264 265 266 267 268 269 270
    char *xml = NULL;
    char *args = NULL;

    if (virAsprintf(&xml, "%s/qemuxml2argvdata/qemuxml2argv-%s.xml",
                    abs_srcdir, info->name) < 0 ||
        virAsprintf(&args, "%s/qemuxml2argvdata/qemuxml2argv-%s.args",
                    abs_srcdir, info->name) < 0)
        goto cleanup;

    result = testCompareXMLToArgvFiles(xml, args, info->extraFlags,
271
                                       info->migrateFrom, info->migrateFd,
E
Eric Blake 已提交
272 273
                                       qemuCapsGet(info->extraFlags,
                                                   QEMU_CAPS_MONITOR_JSON),
274 275
                                       info->expectError,
                                       info->expectFailure);
276 277

cleanup:
278 279
    VIR_FREE(xml);
    VIR_FREE(args);
280
    return result;
281 282 283 284
}



285
static int
E
Eric Blake 已提交
286
mymain(void)
287 288
{
    int ret = 0;
289
    char *map = NULL;
290

291 292 293 294
    abs_top_srcdir = getenv("abs_top_srcdir");
    if (!abs_top_srcdir)
        abs_top_srcdir = "..";

295 296
    if ((driver.caps = testQemuCapsInit()) == NULL)
        return EXIT_FAILURE;
297 298 299 300 301
    if ((driver.stateDir = strdup("/nowhere")) == NULL)
        return EXIT_FAILURE;
    if ((driver.hugetlbfs_mount = strdup("/dev/hugepages")) == NULL)
        return EXIT_FAILURE;
    if ((driver.hugepage_path = strdup("/dev/hugepages/libvirt/qemu")) == NULL)
302
        return EXIT_FAILURE;
303 304 305 306 307
    driver.spiceTLS = 1;
    if (!(driver.spiceTLSx509certdir = strdup("/etc/pki/libvirt-spice")))
        return EXIT_FAILURE;
    if (!(driver.spicePassword = strdup("123456")))
        return EXIT_FAILURE;
308 309
    if (virAsprintf(&map, "%s/src/cpu/cpu_map.xml", abs_top_srcdir) < 0 ||
        cpuMapOverride(map) < 0) {
310
        VIR_FREE(map);
311
        return EXIT_FAILURE;
312
    }
313

314 315
# define DO_TEST_FULL(name, migrateFrom, migrateFd,                     \
                      expectError, expectFailure, ...)                  \
316
    do {                                                                \
317
        struct testInfo info = {                                        \
318 319
            name, NULL, migrateFrom, migrateFd,                         \
            expectError, expectFailure                                  \
J
Jiri Denemark 已提交
320
        };                                                              \
321 322 323
        if (!(info.extraFlags = qemuCapsNew()))                         \
            return EXIT_FAILURE;                                        \
        qemuCapsSetList(info.extraFlags, __VA_ARGS__, QEMU_CAPS_LAST);  \
324 325 326
        if (virtTestRun("QEMU XML-2-ARGV " name,                        \
                        1, testCompareXMLToArgvHelper, &info) < 0)      \
            ret = -1;                                                   \
327
        qemuCapsFree(info.extraFlags);                                  \
328 329
    } while (0)

330
# define DO_TEST(name, expectError, ...)                                \
331 332 333 334
    DO_TEST_FULL(name, NULL, -1, expectError, false, __VA_ARGS__)

# define DO_TEST_FAILURE(name, ...)                                     \
    DO_TEST_FULL(name, NULL, -1, false, true, __VA_ARGS__)
335 336

# define NONE QEMU_CAPS_LAST
337

338 339 340
    /* 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 */
341 342 343 344 345 346 347
    setenv("PATH", "/bin", 1);
    setenv("USER", "test", 1);
    setenv("LOGNAME", "test", 1);
    setenv("HOME", "/home/test", 1);
    unsetenv("TMPDIR");
    unsetenv("LD_PRELOAD");
    unsetenv("LD_LIBRARY_PATH");
348 349
    unsetenv("QEMU_AUDIO_DRV");
    unsetenv("SDL_AUDIODRIVER");
350

351 352 353 354 355 356 357
    DO_TEST("minimal", false, QEMU_CAPS_NAME);
    DO_TEST("machine-aliases1", false, NONE);
    DO_TEST("machine-aliases2", true, NONE);
    DO_TEST("boot-cdrom", false, NONE);
    DO_TEST("boot-network", false, NONE);
    DO_TEST("boot-floppy", false, NONE);
    DO_TEST("boot-multi", false, QEMU_CAPS_BOOT_MENU);
358 359 360 361 362
    DO_TEST("boot-menu-enable", false,
            QEMU_CAPS_BOOT_MENU, QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE);
    DO_TEST("boot-menu-enable", false,
            QEMU_CAPS_BOOT_MENU, QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE,
            QEMU_CAPS_BOOTINDEX);
363
    DO_TEST("boot-menu-disable", false, QEMU_CAPS_BOOT_MENU);
364 365 366 367 368
    DO_TEST("boot-menu-disable-drive", false,
            QEMU_CAPS_BOOT_MENU, QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE);
    DO_TEST("boot-menu-disable-drive-bootindex", false,
            QEMU_CAPS_BOOT_MENU, QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE,
            QEMU_CAPS_BOOTINDEX);
369
    DO_TEST("boot-order", false,
370 371
            QEMU_CAPS_BOOTINDEX, QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE,
            QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
372
    DO_TEST("boot-complex", false,
373 374
            QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT,
            QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
375 376
    DO_TEST("boot-complex-bootindex", false,
            QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT,
377 378
            QEMU_CAPS_BOOTINDEX,
            QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
379
    DO_TEST("bootloader", true, QEMU_CAPS_DOMID);
M
Michal Privoznik 已提交
380
    DO_TEST("bios", false, QEMU_CAPS_DEVICE, QEMU_CAPS_SGA);
381 382
    DO_TEST("clock-utc", false, NONE);
    DO_TEST("clock-localtime", false, NONE);
383 384
    /*
     * Can't be enabled since the absolute timestamp changes every time
385
    DO_TEST("clock-variable", false, QEMU_CAPS_RTC);
386
    */
387
    DO_TEST("clock-france", false, QEMU_CAPS_RTC);
388 389 390
    DO_TEST("cpu-kvmclock", false, QEMU_CAPS_ENABLE_KVM);
    DO_TEST("cpu-host-kvmclock", false, QEMU_CAPS_ENABLE_KVM, QEMU_CAPS_CPU_HOST);
    DO_TEST("kvmclock", false, QEMU_CAPS_KVM);
391 392 393 394 395 396 397

    DO_TEST("hugepages", false, QEMU_CAPS_MEM_PATH);
    DO_TEST("disk-cdrom", false, NONE);
    DO_TEST("disk-cdrom-empty", false, QEMU_CAPS_DRIVE);
    DO_TEST("disk-floppy", false, NONE);
    DO_TEST("disk-many", false, NONE);
    DO_TEST("disk-virtio", false, QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT);
398
    DO_TEST("disk-order", false,
399 400
            QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_DRIVE_BOOT,
            QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426
    DO_TEST("disk-xenvbd", false, QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT);
    DO_TEST("disk-drive-boot-disk", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT);
    DO_TEST("disk-drive-boot-cdrom", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT);
    DO_TEST("floppy-drive-fat", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT, QEMU_CAPS_DRIVE_FORMAT);
    DO_TEST("disk-drive-fat", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT, QEMU_CAPS_DRIVE_FORMAT);
    DO_TEST("disk-drive-readonly-disk", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_READONLY,
            QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("disk-drive-readonly-no-device", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_READONLY, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("disk-drive-fmt-qcow", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_BOOT, QEMU_CAPS_DRIVE_FORMAT);
    DO_TEST("disk-drive-shared", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT, QEMU_CAPS_DRIVE_SERIAL);
    DO_TEST("disk-drive-cache-v1-wt", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
    DO_TEST("disk-drive-cache-v1-wb", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
    DO_TEST("disk-drive-cache-v1-none", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
    DO_TEST("disk-drive-error-policy-stop", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_MONITOR_JSON, QEMU_CAPS_DRIVE_FORMAT);
427 428
    DO_TEST("disk-drive-error-policy-enospace", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_MONITOR_JSON, QEMU_CAPS_DRIVE_FORMAT);
429 430
    DO_TEST("disk-drive-error-policy-wreport-rignore", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_MONITOR_JSON, QEMU_CAPS_DRIVE_FORMAT);
431 432 433 434 435 436
    DO_TEST("disk-drive-cache-v2-wt", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_CACHE_V2, QEMU_CAPS_DRIVE_FORMAT);
    DO_TEST("disk-drive-cache-v2-wb", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_CACHE_V2, QEMU_CAPS_DRIVE_FORMAT);
    DO_TEST("disk-drive-cache-v2-none", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_CACHE_V2, QEMU_CAPS_DRIVE_FORMAT);
437 438 439
    DO_TEST("disk-drive-cache-directsync", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_CACHE_V2,
            QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC, QEMU_CAPS_DRIVE_FORMAT);
440 441 442
    DO_TEST("disk-drive-cache-unsafe", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_CACHE_V2,
            QEMU_CAPS_DRIVE_CACHE_UNSAFE, QEMU_CAPS_DRIVE_FORMAT);
443 444 445 446 447 448
    DO_TEST("disk-drive-network-nbd", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
    DO_TEST("disk-drive-network-rbd", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
    DO_TEST("disk-drive-network-sheepdog", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
449 450
    DO_TEST("disk-drive-network-rbd-auth", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_FORMAT);
451 452
    DO_TEST("disk-drive-no-boot", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_BOOTINDEX);
453 454 455 456 457 458 459
    DO_TEST("disk-usb", false, NONE);
    DO_TEST("disk-usb-device", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("disk-scsi-device", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("disk-scsi-device-auto", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
J
Jim Fehlig 已提交
460 461 462
    DO_TEST("disk-sata-device", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE,
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_ICH9_AHCI);
463 464 465
    DO_TEST("disk-aio", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_AIO,
            QEMU_CAPS_DRIVE_CACHE_V2, QEMU_CAPS_DRIVE_FORMAT);
466 467
    DO_TEST("disk-ioeventfd", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_VIRTIO_IOEVENTFD,
468
            QEMU_CAPS_VIRTIO_TX_ALG, QEMU_CAPS_DEVICE,
O
Osier Yang 已提交
469 470 471 472
            QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
    DO_TEST("disk-copy_on_read", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_COPY_ON_READ,
            QEMU_CAPS_VIRTIO_TX_ALG, QEMU_CAPS_DEVICE,
473
            QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
474 475
    DO_TEST("disk-snapshot", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_CACHE_V2, QEMU_CAPS_DRIVE_FORMAT);
476 477 478 479
    DO_TEST("event_idx", false,
            QEMU_CAPS_DRIVE,
            QEMU_CAPS_VIRTIO_BLK_EVENT_IDX,
            QEMU_CAPS_VIRTIO_NET_EVENT_IDX,
480 481 482 483 484 485
            QEMU_CAPS_DEVICE,
            QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
    DO_TEST("virtio-lun", false,
            QEMU_CAPS_DRIVE,
            QEMU_CAPS_DEVICE,
            QEMU_CAPS_VIRTIO_BLK_SCSI, QEMU_CAPS_VIRTIO_BLK_SG_IO);
486

487 488
    DO_TEST("graphics-vnc", false, NONE);
    DO_TEST("graphics-vnc-socket", false, NONE);
489 490 491

    driver.vncSASL = 1;
    driver.vncSASLdir = strdup("/root/.sasl2");
492
    DO_TEST("graphics-vnc-sasl", false, QEMU_CAPS_VGA);
493 494 495
    driver.vncTLS = 1;
    driver.vncTLSx509verify = 1;
    driver.vncTLSx509certdir = strdup("/etc/pki/tls/qemu");
496
    DO_TEST("graphics-vnc-tls", false, NONE);
497
    driver.vncSASL = driver.vncTLSx509verify = driver.vncTLS = 0;
498 499
    VIR_FREE(driver.vncSASLdir);
    VIR_FREE(driver.vncTLSx509certdir);
500 501
    driver.vncSASLdir = driver.vncTLSx509certdir = NULL;

502 503 504 505 506 507 508 509
    DO_TEST("graphics-sdl", false, NONE);
    DO_TEST("graphics-sdl-fullscreen", false, NONE);
    DO_TEST("nographics", false, QEMU_CAPS_VGA);
    DO_TEST("nographics-vga", false,
            QEMU_CAPS_VGA, QEMU_CAPS_VGA_NONE);
    DO_TEST("graphics-spice", false,
            QEMU_CAPS_VGA, QEMU_CAPS_VGA_QXL,
            QEMU_CAPS_DEVICE, QEMU_CAPS_SPICE);
510 511 512
    DO_TEST("graphics-spice-compression", false,
            QEMU_CAPS_VGA, QEMU_CAPS_VGA_QXL,
            QEMU_CAPS_DEVICE, QEMU_CAPS_SPICE);
513 514 515 516 517
    DO_TEST("graphics-spice-timeout", false,
            QEMU_CAPS_DRIVE,
            QEMU_CAPS_VGA, QEMU_CAPS_VGA_QXL,
            QEMU_CAPS_DEVICE, QEMU_CAPS_SPICE,
            QEMU_CAPS_DEVICE_QXL_VGA);
518 519 520 521
    DO_TEST("graphics-spice-qxl-vga", false,
            QEMU_CAPS_VGA, QEMU_CAPS_VGA_QXL,
            QEMU_CAPS_DEVICE, QEMU_CAPS_SPICE,
            QEMU_CAPS_DEVICE_QXL_VGA);
522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537

    DO_TEST("input-usbmouse", false, NONE);
    DO_TEST("input-usbtablet", false, NONE);
    DO_TEST("input-xen", true, QEMU_CAPS_DOMID);
    DO_TEST("misc-acpi", false, NONE);
    DO_TEST("misc-no-reboot", false, NONE);
    DO_TEST("misc-uuid", false, QEMU_CAPS_NAME, QEMU_CAPS_UUID);
    DO_TEST("net-user", false, NONE);
    DO_TEST("net-virtio", false, NONE);
    DO_TEST("net-virtio-device", false,
            QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_VIRTIO_TX_ALG);
    DO_TEST("net-virtio-netdev", false,
            QEMU_CAPS_DEVICE, QEMU_CAPS_NETDEV, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("net-eth", false, NONE);
    DO_TEST("net-eth-ifname", false, NONE);
    DO_TEST("net-eth-names", false, QEMU_CAPS_NET_NAME);
538 539 540
    DO_TEST("net-client", false, NONE);
    DO_TEST("net-server", false, NONE);
    DO_TEST("net-mcast", false, NONE);
541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580

    DO_TEST("serial-vc", false, NONE);
    DO_TEST("serial-pty", false, NONE);
    DO_TEST("serial-dev", false, NONE);
    DO_TEST("serial-file", false, NONE);
    DO_TEST("serial-unix", false, NONE);
    DO_TEST("serial-tcp", false, NONE);
    DO_TEST("serial-udp", false, NONE);
    DO_TEST("serial-tcp-telnet", false, NONE);
    DO_TEST("serial-many", false, NONE);
    DO_TEST("parallel-tcp", false, NONE);
    DO_TEST("console-compat", false, NONE);
    DO_TEST("console-compat-auto", false, NONE);

    DO_TEST("serial-vc-chardev", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("serial-pty-chardev", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("serial-dev-chardev", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("serial-file-chardev", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("serial-unix-chardev", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("serial-tcp-chardev", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("serial-udp-chardev", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("serial-tcp-telnet-chardev", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("serial-many-chardev", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("parallel-tcp-chardev", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("console-compat-chardev", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);

    DO_TEST("channel-guestfwd", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("channel-virtio", false,
581
            QEMU_CAPS_DEVICE, QEMU_CAPS_CHARDEV, QEMU_CAPS_NODEFCONFIG);
582
    DO_TEST("channel-virtio-auto", false,
583
            QEMU_CAPS_DEVICE, QEMU_CAPS_CHARDEV, QEMU_CAPS_NODEFCONFIG);
584
    DO_TEST("console-virtio", false,
585 586 587
            QEMU_CAPS_DEVICE, QEMU_CAPS_CHARDEV, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("console-virtio-many", false,
            QEMU_CAPS_DEVICE, QEMU_CAPS_CHARDEV, QEMU_CAPS_NODEFCONFIG);
588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610
    DO_TEST("channel-spicevmc", false,
            QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_SPICE, QEMU_CAPS_CHARDEV_SPICEVMC);
    DO_TEST("channel-spicevmc-old", false,
            QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_SPICE, QEMU_CAPS_DEVICE_SPICEVMC);

    DO_TEST("smartcard-host", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE,
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_CCID_EMULATED);
    DO_TEST("smartcard-host-certificates", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE,
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_CCID_EMULATED);
    DO_TEST("smartcard-passthrough-tcp", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE,
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_CCID_PASSTHRU);
    DO_TEST("smartcard-passthrough-spicevmc", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_CCID_PASSTHRU, QEMU_CAPS_CHARDEV_SPICEVMC);
    DO_TEST("smartcard-controller", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE,
            QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_CCID_EMULATED);

611 612 613 614 615
    DO_TEST("usb-controller", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE,
            QEMU_CAPS_NODEFCONFIG);
    DO_TEST("usb-piix3-controller", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_PIIX3_USB_UHCI,
616
            QEMU_CAPS_PCI_MULTIFUNCTION, QEMU_CAPS_NODEFCONFIG);
617 618 619
    DO_TEST("usb-ich9-ehci-addr", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_PCI_MULTIFUNCTION, QEMU_CAPS_ICH9_USB_EHCI1);
620 621
    DO_TEST("input-usbmouse-addr", false,
            QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
622 623 624
    DO_TEST("usb-ich9-companion", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_PCI_MULTIFUNCTION, QEMU_CAPS_ICH9_USB_EHCI1);
M
Marc-André Lureau 已提交
625 626 627
    DO_TEST("usb-hub", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_USB_HUB,
            QEMU_CAPS_NODEFCONFIG);
628 629 630
    DO_TEST("usb-ports", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_USB_HUB,
            QEMU_CAPS_NODEFCONFIG);
631 632 633
    DO_TEST("usb-redir", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_PCI_MULTIFUNCTION, QEMU_CAPS_USB_HUB,
634 635
            QEMU_CAPS_ICH9_USB_EHCI1, QEMU_CAPS_USB_REDIR,
            QEMU_CAPS_SPICE, QEMU_CAPS_CHARDEV_SPICEVMC);
636 637 638 639
    DO_TEST("usb1-usb2", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_PCI_MULTIFUNCTION, QEMU_CAPS_PIIX3_USB_UHCI,
            QEMU_CAPS_USB_HUB, QEMU_CAPS_ICH9_USB_EHCI1);
640

641 642 643 644 645 646 647 648 649 650 651 652
    DO_TEST("smbios", false, QEMU_CAPS_SMBIOS_TYPE);

    DO_TEST("watchdog", false, NONE);
    DO_TEST("watchdog-device", false, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("watchdog-dump", false, NONE);
    DO_TEST("balloon-device", false, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("balloon-device-auto", false,
            QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("sound", false, NONE);
    DO_TEST("sound-device", false,
            QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_HDA_DUPLEX);
    DO_TEST("fs9p", false,
653 654
            QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG, QEMU_CAPS_FSDEV,
            QEMU_CAPS_FSDEV_WRITEOUT);
655 656 657 658 659 660 661

    DO_TEST("hostdev-usb-address", false, NONE);
    DO_TEST("hostdev-usb-address-device", false,
            QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("hostdev-pci-address", false, QEMU_CAPS_PCIDEVICE);
    DO_TEST("hostdev-pci-address-device", false,
            QEMU_CAPS_PCIDEVICE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
662 663 664
    DO_TEST("pci-rom", false,
            QEMU_CAPS_PCIDEVICE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_PCI_ROMBAR);
665

666
    DO_TEST_FULL("restore-v1", "stdio", 7, false, false,
667
            QEMU_CAPS_MIGRATE_KVM_STDIO);
668
    DO_TEST_FULL("restore-v2", "stdio", 7, false, false,
669
            QEMU_CAPS_MIGRATE_QEMU_EXEC);
670
    DO_TEST_FULL("restore-v2", "exec:cat", 7, false, false,
671
            QEMU_CAPS_MIGRATE_QEMU_EXEC);
672
    DO_TEST_FULL("restore-v2-fd", "stdio", 7, false, false,
673
            QEMU_CAPS_MIGRATE_QEMU_FD);
674
    DO_TEST_FULL("restore-v2-fd", "fd:7", 7, false, false,
675
            QEMU_CAPS_MIGRATE_QEMU_FD);
676
    DO_TEST_FULL("migrate", "tcp:10.0.0.1:5000", -1, false, false,
677 678 679 680 681 682 683 684 685 686 687 688 689
            QEMU_CAPS_MIGRATE_QEMU_TCP);

    DO_TEST("qemu-ns", false, NONE);

    DO_TEST("smp", false, QEMU_CAPS_SMP_TOPOLOGY);

    DO_TEST("cpu-topology1", false, QEMU_CAPS_SMP_TOPOLOGY);
    DO_TEST("cpu-topology2", false, QEMU_CAPS_SMP_TOPOLOGY);
    DO_TEST("cpu-topology3", false, NONE);
    DO_TEST("cpu-minimum1", false, NONE);
    DO_TEST("cpu-minimum2", false, NONE);
    DO_TEST("cpu-exact1", false, NONE);
    DO_TEST("cpu-exact2", false, NONE);
690 691 692
    DO_TEST("cpu-exact2-nofallback", false, NONE);
    DO_TEST("cpu-fallback", false, NONE);
    DO_TEST_FAILURE("cpu-nofallback", NONE);
693
    DO_TEST("cpu-strict1", false, NONE);
B
Bharata B Rao 已提交
694 695
    DO_TEST("cpu-numa1", false, NONE);
    DO_TEST("cpu-numa2", false, QEMU_CAPS_SMP_TOPOLOGY);
696 697 698 699 700 701 702
    DO_TEST("cpu-host-model", false, NONE);
    DO_TEST("cpu-host-model-fallback", false, NONE);
    DO_TEST_FAILURE("cpu-host-model-nofallback", NONE);
    DO_TEST("cpu-host-passthrough", false, QEMU_CAPS_KVM, QEMU_CAPS_CPU_HOST);
    DO_TEST_FAILURE("cpu-host-passthrough", NONE);
    DO_TEST_FAILURE("cpu-qemu-host-passthrough",
                    QEMU_CAPS_KVM, QEMU_CAPS_CPU_HOST);
703 704 705

    DO_TEST("memtune", false, QEMU_CAPS_NAME);
    DO_TEST("blkiotune", false, QEMU_CAPS_NAME);
706
    DO_TEST("blkiotune-device", false, QEMU_CAPS_NAME);
O
Osier Yang 已提交
707
    DO_TEST("cputune", false, QEMU_CAPS_NAME);
708
    DO_TEST("numatune-memory", false, NONE);
L
Lei Li 已提交
709
    DO_TEST("blkdeviotune", false, QEMU_CAPS_NAME, QEMU_CAPS_DEVICE,
710
            QEMU_CAPS_DRIVE, QEMU_CAPS_DRIVE_IOTUNE);
711

712 713 714 715
    DO_TEST("multifunction-pci-device", false,
            QEMU_CAPS_DRIVE, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_PCI_MULTIFUNCTION);

716 717
    DO_TEST("monitor-json", false, QEMU_CAPS_DEVICE,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_MONITOR_JSON, QEMU_CAPS_NODEFCONFIG);
718 719 720
    DO_TEST("no-shutdown", false, QEMU_CAPS_DEVICE,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_MONITOR_JSON, QEMU_CAPS_NODEFCONFIG,
            QEMU_CAPS_NO_SHUTDOWN);
721

722 723
    DO_TEST("seclabel-dynamic", false, QEMU_CAPS_NAME);
    DO_TEST("seclabel-dynamic-baselabel", false, QEMU_CAPS_NAME);
724
    DO_TEST("seclabel-dynamic-override", false, QEMU_CAPS_NAME);
725 726
    DO_TEST("seclabel-static", false, QEMU_CAPS_NAME);
    DO_TEST("seclabel-static-relabel", false, QEMU_CAPS_NAME);
E
Eric Blake 已提交
727
    DO_TEST("seclabel-none", false, QEMU_CAPS_NAME);
728

729 730 731 732 733 734 735 736 737
    DO_TEST("pseries-basic", false,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("pseries-vio", false, QEMU_CAPS_DRIVE,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("pseries-vio-user-assigned", false, QEMU_CAPS_DRIVE,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);
    DO_TEST("pseries-vio-address-clash", true, QEMU_CAPS_DRIVE,
            QEMU_CAPS_CHARDEV, QEMU_CAPS_DEVICE, QEMU_CAPS_NODEFCONFIG);

738
    VIR_FREE(driver.stateDir);
739
    virCapabilitiesFree(driver.caps);
740
    VIR_FREE(map);
741

742
    return(ret==0 ? EXIT_SUCCESS : EXIT_FAILURE);
743 744
}

745 746
VIRT_TEST_MAIN(mymain)

747
#else
E
Eric Blake 已提交
748
# include "testutils.h"
749

750 751 752 753
int main(void)
{
    return EXIT_AM_SKIP;
}
754 755

#endif /* WITH_QEMU */