qemu_capabilities.c 177.1 KB
Newer Older
1 2 3
/*
 * qemu_capabilities.c: QEMU capabilities generation
 *
4
 * Copyright (C) 2006-2016 Red Hat, Inc.
5 6 7 8 9 10 11 12 13 14 15 16 17
 * Copyright (C) 2006 Daniel P. Berrange
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with this library.  If not, see
O
Osier Yang 已提交
19
 * <http://www.gnu.org/licenses/>.
20 21 22 23 24 25 26
 *
 * Author: Daniel P. Berrange <berrange@redhat.com>
 */

#include <config.h>

#include "qemu_capabilities.h"
27
#include "viralloc.h"
28
#include "vircrypto.h"
29
#include "virlog.h"
30
#include "virerror.h"
E
Eric Blake 已提交
31
#include "virfile.h"
32 33
#include "virpidfile.h"
#include "virprocess.h"
34
#include "cpu/cpu.h"
35
#include "cpu/cpu_x86.h"
36
#include "domain_conf.h"
37
#include "vircommand.h"
38
#include "virbitmap.h"
39
#include "virnodesuspend.h"
40
#include "virnuma.h"
41
#include "virhostcpu.h"
42
#include "qemu_monitor.h"
43
#include "virstring.h"
44
#include "qemu_hostdev.h"
45
#include "qemu_domain.h"
46
#define __QEMU_CAPSPRIV_H_ALLOW__
47
#include "qemu_capspriv.h"
48

49
#include <fcntl.h>
50 51 52
#include <sys/stat.h>
#include <unistd.h>
#include <sys/wait.h>
53
#include <stdarg.h>
54 55 56

#define VIR_FROM_THIS VIR_FROM_QEMU

57 58
VIR_LOG_INIT("qemu.qemu_capabilities");

59 60 61 62
/* While not public, these strings must not change. They
 * are used in domain status files which are read on
 * daemon restarts
 */
63
VIR_ENUM_IMPL(virQEMUCaps, QEMU_CAPS_LAST,
64 65
              /* 0 */
              "kqemu",
66 67 68 69 70
              "vnc-colon",
              "no-reboot",
              "drive",
              "drive-boot",

71 72
              /* 5 */
              "name",
73 74 75 76 77
              "uuid",
              "domid",
              "vnet-hdr",
              "migrate-kvm-stdio",

78 79
              /* 10 */
              "migrate-qemu-tcp",
80 81 82 83 84
              "migrate-qemu-exec",
              "drive-cache-v2",
              "kvm",
              "drive-format",

85 86
              /* 15 */
              "vga",
87 88 89 90 91
              "0.10",
              "pci-device",
              "mem-path",
              "drive-serial",

92 93
              /* 20 */
              "xen-domid",
94 95 96 97 98
              "migrate-qemu-unix",
              "chardev",
              "enable-kvm",
              "monitor-json",

99 100
              /* 25 */
              "balloon",
101 102 103 104 105
              "device",
              "sdl",
              "smp-topology",
              "netdev",

106 107
              /* 30 */
              "rtc",
108
              "vhost-net",
109 110 111 112
              "rtc-td-hack",
              "no-hpet",
              "no-kvm-pit",

113 114
              /* 35 */
              "tdf",
115 116 117 118 119
              "pci-configfd",
              "nodefconfig",
              "boot-menu",
              "enable-kqemu",

120 121
              /* 40 */
              "fsdev",
122 123 124 125 126
              "nesting",
              "name-process",
              "drive-readonly",
              "smbios-type",

127 128
              /* 45 */
              "vga-qxl",
129 130 131 132 133
              "spice",
              "vga-none",
              "migrate-qemu-fd",
              "boot-index",

134 135
              /* 50 */
              "hda-duplex",
136 137 138 139 140
              "drive-aio",
              "pci-multibus",
              "pci-bootindex",
              "ccid-emulated",

141 142
              /* 55 */
              "ccid-passthru",
143 144 145 146
              "chardev-spicevmc",
              "device-spicevmc",
              "virtio-tx-alg",
              "device-qxl-vga",
147

148 149
              /* 60 */
              "pci-multifunction",
150
              "virtio-blk-pci.ioeventfd",
M
Michal Privoznik 已提交
151
              "sga",
152 153
              "virtio-blk-pci.event_idx",
              "virtio-net-pci.event_idx",
154

155 156
              /* 65 */
              "cache-directsync",
157 158 159 160 161
              "piix3-usb-uhci",
              "piix4-usb-uhci",
              "usb-ehci",
              "ich9-usb-ehci1",

162 163
              /* 70 */
              "vt82c686b-usb-uhci",
164 165
              "pci-ohci",
              "usb-redir",
M
Marc-André Lureau 已提交
166
              "usb-hub",
167
              "no-shutdown",
168

169 170
              /* 75 */
              "cache-unsafe",
171
              "rombar",
J
Jim Fehlig 已提交
172
              "ich9-ahci",
173
              "no-acpi",
174
              "fsdev-readonly",
175

176 177
              /* 80 */
              "virtio-blk-pci.scsi",
178
              "blk-sg-io",
O
Osier Yang 已提交
179
              "drive-copy-on-read",
180
              "cpu-host",
181
              "fsdev-writeout",
182

183 184
              /* 85 */
              "drive-iotune",
185
              "system_wakeup",
186
              "scsi-disk.channel",
187
              "scsi-block",
188
              "transaction",
189

190 191
              /* 90 */
              "block-job-sync",
192
              "block-job-async",
193
              "scsi-cd",
194
              "ide-cd",
195
              "no-user-config",
M
Marc-André Lureau 已提交
196

197 198
              /* 95 */
              "hda-micro",
199
              "dump-guest-memory",
G
Gerd Hoffmann 已提交
200
              "nec-usb-xhci",
201
              "virtio-s390",
202
              "balloon-event",
M
Marc-André Lureau 已提交
203

204 205
              /* 100 */
              "bridge",
206 207
              "lsi",
              "virtio-scsi-pci",
V
Viktor Mihajlovski 已提交
208
              "blockio",
209
              "disable-s3",
R
Richa Marwaha 已提交
210

211 212
              /* 105 */
              "disable-s4",
213
              "usb-redir.filter",
214 215
              "ide-drive.wwn",
              "scsi-disk.wwn",
216
              "seccomp-sandbox",
217

218 219
              /* 110 */
              "reboot-timeout",
220
              "dump-guest-core",
221
              "seamless-migration",
222
              "block-commit",
223
              "vnc",
224

225 226
              /* 115 */
              "drive-mirror",
227 228
              "usb-redir.bootindex",
              "usb-host.bootindex",
229
              "blockdev-snapshot-sync",
230 231
              "qxl",

232 233
              /* 120 */
              "VGA",
234 235 236
              "cirrus-vga",
              "vmware-svga",
              "device-video-primary",
237
              "s390-sclp",
238

239 240
              /* 125 */
              "usb-serial",
G
Guannan Ren 已提交
241
              "usb-net",
242
              "add-fd",
243
              "nbd-server",
244 245
              "virtio-rng",

246 247
              /* 130 */
              "rng-random",
248
              "rng-egd",
O
Olivia Yin 已提交
249 250
              "virtio-ccw",
              "dtb",
251
              "megasas",
J
Ján Tomko 已提交
252

253 254
              /* 135 */
              "ipv6-migration",
255
              "machine-opt",
L
Li Zhang 已提交
256
              "machine-usb-opt",
S
Stefan Berger 已提交
257 258
              "tpm-passthrough",
              "tpm-tis",
259

260 261
              /* 140 */
              "nvram",
H
Han Cheng 已提交
262 263 264 265 266
              "pci-bridge",
              "vfio-pci",
              "vfio-pci.bootindex",
              "scsi-generic",

267 268
              /* 145 */
              "scsi-generic.bootindex",
269
              "mem-merge",
270
              "vnc-websocket",
O
Osier Yang 已提交
271
              "drive-discard",
272
              "mlock",
273

274 275
              /* 150 */
              "vnc-share-policy",
276
              "device-del-event",
277
              "dmi-to-pci-bridge",
278 279
              "i440fx-pci-hole64-size",
              "q35-pci-hole64-size",
280

281 282
              /* 155 */
              "usb-storage",
283
              "usb-storage.removable",
284
              "virtio-mmio",
285
              "ich9-intel-hda",
286
              "kvm-pit-lost-tick-policy",
287

288 289
              /* 160 */
              "boot-strict",
290 291
              "pvpanic",
              "enable-fips",
292 293
              "spice-file-xfer-disable",
              "spiceport",
L
Li Zhang 已提交
294

295 296
              /* 165 */
              "usb-kbd",
297
              "host-pci-multidomain",
298
              "msg-timestamp",
299
              "active-commit",
300
              "change-backing-file",
301

302 303
              /* 170 */
              "memory-backend-ram",
304
              "numa",
305
              "memory-backend-file",
306
              "usb-audio",
307
              "rtc-reset-reinjection",
308

309 310
              /* 175 */
              "splash-timeout",
J
John Ferlan 已提交
311
              "iothread",
312
              "migrate-rdma",
313
              "ivshmem",
314
              "drive-iotune-max",
315

316 317
              /* 180 */
              "VGA.vgamem_mb",
318 319 320
              "vmware-svga.vgamem_mb",
              "qxl.vgamem_mb",
              "qxl-vga.vgamem_mb",
321
              "pc-dimm",
322

323 324
              /* 185 */
              "machine-vmport-opt",
325 326
              "aes-key-wrap",
              "dea-key-wrap",
M
Michal Privoznik 已提交
327
              "pci-serial",
328
              "aarch64-off",
329

330 331
              /* 190 */
              "vhost-user-multiqueue",
332
              "migration-event",
333
              "gpex-pcihost",
334
              "ioh3420",
335
              "x3130-upstream",
336

337 338
              /* 195 */
              "xio3130-downstream",
339
              "rtl8139",
340
              "e1000",
341
              "virtio-net",
342
              "gic-version",
343

344 345
              /* 200 */
              "incoming-defer",
M
Marc-André Lureau 已提交
346
              "virtio-gpu",
347
              "virtio-gpu.virgl",
348 349 350
              "virtio-keyboard",
              "virtio-mouse",

351 352
              /* 205 */
              "virtio-tablet",
353
              "virtio-input-host",
354
              "chardev-file-append",
355 356
              "ich9-disable-s3",
              "ich9-disable-s4",
357

358 359
              /* 210 */
              "vserport-change-event",
360
              "virtio-balloon-pci.deflate-on-oom",
361
              "mptsas1068",
362
              "spice-gl",
363 364
              "qxl.vram64_size_mb",

365 366
              /* 215 */
              "qxl-vga.vram64_size_mb",
367
              "chardev-logfile",
368
              "debug-threads",
369
              "secret",
370
              "pxb",
371

372 373
              /* 220 */
              "pxb-pcie",
374
              "device-tray-moved-event",
375
              "nec-usb-xhci-ports",
376
              "virtio-scsi-pci.iothread",
377
              "name-guest",
378

379 380
              /* 225 */
              "qxl.max_outputs",
381
              "qxl-vga.max_outputs",
382
              "spice-unix",
383
              "drive-detect-zeroes",
B
Boris Fiuczynski 已提交
384
              "tls-creds-x509",
385

386 387
              /* 230 */
              "display",
J
Ján Tomko 已提交
388
              "intel-iommu",
M
Michal Privoznik 已提交
389
              "smm",
390
              "virtio-pci-disable-legacy",
391
              "query-hotpluggable-cpus",
392

393 394
              /* 235 */
              "virtio-net.rx_queue_size",
395
              "machine-iommu",
396
              "virtio-vga",
397
              "drive-iotune-max-length",
398 399
              "ivshmem-plain",

400 401
              /* 240 */
              "ivshmem-doorbell",
402
              "query-qmp-schema",
403
              "gluster.debug_level",
404
              "vhost-scsi",
405
              "drive-iotune-group",
406

407 408
              /* 245 */
              "query-cpu-model-expansion",
409
              "virtio-net.host_mtu",
410
              "spice-rendernode",
411
              "nvdimm",
412
              "pcie-root-port",
413

414 415
              /* 250 */
              "query-cpu-definitions",
416
              "block-write-threshold",
417
              "query-named-block-nodes",
418
              "cpu-cache",
419
              "qemu-xhci",
420

421 422
              /* 255 */
              "kernel-irqchip",
423
              "kernel-irqchip.split",
424
              "intel-iommu.intremap",
425
              "intel-iommu.caching-mode",
426
              "intel-iommu.eim",
427

428 429
              /* 260 */
              "intel-iommu.device-iotlb",
430 431
              "virtio.iommu_platform",
              "virtio.ats",
432
              "loadparm",
433 434
    );

435

436 437 438 439
struct virQEMUCapsMachineType {
    char *name;
    char *alias;
    unsigned int maxCpus;
440
    bool hotplugCpus;
441
};
442 443 444 445 446 447 448 449 450 451 452

typedef struct _virQEMUCapsHostCPUData virQEMUCapsHostCPUData;
typedef virQEMUCapsHostCPUData *virQEMUCapsHostCPUDataPtr;
struct _virQEMUCapsHostCPUData {
    /* Only the "info" part is stored in the capabilities cache, the rest is
     * re-computed from other fields and external data sources everytime we
     * probe QEMU or load the cache.
     */
    qemuMonitorCPUModelInfoPtr info;
    /* Host CPU definition reported in domain capabilities. */
    virCPUDefPtr reported;
453 454
    /* Migratable host CPU definition used for updating guest CPU. */
    virCPUDefPtr migratable;
455 456 457 458
    /* CPU definition with features detected by libvirt using virCPUGetHost
     * combined with features reported by QEMU. This is used for backward
     * compatible comparison between a guest CPU and a host CPU. */
    virCPUDefPtr full;
459 460
};

461 462 463 464 465 466
/*
 * Update the XML parser/formatter when adding more
 * information to this struct so that it gets cached
 * correctly. It does not have to be ABI-stable, as
 * the cache will be discarded & repopulated if the
 * timestamp on the libvirtd binary changes.
467 468
 *
 * And don't forget to update virQEMUCapsNewCopy.
469
 */
470
struct _virQEMUCaps {
471 472
    virObject object;

473 474
    bool usedQMP;

475
    char *binary;
476
    time_t ctime;
477

478
    virBitmapPtr flags;
479 480 481

    unsigned int version;
    unsigned int kvmVersion;
482
    char *package;
483

484
    virArch arch;
485

486 487
    virDomainCapsCPUModelsPtr kvmCPUModels;
    virDomainCapsCPUModelsPtr tcgCPUModels;
488 489

    size_t nmachineTypes;
490
    struct virQEMUCapsMachineType *machineTypes;
A
Andrea Bolognani 已提交
491 492 493

    size_t ngicCapabilities;
    virGICCapability *gicCapabilities;
494

495 496
    virQEMUCapsHostCPUData kvmCPU;
    virQEMUCapsHostCPUData tcgCPU;
497 498
};

499 500 501 502
struct virQEMUCapsSearchData {
    virArch arch;
};

503

504 505
static virClassPtr virQEMUCapsClass;
static void virQEMUCapsDispose(void *obj);
506

507
static int virQEMUCapsOnceInit(void)
508
{
509 510 511 512
    if (!(virQEMUCapsClass = virClassNew(virClassForObject(),
                                         "virQEMUCaps",
                                         sizeof(virQEMUCaps),
                                         virQEMUCapsDispose)))
513 514 515 516 517
        return -1;

    return 0;
}

518
VIR_ONCE_GLOBAL_INIT(virQEMUCaps)
519

520
static virArch virQEMUCapsArchFromString(const char *arch)
521 522 523 524 525
{
    if (STREQ(arch, "i386"))
        return VIR_ARCH_I686;
    if (STREQ(arch, "arm"))
        return VIR_ARCH_ARMV7L;
526 527
    if (STREQ(arch, "or32"))
        return VIR_ARCH_OR32;
528 529 530 531 532

    return virArchFromString(arch);
}


533
static const char *virQEMUCapsArchToString(virArch arch)
534 535 536 537 538
{
    if (arch == VIR_ARCH_I686)
        return "i386";
    else if (arch == VIR_ARCH_ARMV7L)
        return "arm";
539 540
    else if (arch == VIR_ARCH_OR32)
        return "or32";
541 542 543 544

    return virArchToString(arch);
}

545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567

/* Checks whether a domain with @guest arch can run natively on @host.
 */
static bool
virQEMUCapsGuestIsNative(virArch host,
                         virArch guest)
{
    if (host == guest)
        return true;

    if (host == VIR_ARCH_X86_64 && guest == VIR_ARCH_I686)
        return true;

    if (host == VIR_ARCH_AARCH64 && guest == VIR_ARCH_ARMV7L)
        return true;

    if (ARCH_IS_PPC64(host) && ARCH_IS_PPC64(guest))
        return true;

    return false;
}


568 569 570 571 572 573 574 575 576
/* Given a host and guest architectures, find a suitable QEMU target.
 *
 * This is meant to be used as a second attempt if qemu-system-$guestarch
 * can't be found, eg. on a x86_64 host you want to use qemu-system-i386,
 * if available, instead of qemu-system-x86_64 to run i686 guests */
static virArch
virQEMUCapsFindTarget(virArch hostarch,
                      virArch guestarch)
{
577 578 579
    if (virQEMUCapsGuestIsNative(hostarch, guestarch))
        guestarch = hostarch;

580 581 582 583 584 585
    /* Both ppc64 and ppc64le guests can use the ppc64 target */
    if (ARCH_IS_PPC64(guestarch))
        guestarch = VIR_ARCH_PPC64;

    return guestarch;
}
586

587
static virCommandPtr
588 589
virQEMUCapsProbeCommand(const char *qemu,
                        virQEMUCapsPtr qemuCaps,
590
                        uid_t runUid, gid_t runGid)
591 592 593
{
    virCommandPtr cmd = virCommandNew(qemu);

594 595
    if (qemuCaps) {
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG))
596
            virCommandAddArg(cmd, "-no-user-config");
597
        else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NODEFCONFIG))
598 599 600 601 602
            virCommandAddArg(cmd, "-nodefconfig");
    }

    virCommandAddEnvPassCommon(cmd);
    virCommandClearCaps(cmd);
603 604
    virCommandSetGID(cmd, runGid);
    virCommandSetUID(cmd, runUid);
605 606 607 608 609

    return cmd;
}


610
static void
611 612
virQEMUCapsSetDefaultMachine(virQEMUCapsPtr qemuCaps,
                             size_t defIdx)
613
{
614
    struct virQEMUCapsMachineType tmp = qemuCaps->machineTypes[defIdx];
615 616 617 618

    memmove(qemuCaps->machineTypes + 1,
            qemuCaps->machineTypes,
            sizeof(qemuCaps->machineTypes[0]) * defIdx);
619 620

    qemuCaps->machineTypes[0] = tmp;
621 622
}

623 624 625 626
/* Format is:
 * <machine> <desc> [(default)|(alias of <canonical>)]
 */
static int
627 628
virQEMUCapsParseMachineTypesStr(const char *output,
                                virQEMUCapsPtr qemuCaps)
629 630 631
{
    const char *p = output;
    const char *next;
632
    size_t defIdx = 0;
633 634 635

    do {
        const char *t;
636 637
        char *name;
        char *canonical = NULL;
638 639 640 641 642 643 644 645 646 647

        if ((next = strchr(p, '\n')))
            ++next;

        if (STRPREFIX(p, "Supported machines are:"))
            continue;

        if (!(t = strchr(p, ' ')) || (next && t >= next))
            continue;

648 649
        if (VIR_STRNDUP(name, p, t - p) < 0)
            return -1;
650 651

        p = t;
652
        if ((t = strstr(p, "(default)")) && (!next || t < next))
653
            defIdx = qemuCaps->nmachineTypes;
654 655 656

        if ((t = strstr(p, "(alias of ")) && (!next || t < next)) {
            p = t + strlen("(alias of ");
657 658
            if (!(t = strchr(p, ')')) || (next && t >= next)) {
                VIR_FREE(name);
659
                continue;
660
            }
661

662
            if (VIR_STRNDUP(canonical, p, t - p) < 0) {
663
                VIR_FREE(name);
664
                return -1;
665 666 667
            }
        }

668
        if (VIR_REALLOC_N(qemuCaps->machineTypes, qemuCaps->nmachineTypes + 1) < 0) {
669 670
            VIR_FREE(name);
            VIR_FREE(canonical);
671
            return -1;
672
        }
673
        qemuCaps->nmachineTypes++;
674
        if (canonical) {
675 676
            qemuCaps->machineTypes[qemuCaps->nmachineTypes-1].name = canonical;
            qemuCaps->machineTypes[qemuCaps->nmachineTypes-1].alias = name;
677
        } else {
678 679
            qemuCaps->machineTypes[qemuCaps->nmachineTypes-1].name = name;
            qemuCaps->machineTypes[qemuCaps->nmachineTypes-1].alias = NULL;
680
        }
681
        /* When parsing from command line we don't have information about maxCpus */
682
        qemuCaps->machineTypes[qemuCaps->nmachineTypes-1].maxCpus = 0;
683
        qemuCaps->machineTypes[qemuCaps->nmachineTypes-1].hotplugCpus = false;
684 685
    } while ((p = next));

686

687
    if (defIdx)
688
        virQEMUCapsSetDefaultMachine(qemuCaps, defIdx);
689 690 691 692

    return 0;
}

693
static int
694 695
virQEMUCapsProbeMachineTypes(virQEMUCapsPtr qemuCaps,
                             uid_t runUid, gid_t runGid)
696 697
{
    char *output;
698 699
    int ret = -1;
    virCommandPtr cmd;
700
    int status;
701

702 703 704 705
    /* Make sure the binary we are about to try exec'ing exists.
     * Technically we could catch the exec() failure, but that's
     * in a sub-process so it's hard to feed back a useful error.
     */
706
    if (!virFileIsExecutable(qemuCaps->binary)) {
707
        virReportSystemError(errno, _("Cannot find QEMU binary %s"),
708
                             qemuCaps->binary);
709 710 711
        return -1;
    }

712
    cmd = virQEMUCapsProbeCommand(qemuCaps->binary, qemuCaps, runUid, runGid);
713
    virCommandAddArgList(cmd, "-M", "?", NULL);
714
    virCommandSetOutputBuffer(cmd, &output);
715

716 717
    /* Ignore failure from older qemu that did not understand '-M ?'.  */
    if (virCommandRun(cmd, &status) < 0)
718 719
        goto cleanup;

720
    if (virQEMUCapsParseMachineTypesStr(output, qemuCaps) < 0)
721
        goto cleanup;
722 723 724

    ret = 0;

725
 cleanup:
726 727
    VIR_FREE(output);
    virCommandFree(cmd);
728 729 730 731 732 733

    return ret;
}


typedef int
734 735
(*virQEMUCapsParseCPUModels)(const char *output,
                             virQEMUCapsPtr qemuCaps);
736 737 738 739 740 741 742

/* Format:
 *      <arch> <model>
 * qemu-0.13 encloses some model names in []:
 *      <arch> [<model>]
 */
static int
743 744
virQEMUCapsParseX86Models(const char *output,
                          virQEMUCapsPtr qemuCaps)
745 746 747
{
    const char *p = output;
    const char *next;
748 749 750 751
    virDomainCapsCPUModelsPtr cpus;

    if (!(cpus = virDomainCapsCPUModelsNew(0)))
        return -1;
752 753 754

    do {
        const char *t;
755
        size_t len;
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772

        if ((next = strchr(p, '\n')))
            next++;

        if (!(t = strchr(p, ' ')) || (next && t >= next))
            continue;

        if (!STRPREFIX(p, "x86"))
            continue;

        p = t;
        while (*p == ' ')
            p++;

        if (*p == '\0' || *p == '\n')
            continue;

773 774 775 776
        if (next)
            len = next - p - 1;
        else
            len = strlen(p);
777

778 779 780 781
        if (len > 2 && *p == '[' && p[len - 1] == ']') {
            p++;
            len -= 2;
        }
782

J
Jiri Denemark 已提交
783 784
        if (virDomainCapsCPUModelsAdd(cpus, p, len,
                                      VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0)
785
            goto error;
786 787
    } while ((p = next));

788 789 790 791 792 793 794 795 796 797
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
        virDomainCapsCPUModelsPtr kvmCPUs;

        if (!(kvmCPUs = virDomainCapsCPUModelsCopy(cpus)))
            goto error;

        qemuCaps->kvmCPUModels = kvmCPUs;
    }
    qemuCaps->tcgCPUModels = cpus;

798
    return 0;
799

800 801 802
 error:
    virObjectUnref(cpus);
    return -1;
803 804
}

P
Prerna Saxena 已提交
805 806 807 808
/* ppc64 parser.
 * Format : PowerPC <machine> <description>
 */
static int
809 810
virQEMUCapsParsePPCModels(const char *output,
                          virQEMUCapsPtr qemuCaps)
P
Prerna Saxena 已提交
811 812 813
{
    const char *p = output;
    const char *next;
814 815 816 817
    virDomainCapsCPUModelsPtr cpus;

    if (!(cpus = virDomainCapsCPUModelsNew(0)))
        return -1;
P
Prerna Saxena 已提交
818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840

    do {
        const char *t;

        if ((next = strchr(p, '\n')))
            next++;

        if (!STRPREFIX(p, "PowerPC "))
            continue;

        /* Skip the preceding sub-string "PowerPC " */
        p += 8;

        /*Malformed string, does not obey the format 'PowerPC <model> <desc>'*/
        if (!(t = strchr(p, ' ')) || (next && t >= next))
            continue;

        if (*p == '\0')
            break;

        if (*p == '\n')
            continue;

J
Jiri Denemark 已提交
841 842
        if (virDomainCapsCPUModelsAdd(cpus, p, t - p - 1,
                                      VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0)
843
            goto error;
P
Prerna Saxena 已提交
844 845
    } while ((p = next));

846 847 848 849 850 851 852 853 854 855
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
        virDomainCapsCPUModelsPtr kvmCPUs;

        if (!(kvmCPUs = virDomainCapsCPUModelsCopy(cpus)))
            goto error;

        qemuCaps->kvmCPUModels = kvmCPUs;
    }
    qemuCaps->tcgCPUModels = cpus;

856
    return 0;
P
Prerna Saxena 已提交
857

858 859 860
 error:
    virObjectUnref(cpus);
    return -1;
P
Prerna Saxena 已提交
861
}
862

863
static int
864
virQEMUCapsProbeCPUModels(virQEMUCapsPtr qemuCaps, uid_t runUid, gid_t runGid)
865 866 867
{
    char *output = NULL;
    int ret = -1;
868
    virQEMUCapsParseCPUModels parse;
869
    virCommandPtr cmd;
870

A
Andrea Bolognani 已提交
871
    if (ARCH_IS_X86(qemuCaps->arch)) {
872
        parse = virQEMUCapsParseX86Models;
A
Andrea Bolognani 已提交
873
    } else if (ARCH_IS_PPC64(qemuCaps->arch)) {
874
        parse = virQEMUCapsParsePPCModels;
875
    } else {
876
        VIR_DEBUG("don't know how to parse %s CPU models",
877
                  virArchToString(qemuCaps->arch));
878 879 880
        return 0;
    }

881
    cmd = virQEMUCapsProbeCommand(qemuCaps->binary, qemuCaps, runUid, runGid);
882
    virCommandAddArgList(cmd, "-cpu", "?", NULL);
883
    virCommandSetOutputBuffer(cmd, &output);
884

885
    if (virCommandRun(cmd, NULL) < 0)
886 887
        goto cleanup;

888
    if (parse(output, qemuCaps) < 0)
889 890 891 892
        goto cleanup;

    ret = 0;

893
 cleanup:
894
    VIR_FREE(output);
895
    virCommandFree(cmd);
896 897 898 899

    return ret;
}

900
static char *
901 902
virQEMUCapsFindBinary(const char *format,
                      const char *archstr)
903
{
904 905
    char *ret = NULL;
    char *binary = NULL;
906

907 908
    if (virAsprintf(&binary, format, archstr) < 0)
        goto out;
909 910 911

    ret = virFindFileInPath(binary);
    VIR_FREE(binary);
912 913
    if (ret && virFileIsExecutable(ret))
        goto out;
914

915
    VIR_FREE(ret);
916

917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939
 out:
    return ret;
}

static char *
virQEMUCapsFindBinaryForArch(virArch hostarch,
                             virArch guestarch)
{
    char *ret = NULL;
    const char *archstr;
    virArch target;

    /* First attempt: try the guest architecture as it is */
    archstr = virQEMUCapsArchToString(guestarch);
    if ((ret = virQEMUCapsFindBinary("qemu-system-%s", archstr)) != NULL)
        goto out;

    /* Second attempt: try looking up by target instead */
    target = virQEMUCapsFindTarget(hostarch, guestarch);
    if (target != guestarch) {
        archstr = virQEMUCapsArchToString(target);
        if ((ret = virQEMUCapsFindBinary("qemu-system-%s", archstr)) != NULL)
            goto out;
940
    }
941

942 943 944 945
    /* Third attempt, i686 only: try 'qemu' */
    if (guestarch == VIR_ARCH_I686) {
        if ((ret = virQEMUCapsFindBinary("%s", "qemu")) != NULL)
            goto out;
946
    }
947

948
 out:
949 950 951
    return ret;
}

952
static int
953 954 955 956
virQEMUCapsInitGuest(virCapsPtr caps,
                     virQEMUCapsCachePtr cache,
                     virArch hostarch,
                     virArch guestarch)
957
{
958
    size_t i;
959 960
    char *kvmbin = NULL;
    char *binary = NULL;
961 962
    virQEMUCapsPtr qemubinCaps = NULL;
    virQEMUCapsPtr kvmbinCaps = NULL;
963 964
    int ret = -1;

J
Ján Tomko 已提交
965
    /* Check for existence of base emulator, or alternate base
966 967
     * which can be used with magic cpu choice
     */
968
    binary = virQEMUCapsFindBinaryForArch(hostarch, guestarch);
969

970
    /* Ignore binary if extracting version info fails */
971
    if (binary) {
972
        if (!(qemubinCaps = virQEMUCapsCacheLookup(caps, cache, binary))) {
973 974 975 976
            virResetLastError();
            VIR_FREE(binary);
        }
    }
977 978

    /* qemu-kvm/kvm binaries can only be used if
979
     *  - host & guest arches match
980 981
     *  - hostarch is x86_64 and guest arch is i686 (needs -cpu qemu32)
     *  - hostarch is aarch64 and guest arch is armv7l (needs -cpu aarch64=off)
982
     *  - hostarch and guestarch are both ppc64*
983
     */
984
    if (virQEMUCapsGuestIsNative(hostarch, guestarch)) {
985 986 987 988 989 990 991 992 993 994 995 996 997 998 999
        const char *kvmbins[] = {
            "/usr/libexec/qemu-kvm", /* RHEL */
            "qemu-kvm", /* Fedora */
            "kvm", /* Debian/Ubuntu */
            NULL,
        };

        /* x86 32-on-64 can be used with qemu-system-i386 and
         * qemu-system-x86_64, so if we don't find a specific kvm binary,
         * we can just fall back to the host arch native binary and
         * everything works fine.
         *
         * arm is different in that 32-on-64 _only_ works with
         * qemu-system-aarch64. So we have to add it to the kvmbins list
         */
1000
        if (hostarch == VIR_ARCH_AARCH64 && guestarch == VIR_ARCH_ARMV7L)
1001
            kvmbins[3] = "qemu-system-aarch64";
1002

1003
        for (i = 0; i < ARRAY_CARDINALITY(kvmbins); ++i) {
1004 1005 1006
            if (!kvmbins[i])
                continue;

1007
            kvmbin = virFindFileInPath(kvmbins[i]);
1008

1009 1010
            if (!kvmbin)
                continue;
1011

1012
            if (!(kvmbinCaps = virQEMUCapsCacheLookup(caps, cache, kvmbin))) {
1013
                virResetLastError();
1014 1015 1016
                VIR_FREE(kvmbin);
                continue;
            }
1017

1018 1019
            if (!binary) {
                binary = kvmbin;
1020
                qemubinCaps = kvmbinCaps;
1021
                kvmbin = NULL;
1022
                kvmbinCaps = NULL;
1023
            }
1024
            break;
1025 1026 1027
        }
    }

1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
    ret = virQEMUCapsInitGuestFromBinary(caps,
                                         binary, qemubinCaps,
                                         kvmbin, kvmbinCaps,
                                         guestarch);

    VIR_FREE(binary);
    VIR_FREE(kvmbin);
    virObjectUnref(qemubinCaps);
    virObjectUnref(kvmbinCaps);

    return ret;
}

int
virQEMUCapsInitGuestFromBinary(virCapsPtr caps,
                               const char *binary,
                               virQEMUCapsPtr qemubinCaps,
                               const char *kvmbin,
                               virQEMUCapsPtr kvmbinCaps,
                               virArch guestarch)
{
    virCapsGuestPtr guest;
    bool haskvm = false;
    virCapsGuestMachinePtr *machines = NULL;
    size_t nmachines = 0;
    int ret = -1;
    bool hasdisksnapshot = false;

1056 1057 1058
    if (!binary)
        return 0;

1059
    if (virFileExists("/dev/kvm") &&
1060 1061
        (virQEMUCapsGet(qemubinCaps, QEMU_CAPS_KVM) ||
         virQEMUCapsGet(qemubinCaps, QEMU_CAPS_ENABLE_KVM) ||
1062
         kvmbin))
1063
        haskvm = true;
1064

1065
    if (virQEMUCapsGetMachineTypesCaps(qemubinCaps, &nmachines, &machines) < 0)
1066
        goto cleanup;
1067 1068 1069 1070

    /* We register kvm as the base emulator too, since we can
     * just give -no-kvm to disable acceleration if required */
    if ((guest = virCapabilitiesAddGuest(caps,
1071
                                         VIR_DOMAIN_OSTYPE_HVM,
1072
                                         guestarch,
1073 1074 1075 1076
                                         binary,
                                         NULL,
                                         nmachines,
                                         machines)) == NULL)
1077
        goto cleanup;
1078 1079 1080 1081

    machines = NULL;
    nmachines = 0;

A
Andrea Bolognani 已提交
1082 1083 1084
    /* CPU selection is always available, because all QEMU versions
     * we support can use at least '-cpu host' */
    if (!virCapabilitiesAddGuestFeature(guest, "cpuselection", true, false))
1085
        goto cleanup;
1086

1087
    if (virQEMUCapsGet(qemubinCaps, QEMU_CAPS_BOOTINDEX) &&
1088
        !virCapabilitiesAddGuestFeature(guest, "deviceboot", true, false))
1089
        goto cleanup;
1090

1091 1092 1093
    if (virQEMUCapsGet(qemubinCaps, QEMU_CAPS_DISK_SNAPSHOT))
        hasdisksnapshot = true;

1094 1095
    if (!virCapabilitiesAddGuestFeature(guest, "disksnapshot", hasdisksnapshot,
                                        false))
1096
        goto cleanup;
1097

D
Daniel P. Berrange 已提交
1098
    if (virCapabilitiesAddGuestDomain(guest,
1099
                                      VIR_DOMAIN_VIRT_QEMU,
D
Daniel P. Berrange 已提交
1100 1101 1102 1103
                                      NULL,
                                      NULL,
                                      0,
                                      NULL) == NULL)
1104
        goto cleanup;
1105

D
Daniel P. Berrange 已提交
1106 1107
    if (haskvm) {
        virCapsGuestDomainPtr dom;
1108

D
Daniel P. Berrange 已提交
1109
        if (kvmbin &&
1110
            virQEMUCapsGetMachineTypesCaps(kvmbinCaps, &nmachines, &machines) < 0)
1111
            goto cleanup;
1112

D
Daniel P. Berrange 已提交
1113
        if ((dom = virCapabilitiesAddGuestDomain(guest,
1114
                                                 VIR_DOMAIN_VIRT_KVM,
D
Daniel P. Berrange 已提交
1115 1116 1117 1118
                                                 kvmbin ? kvmbin : binary,
                                                 NULL,
                                                 nmachines,
                                                 machines)) == NULL) {
1119
            goto cleanup;
D
Daniel P. Berrange 已提交
1120
        }
1121

D
Daniel P. Berrange 已提交
1122 1123
        machines = NULL;
        nmachines = 0;
1124
    }
1125

1126 1127 1128
    if ((ARCH_IS_X86(guestarch) || guestarch == VIR_ARCH_AARCH64) &&
        virCapabilitiesAddGuestFeature(guest, "acpi", true, true) == NULL) {
        goto cleanup;
1129 1130
    }

A
Andrea Bolognani 已提交
1131
    if (ARCH_IS_X86(guestarch) &&
1132
        virCapabilitiesAddGuestFeature(guest, "apic", true, false) == NULL) {
1133
        goto cleanup;
1134
    }
1135

1136
    if ((guestarch == VIR_ARCH_I686) &&
1137 1138
        (virCapabilitiesAddGuestFeature(guest, "pae", true, false) == NULL ||
         virCapabilitiesAddGuestFeature(guest, "nonpae", true, false) == NULL))
1139
        goto cleanup;
1140 1141 1142

    ret = 0;

1143
 cleanup:
1144 1145 1146

    virCapabilitiesFreeMachines(machines, nmachines);

1147
    return ret;
1148 1149 1150
}


1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170
virCPUDefPtr
virQEMUCapsProbeHostCPUForEmulator(virCapsPtr caps,
                                   virQEMUCapsPtr qemuCaps,
                                   virDomainVirtType type)
{
    size_t nmodels;
    char **models;
    virCPUDefPtr cpu;

    if (virQEMUCapsGetCPUDefinitions(qemuCaps, type, &models, &nmodels) < 0)
        return NULL;

    cpu = virCPUGetHost(caps->host.arch, VIR_CPU_TYPE_GUEST, NULL,
                        (const char **) models, nmodels);

    virStringListFreeCount(models, nmodels);
    return cpu;
}


1171
virCapsPtr virQEMUCapsInit(virQEMUCapsCachePtr cache)
1172 1173
{
    virCapsPtr caps;
1174
    size_t i;
T
Tal Kain 已提交
1175
    virArch hostarch = virArchFromHost();
1176

T
Tal Kain 已提交
1177
    if ((caps = virCapabilitiesNew(hostarch,
1178
                                   true, true)) == NULL)
1179
        goto error;
1180 1181 1182 1183 1184

    /* Some machines have problematic NUMA toplogy causing
     * unexpected failures. We don't want to break the QEMU
     * driver in this scenario, so log errors & carry on
     */
M
Martin Kletzander 已提交
1185
    if (virCapabilitiesInitNUMA(caps) < 0) {
1186
        virCapabilitiesFreeNUMAInfo(caps);
1187
        VIR_WARN("Failed to query host NUMA topology, disabling NUMA capabilities");
1188 1189
    }

1190 1191 1192
    if (virCapabilitiesInitCaches(caps) < 0)
        VIR_WARN("Failed to get host CPU cache info");

M
Martin Kletzander 已提交
1193
    if (!(caps->host.cpu = virCPUProbeHost(caps->host.arch)))
1194
        VIR_WARN("Failed to get host CPU");
1195

1196
    /* Add the power management features of the host */
1197
    if (virNodeSuspendGetTargetMask(&caps->host.powerMgmt) < 0)
1198 1199
        VIR_WARN("Failed to get host power management capabilities");

M
Michal Privoznik 已提交
1200
    /* Add huge pages info */
1201
    if (virCapabilitiesInitPages(caps) < 0)
M
Michal Privoznik 已提交
1202 1203
        VIR_WARN("Failed to get pages info");

1204 1205 1206
    /* Add domain migration transport URIs */
    virCapabilitiesAddHostMigrateTransport(caps, "tcp");
    virCapabilitiesAddHostMigrateTransport(caps, "rdma");
1207

1208 1209 1210 1211
    /* QEMU can support pretty much every arch that exists,
     * so just probe for them all - we gracefully fail
     * if a qemu-system-$ARCH binary can't be found
     */
1212
    for (i = 0; i < VIR_ARCH_LAST; i++)
1213
        if (virQEMUCapsInitGuest(caps, cache,
T
Tal Kain 已提交
1214
                                 hostarch,
1215
                                 i) < 0)
1216
            goto error;
1217 1218 1219

    return caps;

1220
 error:
1221
    virObjectUnref(caps);
1222 1223 1224 1225
    return NULL;
}


1226
static int
1227 1228 1229 1230
virQEMUCapsComputeCmdFlags(const char *help,
                           unsigned int version,
                           virQEMUCapsPtr qemuCaps,
                           bool check_yajl ATTRIBUTE_UNUSED)
1231 1232
{
    const char *p;
R
Richa Marwaha 已提交
1233
    const char *fsdev, *netdev;
1234
    const char *cache;
1235 1236

    if (strstr(help, "-no-kvm"))
1237
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_KVM);
1238
    if (strstr(help, "-enable-kvm"))
1239
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_ENABLE_KVM);
1240 1241
    if (strstr(help, ",process="))
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NAME_PROCESS);
1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256

    cache = strstr(help, "cache=");
    if (cache && (p = strchr(cache, ']'))) {
        if (memmem(cache, p - cache, "directsync", sizeof("directsync") - 1))
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC);
        if (memmem(cache, p - cache, "unsafe", sizeof("unsafe") - 1))
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_UNSAFE);
    }
    if (strstr(help, "aio=threads|native"))
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_AIO);
    if (strstr(help, "copy-on-read=on|off"))
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_COPY_ON_READ);
    if (strstr(help, "bps="))
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_IOTUNE);

P
Paolo Bonzini 已提交
1257 1258
    if (strstr(help, "-display"))
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DISPLAY);
1259 1260 1261
    if ((p = strstr(help, "-vga")) && !strstr(help, "-std-vga")) {
        const char *nl = strstr(p, "\n");
        if ((p = strstr(p, "|none")) && p < nl)
1262
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA_NONE);
1263 1264
    }
    if (strstr(help, "-spice"))
1265
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_SPICE);
1266
    if (strstr(help, "-vnc"))
1267
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC);
1268
    if (strstr(help, "seamless-migration="))
1269
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_SEAMLESS_MIGRATION);
1270
    if (strstr(help, "boot=on"))
1271
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_BOOT);
1272
    if (strstr(help, "serial=s"))
1273
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_SERIAL);
1274 1275
    if (strstr(help, "host=[seg:]bus"))
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_HOST_PCI_MULTIDOMAIN);
1276
    if (strstr(help, "-mem-path"))
1277
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MEM_PATH);
1278
    if (strstr(help, "-chardev")) {
1279
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV);
1280
        if (strstr(help, "-chardev spicevmc"))
1281
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC);
1282 1283
        if (strstr(help, "-chardev spiceport"))
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEPORT);
1284
    }
1285
    if (strstr(help, "-nodefconfig"))
1286
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NODEFCONFIG);
1287
    if (strstr(help, "-no-user-config"))
1288
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG);
1289 1290
    /* The trailing ' ' is important to avoid a bogus match */
    if (strstr(help, "-rtc "))
1291
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_RTC);
1292 1293
    /* to wit */
    if (strstr(help, "-rtc-td-hack"))
1294
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_RTC_TD_HACK);
1295
    if (strstr(help, "-no-hpet"))
1296
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_HPET);
1297
    if (strstr(help, "-no-acpi"))
1298
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_ACPI);
1299
    if (strstr(help, "-no-kvm-pit-reinjection"))
1300
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_KVM_PIT);
1301
    if (strstr(help, "-tdf"))
1302
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_TDF);
1303
    if (strstr(help, "-enable-nesting"))
1304
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NESTING);
1305
    if (strstr(help, ",menu=on"))
1306
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_BOOT_MENU);
1307
    if (strstr(help, ",reboot-timeout=rb_time"))
1308
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_REBOOT_TIMEOUT);
1309 1310
    if (strstr(help, ",splash-time=sp_time"))
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_SPLASH_TIMEOUT);
1311
    if ((fsdev = strstr(help, "-fsdev"))) {
1312
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV);
1313
        if (strstr(fsdev, "readonly"))
1314
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV_READONLY);
1315
        if (strstr(fsdev, "writeout"))
1316
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV_WRITEOUT);
1317
    }
1318
    if (strstr(help, "-smbios type"))
1319
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_SMBIOS_TYPE);
1320
    if (strstr(help, "-sandbox"))
1321
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_SECCOMP_SANDBOX);
1322

R
Richa Marwaha 已提交
1323
    if ((netdev = strstr(help, "-netdev"))) {
1324 1325
        /* Disable -netdev on 0.12 since although it exists,
         * the corresponding netdev_add/remove monitor commands
1326 1327
         * do not, and we need them to be able to do hotplug.
         * But see below about RHEL build. */
R
Richa Marwaha 已提交
1328 1329
        if (version >= 13000) {
            if (strstr(netdev, "bridge"))
1330
                virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV_BRIDGE);
1331
            virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV);
R
Richa Marwaha 已提交
1332
        }
1333 1334 1335
    }

    if (strstr(help, "-sdl"))
1336
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_SDL);
1337

1338
    if (strstr(help, ",vhost="))
1339
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_VHOST_NET);
1340

1341 1342
    /* Do not use -no-shutdown if qemu doesn't support it or SIGTERM handling
     * is most likely buggy when used with -no-shutdown (which applies for qemu
1343
     * 0.14.* and 0.15.0)
1344
     */
1345
    if (strstr(help, "-no-shutdown") && (version < 14000 || version > 15000))
1346
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_SHUTDOWN);
1347

1348
    if (strstr(help, "dump-guest-core=on|off"))
1349
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DUMP_GUEST_CORE);
1350

O
Olivia Yin 已提交
1351 1352 1353
    if (strstr(help, "-dtb"))
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DTB);

1354 1355 1356
    if (strstr(help, "-machine"))
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_OPT);

1357 1358 1359
    /* While JSON mode was available in 0.12.0, it was too
     * incomplete to contemplate using. The 0.13.0 release
     * is good enough to use, even though it lacks one or
1360 1361 1362 1363 1364
     * two features. This is also true of versions of qemu
     * built for RHEL, labeled 0.12.1, but with extra text
     * in the help output that mentions that features were
     * backported for libvirt. The benefits of JSON mode now
     * outweigh the downside.
1365
     */
1366
#if WITH_YAJL
1367
    if (version >= 13000) {
1368
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MONITOR_JSON);
1369 1370
    } else if (version >= 12000 &&
               strstr(help, "libvirt")) {
1371 1372
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MONITOR_JSON);
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV);
1373
    }
1374 1375 1376 1377 1378
#else
    /* Starting with qemu 0.15 and newer, upstream qemu no longer
     * promises to keep the human interface stable, but requests that
     * we use QMP (the JSON interface) for everything.  If the user
     * forgot to include YAJL libraries when building their own
M
Martin Kletzander 已提交
1379
     * libvirt but is targeting a newer qemu, we are better off
1380
     * telling them to recompile (the spec file includes the
1381
     * dependency, so distros won't hit this).  This check is
1382
     * also in m4/virt-yajl.m4 (see $with_yajl).  */
1383 1384 1385
    if (version >= 15000 ||
        (version >= 12000 && strstr(help, "libvirt"))) {
        if (check_yajl) {
1386 1387 1388
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("this qemu binary requires libvirt to be "
                             "compiled with yajl"));
1389 1390
            return -1;
        }
1391
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV);
1392
    }
E
Eric Blake 已提交
1393
#endif
1394 1395

    if (version >= 13000)
1396
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_PCI_MULTIFUNCTION);
1397

1398
    if (version >= 1001000) {
J
Ján Tomko 已提交
1399
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_IPV6_MIGRATION);
1400 1401
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC_SHARE_POLICY);
    }
J
Ján Tomko 已提交
1402

1403
    return 0;
1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429
}

/* We parse the output of 'qemu -help' to get the QEMU
 * version number. The first bit is easy, just parse
 * 'QEMU PC emulator version x.y.z'
 * or
 * 'QEMU emulator version x.y.z'.
 *
 * With qemu-kvm, however, that is followed by a string
 * in parenthesis as follows:
 *  - qemu-kvm-x.y.z in stable releases
 *  - kvm-XX for kvm versions up to kvm-85
 *  - qemu-kvm-devel-XX for kvm version kvm-86 and later
 *
 * For qemu-kvm versions before 0.10.z, we need to detect
 * the KVM version number for some features. With 0.10.z
 * and later, we just need the QEMU version number and
 * whether it is KVM QEMU or mainline QEMU.
 */
#define QEMU_VERSION_STR_1  "QEMU emulator version"
#define QEMU_VERSION_STR_2  "QEMU PC emulator version"
#define QEMU_KVM_VER_PREFIX "(qemu-kvm-"
#define KVM_VER_PREFIX      "(kvm-"

#define SKIP_BLANKS(p) do { while ((*(p) == ' ') || (*(p) == '\t')) (p)++; } while (0)

1430 1431 1432 1433
int virQEMUCapsParseHelpStr(const char *qemu,
                            const char *help,
                            virQEMUCapsPtr qemuCaps,
                            unsigned int *version,
1434
                            bool *is_kvm,
1435
                            unsigned int *kvm_version,
1436 1437
                            bool check_yajl,
                            const char *qmperr)
1438 1439 1440
{
    unsigned major, minor, micro;
    const char *p = help;
1441
    char *strflags;
1442

1443 1444
    *version = *kvm_version = 0;
    *is_kvm = false;
1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461

    if (STRPREFIX(p, QEMU_VERSION_STR_1))
        p += strlen(QEMU_VERSION_STR_1);
    else if (STRPREFIX(p, QEMU_VERSION_STR_2))
        p += strlen(QEMU_VERSION_STR_2);
    else
        goto fail;

    SKIP_BLANKS(p);

    major = virParseNumber(&p);
    if (major == -1 || *p != '.')
        goto fail;

    ++p;

    minor = virParseNumber(&p);
J
Jiri Denemark 已提交
1462
    if (minor == -1)
1463 1464
        goto fail;

J
Jiri Denemark 已提交
1465 1466 1467 1468 1469 1470 1471 1472
    if (*p != '.') {
        micro = 0;
    } else {
        ++p;
        micro = virParseNumber(&p);
        if (micro == -1)
            goto fail;
    }
1473 1474 1475 1476

    SKIP_BLANKS(p);

    if (STRPREFIX(p, QEMU_KVM_VER_PREFIX)) {
1477
        *is_kvm = true;
1478 1479 1480 1481
        p += strlen(QEMU_KVM_VER_PREFIX);
    } else if (STRPREFIX(p, KVM_VER_PREFIX)) {
        int ret;

1482
        *is_kvm = true;
1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493
        p += strlen(KVM_VER_PREFIX);

        ret = virParseNumber(&p);
        if (ret == -1)
            goto fail;

        *kvm_version = ret;
    }

    *version = (major * 1000 * 1000) + (minor * 1000) + micro;

1494 1495 1496 1497 1498 1499 1500
    if (*version < 12000) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("QEMU version >= 0.12.00 is required, but %d.%d.%d found"),
                       major, minor, micro);
        goto cleanup;
    }

1501 1502 1503 1504
    /* Refuse to parse -help output for QEMU releases >= 1.2.0 that should be
     * using QMP probing.
     */
    if (*version >= 1002000) {
1505 1506 1507 1508 1509 1510 1511 1512 1513
        if (qmperr && *qmperr) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("QEMU / QMP failed: %s"),
                           qmperr);
        } else {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("QEMU %u.%u.%u is too new for help parsing"),
                           major, minor, micro);
        }
1514 1515 1516
        goto cleanup;
    }

1517
    if (virQEMUCapsComputeCmdFlags(help, *version,
1518
                                   qemuCaps, check_yajl) < 0)
1519
        goto cleanup;
1520

1521
    strflags = virBitmapString(qemuCaps->flags);
1522 1523 1524
    VIR_DEBUG("Version %u.%u.%u, cooked version %u, flags %s",
              major, minor, micro, *version, NULLSTR(strflags));
    VIR_FREE(strflags);
1525 1526 1527 1528 1529 1530 1531 1532

    if (*kvm_version)
        VIR_DEBUG("KVM version %d detected", *kvm_version);
    else if (*is_kvm)
        VIR_DEBUG("qemu-kvm version %u.%u.%u detected", major, minor, micro);

    return 0;

1533
 fail:
1534
    p = strchr(help, '\n');
1535 1536
    if (!p)
        p = strchr(help, '\0');
1537

1538 1539 1540
    virReportError(VIR_ERR_INTERNAL_ERROR,
                   _("cannot parse %s version number in '%.*s'"),
                   qemu, (int) (p - help), help);
1541

1542
 cleanup:
1543 1544 1545
    return -1;
}

1546

1547
struct virQEMUCapsStringFlags {
1548 1549 1550 1551 1552
    const char *value;
    int flag;
};


1553 1554 1555
struct virQEMUCapsStringFlags virQEMUCapsCommands[] = {
    { "system_wakeup", QEMU_CAPS_WAKEUP },
    { "transaction", QEMU_CAPS_TRANSACTION },
1556 1557
    { "block_stream", QEMU_CAPS_BLOCKJOB_SYNC },
    { "block-stream", QEMU_CAPS_BLOCKJOB_ASYNC },
1558 1559 1560 1561 1562 1563 1564 1565 1566
    { "dump-guest-memory", QEMU_CAPS_DUMP_GUEST_MEMORY },
    { "query-spice", QEMU_CAPS_SPICE },
    { "query-kvm", QEMU_CAPS_KVM },
    { "block-commit", QEMU_CAPS_BLOCK_COMMIT },
    { "query-vnc", QEMU_CAPS_VNC },
    { "drive-mirror", QEMU_CAPS_DRIVE_MIRROR },
    { "blockdev-snapshot-sync", QEMU_CAPS_DISK_SNAPSHOT },
    { "add-fd", QEMU_CAPS_ADD_FD },
    { "nbd-server-start", QEMU_CAPS_NBD_SERVER },
1567
    { "change-backing-file", QEMU_CAPS_CHANGE_BACKING_FILE },
1568
    { "rtc-reset-reinjection", QEMU_CAPS_RTC_RESET_REINJECTION },
1569
    { "migrate-incoming", QEMU_CAPS_INCOMING_DEFER },
1570
    { "query-hotpluggable-cpus", QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS },
1571 1572
    { "query-qmp-schema", QEMU_CAPS_QUERY_QMP_SCHEMA },
    { "query-cpu-model-expansion", QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION},
1573
    { "query-cpu-definitions", QEMU_CAPS_QUERY_CPU_DEFINITIONS},
1574
    { "query-named-block-nodes", QEMU_CAPS_QUERY_NAMED_BLOCK_NODES}
1575 1576
};

1577 1578 1579 1580
struct virQEMUCapsStringFlags virQEMUCapsMigration[] = {
    { "rdma-pin-all", QEMU_CAPS_MIGRATE_RDMA },
};

1581 1582 1583
struct virQEMUCapsStringFlags virQEMUCapsEvents[] = {
    { "BALLOON_CHANGE", QEMU_CAPS_BALLOON_EVENT },
    { "SPICE_MIGRATE_COMPLETED", QEMU_CAPS_SEAMLESS_MIGRATION },
1584
    { "DEVICE_DELETED", QEMU_CAPS_DEVICE_DEL_EVENT },
1585
    { "MIGRATION", QEMU_CAPS_MIGRATION_EVENT },
1586
    { "VSERPORT_CHANGE", QEMU_CAPS_VSERPORT_CHANGE },
1587
    { "DEVICE_TRAY_MOVED", QEMU_CAPS_DEVICE_TRAY_MOVED },
1588
    { "BLOCK_WRITE_THRESHOLD", QEMU_CAPS_BLOCK_WRITE_THRESHOLD },
1589 1590
};

1591
struct virQEMUCapsStringFlags virQEMUCapsObjectTypes[] = {
1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606
    { "hda-duplex", QEMU_CAPS_HDA_DUPLEX },
    { "hda-micro", QEMU_CAPS_HDA_MICRO },
    { "ccid-card-emulated", QEMU_CAPS_CCID_EMULATED },
    { "ccid-card-passthru", QEMU_CAPS_CCID_PASSTHRU },
    { "piix3-usb-uhci", QEMU_CAPS_PIIX3_USB_UHCI },
    { "piix4-usb-uhci", QEMU_CAPS_PIIX4_USB_UHCI },
    { "usb-ehci", QEMU_CAPS_USB_EHCI },
    { "ich9-usb-ehci1", QEMU_CAPS_ICH9_USB_EHCI1 },
    { "vt82c686b-usb-uhci", QEMU_CAPS_VT82C686B_USB_UHCI },
    { "pci-ohci", QEMU_CAPS_PCI_OHCI },
    { "nec-usb-xhci", QEMU_CAPS_NEC_USB_XHCI },
    { "usb-redir", QEMU_CAPS_USB_REDIR },
    { "usb-hub", QEMU_CAPS_USB_HUB },
    { "ich9-ahci", QEMU_CAPS_ICH9_AHCI },
    { "virtio-blk-s390", QEMU_CAPS_VIRTIO_S390 },
1607
    { "virtio-blk-ccw", QEMU_CAPS_VIRTIO_CCW },
1608
    { "sclpconsole", QEMU_CAPS_SCLP_S390 },
1609
    { "lsi53c895a", QEMU_CAPS_SCSI_LSI },
1610
    { "virtio-scsi-pci", QEMU_CAPS_VIRTIO_SCSI },
1611 1612
    { "virtio-scsi-s390", QEMU_CAPS_VIRTIO_SCSI },
    { "virtio-scsi-ccw", QEMU_CAPS_VIRTIO_SCSI },
1613
    { "virtio-scsi-device", QEMU_CAPS_VIRTIO_SCSI },
1614
    { "megasas", QEMU_CAPS_SCSI_MEGASAS },
1615
    { "spicevmc", QEMU_CAPS_DEVICE_SPICEVMC },
1616
    { "qxl", QEMU_CAPS_DEVICE_QXL },
1617 1618 1619 1620
    { "sga", QEMU_CAPS_SGA },
    { "scsi-block", QEMU_CAPS_SCSI_BLOCK },
    { "scsi-cd", QEMU_CAPS_SCSI_CD },
    { "ide-cd", QEMU_CAPS_IDE_CD },
1621 1622 1623
    { "VGA", QEMU_CAPS_DEVICE_VGA },
    { "cirrus-vga", QEMU_CAPS_DEVICE_CIRRUS_VGA },
    { "vmware-svga", QEMU_CAPS_DEVICE_VMWARE_SVGA },
H
Han Cheng 已提交
1624 1625
    { "usb-serial", QEMU_CAPS_DEVICE_USB_SERIAL },
    { "usb-net", QEMU_CAPS_DEVICE_USB_NET },
1626
    { "virtio-rng-pci", QEMU_CAPS_DEVICE_VIRTIO_RNG },
1627 1628
    { "virtio-rng-s390", QEMU_CAPS_DEVICE_VIRTIO_RNG },
    { "virtio-rng-ccw", QEMU_CAPS_DEVICE_VIRTIO_RNG },
1629
    { "virtio-rng-device", QEMU_CAPS_DEVICE_VIRTIO_RNG },
1630
    { "rng-random", QEMU_CAPS_OBJECT_RNG_RANDOM },
1631
    { "rng-egd", QEMU_CAPS_OBJECT_RNG_EGD },
1632
    { "spapr-nvram", QEMU_CAPS_DEVICE_NVRAM },
1633
    { "pci-bridge", QEMU_CAPS_DEVICE_PCI_BRIDGE },
1634
    { "vfio-pci", QEMU_CAPS_DEVICE_VFIO_PCI },
H
Han Cheng 已提交
1635
    { "scsi-generic", QEMU_CAPS_DEVICE_SCSI_GENERIC },
1636
    { "i82801b11-bridge", QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE },
1637
    { "usb-storage", QEMU_CAPS_DEVICE_USB_STORAGE },
1638
    { "virtio-mmio", QEMU_CAPS_DEVICE_VIRTIO_MMIO },
1639
    { "ich9-intel-hda", QEMU_CAPS_DEVICE_ICH9_INTEL_HDA },
H
Hu Tao 已提交
1640
    { "pvpanic", QEMU_CAPS_DEVICE_PANIC },
L
Li Zhang 已提交
1641
    { "usb-kbd", QEMU_CAPS_DEVICE_USB_KBD },
1642
    { "memory-backend-ram", QEMU_CAPS_OBJECT_MEMORY_RAM },
1643
    { "memory-backend-file", QEMU_CAPS_OBJECT_MEMORY_FILE },
1644
    { "usb-audio", QEMU_CAPS_OBJECT_USB_AUDIO },
J
John Ferlan 已提交
1645
    { "iothread", QEMU_CAPS_OBJECT_IOTHREAD},
1646
    { "ivshmem", QEMU_CAPS_DEVICE_IVSHMEM },
1647
    { "pc-dimm", QEMU_CAPS_DEVICE_PC_DIMM },
M
Michal Privoznik 已提交
1648
    { "pci-serial", QEMU_CAPS_DEVICE_PCI_SERIAL },
1649
    { "gpex-pcihost", QEMU_CAPS_OBJECT_GPEX},
1650
    { "ioh3420", QEMU_CAPS_DEVICE_IOH3420 },
1651
    { "x3130-upstream", QEMU_CAPS_DEVICE_X3130_UPSTREAM },
1652
    { "xio3130-downstream", QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM },
1653
    { "rtl8139", QEMU_CAPS_DEVICE_RTL8139 },
1654
    { "e1000", QEMU_CAPS_DEVICE_E1000 },
1655 1656 1657 1658
    { "virtio-net-pci", QEMU_CAPS_DEVICE_VIRTIO_NET },
    { "virtio-net-ccw", QEMU_CAPS_DEVICE_VIRTIO_NET },
    { "virtio-net-s390", QEMU_CAPS_DEVICE_VIRTIO_NET },
    { "virtio-net-device", QEMU_CAPS_DEVICE_VIRTIO_NET },
M
Marc-André Lureau 已提交
1659 1660
    { "virtio-gpu-pci", QEMU_CAPS_DEVICE_VIRTIO_GPU },
    { "virtio-gpu-device", QEMU_CAPS_DEVICE_VIRTIO_GPU },
1661
    { "virtio-vga", QEMU_CAPS_DEVICE_VIRTIO_VGA },
1662 1663 1664 1665 1666 1667
    { "virtio-keyboard-device", QEMU_CAPS_VIRTIO_KEYBOARD },
    { "virtio-keyboard-pci", QEMU_CAPS_VIRTIO_KEYBOARD },
    { "virtio-mouse-device", QEMU_CAPS_VIRTIO_MOUSE },
    { "virtio-mouse-pci", QEMU_CAPS_VIRTIO_MOUSE },
    { "virtio-tablet-device", QEMU_CAPS_VIRTIO_TABLET },
    { "virtio-tablet-pci", QEMU_CAPS_VIRTIO_TABLET },
1668 1669
    { "virtio-input-host-device", QEMU_CAPS_VIRTIO_INPUT_HOST },
    { "virtio-input-host-pci", QEMU_CAPS_VIRTIO_INPUT_HOST },
1670
    { "mptsas1068", QEMU_CAPS_SCSI_MPTSAS1068 },
1671
    { "secret", QEMU_CAPS_OBJECT_SECRET },
1672
    { "pxb", QEMU_CAPS_DEVICE_PXB },
1673
    { "pxb-pcie", QEMU_CAPS_DEVICE_PXB_PCIE },
1674
    { "tls-creds-x509", QEMU_CAPS_OBJECT_TLS_CREDS_X509 },
J
Ján Tomko 已提交
1675
    { "intel-iommu", QEMU_CAPS_DEVICE_INTEL_IOMMU },
1676 1677
    { "ivshmem-plain", QEMU_CAPS_DEVICE_IVSHMEM_PLAIN },
    { "ivshmem-doorbell", QEMU_CAPS_DEVICE_IVSHMEM_DOORBELL },
1678
    { "vhost-scsi", QEMU_CAPS_DEVICE_VHOST_SCSI },
1679
    { "nvdimm", QEMU_CAPS_DEVICE_NVDIMM },
1680
    { "pcie-root-port", QEMU_CAPS_DEVICE_PCIE_ROOT_PORT },
1681
    { "qemu-xhci", QEMU_CAPS_DEVICE_QEMU_XHCI },
1682 1683
};

1684 1685 1686 1687
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsVirtioBalloon[] = {
    { "deflate-on-oom", QEMU_CAPS_VIRTIO_BALLOON_AUTODEFLATE },
};

1688
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsVirtioBlk[] = {
1689 1690 1691 1692 1693 1694 1695 1696
    { "multifunction", QEMU_CAPS_PCI_MULTIFUNCTION },
    { "bootindex", QEMU_CAPS_BOOTINDEX },
    { "ioeventfd", QEMU_CAPS_VIRTIO_IOEVENTFD },
    { "event_idx", QEMU_CAPS_VIRTIO_BLK_EVENT_IDX },
    { "scsi", QEMU_CAPS_VIRTIO_BLK_SCSI },
    { "logical_block_size", QEMU_CAPS_BLOCKIO },
};

1697
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsVirtioNet[] = {
1698 1699
    { "tx", QEMU_CAPS_VIRTIO_TX_ALG },
    { "event_idx", QEMU_CAPS_VIRTIO_NET_EVENT_IDX },
1700
    { "rx_queue_size", QEMU_CAPS_VIRTIO_NET_RX_QUEUE_SIZE },
1701
    { "host_mtu", QEMU_CAPS_VIRTIO_NET_HOST_MTU },
1702 1703
};

1704 1705 1706 1707
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsVirtioSCSI[] = {
    { "iothread", QEMU_CAPS_VIRTIO_SCSI_IOTHREAD },
};

1708
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsPCIAssign[] = {
1709 1710 1711 1712
    { "configfd", QEMU_CAPS_PCI_CONFIGFD },
    { "bootindex", QEMU_CAPS_PCI_BOOTINDEX },
};

1713
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsVfioPCI[] = {
1714 1715 1716
    { "bootindex", QEMU_CAPS_VFIO_PCI_BOOTINDEX },
};

1717
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsSCSIDisk[] = {
1718 1719 1720 1721
    { "channel", QEMU_CAPS_SCSI_DISK_CHANNEL },
    { "wwn", QEMU_CAPS_SCSI_DISK_WWN },
};

1722
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsIDEDrive[] = {
1723 1724 1725
    { "wwn", QEMU_CAPS_IDE_DRIVE_WWN },
};

1726
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsPiix4PM[] = {
1727 1728
    { "disable_s3", QEMU_CAPS_PIIX_DISABLE_S3 },
    { "disable_s4", QEMU_CAPS_PIIX_DISABLE_S4 },
1729 1730
};

1731
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsUSBRedir[] = {
1732
    { "filter", QEMU_CAPS_USB_REDIR_FILTER },
1733 1734 1735
    { "bootindex", QEMU_CAPS_USB_REDIR_BOOTINDEX },
};

1736
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsUSBHost[] = {
1737
    { "bootindex", QEMU_CAPS_USB_HOST_BOOTINDEX },
1738 1739
};

1740
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsSCSIGeneric[] = {
H
Han Cheng 已提交
1741 1742 1743
    { "bootindex", QEMU_CAPS_DEVICE_SCSI_GENERIC_BOOTINDEX },
};

1744
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsI440FXPCIHost[] = {
1745 1746 1747
    { "pci-hole64-size", QEMU_CAPS_I440FX_PCI_HOLE64_SIZE },
};

1748
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsQ35PCIHost[] = {
1749 1750 1751
    { "pci-hole64-size", QEMU_CAPS_Q35_PCI_HOLE64_SIZE },
};

1752
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsUSBStorage[] = {
1753 1754 1755
    { "removable", QEMU_CAPS_USB_STORAGE_REMOVABLE },
};

1756 1757 1758 1759
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsKVMPit[] = {
    { "lost_tick_policy", QEMU_CAPS_KVM_PIT_TICK_POLICY },
};

1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsVGA[] = {
    { "vgamem_mb", QEMU_CAPS_VGA_VGAMEM },
};

static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsVmwareSvga[] = {
    { "vgamem_mb", QEMU_CAPS_VMWARE_SVGA_VGAMEM },
};

static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsQxl[] = {
    { "vgamem_mb", QEMU_CAPS_QXL_VGAMEM },
1770
    { "vram64_size_mb", QEMU_CAPS_QXL_VRAM64 },
1771
    { "max_outputs", QEMU_CAPS_QXL_MAX_OUTPUTS },
1772 1773
};

1774
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsVirtioGpu[] = {
1775
    { "virgl", QEMU_CAPS_VIRTIO_GPU_VIRGL },
1776 1777
};

1778 1779 1780 1781 1782
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsICH9[] = {
    { "disable_s3", QEMU_CAPS_ICH9_DISABLE_S3 },
    { "disable_s4", QEMU_CAPS_ICH9_DISABLE_S4 },
};

1783 1784 1785 1786
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsUSBNECXHCI[] = {
    { "p3", QEMU_CAPS_NEC_USB_XHCI_PORTS },
};

1787 1788
static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsIntelIOMMU[] = {
    { "intremap", QEMU_CAPS_INTEL_IOMMU_INTREMAP },
1789
    { "caching-mode", QEMU_CAPS_INTEL_IOMMU_CACHING_MODE },
1790
    { "eim", QEMU_CAPS_INTEL_IOMMU_EIM },
1791
    { "device-iotlb", QEMU_CAPS_INTEL_IOMMU_DEVICE_IOTLB },
1792 1793
};

1794 1795
/* see documentation for virQEMUCapsQMPSchemaGetByPath for the query format */
static struct virQEMUCapsStringFlags virQEMUCapsQMPSchemaQueries[] = {
1796
    { "blockdev-add/arg-type/options/+gluster/debug-level", QEMU_CAPS_GLUSTER_DEBUG_LEVEL},
1797
    { "blockdev-add/arg-type/+gluster/debug", QEMU_CAPS_GLUSTER_DEBUG_LEVEL},
1798 1799
};

1800
struct virQEMUCapsObjectTypeProps {
1801
    const char *type;
1802
    struct virQEMUCapsStringFlags *props;
1803
    size_t nprops;
1804
    int capsCondition;
1805 1806
};

1807 1808
static struct virQEMUCapsObjectTypeProps virQEMUCapsObjectProps[] = {
    { "virtio-blk-pci", virQEMUCapsObjectPropsVirtioBlk,
1809 1810
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioBlk),
      -1 },
1811
    { "virtio-net-pci", virQEMUCapsObjectPropsVirtioNet,
1812 1813
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioNet),
      -1 },
1814
    { "virtio-scsi-pci", virQEMUCapsObjectPropsVirtioSCSI,
1815 1816
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioSCSI),
      -1 },
1817
    { "virtio-blk-ccw", virQEMUCapsObjectPropsVirtioBlk,
1818 1819
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioBlk),
      -1 },
1820
    { "virtio-net-ccw", virQEMUCapsObjectPropsVirtioNet,
1821 1822
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioNet),
      -1 },
1823
    { "virtio-scsi-ccw", virQEMUCapsObjectPropsVirtioSCSI,
1824 1825
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioSCSI),
      -1 },
1826
    { "virtio-blk-s390", virQEMUCapsObjectPropsVirtioBlk,
1827 1828
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioBlk),
      -1 },
1829
    { "virtio-net-s390", virQEMUCapsObjectPropsVirtioNet,
1830 1831
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioNet),
      -1 },
1832
    { "pci-assign", virQEMUCapsObjectPropsPCIAssign,
1833 1834
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsPCIAssign),
      -1 },
1835
    { "kvm-pci-assign", virQEMUCapsObjectPropsPCIAssign,
1836 1837
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsPCIAssign),
      -1 },
1838
    { "vfio-pci", virQEMUCapsObjectPropsVfioPCI,
1839 1840
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVfioPCI),
      -1 },
1841
    { "scsi-disk", virQEMUCapsObjectPropsSCSIDisk,
1842 1843
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsSCSIDisk),
      -1 },
1844
    { "ide-drive", virQEMUCapsObjectPropsIDEDrive,
1845 1846
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsIDEDrive),
      -1 },
1847
    { "PIIX4_PM", virQEMUCapsObjectPropsPiix4PM,
1848 1849
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsPiix4PM),
      -1 },
1850
    { "usb-redir", virQEMUCapsObjectPropsUSBRedir,
1851 1852
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsUSBRedir),
      -1 },
1853
    { "usb-host", virQEMUCapsObjectPropsUSBHost,
1854 1855
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsUSBHost),
      -1 },
1856
    { "scsi-generic", virQEMUCapsObjectPropsSCSIGeneric,
1857 1858
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsSCSIGeneric),
      -1 },
1859
    { "i440FX-pcihost", virQEMUCapsObjectPropsI440FXPCIHost,
1860 1861
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsI440FXPCIHost),
      -1 },
1862
    { "q35-pcihost", virQEMUCapsObjectPropsQ35PCIHost,
1863 1864
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsQ35PCIHost),
      -1 },
1865
    { "usb-storage", virQEMUCapsObjectPropsUSBStorage,
1866 1867
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsUSBStorage),
      -1 },
1868
    { "kvm-pit", virQEMUCapsObjectPropsKVMPit,
1869 1870
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsKVMPit),
      -1 },
1871
    { "VGA", virQEMUCapsObjectPropsVGA,
1872 1873
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVGA),
      -1 },
1874
    { "vmware-svga", virQEMUCapsObjectPropsVmwareSvga,
1875 1876
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVmwareSvga),
      -1 },
1877
    { "qxl", virQEMUCapsObjectPropsQxl,
1878 1879
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsQxl),
      -1 },
1880
    { "virtio-gpu-pci", virQEMUCapsObjectPropsVirtioGpu,
1881 1882
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioGpu),
      -1 },
1883
    { "virtio-gpu-device", virQEMUCapsObjectPropsVirtioGpu,
1884 1885
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioGpu),
      -1 },
1886
    { "ICH9-LPC", virQEMUCapsObjectPropsICH9,
1887 1888
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsICH9),
      -1 },
1889
    { "virtio-balloon-pci", virQEMUCapsObjectPropsVirtioBalloon,
1890 1891
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioBalloon),
      -1 },
1892
    { "virtio-balloon-ccw", virQEMUCapsObjectPropsVirtioBalloon,
1893 1894
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioBalloon),
      -1 },
1895
    { "virtio-balloon-device", virQEMUCapsObjectPropsVirtioBalloon,
1896 1897
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioBalloon),
      -1 },
1898
    { "nec-usb-xhci", virQEMUCapsObjectPropsUSBNECXHCI,
1899 1900
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsUSBNECXHCI),
      -1 },
1901 1902 1903
    { "intel-iommu", virQEMUCapsObjectPropsIntelIOMMU,
      ARRAY_CARDINALITY(virQEMUCapsObjectPropsIntelIOMMU),
      QEMU_CAPS_DEVICE_INTEL_IOMMU},
1904 1905
};

1906 1907 1908 1909 1910 1911
struct virQEMUCapsPropTypeObjects {
    const char *prop;
    int flag;
    const char **objects;
};

1912
static const char *virQEMUCapsVirtioPCIObjects[] = {
1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930
     "virtio-balloon-pci",
     "virtio-blk-pci",
     "virtio-scsi-pci",
     "virtio-serial-pci",
     "virtio-9p-pci",
     "virtio-net-pci",
     "virtio-rng-pci",
     "virtio-gpu-pci",
     "virtio-input-host-pci",
     "virtio-keyboard-pci",
     "virtio-mouse-pci",
     "virtio-tablet-pci",
     NULL
};

static struct virQEMUCapsPropTypeObjects virQEMUCapsPropObjects[] = {
    { "disable-legacy",
      QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
1931 1932 1933 1934 1935 1936 1937
      virQEMUCapsVirtioPCIObjects },
    { "iommu_platform",
      QEMU_CAPS_VIRTIO_PCI_IOMMU_PLATFORM,
      virQEMUCapsVirtioPCIObjects },
    { "ats",
      QEMU_CAPS_VIRTIO_PCI_ATS,
      virQEMUCapsVirtioPCIObjects },
1938 1939
};

1940 1941

static void
1942 1943 1944 1945 1946
virQEMUCapsProcessStringFlags(virQEMUCapsPtr qemuCaps,
                              size_t nflags,
                              struct virQEMUCapsStringFlags *flags,
                              size_t nvalues,
                              char *const*values)
1947 1948
{
    size_t i, j;
1949 1950
    for (i = 0; i < nflags; i++) {
        for (j = 0; j < nvalues; j++) {
1951
            if (STREQ(values[j], flags[i].value)) {
1952
                virQEMUCapsSet(qemuCaps, flags[i].flag);
1953 1954 1955 1956 1957 1958 1959
                break;
            }
        }
    }
}


1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975
static void
virQEMUCapsProcessProps(virQEMUCapsPtr qemuCaps,
                        size_t nprops,
                        struct virQEMUCapsPropTypeObjects *props,
                        const char *object,
                        size_t nvalues,
                        char *const*values)
{
    size_t i, j;

    for (i = 0; i < nprops; i++) {
        if (virQEMUCapsGet(qemuCaps, props[i].flag))
            continue;

        for (j = 0; j < nvalues; j++) {
            if (STREQ(values[j], props[i].prop)) {
1976
                if (virStringListHasString(props[i].objects, object))
1977 1978 1979 1980 1981 1982 1983 1984
                    virQEMUCapsSet(qemuCaps, props[i].flag);
                break;
            }
        }
    }
}


1985 1986 1987
#define OBJECT_TYPE_PREFIX "name \""

static int
1988 1989
virQEMUCapsParseDeviceStrObjectTypes(const char *str,
                                     char ***types)
1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007
{
    const char *tmp = str;
    int ret = -1;
    size_t ntypelist = 0;
    char **typelist = NULL;

    *types = NULL;

    while ((tmp = strstr(tmp, OBJECT_TYPE_PREFIX))) {
        char *end;
        tmp += strlen(OBJECT_TYPE_PREFIX);
        end = strstr(tmp, "\"");
        if (!end) {
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("Malformed QEMU device list string, missing quote"));
            goto cleanup;
        }

2008
        if (VIR_EXPAND_N(typelist, ntypelist, 1) < 0)
2009
            goto cleanup;
2010
        if (VIR_STRNDUP(typelist[ntypelist - 1], tmp, end-tmp) < 0)
2011 2012 2013 2014 2015 2016
            goto cleanup;
    }

    *types = typelist;
    ret = ntypelist;

2017
 cleanup:
2018
    if (ret < 0)
2019
        virStringListFreeCount(typelist, ntypelist);
2020 2021 2022 2023 2024
    return ret;
}


static int
2025 2026 2027
virQEMUCapsParseDeviceStrObjectProps(const char *str,
                                     const char *type,
                                     char ***props)
2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060
{
    const char *tmp = str;
    int ret = -1;
    size_t nproplist = 0;
    char **proplist = NULL;

    VIR_DEBUG("Extract type %s", type);
    *props = NULL;

    while ((tmp = strchr(tmp, '\n'))) {
        char *end;
        tmp += 1;

        if (*tmp == '\0')
            break;

        if (STRPREFIX(tmp, OBJECT_TYPE_PREFIX))
            continue;

        if (!STRPREFIX(tmp, type))
            continue;

        tmp += strlen(type);
        if (*tmp != '.')
            continue;
        tmp++;

        end = strstr(tmp, "=");
        if (!end) {
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("Malformed QEMU device list string, missing '='"));
            goto cleanup;
        }
2061
        if (VIR_EXPAND_N(proplist, nproplist, 1) < 0)
2062
            goto cleanup;
2063
        if (VIR_STRNDUP(proplist[nproplist - 1], tmp, end-tmp) < 0)
2064 2065 2066 2067 2068 2069
            goto cleanup;
    }

    *props = proplist;
    ret = nproplist;

2070
 cleanup:
2071
    if (ret < 0)
2072
        virStringListFreeCount(proplist, nproplist);
2073 2074 2075 2076 2077
    return ret;
}


int
2078
virQEMUCapsParseDeviceStr(virQEMUCapsPtr qemuCaps, const char *str)
2079 2080 2081 2082 2083
{
    int nvalues;
    char **values;
    size_t i;

2084
    if ((nvalues = virQEMUCapsParseDeviceStrObjectTypes(str, &values)) < 0)
2085
        return -1;
2086 2087 2088 2089
    virQEMUCapsProcessStringFlags(qemuCaps,
                                  ARRAY_CARDINALITY(virQEMUCapsObjectTypes),
                                  virQEMUCapsObjectTypes,
                                  nvalues, values);
2090
    virStringListFreeCount(values, nvalues);
2091

2092
    for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsObjectProps); i++) {
2093 2094 2095 2096
        const char *type = virQEMUCapsObjectProps[i].type;
        if ((nvalues = virQEMUCapsParseDeviceStrObjectProps(str,
                                                            type,
                                                            &values)) < 0)
2097
            return -1;
2098 2099 2100 2101
        virQEMUCapsProcessStringFlags(qemuCaps,
                                      virQEMUCapsObjectProps[i].nprops,
                                      virQEMUCapsObjectProps[i].props,
                                      nvalues, values);
2102
        virStringListFreeCount(values, nvalues);
2103 2104 2105
    }

    /* Prefer -chardev spicevmc (detected earlier) over -device spicevmc */
2106 2107
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC))
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC);
2108 2109 2110 2111 2112

    return 0;
}


E
Eric Blake 已提交
2113
static int
2114 2115
virQEMUCapsExtractDeviceStr(const char *qemu,
                            virQEMUCapsPtr qemuCaps,
2116
                            uid_t runUid, gid_t runGid)
2117
{
E
Eric Blake 已提交
2118
    char *output = NULL;
2119
    virCommandPtr cmd;
E
Eric Blake 已提交
2120
    int ret = -1;
2121

E
Eric Blake 已提交
2122 2123
    /* Cram together all device-related queries into one invocation;
     * the output format makes it possible to distinguish what we
2124 2125
     * need.  With qemu 0.13.0 and later, unrecognized '-device
     * bogus,?' cause an error in isolation, but are silently ignored
2126
     * in combination with '-device ?'.  Upstream qemu 0.12.x doesn't
2127 2128
     * understand '-device name,?', and always exits with status 1 for
     * the simpler '-device ?', so this function is really only useful
2129
     * if -help includes "device driver,?".  */
2130
    cmd = virQEMUCapsProbeCommand(qemu, qemuCaps, runUid, runGid);
2131 2132 2133 2134 2135 2136
    virCommandAddArgList(cmd,
                         "-device", "?",
                         "-device", "pci-assign,?",
                         "-device", "virtio-blk-pci,?",
                         "-device", "virtio-net-pci,?",
                         "-device", "scsi-disk,?",
2137
                         "-device", "PIIX4_PM,?",
2138
                         "-device", "usb-redir,?",
2139
                         "-device", "ide-drive,?",
2140
                         "-device", "usb-host,?",
H
Han Cheng 已提交
2141
                         "-device", "scsi-generic,?",
2142
                         "-device", "usb-storage,?",
2143 2144 2145 2146
                         "-device", "VGA,?",
                         "-device", "vmware-svga,?",
                         "-device", "qxl,?",
                         "-device", "qxl-vga,?",
2147
                         NULL);
2148
    /* qemu -help goes to stdout, but qemu -device ? goes to stderr.  */
E
Eric Blake 已提交
2149
    virCommandSetErrorBuffer(cmd, &output);
2150

2151
    if (virCommandRun(cmd, NULL) < 0)
2152 2153
        goto cleanup;

2154
    ret = virQEMUCapsParseDeviceStr(qemuCaps, output);
2155

2156
 cleanup:
E
Eric Blake 已提交
2157
    VIR_FREE(output);
2158
    virCommandFree(cmd);
E
Eric Blake 已提交
2159 2160 2161
    return ret;
}

2162

2163 2164 2165
int virQEMUCapsGetDefaultVersion(virCapsPtr caps,
                                 virQEMUCapsCachePtr capsCache,
                                 unsigned int *version)
2166
{
2167
    virQEMUCapsPtr qemucaps;
T
Tal Kain 已提交
2168
    virArch hostarch;
2169
    virCapsDomainDataPtr capsdata;
2170 2171 2172 2173

    if (*version > 0)
        return 0;

T
Tal Kain 已提交
2174
    hostarch = virArchFromHost();
2175 2176 2177
    if (!(capsdata = virCapabilitiesDomainDataLookup(caps,
            VIR_DOMAIN_OSTYPE_HVM, hostarch, VIR_DOMAIN_VIRT_QEMU,
            NULL, NULL))) {
2178
        virReportError(VIR_ERR_INTERNAL_ERROR,
2179
                       _("Cannot find suitable emulator for %s"),
T
Tal Kain 已提交
2180
                       virArchToString(hostarch));
2181 2182 2183
        return -1;
    }

2184
    qemucaps = virQEMUCapsCacheLookup(caps, capsCache, capsdata->emulator);
2185 2186
    VIR_FREE(capsdata);
    if (!qemucaps)
2187 2188
        return -1;

2189
    *version = virQEMUCapsGetVersion(qemucaps);
2190
    virObjectUnref(qemucaps);
2191 2192
    return 0;
}
2193 2194


2195 2196


2197 2198
virQEMUCapsPtr
virQEMUCapsNew(void)
2199
{
2200
    virQEMUCapsPtr qemuCaps;
2201

2202
    if (virQEMUCapsInitialize() < 0)
2203 2204
        return NULL;

2205
    if (!(qemuCaps = virObjectNew(virQEMUCapsClass)))
2206 2207
        return NULL;

2208
    if (!(qemuCaps->flags = virBitmapNew(QEMU_CAPS_LAST)))
2209
        goto error;
2210

2211
    return qemuCaps;
2212

2213
 error:
2214
    virObjectUnref(qemuCaps);
2215
    return NULL;
2216 2217 2218
}


2219
static int
2220 2221
virQEMUCapsHostCPUDataCopy(virQEMUCapsHostCPUDataPtr dst,
                           virQEMUCapsHostCPUDataPtr src)
2222
{
2223 2224
    if (src->info &&
        !(dst->info = qemuMonitorCPUModelInfoCopy(src->info)))
2225 2226
        return -1;

2227 2228
    if (src->reported &&
        !(dst->reported = virCPUDefCopy(src->reported)))
2229 2230
        return -1;

2231 2232 2233 2234
    if (src->migratable &&
        !(dst->migratable = virCPUDefCopy(src->migratable)))
        return -1;

2235 2236 2237 2238
    if (src->full &&
        !(dst->full = virCPUDefCopy(src->full)))
        return -1;

2239 2240 2241 2242
    return 0;
}


2243
static void
2244
virQEMUCapsHostCPUDataClear(virQEMUCapsHostCPUDataPtr cpuData)
2245
{
2246 2247
    qemuMonitorCPUModelInfoFree(cpuData->info);
    virCPUDefFree(cpuData->reported);
2248
    virCPUDefFree(cpuData->migratable);
2249
    virCPUDefFree(cpuData->full);
2250 2251

    memset(cpuData, 0, sizeof(*cpuData));
2252 2253 2254
}


2255
virQEMUCapsPtr virQEMUCapsNewCopy(virQEMUCapsPtr qemuCaps)
2256
{
2257
    virQEMUCapsPtr ret = virQEMUCapsNew();
2258 2259 2260 2261 2262
    size_t i;

    if (!ret)
        return NULL;

2263 2264
    ret->usedQMP = qemuCaps->usedQMP;

2265 2266 2267 2268 2269
    if (VIR_STRDUP(ret->binary, qemuCaps->binary) < 0)
        goto error;

    ret->ctime = qemuCaps->ctime;

2270
    virBitmapCopy(ret->flags, qemuCaps->flags);
2271

2272 2273
    ret->version = qemuCaps->version;
    ret->kvmVersion = qemuCaps->kvmVersion;
2274 2275 2276 2277

    if (VIR_STRDUP(ret->package, qemuCaps->package) < 0)
        goto error;

2278
    ret->arch = qemuCaps->arch;
2279

2280 2281 2282 2283 2284 2285 2286 2287 2288
    if (qemuCaps->kvmCPUModels) {
        ret->kvmCPUModels = virDomainCapsCPUModelsCopy(qemuCaps->kvmCPUModels);
        if (!ret->kvmCPUModels)
            goto error;
    }

    if (qemuCaps->tcgCPUModels) {
        ret->tcgCPUModels = virDomainCapsCPUModelsCopy(qemuCaps->tcgCPUModels);
        if (!ret->tcgCPUModels)
2289
            goto error;
2290 2291
    }

2292 2293
    if (virQEMUCapsHostCPUDataCopy(&ret->kvmCPU, &qemuCaps->kvmCPU) < 0 ||
        virQEMUCapsHostCPUDataCopy(&ret->tcgCPU, &qemuCaps->tcgCPU) < 0)
2294 2295
        goto error;

2296
    if (VIR_ALLOC_N(ret->machineTypes, qemuCaps->nmachineTypes) < 0)
2297
        goto error;
2298
    ret->nmachineTypes = qemuCaps->nmachineTypes;
2299
    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
2300 2301
        if (VIR_STRDUP(ret->machineTypes[i].name, qemuCaps->machineTypes[i].name) < 0 ||
            VIR_STRDUP(ret->machineTypes[i].alias, qemuCaps->machineTypes[i].alias) < 0)
2302
            goto error;
2303
        ret->machineTypes[i].maxCpus = qemuCaps->machineTypes[i].maxCpus;
2304
        ret->machineTypes[i].hotplugCpus = qemuCaps->machineTypes[i].hotplugCpus;
2305 2306
    }

2307 2308 2309 2310 2311 2312
    if (VIR_ALLOC_N(ret->gicCapabilities, qemuCaps->ngicCapabilities) < 0)
        goto error;
    ret->ngicCapabilities = qemuCaps->ngicCapabilities;
    for (i = 0; i < qemuCaps->ngicCapabilities; i++)
        ret->gicCapabilities[i] = qemuCaps->gicCapabilities[i];

2313 2314
    return ret;

2315
 error:
2316 2317 2318 2319 2320
    virObjectUnref(ret);
    return NULL;
}


2321
void virQEMUCapsDispose(void *obj)
2322
{
2323
    virQEMUCapsPtr qemuCaps = obj;
2324 2325
    size_t i;

2326
    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
2327 2328
        VIR_FREE(qemuCaps->machineTypes[i].name);
        VIR_FREE(qemuCaps->machineTypes[i].alias);
2329
    }
2330
    VIR_FREE(qemuCaps->machineTypes);
2331

2332 2333
    virObjectUnref(qemuCaps->kvmCPUModels);
    virObjectUnref(qemuCaps->tcgCPUModels);
2334

2335
    virBitmapFree(qemuCaps->flags);
2336

2337
    VIR_FREE(qemuCaps->package);
2338
    VIR_FREE(qemuCaps->binary);
A
Andrea Bolognani 已提交
2339 2340

    VIR_FREE(qemuCaps->gicCapabilities);
2341

2342 2343
    virQEMUCapsHostCPUDataClear(&qemuCaps->kvmCPU);
    virQEMUCapsHostCPUDataClear(&qemuCaps->tcgCPU);
2344 2345
}

2346
void
2347
virQEMUCapsSet(virQEMUCapsPtr qemuCaps,
2348
               virQEMUCapsFlags flag)
2349
{
2350
    ignore_value(virBitmapSetBit(qemuCaps->flags, flag));
2351 2352 2353 2354
}


void
2355
virQEMUCapsSetList(virQEMUCapsPtr qemuCaps, ...)
2356 2357 2358 2359
{
    va_list list;
    int flag;

2360
    va_start(list, qemuCaps);
2361
    while ((flag = va_arg(list, int)) < QEMU_CAPS_LAST)
2362
        ignore_value(virBitmapSetBit(qemuCaps->flags, flag));
2363
    va_end(list);
2364 2365 2366 2367
}


void
2368
virQEMUCapsClear(virQEMUCapsPtr qemuCaps,
2369
                 virQEMUCapsFlags flag)
2370
{
2371
    ignore_value(virBitmapClearBit(qemuCaps->flags, flag));
2372 2373 2374
}


2375
char *virQEMUCapsFlagsString(virQEMUCapsPtr qemuCaps)
2376
{
2377
    return virBitmapString(qemuCaps->flags);
2378 2379 2380 2381
}


bool
2382
virQEMUCapsGet(virQEMUCapsPtr qemuCaps,
2383
               virQEMUCapsFlags flag)
2384
{
J
Ján Tomko 已提交
2385
    return qemuCaps && virBitmapIsBitSet(qemuCaps->flags, flag);
2386
}
2387 2388


D
Daniel P. Berrange 已提交
2389 2390 2391
bool virQEMUCapsHasPCIMultiBus(virQEMUCapsPtr qemuCaps,
                               virDomainDefPtr def)
{
2392 2393 2394
    /* x86_64 and i686 support PCI-multibus on all machine types
     * since forever */
    if (ARCH_IS_X86(qemuCaps->arch))
D
Daniel P. Berrange 已提交
2395 2396 2397
        return true;

    if (def->os.arch == VIR_ARCH_PPC ||
2398
        ARCH_IS_PPC64(def->os.arch)) {
D
Daniel P. Berrange 已提交
2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434
        /*
         * Usage of pci.0 naming:
         *
         *    ref405ep: no pci
         *       taihu: no pci
         *      bamboo: 1.1.0
         *       mac99: 2.0.0
         *     g3beige: 2.0.0
         *        prep: 1.4.0
         *     pseries: 2.0.0
         *   mpc8544ds: forever
         * virtex-m507: no pci
         *     ppce500: 1.6.0
         */

        if (qemuCaps->version >= 2000000)
            return true;

        if (qemuCaps->version >= 1006000 &&
            STREQ(def->os.machine, "ppce500"))
            return true;

        if (qemuCaps->version >= 1004000 &&
            STREQ(def->os.machine, "prep"))
            return true;

        if (qemuCaps->version >= 1001000 &&
            STREQ(def->os.machine, "bamboo"))
            return true;

        if (STREQ(def->os.machine, "mpc8544ds"))
            return true;

        return false;
    }

2435 2436 2437
    /* If 'virt' supports PCI, it supports multibus.
     * No extra conditions here for simplicity.
     */
2438
    if (qemuDomainIsVirt(def))
2439
        return true;
2440

D
Daniel P. Berrange 已提交
2441 2442 2443 2444
    return false;
}


2445
const char *virQEMUCapsGetBinary(virQEMUCapsPtr qemuCaps)
2446
{
2447
    return qemuCaps->binary;
2448 2449
}

2450 2451 2452 2453 2454 2455 2456 2457 2458

void
virQEMUCapsSetArch(virQEMUCapsPtr qemuCaps,
                   virArch arch)
{
    qemuCaps->arch = arch;
}


2459
virArch virQEMUCapsGetArch(virQEMUCapsPtr qemuCaps)
2460
{
2461
    return qemuCaps->arch;
2462 2463 2464
}


2465 2466 2467 2468 2469 2470 2471 2472
void
virQEMUCapsSetVersion(virQEMUCapsPtr qemuCaps,
                      unsigned int version)
{
    qemuCaps->version = version;
}


2473
unsigned int virQEMUCapsGetVersion(virQEMUCapsPtr qemuCaps)
2474
{
2475
    return qemuCaps->version;
2476 2477 2478
}


2479
unsigned int virQEMUCapsGetKVMVersion(virQEMUCapsPtr qemuCaps)
2480
{
2481
    return qemuCaps->kvmVersion;
2482 2483 2484
}


2485 2486 2487 2488 2489 2490
const char *virQEMUCapsGetPackage(virQEMUCapsPtr qemuCaps)
{
    return qemuCaps->package;
}


2491 2492
int
virQEMUCapsAddCPUDefinitions(virQEMUCapsPtr qemuCaps,
2493
                             virDomainVirtType type,
2494
                             const char **name,
2495 2496
                             size_t count,
                             virDomainCapsCPUUsable usable)
2497
{
2498
    size_t i;
2499
    virDomainCapsCPUModelsPtr cpus = NULL;
2500

2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514
    if (type == VIR_DOMAIN_VIRT_KVM && qemuCaps->kvmCPUModels)
        cpus = qemuCaps->kvmCPUModels;
    else if (type == VIR_DOMAIN_VIRT_QEMU && qemuCaps->tcgCPUModels)
        cpus = qemuCaps->tcgCPUModels;

    if (!cpus) {
        if (!(cpus = virDomainCapsCPUModelsNew(count)))
            return -1;

        if (type == VIR_DOMAIN_VIRT_KVM)
            qemuCaps->kvmCPUModels = cpus;
        else
            qemuCaps->tcgCPUModels = cpus;
    }
2515 2516

    for (i = 0; i < count; i++) {
2517
        if (virDomainCapsCPUModelsAdd(cpus, name[i], -1, usable) < 0)
2518
            return -1;
2519
    }
2520

2521 2522 2523 2524
    return 0;
}


2525 2526
int
virQEMUCapsGetCPUDefinitions(virQEMUCapsPtr qemuCaps,
2527
                             virDomainVirtType type,
2528 2529
                             char ***names,
                             size_t *count)
2530
{
2531 2532
    size_t i;
    char **models = NULL;
2533
    virDomainCapsCPUModelsPtr cpus;
2534 2535 2536 2537 2538

    *count = 0;
    if (names)
        *names = NULL;

2539 2540 2541 2542 2543 2544
    if (type == VIR_DOMAIN_VIRT_KVM)
        cpus = qemuCaps->kvmCPUModels;
    else
        cpus = qemuCaps->tcgCPUModels;

    if (!cpus)
2545 2546
        return 0;

2547
    if (names && VIR_ALLOC_N(models, cpus->nmodels) < 0)
2548 2549
        return -1;

2550 2551
    for (i = 0; i < cpus->nmodels; i++) {
        virDomainCapsCPUModelPtr cpu = cpus->models + i;
2552 2553 2554 2555
        if (models && VIR_STRDUP(models[i], cpu->name) < 0)
            goto error;
    }

2556
    if (names)
2557
        *names = models;
2558
    *count = cpus->nmodels;
2559 2560 2561
    return 0;

 error:
2562
    virStringListFreeCount(models, i);
2563
    return -1;
2564 2565 2566
}


2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577
static virQEMUCapsHostCPUDataPtr
virQEMUCapsGetHostCPUData(virQEMUCapsPtr qemuCaps,
                          virDomainVirtType type)
{
    if (type == VIR_DOMAIN_VIRT_KVM)
        return &qemuCaps->kvmCPU;
    else
        return &qemuCaps->tcgCPU;
}


2578
virCPUDefPtr
2579
virQEMUCapsGetHostModel(virQEMUCapsPtr qemuCaps,
2580 2581
                        virDomainVirtType type,
                        virQEMUCapsHostCPUType cpuType)
2582
{
2583 2584
    virQEMUCapsHostCPUDataPtr cpuData = virQEMUCapsGetHostCPUData(qemuCaps, type);

2585 2586 2587
    switch (cpuType) {
    case VIR_QEMU_CAPS_HOST_CPU_REPORTED:
        return cpuData->reported;
2588 2589 2590

    case VIR_QEMU_CAPS_HOST_CPU_MIGRATABLE:
        return cpuData->migratable;
2591 2592 2593 2594 2595

    case VIR_QEMU_CAPS_HOST_CPU_FULL:
        /* 'full' is non-NULL only if we have data from both QEMU and
         * virCPUGetHost */
        return cpuData->full ? cpuData->full : cpuData->reported;
2596 2597 2598
    }

    return NULL;
2599 2600 2601
}


2602 2603 2604
static void
virQEMUCapsSetHostModel(virQEMUCapsPtr qemuCaps,
                        virDomainVirtType type,
2605
                        virCPUDefPtr reported,
2606 2607
                        virCPUDefPtr migratable,
                        virCPUDefPtr full)
2608
{
2609 2610
    virQEMUCapsHostCPUDataPtr cpuData = virQEMUCapsGetHostCPUData(qemuCaps, type);

2611 2612
    cpuData->reported = reported;
    cpuData->migratable = migratable;
2613
    cpuData->full = full;
2614 2615 2616
}


2617 2618 2619 2620 2621 2622
bool
virQEMUCapsIsCPUModeSupported(virQEMUCapsPtr qemuCaps,
                              virCapsPtr caps,
                              virDomainVirtType type,
                              virCPUMode mode)
{
2623 2624
    virDomainCapsCPUModelsPtr cpus;

2625 2626 2627 2628 2629 2630
    switch (mode) {
    case VIR_CPU_MODE_HOST_PASSTHROUGH:
        return type == VIR_DOMAIN_VIRT_KVM &&
               virQEMUCapsGuestIsNative(caps->host.arch, qemuCaps->arch);

    case VIR_CPU_MODE_HOST_MODEL:
2631 2632
        return !!virQEMUCapsGetHostModel(qemuCaps, type,
                                         VIR_QEMU_CAPS_HOST_CPU_REPORTED);
2633 2634

    case VIR_CPU_MODE_CUSTOM:
2635 2636 2637 2638 2639
        if (type == VIR_DOMAIN_VIRT_KVM)
            cpus = qemuCaps->kvmCPUModels;
        else
            cpus = qemuCaps->tcgCPUModels;
        return cpus && cpus->nmodels > 0;
2640 2641 2642 2643 2644 2645 2646 2647 2648

    case VIR_CPU_MODE_LAST:
        break;
    }

    return false;
}


2649 2650 2651
int virQEMUCapsGetMachineTypesCaps(virQEMUCapsPtr qemuCaps,
                                   size_t *nmachines,
                                   virCapsGuestMachinePtr **machines)
2652 2653 2654 2655
{
    size_t i;

    *machines = NULL;
2656
    *nmachines = qemuCaps->nmachineTypes;
2657

2658 2659 2660 2661
    if (*nmachines &&
        VIR_ALLOC_N(*machines, qemuCaps->nmachineTypes) < 0)
        goto error;

2662
    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
2663 2664
        virCapsGuestMachinePtr mach;
        if (VIR_ALLOC(mach) < 0)
2665
            goto error;
2666
        (*machines)[i] = mach;
2667 2668 2669
        if (qemuCaps->machineTypes[i].alias) {
            if (VIR_STRDUP(mach->name, qemuCaps->machineTypes[i].alias) < 0 ||
                VIR_STRDUP(mach->canonical, qemuCaps->machineTypes[i].name) < 0)
2670
                goto error;
2671
        } else {
2672
            if (VIR_STRDUP(mach->name, qemuCaps->machineTypes[i].name) < 0)
2673
                goto error;
2674
        }
2675
        mach->maxCpus = qemuCaps->machineTypes[i].maxCpus;
2676 2677
    }

2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715
    /* Make sure all canonical machine types also have their own entry so that
     * /capabilities/guest/arch[@name='...']/machine/text() XPath selects all
     * supported machine types.
     */
    i = 0;
    while (i < *nmachines) {
        size_t j;
        bool found = false;
        virCapsGuestMachinePtr machine = (*machines)[i];

        if (!machine->canonical) {
            i++;
            continue;
        }

        for (j = 0; j < *nmachines; j++) {
            if (STREQ(machine->canonical, (*machines)[j]->name)) {
                found = true;
                break;
            }
        }

        if (!found) {
            virCapsGuestMachinePtr mach;
            if (VIR_ALLOC(mach) < 0)
                goto error;
            if (VIR_INSERT_ELEMENT_COPY(*machines, i, *nmachines, mach) < 0) {
                VIR_FREE(mach);
                goto error;
            }
            if (VIR_STRDUP(mach->name, machine->canonical) < 0)
                goto error;
            mach->maxCpus = machine->maxCpus;
            i++;
        }
        i++;
    }

2716 2717
    return 0;

2718
 error:
2719 2720 2721 2722 2723 2724 2725 2726
    virCapabilitiesFreeMachines(*machines, *nmachines);
    *nmachines = 0;
    *machines = NULL;
    return -1;
}



2727

2728 2729
const char *virQEMUCapsGetCanonicalMachine(virQEMUCapsPtr qemuCaps,
                                           const char *name)
2730 2731 2732
{
    size_t i;

2733 2734 2735
    if (!name)
        return NULL;

2736
    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
2737
        if (!qemuCaps->machineTypes[i].alias)
2738
            continue;
2739 2740
        if (STREQ(qemuCaps->machineTypes[i].alias, name))
            return qemuCaps->machineTypes[i].name;
2741 2742 2743 2744
    }

    return name;
}
2745 2746


2747 2748 2749 2750 2751 2752 2753 2754 2755
int virQEMUCapsGetMachineMaxCpus(virQEMUCapsPtr qemuCaps,
                                 const char *name)
{
    size_t i;

    if (!name)
        return 0;

    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
2756
        if (!qemuCaps->machineTypes[i].maxCpus)
2757
            continue;
2758 2759
        if (STREQ(qemuCaps->machineTypes[i].name, name))
            return qemuCaps->machineTypes[i].maxCpus;
2760 2761 2762 2763 2764 2765
    }

    return 0;
}


2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779
bool virQEMUCapsGetMachineHotplugCpus(virQEMUCapsPtr qemuCaps,
                                      const char *name)
{
    size_t i;

    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
        if (STREQ_NULLABLE(qemuCaps->machineTypes[i].name, name))
            return qemuCaps->machineTypes[i].hotplugCpus;
    }

    return false;
}


2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803
/**
 * virQEMUCapsSetGICCapabilities:
 * @qemuCaps: QEMU capabilities
 * @capabilities: GIC capabilities
 * @ncapabilities: number of GIC capabilities
 *
 * Set the GIC capabilities for @qemuCaps.
 *
 * The ownership of @capabilities is taken away from the caller, ie. this
 * function will not make a copy of @capabilities, so releasing that memory
 * after it's been called is a bug.
 */
void
virQEMUCapsSetGICCapabilities(virQEMUCapsPtr qemuCaps,
                              virGICCapability *capabilities,
                              size_t ncapabilities)
{
    VIR_FREE(qemuCaps->gicCapabilities);

    qemuCaps->gicCapabilities = capabilities;
    qemuCaps->ngicCapabilities = ncapabilities;
}


2804
static int
2805 2806
virQEMUCapsProbeQMPCommands(virQEMUCapsPtr qemuCaps,
                            qemuMonitorPtr mon)
2807 2808 2809 2810 2811 2812 2813
{
    char **commands = NULL;
    int ncommands;

    if ((ncommands = qemuMonitorGetCommands(mon, &commands)) < 0)
        return -1;

2814 2815 2816 2817
    virQEMUCapsProcessStringFlags(qemuCaps,
                                  ARRAY_CARDINALITY(virQEMUCapsCommands),
                                  virQEMUCapsCommands,
                                  ncommands, commands);
2818
    virStringListFreeCount(commands, ncommands);
2819

2820 2821 2822 2823
    /* QMP add-fd was introduced in 1.2, but did not support
     * management control of set numbering, and did not have a
     * counterpart -add-fd command line option.  We require the
     * add-fd features from 1.3 or later.  */
2824
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_ADD_FD)) {
2825 2826 2827 2828 2829 2830 2831
        int fd = open("/dev/null", O_RDONLY);
        if (fd < 0) {
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("unable to probe for add-fd"));
            return -1;
        }
        if (qemuMonitorAddFd(mon, 0, fd, "/dev/null") < 0)
2832
            virQEMUCapsClear(qemuCaps, QEMU_CAPS_ADD_FD);
2833 2834 2835
        VIR_FORCE_CLOSE(fd);
    }

2836 2837 2838 2839 2840 2841
    /* Probe for active commit of qemu 2.1 (for now, we are choosing
     * to ignore the fact that qemu 2.0 can also do active commit) */
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_BLOCK_COMMIT) &&
        qemuMonitorSupportsActiveCommit(mon))
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_ACTIVE_COMMIT);

2842 2843 2844 2845 2846
    return 0;
}


static int
2847 2848
virQEMUCapsProbeQMPEvents(virQEMUCapsPtr qemuCaps,
                          qemuMonitorPtr mon)
2849 2850 2851 2852 2853 2854 2855
{
    char **events = NULL;
    int nevents;

    if ((nevents = qemuMonitorGetEvents(mon, &events)) < 0)
        return -1;

2856 2857 2858 2859
    virQEMUCapsProcessStringFlags(qemuCaps,
                                  ARRAY_CARDINALITY(virQEMUCapsEvents),
                                  virQEMUCapsEvents,
                                  nevents, events);
2860
    virStringListFreeCount(events, nevents);
2861 2862 2863 2864 2865

    return 0;
}


2866
static int
2867 2868
virQEMUCapsProbeQMPObjects(virQEMUCapsPtr qemuCaps,
                           qemuMonitorPtr mon)
2869 2870 2871 2872 2873 2874 2875
{
    int nvalues;
    char **values;
    size_t i;

    if ((nvalues = qemuMonitorGetObjectTypes(mon, &values)) < 0)
        return -1;
2876 2877 2878 2879
    virQEMUCapsProcessStringFlags(qemuCaps,
                                  ARRAY_CARDINALITY(virQEMUCapsObjectTypes),
                                  virQEMUCapsObjectTypes,
                                  nvalues, values);
2880
    virStringListFreeCount(values, nvalues);
2881

2882
    for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsObjectProps); i++) {
2883
        const char *type = virQEMUCapsObjectProps[i].type;
2884 2885 2886 2887 2888
        int cap = virQEMUCapsObjectProps[i].capsCondition;

        if (cap >= 0 && !virQEMUCapsGet(qemuCaps, cap))
            continue;

2889 2890 2891 2892
        if ((nvalues = qemuMonitorGetObjectProps(mon,
                                                 type,
                                                 &values)) < 0)
            return -1;
2893 2894 2895 2896
        virQEMUCapsProcessStringFlags(qemuCaps,
                                      virQEMUCapsObjectProps[i].nprops,
                                      virQEMUCapsObjectProps[i].props,
                                      nvalues, values);
2897 2898 2899 2900
        virQEMUCapsProcessProps(qemuCaps,
                                ARRAY_CARDINALITY(virQEMUCapsPropObjects),
                                virQEMUCapsPropObjects, type,
                                nvalues, values);
2901
        virStringListFreeCount(values, nvalues);
2902 2903 2904
    }

    /* Prefer -chardev spicevmc (detected earlier) over -device spicevmc */
2905 2906
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC))
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC);
2907 2908 2909 2910 2911 2912

    return 0;
}


static int
2913 2914
virQEMUCapsProbeQMPMachineTypes(virQEMUCapsPtr qemuCaps,
                                qemuMonitorPtr mon)
2915 2916 2917 2918 2919
{
    qemuMonitorMachineInfoPtr *machines = NULL;
    int nmachines = 0;
    int ret = -1;
    size_t i;
2920
    size_t defIdx = 0;
2921 2922

    if ((nmachines = qemuMonitorGetMachines(mon, &machines)) < 0)
2923
        return -1;
2924

2925
    if (VIR_ALLOC_N(qemuCaps->machineTypes, nmachines) < 0)
2926 2927
        goto cleanup;

2928
    for (i = 0; i < nmachines; i++) {
2929
        struct virQEMUCapsMachineType *mach;
2930 2931
        if (STREQ(machines[i]->name, "none"))
            continue;
2932 2933 2934 2935 2936

        mach = &(qemuCaps->machineTypes[qemuCaps->nmachineTypes++]);

        if (VIR_STRDUP(mach->alias, machines[i]->alias) < 0 ||
            VIR_STRDUP(mach->name, machines[i]->name) < 0)
2937
            goto cleanup;
2938 2939

        mach->maxCpus = machines[i]->maxCpus;
2940
        mach->hotplugCpus = machines[i]->hotplugCpus;
2941

2942
        if (machines[i]->isDefault)
2943
            defIdx = qemuCaps->nmachineTypes - 1;
2944
    }
2945 2946

    if (defIdx)
2947
        virQEMUCapsSetDefaultMachine(qemuCaps, defIdx);
2948 2949 2950

    ret = 0;

2951
 cleanup:
2952
    for (i = 0; i < nmachines; i++)
2953 2954 2955 2956 2957 2958 2959
        qemuMonitorMachineInfoFree(machines[i]);
    VIR_FREE(machines);
    return ret;
}


static int
2960
virQEMUCapsProbeQMPCPUDefinitions(virQEMUCapsPtr qemuCaps,
2961 2962
                                  qemuMonitorPtr mon,
                                  bool tcg)
2963
{
2964
    virDomainCapsCPUModelsPtr models;
2965 2966 2967 2968
    qemuMonitorCPUDefInfoPtr *cpus;
    int ncpus;
    int ret = -1;
    size_t i;
2969

2970 2971 2972
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_CPU_DEFINITIONS))
        return 0;

2973
    if ((ncpus = qemuMonitorGetCPUDefinitions(mon, &cpus)) < 0)
2974 2975
        return -1;

2976
    if (!(models = virDomainCapsCPUModelsNew(ncpus)))
2977
        goto cleanup;
2978

2979 2980 2981 2982 2983
    if (tcg || !virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
        qemuCaps->tcgCPUModels = models;
    else
        qemuCaps->kvmCPUModels = models;

2984
    for (i = 0; i < ncpus; i++) {
2985 2986 2987 2988 2989 2990 2991 2992
        virDomainCapsCPUUsable usable = VIR_DOMCAPS_CPU_USABLE_UNKNOWN;

        if (cpus[i]->usable == VIR_TRISTATE_BOOL_YES)
            usable = VIR_DOMCAPS_CPU_USABLE_YES;
        else if (cpus[i]->usable == VIR_TRISTATE_BOOL_NO)
            usable = VIR_DOMCAPS_CPU_USABLE_NO;

        if (virDomainCapsCPUModelsAddSteal(models, &cpus[i]->name, usable) < 0)
2993 2994 2995 2996 2997 2998 2999 3000 3001 3002
            goto cleanup;
    }

    ret = 0;

 cleanup:
    for (i = 0; i < ncpus; i++)
        qemuMonitorCPUDefInfoFree(cpus[i]);
    VIR_FREE(cpus);
    return ret;
3003 3004
}

3005 3006
static int
virQEMUCapsProbeQMPHostCPU(virQEMUCapsPtr qemuCaps,
3007 3008
                           qemuMonitorPtr mon,
                           bool tcg)
3009
{
3010
    qemuMonitorCPUModelInfoPtr modelInfo = NULL;
3011 3012
    qemuMonitorCPUModelInfoPtr nonMigratable = NULL;
    virHashTablePtr hash = NULL;
3013
    const char *model;
3014
    qemuMonitorCPUModelExpansionType type;
3015 3016
    virDomainVirtType virtType;
    virQEMUCapsHostCPUDataPtr cpuData;
3017
    int ret = -1;
3018 3019

    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION))
3020 3021
        return 0;

3022
    if (tcg || !virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
3023
        virtType = VIR_DOMAIN_VIRT_QEMU;
3024 3025
        model = "max";
    } else {
3026
        virtType = VIR_DOMAIN_VIRT_KVM;
3027 3028 3029
        model = "host";
    }

3030 3031
    cpuData = virQEMUCapsGetHostCPUData(qemuCaps, virtType);

3032 3033 3034 3035 3036 3037 3038 3039 3040 3041
    /* Some x86_64 features defined in cpu_map.xml use spelling which differ
     * from the one preferred by QEMU. Static expansion would give us only the
     * preferred spelling, thus we need to do a full expansion on the result of
     * the initial static expansion to get all variants of all features.
     */
    if (ARCH_IS_X86(qemuCaps->arch))
        type = QEMU_MONITOR_CPU_MODEL_EXPANSION_STATIC_FULL;
    else
        type = QEMU_MONITOR_CPU_MODEL_EXPANSION_STATIC;

3042 3043
    if (qemuMonitorGetCPUModelExpansion(mon, type, model, true, &modelInfo) < 0)
        goto cleanup;
3044 3045

    /* Try to check migratability of each feature. */
3046
    if (modelInfo &&
3047 3048
        qemuMonitorGetCPUModelExpansion(mon, type, model, false,
                                        &nonMigratable) < 0)
3049
        goto cleanup;
3050 3051 3052 3053 3054 3055 3056

    if (nonMigratable) {
        qemuMonitorCPUPropertyPtr prop;
        qemuMonitorCPUPropertyPtr nmProp;
        size_t i;

        if (!(hash = virHashCreate(0, NULL)))
3057
            goto cleanup;
3058

3059 3060
        for (i = 0; i < modelInfo->nprops; i++) {
            prop = modelInfo->props + i;
3061
            if (virHashAddEntry(hash, prop->name, prop) < 0)
3062
                goto cleanup;
3063 3064 3065 3066 3067 3068 3069 3070 3071
        }

        for (i = 0; i < nonMigratable->nprops; i++) {
            nmProp = nonMigratable->props + i;
            if (!(prop = virHashLookup(hash, nmProp->name)) ||
                prop->type != QEMU_MONITOR_CPU_PROPERTY_BOOLEAN ||
                prop->type != nmProp->type)
                continue;

3072
            if (prop->value.boolean) {
3073
                prop->migratable = VIR_TRISTATE_BOOL_YES;
3074 3075 3076 3077
            } else if (nmProp->value.boolean) {
                prop->value.boolean = true;
                prop->migratable = VIR_TRISTATE_BOOL_NO;
            }
3078 3079
        }

3080
        modelInfo->migratability = true;
3081 3082
    }

3083
    VIR_STEAL_PTR(cpuData->info, modelInfo);
3084 3085 3086 3087 3088
    ret = 0;

 cleanup:
    virHashFree(hash);
    qemuMonitorCPUModelInfoFree(nonMigratable);
3089
    qemuMonitorCPUModelInfoFree(modelInfo);
3090 3091

    return ret;
3092 3093
}

3094 3095
struct tpmTypeToCaps {
    int type;
3096
    virQEMUCapsFlags caps;
3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116
};

static const struct tpmTypeToCaps virQEMUCapsTPMTypesToCaps[] = {
    {
        .type = VIR_DOMAIN_TPM_TYPE_PASSTHROUGH,
        .caps = QEMU_CAPS_DEVICE_TPM_PASSTHROUGH,
    },
};

const struct tpmTypeToCaps virQEMUCapsTPMModelsToCaps[] = {
    {
        .type = VIR_DOMAIN_TPM_MODEL_TIS,
        .caps = QEMU_CAPS_DEVICE_TPM_TIS,
    },
};

static int
virQEMUCapsProbeQMPTPM(virQEMUCapsPtr qemuCaps,
                       qemuMonitorPtr mon)
{
3117 3118
    int nentries;
    size_t i;
3119
    char **entries = NULL;
S
Stefan Berger 已提交
3120

3121 3122 3123 3124 3125 3126 3127
    if ((nentries = qemuMonitorGetTPMModels(mon, &entries)) < 0)
        return -1;

    if (nentries > 0) {
        for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsTPMModelsToCaps); i++) {
            const char *needle = virDomainTPMModelTypeToString(
                virQEMUCapsTPMModelsToCaps[i].type);
3128
            if (virStringListHasString((const char **) entries, needle))
3129 3130 3131 3132
                virQEMUCapsSet(qemuCaps,
                               virQEMUCapsTPMModelsToCaps[i].caps);
        }
    }
3133
    virStringListFree(entries);
3134 3135 3136 3137 3138 3139 3140 3141

    if ((nentries = qemuMonitorGetTPMTypes(mon, &entries)) < 0)
        return -1;

    if (nentries > 0) {
        for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsTPMTypesToCaps); i++) {
            const char *needle = virDomainTPMBackendTypeToString(
                virQEMUCapsTPMTypesToCaps[i].type);
3142
            if (virStringListHasString((const char **) entries, needle))
3143 3144 3145
                virQEMUCapsSet(qemuCaps, virQEMUCapsTPMTypesToCaps[i].caps);
        }
    }
3146
    virStringListFree(entries);
3147 3148 3149 3150

    return 0;
}

3151

3152
static int
3153 3154
virQEMUCapsProbeQMPKVMState(virQEMUCapsPtr qemuCaps,
                            qemuMonitorPtr mon)
3155 3156 3157 3158
{
    bool enabled = false;
    bool present = false;

3159
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
3160 3161 3162 3163 3164 3165
        return 0;

    if (qemuMonitorGetKVMState(mon, &enabled, &present) < 0)
        return -1;

    /* The QEMU_CAPS_KVM flag was initially set according to the QEMU
3166
     * reporting the recognition of 'query-kvm' QMP command. That merely
N
Nehal J Wani 已提交
3167
     * indicates existence of the command though, not whether KVM support
3168 3169 3170 3171 3172 3173
     * is actually available, nor whether it is enabled by default.
     *
     * If it is not present we need to clear the flag, and if it is
     * not enabled by default we need to change the flag.
     */
    if (!present) {
3174
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_KVM);
3175
    } else if (!enabled) {
3176 3177
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_KVM);
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_ENABLE_KVM);
3178 3179 3180 3181 3182
    }

    return 0;
}

3183 3184 3185 3186 3187 3188 3189 3190
struct virQEMUCapsCommandLineProps {
    const char *option;
    const char *param;
    int flag;
};

static struct virQEMUCapsCommandLineProps virQEMUCapsCommandLine[] = {
    { "machine", "mem-merge", QEMU_CAPS_MEM_MERGE },
3191
    { "machine", "vmport", QEMU_CAPS_MACHINE_VMPORT_OPT },
O
Osier Yang 已提交
3192
    { "drive", "discard", QEMU_CAPS_DRIVE_DISCARD },
3193
    { "drive", "detect-zeroes", QEMU_CAPS_DRIVE_DETECT_ZEROES },
3194
    { "realtime", "mlock", QEMU_CAPS_REALTIME_MLOCK },
3195
    { "boot-opts", "strict", QEMU_CAPS_BOOT_STRICT },
3196
    { "boot-opts", "reboot-timeout", QEMU_CAPS_REBOOT_TIMEOUT },
3197
    { "boot-opts", "splash-time", QEMU_CAPS_SPLASH_TIMEOUT },
3198
    { "spice", "disable-agent-file-xfer", QEMU_CAPS_SPICE_FILE_XFER_DISABLE },
3199
    { "msg", "timestamp", QEMU_CAPS_MSG_TIMESTAMP },
3200
    { "numa", NULL, QEMU_CAPS_NUMA },
3201
    { "drive", "throttling.bps-total-max", QEMU_CAPS_DRIVE_IOTUNE_MAX},
3202 3203
    { "machine", "aes-key-wrap", QEMU_CAPS_AES_KEY_WRAP },
    { "machine", "dea-key-wrap", QEMU_CAPS_DEA_KEY_WRAP },
3204
    { "chardev", "append", QEMU_CAPS_CHARDEV_FILE_APPEND },
3205
    { "spice", "gl", QEMU_CAPS_SPICE_GL },
3206
    { "chardev", "logfile", QEMU_CAPS_CHARDEV_LOGFILE },
3207
    { "name", "debug-threads", QEMU_CAPS_NAME_DEBUG_THREADS },
3208
    { "name", "guest", QEMU_CAPS_NAME_GUEST },
3209
    { "spice", "unix", QEMU_CAPS_SPICE_UNIX },
3210
    { "drive", "throttling.bps-total-max-length", QEMU_CAPS_DRIVE_IOTUNE_MAX_LENGTH },
3211
    { "drive", "throttling.group", QEMU_CAPS_DRIVE_IOTUNE_GROUP },
3212
    { "spice", "rendernode", QEMU_CAPS_SPICE_RENDERNODE },
3213
    { "machine", "kernel_irqchip", QEMU_CAPS_MACHINE_KERNEL_IRQCHIP },
3214
    { "machine", "loadparm", QEMU_CAPS_LOADPARM },
3215 3216 3217 3218 3219 3220
};

static int
virQEMUCapsProbeQMPCommandLine(virQEMUCapsPtr qemuCaps,
                               qemuMonitorPtr mon)
{
3221
    bool found = false;
3222 3223 3224 3225 3226 3227 3228
    int nvalues;
    char **values;
    size_t i, j;

    for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsCommandLine); i++) {
        if ((nvalues = qemuMonitorGetCommandLineOptionParameters(mon,
                                                                 virQEMUCapsCommandLine[i].option,
3229 3230
                                                                 &values,
                                                                 &found)) < 0)
3231
            return -1;
3232 3233 3234 3235

        if (found && !virQEMUCapsCommandLine[i].param)
            virQEMUCapsSet(qemuCaps, virQEMUCapsCommandLine[i].flag);

3236
        for (j = 0; j < nvalues; j++) {
3237
            if (STREQ_NULLABLE(virQEMUCapsCommandLine[i].param, values[j])) {
3238 3239 3240 3241
                virQEMUCapsSet(qemuCaps, virQEMUCapsCommandLine[i].flag);
                break;
            }
        }
3242
        virStringListFree(values);
3243 3244 3245 3246
    }

    return 0;
}
3247

3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261
static int
virQEMUCapsProbeQMPMigrationCapabilities(virQEMUCapsPtr qemuCaps,
                                         qemuMonitorPtr mon)
{
    char **caps = NULL;
    int ncaps;

    if ((ncaps = qemuMonitorGetMigrationCapabilities(mon, &caps)) < 0)
        return -1;

    virQEMUCapsProcessStringFlags(qemuCaps,
                                  ARRAY_CARDINALITY(virQEMUCapsMigration),
                                  virQEMUCapsMigration,
                                  ncaps, caps);
3262
    virStringListFreeCount(caps, ncaps);
3263 3264 3265 3266

    return 0;
}

A
Andrea Bolognani 已提交
3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286
/**
 * virQEMUCapsProbeQMPGICCapabilities:
 * @qemuCaps: QEMU binary capabilities
 * @mon: QEMU monitor
 *
 * Use @mon to obtain information about the GIC capabilities for the
 * corresponding QEMU binary, and store them in @qemuCaps.
 *
 * Returns: 0 on success, <0 on failure
 */
static int
virQEMUCapsProbeQMPGICCapabilities(virQEMUCapsPtr qemuCaps,
                                   qemuMonitorPtr mon)
{
    virGICCapability *caps = NULL;
    int ncaps;

    if ((ncaps = qemuMonitorGetGICCapabilities(mon, &caps)) < 0)
        return -1;

3287
    virQEMUCapsSetGICCapabilities(qemuCaps, caps, ncaps);
A
Andrea Bolognani 已提交
3288 3289 3290 3291

    return 0;
}

3292

3293 3294
static bool
virQEMUCapsCPUFilterFeatures(const char *name,
3295
                             void *opaque)
3296
{
3297 3298 3299 3300 3301
    virQEMUCapsPtr qemuCaps = opaque;

    if (!ARCH_IS_X86(qemuCaps->arch))
        return true;

3302 3303 3304 3305 3306 3307 3308 3309 3310
    if (STREQ(name, "cmt") ||
        STREQ(name, "mbm_total") ||
        STREQ(name, "mbm_local"))
        return false;

    return true;
}


3311 3312 3313 3314 3315 3316 3317
/**
 * Returns  0 when host CPU model provided by QEMU was filled in qemuCaps,
 *          1 when the caller should fall back to using virCapsPtr->host.cpu,
 *         -1 on error.
 */
static int
virQEMUCapsInitCPUModelS390(virQEMUCapsPtr qemuCaps,
3318
                            qemuMonitorCPUModelInfoPtr modelInfo,
3319 3320
                            virCPUDefPtr cpu,
                            bool migratable)
3321
{
3322
    size_t i;
3323

3324
    if (!modelInfo) {
3325
        virReportError(VIR_ERR_INTERNAL_ERROR,
3326 3327 3328 3329
                       _("missing host CPU model info from QEMU capabilities "
                         "for binary %s"),
                       qemuCaps->binary);
        return -1;
3330
    }
J
Jiri Denemark 已提交
3331

3332 3333
    if (VIR_STRDUP(cpu->model, modelInfo->name) < 0 ||
        VIR_ALLOC_N(cpu->features, modelInfo->nprops) < 0)
3334
        return -1;
3335 3336 3337 3338 3339

    cpu->nfeatures_max = modelInfo->nprops;
    cpu->nfeatures = 0;

    for (i = 0; i < modelInfo->nprops; i++) {
3340 3341
        virCPUFeatureDefPtr feature = cpu->features + cpu->nfeatures;
        qemuMonitorCPUPropertyPtr prop = modelInfo->props + i;
3342

3343 3344
        if (prop->type != QEMU_MONITOR_CPU_PROPERTY_BOOLEAN)
            continue;
3345

3346 3347
        if (VIR_STRDUP(feature->name, prop->name) < 0)
            return -1;
3348 3349 3350 3351 3352 3353

        if (!prop->value.boolean ||
            (migratable && prop->migratable == VIR_TRISTATE_BOOL_NO))
            feature->policy = VIR_CPU_FEATURE_DISABLE;
        else
            feature->policy = VIR_CPU_FEATURE_REQUIRE;
3354 3355 3356
        cpu->nfeatures++;
    }

3357 3358
    return 0;
}
3359

3360

3361 3362 3363 3364 3365 3366 3367 3368
/**
 * Returns  0 when host CPU model provided by QEMU was filled in qemuCaps,
 *          1 when the caller should fall back to using virCapsPtr->host.cpu,
 *         -1 on error.
 */
static int
virQEMUCapsInitCPUModelX86(virQEMUCapsPtr qemuCaps,
                           virDomainVirtType type,
3369
                           qemuMonitorCPUModelInfoPtr model,
3370 3371
                           virCPUDefPtr cpu,
                           bool migratable)
3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391
{
    virCPUDataPtr data = NULL;
    unsigned long long sigFamily = 0;
    unsigned long long sigModel = 0;
    size_t nmodels = 0;
    char **models = NULL;
    int ret = -1;
    size_t i;

    if (!model)
        return 1;

    if (!(data = virCPUDataNew(VIR_ARCH_X86_64)))
        goto cleanup;

    for (i = 0; i < model->nprops; i++) {
        qemuMonitorCPUPropertyPtr prop = model->props + i;

        switch (prop->type) {
        case QEMU_MONITOR_CPU_PROPERTY_BOOLEAN:
3392 3393 3394 3395 3396
            if (!prop->value.boolean ||
                (migratable && prop->migratable == VIR_TRISTATE_BOOL_NO))
                continue;

            if (virCPUx86DataAddFeature(data, prop->name) < 0)
3397
                goto cleanup;
3398

3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434
            break;

        case QEMU_MONITOR_CPU_PROPERTY_STRING:
            if (STREQ(prop->name, "vendor") &&
                virCPUx86DataSetVendor(data, prop->value.string) < 0)
                goto cleanup;
            break;

        case QEMU_MONITOR_CPU_PROPERTY_NUMBER:
            if (STREQ(prop->name, "family"))
                sigFamily = prop->value.number;
            else if (STREQ(prop->name, "model"))
                sigModel = prop->value.number;
            break;

        case QEMU_MONITOR_CPU_PROPERTY_LAST:
            break;
        }
    }

    if (virCPUx86DataSetSignature(data, sigFamily, sigModel) < 0)
        goto cleanup;

    if (virQEMUCapsGetCPUDefinitions(qemuCaps, type, &models, &nmodels) < 0 ||
        cpuDecode(cpu, data, (const char **) models, nmodels, NULL) < 0)
        goto cleanup;

    ret = 0;

 cleanup:
    virCPUDataFree(data);
    virStringListFreeCount(models, nmodels);
    return ret;
}


3435 3436
/**
 * Returns  0 when host CPU model provided by QEMU was filled in qemuCaps,
3437
 *          1 when the caller should fall back to other methods
3438 3439
 *         -1 on error.
 */
3440
int
3441
virQEMUCapsInitCPUModel(virQEMUCapsPtr qemuCaps,
3442
                        virDomainVirtType type,
3443 3444
                        virCPUDefPtr cpu,
                        bool migratable)
3445
{
3446
    virQEMUCapsHostCPUDataPtr cpuData = virQEMUCapsGetHostCPUData(qemuCaps, type);
3447 3448
    int ret = 1;

3449
    if (migratable && cpuData->info && !cpuData->info->migratability)
3450 3451
        return 1;

3452 3453 3454 3455 3456 3457 3458
    if (ARCH_IS_S390(qemuCaps->arch)) {
        ret = virQEMUCapsInitCPUModelS390(qemuCaps, cpuData->info,
                                          cpu, migratable);
    } else if (ARCH_IS_X86(qemuCaps->arch)) {
        ret = virQEMUCapsInitCPUModelX86(qemuCaps, type, cpuData->info,
                                         cpu, migratable);
    }
3459

3460 3461 3462
    if (ret == 0)
        cpu->fallback = VIR_CPU_FALLBACK_FORBID;

3463
    return ret;
3464 3465 3466
}


3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483
static virCPUDefPtr
virQEMUCapsNewHostCPUModel(void)
{
    virCPUDefPtr cpu;

    if (VIR_ALLOC(cpu) < 0)
        return NULL;

    cpu->type = VIR_CPU_TYPE_GUEST;
    cpu->mode = VIR_CPU_MODE_CUSTOM;
    cpu->match = VIR_CPU_MATCH_EXACT;
    cpu->fallback = VIR_CPU_FALLBACK_ALLOW;

    return cpu;
}


3484 3485
void
virQEMUCapsInitHostCPUModel(virQEMUCapsPtr qemuCaps,
3486 3487
                            virCapsPtr caps,
                            virDomainVirtType type)
3488 3489
{
    virCPUDefPtr cpu = NULL;
3490
    virCPUDefPtr migCPU = NULL;
3491
    virCPUDefPtr hostCPU = NULL;
3492 3493
    virCPUDefPtr fullCPU = NULL;
    size_t i;
3494
    int rc;
3495

3496 3497 3498
    if (!caps || !virQEMUCapsGuestIsNative(caps->host.arch, qemuCaps->arch))
        return;

3499
    if (!(cpu = virQEMUCapsNewHostCPUModel()))
3500 3501
        goto error;

3502
    if ((rc = virQEMUCapsInitCPUModel(qemuCaps, type, cpu, false)) < 0) {
3503 3504
        goto error;
    } else if (rc == 1) {
3505
        VIR_DEBUG("No host CPU model info from QEMU; probing host CPU directly");
3506

3507 3508 3509
        hostCPU = virQEMUCapsProbeHostCPUForEmulator(caps, qemuCaps, type);
        if (!hostCPU ||
            virCPUDefCopyModelFilter(cpu, hostCPU, true,
3510 3511
                                     virQEMUCapsCPUFilterFeatures,
                                     qemuCaps) < 0)
3512
            goto error;
3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524
    } else if (type == VIR_DOMAIN_VIRT_KVM &&
               virCPUGetHostIsSupported(qemuCaps->arch)) {
        if (!(fullCPU = virCPUGetHost(qemuCaps->arch, VIR_CPU_TYPE_GUEST,
                                      NULL, NULL, 0)))
            goto error;

        for (i = 0; i < cpu->nfeatures; i++) {
            if (cpu->features[i].policy == VIR_CPU_FEATURE_REQUIRE &&
                virCPUDefUpdateFeature(fullCPU, cpu->features[i].name,
                                       VIR_CPU_FEATURE_REQUIRE) < 0)
                goto error;
        }
3525 3526
    }

3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539
    if (!(migCPU = virQEMUCapsNewHostCPUModel()))
        goto error;

    if ((rc = virQEMUCapsInitCPUModel(qemuCaps, type, migCPU, true)) < 0) {
        goto error;
    } else if (rc == 1) {
        VIR_DEBUG("CPU migratability not provided by QEMU");

        virCPUDefFree(migCPU);
        if (!(migCPU = virCPUCopyMigratable(qemuCaps->arch, cpu)))
            goto error;
    }

3540
    virQEMUCapsSetHostModel(qemuCaps, type, cpu, migCPU, fullCPU);
3541

3542 3543
 cleanup:
    virCPUDefFree(hostCPU);
3544 3545 3546 3547
    return;

 error:
    virCPUDefFree(cpu);
3548
    virCPUDefFree(migCPU);
3549
    virCPUDefFree(fullCPU);
3550
    virResetLastError();
3551
    goto cleanup;
3552 3553 3554
}


3555 3556 3557 3558 3559
void
virQEMUCapsSetCPUModelInfo(virQEMUCapsPtr qemuCaps,
                           virDomainVirtType type,
                           qemuMonitorCPUModelInfoPtr modelInfo)
{
3560 3561 3562
    virQEMUCapsHostCPUDataPtr cpuData = virQEMUCapsGetHostCPUData(qemuCaps, type);

    cpuData->info = modelInfo;
3563 3564 3565
}


3566 3567
static int
virQEMUCapsLoadHostCPUModelInfo(virQEMUCapsPtr qemuCaps,
3568 3569
                                xmlXPathContextPtr ctxt,
                                virDomainVirtType virtType)
3570 3571 3572
{
    char *str = NULL;
    xmlNodePtr hostCPUNode;
3573
    xmlNodePtr *nodes = NULL;
3574 3575 3576 3577 3578
    xmlNodePtr oldnode = ctxt->node;
    qemuMonitorCPUModelInfoPtr hostCPU = NULL;
    int ret = -1;
    size_t i;
    int n;
3579
    int val;
3580

3581 3582 3583 3584 3585 3586
    if (virtType == VIR_DOMAIN_VIRT_KVM)
        hostCPUNode = virXPathNode("./hostCPU[@type='kvm']", ctxt);
    else
        hostCPUNode = virXPathNode("./hostCPU[@type='tcg']", ctxt);

    if (!hostCPUNode) {
3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600
        ret = 0;
        goto cleanup;
    }

    if (VIR_ALLOC(hostCPU) < 0)
        goto cleanup;

    if (!(hostCPU->name = virXMLPropString(hostCPUNode, "model"))) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("missing host CPU model name in QEMU "
                         "capabilities cache"));
        goto cleanup;
    }

3601 3602 3603 3604 3605 3606 3607 3608 3609
    if (!(str = virXMLPropString(hostCPUNode, "migratability")) ||
        (val = virTristateBoolTypeFromString(str)) <= 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("invalid migratability value for host CPU model"));
        goto cleanup;
    }
    hostCPU->migratability = val == VIR_TRISTATE_BOOL_YES;
    VIR_FREE(str);

3610 3611
    ctxt->node = hostCPUNode;

3612
    if ((n = virXPathNodeSet("./property", ctxt, &nodes)) > 0) {
3613 3614 3615 3616 3617 3618
        if (VIR_ALLOC_N(hostCPU->props, n) < 0)
            goto cleanup;

        hostCPU->nprops = n;

        for (i = 0; i < n; i++) {
3619 3620 3621 3622 3623
            qemuMonitorCPUPropertyPtr prop = hostCPU->props + i;

            ctxt->node = nodes[i];

            if (!(prop->name = virXMLPropString(ctxt->node, "name"))) {
3624 3625
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("missing 'name' attribute for a host CPU"
3626
                                 " model property in QEMU capabilities cache"));
3627 3628 3629
                goto cleanup;
            }

3630
            if (!(str = virXMLPropString(ctxt->node, "type")) ||
3631
                (val = qemuMonitorCPUPropertyTypeFromString(str)) < 0) {
3632
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3633 3634
                               _("missing or invalid CPU model property type "
                                 "in QEMU capabilities cache"));
3635 3636 3637
                goto cleanup;
            }
            VIR_FREE(str);
3638

3639
            prop->type = val;
3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670
            switch (prop->type) {
            case QEMU_MONITOR_CPU_PROPERTY_BOOLEAN:
                if (virXPathBoolean("./@value='true'", ctxt))
                    prop->value.boolean = true;
                break;

            case QEMU_MONITOR_CPU_PROPERTY_STRING:
                prop->value.string = virXMLPropString(ctxt->node, "value");
                if (!prop->value.string) {
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("invalid string value for '%s' host CPU "
                                     "model property in QEMU capabilities cache"),
                                   prop->name);
                    goto cleanup;
                }
                break;

            case QEMU_MONITOR_CPU_PROPERTY_NUMBER:
                if (virXPathLongLong("string(./@value)", ctxt,
                                     &prop->value.number) < 0) {
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("invalid number value for '%s' host CPU "
                                     "model property in QEMU capabilities cache"),
                                   prop->name);
                    goto cleanup;
                }
                break;

            case QEMU_MONITOR_CPU_PROPERTY_LAST:
                break;
            }
3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683

            if ((str = virXMLPropString(ctxt->node, "migratable"))) {
                if ((val = virTristateBoolTypeFromString(str)) <= 0) {
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("unknown migratable value for '%s' host "
                                     "CPU model property"),
                                   prop->name);
                    goto cleanup;
                }

                prop->migratable = val;
                VIR_FREE(str);
            }
3684 3685 3686
        }
    }

3687
    virQEMUCapsSetCPUModelInfo(qemuCaps, virtType, hostCPU);
3688 3689 3690 3691 3692 3693
    hostCPU = NULL;
    ret = 0;

 cleanup:
    ctxt->node = oldnode;
    VIR_FREE(str);
3694
    VIR_FREE(nodes);
3695 3696 3697 3698 3699
    qemuMonitorCPUModelInfoFree(hostCPU);
    return ret;
}


3700 3701
static int
virQEMUCapsLoadCPUModels(virQEMUCapsPtr qemuCaps,
3702 3703
                         xmlXPathContextPtr ctxt,
                         virDomainVirtType type)
3704
{
3705
    virDomainCapsCPUModelsPtr cpus = NULL;
3706 3707 3708 3709 3710 3711
    xmlNodePtr *nodes = NULL;
    char *str = NULL;
    size_t i;
    int n;
    int ret = -1;

3712 3713 3714 3715 3716 3717
    if (type == VIR_DOMAIN_VIRT_KVM)
        n = virXPathNodeSet("./cpu[@type='kvm']", ctxt, &nodes);
    else
        n = virXPathNodeSet("./cpu[@type='tcg']", ctxt, &nodes);

    if (n < 0) {
3718 3719 3720 3721 3722 3723 3724 3725 3726 3727
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("failed to parse qemu capabilities cpus"));
        goto cleanup;
    }

    if (n == 0) {
        ret = 0;
        goto cleanup;
    }

3728
    if (!(cpus = virDomainCapsCPUModelsNew(n)))
3729 3730
        goto cleanup;

3731 3732 3733 3734 3735
    if (type == VIR_DOMAIN_VIRT_KVM)
        qemuCaps->kvmCPUModels = cpus;
    else
        qemuCaps->tcgCPUModels = cpus;

3736
    for (i = 0; i < n; i++) {
3737 3738 3739 3740 3741 3742 3743 3744 3745 3746
        int usable = VIR_DOMCAPS_CPU_USABLE_UNKNOWN;

        if ((str = virXMLPropString(nodes[i], "usable")) &&
            (usable = virDomainCapsCPUUsableTypeFromString(str)) < 0) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("unknown value '%s' in attribute 'usable'"), str);
            goto cleanup;
        }
        VIR_FREE(str);

3747 3748 3749 3750 3751 3752
        if (!(str = virXMLPropString(nodes[i], "name"))) {
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("missing cpu name in QEMU capabilities cache"));
            goto cleanup;
        }

3753
        if (virDomainCapsCPUModelsAddSteal(cpus, &str, usable) < 0)
3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765
            goto cleanup;
    }

    ret = 0;

 cleanup:
    VIR_FREE(nodes);
    VIR_FREE(str);
    return ret;
}


3766 3767 3768 3769 3770 3771
/*
 * Parsing a doc that looks like
 *
 * <qemuCaps>
 *   <qemuctime>234235253</qemuctime>
 *   <selfctime>234235253</selfctime>
3772
 *   <selfvers>1002016</selfvers>
3773 3774 3775 3776 3777 3778
 *   <usedQMP/>
 *   <flag name='foo'/>
 *   <flag name='bar'/>
 *   ...
 *   <cpu name="pentium3"/>
 *   ...
3779
 *   <machine name="pc-1.0" alias="pc" hotplugCpus='yes' maxCpus="4"/>
3780 3781 3782
 *   ...
 * </qemuCaps>
 */
3783
int
3784 3785 3786 3787
virQEMUCapsLoadCache(virCapsPtr caps,
                     virQEMUCapsPtr qemuCaps,
                     const char *filename,
                     time_t *selfctime,
3788
                     unsigned long *selfvers)
3789 3790 3791 3792 3793 3794 3795
{
    xmlDocPtr doc = NULL;
    int ret = -1;
    size_t i;
    int n;
    xmlNodePtr *nodes = NULL;
    xmlXPathContextPtr ctxt = NULL;
J
Ján Tomko 已提交
3796
    char *str = NULL;
3797
    long long int l;
3798
    unsigned long lu;
3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822

    if (!(doc = virXMLParseFile(filename)))
        goto cleanup;

    if (!(ctxt = xmlXPathNewContext(doc))) {
        virReportOOMError();
        goto cleanup;
    }

    ctxt->node = xmlDocGetRootElement(doc);

    if (STRNEQ((const char *)ctxt->node->name, "qemuCaps")) {
        virReportError(VIR_ERR_XML_ERROR,
                       _("unexpected root element <%s>, "
                         "expecting <qemuCaps>"),
                       ctxt->node->name);
        goto cleanup;
    }

    if (virXPathLongLong("string(./qemuctime)", ctxt, &l) < 0) {
        virReportError(VIR_ERR_XML_ERROR, "%s",
                       _("missing qemuctime in QEMU capabilities XML"));
        goto cleanup;
    }
3823
    qemuCaps->ctime = (time_t)l;
3824 3825 3826 3827 3828 3829 3830 3831

    if (virXPathLongLong("string(./selfctime)", ctxt, &l) < 0) {
        virReportError(VIR_ERR_XML_ERROR, "%s",
                       _("missing selfctime in QEMU capabilities XML"));
        goto cleanup;
    }
    *selfctime = (time_t)l;

3832 3833 3834 3835
    *selfvers = 0;
    if (virXPathULong("string(./selfvers)", ctxt, &lu) == 0)
        *selfvers = lu;

3836 3837 3838 3839 3840 3841 3842 3843 3844
    qemuCaps->usedQMP = virXPathBoolean("count(./usedQMP) > 0",
                                        ctxt) > 0;

    if ((n = virXPathNodeSet("./flag", ctxt, &nodes)) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("failed to parse qemu capabilities flags"));
        goto cleanup;
    }
    VIR_DEBUG("Got flags %d", n);
3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856
    for (i = 0; i < n; i++) {
        int flag;
        if (!(str = virXMLPropString(nodes[i], "name"))) {
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("missing flag name in QEMU capabilities cache"));
            goto cleanup;
        }
        flag = virQEMUCapsTypeFromString(str);
        if (flag < 0) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Unknown qemu capabilities flag %s"), str);
            goto cleanup;
3857
        }
3858 3859
        VIR_FREE(str);
        virQEMUCapsSet(qemuCaps, flag);
3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874
    }
    VIR_FREE(nodes);

    if (virXPathUInt("string(./version)", ctxt, &qemuCaps->version) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("missing version in QEMU capabilities cache"));
        goto cleanup;
    }

    if (virXPathUInt("string(./kvmVersion)", ctxt, &qemuCaps->kvmVersion) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("missing version in QEMU capabilities cache"));
        goto cleanup;
    }

3875 3876 3877 3878 3879 3880
    if (virXPathBoolean("boolean(./package)", ctxt) > 0) {
        qemuCaps->package = virXPathString("string(./package)", ctxt);
        if (!qemuCaps->package &&
            VIR_STRDUP(qemuCaps->package, "") < 0)
            goto cleanup;
    }
3881

3882 3883 3884 3885 3886 3887 3888 3889 3890 3891
    if (!(str = virXPathString("string(./arch)", ctxt))) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("missing arch in QEMU capabilities cache"));
        goto cleanup;
    }
    if (!(qemuCaps->arch = virArchFromString(str))) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("unknown arch %s in QEMU capabilities cache"), str);
        goto cleanup;
    }
J
Ján Tomko 已提交
3892
    VIR_FREE(str);
3893

3894 3895
    if (virQEMUCapsLoadHostCPUModelInfo(qemuCaps, ctxt, VIR_DOMAIN_VIRT_KVM) < 0 ||
        virQEMUCapsLoadHostCPUModelInfo(qemuCaps, ctxt, VIR_DOMAIN_VIRT_QEMU) < 0)
3896 3897
        goto cleanup;

3898 3899
    if (virQEMUCapsLoadCPUModels(qemuCaps, ctxt, VIR_DOMAIN_VIRT_KVM) < 0 ||
        virQEMUCapsLoadCPUModels(qemuCaps, ctxt, VIR_DOMAIN_VIRT_QEMU) < 0)
3900 3901 3902 3903 3904 3905 3906 3907 3908
        goto cleanup;

    if ((n = virXPathNodeSet("./machine", ctxt, &nodes)) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("failed to parse qemu capabilities machines"));
        goto cleanup;
    }
    if (n > 0) {
        qemuCaps->nmachineTypes = n;
3909
        if (VIR_ALLOC_N(qemuCaps->machineTypes, qemuCaps->nmachineTypes) < 0)
3910 3911 3912
            goto cleanup;

        for (i = 0; i < n; i++) {
3913
            if (!(qemuCaps->machineTypes[i].name = virXMLPropString(nodes[i], "name"))) {
3914 3915 3916 3917
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("missing machine name in QEMU capabilities cache"));
                goto cleanup;
            }
3918
            qemuCaps->machineTypes[i].alias = virXMLPropString(nodes[i], "alias");
3919 3920 3921

            str = virXMLPropString(nodes[i], "maxCpus");
            if (str &&
3922
                virStrToLong_ui(str, NULL, 10, &(qemuCaps->machineTypes[i].maxCpus)) < 0) {
3923 3924 3925 3926
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("malformed machine cpu count in QEMU capabilities cache"));
                goto cleanup;
            }
J
Ján Tomko 已提交
3927
            VIR_FREE(str);
3928 3929 3930 3931 3932

            str = virXMLPropString(nodes[i], "hotplugCpus");
            if (STREQ_NULLABLE(str, "yes"))
                qemuCaps->machineTypes[i].hotplugCpus = true;
            VIR_FREE(str);
3933 3934 3935 3936
        }
    }
    VIR_FREE(nodes);

A
Andrea Bolognani 已提交
3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002
    if ((n = virXPathNodeSet("./gic", ctxt, &nodes)) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("failed to parse qemu capabilities gic"));
        goto cleanup;
    }
    if (n > 0) {
        unsigned int uintValue;
        bool boolValue;

        qemuCaps->ngicCapabilities = n;
        if (VIR_ALLOC_N(qemuCaps->gicCapabilities, n) < 0)
            goto cleanup;

        for (i = 0; i < n; i++) {
            virGICCapabilityPtr cap = &qemuCaps->gicCapabilities[i];

            if (!(str = virXMLPropString(nodes[i], "version"))) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("missing GIC version "
                                 "in QEMU capabilities cache"));
                goto cleanup;
            }
            if (virStrToLong_ui(str, NULL, 10, &uintValue) < 0) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("malformed GIC version "
                                 "in QEMU capabilities cache"));
                goto cleanup;
            }
            cap->version = uintValue;
            VIR_FREE(str);

            if (!(str = virXMLPropString(nodes[i], "kernel"))) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("missing in-kernel GIC information "
                                 "in QEMU capabilities cache"));
                goto cleanup;
            }
            if (!(boolValue = STREQ(str, "yes")) && STRNEQ(str, "no")) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("malformed in-kernel GIC information "
                                 "in QEMU capabilities cache"));
                goto cleanup;
            }
            if (boolValue)
                cap->implementation |= VIR_GIC_IMPLEMENTATION_KERNEL;
            VIR_FREE(str);

            if (!(str = virXMLPropString(nodes[i], "emulated"))) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("missing emulated GIC information "
                                 "in QEMU capabilities cache"));
                goto cleanup;
            }
            if (!(boolValue = STREQ(str, "yes")) && STRNEQ(str, "no")) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("malformed emulated GIC information "
                                 "in QEMU capabilities cache"));
                goto cleanup;
            }
            if (boolValue)
                cap->implementation |= VIR_GIC_IMPLEMENTATION_EMULATED;
            VIR_FREE(str);
        }
    }
    VIR_FREE(nodes);

4003 4004
    virQEMUCapsInitHostCPUModel(qemuCaps, caps, VIR_DOMAIN_VIRT_KVM);
    virQEMUCapsInitHostCPUModel(qemuCaps, caps, VIR_DOMAIN_VIRT_QEMU);
4005

4006
    ret = 0;
4007
 cleanup:
J
Ján Tomko 已提交
4008
    VIR_FREE(str);
4009 4010 4011 4012 4013 4014 4015
    VIR_FREE(nodes);
    xmlXPathFreeContext(ctxt);
    xmlFreeDoc(doc);
    return ret;
}


4016 4017
static void
virQEMUCapsFormatHostCPUModelInfo(virQEMUCapsPtr qemuCaps,
4018 4019
                                  virBufferPtr buf,
                                  virDomainVirtType type)
4020
{
4021 4022 4023
    virQEMUCapsHostCPUDataPtr cpuData = virQEMUCapsGetHostCPUData(qemuCaps, type);
    qemuMonitorCPUModelInfoPtr model = cpuData->info;
    const char *typeStr = type == VIR_DOMAIN_VIRT_KVM ? "kvm" : "tcg";
4024 4025
    size_t i;

4026 4027 4028
    if (!model)
        return;

4029 4030 4031 4032
    virBufferAsprintf(buf,
                      "<hostCPU type='%s' model='%s' migratability='%s'>\n",
                      typeStr, model->name,
                      model->migratability ? "yes" : "no");
4033 4034 4035
    virBufferAdjustIndent(buf, 2);

    for (i = 0; i < model->nprops; i++) {
4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058
        qemuMonitorCPUPropertyPtr prop = model->props + i;

        virBufferAsprintf(buf, "<property name='%s' type='%s' ",
                          prop->name,
                          qemuMonitorCPUPropertyTypeToString(prop->type));

        switch (prop->type) {
        case QEMU_MONITOR_CPU_PROPERTY_BOOLEAN:
            virBufferAsprintf(buf, "value='%s'",
                              prop->value.boolean ? "true" : "false");
            break;

        case QEMU_MONITOR_CPU_PROPERTY_STRING:
            virBufferEscapeString(buf, "value='%s'", prop->value.string);
            break;

        case QEMU_MONITOR_CPU_PROPERTY_NUMBER:
            virBufferAsprintf(buf, "value='%lld'", prop->value.number);
            break;

        case QEMU_MONITOR_CPU_PROPERTY_LAST:
            break;
        }
4059 4060 4061 4062 4063

        if (prop->migratable > 0)
            virBufferAsprintf(buf, " migratable='%s'",
                              virTristateBoolTypeToString(prop->migratable));

4064
        virBufferAddLit(buf, "/>\n");
4065 4066 4067 4068 4069 4070 4071
    }

    virBufferAdjustIndent(buf, -2);
    virBufferAddLit(buf, "</hostCPU>\n");
}


4072 4073
static void
virQEMUCapsFormatCPUModels(virQEMUCapsPtr qemuCaps,
4074 4075
                           virBufferPtr buf,
                           virDomainVirtType type)
4076
{
4077 4078
    virDomainCapsCPUModelsPtr cpus;
    const char *typeStr;
4079 4080
    size_t i;

4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092
    if (type == VIR_DOMAIN_VIRT_KVM) {
        typeStr = "kvm";
        cpus = qemuCaps->kvmCPUModels;
    } else {
        typeStr = "tcg";
        cpus = qemuCaps->tcgCPUModels;
    }

    if (!cpus)
        return;

    for (i = 0; i < cpus->nmodels; i++) {
4093 4094
        virDomainCapsCPUModelPtr cpu = cpus->models + i;

4095
        virBufferAsprintf(buf, "<cpu type='%s' ", typeStr);
4096 4097 4098 4099 4100 4101
        virBufferEscapeString(buf, "name='%s'", cpu->name);
        if (cpu->usable) {
            virBufferAsprintf(buf, " usable='%s'",
                              virDomainCapsCPUUsableTypeToString(cpu->usable));
        }
        virBufferAddLit(buf, "/>\n");
4102 4103 4104 4105
    }
}


4106
char *
4107 4108 4109
virQEMUCapsFormatCache(virQEMUCapsPtr qemuCaps,
                       time_t selfCTime,
                       unsigned long selfVersion)
4110 4111
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
4112
    char *ret = NULL;
4113 4114 4115
    size_t i;

    virBufferAddLit(&buf, "<qemuCaps>\n");
4116
    virBufferAdjustIndent(&buf, 2);
4117

4118
    virBufferAsprintf(&buf, "<qemuctime>%llu</qemuctime>\n",
4119
                      (long long) qemuCaps->ctime);
4120
    virBufferAsprintf(&buf, "<selfctime>%llu</selfctime>\n",
4121
                      (long long) selfCTime);
4122
    virBufferAsprintf(&buf, "<selfvers>%lu</selfvers>\n",
4123
                      (unsigned long) selfVersion);
4124 4125

    if (qemuCaps->usedQMP)
4126
        virBufferAddLit(&buf, "<usedQMP/>\n");
4127 4128 4129

    for (i = 0; i < QEMU_CAPS_LAST; i++) {
        if (virQEMUCapsGet(qemuCaps, i)) {
4130
            virBufferAsprintf(&buf, "<flag name='%s'/>\n",
4131 4132 4133 4134
                              virQEMUCapsTypeToString(i));
        }
    }

4135
    virBufferAsprintf(&buf, "<version>%d</version>\n",
4136 4137
                      qemuCaps->version);

4138
    virBufferAsprintf(&buf, "<kvmVersion>%d</kvmVersion>\n",
4139 4140
                      qemuCaps->kvmVersion);

4141 4142 4143 4144
    if (qemuCaps->package)
        virBufferAsprintf(&buf, "<package>%s</package>\n",
                          qemuCaps->package);

4145
    virBufferAsprintf(&buf, "<arch>%s</arch>\n",
4146 4147
                      virArchToString(qemuCaps->arch));

4148 4149
    virQEMUCapsFormatHostCPUModelInfo(qemuCaps, &buf, VIR_DOMAIN_VIRT_KVM);
    virQEMUCapsFormatHostCPUModelInfo(qemuCaps, &buf, VIR_DOMAIN_VIRT_QEMU);
4150

4151 4152
    virQEMUCapsFormatCPUModels(qemuCaps, &buf, VIR_DOMAIN_VIRT_KVM);
    virQEMUCapsFormatCPUModels(qemuCaps, &buf, VIR_DOMAIN_VIRT_QEMU);
4153 4154

    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
4155
        virBufferEscapeString(&buf, "<machine name='%s'",
4156 4157
                              qemuCaps->machineTypes[i].name);
        if (qemuCaps->machineTypes[i].alias)
4158
            virBufferEscapeString(&buf, " alias='%s'",
4159
                              qemuCaps->machineTypes[i].alias);
4160 4161
        if (qemuCaps->machineTypes[i].hotplugCpus)
            virBufferAddLit(&buf, " hotplugCpus='yes'");
4162
        virBufferAsprintf(&buf, " maxCpus='%u'/>\n",
4163
                          qemuCaps->machineTypes[i].maxCpus);
4164 4165
    }

A
Andrea Bolognani 已提交
4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181
    for (i = 0; i < qemuCaps->ngicCapabilities; i++) {
        virGICCapabilityPtr cap;
        bool kernel;
        bool emulated;

        cap = &qemuCaps->gicCapabilities[i];
        kernel = (cap->implementation & VIR_GIC_IMPLEMENTATION_KERNEL);
        emulated = (cap->implementation & VIR_GIC_IMPLEMENTATION_EMULATED);

        virBufferAsprintf(&buf,
                          "<gic version='%d' kernel='%s' emulated='%s'/>\n",
                          cap->version,
                          kernel ? "yes" : "no",
                          emulated ? "yes" : "no");
    }

4182
    virBufferAdjustIndent(&buf, -2);
4183 4184
    virBufferAddLit(&buf, "</qemuCaps>\n");

4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196
    if (virBufferCheckError(&buf) == 0)
        ret = virBufferContentAndReset(&buf);

    return ret;
}


static int
virQEMUCapsSaveCache(virQEMUCapsPtr qemuCaps, const char *filename)
{
    char *xml = NULL;
    int ret = -1;
4197

4198 4199 4200
    xml = virQEMUCapsFormatCache(qemuCaps,
                                 virGetSelfLastChanged(),
                                 LIBVIR_VERSION_NUMBER);
4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264

    if (virFileWriteStr(filename, xml, 0600) < 0) {
        virReportSystemError(errno,
                             _("Failed to save '%s' for '%s'"),
                             filename, qemuCaps->binary);
        goto cleanup;
    }

    VIR_DEBUG("Saved caps '%s' for '%s' with (%lld, %lld)",
              filename, qemuCaps->binary,
              (long long)qemuCaps->ctime,
              (long long)virGetSelfLastChanged());

    ret = 0;
 cleanup:
    VIR_FREE(xml);
    return ret;
}

static int
virQEMUCapsRememberCached(virQEMUCapsPtr qemuCaps, const char *cacheDir)
{
    char *capsdir = NULL;
    char *capsfile = NULL;
    int ret = -1;
    char *binaryhash = NULL;

    if (virAsprintf(&capsdir, "%s/capabilities", cacheDir) < 0)
        goto cleanup;

    if (virCryptoHashString(VIR_CRYPTO_HASH_SHA256,
                            qemuCaps->binary,
                            &binaryhash) < 0)
        goto cleanup;

    if (virAsprintf(&capsfile, "%s/%s.xml", capsdir, binaryhash) < 0)
        goto cleanup;

    if (virFileMakePath(capsdir) < 0) {
        virReportSystemError(errno,
                             _("Unable to create directory '%s'"),
                             capsdir);
        goto cleanup;
    }

    if (virQEMUCapsSaveCache(qemuCaps, capsfile) < 0)
        goto cleanup;

    ret = 0;
 cleanup:
    VIR_FREE(binaryhash);
    VIR_FREE(capsfile);
    VIR_FREE(capsdir);
    return ret;
}


static void
virQEMUCapsReset(virQEMUCapsPtr qemuCaps)
{
    size_t i;

    virBitmapClearAll(qemuCaps->flags);
    qemuCaps->version = qemuCaps->kvmVersion = 0;
4265
    VIR_FREE(qemuCaps->package);
4266 4267 4268
    qemuCaps->arch = VIR_ARCH_NONE;
    qemuCaps->usedQMP = false;

4269 4270 4271 4272
    virObjectUnref(qemuCaps->kvmCPUModels);
    qemuCaps->kvmCPUModels = NULL;
    virObjectUnref(qemuCaps->tcgCPUModels);
    qemuCaps->tcgCPUModels = NULL;
4273 4274

    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
4275 4276
        VIR_FREE(qemuCaps->machineTypes[i].name);
        VIR_FREE(qemuCaps->machineTypes[i].alias);
4277 4278 4279
    }
    VIR_FREE(qemuCaps->machineTypes);
    qemuCaps->nmachineTypes = 0;
A
Andrea Bolognani 已提交
4280 4281 4282

    VIR_FREE(qemuCaps->gicCapabilities);
    qemuCaps->ngicCapabilities = 0;
4283

4284 4285
    virQEMUCapsHostCPUDataClear(&qemuCaps->kvmCPU);
    virQEMUCapsHostCPUDataClear(&qemuCaps->tcgCPU);
4286 4287 4288 4289
}


static int
4290 4291
virQEMUCapsInitCached(virCapsPtr caps,
                      virQEMUCapsPtr qemuCaps,
4292 4293 4294
                      const char *cacheDir,
                      uid_t runUid,
                      gid_t runGid)
4295 4296 4297 4298 4299 4300
{
    char *capsdir = NULL;
    char *capsfile = NULL;
    int ret = -1;
    char *binaryhash = NULL;
    struct stat sb;
4301
    time_t qemuctime = qemuCaps->ctime;
4302
    time_t selfctime;
4303
    unsigned long selfvers;
4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335

    if (virAsprintf(&capsdir, "%s/capabilities", cacheDir) < 0)
        goto cleanup;

    if (virCryptoHashString(VIR_CRYPTO_HASH_SHA256,
                            qemuCaps->binary,
                            &binaryhash) < 0)
        goto cleanup;

    if (virAsprintf(&capsfile, "%s/%s.xml", capsdir, binaryhash) < 0)
        goto cleanup;

    if (virFileMakePath(capsdir) < 0) {
        virReportSystemError(errno,
                             _("Unable to create directory '%s'"),
                             capsdir);
        goto cleanup;
    }

    if (stat(capsfile, &sb) < 0) {
        if (errno == ENOENT) {
            VIR_DEBUG("No cached capabilities '%s' for '%s'",
                      capsfile, qemuCaps->binary);
            ret = 0;
            goto cleanup;
        }
        virReportSystemError(errno,
                             _("Unable to access cache '%s' for '%s'"),
                             capsfile, qemuCaps->binary);
        goto cleanup;
    }

4336
    if (virQEMUCapsLoadCache(caps, qemuCaps, capsfile,
4337
                             &selfctime, &selfvers) < 0) {
4338
        VIR_WARN("Failed to load cached caps from '%s' for '%s': %s",
4339
                 capsfile, qemuCaps->binary, virGetLastErrorMessage());
4340
        virResetLastError();
4341
        goto discard;
4342 4343
    }

4344
    if (!virQEMUCapsIsValid(qemuCaps, qemuctime, runUid, runGid))
4345 4346
        goto discard;

4347
    /* Discard cache if QEMU binary or libvirtd changed */
4348
    if (selfctime != virGetSelfLastChanged() ||
4349
        selfvers != LIBVIR_VERSION_NUMBER) {
4350 4351 4352
        VIR_DEBUG("Outdated capabilities for '%s': libvirt changed "
                  "(%lld vs %lld, %lu vs %lu)",
                  qemuCaps->binary,
4353 4354
                  (long long)selfctime, (long long)virGetSelfLastChanged(),
                  selfvers, (unsigned long)LIBVIR_VERSION_NUMBER);
4355
        goto discard;
4356 4357 4358 4359 4360 4361 4362 4363
    }

    VIR_DEBUG("Loaded '%s' for '%s' ctime %lld usedQMP=%d",
              capsfile, qemuCaps->binary,
              (long long)qemuCaps->ctime, qemuCaps->usedQMP);

    ret = 1;
 cleanup:
4364
    qemuCaps->ctime = qemuctime;
4365 4366 4367 4368
    VIR_FREE(binaryhash);
    VIR_FREE(capsfile);
    VIR_FREE(capsdir);
    return ret;
4369 4370 4371 4372 4373 4374 4375 4376

 discard:
    VIR_DEBUG("Dropping cached capabilities '%s' for '%s'",
              capsfile, qemuCaps->binary);
    ignore_value(unlink(capsfile));
    virQEMUCapsReset(qemuCaps);
    ret = 0;
    goto cleanup;
4377 4378 4379
}


4380 4381
#define QEMU_SYSTEM_PREFIX "qemu-system-"

4382
static int
4383
virQEMUCapsInitHelp(virQEMUCapsPtr qemuCaps, uid_t runUid, gid_t runGid, const char *qmperr)
4384
{
4385
    virCommandPtr cmd = NULL;
4386
    bool is_kvm;
4387
    char *help = NULL;
4388 4389
    int ret = -1;
    const char *tmp;
4390

4391
    VIR_DEBUG("qemuCaps=%p", qemuCaps);
4392

4393
    tmp = strstr(qemuCaps->binary, QEMU_SYSTEM_PREFIX);
4394 4395
    if (tmp) {
        tmp += strlen(QEMU_SYSTEM_PREFIX);
4396

4397
        qemuCaps->arch = virQEMUCapsArchFromString(tmp);
4398
    } else {
4399
        qemuCaps->arch = virArchFromHost();
4400 4401
    }

4402
    cmd = virQEMUCapsProbeCommand(qemuCaps->binary, NULL, runUid, runGid);
4403 4404 4405 4406
    virCommandAddArgList(cmd, "-help", NULL);
    virCommandSetOutputBuffer(cmd, &help);

    if (virCommandRun(cmd, NULL) < 0)
4407
        goto cleanup;
4408

4409 4410 4411 4412 4413
    if (virQEMUCapsParseHelpStr(qemuCaps->binary,
                                help, qemuCaps,
                                &qemuCaps->version,
                                &is_kvm,
                                &qemuCaps->kvmVersion,
4414 4415
                                false,
                                qmperr) < 0)
4416
        goto cleanup;
4417

4418 4419 4420 4421 4422 4423 4424
    /* Older QEMU versions reported -no-acpi in the output of -help even
     * though it was not supported by the architecture. The issue has since
     * been fixed, but to maintain compatibility with all release we still
     * need to filter out the capability for architectures that we know
     * don't support the feature, eg. anything but x86 and aarch64 */
    if (!ARCH_IS_X86(qemuCaps->arch) &&
        qemuCaps->arch != VIR_ARCH_AARCH64) {
4425
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_NO_ACPI);
4426
    }
4427

4428
    /* virQEMUCapsExtractDeviceStr will only set additional caps if qemu
4429
     * understands the 0.13.0+ notion of "-device driver,".  */
J
Ján Tomko 已提交
4430
    if (strstr(help, "-device driver,?") &&
4431 4432
        virQEMUCapsExtractDeviceStr(qemuCaps->binary,
                                    qemuCaps, runUid, runGid) < 0) {
4433
        goto cleanup;
4434
    }
4435

4436
    if (virQEMUCapsProbeCPUModels(qemuCaps, runUid, runGid) < 0)
4437
        goto cleanup;
4438

4439
    if (virQEMUCapsProbeMachineTypes(qemuCaps, runUid, runGid) < 0)
4440
        goto cleanup;
4441

4442
    ret = 0;
4443
 cleanup:
4444
    virCommandFree(cmd);
4445
    VIR_FREE(help);
4446 4447 4448 4449
    return ret;
}


4450
static void virQEMUCapsMonitorNotify(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
4451 4452
                                     virDomainObjPtr vm ATTRIBUTE_UNUSED,
                                     void *opaque ATTRIBUTE_UNUSED)
4453 4454 4455 4456
{
}

static qemuMonitorCallbacks callbacks = {
4457 4458
    .eofNotify = virQEMUCapsMonitorNotify,
    .errorNotify = virQEMUCapsMonitorNotify,
4459 4460 4461 4462 4463 4464 4465
};


/* Capabilities that we assume are always enabled
 * for QEMU >= 1.2.0
 */
static void
4466
virQEMUCapsInitQMPBasic(virQEMUCapsPtr qemuCaps)
4467
{
4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_MEM_PATH);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_SERIAL);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_MONITOR_JSON);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_SDL);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_RTC);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_VHOST_NET);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_NODEFCONFIG);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_BOOT_MENU);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_NAME_PROCESS);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_SMBIOS_TYPE);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA_NONE);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_AIO);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_SHUTDOWN);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_UNSAFE);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV_READONLY);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_COPY_ON_READ);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV_WRITEOUT);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_IOTUNE);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_WAKEUP);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV_BRIDGE);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_SECCOMP_SANDBOX);
O
Olivia Yin 已提交
4495
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DTB);
J
Ján Tomko 已提交
4496
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_IPV6_MIGRATION);
4497 4498
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_OPT);
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DUMP_GUEST_CORE);
4499
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC_SHARE_POLICY);
4500
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_HOST_PCI_MULTIDOMAIN);
P
Paolo Bonzini 已提交
4501
    virQEMUCapsSet(qemuCaps, QEMU_CAPS_DISPLAY);
4502 4503
}

4504 4505 4506 4507 4508 4509 4510 4511 4512

/**
 * virQEMUCapsInitQMPArch:
 * @qemuCaps: QEMU capabilities
 * @mon: QEMU monitor
 *
 * Initialize the architecture for @qemuCaps by asking @mon.
 *
 * Returns: 0 on success, <0 on failure
4513 4514
 */
static int
4515
virQEMUCapsInitQMPArch(virQEMUCapsPtr qemuCaps,
4516 4517 4518 4519 4520 4521
                            qemuMonitorPtr mon)
{
    char *archstr = NULL;
    int ret = -1;

    if (!(archstr = qemuMonitorGetTargetArch(mon)))
4522
        goto cleanup;
4523 4524 4525 4526 4527 4528 4529

    if ((qemuCaps->arch = virQEMUCapsArchFromString(archstr)) == VIR_ARCH_NONE) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Unknown QEMU arch %s"), archstr);
        goto cleanup;
    }

4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543
    ret = 0;

 cleanup:
    VIR_FREE(archstr);
    return ret;
}


/**
 * virQEMUCapsInitQMPBasicArch:
 * @qemuCaps: QEMU capabilities
 *
 * Initialize @qemuCaps with basic architecture-dependent capabilities.
 */
4544
void
4545 4546
virQEMUCapsInitQMPBasicArch(virQEMUCapsPtr qemuCaps)
{
4547 4548 4549
    /* ACPI only works on x86 and aarch64 */
    if (ARCH_IS_X86(qemuCaps->arch) ||
        qemuCaps->arch == VIR_ARCH_AARCH64) {
4550
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_ACPI);
4551 4552 4553 4554
    }

    /* HPET and KVM PIT are x86 specific */
    if (ARCH_IS_X86(qemuCaps->arch)) {
J
Ján Tomko 已提交
4555
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_HPET);
4556 4557 4558
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_KVM_PIT);
    }
}
4559

4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599

/**
 * virQEMUCapsQMPSchemaObjectGetType:
 * @field: name of the object containing the requested type
 * @name: name of the requested type
 * @namefield: name of the object property holding @name
 *
 * Helper that selects the type of a QMP schema object member or it's variant
 * member. Returns the type string on success or NULL on error.
 */
static const char *
virQEMUCapsQMPSchemaObjectGetType(const char *field,
                                  const char *name,
                                  const char *namefield,
                                  virJSONValuePtr elem)
{
    virJSONValuePtr arr;
    virJSONValuePtr cur;
    const char *curname;
    const char *type;
    size_t i;

    if (!(arr = virJSONValueObjectGetArray(elem, field)))
        return NULL;

    for (i = 0; i < virJSONValueArraySize(arr); i++) {
        if (!(cur = virJSONValueArrayGet(arr, i)) ||
            !(curname = virJSONValueObjectGetString(cur, namefield)) ||
            !(type = virJSONValueObjectGetString(cur, "type")))
            continue;

        if (STREQ(name, curname))
            return type;
    }

    return NULL;
}


static virJSONValuePtr
4600
virQEMUCapsQMPSchemaTraverse(const char *baseName,
4601 4602 4603 4604 4605 4606 4607
                             char **query,
                             virHashTablePtr schema)
{
    virJSONValuePtr base;
    const char *metatype;

    do {
4608
        if (!(base = virHashLookup(schema, baseName)))
4609 4610 4611 4612 4613 4614 4615 4616 4617 4618
            return NULL;

        if (!*query)
            return base;

        if (!(metatype = virJSONValueObjectGetString(base, "meta-type")))
            return NULL;

        /* flatten arrays by default */
        if (STREQ(metatype, "array")) {
4619
            if (!(baseName = virJSONValueObjectGetString(base, "element-type")))
4620 4621 4622 4623 4624
                return NULL;

            continue;
        } else if (STREQ(metatype, "object")) {
            if (**query == '+')
4625
                baseName = virQEMUCapsQMPSchemaObjectGetType("variants",
4626 4627 4628
                                                             *query + 1,
                                                             "case", base);
            else
4629
                baseName = virQEMUCapsQMPSchemaObjectGetType("members",
4630 4631 4632
                                                             *query,
                                                             "name", base);

4633
            if (!baseName)
4634 4635 4636
                return NULL;
        } else if (STREQ(metatype, "command") ||
                   STREQ(metatype, "event")) {
4637
            if (!(baseName = virJSONValueObjectGetString(base, *query)))
4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693
                return NULL;
        } else {
            /* alternates, basic types and enums can't be entered */
            return NULL;
        }

        query++;
    } while (*query);

    return base;
}


/**
 * virQEMUCapsQMPSchemaGetByPath:
 * @query: string specifying the required data type (see below)
 * @schema: hash table containing the schema data
 * @entry: filled with the located schema object requested by @query
 *
 * Retrieves the requested schema entry specified by @query to @entry. The
 * @query parameter has the following syntax which is very closely tied to the
 * qemu schema syntax entries separated by slashes with a few special characters:
 *
 * "command_or_event/attribute/subattribute/+variant_discriminator/subattribute"
 *
 * command_or_event: name of the event or attribute to introspect
 * attribute: selects whether arguments or return type should be introspected
 *            ("arg-type" or "ret-type" for commands, "arg-type" for events)
 * subattribute: specifies member name of object types
 * +variant_discriminator: In the case of unionized objects, select a
 *                         specific case to introspect.
 *
 * Array types are automatically flattened to the singular type. Alternate
 * types are currently not supported.
 *
 * The above types can be chained arbitrarily using slashes to construct any
 * path into the schema tree.
 *
 * Returns 0 on success (including if the requested schema was not found) and
 * fills @entry appropriately. On failure returns -1 and sets an appropriate
 * error message.
 */
static int
virQEMUCapsQMPSchemaGetByPath(const char *query,
                              virHashTablePtr schema,
                              virJSONValuePtr *entry)
{
    char **elems = NULL;

    *entry = NULL;

    if (!(elems = virStringSplit(query, "/", 0)))
        return -1;

    if (!*elems) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("malformed query string"));
4694
        virStringListFree(elems);
4695 4696 4697 4698 4699
        return -1;
    }

    *entry = virQEMUCapsQMPSchemaTraverse(*elems, elems + 1, schema);

4700
    virStringListFree(elems);
4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740
    return 0;
}


static bool
virQEMUCapsQMPSchemaQueryPath(const char *query,
                              virHashTablePtr schema)
{
    virJSONValuePtr entry;

    if (virQEMUCapsQMPSchemaGetByPath(query, schema, &entry))
        return false;

    return !!entry;
}


static int
virQEMUCapsProbeQMPSchemaCapabilities(virQEMUCapsPtr qemuCaps,
                                      qemuMonitorPtr mon)
{
    struct virQEMUCapsStringFlags *entry;
    virHashTablePtr schema;
    size_t i;

    if (!(schema = qemuMonitorQueryQMPSchema(mon)))
        return -1;

    for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsQMPSchemaQueries); i++) {
        entry = virQEMUCapsQMPSchemaQueries + i;

        if (virQEMUCapsQMPSchemaQueryPath(entry->value, schema))
            virQEMUCapsSet(qemuCaps, entry->flag);
    }

    virHashFree(schema);
    return 0;
}


4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752
int
virQEMUCapsInitQMPMonitor(virQEMUCapsPtr qemuCaps,
                          qemuMonitorPtr mon)
{
    int ret = -1;
    int major, minor, micro;
    char *package = NULL;

    /* @mon is supposed to be locked by callee */

    if (qemuMonitorSetCapabilities(mon) < 0) {
        VIR_DEBUG("Failed to set monitor capabilities %s",
4753
                  virGetLastErrorMessage());
4754 4755 4756 4757 4758 4759 4760 4761
        ret = 0;
        goto cleanup;
    }

    if (qemuMonitorGetVersion(mon,
                              &major, &minor, &micro,
                              &package) < 0) {
        VIR_DEBUG("Failed to query monitor version %s",
4762
                  virGetLastErrorMessage());
4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776
        ret = 0;
        goto cleanup;
    }

    VIR_DEBUG("Got version %d.%d.%d (%s)",
              major, minor, micro, NULLSTR(package));

    if (major < 1 || (major == 1 && minor < 2)) {
        VIR_DEBUG("Not new enough for QMP capabilities detection");
        ret = 0;
        goto cleanup;
    }

    qemuCaps->version = major * 1000000 + minor * 1000 + micro;
4777
    qemuCaps->package = package;
4778 4779 4780 4781
    qemuCaps->usedQMP = true;

    virQEMUCapsInitQMPBasic(qemuCaps);

4782
    if (virQEMUCapsInitQMPArch(qemuCaps, mon) < 0)
4783 4784
        goto cleanup;

4785 4786
    virQEMUCapsInitQMPBasicArch(qemuCaps);

4787 4788 4789 4790 4791 4792 4793 4794
    /* USB option is supported v1.3.0 onwards */
    if (qemuCaps->version >= 1003000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_USB_OPT);

    /* WebSockets were introduced between 1.3.0 and 1.3.1 */
    if (qemuCaps->version >= 1003001)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC_WEBSOCKET);

4795 4796 4797 4798 4799 4800
    /* -chardev spiceport is supported from 1.4.0, but usable through
     * qapi only since 1.5.0, however, it still cannot be queried
     * for as a capability */
    if (qemuCaps->version >= 1005000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEPORT);

4801 4802 4803
    if (qemuCaps->version >= 1006000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEVICE_VIDEO_PRIMARY);

4804 4805 4806 4807
    /* vmport option is supported v2.2.0 onwards */
    if (qemuCaps->version >= 2002000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_VMPORT_OPT);

4808 4809 4810 4811 4812 4813
    /* -cpu ...,aarch64=off supported in v2.3.0 and onwards. But it
       isn't detectable via qmp at this point */
    if (qemuCaps->arch == VIR_ARCH_AARCH64 &&
        qemuCaps->version >= 2003000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_CPU_AARCH64_OFF);

4814 4815 4816
    /* vhost-user supports multi-queue from v2.4.0 onwards,
     * but there is no way to query for that capability */
    if (qemuCaps->version >= 2004000)
J
Ján Tomko 已提交
4817
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_VHOSTUSER_MULTIQUEUE);
4818

M
Michal Privoznik 已提交
4819 4820 4821 4822
    /* smm option is supported from v2.4.0 */
    if (qemuCaps->version >= 2004000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_SMM_OPT);

4823 4824 4825 4826
    /* Since 2.4.50 ARM virt machine supports gic-version option */
    if (qemuCaps->version >= 2004050)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACH_VIRT_GIC_VERSION);

4827 4828 4829 4830
    /* no way to query if -machine kernel_irqchip supports split */
    if (qemuCaps->version >= 2006000)
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_KERNEL_IRQCHIP_SPLIT);

4831 4832
    if (virQEMUCapsProbeQMPCommands(qemuCaps, mon) < 0)
        goto cleanup;
J
Jiri Denemark 已提交
4833 4834 4835 4836 4837

    /* Some capabilities may differ depending on KVM state */
    if (virQEMUCapsProbeQMPKVMState(qemuCaps, mon) < 0)
        goto cleanup;

4838 4839 4840 4841 4842 4843
    if (virQEMUCapsProbeQMPEvents(qemuCaps, mon) < 0)
        goto cleanup;
    if (virQEMUCapsProbeQMPObjects(qemuCaps, mon) < 0)
        goto cleanup;
    if (virQEMUCapsProbeQMPMachineTypes(qemuCaps, mon) < 0)
        goto cleanup;
4844
    if (virQEMUCapsProbeQMPCPUDefinitions(qemuCaps, mon, false) < 0)
4845 4846 4847 4848 4849
        goto cleanup;
    if (virQEMUCapsProbeQMPTPM(qemuCaps, mon) < 0)
        goto cleanup;
    if (virQEMUCapsProbeQMPCommandLine(qemuCaps, mon) < 0)
        goto cleanup;
4850 4851
    if (virQEMUCapsProbeQMPMigrationCapabilities(qemuCaps, mon) < 0)
        goto cleanup;
4852 4853 4854
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_QMP_SCHEMA) &&
        virQEMUCapsProbeQMPSchemaCapabilities(qemuCaps, mon) < 0)
        goto cleanup;
4855
    if (virQEMUCapsProbeQMPHostCPU(qemuCaps, mon, false) < 0)
4856
        goto cleanup;
4857

4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868
    /* 'intel-iommu' shows up as a device since 2.2.0, but can
     * not be used with -device until 2.7.0. Before that it
     * requires -machine iommu=on. So we must clear the device
     * capability we detected on older QEMUs
     */
    if (qemuCaps->version < 2007000 &&
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_INTEL_IOMMU)) {
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_DEVICE_INTEL_IOMMU);
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_IOMMU);
    }

A
Andrea Bolognani 已提交
4869 4870 4871 4872 4873 4874
    /* GIC capabilities, eg. available GIC versions */
    if ((qemuCaps->arch == VIR_ARCH_AARCH64 ||
         qemuCaps->arch == VIR_ARCH_ARMV7L) &&
        virQEMUCapsProbeQMPGICCapabilities(qemuCaps, mon) < 0)
        goto cleanup;

4875 4876 4877 4878 4879 4880 4881
    /* Prealloc on NVDIMMs is broken on older QEMUs leading to
     * user data corruption. If we are dealing with such version
     * of QEMU pretend we don't know how to NVDIMM. */
    if (qemuCaps->version < 2009000 &&
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_NVDIMM))
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_DEVICE_NVDIMM);

4882 4883 4884 4885
    if (ARCH_IS_X86(qemuCaps->arch) &&
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION))
        virQEMUCapsSet(qemuCaps, QEMU_CAPS_CPU_CACHE);

4886
    ret = 0;
4887
 cleanup:
4888 4889 4890
    return ret;
}

4891

4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904
int
virQEMUCapsInitQMPMonitorTCG(virQEMUCapsPtr qemuCaps ATTRIBUTE_UNUSED,
                             qemuMonitorPtr mon)
{
    int ret = -1;

    if (qemuMonitorSetCapabilities(mon) < 0) {
        VIR_DEBUG("Failed to set monitor capabilities %s",
                  virGetLastErrorMessage());
        ret = 0;
        goto cleanup;
    }

4905 4906 4907
    if (virQEMUCapsProbeQMPCPUDefinitions(qemuCaps, mon, true) < 0)
        goto cleanup;

4908 4909 4910
    if (virQEMUCapsProbeQMPHostCPU(qemuCaps, mon, true) < 0)
        goto cleanup;

4911 4912 4913 4914 4915 4916
    ret = 0;
 cleanup:
    return ret;
}


4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928
typedef struct _virQEMUCapsInitQMPCommand virQEMUCapsInitQMPCommand;
typedef virQEMUCapsInitQMPCommand *virQEMUCapsInitQMPCommandPtr;
struct _virQEMUCapsInitQMPCommand {
    char *binary;
    uid_t runUid;
    gid_t runGid;
    char **qmperr;
    char *monarg;
    char *monpath;
    char *pidfile;
    virCommandPtr cmd;
    qemuMonitorPtr mon;
4929
    virDomainChrSourceDef config;
4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001
    pid_t pid;
    virDomainObjPtr vm;
};


static void
virQEMUCapsInitQMPCommandAbort(virQEMUCapsInitQMPCommandPtr cmd)
{
    if (cmd->mon)
        virObjectUnlock(cmd->mon);
    qemuMonitorClose(cmd->mon);
    cmd->mon = NULL;

    virCommandAbort(cmd->cmd);
    virCommandFree(cmd->cmd);
    cmd->cmd = NULL;

    if (cmd->monpath)
        ignore_value(unlink(cmd->monpath));

    virDomainObjEndAPI(&cmd->vm);

    if (cmd->pid != 0) {
        char ebuf[1024];

        VIR_DEBUG("Killing QMP caps process %lld", (long long) cmd->pid);
        if (virProcessKill(cmd->pid, SIGKILL) < 0 && errno != ESRCH)
            VIR_ERROR(_("Failed to kill process %lld: %s"),
                      (long long) cmd->pid,
                      virStrerror(errno, ebuf, sizeof(ebuf)));

        VIR_FREE(*cmd->qmperr);
    }
    if (cmd->pidfile)
        unlink(cmd->pidfile);
    cmd->pid = 0;
}


static void
virQEMUCapsInitQMPCommandFree(virQEMUCapsInitQMPCommandPtr cmd)
{
    if (!cmd)
        return;

    virQEMUCapsInitQMPCommandAbort(cmd);
    VIR_FREE(cmd->binary);
    VIR_FREE(cmd->monpath);
    VIR_FREE(cmd->monarg);
    VIR_FREE(cmd->pidfile);
    VIR_FREE(cmd);
}


static virQEMUCapsInitQMPCommandPtr
virQEMUCapsInitQMPCommandNew(char *binary,
                             const char *libDir,
                             uid_t runUid,
                             gid_t runGid,
                             char **qmperr)
{
    virQEMUCapsInitQMPCommandPtr cmd = NULL;

    if (VIR_ALLOC(cmd) < 0)
        goto error;

    if (VIR_STRDUP(cmd->binary, binary) < 0)
        goto error;

    cmd->runUid = runUid;
    cmd->runGid = runGid;
    cmd->qmperr = qmperr;
5002

5003 5004 5005
    /* the ".sock" sufix is important to avoid a possible clash with a qemu
     * domain called "capabilities"
     */
5006 5007 5008 5009 5010
    if (virAsprintf(&cmd->monpath, "%s/%s", libDir,
                    "capabilities.monitor.sock") < 0)
        goto error;
    if (virAsprintf(&cmd->monarg, "unix:%s,server,nowait", cmd->monpath) < 0)
        goto error;
5011

5012 5013
    /* ".pidfile" suffix is used rather than ".pid" to avoid a possible clash
     * with a qemu domain called "capabilities"
5014 5015 5016
     * Normally we'd use runDir for pid files, but because we're using
     * -daemonize we need QEMU to be allowed to create them, rather
     * than libvirtd. So we're using libDir which QEMU can write to
5017
     */
5018 5019
    if (virAsprintf(&cmd->pidfile, "%s/%s", libDir, "capabilities.pidfile") < 0)
        goto error;
5020

5021
    virPidFileForceCleanupPath(cmd->pidfile);
5022

5023 5024 5025
    cmd->config.type = VIR_DOMAIN_CHR_TYPE_UNIX;
    cmd->config.data.nix.path = cmd->monpath;
    cmd->config.data.nix.listen = false;
5026

5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039
    return cmd;

 error:
    virQEMUCapsInitQMPCommandFree(cmd);
    return NULL;
}


/* Returns -1 on fatal error,
 *          0 on success,
 *          1 when probing QEMU failed
 */
static int
5040 5041
virQEMUCapsInitQMPCommandRun(virQEMUCapsInitQMPCommandPtr cmd,
                             bool forceTCG)
5042 5043
{
    virDomainXMLOptionPtr xmlopt = NULL;
5044
    const char *machine;
5045 5046 5047
    int status = 0;
    int ret = -1;

5048 5049 5050 5051 5052 5053 5054
    if (forceTCG)
        machine = "none,accel=tcg";
    else
        machine = "none,accel=kvm:tcg";

    VIR_DEBUG("Try to probe capabilities of '%s' via QMP, machine %s",
              cmd->binary, machine);
5055

5056 5057 5058 5059 5060 5061 5062
    /*
     * We explicitly need to use -daemonize here, rather than
     * virCommandDaemonize, because we need to synchronize
     * with QEMU creating its monitor socket API. Using
     * daemonize guarantees control won't return to libvirt
     * until the socket is present.
     */
5063 5064 5065 5066 5067
    cmd->cmd = virCommandNewArgList(cmd->binary,
                                    "-S",
                                    "-no-user-config",
                                    "-nodefaults",
                                    "-nographic",
5068
                                    "-machine", machine,
5069 5070 5071 5072 5073 5074 5075 5076 5077 5078
                                    "-qmp", cmd->monarg,
                                    "-pidfile", cmd->pidfile,
                                    "-daemonize",
                                    NULL);
    virCommandAddEnvPassCommon(cmd->cmd);
    virCommandClearCaps(cmd->cmd);
    virCommandSetGID(cmd->cmd, cmd->runGid);
    virCommandSetUID(cmd->cmd, cmd->runUid);

    virCommandSetErrorBuffer(cmd->cmd, cmd->qmperr);
5079

5080
    /* Log, but otherwise ignore, non-zero status.  */
5081
    if (virCommandRun(cmd->cmd, &status) < 0)
5082 5083 5084
        goto cleanup;

    if (status != 0) {
5085
        VIR_DEBUG("QEMU %s exited with status %d: %s",
5086 5087
                  cmd->binary, status, *cmd->qmperr);
        goto ignore;
5088 5089
    }

5090 5091 5092
    if (virPidFileReadPath(cmd->pidfile, &cmd->pid) < 0) {
        VIR_DEBUG("Failed to read pidfile %s", cmd->pidfile);
        goto ignore;
5093 5094
    }

5095
    if (!(xmlopt = virDomainXMLOptionNew(NULL, NULL, NULL, NULL, NULL)) ||
5096
        !(cmd->vm = virDomainObjNew(xmlopt)))
5097 5098
        goto cleanup;

5099
    cmd->vm->pid = cmd->pid;
5100

5101
    if (!(cmd->mon = qemuMonitorOpen(cmd->vm, &cmd->config, true,
5102
                                     0, &callbacks, NULL)))
5103
        goto ignore;
5104

5105
    virObjectLock(cmd->mon);
5106 5107 5108

    ret = 0;

5109
 cleanup:
5110 5111
    if (!cmd->mon)
        virQEMUCapsInitQMPCommandAbort(cmd);
5112
    virObjectUnref(xmlopt);
5113

5114
    return ret;
5115

5116 5117 5118 5119
 ignore:
    ret = 1;
    goto cleanup;
}
5120

5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136

static int
virQEMUCapsInitQMP(virQEMUCapsPtr qemuCaps,
                   const char *libDir,
                   uid_t runUid,
                   gid_t runGid,
                   char **qmperr)
{
    virQEMUCapsInitQMPCommandPtr cmd = NULL;
    int ret = -1;
    int rc;

    if (!(cmd = virQEMUCapsInitQMPCommandNew(qemuCaps->binary, libDir,
                                             runUid, runGid, qmperr)))
        goto cleanup;

5137
    if ((rc = virQEMUCapsInitQMPCommandRun(cmd, false)) != 0) {
5138 5139 5140
        if (rc == 1)
            ret = 0;
        goto cleanup;
5141
    }
5142 5143 5144 5145

    if (virQEMUCapsInitQMPMonitor(qemuCaps, cmd->mon) < 0)
        goto cleanup;

5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
        virQEMUCapsInitQMPCommandAbort(cmd);
        if ((rc = virQEMUCapsInitQMPCommandRun(cmd, true)) != 0) {
            if (rc == 1)
                ret = 0;
            goto cleanup;
        }

        if (virQEMUCapsInitQMPMonitorTCG(qemuCaps, cmd->mon) < 0)
            goto cleanup;
    }

5158 5159 5160 5161
    ret = 0;

 cleanup:
    virQEMUCapsInitQMPCommandFree(cmd);
5162 5163 5164 5165
    return ret;
}


5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176
#define MESSAGE_ID_CAPS_PROBE_FAILURE "8ae2f3fb-2dbe-498e-8fbd-012d40afa361"

static void
virQEMUCapsLogProbeFailure(const char *binary)
{
    virLogMetadata meta[] = {
        { .key = "MESSAGE_ID", .s = MESSAGE_ID_CAPS_PROBE_FAILURE, .iv = 0 },
        { .key = "LIBVIRT_QEMU_BINARY", .s = binary, .iv = 0 },
        { .key = NULL },
    };

5177
    virLogMessage(&virLogSelf,
5178 5179 5180 5181
                  VIR_LOG_WARN,
                  __FILE__, __LINE__, __func__,
                  meta,
                  _("Failed to probe capabilities for %s: %s"),
5182
                  binary, virGetLastErrorMessage());
5183 5184 5185
}


5186
virQEMUCapsPtr
5187
virQEMUCapsNewForBinaryInternal(virCapsPtr caps,
5188
                                const char *binary,
5189 5190 5191 5192 5193
                                const char *libDir,
                                const char *cacheDir,
                                uid_t runUid,
                                gid_t runGid,
                                bool qmpOnly)
5194
{
5195
    virQEMUCapsPtr qemuCaps;
5196 5197
    struct stat sb;
    int rv;
5198
    char *qmperr = NULL;
5199

5200 5201 5202
    if (!(qemuCaps = virQEMUCapsNew()))
        goto error;

5203 5204
    if (VIR_STRDUP(qemuCaps->binary, binary) < 0)
        goto error;
5205 5206 5207 5208 5209 5210 5211 5212

    /* We would also want to check faccessat if we cared about ACLs,
     * but we don't.  */
    if (stat(binary, &sb) < 0) {
        virReportSystemError(errno, _("Cannot check QEMU binary %s"),
                             binary);
        goto error;
    }
5213
    qemuCaps->ctime = sb.st_ctime;
5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224

    /* Make sure the binary we are about to try exec'ing exists.
     * Technically we could catch the exec() failure, but that's
     * in a sub-process so it's hard to feed back a useful error.
     */
    if (!virFileIsExecutable(binary)) {
        virReportSystemError(errno, _("QEMU binary %s is not executable"),
                             binary);
        goto error;
    }

5225 5226
    if (!cacheDir)
        rv = 0;
5227 5228
    else if ((rv = virQEMUCapsInitCached(caps, qemuCaps, cacheDir,
                                         runUid, runGid)) < 0)
5229 5230
        goto error;

5231
    if (rv == 0) {
5232
        if (virQEMUCapsInitQMP(qemuCaps, libDir, runUid, runGid, &qmperr) < 0) {
5233 5234 5235 5236
            virQEMUCapsLogProbeFailure(binary);
            goto error;
        }

5237 5238 5239 5240 5241 5242 5243 5244
        if (qmpOnly && !qemuCaps->usedQMP) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Failed to probe QEMU binary with QMP: %s"),
                           qmperr ? qmperr : _("unknown error"));
            virQEMUCapsLogProbeFailure(binary);
            goto error;
        }

5245
        if (!qemuCaps->usedQMP &&
5246
            virQEMUCapsInitHelp(qemuCaps, runUid, runGid, qmperr) < 0) {
5247 5248 5249 5250
            virQEMUCapsLogProbeFailure(binary);
            goto error;
        }

5251 5252
        if (cacheDir &&
            virQEMUCapsRememberCached(qemuCaps, cacheDir) < 0)
5253
            goto error;
5254

5255 5256
        virQEMUCapsInitHostCPUModel(qemuCaps, caps, VIR_DOMAIN_VIRT_KVM);
        virQEMUCapsInitHostCPUModel(qemuCaps, caps, VIR_DOMAIN_VIRT_QEMU);
5257
    }
5258

5259
 cleanup:
5260
    VIR_FREE(qmperr);
5261
    return qemuCaps;
5262

5263
 error:
5264 5265
    virObjectUnref(qemuCaps);
    qemuCaps = NULL;
5266
    goto cleanup;
5267 5268
}

5269
static virQEMUCapsPtr
5270 5271
virQEMUCapsNewForBinary(virCapsPtr caps,
                        const char *binary,
5272 5273 5274 5275 5276
                        const char *libDir,
                        const char *cacheDir,
                        uid_t runUid,
                        gid_t runGid)
{
5277
    return virQEMUCapsNewForBinaryInternal(caps, binary, libDir, cacheDir,
5278 5279 5280
                                           runUid, runGid, false);
}

5281

5282 5283
bool
virQEMUCapsIsValid(virQEMUCapsPtr qemuCaps,
5284 5285 5286
                   time_t qemuctime,
                   uid_t runUid,
                   gid_t runGid)
5287
{
5288 5289
    bool kvmUsable;

5290
    if (!qemuCaps->binary)
5291 5292
        return true;

J
Jiri Denemark 已提交
5293
    if (!qemuctime) {
5294 5295 5296 5297 5298 5299 5300 5301 5302
        struct stat sb;

        if (stat(qemuCaps->binary, &sb) < 0) {
            char ebuf[1024];
            VIR_DEBUG("Failed to stat QEMU binary '%s': %s",
                      qemuCaps->binary,
                      virStrerror(errno, ebuf, sizeof(ebuf)));
            return false;
        }
J
Jiri Denemark 已提交
5303
        qemuctime = sb.st_ctime;
5304 5305
    }

J
Jiri Denemark 已提交
5306
    if (qemuctime != qemuCaps->ctime) {
5307 5308 5309
        VIR_DEBUG("Outdated capabilities for '%s': QEMU binary changed "
                  "(%lld vs %lld)",
                  qemuCaps->binary,
J
Jiri Denemark 已提交
5310
                  (long long) qemuctime, (long long) qemuCaps->ctime);
5311
        return false;
5312
    }
5313

5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333
    kvmUsable = virFileAccessibleAs("/dev/kvm", R_OK | W_OK,
                                    runUid, runGid) == 0;

    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM) &&
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_ENABLE_KVM) &&
        kvmUsable) {
        VIR_DEBUG("KVM was not enabled when probing '%s', "
                  "but it should be usable now",
                  qemuCaps->binary);
        return false;
    }

    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM) &&
        !kvmUsable) {
        VIR_DEBUG("KVM was enabled when probing '%s', "
                  "but it is not available now",
                  qemuCaps->binary);
        return false;
    }

5334
    return true;
5335
}
5336 5337


5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370
struct virQEMUCapsMachineTypeFilter {
    const char *machineType;
    virQEMUCapsFlags *flags;
    size_t nflags;
};

static const struct virQEMUCapsMachineTypeFilter virQEMUCapsMachineFilter[] = {
    /* { "blah", virQEMUCapsMachineBLAHFilter,
         ARRAY_CARDINALITY(virQEMUCapsMachineBLAHFilter) }, */
    { "", NULL, 0 },
};


void
virQEMUCapsFilterByMachineType(virQEMUCapsPtr qemuCaps,
                               const char *machineType)
{
    size_t i;

    if (!machineType)
        return;

    for (i = 0; i < ARRAY_CARDINALITY(virQEMUCapsMachineFilter); i++) {
        const struct virQEMUCapsMachineTypeFilter *filter = &virQEMUCapsMachineFilter[i];
        size_t j;

        if (STRNEQ(filter->machineType, machineType))
            continue;

        for (j = 0; j < filter->nflags; j++)
            virQEMUCapsClear(qemuCaps, filter->flags[j]);
    }

5371 5372
    if (!virQEMUCapsGetMachineHotplugCpus(qemuCaps, machineType))
        virQEMUCapsClear(qemuCaps, QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS);
5373 5374 5375
}


5376 5377
virQEMUCapsCachePtr
virQEMUCapsCacheNew(const char *libDir,
5378
                    const char *cacheDir,
5379 5380
                    uid_t runUid,
                    gid_t runGid)
5381
{
5382
    virQEMUCapsCachePtr cache;
5383

5384
    if (VIR_ALLOC(cache) < 0)
5385 5386 5387 5388 5389 5390 5391 5392 5393
        return NULL;

    if (virMutexInit(&cache->lock) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("Unable to initialize mutex"));
        VIR_FREE(cache);
        return NULL;
    }

E
Eric Blake 已提交
5394
    if (!(cache->binaries = virHashCreate(10, virObjectFreeHashData)))
5395
        goto error;
5396
    if (VIR_STRDUP(cache->libDir, libDir) < 0)
5397
        goto error;
5398 5399
    if (VIR_STRDUP(cache->cacheDir, cacheDir) < 0)
        goto error;
5400

5401 5402 5403
    cache->runUid = runUid;
    cache->runGid = runGid;

5404 5405
    return cache;

5406
 error:
5407
    virQEMUCapsCacheFree(cache);
5408 5409 5410
    return NULL;
}

5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441

static void ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
virQEMUCapsCacheValidate(virQEMUCapsCachePtr cache,
                         const char *binary,
                         virCapsPtr caps,
                         virQEMUCapsPtr *qemuCaps)
{
    if (*qemuCaps &&
        !virQEMUCapsIsValid(*qemuCaps, 0, cache->runUid, cache->runGid)) {
        VIR_DEBUG("Cached capabilities %p no longer valid for %s",
                  *qemuCaps, binary);
        virHashRemoveEntry(cache->binaries, binary);
        *qemuCaps = NULL;
    }

    if (!*qemuCaps) {
        VIR_DEBUG("Creating capabilities for %s", binary);
        *qemuCaps = virQEMUCapsNewForBinary(caps, binary,
                                            cache->libDir, cache->cacheDir,
                                            cache->runUid, cache->runGid);
        if (*qemuCaps) {
            VIR_DEBUG("Caching capabilities %p for %s", *qemuCaps, binary);
            if (virHashAddEntry(cache->binaries, binary, *qemuCaps) < 0) {
                virObjectUnref(*qemuCaps);
                *qemuCaps = NULL;
            }
        }
    }
}


5442
virQEMUCapsPtr
5443 5444 5445
virQEMUCapsCacheLookup(virCapsPtr caps,
                       virQEMUCapsCachePtr cache,
                       const char *binary)
5446
{
5447
    virQEMUCapsPtr ret = NULL;
5448

5449
    virMutexLock(&cache->lock);
5450

5451
    ret = virHashLookup(cache->binaries, binary);
5452
    virQEMUCapsCacheValidate(cache, binary, caps, &ret);
5453
    virObjectRef(ret);
5454

5455
    virMutexUnlock(&cache->lock);
5456 5457

    VIR_DEBUG("Returning caps %p for %s", ret, binary);
5458 5459 5460 5461
    return ret;
}


5462
virQEMUCapsPtr
5463 5464
virQEMUCapsCacheLookupCopy(virCapsPtr caps,
                           virQEMUCapsCachePtr cache,
5465
                           const char *binary,
5466
                           const char *machineType)
5467
{
5468
    virQEMUCapsPtr qemuCaps = virQEMUCapsCacheLookup(caps, cache, binary);
5469
    virQEMUCapsPtr ret;
5470

5471
    if (!qemuCaps)
5472 5473
        return NULL;

5474 5475
    ret = virQEMUCapsNewCopy(qemuCaps);
    virObjectUnref(qemuCaps);
5476 5477 5478 5479

    if (!ret)
        return NULL;

5480
    virQEMUCapsFilterByMachineType(ret, machineType);
5481 5482 5483 5484
    return ret;
}


5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497
static int
virQEMUCapsCompareArch(const void *payload,
                       const void *name ATTRIBUTE_UNUSED,
                       const void *opaque)
{
    struct virQEMUCapsSearchData *data = (struct virQEMUCapsSearchData *) opaque;
    const virQEMUCaps *qemuCaps = payload;

    return qemuCaps->arch == data->arch;
}


virQEMUCapsPtr
5498 5499
virQEMUCapsCacheLookupByArch(virCapsPtr caps,
                             virQEMUCapsCachePtr cache,
5500 5501 5502
                             virArch arch)
{
    virQEMUCapsPtr ret = NULL;
5503
    virArch target;
5504 5505 5506 5507
    struct virQEMUCapsSearchData data = { .arch = arch };

    virMutexLock(&cache->lock);
    ret = virHashSearch(cache->binaries, virQEMUCapsCompareArch, &data);
5508 5509 5510 5511 5512 5513 5514 5515 5516
    if (!ret) {
        /* If the first attempt at finding capabilities has failed, try
         * again using the QEMU target as lookup key instead */
        target = virQEMUCapsFindTarget(virArchFromHost(), data.arch);
        if (target != data.arch) {
            data.arch = target;
            ret = virHashSearch(cache->binaries, virQEMUCapsCompareArch, &data);
        }
    }
5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532

    if (ret) {
        char *binary;

        if (VIR_STRDUP(binary, ret->binary) < 0) {
            ret = NULL;
        } else {
            virQEMUCapsCacheValidate(cache, binary, caps, &ret);
            VIR_FREE(binary);
        }
    } else {
        virReportError(VIR_ERR_INVALID_ARG,
                       _("unable to find any emulator to serve '%s' "
                         "architecture"), virArchToString(arch));
    }

5533 5534 5535
    virObjectRef(ret);
    virMutexUnlock(&cache->lock);

5536 5537
    VIR_DEBUG("Returning caps %p for arch %s", ret, virArchToString(arch));

5538 5539 5540 5541
    return ret;
}


5542
void
5543
virQEMUCapsCacheFree(virQEMUCapsCachePtr cache)
5544 5545 5546 5547
{
    if (!cache)
        return;

5548
    VIR_FREE(cache->libDir);
5549
    VIR_FREE(cache->cacheDir);
5550 5551 5552 5553
    virHashFree(cache->binaries);
    virMutexDestroy(&cache->lock);
    VIR_FREE(cache);
}
5554

5555 5556

bool
5557
virQEMUCapsSupportsChardev(const virDomainDef *def,
5558
                           virQEMUCapsPtr qemuCaps,
5559
                           virDomainChrDefPtr chr)
5560
{
J
Ján Tomko 已提交
5561
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV))
5562 5563
        return false;

5564
    if ((def->os.arch == VIR_ARCH_PPC) || ARCH_IS_PPC64(def->os.arch)) {
5565
        if (!qemuDomainIsPSeries(def))
S
Shivaprasad G Bhat 已提交
5566
            return false;
5567
        /* only pseries need -device spapr-vty with -chardev */
S
Shivaprasad G Bhat 已提交
5568 5569 5570
        if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL &&
            chr->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO)
            return false;
5571 5572
    }

5573
    if ((def->os.arch != VIR_ARCH_ARMV7L) && (def->os.arch != VIR_ARCH_AARCH64))
5574
        return true;
5575

5576 5577 5578 5579 5580 5581
    /* This may not be true for all ARM machine types, but at least
     * the only supported non-virtio serial devices of vexpress and versatile
     * don't have the -chardev property wired up. */
    return (chr->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_MMIO ||
            (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE &&
             chr->targetType == VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO));
5582
}
5583 5584


5585 5586 5587 5588 5589 5590 5591
bool
virQEMUCapsSupportsVmport(virQEMUCapsPtr qemuCaps,
                          const virDomainDef *def)
{
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MACHINE_VMPORT_OPT))
        return false;

5592 5593
    return qemuDomainIsI440FX(def) ||
        qemuDomainIsQ35(def) ||
5594 5595 5596 5597
        STREQ(def->os.machine, "isapc");
}


M
Michal Privoznik 已提交
5598 5599 5600 5601 5602 5603 5604
bool
virQEMUCapsSupportsSMM(virQEMUCapsPtr qemuCaps,
                       const virDomainDef *def)
{
    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MACHINE_SMM_OPT))
        return false;

5605
    return qemuDomainIsQ35(def);
M
Michal Privoznik 已提交
5606 5607 5608
}


5609 5610 5611 5612 5613 5614 5615
bool
virQEMUCapsIsMachineSupported(virQEMUCapsPtr qemuCaps,
                              const char *canonical_machine)
{
    size_t i;

    for (i = 0; i < qemuCaps->nmachineTypes; i++) {
5616
        if (STREQ(canonical_machine, qemuCaps->machineTypes[i].name))
5617 5618 5619 5620
            return true;
    }
    return false;
}
5621 5622 5623 5624 5625 5626 5627


const char *
virQEMUCapsGetDefaultMachine(virQEMUCapsPtr qemuCaps)
{
    if (!qemuCaps->nmachineTypes)
        return NULL;
5628
    return qemuCaps->machineTypes[0].name;
5629
}
5630 5631


5632
static int
5633
virQEMUCapsFillDomainLoaderCaps(virDomainCapsLoaderPtr capsLoader,
5634 5635
                                virFirmwarePtr *firmwares,
                                size_t nfirmwares)
5636
{
5637 5638
    size_t i;

5639
    capsLoader->supported = true;
5640

5641
    if (VIR_ALLOC_N(capsLoader->values.values, nfirmwares) < 0)
5642 5643
        return -1;

5644 5645
    for (i = 0; i < nfirmwares; i++) {
        const char *filename = firmwares[i]->name;
5646 5647 5648 5649 5650 5651

        if (!virFileExists(filename)) {
            VIR_DEBUG("loader filename=%s does not exist", filename);
            continue;
        }

5652
        if (VIR_STRDUP(capsLoader->values.values[capsLoader->values.nvalues],
5653 5654
                       filename) < 0)
            return -1;
5655
        capsLoader->values.nvalues++;
5656 5657
    }

5658
    VIR_DOMAIN_CAPS_ENUM_SET(capsLoader->type,
5659 5660
                             VIR_DOMAIN_LOADER_TYPE_ROM);

5661 5662
    VIR_DOMAIN_CAPS_ENUM_SET(capsLoader->type,
                             VIR_DOMAIN_LOADER_TYPE_PFLASH);
5663 5664


5665 5666 5667
    VIR_DOMAIN_CAPS_ENUM_SET(capsLoader->readonly,
                             VIR_TRISTATE_BOOL_YES,
                             VIR_TRISTATE_BOOL_NO);
5668
    return 0;
5669 5670 5671
}


5672
static int
5673
virQEMUCapsFillDomainOSCaps(virDomainCapsOSPtr os,
5674 5675
                            virFirmwarePtr *firmwares,
                            size_t nfirmwares)
5676
{
5677
    virDomainCapsLoaderPtr capsLoader = &os->loader;
5678

5679
    os->supported = true;
5680
    if (virQEMUCapsFillDomainLoaderCaps(capsLoader, firmwares, nfirmwares) < 0)
5681 5682
        return -1;
    return 0;
5683 5684 5685
}


5686 5687 5688 5689 5690
static int
virQEMUCapsFillDomainCPUCaps(virCapsPtr caps,
                             virQEMUCapsPtr qemuCaps,
                             virDomainCapsPtr domCaps)
{
5691 5692
    if (virQEMUCapsIsCPUModeSupported(qemuCaps, caps, domCaps->virttype,
                                      VIR_CPU_MODE_HOST_PASSTHROUGH))
5693 5694
        domCaps->cpu.hostPassthrough = true;

5695
    if (virQEMUCapsIsCPUModeSupported(qemuCaps, caps, domCaps->virttype,
5696
                                      VIR_CPU_MODE_HOST_MODEL)) {
5697 5698
        virCPUDefPtr cpu = virQEMUCapsGetHostModel(qemuCaps, domCaps->virttype,
                                                   VIR_QEMU_CAPS_HOST_CPU_REPORTED);
5699 5700
        domCaps->cpu.hostModel = virCPUDefCopy(cpu);
    }
5701 5702 5703 5704 5705

    if (virQEMUCapsIsCPUModeSupported(qemuCaps, caps, domCaps->virttype,
                                      VIR_CPU_MODE_CUSTOM)) {
        virDomainCapsCPUModelsPtr filtered = NULL;
        char **models = NULL;
5706
        const char *blacklist[] = { "host", NULL };
5707

J
Jiri Denemark 已提交
5708
        if (virCPUGetModels(domCaps->arch, &models) >= 0) {
5709 5710 5711 5712 5713 5714 5715 5716
            virDomainCapsCPUModelsPtr cpus;

            if (domCaps->virttype == VIR_DOMAIN_VIRT_KVM)
                cpus = qemuCaps->kvmCPUModels;
            else
                cpus = qemuCaps->tcgCPUModels;

            filtered = virDomainCapsCPUModelsFilter(cpus,
5717 5718
                                                    (const char **) models,
                                                    blacklist);
5719
            virStringListFree(models);
5720 5721
        }
        domCaps->cpu.custom = filtered;
5722
    }
5723 5724 5725 5726 5727

    return 0;
}


5728
static int
5729
virQEMUCapsFillDomainDeviceDiskCaps(virQEMUCapsPtr qemuCaps,
5730
                                    const char *machine,
5731 5732
                                    virDomainCapsDeviceDiskPtr disk)
{
5733
    disk->supported = true;
5734 5735 5736
    /* QEMU supports all of these */
    VIR_DOMAIN_CAPS_ENUM_SET(disk->diskDevice,
                             VIR_DOMAIN_DISK_DEVICE_DISK,
5737 5738
                             VIR_DOMAIN_DISK_DEVICE_CDROM,
                             VIR_DOMAIN_DISK_DEVICE_LUN);
5739 5740

    /* PowerPC pseries based VMs do not support floppy device */
5741
    if (!qemuDomainMachineIsPSeries(machine, qemuCaps->arch))
5742
        VIR_DOMAIN_CAPS_ENUM_SET(disk->diskDevice, VIR_DOMAIN_DISK_DEVICE_FLOPPY);
5743

5744 5745 5746
    if (qemuDomainMachineHasBuiltinIDE(machine))
        VIR_DOMAIN_CAPS_ENUM_SET(disk->bus, VIR_DOMAIN_DISK_BUS_IDE);

5747 5748 5749 5750 5751
    VIR_DOMAIN_CAPS_ENUM_SET(disk->bus,
                             VIR_DOMAIN_DISK_BUS_SCSI,
                             VIR_DOMAIN_DISK_BUS_VIRTIO,
                             /* VIR_DOMAIN_DISK_BUS_SD */);

5752
    /* PowerPC pseries based VMs do not support floppy device */
5753
    if (!qemuDomainMachineIsPSeries(machine, qemuCaps->arch))
5754 5755
        VIR_DOMAIN_CAPS_ENUM_SET(disk->bus, VIR_DOMAIN_DISK_BUS_FDC);

5756 5757
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_USB_STORAGE))
        VIR_DOMAIN_CAPS_ENUM_SET(disk->bus, VIR_DOMAIN_DISK_BUS_USB);
5758 5759 5760 5761

    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_ICH9_AHCI))
        VIR_DOMAIN_CAPS_ENUM_SET(disk->bus, VIR_DOMAIN_DISK_BUS_SATA);

5762
    return 0;
5763 5764 5765
}


5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782
static int
virQEMUCapsFillDomainDeviceGraphicsCaps(virQEMUCapsPtr qemuCaps,
                                        virDomainCapsDeviceGraphicsPtr dev)
{
    dev->supported = true;

    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SDL))
        VIR_DOMAIN_CAPS_ENUM_SET(dev->type, VIR_DOMAIN_GRAPHICS_TYPE_SDL);
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VNC))
        VIR_DOMAIN_CAPS_ENUM_SET(dev->type, VIR_DOMAIN_GRAPHICS_TYPE_VNC);
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SPICE))
        VIR_DOMAIN_CAPS_ENUM_SET(dev->type, VIR_DOMAIN_GRAPHICS_TYPE_SPICE);

    return 0;
}


5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794
static int
virQEMUCapsFillDomainDeviceVideoCaps(virQEMUCapsPtr qemuCaps,
                                     virDomainCapsDeviceVideoPtr dev)
{
    dev->supported = true;

    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VGA))
        VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_VGA);
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_CIRRUS_VGA))
        VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_CIRRUS);
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VMWARE_SVGA))
        VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_VMVGA);
5795
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QXL))
5796 5797 5798 5799 5800 5801 5802 5803
        VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_QXL);
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VIRTIO_GPU))
        VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_VIRTIO);

    return 0;
}


5804
static int
5805 5806 5807 5808 5809 5810
virQEMUCapsFillDomainDeviceHostdevCaps(virQEMUCapsPtr qemuCaps,
                                       virDomainCapsDeviceHostdevPtr hostdev)
{
    bool supportsPassthroughKVM = qemuHostdevHostSupportsPassthroughLegacy();
    bool supportsPassthroughVFIO = qemuHostdevHostSupportsPassthroughVFIO();

5811
    hostdev->supported = true;
5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824
    /* VIR_DOMAIN_HOSTDEV_MODE_CAPABILITIES is for containers only */
    VIR_DOMAIN_CAPS_ENUM_SET(hostdev->mode,
                             VIR_DOMAIN_HOSTDEV_MODE_SUBSYS);

    VIR_DOMAIN_CAPS_ENUM_SET(hostdev->startupPolicy,
                             VIR_DOMAIN_STARTUP_POLICY_DEFAULT,
                             VIR_DOMAIN_STARTUP_POLICY_MANDATORY,
                             VIR_DOMAIN_STARTUP_POLICY_REQUISITE,
                             VIR_DOMAIN_STARTUP_POLICY_OPTIONAL);

    VIR_DOMAIN_CAPS_ENUM_SET(hostdev->subsysType,
                             VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB,
                             VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI);
J
Ján Tomko 已提交
5825
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SCSI_GENERIC))
5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839
        VIR_DOMAIN_CAPS_ENUM_SET(hostdev->subsysType,
                                 VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI);

    /* No virDomainHostdevCapsType for QEMU */
    virDomainCapsEnumClear(&hostdev->capsType);

    virDomainCapsEnumClear(&hostdev->pciBackend);
    if (supportsPassthroughVFIO &&
        virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VFIO_PCI)) {
        VIR_DOMAIN_CAPS_ENUM_SET(hostdev->pciBackend,
                                 VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT,
                                 VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO);
    }

J
Ján Tomko 已提交
5840
    if (supportsPassthroughKVM) {
5841 5842 5843 5844
        VIR_DOMAIN_CAPS_ENUM_SET(hostdev->pciBackend,
                                 VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT,
                                 VIR_DOMAIN_HOSTDEV_PCI_BACKEND_KVM);
    }
5845
    return 0;
5846 5847 5848
}


5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886
/**
 * virQEMUCapsSupportsGICVersion:
 * @qemuCaps: QEMU capabilities
 * @virtType: domain type
 * @version: GIC version
 *
 * Checks the QEMU binary with capabilities @qemuCaps supports a specific
 * GIC version for a domain of type @virtType.
 *
 * Returns: true if the binary supports the requested GIC version, false
 *          otherwise
 */
bool
virQEMUCapsSupportsGICVersion(virQEMUCapsPtr qemuCaps,
                              virDomainVirtType virtType,
                              virGICVersion version)
{
    size_t i;

    for (i = 0; i < qemuCaps->ngicCapabilities; i++) {
        virGICCapabilityPtr cap = &(qemuCaps->gicCapabilities[i]);

        if (cap->version != version)
            continue;

        if (virtType == VIR_DOMAIN_VIRT_KVM &&
            cap->implementation & VIR_GIC_IMPLEMENTATION_KERNEL)
            return true;

        if (virtType == VIR_DOMAIN_VIRT_QEMU &&
            cap->implementation & VIR_GIC_IMPLEMENTATION_EMULATED)
            return true;
    }

    return false;
}


5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910
/**
 * virQEMUCapsFillDomainFeatureGICCaps:
 * @qemuCaps: QEMU capabilities
 * @domCaps: domain capabilities
 *
 * Take the information about GIC capabilities that has been obtained
 * using the 'query-gic-capabilities' QMP command and stored in @qemuCaps
 * and convert it to a form suitable for @domCaps.
 *
 * @qemuCaps contains complete information about the GIC capabilities for
 * the corresponding QEMU binary, stored as custom objects; @domCaps, on
 * the other hand, should only contain information about the GIC versions
 * available for the specific combination of architecture, machine type
 * and virtualization type. Moreover, a common format is used to store
 * information about enumerations in @domCaps, so further processing is
 * required.
 *
 * Returns: 0 on success, <0 on failure
 */
static int
virQEMUCapsFillDomainFeatureGICCaps(virQEMUCapsPtr qemuCaps,
                                    virDomainCapsPtr domCaps)
{
    virDomainCapsFeatureGICPtr gic = &domCaps->gic;
5911
    virGICVersion version;
5912

5913
    if (!qemuDomainMachineIsVirt(domCaps->machine, domCaps->arch))
5914 5915
        return 0;

5916 5917 5918 5919 5920 5921
    for (version = VIR_GIC_VERSION_LAST - 1;
         version > VIR_GIC_VERSION_NONE;
         version--) {
        if (!virQEMUCapsSupportsGICVersion(qemuCaps,
                                           domCaps->virttype,
                                           version))
5922 5923 5924 5925
            continue;

        gic->supported = true;
        VIR_DOMAIN_CAPS_ENUM_SET(gic->version,
5926
                                 version);
5927 5928 5929 5930 5931 5932
    }

    return 0;
}


5933
int
5934 5935
virQEMUCapsFillDomainCaps(virCapsPtr caps,
                          virDomainCapsPtr domCaps,
5936
                          virQEMUCapsPtr qemuCaps,
5937
                          virFirmwarePtr *firmwares,
5938
                          size_t nfirmwares)
5939
{
5940
    virDomainCapsOSPtr os = &domCaps->os;
5941 5942
    virDomainCapsDeviceDiskPtr disk = &domCaps->disk;
    virDomainCapsDeviceHostdevPtr hostdev = &domCaps->hostdev;
5943
    virDomainCapsDeviceGraphicsPtr graphics = &domCaps->graphics;
5944
    virDomainCapsDeviceVideoPtr video = &domCaps->video;
5945

5946 5947
    domCaps->maxvcpus = virQEMUCapsGetMachineMaxCpus(qemuCaps,
                                                     domCaps->machine);
5948
    if (domCaps->virttype == VIR_DOMAIN_VIRT_KVM) {
5949 5950 5951 5952 5953 5954
        int hostmaxvcpus;

        if ((hostmaxvcpus = virHostCPUGetKVMMaxVCPUs()) < 0)
            return -1;

        domCaps->maxvcpus = MIN(domCaps->maxvcpus, hostmaxvcpus);
5955
    }
5956

5957
    if (virQEMUCapsFillDomainOSCaps(os, firmwares, nfirmwares) < 0 ||
5958
        virQEMUCapsFillDomainCPUCaps(caps, qemuCaps, domCaps) < 0 ||
5959 5960 5961
        virQEMUCapsFillDomainDeviceDiskCaps(qemuCaps,
                                            domCaps->machine, disk) < 0 ||
        virQEMUCapsFillDomainDeviceGraphicsCaps(qemuCaps, graphics) < 0 ||
5962
        virQEMUCapsFillDomainDeviceVideoCaps(qemuCaps, video) < 0 ||
5963 5964
        virQEMUCapsFillDomainDeviceHostdevCaps(qemuCaps, hostdev) < 0 ||
        virQEMUCapsFillDomainFeatureGICCaps(qemuCaps, domCaps) < 0)
5965 5966
        return -1;
    return 0;
5967
}