1 /*
2 * qemu_capabilities.c: QEMU capabilities generation
3 *
4 * Copyright (C) 2006-2016 Red Hat, Inc.
5 * Copyright (C) 2006 Daniel P. Berrange
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library. If not, see
19 * <http://www.gnu.org/licenses/>.
20 */
21
22 #include <config.h>
23
24 #include "qemu_capabilities.h"
25 #include "viralloc.h"
26 #include "virarch.h"
27 #include "vircrypto.h"
28 #include "virlog.h"
29 #include "virerror.h"
30 #include "virfile.h"
31 #include "virfilecache.h"
32 #include "virpidfile.h"
33 #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 LIBVIRT_QEMU_CAPSPRIV_H_ALLOW
47 #include "qemu_capspriv.h"
48 #include "qemu_qapi.h"
49 #include "qemu_process.h"
50 #include "qemu_firmware.h"
51 #include "virutil.h"
52
53 #include <fcntl.h>
54 #include <sys/stat.h>
55 #include <unistd.h>
56 #include <stdarg.h>
57 #include <sys/utsname.h>
58
59 #define VIR_FROM_THIS VIR_FROM_QEMU
60
61 VIR_LOG_INIT("qemu.qemu_capabilities");
62
63 /* While not public, these strings must not change. They
64 * are used in domain status files which are read on
65 * daemon restarts
66 */
67 VIR_ENUM_IMPL(virQEMUCaps,
68 QEMU_CAPS_LAST, /* virQEMUCaps grouping marker */
69 /* 0 */
70 "vnc-colon", /* X_QEMU_CAPS_VNC_COLON */
71 "no-reboot", /* X_QEMU_CAPS_NO_REBOOT */
72 "drive", /* X_QEMU_CAPS_DRIVE */
73 "drive-boot", /* X_QEMU_CAPS_DRIVE_BOOT */
74 "name", /* X_QEMU_CAPS_NAME */
75
76 /* 5 */
77 "uuid", /* X_QEMU_CAPS_UUID */
78 "domid", /* X_QEMU_CAPS_DOMID */
79 "vnet-hdr", /* X_QEMU_CAPS_VNET_HDR */
80 "migrate-kvm-stdio", /* X_QEMU_CAPS_MIGRATE_KVM_STDIO */
81 "migrate-qemu-tcp", /* X_QEMU_CAPS_MIGRATE_QEMU_TCP */
82
83 /* 10 */
84 "migrate-qemu-exec", /* X_QEMU_CAPS_MIGRATE_QEMU_EXEC */
85 "drive-cache-v2", /* X_QEMU_CAPS_DRIVE_CACHE_V2 */
86 "kvm", /* QEMU_CAPS_KVM */
87 "drive-format", /* X_QEMU_CAPS_DRIVE_FORMAT */
88 "vga", /* X_QEMU_CAPS_VGA */
89
90 /* 15 */
91 "0.10", /* X_QEMU_CAPS_0_10 */
92 "pci-device", /* X_QEMU_CAPS_PCIDEVICE */
93 "mem-path", /* X_QEMU_CAPS_MEM_PATH */
94 "drive-serial", /* X_QEMU_CAPS_DRIVE_SERIAL */
95 "xen-domid", /* X_QEMU_CAPS_XEN_DOMID */
96
97 /* 20 */
98 "migrate-qemu-unix", /* X_QEMU_CAPS_MIGRATE_QEMU_UNIX */
99 "chardev", /* X_QEMU_CAPS_CHARDEV */
100 "enable-kvm", /* X_QEMU_CAPS_ENABLE_KVM */
101 "monitor-json", /* X_QEMU_CAPS_MONITOR_JSON */
102 "balloon", /* X_QEMU_CAPS_BALLOON */
103
104 /* 25 */
105 "device", /* X_QEMU_CAPS_DEVICE */
106 "sdl", /* QEMU_CAPS_SDL */
107 "smp-topology", /* X_QEMU_CAPS_SMP_TOPOLOGY */
108 "netdev", /* X_QEMU_CAPS_NETDEV */
109 "rtc", /* X_QEMU_CAPS_RTC */
110
111 /* 30 */
112 "vhost-net", /* X_QEMU_CAPS_VHOST_NET */
113 "rtc-td-hack", /* X_QEMU_CAPS_RTC_TD_HACK */
114 "no-hpet", /* QEMU_CAPS_NO_HPET */
115 "no-kvm-pit", /* X_QEMU_CAPS_NO_KVM_PIT */
116 "tdf", /* X_QEMU_CAPS_TDF */
117
118 /* 35 */
119 "pci-configfd", /* X_QEMU_CAPS_PCI_CONFIGFD */
120 "nodefconfig", /* X_QEMU_CAPS_NODEFCONFIG */
121 "boot-menu", /* X_QEMU_CAPS_BOOT_MENU */
122 "fsdev", /* X_QEMU_CAPS_FSDEV */
123 "nesting", /* X_QEMU_CAPS_NESTING */
124
125 /* 40 */
126 "name-process", /* X_QEMU_CAPS_NAME_PROCESS */
127 "drive-readonly", /* X_QEMU_CAPS_DRIVE_READONLY */
128 "smbios-type", /* X_QEMU_CAPS_SMBIOS_TYPE */
129 "vga-qxl", /* X_QEMU_CAPS_VGA_QXL */
130 "spice", /* QEMU_CAPS_SPICE */
131
132 /* 45 */
133 "vga-none", /* X_QEMU_CAPS_VGA_NONE */
134 "migrate-qemu-fd", /* X_QEMU_CAPS_MIGRATE_QEMU_FD */
135 "boot-index", /* X_QEMU_CAPS_BOOTINDEX */
136 "hda-duplex", /* QEMU_CAPS_HDA_DUPLEX */
137 "drive-aio", /* X_QEMU_CAPS_DRIVE_AIO */
138
139 /* 50 */
140 "pci-multibus", /* X_QEMU_CAPS_PCI_MULTIBUS */
141 "pci-bootindex", /* X_QEMU_CAPS_PCI_BOOTINDEX */
142 "ccid-emulated", /* QEMU_CAPS_CCID_EMULATED */
143 "ccid-passthru", /* QEMU_CAPS_CCID_PASSTHRU */
144 "chardev-spicevmc", /* X_QEMU_CAPS_CHARDEV_SPICEVMC */
145
146 /* 55 */
147 "device-spicevmc", /* X_QEMU_CAPS_DEVICE_SPICEVMC */
148 "virtio-tx-alg", /* QEMU_CAPS_VIRTIO_TX_ALG */
149 "device-qxl-vga", /* X_QEMU_CAPS_DEVICE_QXL_VGA */
150 "pci-multifunction", /* X_QEMU_CAPS_PCI_MULTIFUNCTION */
151 "virtio-blk-pci.ioeventfd", /* X_QEMU_CAPS_VIRTIO_IOEVENTFD */
152
153 /* 60 */
154 "sga", /* X_QEMU_CAPS_SGA */
155 "virtio-blk-pci.event_idx", /* X_QEMU_CAPS_VIRTIO_BLK_EVENT_IDX */
156 "virtio-net-pci.event_idx", /* X_QEMU_CAPS_VIRTIO_NET_EVENT_IDX */
157 "cache-directsync", /* X_QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC */
158 "piix3-usb-uhci", /* QEMU_CAPS_PIIX3_USB_UHCI */
159
160 /* 65 */
161 "piix4-usb-uhci", /* QEMU_CAPS_PIIX4_USB_UHCI */
162 "usb-ehci", /* QEMU_CAPS_USB_EHCI */
163 "ich9-usb-ehci1", /* QEMU_CAPS_ICH9_USB_EHCI1 */
164 "vt82c686b-usb-uhci", /* QEMU_CAPS_VT82C686B_USB_UHCI */
165 "pci-ohci", /* QEMU_CAPS_PCI_OHCI */
166
167 /* 70 */
168 "usb-redir", /* QEMU_CAPS_USB_REDIR */
169 "usb-hub", /* QEMU_CAPS_USB_HUB */
170 "no-shutdown", /* X_QEMU_CAPS_NO_SHUTDOWN */
171 "cache-unsafe", /* X_QEMU_CAPS_DRIVE_CACHE_UNSAFE */
172 "rombar", /* X_QEMU_CAPS_PCI_ROMBAR */
173
174 /* 75 */
175 "ich9-ahci", /* QEMU_CAPS_ICH9_AHCI */
176 "no-acpi", /* QEMU_CAPS_NO_ACPI */
177 "fsdev-readonly", /* X_QEMU_CAPS_FSDEV_READONLY */
178 "virtio-blk-pci.scsi", /* QEMU_CAPS_VIRTIO_BLK_SCSI */
179 "blk-sg-io", /* X_QEMU_CAPS_VIRTIO_BLK_SG_IO */
180
181 /* 80 */
182 "drive-copy-on-read", /* X_QEMU_CAPS_DRIVE_COPY_ON_READ */
183 "cpu-host", /* X_QEMU_CAPS_CPU_HOST */
184 "fsdev-writeout", /* X_QEMU_CAPS_FSDEV_WRITEOUT */
185 "drive-iotune", /* X_QEMU_CAPS_DRIVE_IOTUNE */
186 "system_wakeup", /* X_QEMU_CAPS_WAKEUP */
187
188 /* 85 */
189 "scsi-disk.channel", /* QEMU_CAPS_SCSI_DISK_CHANNEL */
190 "scsi-block", /* QEMU_CAPS_SCSI_BLOCK */
191 "transaction", /* X_QEMU_CAPS_TRANSACTION */
192 "block-job-sync", /* X_QEMU_CAPS_BLOCKJOB_SYNC */
193 "block-job-async", /* X_QEMU_CAPS_BLOCKJOB_ASYNC */
194
195 /* 90 */
196 "scsi-cd", /* X_QEMU_CAPS_SCSI_CD */
197 "ide-cd", /* X_QEMU_CAPS_IDE_CD */
198 "no-user-config", /* X_QEMU_CAPS_NO_USER_CONFIG */
199 "hda-micro", /* QEMU_CAPS_HDA_MICRO */
200 "dump-guest-memory", /* QEMU_CAPS_DUMP_GUEST_MEMORY */
201
202 /* 95 */
203 "nec-usb-xhci", /* QEMU_CAPS_NEC_USB_XHCI */
204 "virtio-s390", /* X_QEMU_CAPS_VIRTIO_S390 */
205 "balloon-event", /* X_QEMU_CAPS_BALLOON_EVENT */
206 "bridge", /* X_QEMU_CAPS_NETDEV_BRIDGE */
207 "lsi", /* QEMU_CAPS_SCSI_LSI */
208
209 /* 100 */
210 "virtio-scsi-pci", /* QEMU_CAPS_VIRTIO_SCSI */
211 "blockio", /* QEMU_CAPS_BLOCKIO */
212 "disable-s3", /* QEMU_CAPS_PIIX_DISABLE_S3 */
213 "disable-s4", /* QEMU_CAPS_PIIX_DISABLE_S4 */
214 "usb-redir.filter", /* QEMU_CAPS_USB_REDIR_FILTER */
215
216 /* 105 */
217 "ide-drive.wwn", /* QEMU_CAPS_IDE_DRIVE_WWN */
218 "scsi-disk.wwn", /* QEMU_CAPS_SCSI_DISK_WWN */
219 "seccomp-sandbox", /* QEMU_CAPS_SECCOMP_SANDBOX */
220 "reboot-timeout", /* X_QEMU_CAPS_REBOOT_TIMEOUT */
221 "dump-guest-core", /* X_QEMU_CAPS_DUMP_GUEST_CORE */
222
223 /* 110 */
224 "seamless-migration", /* X_QEMU_CAPS_SEAMLESS_MIGRATION */
225 "block-commit", /* X_QEMU_CAPS_BLOCK_COMMIT */
226 "vnc", /* QEMU_CAPS_VNC */
227 "drive-mirror", /* X_QEMU_CAPS_DRIVE_MIRROR */
228 "usb-redir.bootindex", /* X_QEMU_CAPS_USB_REDIR_BOOTINDEX */
229
230 /* 115 */
231 "usb-host.bootindex", /* X_QEMU_CAPS_USB_HOST_BOOTINDEX */
232 "blockdev-snapshot-sync", /* X_QEMU_CAPS_DISK_SNAPSHOT */
233 "qxl", /* QEMU_CAPS_DEVICE_QXL */
234 "VGA", /* QEMU_CAPS_DEVICE_VGA */
235 "cirrus-vga", /* QEMU_CAPS_DEVICE_CIRRUS_VGA */
236
237 /* 120 */
238 "vmware-svga", /* QEMU_CAPS_DEVICE_VMWARE_SVGA */
239 "device-video-primary", /* X_QEMU_CAPS_DEVICE_VIDEO_PRIMARY */
240 "s390-sclp", /* QEMU_CAPS_DEVICE_SCLPCONSOLE */
241 "usb-serial", /* QEMU_CAPS_DEVICE_USB_SERIAL */
242 "usb-net", /* X_QEMU_CAPS_DEVICE_USB_NET */
243
244 /* 125 */
245 "add-fd", /* X_QEMU_CAPS_ADD_FD */
246 "nbd-server", /* QEMU_CAPS_NBD_SERVER */
247 "virtio-rng", /* QEMU_CAPS_DEVICE_VIRTIO_RNG */
248 "rng-random", /* QEMU_CAPS_OBJECT_RNG_RANDOM */
249 "rng-egd", /* QEMU_CAPS_OBJECT_RNG_EGD */
250
251 /* 130 */
252 "virtio-ccw", /* QEMU_CAPS_VIRTIO_CCW */
253 "dtb", /* X_QEMU_CAPS_DTB */
254 "megasas", /* QEMU_CAPS_SCSI_MEGASAS */
255 "ipv6-migration", /* X_QEMU_CAPS_IPV6_MIGRATION */
256 "machine-opt", /* X_QEMU_CAPS_MACHINE_OPT */
257
258 /* 135 */
259 "machine-usb-opt", /* X_QEMU_CAPS_MACHINE_USB_OPT */
260 "tpm-passthrough", /* QEMU_CAPS_DEVICE_TPM_PASSTHROUGH */
261 "tpm-tis", /* QEMU_CAPS_DEVICE_TPM_TIS */
262 "nvram", /* QEMU_CAPS_DEVICE_NVRAM */
263 "pci-bridge", /* QEMU_CAPS_DEVICE_PCI_BRIDGE */
264
265 /* 140 */
266 "vfio-pci", /* QEMU_CAPS_DEVICE_VFIO_PCI */
267 "vfio-pci.bootindex", /* X_QEMU_CAPS_VFIO_PCI_BOOTINDEX */
268 "scsi-generic", /* X_QEMU_CAPS_DEVICE_SCSI_GENERIC */
269 "scsi-generic.bootindex", /* X_QEMU_CAPS_DEVICE_SCSI_GENERIC_BOOTINDEX */
270 "mem-merge", /* X_QEMU_CAPS_MEM_MERGE */
271
272 /* 145 */
273 "vnc-websocket", /* X_QEMU_CAPS_VNC_WEBSOCKET */
274 "drive-discard", /* QEMU_CAPS_DRIVE_DISCARD */
275 "mlock", /* X_QEMU_CAPS_REALTIME_MLOCK */
276 "vnc-share-policy", /* X_QEMU_CAPS_VNC_SHARE_POLICY */
277 "device-del-event", /* X_QEMU_CAPS_DEVICE_DEL_EVENT */
278
279 /* 150 */
280 "dmi-to-pci-bridge", /* QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE */
281 "i440fx-pci-hole64-size", /* QEMU_CAPS_I440FX_PCI_HOLE64_SIZE */
282 "q35-pci-hole64-size", /* QEMU_CAPS_Q35_PCI_HOLE64_SIZE */
283 "usb-storage", /* QEMU_CAPS_DEVICE_USB_STORAGE */
284 "usb-storage.removable", /* QEMU_CAPS_USB_STORAGE_REMOVABLE */
285
286 /* 155 */
287 "virtio-mmio", /* QEMU_CAPS_DEVICE_VIRTIO_MMIO */
288 "ich9-intel-hda", /* QEMU_CAPS_DEVICE_ICH9_INTEL_HDA */
289 "kvm-pit-lost-tick-policy", /* QEMU_CAPS_KVM_PIT_TICK_POLICY */
290 "boot-strict", /* X_QEMU_CAPS_BOOT_STRICT */
291 "pvpanic", /* QEMU_CAPS_DEVICE_PANIC */
292
293 /* 160 */
294 "enable-fips", /* QEMU_CAPS_ENABLE_FIPS */
295 "spice-file-xfer-disable", /* X_QEMU_CAPS_SPICE_FILE_XFER_DISABLE */
296 "spiceport", /* X_QEMU_CAPS_CHARDEV_SPICEPORT */
297 "usb-kbd", /* QEMU_CAPS_DEVICE_USB_KBD */
298 "host-pci-multidomain", /* X_QEMU_CAPS_HOST_PCI_MULTIDOMAIN */
299
300 /* 165 */
301 "msg-timestamp", /* X_QEMU_CAPS_MSG_TIMESTAMP */
302 "active-commit", /* QEMU_CAPS_ACTIVE_COMMIT */
303 "change-backing-file", /* QEMU_CAPS_CHANGE_BACKING_FILE */
304 "memory-backend-ram", /* QEMU_CAPS_OBJECT_MEMORY_RAM */
305 "numa", /* QEMU_CAPS_NUMA */
306
307 /* 170 */
308 "memory-backend-file", /* QEMU_CAPS_OBJECT_MEMORY_FILE */
309 "usb-audio", /* QEMU_CAPS_OBJECT_USB_AUDIO */
310 "rtc-reset-reinjection", /* QEMU_CAPS_RTC_RESET_REINJECTION */
311 "splash-timeout", /* X_QEMU_CAPS_SPLASH_TIMEOUT */
312 "iothread", /* QEMU_CAPS_OBJECT_IOTHREAD */
313
314 /* 175 */
315 "migrate-rdma", /* QEMU_CAPS_MIGRATE_RDMA */
316 "ivshmem", /* QEMU_CAPS_DEVICE_IVSHMEM */
317 "drive-iotune-max", /* X_QEMU_CAPS_DRIVE_IOTUNE_MAX */
318 "VGA.vgamem_mb", /* QEMU_CAPS_VGA_VGAMEM */
319 "vmware-svga.vgamem_mb", /* QEMU_CAPS_VMWARE_SVGA_VGAMEM */
320
321 /* 180 */
322 "qxl.vgamem_mb", /* QEMU_CAPS_QXL_VGAMEM */
323 "qxl-vga.vgamem_mb", /* X_QEMU_CAPS_QXL_VGA_VGAMEM */
324 "pc-dimm", /* QEMU_CAPS_DEVICE_PC_DIMM */
325 "machine-vmport-opt", /* QEMU_CAPS_MACHINE_VMPORT_OPT */
326 "aes-key-wrap", /* QEMU_CAPS_AES_KEY_WRAP */
327
328 /* 185 */
329 "dea-key-wrap", /* QEMU_CAPS_DEA_KEY_WRAP */
330 "pci-serial", /* QEMU_CAPS_DEVICE_PCI_SERIAL */
331 "aarch64-off", /* QEMU_CAPS_CPU_AARCH64_OFF */
332 "vhost-user-multiqueue", /* X_QEMU_CAPS_VHOSTUSER_MULTIQUEUE */
333 "migration-event", /* QEMU_CAPS_MIGRATION_EVENT */
334
335 /* 190 */
336 "gpex-pcihost", /* QEMU_CAPS_OBJECT_GPEX */
337 "ioh3420", /* QEMU_CAPS_DEVICE_IOH3420 */
338 "x3130-upstream", /* QEMU_CAPS_DEVICE_X3130_UPSTREAM */
339 "xio3130-downstream", /* QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM */
340 "rtl8139", /* QEMU_CAPS_DEVICE_RTL8139 */
341
342 /* 195 */
343 "e1000", /* QEMU_CAPS_DEVICE_E1000 */
344 "virtio-net", /* QEMU_CAPS_DEVICE_VIRTIO_NET */
345 "gic-version", /* QEMU_CAPS_MACH_VIRT_GIC_VERSION */
346 "incoming-defer", /* QEMU_CAPS_INCOMING_DEFER */
347 "virtio-gpu", /* QEMU_CAPS_DEVICE_VIRTIO_GPU */
348
349 /* 200 */
350 "virtio-gpu.virgl", /* QEMU_CAPS_VIRTIO_GPU_VIRGL */
351 "virtio-keyboard", /* QEMU_CAPS_VIRTIO_KEYBOARD */
352 "virtio-mouse", /* QEMU_CAPS_VIRTIO_MOUSE */
353 "virtio-tablet", /* QEMU_CAPS_VIRTIO_TABLET */
354 "virtio-input-host", /* QEMU_CAPS_VIRTIO_INPUT_HOST */
355
356 /* 205 */
357 "chardev-file-append", /* QEMU_CAPS_CHARDEV_FILE_APPEND */
358 "ich9-disable-s3", /* QEMU_CAPS_ICH9_DISABLE_S3 */
359 "ich9-disable-s4", /* QEMU_CAPS_ICH9_DISABLE_S4 */
360 "vserport-change-event", /* QEMU_CAPS_VSERPORT_CHANGE */
361 "virtio-balloon-pci.deflate-on-oom", /* QEMU_CAPS_VIRTIO_BALLOON_AUTODEFLATE */
362
363 /* 210 */
364 "mptsas1068", /* QEMU_CAPS_SCSI_MPTSAS1068 */
365 "spice-gl", /* QEMU_CAPS_SPICE_GL */
366 "qxl.vram64_size_mb", /* QEMU_CAPS_QXL_VRAM64 */
367 "qxl-vga.vram64_size_mb", /* X_QEMU_CAPS_QXL_VGA_VRAM64 */
368 "chardev-logfile", /* QEMU_CAPS_CHARDEV_LOGFILE */
369
370 /* 215 */
371 "debug-threads", /* X_QEMU_CAPS_NAME_DEBUG_THREADS */
372 "secret", /* X_QEMU_CAPS_OBJECT_SECRET */
373 "pxb", /* QEMU_CAPS_DEVICE_PXB */
374 "pxb-pcie", /* QEMU_CAPS_DEVICE_PXB_PCIE */
375 "device-tray-moved-event", /* X_QEMU_CAPS_DEVICE_TRAY_MOVED */
376
377 /* 220 */
378 "nec-usb-xhci-ports", /* QEMU_CAPS_NEC_USB_XHCI_PORTS */
379 "virtio-scsi-pci.iothread", /* QEMU_CAPS_VIRTIO_SCSI_IOTHREAD */
380 "name-guest", /* X_QEMU_CAPS_NAME_GUEST */
381 "qxl.max_outputs", /* QEMU_CAPS_QXL_MAX_OUTPUTS */
382 "qxl-vga.max_outputs", /* X_QEMU_CAPS_QXL_VGA_MAX_OUTPUTS */
383
384 /* 225 */
385 "spice-unix", /* X_QEMU_CAPS_SPICE_UNIX */
386 "drive-detect-zeroes", /* QEMU_CAPS_DRIVE_DETECT_ZEROES */
387 "tls-creds-x509", /* X_QEMU_CAPS_OBJECT_TLS_CREDS_X509 */
388 "display", /* X_QEMU_CAPS_DISPLAY */
389 "intel-iommu", /* QEMU_CAPS_DEVICE_INTEL_IOMMU */
390
391 /* 230 */
392 "smm", /* X_QEMU_CAPS_MACHINE_SMM_OPT */
393 "virtio-pci-disable-legacy", /* QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY */
394 "query-hotpluggable-cpus", /* QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS */
395 "virtio-net.rx_queue_size", /* QEMU_CAPS_VIRTIO_NET_RX_QUEUE_SIZE */
396 "machine-iommu", /* X_QEMU_CAPS_MACHINE_IOMMU */
397
398 /* 235 */
399 "virtio-vga", /* QEMU_CAPS_DEVICE_VIRTIO_VGA */
400 "drive-iotune-max-length", /* X_QEMU_CAPS_DRIVE_IOTUNE_MAX_LENGTH */
401 "ivshmem-plain", /* QEMU_CAPS_DEVICE_IVSHMEM_PLAIN */
402 "ivshmem-doorbell", /* QEMU_CAPS_DEVICE_IVSHMEM_DOORBELL */
403 "query-qmp-schema", /* X_QEMU_CAPS_QUERY_QMP_SCHEMA */
404
405 /* 240 */
406 "gluster.debug_level", /* QEMU_CAPS_GLUSTER_DEBUG_LEVEL */
407 "vhost-scsi", /* QEMU_CAPS_DEVICE_VHOST_SCSI */
408 "drive-iotune-group", /* X_QEMU_CAPS_DRIVE_IOTUNE_GROUP */
409 "query-cpu-model-expansion", /* QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION */
410 "virtio-net.host_mtu", /* QEMU_CAPS_VIRTIO_NET_HOST_MTU */
411
412 /* 245 */
413 "spice-rendernode", /* QEMU_CAPS_SPICE_RENDERNODE */
414 "nvdimm", /* QEMU_CAPS_DEVICE_NVDIMM */
415 "pcie-root-port", /* QEMU_CAPS_DEVICE_PCIE_ROOT_PORT */
416 "query-cpu-definitions", /* QEMU_CAPS_QUERY_CPU_DEFINITIONS */
417 "block-write-threshold", /* QEMU_CAPS_BLOCK_WRITE_THRESHOLD */
418
419 /* 250 */
420 "query-named-block-nodes", /* QEMU_CAPS_QUERY_NAMED_BLOCK_NODES */
421 "cpu-cache", /* QEMU_CAPS_CPU_CACHE */
422 "qemu-xhci", /* QEMU_CAPS_DEVICE_QEMU_XHCI */
423 "kernel-irqchip", /* X_QEMU_CAPS_MACHINE_KERNEL_IRQCHIP */
424 "kernel-irqchip.split", /* X_QEMU_CAPS_MACHINE_KERNEL_IRQCHIP_SPLIT */
425
426 /* 255 */
427 "intel-iommu.intremap", /* QEMU_CAPS_INTEL_IOMMU_INTREMAP */
428 "intel-iommu.caching-mode", /* QEMU_CAPS_INTEL_IOMMU_CACHING_MODE */
429 "intel-iommu.eim", /* QEMU_CAPS_INTEL_IOMMU_EIM */
430 "intel-iommu.device-iotlb", /* QEMU_CAPS_INTEL_IOMMU_DEVICE_IOTLB */
431 "virtio.iommu_platform", /* X_QEMU_CAPS_VIRTIO_PCI_IOMMU_PLATFORM */
432
433 /* 260 */
434 "virtio.ats", /* X_QEMU_CAPS_VIRTIO_PCI_ATS */
435 "loadparm", /* QEMU_CAPS_LOADPARM */
436 "spapr-pci-host-bridge", /* QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE */
437 "spapr-pci-host-bridge.numa_node", /* QEMU_CAPS_SPAPR_PCI_HOST_BRIDGE_NUMA_NODE */
438 "vnc-multi-servers", /* X_QEMU_CAPS_VNC_MULTI_SERVERS */
439
440 /* 265 */
441 "virtio-net.tx_queue_size", /* QEMU_CAPS_VIRTIO_NET_TX_QUEUE_SIZE */
442 "chardev-reconnect", /* QEMU_CAPS_CHARDEV_RECONNECT */
443 "virtio-gpu.max_outputs", /* QEMU_CAPS_VIRTIO_GPU_MAX_OUTPUTS */
444 "vxhs", /* QEMU_CAPS_VXHS */
445 "virtio-blk.num-queues", /* QEMU_CAPS_VIRTIO_BLK_NUM_QUEUES */
446
447 /* 270 */
448 "machine.pseries.resize-hpt", /* QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT */
449 "vmcoreinfo", /* QEMU_CAPS_DEVICE_VMCOREINFO */
450 "spapr-vty", /* QEMU_CAPS_DEVICE_SPAPR_VTY */
451 "sclplmconsole", /* QEMU_CAPS_DEVICE_SCLPLMCONSOLE */
452 "numa.dist", /* X_QEMU_CAPS_NUMA_DIST */
453
454 /* 275 */
455 "disk-share-rw", /* QEMU_CAPS_DISK_SHARE_RW */
456 "iscsi.password-secret", /* X_QEMU_CAPS_ISCSI_PASSWORD_SECRET */
457 "isa-serial", /* QEMU_CAPS_DEVICE_ISA_SERIAL */
458 "pl011", /* QEMU_CAPS_DEVICE_PL011 */
459 "machine.pseries.max-cpu-compat", /* QEMU_CAPS_MACHINE_PSERIES_MAX_CPU_COMPAT */
460
461 /* 280 */
462 "dump-completed", /* QEMU_CAPS_DUMP_COMPLETED */
463 "virtio-gpu-ccw", /* QEMU_CAPS_DEVICE_VIRTIO_GPU_CCW */
464 "virtio-keyboard-ccw", /* QEMU_CAPS_DEVICE_VIRTIO_KEYBOARD_CCW */
465 "virtio-mouse-ccw", /* QEMU_CAPS_DEVICE_VIRTIO_MOUSE_CCW */
466 "virtio-tablet-ccw", /* QEMU_CAPS_DEVICE_VIRTIO_TABLET_CCW */
467
468 /* 285 */
469 "qcow2-luks", /* QEMU_CAPS_QCOW2_LUKS */
470 "pcie-pci-bridge", /* QEMU_CAPS_DEVICE_PCIE_PCI_BRIDGE */
471 "seccomp-blacklist", /* X_QEMU_CAPS_SECCOMP_BLACKLIST */
472 "query-cpus-fast", /* QEMU_CAPS_QUERY_CPUS_FAST */
473 "disk-write-cache", /* QEMU_CAPS_DISK_WRITE_CACHE */
474
475 /* 290 */
476 "nbd-tls", /* QEMU_CAPS_NBD_TLS */
477 "tpm-crb", /* QEMU_CAPS_DEVICE_TPM_CRB */
478 "pr-manager-helper", /* QEMU_CAPS_PR_MANAGER_HELPER */
479 "qom-list-properties", /* QEMU_CAPS_QOM_LIST_PROPERTIES */
480 "memory-backend-file.discard-data", /* QEMU_CAPS_OBJECT_MEMORY_FILE_DISCARD */
481
482 /* 295 */
483 "virtual-css-bridge", /* QEMU_CAPS_CCW */
484 "virtual-css-bridge.cssid-unrestricted", /* QEMU_CAPS_CCW_CSSID_UNRESTRICTED */
485 "vfio-ccw", /* QEMU_CAPS_DEVICE_VFIO_CCW */
486 "sdl-gl", /* X_QEMU_CAPS_SDL_GL */
487 "screendump_device", /* QEMU_CAPS_SCREENDUMP_DEVICE */
488
489 /* 300 */
490 "hda-output", /* QEMU_CAPS_HDA_OUTPUT */
491 "blockdev-del", /* QEMU_CAPS_BLOCKDEV_DEL */
492 "vmgenid", /* QEMU_CAPS_DEVICE_VMGENID */
493 "vhost-vsock", /* QEMU_CAPS_DEVICE_VHOST_VSOCK */
494 "chardev-fd-pass", /* QEMU_CAPS_CHARDEV_FD_PASS_COMMANDLINE */
495
496 /* 305 */
497 "tpm-emulator", /* QEMU_CAPS_DEVICE_TPM_EMULATOR */
498 "mch", /* QEMU_CAPS_DEVICE_MCH */
499 "mch.extended-tseg-mbytes", /* QEMU_CAPS_MCH_EXTENDED_TSEG_MBYTES */
500 "sev-guest", /* QEMU_CAPS_SEV_GUEST */
501 "machine.pseries.cap-hpt-max-page-size", /* QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE */
502
503 /* 310 */
504 "machine.pseries.cap-htm", /* QEMU_CAPS_MACHINE_PSERIES_CAP_HTM */
505 "usb-storage.werror", /* QEMU_CAPS_USB_STORAGE_WERROR */
506 "egl-headless", /* QEMU_CAPS_EGL_HEADLESS */
507 "vfio-pci.display", /* QEMU_CAPS_VFIO_PCI_DISPLAY */
508 "blockdev", /* QEMU_CAPS_BLOCKDEV */
509
510 /* 315 */
511 "vfio-ap", /* QEMU_CAPS_DEVICE_VFIO_AP */
512 "zpci", /* QEMU_CAPS_DEVICE_ZPCI */
513 "memory-backend-memfd", /* QEMU_CAPS_OBJECT_MEMORY_MEMFD */
514 "memory-backend-memfd.hugetlb", /* QEMU_CAPS_OBJECT_MEMORY_MEMFD_HUGETLB */
515 "iothread.poll-max-ns", /* QEMU_CAPS_IOTHREAD_POLLING */
516
517 /* 320 */
518 "machine.pseries.cap-nested-hv", /* QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV */
519 "egl-headless.rendernode", /* QEMU_CAPS_EGL_HEADLESS_RENDERNODE */
520 "memory-backend-file.align", /* QEMU_CAPS_OBJECT_MEMORY_FILE_ALIGN */
521 "memory-backend-file.pmem", /* QEMU_CAPS_OBJECT_MEMORY_FILE_PMEM */
522 "nvdimm.unarmed", /* QEMU_CAPS_DEVICE_NVDIMM_UNARMED */
523
524 /* 325 */
525 "scsi-disk.device_id", /* QEMU_CAPS_SCSI_DISK_DEVICE_ID */
526 "virtio-pci-non-transitional", /* QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL */
527 "overcommit", /* QEMU_CAPS_OVERCOMMIT */
528 "query-current-machine", /* QEMU_CAPS_QUERY_CURRENT_MACHINE */
529 "machine.virt.iommu", /* QEMU_CAPS_MACHINE_VIRT_IOMMU */
530
531 /* 330 */
532 "bitmap-merge", /* QEMU_CAPS_BITMAP_MERGE */
533 "nbd-bitmap", /* QEMU_CAPS_NBD_BITMAP */
534 "x86-max-cpu", /* QEMU_CAPS_X86_MAX_CPU */
535 "cpu-unavailable-features", /* QEMU_CAPS_CPU_UNAVAILABLE_FEATURES */
536 "canonical-cpu-features", /* QEMU_CAPS_CANONICAL_CPU_FEATURES */
537
538 /* 335 */
539 "bochs-display", /* QEMU_CAPS_DEVICE_BOCHS_DISPLAY */
540 "migration-file-drop-cache", /* QEMU_CAPS_MIGRATION_FILE_DROP_CACHE */
541 "dbus-vmstate", /* QEMU_CAPS_DBUS_VMSTATE */
542 "vhost-user-gpu", /* QEMU_CAPS_DEVICE_VHOST_USER_GPU */
543 "vhost-user-vga", /* QEMU_CAPS_DEVICE_VHOST_USER_VGA */
544
545 /* 340 */
546 "incremental-backup", /* QEMU_CAPS_INCREMENTAL_BACKUP */
547 "query-cpu-model-baseline", /* QEMU_CAPS_QUERY_CPU_MODEL_BASELINE */
548 "query-cpu-model-comparison", /* QEMU_CAPS_QUERY_CPU_MODEL_COMPARISON */
549 "ramfb", /* QEMU_CAPS_DEVICE_RAMFB */
550 "machine.pseries.cap-ccf-assist", /* QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST */
551
552 /* 345 */
553 "arm-max-cpu", /* QEMU_CAPS_ARM_MAX_CPU */
554 "blockdev-file-dynamic-auto-read-only", /* QEMU_CAPS_BLOCK_FILE_AUTO_READONLY_DYNAMIC */
555 "savevm-monitor-nodes", /* QEMU_CAPS_SAVEVM_MONITOR_NODES */
556 "drive-nvme", /* QEMU_CAPS_DRIVE_NVME */
557 "smp-dies", /* QEMU_CAPS_SMP_DIES */
558
559 /* 350 */
560 "i8042", /* QEMU_CAPS_DEVICE_I8042 */
561 "rng-builtin", /* QEMU_CAPS_OBJECT_RNG_BUILTIN */
562 "virtio-net.failover", /* QEMU_CAPS_VIRTIO_NET_FAILOVER */
563 "tpm-spapr", /* QEMU_CAPS_DEVICE_TPM_SPAPR */
564 "cpu.kvm-no-adjvtime", /* QEMU_CAPS_CPU_KVM_NO_ADJVTIME */
565
566 /* 355 */
567 "vhost-user-fs", /* QEMU_CAPS_DEVICE_VHOST_USER_FS */
568 "query-named-block-nodes.flat", /* QEMU_CAPS_QMP_QUERY_NAMED_BLOCK_NODES_FLAT */
569 "blockdev-snapshot.allow-write-only-overlay", /* QEMU_CAPS_BLOCKDEV_SNAPSHOT_ALLOW_WRITE_ONLY */
570 "blockdev-reopen", /* QEMU_CAPS_BLOCKDEV_REOPEN */
571 "storage.werror", /* QEMU_CAPS_STORAGE_WERROR */
572
573 /* 360 */
574 "fsdev.multidevs", /* QEMU_CAPS_FSDEV_MULTIDEVS */
575 "virtio.packed", /* QEMU_CAPS_VIRTIO_PACKED_QUEUES */
576 "pcie-root-port.hotplug", /* QEMU_CAPS_PCIE_ROOT_PORT_HOTPLUG */
577 "aio.io_uring", /* QEMU_CAPS_AIO_IO_URING */
578 "machine.pseries.cap-cfpc", /* QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC */
579
580 /* 365 */
581 "machine.pseries.cap-sbbc", /* QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC */
582 "machine.pseries.cap-ibs", /* QEMU_CAPS_MACHINE_PSERIES_CAP_IBS */
583 "tcg", /* QEMU_CAPS_TCG */
584 "virtio-blk-pci.scsi.default.disabled", /* QEMU_CAPS_VIRTIO_BLK_SCSI_DEFAULT_DISABLED */
585 "pvscsi", /* QEMU_CAPS_SCSI_PVSCSI */
586
587 /* 370 */
588 "cpu.migratable", /* QEMU_CAPS_CPU_MIGRATABLE */
589 "query-cpu-model-expansion.migratable", /* QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION_MIGRATABLE */
590 "fw_cfg", /* X_QEMU_CAPS_FW_CFG */
591 "migration-param.bandwidth", /* QEMU_CAPS_MIGRATION_PARAM_BANDWIDTH */
592 "migration-param.downtime", /* QEMU_CAPS_MIGRATION_PARAM_DOWNTIME */
593
594 /* 375 */
595 "migration-param.xbzrle-cache-size", /* QEMU_CAPS_MIGRATION_PARAM_XBZRLE_CACHE_SIZE */
596 "intel-iommu.aw-bits", /* QEMU_CAPS_INTEL_IOMMU_AW_BITS */
597 "spapr-tpm-proxy", /* QEMU_CAPS_DEVICE_SPAPR_TPM_PROXY */
598 "numa.hmat", /* QEMU_CAPS_NUMA_HMAT */
599 "blockdev-hostdev-scsi", /* QEMU_CAPS_BLOCKDEV_HOSTDEV_SCSI */
600
601 /* 380 */
602 "usb-host.hostdevice", /* QEMU_CAPS_USB_HOST_HOSTDEVICE */
603 "virtio-balloon.free-page-reporting", /* QEMU_CAPS_VIRTIO_BALLOON_FREE_PAGE_REPORTING */
604 "block-export-add", /* QEMU_CAPS_BLOCK_EXPORT_ADD */
605 "netdev.vhost-vdpa", /* QEMU_CAPS_NETDEV_VHOST_VDPA */
606 "fsdev.createmode", /* X_QEMU_CAPS_FSDEV_CREATEMODE */
607
608 /* 385 */
609 "ncr53c90", /* QEMU_CAPS_SCSI_NCR53C90 */
610 "dc390", /* QEMU_CAPS_SCSI_DC390 */
611 "am53c974", /* QEMU_CAPS_SCSI_AM53C974 */
612 "virtio-pmem-pci", /* QEMU_CAPS_DEVICE_VIRTIO_PMEM_PCI */
613 "vhost-user-fs.bootindex", /* QEMU_CAPS_VHOST_USER_FS_BOOTINDEX */
614
615 /* 390 */
616 "vhost-user-blk", /* QEMU_CAPS_DEVICE_VHOST_USER_BLK */
617 "cpu-max", /* QEMU_CAPS_CPU_MAX */
618 "memory-backend-file.x-use-canonical-path-for-ramblock-id", /* QEMU_CAPS_X_USE_CANONICAL_PATH_FOR_RAMBLOCK_ID */
619 "vnc-opts", /* X_QEMU_CAPS_VNC_OPTS */
620 "migration-param.block-bitmap-mapping", /* QEMU_CAPS_MIGRATION_PARAM_BLOCK_BITMAP_MAPPING */
621
622 /* 395 */
623 "vnc-power-control", /* QEMU_CAPS_VNC_POWER_CONTROL */
624 "audiodev", /* QEMU_CAPS_AUDIODEV */
625 "blockdev-backup", /* QEMU_CAPS_BLOCKDEV_BACKUP */
626 "object.qapified", /* QEMU_CAPS_OBJECT_JSON */
627 "rotation-rate", /* QEMU_CAPS_ROTATION_RATE */
628
629 /* 400 */
630 "compat-deprecated", /* QEMU_CAPS_COMPAT_DEPRECATED */
631 "acpi-index", /* QEMU_CAPS_ACPI_INDEX */
632 "input-linux", /* QEMU_CAPS_INPUT_LINUX */
633 "virtio-gpu-gl-pci", /* QEMU_CAPS_VIRTIO_GPU_GL_PCI */
634 "virtio-vga-gl", /* QEMU_CAPS_VIRTIO_VGA_GL */
635
636 /* 405 */
637 "confidential-guest-support", /* QEMU_CAPS_MACHINE_CONFIDENTAL_GUEST_SUPPORT */
638 "query-display-options", /* QEMU_CAPS_QUERY_DISPLAY_OPTIONS */
639 "s390-pv-guest", /* QEMU_CAPS_S390_PV_GUEST */
640 "set-action", /* QEMU_CAPS_SET_ACTION */
641 "virtio-blk.queue-size", /* QEMU_CAPS_VIRTIO_BLK_QUEUE_SIZE */
642
643 /* 410 */
644 "virtio-mem-pci", /* QEMU_CAPS_DEVICE_VIRTIO_MEM_PCI */
645 "memory-backend-file.reserve", /* QEMU_CAPS_MEMORY_BACKEND_RESERVE */
646 "piix4.acpi-root-pci-hotplug", /* QEMU_CAPS_PIIX4_ACPI_ROOT_PCI_HOTPLUG */
647 "netdev.json", /* QEMU_CAPS_NETDEV_JSON */
648 "chardev.json", /* QEMU_CAPS_CHARDEV_JSON */
649
650 /* 415 */
651 "device.json", /* QEMU_CAPS_DEVICE_JSON */
652 "query-dirty-rate", /* QEMU_CAPS_QUERY_DIRTY_RATE */
653 "rbd-encryption", /* QEMU_CAPS_RBD_ENCRYPTION */
654
655 /* 420 */
656 "nvmm",
657 );
658
659
660 typedef struct _virQEMUCapsMachineType virQEMUCapsMachineType;
661 struct _virQEMUCapsMachineType {
662 char *name;
663 char *alias;
664 unsigned int maxCpus;
665 bool hotplugCpus;
666 bool qemuDefault;
667 char *defaultCPU;
668 bool numaMemSupported;
669 char *defaultRAMid;
670 bool deprecated;
671 };
672
673 typedef struct _virQEMUCapsHostCPUData virQEMUCapsHostCPUData;
674 struct _virQEMUCapsHostCPUData {
675 /* Only the "info" part is stored in the capabilities cache, the rest is
676 * re-computed from other fields and external data sources every time we
677 * probe QEMU or load the cache.
678 */
679 qemuMonitorCPUModelInfo *info;
680 /* Host CPU definition reported in domain capabilities. */
681 virCPUDef *reported;
682 /* Migratable host CPU definition used for updating guest CPU. */
683 virCPUDef *migratable;
684 /* CPU definition with features detected by libvirt using virCPUGetHost
685 * combined with features reported by QEMU. This is used for backward
686 * compatible comparison between a guest CPU and a host CPU. */
687 virCPUDef *full;
688 };
689
690 typedef struct _virQEMUCapsAccel virQEMUCapsAccel;
691 struct _virQEMUCapsAccel {
692 size_t nmachineTypes;
693 virQEMUCapsMachineType *machineTypes;
694 virQEMUCapsHostCPUData hostCPU;
695 qemuMonitorCPUDefs *cpuModels;
696 };
697
698
699 /*
700 * Update the XML parser/formatter when adding more
701 * information to this struct so that it gets cached
702 * correctly. It does not have to be ABI-stable, as
703 * the cache will be discarded & repopulated if the
704 * timestamp on the libvirtd binary changes.
705 *
706 * And don't forget to update virQEMUCapsNewCopy.
707 */
708 struct _virQEMUCaps {
709 virObject parent;
710
711 bool kvmSupportsNesting;
712 bool kvmSupportsSecureGuest;
713
714 char *binary;
715 time_t ctime;
716 time_t libvirtCtime;
717 time_t modDirMtime;
718 bool invalidation;
719
720 virBitmap *flags;
721
722 unsigned int version;
723 unsigned int kvmVersion;
724 unsigned int libvirtVersion;
725 unsigned int microcodeVersion;
726 char *hostCPUSignature;
727 char *package;
728 char *kernelVersion;
729
730 virArch arch;
731 virCPUData *cpuData;
732
733 size_t ngicCapabilities;
734 virGICCapability *gicCapabilities;
735
736 virSEVCapability *sevCapabilities;
737
738 /* Capabilities which may differ depending on the accelerator. */
739 virQEMUCapsAccel kvm;
740 virQEMUCapsAccel nvmm;
741 virQEMUCapsAccel tcg;
742 };
743
744 struct virQEMUCapsSearchData {
745 virArch arch;
746 const char *binaryFilter;
747 };
748
749
750 static virClass *virQEMUCapsClass;
751 static void virQEMUCapsDispose(void *obj);
752
virQEMUCapsOnceInit(void)753 static int virQEMUCapsOnceInit(void)
754 {
755 if (!VIR_CLASS_NEW(virQEMUCaps, virClassForObject()))
756 return -1;
757
758 return 0;
759 }
760
761 VIR_ONCE_GLOBAL_INIT(virQEMUCaps);
762
virQEMUCapsArchFromString(const char * arch)763 virArch virQEMUCapsArchFromString(const char *arch)
764 {
765 if (STREQ(arch, "i386"))
766 return VIR_ARCH_I686;
767 if (STREQ(arch, "arm"))
768 return VIR_ARCH_ARMV7L;
769 if (STREQ(arch, "or32"))
770 return VIR_ARCH_OR32;
771
772 return virArchFromString(arch);
773 }
774
775
virQEMUCapsArchToString(virArch arch)776 const char *virQEMUCapsArchToString(virArch arch)
777 {
778 if (arch == VIR_ARCH_I686)
779 return "i386";
780 if (arch == VIR_ARCH_ARMV6L || arch == VIR_ARCH_ARMV7L)
781 return "arm";
782 if (arch == VIR_ARCH_OR32)
783 return "or32";
784
785 return virArchToString(arch);
786 }
787
788
789 /* Checks whether a domain with @guest arch can run natively on @host.
790 */
791 bool
virQEMUCapsGuestIsNative(virArch host,virArch guest)792 virQEMUCapsGuestIsNative(virArch host,
793 virArch guest)
794 {
795 /* host & guest arches match */
796 if (host == guest)
797 return true;
798
799 /* hostarch is x86_64 and guest arch is i686 (needs -cpu qemu32) */
800 if (host == VIR_ARCH_X86_64 && guest == VIR_ARCH_I686)
801 return true;
802
803 /* hostarch is aarch64 and guest arch is armv7l (needs -cpu aarch64=off) */
804 if (host == VIR_ARCH_AARCH64 && guest == VIR_ARCH_ARMV7L)
805 return true;
806
807 /* hostarch and guestarch are both ppc64 */
808 if (ARCH_IS_PPC64(host) && ARCH_IS_PPC64(guest))
809 return true;
810
811 return false;
812 }
813
814
815 /* Given a host and guest architectures, find a suitable QEMU target.
816 *
817 * This is meant to be used as a second attempt if qemu-system-$guestarch
818 * can't be found, eg. on a x86_64 host you want to use qemu-system-i386,
819 * if available, instead of qemu-system-x86_64 to run i686 guests */
820 static virArch
virQEMUCapsFindTarget(virArch hostarch,virArch guestarch)821 virQEMUCapsFindTarget(virArch hostarch,
822 virArch guestarch)
823 {
824 if (virQEMUCapsGuestIsNative(hostarch, guestarch))
825 guestarch = hostarch;
826
827 /* Both ppc64 and ppc64le guests can use the ppc64 target */
828 if (ARCH_IS_PPC64(guestarch))
829 guestarch = VIR_ARCH_PPC64;
830
831 return guestarch;
832 }
833
834
835 static virQEMUCapsAccel *
virQEMUCapsGetAccel(virQEMUCaps * qemuCaps,virDomainVirtType type)836 virQEMUCapsGetAccel(virQEMUCaps *qemuCaps,
837 virDomainVirtType type)
838 {
839 if (type == VIR_DOMAIN_VIRT_KVM)
840 return &qemuCaps->kvm;
841
842 if (type == VIR_DOMAIN_VIRT_NVMM)
843 return &qemuCaps->nvmm;
844
845 return &qemuCaps->tcg;
846 }
847
848
849 static void
virQEMUCapsSetDefaultMachine(virQEMUCapsAccel * caps,size_t defIdx)850 virQEMUCapsSetDefaultMachine(virQEMUCapsAccel *caps,
851 size_t defIdx)
852 {
853 virQEMUCapsMachineType tmp = caps->machineTypes[defIdx];
854
855 memmove(caps->machineTypes + 1,
856 caps->machineTypes,
857 sizeof(caps->machineTypes[0]) * defIdx);
858
859 caps->machineTypes[0] = tmp;
860 }
861
862
863 static char *
virQEMUCapsFindBinary(const char * format,const char * archstr)864 virQEMUCapsFindBinary(const char *format,
865 const char *archstr)
866 {
867 char *ret = NULL;
868 char *binary = NULL;
869
870 binary = g_strdup_printf(format, archstr);
871
872 ret = virFindFileInPath(binary);
873 VIR_FREE(binary);
874 return ret;
875 }
876
877 static char *
virQEMUCapsFindBinaryForArch(virArch hostarch,virArch guestarch)878 virQEMUCapsFindBinaryForArch(virArch hostarch,
879 virArch guestarch)
880 {
881 char *ret = NULL;
882 const char *archstr;
883 virArch target;
884
885 /* armv7l guests can only take advantage of KVM on aarch64 hosts by
886 * using the qemu-system-aarch64 binary, so look for that one first
887 * to avoid using qemu-system-arm (and thus TCG) instead */
888 if (hostarch == VIR_ARCH_AARCH64 && guestarch == VIR_ARCH_ARMV7L) {
889 archstr = virQEMUCapsArchToString(hostarch);
890 if ((ret = virQEMUCapsFindBinary("qemu-system-%s", archstr)) != NULL)
891 return ret;
892 }
893
894 /* First attempt: try the guest architecture as it is */
895 archstr = virQEMUCapsArchToString(guestarch);
896 if ((ret = virQEMUCapsFindBinary("qemu-system-%s", archstr)) != NULL)
897 return ret;
898
899 /* Second attempt: try looking up by target instead */
900 target = virQEMUCapsFindTarget(hostarch, guestarch);
901 if (target != guestarch) {
902 archstr = virQEMUCapsArchToString(target);
903 if ((ret = virQEMUCapsFindBinary("qemu-system-%s", archstr)) != NULL)
904 return ret;
905 }
906
907 return ret;
908 }
909
910
911 char *
virQEMUCapsGetDefaultEmulator(virArch hostarch,virArch guestarch)912 virQEMUCapsGetDefaultEmulator(virArch hostarch,
913 virArch guestarch)
914 {
915 char *binary = NULL;
916 /* Check for existence of base emulator, or alternate base
917 * which can be used with magic cpu choice
918 */
919 binary = virQEMUCapsFindBinaryForArch(hostarch, guestarch);
920
921 /* RHEL doesn't follow the usual naming for QEMU binaries and ships
922 * a single binary named qemu-kvm outside of $PATH instead */
923 if (virQEMUCapsGuestIsNative(hostarch, guestarch) && !binary)
924 binary = g_strdup("/usr/libexec/qemu-kvm");
925
926 return binary;
927 }
928
929
930 static int
virQEMUCapsInitGuest(virCaps * caps,virFileCache * cache,virArch hostarch,virArch guestarch)931 virQEMUCapsInitGuest(virCaps *caps,
932 virFileCache *cache,
933 virArch hostarch,
934 virArch guestarch)
935 {
936 char *binary = NULL;
937 virQEMUCaps *qemuCaps = NULL;
938 int ret = -1;
939
940 binary = virQEMUCapsGetDefaultEmulator(hostarch, guestarch);
941
942 /* Ignore binary if extracting version info fails */
943 if (binary) {
944 if (!(qemuCaps = virQEMUCapsCacheLookup(cache, binary))) {
945 virResetLastError();
946 VIR_FREE(binary);
947 }
948 }
949
950 ret = virQEMUCapsInitGuestFromBinary(caps,
951 binary, qemuCaps,
952 guestarch);
953
954 VIR_FREE(binary);
955 virObjectUnref(qemuCaps);
956
957 return ret;
958 }
959
960
961 static int
virQEMUCapsGetMachineTypesCaps(virQEMUCaps * qemuCaps,size_t * nmachines,virCapsGuestMachine *** machines)962 virQEMUCapsGetMachineTypesCaps(virQEMUCaps *qemuCaps,
963 size_t *nmachines,
964 virCapsGuestMachine ***machines)
965 {
966 size_t i;
967 virQEMUCapsAccel *accel;
968 g_autoptr(GPtrArray) array = NULL;
969
970 /* Guest capabilities do not report TCG vs. KVM caps separately. We just
971 * take the set of machine types we probed first. */
972 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
973 accel = &qemuCaps->kvm;
974 else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NVMM))
975 accel = &qemuCaps->nvmm;
976 else
977 accel = &qemuCaps->tcg;
978
979 *machines = NULL;
980 *nmachines = accel->nmachineTypes;
981
982 if (*nmachines == 0)
983 return 0;
984
985 array = g_ptr_array_sized_new(*nmachines);
986
987 for (i = 0; i < accel->nmachineTypes; i++) {
988 virCapsGuestMachine *mach = g_new0(virCapsGuestMachine, 1);
989 if (accel->machineTypes[i].alias) {
990 mach->name = g_strdup(accel->machineTypes[i].alias);
991 mach->canonical = g_strdup(accel->machineTypes[i].name);
992 } else {
993 mach->name = g_strdup(accel->machineTypes[i].name);
994 }
995 mach->maxCpus = accel->machineTypes[i].maxCpus;
996 mach->deprecated = accel->machineTypes[i].deprecated;
997 g_ptr_array_add(array, mach);
998 }
999
1000 /* Make sure all canonical machine types also have their own entry so that
1001 * /capabilities/guest/arch[@name='...']/machine/text() XPath selects all
1002 * supported machine types.
1003 */
1004 i = 0;
1005 while (i < array->len) {
1006 size_t j;
1007 bool found = false;
1008 virCapsGuestMachine *machine = g_ptr_array_index(array, i);
1009
1010 if (!machine->canonical) {
1011 i++;
1012 continue;
1013 }
1014
1015 for (j = 0; j < array->len; j++) {
1016 virCapsGuestMachine *mach = g_ptr_array_index(array, j);
1017 if (STREQ(machine->canonical, mach->name)) {
1018 found = true;
1019 break;
1020 }
1021 }
1022
1023 if (!found) {
1024 virCapsGuestMachine *mach;
1025 mach = g_new0(virCapsGuestMachine, 1);
1026 mach->name = g_strdup(machine->canonical);
1027 mach->maxCpus = machine->maxCpus;
1028 mach->deprecated = machine->deprecated;
1029 g_ptr_array_insert(array, i, mach);
1030 i++;
1031 }
1032 i++;
1033 }
1034
1035 *nmachines = array->len;
1036 *machines = g_new0(virCapsGuestMachine *, array->len);
1037 for (i = 0; i < array->len; ++i)
1038 (*machines)[i] = g_ptr_array_index(array, i);
1039
1040 return 0;
1041 }
1042
1043
1044 int
virQEMUCapsInitGuestFromBinary(virCaps * caps,const char * binary,virQEMUCaps * qemuCaps,virArch guestarch)1045 virQEMUCapsInitGuestFromBinary(virCaps *caps,
1046 const char *binary,
1047 virQEMUCaps *qemuCaps,
1048 virArch guestarch)
1049 {
1050 virCapsGuest *guest;
1051 virCapsGuestMachine **machines = NULL;
1052 size_t nmachines = 0;
1053 int ret = -1;
1054
1055 if (!binary)
1056 return 0;
1057
1058 if (virQEMUCapsGetMachineTypesCaps(qemuCaps, &nmachines, &machines) < 0)
1059 goto cleanup;
1060
1061 /* We register kvm as the base emulator too, since we can
1062 * just give -no-kvm to disable acceleration if required */
1063 guest = virCapabilitiesAddGuest(caps, VIR_DOMAIN_OSTYPE_HVM,
1064 guestarch, binary,
1065 NULL, nmachines, machines);
1066
1067 machines = NULL;
1068 nmachines = 0;
1069
1070 /* CPU selection is always available, because all QEMU versions
1071 * we support can use at least '-cpu host' */
1072 virCapabilitiesAddGuestFeature(guest, VIR_CAPS_GUEST_FEATURE_TYPE_CPUSELECTION);
1073 virCapabilitiesAddGuestFeature(guest, VIR_CAPS_GUEST_FEATURE_TYPE_DEVICEBOOT);
1074 virCapabilitiesAddGuestFeatureWithToggle(guest, VIR_CAPS_GUEST_FEATURE_TYPE_DISKSNAPSHOT,
1075 true, false);
1076
1077 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_TCG)) {
1078 virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_QEMU,
1079 NULL, NULL, 0, NULL);
1080 }
1081
1082 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
1083 virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_KVM,
1084 NULL, NULL, 0, NULL);
1085 }
1086
1087 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NVMM)) {
1088 virCapabilitiesAddGuestDomain(guest, VIR_DOMAIN_VIRT_NVMM,
1089 NULL, NULL, 0, NULL);
1090 }
1091
1092 if ((ARCH_IS_X86(guestarch) || guestarch == VIR_ARCH_AARCH64))
1093 virCapabilitiesAddGuestFeatureWithToggle(guest, VIR_CAPS_GUEST_FEATURE_TYPE_ACPI,
1094 true, true);
1095
1096 if (ARCH_IS_X86(guestarch))
1097 virCapabilitiesAddGuestFeatureWithToggle(guest, VIR_CAPS_GUEST_FEATURE_TYPE_APIC,
1098 true, false);
1099
1100 if (guestarch == VIR_ARCH_I686) {
1101 virCapabilitiesAddGuestFeature(guest, VIR_CAPS_GUEST_FEATURE_TYPE_PAE);
1102 virCapabilitiesAddGuestFeature(guest, VIR_CAPS_GUEST_FEATURE_TYPE_NONPAE);
1103 }
1104
1105 ret = 0;
1106
1107 cleanup:
1108
1109 virCapabilitiesFreeMachines(machines, nmachines);
1110
1111 return ret;
1112 }
1113
1114
1115 virCPUDef *
virQEMUCapsProbeHostCPU(virArch hostArch,virDomainCapsCPUModels * models)1116 virQEMUCapsProbeHostCPU(virArch hostArch,
1117 virDomainCapsCPUModels *models)
1118 {
1119 return virCPUGetHost(hostArch, VIR_CPU_TYPE_GUEST, NULL, models);
1120 }
1121
1122
1123 virCaps *
virQEMUCapsInit(virFileCache * cache)1124 virQEMUCapsInit(virFileCache *cache)
1125 {
1126 g_autoptr(virCaps) caps = NULL;
1127 size_t i;
1128 virArch hostarch = virArchFromHost();
1129
1130 if ((caps = virCapabilitiesNew(hostarch,
1131 true, true)) == NULL)
1132 return NULL;
1133
1134 if (virCapabilitiesInitCaches(caps) < 0)
1135 VIR_WARN("Failed to get host CPU cache info");
1136
1137 /* Add the power management features of the host */
1138 if (virNodeSuspendGetTargetMask(&caps->host.powerMgmt) < 0)
1139 VIR_WARN("Failed to get host power management capabilities");
1140
1141 /* Add IOMMU info */
1142 virCapabilitiesHostInitIOMMU(caps);
1143
1144 /* Add huge pages info */
1145 if (virCapabilitiesInitPages(caps) < 0)
1146 VIR_WARN("Failed to get pages info");
1147
1148 /* Add domain migration transport URIs */
1149 virCapabilitiesAddHostMigrateTransport(caps, "tcp");
1150 virCapabilitiesAddHostMigrateTransport(caps, "rdma");
1151
1152 /* QEMU can support pretty much every arch that exists,
1153 * so just probe for them all - we gracefully fail
1154 * if a qemu-system-$ARCH binary can't be found
1155 */
1156 for (i = 0; i < VIR_ARCH_LAST; i++)
1157 if (virQEMUCapsInitGuest(caps, cache,
1158 hostarch,
1159 i) < 0)
1160 return NULL;
1161
1162 return g_steal_pointer(&caps);
1163 }
1164
1165
1166 struct virQEMUCapsStringFlags {
1167 const char *value;
1168 int flag;
1169 };
1170
1171
1172 struct virQEMUCapsStringFlags virQEMUCapsCommands[] = {
1173 { "dump-guest-memory", QEMU_CAPS_DUMP_GUEST_MEMORY },
1174 { "query-spice", QEMU_CAPS_SPICE },
1175 { "query-vnc", QEMU_CAPS_VNC },
1176 { "nbd-server-start", QEMU_CAPS_NBD_SERVER },
1177 { "change-backing-file", QEMU_CAPS_CHANGE_BACKING_FILE },
1178 { "rtc-reset-reinjection", QEMU_CAPS_RTC_RESET_REINJECTION },
1179 { "migrate-incoming", QEMU_CAPS_INCOMING_DEFER },
1180 { "query-hotpluggable-cpus", QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS },
1181 { "query-cpu-model-expansion", QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION },
1182 { "query-cpu-definitions", QEMU_CAPS_QUERY_CPU_DEFINITIONS },
1183 { "query-named-block-nodes", QEMU_CAPS_QUERY_NAMED_BLOCK_NODES },
1184 { "query-cpus-fast", QEMU_CAPS_QUERY_CPUS_FAST },
1185 { "qom-list-properties", QEMU_CAPS_QOM_LIST_PROPERTIES },
1186 { "blockdev-del", QEMU_CAPS_BLOCKDEV_DEL },
1187 { "query-current-machine", QEMU_CAPS_QUERY_CURRENT_MACHINE },
1188 { "block-dirty-bitmap-merge", QEMU_CAPS_BITMAP_MERGE },
1189 { "query-cpu-model-baseline", QEMU_CAPS_QUERY_CPU_MODEL_BASELINE },
1190 { "query-cpu-model-comparison", QEMU_CAPS_QUERY_CPU_MODEL_COMPARISON },
1191 { "block-export-add", QEMU_CAPS_BLOCK_EXPORT_ADD },
1192 { "query-display-options", QEMU_CAPS_QUERY_DISPLAY_OPTIONS },
1193 { "blockdev-reopen", QEMU_CAPS_BLOCKDEV_REOPEN },
1194 { "set-numa-node", QEMU_CAPS_NUMA },
1195 { "set-action", QEMU_CAPS_SET_ACTION },
1196 { "query-dirty-rate", QEMU_CAPS_QUERY_DIRTY_RATE },
1197 };
1198
1199 struct virQEMUCapsStringFlags virQEMUCapsMigration[] = {
1200 { "rdma-pin-all", QEMU_CAPS_MIGRATE_RDMA },
1201 };
1202
1203 /* Use virQEMUCapsQMPSchemaQueries for querying parameters of events */
1204 struct virQEMUCapsStringFlags virQEMUCapsEvents[] = {
1205 { "MIGRATION", QEMU_CAPS_MIGRATION_EVENT },
1206 { "VSERPORT_CHANGE", QEMU_CAPS_VSERPORT_CHANGE },
1207 { "BLOCK_WRITE_THRESHOLD", QEMU_CAPS_BLOCK_WRITE_THRESHOLD },
1208 { "DUMP_COMPLETED", QEMU_CAPS_DUMP_COMPLETED },
1209 };
1210
1211 struct virQEMUCapsStringFlags virQEMUCapsObjectTypes[] = {
1212 { "hda-duplex", QEMU_CAPS_HDA_DUPLEX },
1213 { "hda-micro", QEMU_CAPS_HDA_MICRO },
1214 { "ccid-card-emulated", QEMU_CAPS_CCID_EMULATED },
1215 { "ccid-card-passthru", QEMU_CAPS_CCID_PASSTHRU },
1216 { "piix3-usb-uhci", QEMU_CAPS_PIIX3_USB_UHCI },
1217 { "piix4-usb-uhci", QEMU_CAPS_PIIX4_USB_UHCI },
1218 { "usb-ehci", QEMU_CAPS_USB_EHCI },
1219 { "ich9-usb-ehci1", QEMU_CAPS_ICH9_USB_EHCI1 },
1220 { "vt82c686b-usb-uhci", QEMU_CAPS_VT82C686B_USB_UHCI },
1221 { "pci-ohci", QEMU_CAPS_PCI_OHCI },
1222 { "nec-usb-xhci", QEMU_CAPS_NEC_USB_XHCI },
1223 { "usb-redir", QEMU_CAPS_USB_REDIR },
1224 { "usb-hub", QEMU_CAPS_USB_HUB },
1225 { "ich9-ahci", QEMU_CAPS_ICH9_AHCI },
1226 { "virtio-blk-ccw", QEMU_CAPS_VIRTIO_CCW },
1227 { "sclpconsole", QEMU_CAPS_DEVICE_SCLPCONSOLE },
1228 { "lsi53c895a", QEMU_CAPS_SCSI_LSI },
1229 { "virtio-scsi-pci", QEMU_CAPS_VIRTIO_SCSI },
1230 { "virtio-scsi-ccw", QEMU_CAPS_VIRTIO_SCSI },
1231 { "virtio-scsi-device", QEMU_CAPS_VIRTIO_SCSI },
1232 { "megasas", QEMU_CAPS_SCSI_MEGASAS },
1233 { "qxl", QEMU_CAPS_DEVICE_QXL },
1234 { "scsi-block", QEMU_CAPS_SCSI_BLOCK },
1235 { "VGA", QEMU_CAPS_DEVICE_VGA },
1236 { "cirrus-vga", QEMU_CAPS_DEVICE_CIRRUS_VGA },
1237 { "vmware-svga", QEMU_CAPS_DEVICE_VMWARE_SVGA },
1238 { "usb-serial", QEMU_CAPS_DEVICE_USB_SERIAL },
1239 { "virtio-rng-pci", QEMU_CAPS_DEVICE_VIRTIO_RNG },
1240 { "virtio-rng-ccw", QEMU_CAPS_DEVICE_VIRTIO_RNG },
1241 { "virtio-rng-device", QEMU_CAPS_DEVICE_VIRTIO_RNG },
1242 { "rng-random", QEMU_CAPS_OBJECT_RNG_RANDOM },
1243 { "rng-egd", QEMU_CAPS_OBJECT_RNG_EGD },
1244 { "spapr-nvram", QEMU_CAPS_DEVICE_NVRAM },
1245 { "pci-bridge", QEMU_CAPS_DEVICE_PCI_BRIDGE },
1246 { "vfio-pci", QEMU_CAPS_DEVICE_VFIO_PCI },
1247 { "i82801b11-bridge", QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE },
1248 { "usb-storage", QEMU_CAPS_DEVICE_USB_STORAGE },
1249 { "virtio-mmio", QEMU_CAPS_DEVICE_VIRTIO_MMIO },
1250 { "ich9-intel-hda", QEMU_CAPS_DEVICE_ICH9_INTEL_HDA },
1251 { "pvpanic", QEMU_CAPS_DEVICE_PANIC },
1252 { "usb-kbd", QEMU_CAPS_DEVICE_USB_KBD },
1253 { "memory-backend-ram", QEMU_CAPS_OBJECT_MEMORY_RAM },
1254 { "memory-backend-file", QEMU_CAPS_OBJECT_MEMORY_FILE },
1255 { "usb-audio", QEMU_CAPS_OBJECT_USB_AUDIO },
1256 { "iothread", QEMU_CAPS_OBJECT_IOTHREAD},
1257 { "ivshmem", QEMU_CAPS_DEVICE_IVSHMEM },
1258 { "pc-dimm", QEMU_CAPS_DEVICE_PC_DIMM },
1259 { "pci-serial", QEMU_CAPS_DEVICE_PCI_SERIAL },
1260 { "gpex-pcihost", QEMU_CAPS_OBJECT_GPEX},
1261 { "ioh3420", QEMU_CAPS_DEVICE_IOH3420 },
1262 { "x3130-upstream", QEMU_CAPS_DEVICE_X3130_UPSTREAM },
1263 { "xio3130-downstream", QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM },
1264 { "rtl8139", QEMU_CAPS_DEVICE_RTL8139 },
1265 { "e1000", QEMU_CAPS_DEVICE_E1000 },
1266 { "virtio-net-pci", QEMU_CAPS_DEVICE_VIRTIO_NET },
1267 { "virtio-net-ccw", QEMU_CAPS_DEVICE_VIRTIO_NET },
1268 { "virtio-net-device", QEMU_CAPS_DEVICE_VIRTIO_NET },
1269 { "virtio-gpu-pci", QEMU_CAPS_DEVICE_VIRTIO_GPU },
1270 { "virtio-gpu-device", QEMU_CAPS_DEVICE_VIRTIO_GPU },
1271 { "virtio-vga", QEMU_CAPS_DEVICE_VIRTIO_VGA },
1272 { "virtio-keyboard-device", QEMU_CAPS_VIRTIO_KEYBOARD },
1273 { "virtio-keyboard-pci", QEMU_CAPS_VIRTIO_KEYBOARD },
1274 { "virtio-mouse-device", QEMU_CAPS_VIRTIO_MOUSE },
1275 { "virtio-mouse-pci", QEMU_CAPS_VIRTIO_MOUSE },
1276 { "virtio-tablet-device", QEMU_CAPS_VIRTIO_TABLET },
1277 { "virtio-tablet-pci", QEMU_CAPS_VIRTIO_TABLET },
1278 { "virtio-input-host-device", QEMU_CAPS_VIRTIO_INPUT_HOST },
1279 { "virtio-input-host-pci", QEMU_CAPS_VIRTIO_INPUT_HOST },
1280 { "mptsas1068", QEMU_CAPS_SCSI_MPTSAS1068 },
1281 { "pxb", QEMU_CAPS_DEVICE_PXB },
1282 { "pxb-pcie", QEMU_CAPS_DEVICE_PXB_PCIE },
1283 { "intel-iommu", QEMU_CAPS_DEVICE_INTEL_IOMMU },
1284 { "ivshmem-plain", QEMU_CAPS_DEVICE_IVSHMEM_PLAIN },
1285 { "ivshmem-doorbell", QEMU_CAPS_DEVICE_IVSHMEM_DOORBELL },
1286 { "vhost-scsi", QEMU_CAPS_DEVICE_VHOST_SCSI },
1287 { "nvdimm", QEMU_CAPS_DEVICE_NVDIMM },
1288 { "pcie-root-port", QEMU_CAPS_DEVICE_PCIE_ROOT_PORT },
1289 { "qemu-xhci", QEMU_CAPS_DEVICE_QEMU_XHCI },
1290 { "spapr-pci-host-bridge", QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE },
1291 { "vmcoreinfo", QEMU_CAPS_DEVICE_VMCOREINFO },
1292 { "spapr-vty", QEMU_CAPS_DEVICE_SPAPR_VTY },
1293 { "sclplmconsole", QEMU_CAPS_DEVICE_SCLPLMCONSOLE },
1294 { "isa-serial", QEMU_CAPS_DEVICE_ISA_SERIAL },
1295 { "pl011", QEMU_CAPS_DEVICE_PL011 },
1296 { "virtio-gpu-ccw", QEMU_CAPS_DEVICE_VIRTIO_GPU_CCW },
1297 { "virtio-keyboard-ccw", QEMU_CAPS_DEVICE_VIRTIO_KEYBOARD_CCW },
1298 { "virtio-mouse-ccw", QEMU_CAPS_DEVICE_VIRTIO_MOUSE_CCW },
1299 { "virtio-tablet-ccw", QEMU_CAPS_DEVICE_VIRTIO_TABLET_CCW },
1300 { "pcie-pci-bridge", QEMU_CAPS_DEVICE_PCIE_PCI_BRIDGE },
1301 { "pr-manager-helper", QEMU_CAPS_PR_MANAGER_HELPER },
1302 { "virtual-css-bridge", QEMU_CAPS_CCW },
1303 { "vfio-ccw", QEMU_CAPS_DEVICE_VFIO_CCW },
1304 { "hda-output", QEMU_CAPS_HDA_OUTPUT },
1305 { "vmgenid", QEMU_CAPS_DEVICE_VMGENID },
1306 { "vhost-vsock-device", QEMU_CAPS_DEVICE_VHOST_VSOCK },
1307 { "mch", QEMU_CAPS_DEVICE_MCH },
1308 { "sev-guest", QEMU_CAPS_SEV_GUEST },
1309 { "vfio-ap", QEMU_CAPS_DEVICE_VFIO_AP },
1310 { "zpci", QEMU_CAPS_DEVICE_ZPCI },
1311 { "memory-backend-memfd", QEMU_CAPS_OBJECT_MEMORY_MEMFD },
1312 { "virtio-blk-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1313 { "virtio-blk-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1314 { "virtio-net-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1315 { "virtio-net-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1316 { "vhost-scsi-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1317 { "vhost-scsi-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1318 { "virtio-rng-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1319 { "virtio-rng-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1320 { "virtio-9p-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1321 { "virtio-9p-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1322 { "virtio-balloon-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1323 { "virtio-balloon-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1324 { "vhost-vsock-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1325 { "vhost-vsock-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1326 { "virtio-input-host-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1327 { "virtio-input-host-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1328 { "virtio-scsi-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1329 { "virtio-scsi-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1330 { "virtio-serial-pci-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1331 { "virtio-serial-pci-non-transitional", QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL },
1332 { "max-x86_64-cpu", QEMU_CAPS_X86_MAX_CPU },
1333 { "bochs-display", QEMU_CAPS_DEVICE_BOCHS_DISPLAY },
1334 { "dbus-vmstate", QEMU_CAPS_DBUS_VMSTATE },
1335 { "vhost-user-gpu", QEMU_CAPS_DEVICE_VHOST_USER_GPU },
1336 { "vhost-user-vga", QEMU_CAPS_DEVICE_VHOST_USER_VGA },
1337 { "ramfb", QEMU_CAPS_DEVICE_RAMFB },
1338 { "max-arm-cpu", QEMU_CAPS_ARM_MAX_CPU },
1339 { "i8042", QEMU_CAPS_DEVICE_I8042 },
1340 { "rng-builtin", QEMU_CAPS_OBJECT_RNG_BUILTIN },
1341 { "tpm-spapr", QEMU_CAPS_DEVICE_TPM_SPAPR },
1342 { "vhost-user-fs-device", QEMU_CAPS_DEVICE_VHOST_USER_FS },
1343 { "tcg-accel", QEMU_CAPS_TCG },
1344 { "pvscsi", QEMU_CAPS_SCSI_PVSCSI },
1345 { "spapr-tpm-proxy", QEMU_CAPS_DEVICE_SPAPR_TPM_PROXY },
1346 { "vmport", QEMU_CAPS_MACHINE_VMPORT_OPT },
1347 /*
1348 * We don't probe 'esp' directly, because it is often reported
1349 * as present for all QEMU binaries, due to it being enabled
1350 * for built as a dependency of dc390/am53c974 PCI SCSI
1351 * controllers.
1352 *
1353 * The base 'esp' device is only used as a built-in device
1354 * and is not user-creatable. So we turn this cap on later
1355 * based on arch.
1356 *
1357 * { "esp", QEMU_CAPS_SCSI_NCR53C90 },
1358 */
1359 { "dc390", QEMU_CAPS_SCSI_DC390 },
1360 { "am53c974", QEMU_CAPS_SCSI_AM53C974 },
1361 { "virtio-pmem-pci", QEMU_CAPS_DEVICE_VIRTIO_PMEM_PCI },
1362 { "vhost-user-blk", QEMU_CAPS_DEVICE_VHOST_USER_BLK },
1363 { "input-linux", QEMU_CAPS_INPUT_LINUX },
1364 { "virtio-gpu-gl-pci", QEMU_CAPS_VIRTIO_GPU_GL_PCI },
1365 { "virtio-vga-gl", QEMU_CAPS_VIRTIO_VGA_GL },
1366 { "s390-pv-guest", QEMU_CAPS_S390_PV_GUEST },
1367 { "virtio-mem-pci", QEMU_CAPS_DEVICE_VIRTIO_MEM_PCI },
1368 };
1369
1370
1371 struct virQEMUCapsDevicePropsFlags {
1372 const char *value;
1373 int flag;
1374 int (*cb)(virJSONValue *props, virQEMUCaps *caps);
1375 };
1376
1377
1378 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsVirtioBalloon[] = {
1379 { "deflate-on-oom", QEMU_CAPS_VIRTIO_BALLOON_AUTODEFLATE, NULL },
1380 { "disable-legacy", QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY, NULL },
1381 { "packed", QEMU_CAPS_VIRTIO_PACKED_QUEUES, NULL },
1382 { "free-page-reporting", QEMU_CAPS_VIRTIO_BALLOON_FREE_PAGE_REPORTING, NULL },
1383 { "acpi-index", QEMU_CAPS_ACPI_INDEX, NULL },
1384 };
1385
1386
1387 static int
virQEMUCapsDevicePropsVirtioBlkSCSIDefault(virJSONValue * props,virQEMUCaps * qemuCaps)1388 virQEMUCapsDevicePropsVirtioBlkSCSIDefault(virJSONValue *props,
1389 virQEMUCaps *qemuCaps)
1390 {
1391 bool def = false;
1392
1393 if (virJSONValueObjectGetBoolean(props, "default-value", &def) < 0)
1394 return 0;
1395
1396 if (def == false)
1397 virQEMUCapsSet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_SCSI_DEFAULT_DISABLED);
1398
1399 return 0;
1400 }
1401
1402
1403 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsVirtioBlk[] = {
1404 { "scsi", QEMU_CAPS_VIRTIO_BLK_SCSI, virQEMUCapsDevicePropsVirtioBlkSCSIDefault },
1405 { "logical_block_size", QEMU_CAPS_BLOCKIO, NULL },
1406 { "num-queues", QEMU_CAPS_VIRTIO_BLK_NUM_QUEUES, NULL },
1407 { "queue-size", QEMU_CAPS_VIRTIO_BLK_QUEUE_SIZE, NULL },
1408 { "share-rw", QEMU_CAPS_DISK_SHARE_RW, NULL },
1409 { "disable-legacy", QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY, NULL },
1410 { "write-cache", QEMU_CAPS_DISK_WRITE_CACHE, NULL },
1411 { "werror", QEMU_CAPS_STORAGE_WERROR, NULL },
1412 { "packed", QEMU_CAPS_VIRTIO_PACKED_QUEUES, NULL },
1413 { "acpi-index", QEMU_CAPS_ACPI_INDEX, NULL },
1414 };
1415
1416 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsVirtioNet[] = {
1417 { "tx", QEMU_CAPS_VIRTIO_TX_ALG, NULL },
1418 { "rx_queue_size", QEMU_CAPS_VIRTIO_NET_RX_QUEUE_SIZE, NULL },
1419 { "tx_queue_size", QEMU_CAPS_VIRTIO_NET_TX_QUEUE_SIZE, NULL },
1420 { "host_mtu", QEMU_CAPS_VIRTIO_NET_HOST_MTU, NULL },
1421 { "disable-legacy", QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY, NULL },
1422 { "failover", QEMU_CAPS_VIRTIO_NET_FAILOVER, NULL },
1423 { "packed", QEMU_CAPS_VIRTIO_PACKED_QUEUES, NULL },
1424 { "acpi-index", QEMU_CAPS_ACPI_INDEX, NULL },
1425 };
1426
1427 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsPCIeRootPort[] = {
1428 { "hotplug", QEMU_CAPS_PCIE_ROOT_PORT_HOTPLUG, NULL },
1429 };
1430
1431 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsUSBHost[] = {
1432 { "hostdevice", QEMU_CAPS_USB_HOST_HOSTDEVICE, NULL },
1433 };
1434
1435 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsSpaprPCIHostBridge[] = {
1436 { "numa_node", QEMU_CAPS_SPAPR_PCI_HOST_BRIDGE_NUMA_NODE, NULL },
1437 };
1438
1439 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsVirtioSCSI[] = {
1440 { "iothread", QEMU_CAPS_VIRTIO_SCSI_IOTHREAD, NULL },
1441 { "disable-legacy", QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY, NULL },
1442 { "packed", QEMU_CAPS_VIRTIO_PACKED_QUEUES, NULL },
1443 { "acpi-index", QEMU_CAPS_ACPI_INDEX, NULL },
1444 };
1445
1446 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsVfioPCI[] = {
1447 { "display", QEMU_CAPS_VFIO_PCI_DISPLAY, NULL },
1448 };
1449
1450 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsSCSIDisk[] = {
1451 { "channel", QEMU_CAPS_SCSI_DISK_CHANNEL, NULL },
1452 { "wwn", QEMU_CAPS_SCSI_DISK_WWN, NULL },
1453 { "share-rw", QEMU_CAPS_DISK_SHARE_RW, NULL },
1454 { "write-cache", QEMU_CAPS_DISK_WRITE_CACHE, NULL },
1455 { "device_id", QEMU_CAPS_SCSI_DISK_DEVICE_ID, NULL },
1456 { "werror", QEMU_CAPS_STORAGE_WERROR, NULL },
1457 { "rotation_rate", QEMU_CAPS_ROTATION_RATE, NULL },
1458 };
1459
1460 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsIDEDrive[] = {
1461 { "wwn", QEMU_CAPS_IDE_DRIVE_WWN, NULL },
1462 { "share-rw", QEMU_CAPS_DISK_SHARE_RW, NULL },
1463 { "write-cache", QEMU_CAPS_DISK_WRITE_CACHE, NULL },
1464 };
1465
1466 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsPiix4PM[] = {
1467 { "disable_s3", QEMU_CAPS_PIIX_DISABLE_S3, NULL },
1468 { "disable_s4", QEMU_CAPS_PIIX_DISABLE_S4, NULL },
1469 { "acpi-root-pci-hotplug", QEMU_CAPS_PIIX4_ACPI_ROOT_PCI_HOTPLUG, NULL },
1470 };
1471
1472 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsUSBRedir[] = {
1473 { "filter", QEMU_CAPS_USB_REDIR_FILTER, NULL },
1474 };
1475
1476 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsI440FXPCIHost[] = {
1477 { "pci-hole64-size", QEMU_CAPS_I440FX_PCI_HOLE64_SIZE, NULL },
1478 };
1479
1480 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsQ35PCIHost[] = {
1481 { "pci-hole64-size", QEMU_CAPS_Q35_PCI_HOLE64_SIZE, NULL },
1482 };
1483
1484 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsUSBStorage[] = {
1485 { "removable", QEMU_CAPS_USB_STORAGE_REMOVABLE, NULL },
1486 { "share-rw", QEMU_CAPS_DISK_SHARE_RW, NULL },
1487 { "write-cache", QEMU_CAPS_DISK_WRITE_CACHE, NULL },
1488 { "werror", QEMU_CAPS_USB_STORAGE_WERROR, NULL },
1489 };
1490
1491 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsKVMPit[] = {
1492 { "lost_tick_policy", QEMU_CAPS_KVM_PIT_TICK_POLICY, NULL },
1493 };
1494
1495 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsVGA[] = {
1496 { "vgamem_mb", QEMU_CAPS_VGA_VGAMEM, NULL },
1497 };
1498
1499 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsVmwareSvga[] = {
1500 { "vgamem_mb", QEMU_CAPS_VMWARE_SVGA_VGAMEM, NULL },
1501 };
1502
1503 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsQxl[] = {
1504 { "vgamem_mb", QEMU_CAPS_QXL_VGAMEM, NULL },
1505 { "vram64_size_mb", QEMU_CAPS_QXL_VRAM64, NULL },
1506 { "max_outputs", QEMU_CAPS_QXL_MAX_OUTPUTS, NULL },
1507 };
1508
1509 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsVirtioGpu[] = {
1510 { "virgl", QEMU_CAPS_VIRTIO_GPU_VIRGL, NULL },
1511 { "max_outputs", QEMU_CAPS_VIRTIO_GPU_MAX_OUTPUTS, NULL },
1512 { "disable-legacy", QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY, NULL },
1513 { "packed", QEMU_CAPS_VIRTIO_PACKED_QUEUES, NULL },
1514 { "acpi-index", QEMU_CAPS_ACPI_INDEX, NULL },
1515 };
1516
1517 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsICH9[] = {
1518 { "disable_s3", QEMU_CAPS_ICH9_DISABLE_S3, NULL },
1519 { "disable_s4", QEMU_CAPS_ICH9_DISABLE_S4, NULL },
1520 };
1521
1522 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsUSBNECXHCI[] = {
1523 { "p3", QEMU_CAPS_NEC_USB_XHCI_PORTS, NULL },
1524 };
1525
1526 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsIntelIOMMU[] = {
1527 { "intremap", QEMU_CAPS_INTEL_IOMMU_INTREMAP, NULL },
1528 { "caching-mode", QEMU_CAPS_INTEL_IOMMU_CACHING_MODE, NULL },
1529 { "eim", QEMU_CAPS_INTEL_IOMMU_EIM, NULL },
1530 { "device-iotlb", QEMU_CAPS_INTEL_IOMMU_DEVICE_IOTLB, NULL },
1531 { "aw-bits", QEMU_CAPS_INTEL_IOMMU_AW_BITS, NULL },
1532 };
1533
1534 static struct virQEMUCapsDevicePropsFlags virQEMUCapsObjectPropsVirtualCSSBridge[] = {
1535 { "cssid-unrestricted", QEMU_CAPS_CCW_CSSID_UNRESTRICTED, NULL },
1536 };
1537
1538 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsMCH[] = {
1539 { "extended-tseg-mbytes", QEMU_CAPS_MCH_EXTENDED_TSEG_MBYTES, NULL },
1540 };
1541
1542 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsNVDIMM[] = {
1543 { "unarmed", QEMU_CAPS_DEVICE_NVDIMM_UNARMED, NULL },
1544 };
1545
1546 static struct virQEMUCapsDevicePropsFlags virQEMUCapsDevicePropsVhostUserFS[] = {
1547 { "bootindex", QEMU_CAPS_VHOST_USER_FS_BOOTINDEX, NULL },
1548 };
1549
1550 /* see documentation for virQEMUQAPISchemaPathGet for the query format */
1551 static struct virQEMUCapsStringFlags virQEMUCapsQMPSchemaQueries[] = {
1552 { "block-commit/arg-type/*top", QEMU_CAPS_ACTIVE_COMMIT },
1553 { "blockdev-add/arg-type/options/+gluster/debug-level", QEMU_CAPS_GLUSTER_DEBUG_LEVEL},
1554 { "blockdev-add/arg-type/+gluster/debug", QEMU_CAPS_GLUSTER_DEBUG_LEVEL},
1555 { "blockdev-add/arg-type/+vxhs", QEMU_CAPS_VXHS},
1556 { "blockdev-add/arg-type/+qcow2/encrypt/+luks/key-secret", QEMU_CAPS_QCOW2_LUKS },
1557 { "blockdev-add/arg-type/+file/drop-cache", QEMU_CAPS_MIGRATION_FILE_DROP_CACHE },
1558 { "blockdev-add/arg-type/+file/$dynamic-auto-read-only", QEMU_CAPS_BLOCK_FILE_AUTO_READONLY_DYNAMIC },
1559 { "blockdev-add/arg-type/+nvme", QEMU_CAPS_DRIVE_NVME },
1560 { "blockdev-add/arg-type/+file/aio/^io_uring", QEMU_CAPS_AIO_IO_URING },
1561 { "blockdev-add/arg-type/+rbd/encrypt", QEMU_CAPS_RBD_ENCRYPTION },
1562 { "blockdev-add/arg-type/discard", QEMU_CAPS_DRIVE_DISCARD },
1563 { "blockdev-add/arg-type/detect-zeroes", QEMU_CAPS_DRIVE_DETECT_ZEROES },
1564 { "blockdev-backup", QEMU_CAPS_BLOCKDEV_BACKUP },
1565 { "blockdev-snapshot/$allow-write-only-overlay", QEMU_CAPS_BLOCKDEV_SNAPSHOT_ALLOW_WRITE_ONLY },
1566 { "chardev-add/arg-type/backend/+socket/data/reconnect", QEMU_CAPS_CHARDEV_RECONNECT },
1567 { "chardev-add/arg-type/backend/+file/data/logfile", QEMU_CAPS_CHARDEV_LOGFILE },
1568 { "chardev-add/arg-type/backend/+file/data/logappend", QEMU_CAPS_CHARDEV_FILE_APPEND },
1569 { "device_add/$json-cli", QEMU_CAPS_DEVICE_JSON },
1570 { "human-monitor-command/$savevm-monitor-nodes", QEMU_CAPS_SAVEVM_MONITOR_NODES },
1571 { "migrate-set-parameters/arg-type/max-bandwidth", QEMU_CAPS_MIGRATION_PARAM_BANDWIDTH },
1572 { "migrate-set-parameters/arg-type/downtime-limit", QEMU_CAPS_MIGRATION_PARAM_DOWNTIME },
1573 { "migrate-set-parameters/arg-type/xbzrle-cache-size", QEMU_CAPS_MIGRATION_PARAM_XBZRLE_CACHE_SIZE },
1574 { "migrate-set-parameters/arg-type/block-bitmap-mapping/bitmaps/transform", QEMU_CAPS_MIGRATION_PARAM_BLOCK_BITMAP_MAPPING },
1575 { "nbd-server-start/arg-type/tls-creds", QEMU_CAPS_NBD_TLS },
1576 { "nbd-server-add/arg-type/bitmap", QEMU_CAPS_NBD_BITMAP },
1577 { "netdev_add/arg-type/+vhost-vdpa", QEMU_CAPS_NETDEV_VHOST_VDPA },
1578 { "object-add/arg-type/qom-type/^secret", QEMU_CAPS_OBJECT_JSON },
1579 { "query-display-options/ret-type/+egl-headless/rendernode", QEMU_CAPS_EGL_HEADLESS_RENDERNODE },
1580 { "query-display-options/ret-type/+sdl", QEMU_CAPS_SDL },
1581 { "query-display-options/ret-type/+egl-headless", QEMU_CAPS_EGL_HEADLESS },
1582 { "query-iothreads/ret-type/poll-max-ns", QEMU_CAPS_IOTHREAD_POLLING },
1583 { "query-hotpluggable-cpus/ret-type/props/die-id", QEMU_CAPS_SMP_DIES },
1584 { "query-named-block-nodes/arg-type/flat", QEMU_CAPS_QMP_QUERY_NAMED_BLOCK_NODES_FLAT },
1585 { "screendump/arg-type/device", QEMU_CAPS_SCREENDUMP_DEVICE },
1586 { "set-numa-node/arg-type/+hmat-lb", QEMU_CAPS_NUMA_HMAT },
1587 };
1588
1589 typedef struct _virQEMUCapsObjectTypeProps virQEMUCapsObjectTypeProps;
1590 struct _virQEMUCapsObjectTypeProps {
1591 const char *type;
1592 struct virQEMUCapsStringFlags *props;
1593 size_t nprops;
1594 int capsCondition;
1595 };
1596
1597
1598 typedef struct _virQEMUCapsDeviceTypeProps virQEMUCapsDeviceTypeProps;
1599 struct _virQEMUCapsDeviceTypeProps {
1600 const char *type;
1601 struct virQEMUCapsDevicePropsFlags *props;
1602 size_t nprops;
1603 int capsCondition;
1604 };
1605
1606
1607 static virQEMUCapsDeviceTypeProps virQEMUCapsDeviceProps[] = {
1608 { "virtio-blk-pci", virQEMUCapsDevicePropsVirtioBlk,
1609 G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioBlk),
1610 -1 },
1611 { "virtio-net-pci", virQEMUCapsDevicePropsVirtioNet,
1612 G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioNet),
1613 QEMU_CAPS_DEVICE_VIRTIO_NET },
1614 { "virtio-scsi-pci", virQEMUCapsDevicePropsVirtioSCSI,
1615 G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioSCSI),
1616 QEMU_CAPS_VIRTIO_SCSI },
1617 { "virtio-blk-ccw", virQEMUCapsDevicePropsVirtioBlk,
1618 G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioBlk),
1619 QEMU_CAPS_VIRTIO_CCW },
1620 { "virtio-net-ccw", virQEMUCapsDevicePropsVirtioNet,
1621 G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioNet),
1622 QEMU_CAPS_DEVICE_VIRTIO_NET },
1623 { "virtio-scsi-ccw", virQEMUCapsDevicePropsVirtioSCSI,
1624 G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioSCSI),
1625 QEMU_CAPS_VIRTIO_SCSI },
1626 { "vfio-pci", virQEMUCapsDevicePropsVfioPCI,
1627 G_N_ELEMENTS(virQEMUCapsDevicePropsVfioPCI),
1628 QEMU_CAPS_DEVICE_VFIO_PCI },
1629 { "scsi-hd", virQEMUCapsDevicePropsSCSIDisk,
1630 G_N_ELEMENTS(virQEMUCapsDevicePropsSCSIDisk),
1631 -1 },
1632 { "ide-hd", virQEMUCapsDevicePropsIDEDrive,
1633 G_N_ELEMENTS(virQEMUCapsDevicePropsIDEDrive),
1634 -1 },
1635 { "PIIX4_PM", virQEMUCapsDevicePropsPiix4PM,
1636 G_N_ELEMENTS(virQEMUCapsDevicePropsPiix4PM),
1637 -1 },
1638 { "usb-redir", virQEMUCapsDevicePropsUSBRedir,
1639 G_N_ELEMENTS(virQEMUCapsDevicePropsUSBRedir),
1640 QEMU_CAPS_USB_REDIR },
1641 { "i440FX-pcihost", virQEMUCapsDevicePropsI440FXPCIHost,
1642 G_N_ELEMENTS(virQEMUCapsDevicePropsI440FXPCIHost),
1643 -1 },
1644 { "q35-pcihost", virQEMUCapsDevicePropsQ35PCIHost,
1645 G_N_ELEMENTS(virQEMUCapsDevicePropsQ35PCIHost),
1646 -1 },
1647 { "usb-storage", virQEMUCapsDevicePropsUSBStorage,
1648 G_N_ELEMENTS(virQEMUCapsDevicePropsUSBStorage),
1649 QEMU_CAPS_DEVICE_USB_STORAGE },
1650 { "kvm-pit", virQEMUCapsDevicePropsKVMPit,
1651 G_N_ELEMENTS(virQEMUCapsDevicePropsKVMPit),
1652 -1 },
1653 { "VGA", virQEMUCapsDevicePropsVGA,
1654 G_N_ELEMENTS(virQEMUCapsDevicePropsVGA),
1655 QEMU_CAPS_DEVICE_VGA },
1656 { "vmware-svga", virQEMUCapsDevicePropsVmwareSvga,
1657 G_N_ELEMENTS(virQEMUCapsDevicePropsVmwareSvga),
1658 QEMU_CAPS_DEVICE_VMWARE_SVGA },
1659 { "qxl", virQEMUCapsDevicePropsQxl,
1660 G_N_ELEMENTS(virQEMUCapsDevicePropsQxl),
1661 QEMU_CAPS_DEVICE_QXL },
1662 { "virtio-gpu-pci", virQEMUCapsDevicePropsVirtioGpu,
1663 G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioGpu),
1664 QEMU_CAPS_DEVICE_VIRTIO_GPU },
1665 { "virtio-gpu-device", virQEMUCapsDevicePropsVirtioGpu,
1666 G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioGpu),
1667 QEMU_CAPS_DEVICE_VIRTIO_GPU },
1668 { "ICH9-LPC", virQEMUCapsDevicePropsICH9,
1669 G_N_ELEMENTS(virQEMUCapsDevicePropsICH9),
1670 -1 },
1671 { "virtio-balloon-pci", virQEMUCapsDevicePropsVirtioBalloon,
1672 G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioBalloon),
1673 -1 },
1674 { "virtio-balloon-ccw", virQEMUCapsDevicePropsVirtioBalloon,
1675 G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioBalloon),
1676 -1 },
1677 { "virtio-balloon-device", virQEMUCapsDevicePropsVirtioBalloon,
1678 G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioBalloon),
1679 -1 },
1680 { "nec-usb-xhci", virQEMUCapsDevicePropsUSBNECXHCI,
1681 G_N_ELEMENTS(virQEMUCapsDevicePropsUSBNECXHCI),
1682 QEMU_CAPS_NEC_USB_XHCI },
1683 { "intel-iommu", virQEMUCapsDevicePropsIntelIOMMU,
1684 G_N_ELEMENTS(virQEMUCapsDevicePropsIntelIOMMU),
1685 QEMU_CAPS_DEVICE_INTEL_IOMMU },
1686 { "spapr-pci-host-bridge", virQEMUCapsDevicePropsSpaprPCIHostBridge,
1687 G_N_ELEMENTS(virQEMUCapsDevicePropsSpaprPCIHostBridge),
1688 QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE },
1689 { "virtio-gpu-ccw", virQEMUCapsDevicePropsVirtioGpu,
1690 G_N_ELEMENTS(virQEMUCapsDevicePropsVirtioGpu),
1691 QEMU_CAPS_DEVICE_VIRTIO_GPU_CCW },
1692 { "virtual-css-bridge", virQEMUCapsObjectPropsVirtualCSSBridge,
1693 G_N_ELEMENTS(virQEMUCapsObjectPropsVirtualCSSBridge),
1694 QEMU_CAPS_CCW },
1695 { "mch", virQEMUCapsDevicePropsMCH,
1696 G_N_ELEMENTS(virQEMUCapsDevicePropsMCH),
1697 QEMU_CAPS_DEVICE_MCH },
1698 { "nvdimm", virQEMUCapsDevicePropsNVDIMM,
1699 G_N_ELEMENTS(virQEMUCapsDevicePropsNVDIMM),
1700 QEMU_CAPS_DEVICE_NVDIMM },
1701 { "pcie-root-port", virQEMUCapsDevicePropsPCIeRootPort,
1702 G_N_ELEMENTS(virQEMUCapsDevicePropsPCIeRootPort),
1703 QEMU_CAPS_DEVICE_PCIE_ROOT_PORT },
1704 { "usb-host", virQEMUCapsDevicePropsUSBHost,
1705 G_N_ELEMENTS(virQEMUCapsDevicePropsUSBHost),
1706 -1 },
1707 { "vhost-user-fs-device", virQEMUCapsDevicePropsVhostUserFS,
1708 G_N_ELEMENTS(virQEMUCapsDevicePropsVhostUserFS),
1709 QEMU_CAPS_DEVICE_VHOST_USER_FS },
1710 };
1711
1712 static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsMemoryBackendFile[] = {
1713 { "discard-data", QEMU_CAPS_OBJECT_MEMORY_FILE_DISCARD },
1714 { "align", QEMU_CAPS_OBJECT_MEMORY_FILE_ALIGN },
1715 { "pmem", QEMU_CAPS_OBJECT_MEMORY_FILE_PMEM },
1716 /* As of QEMU commit 8db0b20415c129cf5e577a593a4a0372d90b7cc9 the
1717 * "x-use-canonical-path-for-ramblock-id" property is considered stable and
1718 * supported. The 'x-' prefix was kept for compatibility with already
1719 * released qemu versions. */
1720 { "x-use-canonical-path-for-ramblock-id", QEMU_CAPS_X_USE_CANONICAL_PATH_FOR_RAMBLOCK_ID },
1721 { "reserve", QEMU_CAPS_MEMORY_BACKEND_RESERVE },
1722 };
1723
1724 static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsMemoryBackendMemfd[] = {
1725 { "hugetlb", QEMU_CAPS_OBJECT_MEMORY_MEMFD_HUGETLB },
1726 };
1727
1728 static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsMaxCPU[] = {
1729 { "unavailable-features", QEMU_CAPS_CPU_UNAVAILABLE_FEATURES },
1730 { "kvm-no-adjvtime", QEMU_CAPS_CPU_KVM_NO_ADJVTIME },
1731 { "migratable", QEMU_CAPS_CPU_MIGRATABLE },
1732 };
1733
1734 static virQEMUCapsObjectTypeProps virQEMUCapsObjectProps[] = {
1735 { "memory-backend-file", virQEMUCapsObjectPropsMemoryBackendFile,
1736 G_N_ELEMENTS(virQEMUCapsObjectPropsMemoryBackendFile),
1737 QEMU_CAPS_OBJECT_MEMORY_FILE },
1738 { "memory-backend-memfd", virQEMUCapsObjectPropsMemoryBackendMemfd,
1739 G_N_ELEMENTS(virQEMUCapsObjectPropsMemoryBackendMemfd),
1740 QEMU_CAPS_OBJECT_MEMORY_MEMFD },
1741 { "max-x86_64-cpu", virQEMUCapsObjectPropsMaxCPU,
1742 G_N_ELEMENTS(virQEMUCapsObjectPropsMaxCPU),
1743 QEMU_CAPS_X86_MAX_CPU },
1744 { "max-arm-cpu", virQEMUCapsObjectPropsMaxCPU,
1745 G_N_ELEMENTS(virQEMUCapsObjectPropsMaxCPU),
1746 QEMU_CAPS_ARM_MAX_CPU },
1747 };
1748
1749 static struct virQEMUCapsStringFlags virQEMUCapsMachinePropsPSeries[] = {
1750 { "cap-hpt-max-page-size", QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE },
1751 { "cap-htm", QEMU_CAPS_MACHINE_PSERIES_CAP_HTM },
1752 { "cap-nested-hv", QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV },
1753 { "cap-ccf-assist", QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST },
1754 { "cap-cfpc", QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC },
1755 { "cap-sbbc", QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC },
1756 { "cap-ibs", QEMU_CAPS_MACHINE_PSERIES_CAP_IBS },
1757 };
1758
1759 static struct virQEMUCapsStringFlags virQEMUCapsMachinePropsVirt[] = {
1760 { "iommu", QEMU_CAPS_MACHINE_VIRT_IOMMU },
1761 };
1762
1763 static struct virQEMUCapsStringFlags virQEMUCapsMachinePropsGeneric[] = {
1764 { "confidential-guest-support", QEMU_CAPS_MACHINE_CONFIDENTAL_GUEST_SUPPORT },
1765 };
1766
1767 static virQEMUCapsObjectTypeProps virQEMUCapsMachineProps[] = {
1768 { "pseries", virQEMUCapsMachinePropsPSeries,
1769 G_N_ELEMENTS(virQEMUCapsMachinePropsPSeries),
1770 -1 },
1771 { "virt", virQEMUCapsMachinePropsVirt,
1772 G_N_ELEMENTS(virQEMUCapsMachinePropsVirt),
1773 -1 },
1774 { "none", virQEMUCapsMachinePropsGeneric,
1775 G_N_ELEMENTS(virQEMUCapsMachinePropsGeneric),
1776 -1 },
1777 };
1778
1779 static void
virQEMUCapsProcessStringFlags(virQEMUCaps * qemuCaps,size_t nflags,struct virQEMUCapsStringFlags * flags,char ** values)1780 virQEMUCapsProcessStringFlags(virQEMUCaps *qemuCaps,
1781 size_t nflags,
1782 struct virQEMUCapsStringFlags *flags,
1783 char **values)
1784 {
1785 size_t i;
1786 char **value;
1787
1788 for (i = 0; i < nflags; i++) {
1789 if (virQEMUCapsGet(qemuCaps, flags[i].flag))
1790 continue;
1791
1792 for (value = values; *value; value++) {
1793 if (STREQ(*value, flags[i].value)) {
1794 virQEMUCapsSet(qemuCaps, flags[i].flag);
1795 break;
1796 }
1797 }
1798 }
1799 }
1800
1801
virQEMUCapsGetDefaultVersion(virCaps * caps,virFileCache * capsCache,unsigned int * version)1802 int virQEMUCapsGetDefaultVersion(virCaps *caps,
1803 virFileCache *capsCache,
1804 unsigned int *version)
1805 {
1806 virQEMUCaps *qemucaps;
1807 virArch hostarch;
1808 virCapsDomainData *capsdata;
1809
1810 if (*version > 0)
1811 return 0;
1812
1813 hostarch = virArchFromHost();
1814 if (!(capsdata = virCapabilitiesDomainDataLookup(caps,
1815 VIR_DOMAIN_OSTYPE_HVM, hostarch, VIR_DOMAIN_VIRT_QEMU,
1816 NULL, NULL))) {
1817 virReportError(VIR_ERR_INTERNAL_ERROR,
1818 _("Cannot find suitable emulator for %s"),
1819 virArchToString(hostarch));
1820 return -1;
1821 }
1822
1823 qemucaps = virQEMUCapsCacheLookup(capsCache, capsdata->emulator);
1824 VIR_FREE(capsdata);
1825 if (!qemucaps)
1826 return -1;
1827
1828 *version = virQEMUCapsGetVersion(qemucaps);
1829 virObjectUnref(qemucaps);
1830 return 0;
1831 }
1832
1833
1834 virQEMUCaps *
virQEMUCapsNew(void)1835 virQEMUCapsNew(void)
1836 {
1837 virQEMUCaps *qemuCaps;
1838
1839 if (virQEMUCapsInitialize() < 0)
1840 return NULL;
1841
1842 if (!(qemuCaps = virObjectNew(virQEMUCapsClass)))
1843 return NULL;
1844
1845 qemuCaps->invalidation = true;
1846 qemuCaps->flags = virBitmapNew(QEMU_CAPS_LAST);
1847
1848 return qemuCaps;
1849 }
1850
1851
1852 virQEMUCaps *
virQEMUCapsNewBinary(const char * binary)1853 virQEMUCapsNewBinary(const char *binary)
1854 {
1855 virQEMUCaps *qemuCaps = virQEMUCapsNew();
1856
1857 if (qemuCaps)
1858 qemuCaps->binary = g_strdup(binary);
1859
1860 return qemuCaps;
1861 }
1862
1863
1864 static int
virQEMUCapsHostCPUDataCopy(virQEMUCapsHostCPUData * dst,virQEMUCapsHostCPUData * src)1865 virQEMUCapsHostCPUDataCopy(virQEMUCapsHostCPUData *dst,
1866 virQEMUCapsHostCPUData *src)
1867 {
1868 if (src->info &&
1869 !(dst->info = qemuMonitorCPUModelInfoCopy(src->info)))
1870 return -1;
1871
1872 if (src->reported &&
1873 !(dst->reported = virCPUDefCopy(src->reported)))
1874 return -1;
1875
1876 if (src->migratable &&
1877 !(dst->migratable = virCPUDefCopy(src->migratable)))
1878 return -1;
1879
1880 if (src->full &&
1881 !(dst->full = virCPUDefCopy(src->full)))
1882 return -1;
1883
1884 return 0;
1885 }
1886
1887
1888 static void
virQEMUCapsHostCPUDataClear(virQEMUCapsHostCPUData * cpuData)1889 virQEMUCapsHostCPUDataClear(virQEMUCapsHostCPUData *cpuData)
1890 {
1891 qemuMonitorCPUModelInfoFree(cpuData->info);
1892 virCPUDefFree(cpuData->reported);
1893 virCPUDefFree(cpuData->migratable);
1894 virCPUDefFree(cpuData->full);
1895
1896 memset(cpuData, 0, sizeof(*cpuData));
1897 }
1898
1899
1900 static int
virQEMUCapsSEVInfoCopy(virSEVCapability ** dst,virSEVCapability * src)1901 virQEMUCapsSEVInfoCopy(virSEVCapability **dst,
1902 virSEVCapability *src)
1903 {
1904 g_autoptr(virSEVCapability) tmp = NULL;
1905
1906 tmp = g_new0(virSEVCapability, 1);
1907
1908 tmp->pdh = g_strdup(src->pdh);
1909 tmp->cert_chain = g_strdup(src->cert_chain);
1910
1911 tmp->cbitpos = src->cbitpos;
1912 tmp->reduced_phys_bits = src->reduced_phys_bits;
1913
1914 *dst = g_steal_pointer(&tmp);
1915 return 0;
1916 }
1917
1918
1919 static void
virQEMUCapsAccelCopyMachineTypes(virQEMUCapsAccel * dst,virQEMUCapsAccel * src)1920 virQEMUCapsAccelCopyMachineTypes(virQEMUCapsAccel *dst,
1921 virQEMUCapsAccel *src)
1922 {
1923 size_t i;
1924
1925 dst->machineTypes = g_new0(virQEMUCapsMachineType, src->nmachineTypes);
1926
1927 dst->nmachineTypes = src->nmachineTypes;
1928 for (i = 0; i < src->nmachineTypes; i++) {
1929 dst->machineTypes[i].name = g_strdup(src->machineTypes[i].name);
1930 dst->machineTypes[i].alias = g_strdup(src->machineTypes[i].alias);
1931 dst->machineTypes[i].defaultCPU = g_strdup(src->machineTypes[i].defaultCPU);
1932 dst->machineTypes[i].maxCpus = src->machineTypes[i].maxCpus;
1933 dst->machineTypes[i].hotplugCpus = src->machineTypes[i].hotplugCpus;
1934 dst->machineTypes[i].qemuDefault = src->machineTypes[i].qemuDefault;
1935 dst->machineTypes[i].numaMemSupported = src->machineTypes[i].numaMemSupported;
1936 dst->machineTypes[i].defaultRAMid = g_strdup(src->machineTypes[i].defaultRAMid);
1937 dst->machineTypes[i].deprecated = src->machineTypes[i].deprecated;
1938 }
1939 }
1940
1941
1942 static int
virQEMUCapsAccelCopy(virQEMUCapsAccel * dst,virQEMUCapsAccel * src)1943 virQEMUCapsAccelCopy(virQEMUCapsAccel *dst,
1944 virQEMUCapsAccel *src)
1945 {
1946 virQEMUCapsAccelCopyMachineTypes(dst, src);
1947
1948 if (virQEMUCapsHostCPUDataCopy(&dst->hostCPU, &src->hostCPU) < 0)
1949 return -1;
1950
1951 dst->cpuModels = qemuMonitorCPUDefsCopy(src->cpuModels);
1952
1953 return 0;
1954 }
1955
1956
virQEMUCapsNewCopy(virQEMUCaps * qemuCaps)1957 virQEMUCaps *virQEMUCapsNewCopy(virQEMUCaps *qemuCaps)
1958 {
1959 g_autoptr(virQEMUCaps) ret = virQEMUCapsNewBinary(qemuCaps->binary);
1960 size_t i;
1961
1962 if (!ret)
1963 return NULL;
1964
1965 ret->invalidation = qemuCaps->invalidation;
1966 ret->kvmSupportsNesting = qemuCaps->kvmSupportsNesting;
1967 ret->kvmSupportsSecureGuest = qemuCaps->kvmSupportsSecureGuest;
1968
1969 ret->ctime = qemuCaps->ctime;
1970
1971 virBitmapFree(ret->flags);
1972 ret->flags = virBitmapNewCopy(qemuCaps->flags);
1973
1974 ret->version = qemuCaps->version;
1975 ret->kvmVersion = qemuCaps->kvmVersion;
1976 ret->microcodeVersion = qemuCaps->microcodeVersion;
1977 ret->hostCPUSignature = g_strdup(qemuCaps->hostCPUSignature);
1978
1979 ret->package = g_strdup(qemuCaps->package);
1980 ret->kernelVersion = g_strdup(qemuCaps->kernelVersion);
1981
1982 ret->arch = qemuCaps->arch;
1983 ret->cpuData = virCPUDataNewCopy(qemuCaps->cpuData);
1984
1985 if (virQEMUCapsAccelCopy(&ret->kvm, &qemuCaps->kvm) < 0 ||
1986 virQEMUCapsAccelCopy(&ret->nvmm, &qemuCaps->nvmm) < 0 ||
1987 virQEMUCapsAccelCopy(&ret->tcg, &qemuCaps->tcg) < 0)
1988 return NULL;
1989
1990 ret->gicCapabilities = g_new0(virGICCapability, qemuCaps->ngicCapabilities);
1991 ret->ngicCapabilities = qemuCaps->ngicCapabilities;
1992 for (i = 0; i < qemuCaps->ngicCapabilities; i++)
1993 ret->gicCapabilities[i] = qemuCaps->gicCapabilities[i];
1994
1995 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SEV_GUEST) &&
1996 virQEMUCapsSEVInfoCopy(&ret->sevCapabilities,
1997 qemuCaps->sevCapabilities) < 0)
1998 return NULL;
1999
2000 return g_steal_pointer(&ret);
2001 }
2002
2003
2004 static void
virQEMUCapsAccelClear(virQEMUCapsAccel * caps)2005 virQEMUCapsAccelClear(virQEMUCapsAccel *caps)
2006 {
2007 size_t i;
2008
2009 for (i = 0; i < caps->nmachineTypes; i++) {
2010 VIR_FREE(caps->machineTypes[i].name);
2011 VIR_FREE(caps->machineTypes[i].alias);
2012 VIR_FREE(caps->machineTypes[i].defaultCPU);
2013 VIR_FREE(caps->machineTypes[i].defaultRAMid);
2014 }
2015 VIR_FREE(caps->machineTypes);
2016
2017 virQEMUCapsHostCPUDataClear(&caps->hostCPU);
2018 qemuMonitorCPUDefsFree(caps->cpuModels);
2019 }
2020
2021
virQEMUCapsDispose(void * obj)2022 void virQEMUCapsDispose(void *obj)
2023 {
2024 virQEMUCaps *qemuCaps = obj;
2025
2026 virBitmapFree(qemuCaps->flags);
2027
2028 g_free(qemuCaps->package);
2029 g_free(qemuCaps->kernelVersion);
2030 g_free(qemuCaps->binary);
2031 g_free(qemuCaps->hostCPUSignature);
2032
2033 g_free(qemuCaps->gicCapabilities);
2034
2035 virCPUDataFree(qemuCaps->cpuData);
2036
2037 virSEVCapabilitiesFree(qemuCaps->sevCapabilities);
2038
2039 virQEMUCapsAccelClear(&qemuCaps->kvm);
2040 virQEMUCapsAccelClear(&qemuCaps->nvmm);
2041 virQEMUCapsAccelClear(&qemuCaps->tcg);
2042 }
2043
2044 void
virQEMUCapsSet(virQEMUCaps * qemuCaps,virQEMUCapsFlags flag)2045 virQEMUCapsSet(virQEMUCaps *qemuCaps,
2046 virQEMUCapsFlags flag)
2047 {
2048 ignore_value(virBitmapSetBit(qemuCaps->flags, flag));
2049 }
2050
2051
2052 void
virQEMUCapsClear(virQEMUCaps * qemuCaps,virQEMUCapsFlags flag)2053 virQEMUCapsClear(virQEMUCaps *qemuCaps,
2054 virQEMUCapsFlags flag)
2055 {
2056 ignore_value(virBitmapClearBit(qemuCaps->flags, flag));
2057 }
2058
2059
2060 bool
virQEMUCapsGet(virQEMUCaps * qemuCaps,virQEMUCapsFlags flag)2061 virQEMUCapsGet(virQEMUCaps *qemuCaps,
2062 virQEMUCapsFlags flag)
2063 {
2064 return qemuCaps && virBitmapIsBitSet(qemuCaps->flags, flag);
2065 }
2066
2067
virQEMUCapsHasPCIMultiBus(const virDomainDef * def)2068 bool virQEMUCapsHasPCIMultiBus(const virDomainDef *def)
2069 {
2070 /* x86_64 and i686 support PCI-multibus on all machine types
2071 * since forever */
2072 if (ARCH_IS_X86(def->os.arch))
2073 return true;
2074
2075 /* PPC supports multibus on all machine types which have pci since qemu-2.0.0 */
2076 if (def->os.arch == VIR_ARCH_PPC ||
2077 ARCH_IS_PPC64(def->os.arch)) {
2078 return true;
2079 }
2080
2081 /* S390 supports PCI-multibus. */
2082 if (ARCH_IS_S390(def->os.arch))
2083 return true;
2084
2085 /* If the virt machine, both on ARM and RISC-V, supports PCI,
2086 * then it also supports multibus */
2087 if (qemuDomainIsARMVirt(def) ||
2088 qemuDomainIsRISCVVirt(def)) {
2089 return true;
2090 }
2091
2092 return false;
2093 }
2094
2095
virQEMUCapsGetBinary(virQEMUCaps * qemuCaps)2096 const char *virQEMUCapsGetBinary(virQEMUCaps *qemuCaps)
2097 {
2098 return qemuCaps->binary;
2099 }
2100
2101
2102 void
virQEMUCapsSetArch(virQEMUCaps * qemuCaps,virArch arch)2103 virQEMUCapsSetArch(virQEMUCaps *qemuCaps,
2104 virArch arch)
2105 {
2106 qemuCaps->arch = arch;
2107 }
2108
2109
virQEMUCapsGetArch(virQEMUCaps * qemuCaps)2110 virArch virQEMUCapsGetArch(virQEMUCaps *qemuCaps)
2111 {
2112 return qemuCaps->arch;
2113 }
2114
2115
virQEMUCapsGetVersion(virQEMUCaps * qemuCaps)2116 unsigned int virQEMUCapsGetVersion(virQEMUCaps *qemuCaps)
2117 {
2118 return qemuCaps->version;
2119 }
2120
2121
virQEMUCapsGetKVMVersion(virQEMUCaps * qemuCaps)2122 unsigned int virQEMUCapsGetKVMVersion(virQEMUCaps *qemuCaps)
2123 {
2124 return qemuCaps->kvmVersion;
2125 }
2126
2127
virQEMUCapsGetPackage(virQEMUCaps * qemuCaps)2128 const char *virQEMUCapsGetPackage(virQEMUCaps *qemuCaps)
2129 {
2130 return qemuCaps->package;
2131 }
2132
2133
virQEMUCapsGetKVMSupportsSecureGuest(virQEMUCaps * qemuCaps)2134 bool virQEMUCapsGetKVMSupportsSecureGuest(virQEMUCaps *qemuCaps)
2135 {
2136 return qemuCaps->kvmSupportsSecureGuest;
2137 }
2138
2139
2140 int
virQEMUCapsAddCPUDefinitions(virQEMUCaps * qemuCaps,virDomainVirtType type,const char ** name,size_t count,virDomainCapsCPUUsable usable)2141 virQEMUCapsAddCPUDefinitions(virQEMUCaps *qemuCaps,
2142 virDomainVirtType type,
2143 const char **name,
2144 size_t count,
2145 virDomainCapsCPUUsable usable)
2146 {
2147 size_t i;
2148 size_t start;
2149 virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, type);
2150 qemuMonitorCPUDefs *defs = accel->cpuModels;
2151
2152 if (defs) {
2153 start = defs->ncpus;
2154
2155 VIR_EXPAND_N(defs->cpus, defs->ncpus, count);
2156 } else {
2157 start = 0;
2158
2159 if (!(defs = qemuMonitorCPUDefsNew(count)))
2160 return -1;
2161
2162 accel->cpuModels = defs;
2163 }
2164
2165 for (i = 0; i < count; i++) {
2166 qemuMonitorCPUDefInfo *cpu = defs->cpus + start + i;
2167
2168 cpu->usable = usable;
2169 cpu->name = g_strdup(name[i]);
2170 }
2171
2172 return 0;
2173 }
2174
2175
2176 static virDomainCapsCPUModels *
virQEMUCapsCPUDefsToModels(qemuMonitorCPUDefs * defs,const char ** modelAllowed,const char ** modelForbidden)2177 virQEMUCapsCPUDefsToModels(qemuMonitorCPUDefs *defs,
2178 const char **modelAllowed,
2179 const char **modelForbidden)
2180 {
2181 g_autoptr(virDomainCapsCPUModels) cpuModels = NULL;
2182 size_t i;
2183
2184 if (!(cpuModels = virDomainCapsCPUModelsNew(defs->ncpus)))
2185 return NULL;
2186
2187 for (i = 0; i < defs->ncpus; i++) {
2188 qemuMonitorCPUDefInfo *cpu = defs->cpus + i;
2189
2190 if (modelAllowed && !g_strv_contains(modelAllowed, cpu->name))
2191 continue;
2192
2193 if (modelForbidden && g_strv_contains(modelForbidden, cpu->name))
2194 continue;
2195
2196 if (virDomainCapsCPUModelsAdd(cpuModels, cpu->name, cpu->usable,
2197 cpu->blockers, cpu->deprecated) < 0)
2198 return NULL;
2199 }
2200
2201 return g_steal_pointer(&cpuModels);
2202 }
2203
2204
2205 virDomainCapsCPUModels *
virQEMUCapsGetCPUModels(virQEMUCaps * qemuCaps,virDomainVirtType type,const char ** modelAllowed,const char ** modelForbidden)2206 virQEMUCapsGetCPUModels(virQEMUCaps *qemuCaps,
2207 virDomainVirtType type,
2208 const char **modelAllowed,
2209 const char **modelForbidden)
2210 {
2211 qemuMonitorCPUDefs *defs;
2212
2213 if (!(defs = virQEMUCapsGetAccel(qemuCaps, type)->cpuModels))
2214 return NULL;
2215
2216 return virQEMUCapsCPUDefsToModels(defs, modelAllowed, modelForbidden);
2217 }
2218
2219
2220 virCPUDef *
virQEMUCapsGetHostModel(virQEMUCaps * qemuCaps,virDomainVirtType type,virQEMUCapsHostCPUType cpuType)2221 virQEMUCapsGetHostModel(virQEMUCaps *qemuCaps,
2222 virDomainVirtType type,
2223 virQEMUCapsHostCPUType cpuType)
2224 {
2225 virQEMUCapsHostCPUData *cpuData;
2226
2227 cpuData = &virQEMUCapsGetAccel(qemuCaps, type)->hostCPU;
2228 switch (cpuType) {
2229 case VIR_QEMU_CAPS_HOST_CPU_REPORTED:
2230 return cpuData->reported;
2231
2232 case VIR_QEMU_CAPS_HOST_CPU_MIGRATABLE:
2233 return cpuData->migratable;
2234
2235 case VIR_QEMU_CAPS_HOST_CPU_FULL:
2236 /* 'full' is non-NULL only if we have data from both QEMU and
2237 * virCPUGetHost */
2238 return cpuData->full ? cpuData->full : cpuData->reported;
2239 }
2240
2241 return NULL;
2242 }
2243
2244
2245 static void
virQEMUCapsSetHostModel(virQEMUCaps * qemuCaps,virDomainVirtType type,virCPUDef * reported,virCPUDef * migratable,virCPUDef * full)2246 virQEMUCapsSetHostModel(virQEMUCaps *qemuCaps,
2247 virDomainVirtType type,
2248 virCPUDef *reported,
2249 virCPUDef *migratable,
2250 virCPUDef *full)
2251 {
2252 virQEMUCapsHostCPUData *cpuData;
2253
2254 cpuData = &virQEMUCapsGetAccel(qemuCaps, type)->hostCPU;
2255 cpuData->reported = reported;
2256 cpuData->migratable = migratable;
2257 cpuData->full = full;
2258 }
2259
2260
2261 bool
virQEMUCapsIsArchSupported(virQEMUCaps * qemuCaps,virArch arch)2262 virQEMUCapsIsArchSupported(virQEMUCaps *qemuCaps,
2263 virArch arch)
2264 {
2265 if (arch == qemuCaps->arch)
2266 return true;
2267
2268 if (qemuCaps->arch == VIR_ARCH_X86_64 && arch == VIR_ARCH_I686)
2269 return true;
2270
2271 if (qemuCaps->arch == VIR_ARCH_AARCH64 && arch == VIR_ARCH_ARMV7L)
2272 return true;
2273
2274 if (qemuCaps->arch == VIR_ARCH_ARMV7L && arch == VIR_ARCH_ARMV6L)
2275 return true;
2276
2277 if (qemuCaps->arch == VIR_ARCH_PPC64 && arch == VIR_ARCH_PPC64LE)
2278 return true;
2279
2280 return false;
2281 }
2282
2283
2284 bool
virQEMUCapsIsVirtTypeSupported(virQEMUCaps * qemuCaps,virDomainVirtType virtType)2285 virQEMUCapsIsVirtTypeSupported(virQEMUCaps *qemuCaps,
2286 virDomainVirtType virtType)
2287 {
2288 if (virtType == VIR_DOMAIN_VIRT_QEMU &&
2289 virQEMUCapsGet(qemuCaps, QEMU_CAPS_TCG))
2290 return true;
2291
2292 if (virtType == VIR_DOMAIN_VIRT_NVMM &&
2293 virQEMUCapsGet(qemuCaps, QEMU_CAPS_NVMM))
2294 return true;
2295
2296 if (virtType == VIR_DOMAIN_VIRT_KVM &&
2297 virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
2298 return true;
2299
2300 return false;
2301 }
2302
2303 const char *s390HostPassthroughOnlyMachines[] = {
2304 "s390-ccw-virtio-2.4",
2305 "s390-ccw-virtio-2.5",
2306 "s390-ccw-virtio-2.6",
2307 "s390-ccw-virtio-2.7",
2308 NULL
2309 };
2310
2311 bool
virQEMUCapsIsCPUModeSupported(virQEMUCaps * qemuCaps,virArch hostarch,virDomainVirtType type,virCPUMode mode,const char * machineType)2312 virQEMUCapsIsCPUModeSupported(virQEMUCaps *qemuCaps,
2313 virArch hostarch,
2314 virDomainVirtType type,
2315 virCPUMode mode,
2316 const char *machineType)
2317 {
2318 qemuMonitorCPUDefs *cpus;
2319
2320 /* CPU models (except for "host") are not supported by QEMU for on s390
2321 * KVM domains with old machine types regardless on QEMU version. */
2322 if (ARCH_IS_S390(qemuCaps->arch) &&
2323 type == VIR_DOMAIN_VIRT_KVM &&
2324 mode != VIR_CPU_MODE_HOST_PASSTHROUGH &&
2325 machineType &&
2326 g_strv_contains(s390HostPassthroughOnlyMachines, machineType)) {
2327 return false;
2328 }
2329
2330 switch (mode) {
2331 case VIR_CPU_MODE_HOST_PASSTHROUGH:
2332 return type == VIR_DOMAIN_VIRT_KVM &&
2333 virQEMUCapsGuestIsNative(hostarch, qemuCaps->arch);
2334
2335 case VIR_CPU_MODE_HOST_MODEL:
2336 return !!virQEMUCapsGetHostModel(qemuCaps, type,
2337 VIR_QEMU_CAPS_HOST_CPU_REPORTED);
2338
2339 case VIR_CPU_MODE_CUSTOM:
2340 cpus = virQEMUCapsGetAccel(qemuCaps, type)->cpuModels;
2341 return cpus && cpus->ncpus > 0;
2342
2343 case VIR_CPU_MODE_MAXIMUM:
2344 return virQEMUCapsGet(qemuCaps, QEMU_CAPS_CPU_MAX);
2345
2346 case VIR_CPU_MODE_LAST:
2347 break;
2348 }
2349
2350 return false;
2351 }
2352
2353
2354 /**
2355 * virQEMUCapsGetCanonicalMachine:
2356 * @qemuCaps: qemu capabilities object
2357 * @name: machine name
2358 *
2359 * Resolves aliased machine names to the actual machine name. If qemuCaps isn't
2360 * present @name is returned.
2361 */
2362 const char *
virQEMUCapsGetCanonicalMachine(virQEMUCaps * qemuCaps,virDomainVirtType virtType,const char * name)2363 virQEMUCapsGetCanonicalMachine(virQEMUCaps *qemuCaps,
2364 virDomainVirtType virtType,
2365 const char *name)
2366 {
2367 virQEMUCapsAccel *accel;
2368 size_t i;
2369
2370 if (!name || !qemuCaps)
2371 return name;
2372
2373 accel = virQEMUCapsGetAccel(qemuCaps, virtType);
2374
2375 for (i = 0; i < accel->nmachineTypes; i++) {
2376 if (!accel->machineTypes[i].alias)
2377 continue;
2378 if (STREQ(accel->machineTypes[i].alias, name))
2379 return accel->machineTypes[i].name;
2380 }
2381
2382 return name;
2383 }
2384
2385
2386 int
virQEMUCapsGetMachineMaxCpus(virQEMUCaps * qemuCaps,virDomainVirtType virtType,const char * name)2387 virQEMUCapsGetMachineMaxCpus(virQEMUCaps *qemuCaps,
2388 virDomainVirtType virtType,
2389 const char *name)
2390 {
2391 virQEMUCapsAccel *accel;
2392 size_t i;
2393
2394 if (!name)
2395 return 0;
2396
2397 accel = virQEMUCapsGetAccel(qemuCaps, virtType);
2398
2399 for (i = 0; i < accel->nmachineTypes; i++) {
2400 if (!accel->machineTypes[i].maxCpus)
2401 continue;
2402 if (STREQ(accel->machineTypes[i].name, name))
2403 return accel->machineTypes[i].maxCpus;
2404 }
2405
2406 return 0;
2407 }
2408
2409
2410 bool
virQEMUCapsGetMachineHotplugCpus(virQEMUCaps * qemuCaps,virDomainVirtType virtType,const char * name)2411 virQEMUCapsGetMachineHotplugCpus(virQEMUCaps *qemuCaps,
2412 virDomainVirtType virtType,
2413 const char *name)
2414 {
2415 virQEMUCapsAccel *accel;
2416 size_t i;
2417
2418 accel = virQEMUCapsGetAccel(qemuCaps, virtType);
2419
2420 for (i = 0; i < accel->nmachineTypes; i++) {
2421 if (STREQ_NULLABLE(accel->machineTypes[i].name, name))
2422 return accel->machineTypes[i].hotplugCpus;
2423 }
2424
2425 return false;
2426 }
2427
2428
2429 const char *
virQEMUCapsGetMachineDefaultCPU(virQEMUCaps * qemuCaps,const char * name,virDomainVirtType type)2430 virQEMUCapsGetMachineDefaultCPU(virQEMUCaps *qemuCaps,
2431 const char *name,
2432 virDomainVirtType type)
2433 {
2434 virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, type);
2435 qemuMonitorCPUDefs *defs = accel->cpuModels;
2436 const char *cpuType = NULL;
2437 size_t i;
2438
2439 if (!name || !defs)
2440 return NULL;
2441
2442 for (i = 0; i < accel->nmachineTypes; i++) {
2443 if (STREQ(accel->machineTypes[i].name, name)) {
2444 cpuType = accel->machineTypes[i].defaultCPU;
2445 break;
2446 }
2447 }
2448
2449 if (!cpuType)
2450 return NULL;
2451
2452 for (i = 0; i < defs->ncpus; i++) {
2453 if (STREQ_NULLABLE(defs->cpus[i].type, cpuType))
2454 return defs->cpus[i].name;
2455 }
2456
2457 return NULL;
2458 }
2459
2460
2461 bool
virQEMUCapsIsCPUDeprecated(virQEMUCaps * qemuCaps,virDomainVirtType type,const char * model)2462 virQEMUCapsIsCPUDeprecated(virQEMUCaps *qemuCaps,
2463 virDomainVirtType type,
2464 const char *model)
2465 {
2466 virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, type);
2467 qemuMonitorCPUDefs *defs = accel->cpuModels;
2468 size_t i;
2469
2470 for (i = 0; i < defs->ncpus; i++) {
2471 if (STREQ_NULLABLE(defs->cpus[i].name, model))
2472 return defs->cpus[i].deprecated;
2473 }
2474 return false;
2475 }
2476
2477
2478 bool
virQEMUCapsIsMachineDeprecated(virQEMUCaps * qemuCaps,virDomainVirtType type,const char * machine)2479 virQEMUCapsIsMachineDeprecated(virQEMUCaps *qemuCaps,
2480 virDomainVirtType type,
2481 const char *machine)
2482 {
2483 virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, type);
2484 size_t i;
2485
2486 for (i = 0; i < accel->nmachineTypes; i++) {
2487 if (STREQ_NULLABLE(accel->machineTypes[i].name, machine))
2488 return accel->machineTypes[i].deprecated;
2489 }
2490 return false;
2491 }
2492
2493
2494 bool
virQEMUCapsGetMachineNumaMemSupported(virQEMUCaps * qemuCaps,virDomainVirtType virtType,const char * name)2495 virQEMUCapsGetMachineNumaMemSupported(virQEMUCaps *qemuCaps,
2496 virDomainVirtType virtType,
2497 const char *name)
2498 {
2499 virQEMUCapsAccel *accel;
2500 size_t i;
2501
2502 accel = virQEMUCapsGetAccel(qemuCaps, virtType);
2503
2504 for (i = 0; i < accel->nmachineTypes; i++) {
2505 if (STREQ(accel->machineTypes[i].name, name))
2506 return accel->machineTypes[i].numaMemSupported;
2507 }
2508
2509 return false;
2510 }
2511
2512
2513 const char *
virQEMUCapsGetMachineDefaultRAMid(virQEMUCaps * qemuCaps,virDomainVirtType virtType,const char * name)2514 virQEMUCapsGetMachineDefaultRAMid(virQEMUCaps *qemuCaps,
2515 virDomainVirtType virtType,
2516 const char *name)
2517 {
2518 virQEMUCapsAccel *accel;
2519 size_t i;
2520
2521 accel = virQEMUCapsGetAccel(qemuCaps, virtType);
2522
2523 for (i = 0; i < accel->nmachineTypes; i++) {
2524 if (STREQ(accel->machineTypes[i].name, name))
2525 return accel->machineTypes[i].defaultRAMid;
2526 }
2527
2528 return NULL;
2529 }
2530
2531
2532 /**
2533 * virQEMUCapsSetGICCapabilities:
2534 * @qemuCaps: QEMU capabilities
2535 * @capabilities: GIC capabilities
2536 * @ncapabilities: number of GIC capabilities
2537 *
2538 * Set the GIC capabilities for @qemuCaps.
2539 *
2540 * The ownership of @capabilities is taken away from the caller, ie. this
2541 * function will not make a copy of @capabilities, so releasing that memory
2542 * after it's been called is a bug.
2543 */
2544 void
virQEMUCapsSetGICCapabilities(virQEMUCaps * qemuCaps,virGICCapability * capabilities,size_t ncapabilities)2545 virQEMUCapsSetGICCapabilities(virQEMUCaps *qemuCaps,
2546 virGICCapability *capabilities,
2547 size_t ncapabilities)
2548 {
2549 VIR_FREE(qemuCaps->gicCapabilities);
2550
2551 qemuCaps->gicCapabilities = capabilities;
2552 qemuCaps->ngicCapabilities = ncapabilities;
2553 }
2554
2555
2556 virSEVCapability *
virQEMUCapsGetSEVCapabilities(virQEMUCaps * qemuCaps)2557 virQEMUCapsGetSEVCapabilities(virQEMUCaps *qemuCaps)
2558 {
2559 return qemuCaps->sevCapabilities;
2560 }
2561
2562
2563 static int
virQEMUCapsProbeQMPCommands(virQEMUCaps * qemuCaps,qemuMonitor * mon)2564 virQEMUCapsProbeQMPCommands(virQEMUCaps *qemuCaps,
2565 qemuMonitor *mon)
2566 {
2567 g_auto(GStrv) commands = NULL;
2568
2569 if (qemuMonitorGetCommands(mon, &commands) < 0)
2570 return -1;
2571
2572 virQEMUCapsProcessStringFlags(qemuCaps,
2573 G_N_ELEMENTS(virQEMUCapsCommands),
2574 virQEMUCapsCommands,
2575 commands);
2576
2577 return 0;
2578 }
2579
2580
2581 static int
virQEMUCapsProbeQMPObjectTypes(virQEMUCaps * qemuCaps,qemuMonitor * mon)2582 virQEMUCapsProbeQMPObjectTypes(virQEMUCaps *qemuCaps,
2583 qemuMonitor *mon)
2584 {
2585 g_auto(GStrv) values = NULL;
2586
2587 if (qemuMonitorGetObjectTypes(mon, &values) < 0)
2588 return -1;
2589 virQEMUCapsProcessStringFlags(qemuCaps,
2590 G_N_ELEMENTS(virQEMUCapsObjectTypes),
2591 virQEMUCapsObjectTypes,
2592 values);
2593
2594 return 0;
2595 }
2596
2597
2598 static int
virQEMUCapsProbeQMPDeviceProperties(virQEMUCaps * qemuCaps,qemuMonitor * mon)2599 virQEMUCapsProbeQMPDeviceProperties(virQEMUCaps *qemuCaps,
2600 qemuMonitor *mon)
2601 {
2602 size_t i;
2603
2604 for (i = 0; i < G_N_ELEMENTS(virQEMUCapsDeviceProps); i++) {
2605 virQEMUCapsDeviceTypeProps *device = virQEMUCapsDeviceProps + i;
2606 g_autoptr(GHashTable) qemuprops = NULL;
2607 size_t j;
2608
2609 if (device->capsCondition >= 0 &&
2610 !virQEMUCapsGet(qemuCaps, device->capsCondition))
2611 continue;
2612
2613 if (!(qemuprops = qemuMonitorGetDeviceProps(mon, device->type)))
2614 return -1;
2615
2616 for (j = 0; j < device->nprops; j++) {
2617 virJSONValue *entry = virHashLookup(qemuprops, device->props[j].value);
2618
2619 if (!entry)
2620 continue;
2621
2622 virQEMUCapsSet(qemuCaps, device->props[j].flag);
2623
2624 if (device->props[j].cb &&
2625 device->props[j].cb(entry, qemuCaps) < 0)
2626 return -1;
2627 }
2628 }
2629
2630 return 0;
2631 }
2632
2633
2634 static int
virQEMUCapsProbeQMPObjectProperties(virQEMUCaps * qemuCaps,qemuMonitor * mon)2635 virQEMUCapsProbeQMPObjectProperties(virQEMUCaps *qemuCaps,
2636 qemuMonitor *mon)
2637 {
2638 size_t i;
2639
2640 if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_QOM_LIST_PROPERTIES))
2641 return 0;
2642
2643 for (i = 0; i < G_N_ELEMENTS(virQEMUCapsObjectProps); i++) {
2644 virQEMUCapsObjectTypeProps *props = virQEMUCapsObjectProps + i;
2645 g_auto(GStrv) values = NULL;
2646
2647 if (props->capsCondition >= 0 &&
2648 !virQEMUCapsGet(qemuCaps, props->capsCondition))
2649 continue;
2650
2651 if (qemuMonitorGetObjectProps(mon, props->type, &values) < 0)
2652 return -1;
2653
2654 virQEMUCapsProcessStringFlags(qemuCaps,
2655 props->nprops,
2656 props->props,
2657 values);
2658 }
2659
2660 return 0;
2661 }
2662
2663
2664 /* Historically QEMU x86 targets defaulted to 'pc' machine type but
2665 * in future x86_64 might switch to 'q35'. Such a change is considered
2666 * an ABI break from libvirt's POV. Other QEMU targets may not declare
2667 * a default machine at all, causing libvirt to use the first reported
2668 * machine in the list.
2669 *
2670 * Here we record a preferred default machine for all arches, so
2671 * that we're not vulnerable to changes in QEMU defaults or machine
2672 * list ordering.
2673 */
2674 static const char *preferredMachines[] =
2675 {
2676 NULL, /* VIR_ARCH_NONE (not a real arch :) */
2677 "clipper", /* VIR_ARCH_ALPHA */
2678 "integratorcp", /* VIR_ARCH_ARMV6L */
2679 "integratorcp", /* VIR_ARCH_ARMV7L */
2680 "integratorcp", /* VIR_ARCH_ARMV7B */
2681
2682 "integratorcp", /* VIR_ARCH_AARCH64 */
2683 "axis-dev88", /* VIR_ARCH_CRIS */
2684 "pc", /* VIR_ARCH_I686 */
2685 NULL, /* VIR_ARCH_ITANIUM (doesn't exist in QEMU any more) */
2686 "lm32-evr", /* VIR_ARCH_LM32 */
2687
2688 "mcf5208evb", /* VIR_ARCH_M68K */
2689 "petalogix-s3adsp1800", /* VIR_ARCH_MICROBLAZE */
2690 "petalogix-s3adsp1800", /* VIR_ARCH_MICROBLAZEEL */
2691 "malta", /* VIR_ARCH_MIPS */
2692 "malta", /* VIR_ARCH_MIPSEL */
2693
2694 "malta", /* VIR_ARCH_MIPS64 */
2695 "malta", /* VIR_ARCH_MIPS64EL */
2696 "or1k-sim", /* VIR_ARCH_OR32 */
2697 NULL, /* VIR_ARCH_PARISC (no QEMU impl) */
2698 NULL, /* VIR_ARCH_PARISC64 (no QEMU impl) */
2699
2700 "g3beige", /* VIR_ARCH_PPC */
2701 "g3beige", /* VIR_ARCH_PPCLE */
2702 "pseries", /* VIR_ARCH_PPC64 */
2703 "pseries", /* VIR_ARCH_PPC64LE */
2704 "bamboo", /* VIR_ARCH_PPCEMB */
2705
2706 "spike_v1.10", /* VIR_ARCH_RISCV32 */
2707 "spike_v1.10", /* VIR_ARCH_RISCV64 */
2708 NULL, /* VIR_ARCH_S390 (no QEMU impl) */
2709 "s390-ccw-virtio", /* VIR_ARCH_S390X */
2710 "shix", /* VIR_ARCH_SH4 */
2711
2712 "shix", /* VIR_ARCH_SH4EB */
2713 "SS-5", /* VIR_ARCH_SPARC */
2714 "sun4u", /* VIR_ARCH_SPARC64 */
2715 "puv3", /* VIR_ARCH_UNICORE32 */
2716 "pc", /* VIR_ARCH_X86_64 */
2717
2718 "sim", /* VIR_ARCH_XTENSA */
2719 "sim", /* VIR_ARCH_XTENSAEB */
2720 };
2721 G_STATIC_ASSERT(G_N_ELEMENTS(preferredMachines) == VIR_ARCH_LAST);
2722
2723
2724 void
virQEMUCapsAddMachine(virQEMUCaps * qemuCaps,virDomainVirtType virtType,const char * name,const char * alias,const char * defaultCPU,int maxCpus,bool hotplugCpus,bool isDefault,bool numaMemSupported,const char * defaultRAMid,bool deprecated)2725 virQEMUCapsAddMachine(virQEMUCaps *qemuCaps,
2726 virDomainVirtType virtType,
2727 const char *name,
2728 const char *alias,
2729 const char *defaultCPU,
2730 int maxCpus,
2731 bool hotplugCpus,
2732 bool isDefault,
2733 bool numaMemSupported,
2734 const char *defaultRAMid,
2735 bool deprecated)
2736 {
2737 virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, virtType);
2738 virQEMUCapsMachineType *mach;
2739
2740 accel->machineTypes = g_renew(virQEMUCapsMachineType,
2741 accel->machineTypes,
2742 ++accel->nmachineTypes);
2743
2744 mach = &(accel->machineTypes[accel->nmachineTypes - 1]);
2745
2746 mach->alias = g_strdup(alias);
2747 mach->name = g_strdup(name);
2748 mach->defaultCPU = g_strdup(defaultCPU);
2749
2750 mach->maxCpus = maxCpus;
2751 mach->hotplugCpus = hotplugCpus;
2752
2753 mach->qemuDefault = isDefault;
2754
2755 mach->numaMemSupported = numaMemSupported;
2756
2757 mach->defaultRAMid = g_strdup(defaultRAMid);
2758 mach->deprecated = deprecated;
2759 }
2760
2761 /**
2762 * virQEMUCapsHasMachines:
2763 * @qemuCaps: qemu capabilities object
2764 *
2765 * Returns true if @qemuCaps has at least one machine type defined. This is
2766 * called by the test suite to figure out whether to populate fake machine types
2767 * into the list.
2768 */
2769 bool
virQEMUCapsHasMachines(virQEMUCaps * qemuCaps)2770 virQEMUCapsHasMachines(virQEMUCaps *qemuCaps)
2771 {
2772
2773 return !!qemuCaps->kvm.nmachineTypes || !!qemuCaps->tcg.nmachineTypes;
2774 }
2775
2776
2777 static int
virQEMUCapsProbeQMPMachineTypes(virQEMUCaps * qemuCaps,virDomainVirtType virtType,qemuMonitor * mon)2778 virQEMUCapsProbeQMPMachineTypes(virQEMUCaps *qemuCaps,
2779 virDomainVirtType virtType,
2780 qemuMonitor *mon)
2781 {
2782 qemuMonitorMachineInfo **machines = NULL;
2783 int nmachines = 0;
2784 size_t i;
2785 ssize_t defIdx = -1;
2786 ssize_t preferredIdx = -1;
2787 const char *preferredMachine = preferredMachines[qemuCaps->arch];
2788 virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, virtType);
2789
2790 if ((nmachines = qemuMonitorGetMachines(mon, &machines)) < 0)
2791 return -1;
2792
2793 for (i = 0; i < nmachines; i++) {
2794 if (STREQ(machines[i]->name, "none"))
2795 continue;
2796
2797 virQEMUCapsAddMachine(qemuCaps,
2798 virtType,
2799 machines[i]->name,
2800 machines[i]->alias,
2801 machines[i]->defaultCPU,
2802 machines[i]->maxCpus,
2803 machines[i]->hotplugCpus,
2804 machines[i]->isDefault,
2805 machines[i]->numaMemSupported,
2806 machines[i]->defaultRAMid,
2807 machines[i]->deprecated);
2808
2809 if (preferredMachine &&
2810 (STREQ_NULLABLE(machines[i]->alias, preferredMachine) ||
2811 STREQ(machines[i]->name, preferredMachine))) {
2812 preferredIdx = accel->nmachineTypes - 1;
2813 }
2814
2815 if (machines[i]->isDefault)
2816 defIdx = accel->nmachineTypes - 1;
2817 }
2818
2819 /*
2820 * We'll prefer to use our own historical default machine
2821 * to avoid mgmt apps seeing semantics changes when QEMU
2822 * alters its defaults.
2823 *
2824 * Our preferred machine might have been compiled out of
2825 * QEMU at build time though, so we still fallback to honouring
2826 * QEMU's reported default in that case
2827 */
2828 if (preferredIdx == -1)
2829 preferredIdx = defIdx;
2830 if (preferredIdx != -1)
2831 virQEMUCapsSetDefaultMachine(accel, preferredIdx);
2832
2833 for (i = 0; i < nmachines; i++)
2834 qemuMonitorMachineInfoFree(machines[i]);
2835 VIR_FREE(machines);
2836 return 0;
2837 }
2838
2839
2840 bool
virQEMUCapsIsMachineSupported(virQEMUCaps * qemuCaps,virDomainVirtType virtType,const char * canonical_machine)2841 virQEMUCapsIsMachineSupported(virQEMUCaps *qemuCaps,
2842 virDomainVirtType virtType,
2843 const char *canonical_machine)
2844 {
2845 virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, virtType);
2846 size_t i;
2847
2848 for (i = 0; i < accel->nmachineTypes; i++) {
2849 if (STREQ(canonical_machine, accel->machineTypes[i].name))
2850 return true;
2851 }
2852 return false;
2853 }
2854
2855
2856 static int
virQEMUCapsProbeQMPMachineProps(virQEMUCaps * qemuCaps,virDomainVirtType virtType,qemuMonitor * mon)2857 virQEMUCapsProbeQMPMachineProps(virQEMUCaps *qemuCaps,
2858 virDomainVirtType virtType,
2859 qemuMonitor *mon)
2860 {
2861 size_t i;
2862
2863 if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_QOM_LIST_PROPERTIES))
2864 return 0;
2865
2866 for (i = 0; i < G_N_ELEMENTS(virQEMUCapsMachineProps); i++) {
2867 virQEMUCapsObjectTypeProps props = virQEMUCapsMachineProps[i];
2868 const char *canon = virQEMUCapsGetCanonicalMachine(qemuCaps, virtType, props.type);
2869 g_autofree char *type = NULL;
2870 g_auto(GStrv) values = NULL;
2871
2872 if (STRNEQ(canon, "none") &&
2873 !virQEMUCapsIsMachineSupported(qemuCaps, virtType, canon)) {
2874 continue;
2875 }
2876
2877 /* The QOM type for machine types is the machine type name
2878 * followed by the -machine suffix */
2879 type = g_strdup_printf("%s-machine", canon);
2880
2881 if (qemuMonitorGetObjectProps(mon, type, &values) < 0)
2882 return -1;
2883
2884 virQEMUCapsProcessStringFlags(qemuCaps,
2885 props.nprops,
2886 props.props,
2887 values);
2888 }
2889
2890 return 0;
2891 }
2892
2893
2894 static int
virQEMUCapsFetchCPUDefinitions(qemuMonitor * mon,virArch arch,qemuMonitorCPUDefs ** cpuDefs)2895 virQEMUCapsFetchCPUDefinitions(qemuMonitor *mon,
2896 virArch arch,
2897 qemuMonitorCPUDefs **cpuDefs)
2898 {
2899 g_autoptr(qemuMonitorCPUDefs) defs = NULL;
2900 size_t i;
2901
2902 *cpuDefs = NULL;
2903
2904 if (qemuMonitorGetCPUDefinitions(mon, &defs) < 0)
2905 return -1;
2906
2907 if (!defs)
2908 return 0;
2909
2910 /* QEMU 2.11 for Power renamed all CPU models to lower case, we need to
2911 * translate them back to libvirt's upper case model names. */
2912 if (ARCH_IS_PPC64(arch)) {
2913 g_auto(GStrv) libvirtModels = NULL;
2914 char **name;
2915
2916 if (virCPUGetModels(arch, &libvirtModels) < 0)
2917 return -1;
2918
2919 for (name = libvirtModels; name && *name; name++) {
2920 for (i = 0; i < defs->ncpus; i++) {
2921 if (STRCASENEQ(defs->cpus[i].name, *name))
2922 continue;
2923
2924 VIR_FREE(defs->cpus[i].name);
2925 defs->cpus[i].name = g_strdup(*name);
2926 }
2927 }
2928 }
2929
2930 *cpuDefs = g_steal_pointer(&defs);
2931 return 0;
2932 }
2933
2934
2935 int
virQEMUCapsFetchCPUModels(qemuMonitor * mon,virArch arch,virDomainCapsCPUModels ** cpuModels)2936 virQEMUCapsFetchCPUModels(qemuMonitor *mon,
2937 virArch arch,
2938 virDomainCapsCPUModels **cpuModels)
2939 {
2940 g_autoptr(qemuMonitorCPUDefs) defs = NULL;
2941
2942 *cpuModels = NULL;
2943
2944 if (virQEMUCapsFetchCPUDefinitions(mon, arch, &defs) < 0)
2945 return -1;
2946
2947 if (defs && !(*cpuModels = virQEMUCapsCPUDefsToModels(defs, NULL, NULL)))
2948 return -1;
2949
2950 return 0;
2951 }
2952
2953
2954 static int
virQEMUCapsProbeQMPCPUDefinitions(virQEMUCaps * qemuCaps,virQEMUCapsAccel * accel,qemuMonitor * mon)2955 virQEMUCapsProbeQMPCPUDefinitions(virQEMUCaps *qemuCaps,
2956 virQEMUCapsAccel *accel,
2957 qemuMonitor *mon)
2958 {
2959 qemuMonitorCPUDefs *defs;
2960 size_t i;
2961
2962 if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_CPU_DEFINITIONS))
2963 return 0;
2964
2965 if (virQEMUCapsFetchCPUDefinitions(mon, qemuCaps->arch, &accel->cpuModels) < 0)
2966 return -1;
2967
2968 defs = accel->cpuModels;
2969 for (i = 0; i < defs->ncpus; i++) {
2970 if (STREQ_NULLABLE(defs->cpus[i].name, "max")) {
2971 virQEMUCapsSet(qemuCaps, QEMU_CAPS_CPU_MAX);
2972 break;
2973 }
2974 }
2975
2976 return 0;
2977 }
2978
2979
2980 int
virQEMUCapsProbeCPUDefinitionsTest(virQEMUCaps * qemuCaps,qemuMonitor * mon)2981 virQEMUCapsProbeCPUDefinitionsTest(virQEMUCaps *qemuCaps,
2982 qemuMonitor *mon)
2983 {
2984 return virQEMUCapsProbeQMPCPUDefinitions(qemuCaps, &qemuCaps->kvm, mon);
2985 }
2986
2987
2988 static int
virQEMUCapsProbeQMPHostCPU(virQEMUCaps * qemuCaps,virQEMUCapsAccel * accel,qemuMonitor * mon,virDomainVirtType virtType)2989 virQEMUCapsProbeQMPHostCPU(virQEMUCaps *qemuCaps,
2990 virQEMUCapsAccel *accel,
2991 qemuMonitor *mon,
2992 virDomainVirtType virtType)
2993 {
2994 const char *model = virtType == VIR_DOMAIN_VIRT_KVM ? "host" : "max";
2995 g_autoptr(qemuMonitorCPUModelInfo) modelInfo = NULL;
2996 g_autoptr(qemuMonitorCPUModelInfo) nonMigratable = NULL;
2997 g_autoptr(GHashTable) hash = NULL;
2998 g_autoptr(virCPUDef) cpu = NULL;
2999 qemuMonitorCPUModelExpansionType type;
3000 bool fail_no_props = true;
3001
3002 if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION))
3003 return 0;
3004
3005 cpu = virCPUDefNew();
3006
3007 cpu->model = g_strdup(model);
3008
3009 /* Some x86_64 features defined in src/cpu_map/ use spelling which differ
3010 * from the one preferred by QEMU. Static expansion would give us only the
3011 * preferred spelling. With new QEMU we always use the QEMU's canonical
3012 * names of all features and translate between them and our names. But for
3013 * older version of QEMU we need to do a full expansion on the result of
3014 * the initial static expansion to get all variants of feature names.
3015 */
3016 if (ARCH_IS_X86(qemuCaps->arch) &&
3017 !virQEMUCapsGet(qemuCaps, QEMU_CAPS_CANONICAL_CPU_FEATURES)) {
3018 type = QEMU_MONITOR_CPU_MODEL_EXPANSION_STATIC_FULL;
3019 } else if (ARCH_IS_ARM(qemuCaps->arch)) {
3020 type = QEMU_MONITOR_CPU_MODEL_EXPANSION_FULL;
3021 } else {
3022 type = QEMU_MONITOR_CPU_MODEL_EXPANSION_STATIC;
3023 }
3024
3025 /* Older s390 models do not report a feature set */
3026 if (ARCH_IS_S390(qemuCaps->arch))
3027 fail_no_props = false;
3028
3029 if (qemuMonitorGetCPUModelExpansion(mon, type, cpu, true, fail_no_props,
3030 &modelInfo) < 0)
3031 return -1;
3032
3033 /* Try to check migratability of each feature. */
3034 if (modelInfo &&
3035 virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION_MIGRATABLE) &&
3036 qemuMonitorGetCPUModelExpansion(mon, type, cpu, false, fail_no_props,
3037 &nonMigratable) < 0)
3038 return -1;
3039
3040 if (nonMigratable) {
3041 qemuMonitorCPUProperty *prop;
3042 qemuMonitorCPUProperty *nmProp;
3043 size_t i;
3044
3045 hash = virHashNew(NULL);
3046
3047 for (i = 0; i < modelInfo->nprops; i++) {
3048 prop = modelInfo->props + i;
3049 if (virHashAddEntry(hash, prop->name, prop) < 0)
3050 return -1;
3051 }
3052
3053 for (i = 0; i < nonMigratable->nprops; i++) {
3054 nmProp = nonMigratable->props + i;
3055 if (!(prop = virHashLookup(hash, nmProp->name)) ||
3056 prop->type != QEMU_MONITOR_CPU_PROPERTY_BOOLEAN ||
3057 prop->type != nmProp->type)
3058 continue;
3059
3060 if (prop->value.boolean) {
3061 prop->migratable = VIR_TRISTATE_BOOL_YES;
3062 } else if (nmProp->value.boolean) {
3063 prop->value.boolean = true;
3064 prop->migratable = VIR_TRISTATE_BOOL_NO;
3065 }
3066 }
3067
3068 modelInfo->migratability = true;
3069 }
3070
3071 accel->hostCPU.info = g_steal_pointer(&modelInfo);
3072 return 0;
3073 }
3074
3075
3076 /**
3077 * Get NULL terminated list of features supported by QEMU.
3078 *
3079 * Returns -1 on error,
3080 * 0 on success (@features will be NULL if QEMU does not support this),
3081 * 1 when @features is filled in, but migratability info is not available.
3082 */
3083 int
virQEMUCapsGetCPUFeatures(virQEMUCaps * qemuCaps,virDomainVirtType virtType,bool migratable,char *** features)3084 virQEMUCapsGetCPUFeatures(virQEMUCaps *qemuCaps,
3085 virDomainVirtType virtType,
3086 bool migratable,
3087 char ***features)
3088 {
3089 qemuMonitorCPUModelInfo *modelInfo;
3090 g_auto(GStrv) list = NULL;
3091 size_t i;
3092 size_t n;
3093
3094 *features = NULL;
3095 modelInfo = virQEMUCapsGetCPUModelInfo(qemuCaps, virtType);
3096
3097 if (!modelInfo)
3098 return 0;
3099
3100 list = g_new0(char *, modelInfo->nprops + 1);
3101
3102 n = 0;
3103 for (i = 0; i < modelInfo->nprops; i++) {
3104 qemuMonitorCPUProperty *prop = modelInfo->props + i;
3105
3106 if (migratable && prop->migratable == VIR_TRISTATE_BOOL_NO)
3107 continue;
3108
3109 list[n++] = g_strdup(virQEMUCapsCPUFeatureFromQEMU(qemuCaps, prop->name));
3110 }
3111
3112 *features = g_steal_pointer(&list);
3113
3114 if (migratable && !modelInfo->migratability)
3115 return 1;
3116 return 0;
3117 }
3118
3119
3120 struct tpmTypeToCaps {
3121 int type;
3122 virQEMUCapsFlags caps;
3123 };
3124
3125 static const struct tpmTypeToCaps virQEMUCapsTPMTypesToCaps[] = {
3126 {
3127 .type = VIR_DOMAIN_TPM_TYPE_PASSTHROUGH,
3128 .caps = QEMU_CAPS_DEVICE_TPM_PASSTHROUGH,
3129 },
3130 {
3131 .type = VIR_DOMAIN_TPM_TYPE_EMULATOR,
3132 .caps = QEMU_CAPS_DEVICE_TPM_EMULATOR,
3133 },
3134 };
3135
3136 const struct tpmTypeToCaps virQEMUCapsTPMModelsToCaps[] = {
3137 {
3138 .type = VIR_DOMAIN_TPM_MODEL_TIS,
3139 .caps = QEMU_CAPS_DEVICE_TPM_TIS,
3140 },
3141 {
3142 .type = VIR_DOMAIN_TPM_MODEL_CRB,
3143 .caps = QEMU_CAPS_DEVICE_TPM_CRB,
3144 },
3145 {
3146 .type = VIR_DOMAIN_TPM_MODEL_SPAPR,
3147 .caps = QEMU_CAPS_DEVICE_TPM_SPAPR,
3148 },
3149 };
3150
3151 static int
virQEMUCapsProbeQMPTPM(virQEMUCaps * qemuCaps,qemuMonitor * mon)3152 virQEMUCapsProbeQMPTPM(virQEMUCaps *qemuCaps,
3153 qemuMonitor *mon)
3154 {
3155 g_auto(GStrv) models = NULL;
3156 g_auto(GStrv) types = NULL;
3157 size_t i;
3158
3159 if (qemuMonitorGetTPMModels(mon, &models) < 0)
3160 return -1;
3161
3162 if (!models)
3163 return 0;
3164
3165 for (i = 0; i < G_N_ELEMENTS(virQEMUCapsTPMModelsToCaps); i++) {
3166 const char *needle = virDomainTPMModelTypeToString(virQEMUCapsTPMModelsToCaps[i].type);
3167 if (g_strv_contains((const char **)models, needle))
3168 virQEMUCapsSet(qemuCaps, virQEMUCapsTPMModelsToCaps[i].caps);
3169 }
3170
3171 if (qemuMonitorGetTPMTypes(mon, &types) < 0)
3172 return -1;
3173
3174 if (!types)
3175 return 0;
3176
3177 for (i = 0; i < G_N_ELEMENTS(virQEMUCapsTPMTypesToCaps); i++) {
3178 const char *needle = virDomainTPMBackendTypeToString(virQEMUCapsTPMTypesToCaps[i].type);
3179 if (g_strv_contains((const char **)types, needle))
3180 virQEMUCapsSet(qemuCaps, virQEMUCapsTPMTypesToCaps[i].caps);
3181 }
3182
3183 return 0;
3184 }
3185
3186
3187 static int
virQEMUCapsProbeQMPKVMState(virQEMUCaps * qemuCaps,qemuMonitor * mon)3188 virQEMUCapsProbeQMPKVMState(virQEMUCaps *qemuCaps,
3189 qemuMonitor *mon)
3190 {
3191 bool enabled = false;
3192 bool present = false;
3193
3194 if (qemuMonitorGetKVMState(mon, &enabled, &present) < 0)
3195 return -1;
3196
3197 if (present && enabled)
3198 virQEMUCapsSet(qemuCaps, QEMU_CAPS_KVM);
3199
3200 return 0;
3201 }
3202
3203 static int
virQEMUCapsProbeQMPNVMMState(virQEMUCaps * qemuCaps,qemuMonitor * mon)3204 virQEMUCapsProbeQMPNVMMState(virQEMUCaps *qemuCaps,
3205 qemuMonitor *mon)
3206 {
3207 bool enabled = false;
3208 bool present = false;
3209
3210 if (qemuMonitorGetNVMMState(mon, &enabled, &present) < 0)
3211 return -1;
3212
3213 if (present && enabled)
3214 virQEMUCapsSet(qemuCaps, QEMU_CAPS_NVMM);
3215
3216 return 0;
3217 }
3218
3219 struct virQEMUCapsCommandLineProps {
3220 const char *option;
3221 const char *param;
3222 int flag;
3223 };
3224
3225
3226 /* This uses 'query-command-line-options' which uses old-style argument parsers
3227 * in qemu and thus isn't being properly extended. Other means to detect
3228 * features should be used if possible. */
3229 static struct virQEMUCapsCommandLineProps virQEMUCapsCommandLine[] = {
3230 { "chardev", "fd", QEMU_CAPS_CHARDEV_FD_PASS_COMMANDLINE },
3231 { "fsdev", "multidevs", QEMU_CAPS_FSDEV_MULTIDEVS },
3232 { "numa", NULL, QEMU_CAPS_NUMA }, /* not needed after qemuCaps->version < 3000000 */
3233 { "overcommit", NULL, QEMU_CAPS_OVERCOMMIT },
3234 { "sandbox", NULL, QEMU_CAPS_SECCOMP_SANDBOX },
3235 { "spice", "gl", QEMU_CAPS_SPICE_GL },
3236 { "spice", "rendernode", QEMU_CAPS_SPICE_RENDERNODE },
3237 { "vnc", "power-control", QEMU_CAPS_VNC_POWER_CONTROL },
3238 { "vnc", "audiodev", QEMU_CAPS_AUDIODEV },
3239 };
3240
3241 static int
virQEMUCapsProbeQMPCommandLine(virQEMUCaps * qemuCaps,qemuMonitor * mon)3242 virQEMUCapsProbeQMPCommandLine(virQEMUCaps *qemuCaps,
3243 qemuMonitor *mon)
3244 {
3245 g_autoptr(GHashTable) options = NULL;
3246 size_t i;
3247
3248 if (!(options = qemuMonitorGetCommandLineOptions(mon)))
3249 return -1;
3250
3251 for (i = 0; i < G_N_ELEMENTS(virQEMUCapsCommandLine); i++) {
3252 virJSONValue *option = g_hash_table_lookup(options, virQEMUCapsCommandLine[i].option);
3253 size_t j;
3254
3255 if (!option)
3256 continue;
3257
3258 /* not looking for a specific argument */
3259 if (!virQEMUCapsCommandLine[i].param) {
3260 virQEMUCapsSet(qemuCaps, virQEMUCapsCommandLine[i].flag);
3261 continue;
3262 }
3263
3264 for (j = 0; j < virJSONValueArraySize(option); j++) {
3265 virJSONValue *param = virJSONValueArrayGet(option, j);
3266 const char *paramname = virJSONValueObjectGetString(param, "name");
3267
3268 if (STREQ_NULLABLE(virQEMUCapsCommandLine[i].param, paramname))
3269 virQEMUCapsSet(qemuCaps, virQEMUCapsCommandLine[i].flag);
3270 }
3271 }
3272
3273 return 0;
3274 }
3275
3276 static int
virQEMUCapsProbeQMPMigrationCapabilities(virQEMUCaps * qemuCaps,qemuMonitor * mon)3277 virQEMUCapsProbeQMPMigrationCapabilities(virQEMUCaps *qemuCaps,
3278 qemuMonitor *mon)
3279 {
3280 g_auto(GStrv) caps = NULL;
3281
3282 if (qemuMonitorGetMigrationCapabilities(mon, &caps) < 0)
3283 return -1;
3284
3285 virQEMUCapsProcessStringFlags(qemuCaps,
3286 G_N_ELEMENTS(virQEMUCapsMigration),
3287 virQEMUCapsMigration,
3288 caps);
3289
3290 return 0;
3291 }
3292
3293 /**
3294 * virQEMUCapsProbeQMPGICCapabilities:
3295 * @qemuCaps: QEMU binary capabilities
3296 * @mon: QEMU monitor
3297 *
3298 * Use @mon to obtain information about the GIC capabilities for the
3299 * corresponding QEMU binary, and store them in @qemuCaps.
3300 *
3301 * Returns: 0 on success, <0 on failure
3302 */
3303 static int
virQEMUCapsProbeQMPGICCapabilities(virQEMUCaps * qemuCaps,qemuMonitor * mon)3304 virQEMUCapsProbeQMPGICCapabilities(virQEMUCaps *qemuCaps,
3305 qemuMonitor *mon)
3306 {
3307 virGICCapability *caps = NULL;
3308 int ncaps;
3309
3310 if (!(qemuCaps->arch == VIR_ARCH_AARCH64 ||
3311 qemuCaps->arch == VIR_ARCH_ARMV6L ||
3312 qemuCaps->arch == VIR_ARCH_ARMV7L))
3313 return 0;
3314
3315 if ((ncaps = qemuMonitorGetGICCapabilities(mon, &caps)) < 0)
3316 return -1;
3317
3318 virQEMUCapsSetGICCapabilities(qemuCaps, caps, ncaps);
3319
3320 return 0;
3321 }
3322
3323
3324 static int
virQEMUCapsProbeQMPSEVCapabilities(virQEMUCaps * qemuCaps,qemuMonitor * mon)3325 virQEMUCapsProbeQMPSEVCapabilities(virQEMUCaps *qemuCaps,
3326 qemuMonitor *mon)
3327 {
3328 int rc = -1;
3329 virSEVCapability *caps = NULL;
3330
3331 if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SEV_GUEST))
3332 return 0;
3333
3334 if ((rc = qemuMonitorGetSEVCapabilities(mon, &caps)) < 0)
3335 return -1;
3336
3337 /* SEV isn't actually supported */
3338 if (rc == 0) {
3339 virQEMUCapsClear(qemuCaps, QEMU_CAPS_SEV_GUEST);
3340 return 0;
3341 }
3342
3343 virSEVCapabilitiesFree(qemuCaps->sevCapabilities);
3344 qemuCaps->sevCapabilities = caps;
3345 return 0;
3346 }
3347
3348
3349 /*
3350 * Filter for features which should never be passed to QEMU. Either because
3351 * QEMU never supported them or they were dropped as they never did anything
3352 * useful.
3353 */
3354 bool
virQEMUCapsCPUFilterFeatures(const char * name,virCPUFeaturePolicy policy G_GNUC_UNUSED,void * opaque)3355 virQEMUCapsCPUFilterFeatures(const char *name,
3356 virCPUFeaturePolicy policy G_GNUC_UNUSED,
3357 void *opaque)
3358 {
3359 virArch *arch = opaque;
3360
3361 if (!ARCH_IS_X86(*arch))
3362 return true;
3363
3364 if (STREQ(name, "cmt") ||
3365 STREQ(name, "mbm_total") ||
3366 STREQ(name, "mbm_local") ||
3367 STREQ(name, "osxsave") ||
3368 STREQ(name, "ospke"))
3369 return false;
3370
3371 return true;
3372 }
3373
3374
3375 typedef struct _virQEMUCapsCPUFeatureTranslationTable virQEMUCapsCPUFeatureTranslationTable;
3376 struct _virQEMUCapsCPUFeatureTranslationTable {
3377 const char *libvirt;
3378 const char *qemu;
3379 };
3380
3381 virQEMUCapsCPUFeatureTranslationTable virQEMUCapsCPUFeaturesX86[] = {
3382 {"cmp_legacy", "cmp-legacy"},
3383 {"ds_cpl", "ds-cpl"},
3384 {"fxsr_opt", "fxsr-opt"},
3385 {"kvm_pv_eoi", "kvm-pv-eoi"},
3386 {"kvm_pv_unhalt", "kvm-pv-unhalt"},
3387 {"lahf_lm", "lahf-lm"},
3388 {"nodeid_msr", "nodeid-msr"},
3389 {"pclmuldq", "pclmulqdq"},
3390 {"perfctr_core", "perfctr-core"},
3391 {"perfctr_nb", "perfctr-nb"},
3392 {"tsc_adjust", "tsc-adjust"},
3393 {NULL, NULL}
3394 };
3395
3396
3397 static const char *
virQEMUCapsCPUFeatureTranslate(virQEMUCaps * qemuCaps,const char * feature,bool reversed)3398 virQEMUCapsCPUFeatureTranslate(virQEMUCaps *qemuCaps,
3399 const char *feature,
3400 bool reversed)
3401 {
3402 virQEMUCapsCPUFeatureTranslationTable *table = NULL;
3403 virQEMUCapsCPUFeatureTranslationTable *entry;
3404
3405 if (ARCH_IS_X86(qemuCaps->arch))
3406 table = virQEMUCapsCPUFeaturesX86;
3407
3408 if (!table ||
3409 !feature)
3410 return feature;
3411
3412 for (entry = table; entry->libvirt; entry++) {
3413 const char *key = reversed ? entry->qemu : entry->libvirt;
3414
3415 if (STREQ(feature, key))
3416 return reversed ? entry->libvirt : entry->qemu;
3417 }
3418
3419 return feature;
3420 }
3421
3422
3423 const char *
virQEMUCapsCPUFeatureToQEMU(virQEMUCaps * qemuCaps,const char * feature)3424 virQEMUCapsCPUFeatureToQEMU(virQEMUCaps *qemuCaps,
3425 const char *feature)
3426 {
3427 return virQEMUCapsCPUFeatureTranslate(qemuCaps, feature, false);
3428 }
3429
3430
3431 const char *
virQEMUCapsCPUFeatureFromQEMU(virQEMUCaps * qemuCaps,const char * feature)3432 virQEMUCapsCPUFeatureFromQEMU(virQEMUCaps *qemuCaps,
3433 const char *feature)
3434 {
3435 return virQEMUCapsCPUFeatureTranslate(qemuCaps, feature, true);
3436 }
3437
3438
3439 /**
3440 * Returns 0 when host CPU model provided by QEMU was filled in qemuCaps,
3441 * 1 when the caller should fall back to using virCaps *->host.cpu,
3442 * 2 when cpu model info is not supported for this configuration,
3443 * -1 on error.
3444 */
3445 static int
virQEMUCapsInitCPUModelS390(virQEMUCaps * qemuCaps,virDomainVirtType type,qemuMonitorCPUModelInfo * modelInfo,virCPUDef * cpu,bool migratable)3446 virQEMUCapsInitCPUModelS390(virQEMUCaps *qemuCaps,
3447 virDomainVirtType type,
3448 qemuMonitorCPUModelInfo *modelInfo,
3449 virCPUDef *cpu,
3450 bool migratable)
3451 {
3452 size_t i;
3453
3454 if (!modelInfo) {
3455 if (type == VIR_DOMAIN_VIRT_KVM) {
3456 virReportError(VIR_ERR_INTERNAL_ERROR,
3457 _("missing host CPU model info from QEMU "
3458 "capabilities for binary %s"),
3459 qemuCaps->binary);
3460 return -1;
3461 }
3462 return 2;
3463 }
3464
3465 cpu->model = g_strdup(modelInfo->name);
3466 cpu->features = g_new0(virCPUFeatureDef, modelInfo->nprops);
3467
3468 cpu->nfeatures_max = modelInfo->nprops;
3469 cpu->nfeatures = 0;
3470
3471 for (i = 0; i < modelInfo->nprops; i++) {
3472 virCPUFeatureDef *feature = cpu->features + cpu->nfeatures;
3473 qemuMonitorCPUProperty *prop = modelInfo->props + i;
3474 const char *name = virQEMUCapsCPUFeatureFromQEMU(qemuCaps, prop->name);
3475
3476 if (prop->type != QEMU_MONITOR_CPU_PROPERTY_BOOLEAN)
3477 continue;
3478
3479 feature->name = g_strdup(name);
3480
3481 if (!prop->value.boolean ||
3482 (migratable && prop->migratable == VIR_TRISTATE_BOOL_NO))
3483 feature->policy = VIR_CPU_FEATURE_DISABLE;
3484 else
3485 feature->policy = VIR_CPU_FEATURE_REQUIRE;
3486 cpu->nfeatures++;
3487 }
3488
3489 return 0;
3490 }
3491
3492
3493 virCPUData *
virQEMUCapsGetCPUModelX86Data(virQEMUCaps * qemuCaps,qemuMonitorCPUModelInfo * model,bool migratable)3494 virQEMUCapsGetCPUModelX86Data(virQEMUCaps *qemuCaps,
3495 qemuMonitorCPUModelInfo *model,
3496 bool migratable)
3497 {
3498 unsigned long long sigFamily = 0;
3499 unsigned long long sigModel = 0;
3500 unsigned long long sigStepping = 0;
3501 g_autoptr(virCPUData) data = NULL;
3502 size_t i;
3503
3504 if (!(data = virCPUDataNew(VIR_ARCH_X86_64)))
3505 return NULL;
3506
3507 for (i = 0; i < model->nprops; i++) {
3508 qemuMonitorCPUProperty *prop = model->props + i;
3509 const char *name = virQEMUCapsCPUFeatureFromQEMU(qemuCaps, prop->name);
3510
3511 switch (prop->type) {
3512 case QEMU_MONITOR_CPU_PROPERTY_BOOLEAN:
3513 if (!prop->value.boolean ||
3514 (migratable && prop->migratable == VIR_TRISTATE_BOOL_NO))
3515 continue;
3516
3517 if (virCPUDataAddFeature(data, name) < 0)
3518 return NULL;
3519
3520 break;
3521
3522 case QEMU_MONITOR_CPU_PROPERTY_STRING:
3523 if (STREQ(name, "vendor") &&
3524 virCPUx86DataSetVendor(data, prop->value.string) < 0)
3525 return NULL;
3526 break;
3527
3528 case QEMU_MONITOR_CPU_PROPERTY_NUMBER:
3529 if (STREQ(name, "family"))
3530 sigFamily = prop->value.number;
3531 else if (STREQ(name, "model"))
3532 sigModel = prop->value.number;
3533 else if (STREQ(name, "stepping"))
3534 sigStepping = prop->value.number;
3535 break;
3536
3537 case QEMU_MONITOR_CPU_PROPERTY_LAST:
3538 break;
3539 }
3540 }
3541
3542 if (virCPUx86DataSetSignature(data, sigFamily, sigModel, sigStepping) < 0)
3543 return NULL;
3544
3545 return g_steal_pointer(&data);
3546 }
3547
3548
3549 /**
3550 * Returns 0 when host CPU model provided by QEMU was filled in qemuCaps,
3551 * 1 when the caller should fall back to using virCaps *->host.cpu,
3552 * -1 on error.
3553 */
3554 static int
virQEMUCapsInitCPUModelX86(virQEMUCaps * qemuCaps,virDomainVirtType type,qemuMonitorCPUModelInfo * model,virCPUDef * cpu,bool migratable)3555 virQEMUCapsInitCPUModelX86(virQEMUCaps *qemuCaps,
3556 virDomainVirtType type,
3557 qemuMonitorCPUModelInfo *model,
3558 virCPUDef *cpu,
3559 bool migratable)
3560 {
3561 g_autoptr(virDomainCapsCPUModels) cpuModels = NULL;
3562 g_autoptr(virCPUData) data = NULL;
3563
3564 if (!model)
3565 return 1;
3566
3567 if (!(data = virQEMUCapsGetCPUModelX86Data(qemuCaps, model, migratable)))
3568 return -1;
3569
3570 cpuModels = virQEMUCapsGetCPUModels(qemuCaps, type, NULL, NULL);
3571
3572 if (cpuDecode(cpu, data, cpuModels) < 0)
3573 return -1;
3574
3575 return 0;
3576 }
3577
3578
3579 /**
3580 * Returns 0 when host CPU model provided by QEMU was filled in qemuCaps,
3581 * 1 when the caller should fall back to other methods,
3582 * 2 when cpu model info is not supported for this configuration,
3583 * -1 on error.
3584 */
3585 int
virQEMUCapsInitCPUModel(virQEMUCaps * qemuCaps,virDomainVirtType type,virCPUDef * cpu,bool migratable)3586 virQEMUCapsInitCPUModel(virQEMUCaps *qemuCaps,
3587 virDomainVirtType type,
3588 virCPUDef *cpu,
3589 bool migratable)
3590 {
3591 qemuMonitorCPUModelInfo *modelInfo = virQEMUCapsGetCPUModelInfo(qemuCaps, type);
3592 int ret = 1;
3593
3594 if (migratable && modelInfo && !modelInfo->migratability)
3595 return 1;
3596
3597 if (ARCH_IS_S390(qemuCaps->arch)) {
3598 ret = virQEMUCapsInitCPUModelS390(qemuCaps, type, modelInfo,
3599 cpu, migratable);
3600 } else if (ARCH_IS_X86(qemuCaps->arch)) {
3601 ret = virQEMUCapsInitCPUModelX86(qemuCaps, type, modelInfo,
3602 cpu, migratable);
3603 } else if (ARCH_IS_ARM(qemuCaps->arch)) {
3604 ret = 2;
3605 }
3606
3607 if (ret == 0)
3608 cpu->fallback = VIR_CPU_FALLBACK_FORBID;
3609
3610 return ret;
3611 }
3612
3613
3614 static virCPUDef *
virQEMUCapsNewHostCPUModel(void)3615 virQEMUCapsNewHostCPUModel(void)
3616 {
3617 virCPUDef *cpu = virCPUDefNew();
3618
3619 cpu->type = VIR_CPU_TYPE_GUEST;
3620 cpu->mode = VIR_CPU_MODE_CUSTOM;
3621 cpu->match = VIR_CPU_MATCH_EXACT;
3622 cpu->fallback = VIR_CPU_FALLBACK_ALLOW;
3623
3624 return cpu;
3625 }
3626
3627
3628 void
virQEMUCapsInitHostCPUModel(virQEMUCaps * qemuCaps,virArch hostArch,virDomainVirtType type)3629 virQEMUCapsInitHostCPUModel(virQEMUCaps *qemuCaps,
3630 virArch hostArch,
3631 virDomainVirtType type)
3632 {
3633 virCPUDef *cpu = NULL;
3634 virCPUDef *cpuExpanded = NULL;
3635 virCPUDef *migCPU = NULL;
3636 virCPUDef *hostCPU = NULL;
3637 virCPUDef *fullCPU = NULL;
3638 size_t i;
3639 int rc;
3640
3641 if (!virQEMUCapsGuestIsNative(hostArch, qemuCaps->arch))
3642 return;
3643
3644 if (!(cpu = virQEMUCapsNewHostCPUModel()))
3645 goto error;
3646
3647 if ((rc = virQEMUCapsInitCPUModel(qemuCaps, type, cpu, false)) < 0) {
3648 goto error;
3649 } else if (rc == 1) {
3650 g_autoptr(virDomainCapsCPUModels) cpuModels = NULL;
3651
3652 VIR_DEBUG("No host CPU model info from QEMU; probing host CPU directly");
3653
3654 cpuModels = virQEMUCapsGetCPUModels(qemuCaps, type, NULL, NULL);
3655 hostCPU = virQEMUCapsProbeHostCPU(hostArch, cpuModels);
3656
3657 if (!hostCPU ||
3658 virCPUDefCopyModelFilter(cpu, hostCPU, true,
3659 virQEMUCapsCPUFilterFeatures,
3660 &qemuCaps->arch) < 0)
3661 goto error;
3662 } else if (rc == 2) {
3663 VIR_DEBUG("QEMU does not provide CPU model for arch=%s virttype=%s",
3664 virArchToString(qemuCaps->arch),
3665 virDomainVirtTypeToString(type));
3666 goto error;
3667 } else if (type == VIR_DOMAIN_VIRT_KVM &&
3668 virCPUGetHostIsSupported(qemuCaps->arch)) {
3669 if (!(fullCPU = virQEMUCapsProbeHostCPU(qemuCaps->arch, NULL)))
3670 goto error;
3671
3672 if (!(cpuExpanded = virCPUDefCopy(cpu)) ||
3673 virCPUExpandFeatures(qemuCaps->arch, cpuExpanded) < 0)
3674 goto error;
3675
3676 for (i = 0; i < cpuExpanded->nfeatures; i++) {
3677 if (cpuExpanded->features[i].policy == VIR_CPU_FEATURE_REQUIRE &&
3678 virCPUDefUpdateFeature(fullCPU, cpuExpanded->features[i].name,
3679 VIR_CPU_FEATURE_REQUIRE) < 0)
3680 goto error;
3681 }
3682 }
3683
3684 if (!(migCPU = virQEMUCapsNewHostCPUModel()))
3685 goto error;
3686
3687 if ((rc = virQEMUCapsInitCPUModel(qemuCaps, type, migCPU, true)) < 0) {
3688 goto error;
3689 } else if (rc == 1) {
3690 VIR_DEBUG("CPU migratability not provided by QEMU");
3691
3692 virCPUDefFree(migCPU);
3693 if (!(migCPU = virCPUCopyMigratable(qemuCaps->arch, cpu)))
3694 goto error;
3695 }
3696
3697 if (ARCH_IS_X86(qemuCaps->arch) &&
3698 !virQEMUCapsGet(qemuCaps, QEMU_CAPS_CPU_UNAVAILABLE_FEATURES)) {
3699 if (cpu &&
3700 virCPUDefFilterFeatures(cpu, virCPUx86FeatureFilterDropMSR, NULL) < 0)
3701 goto error;
3702
3703 if (migCPU &&
3704 virCPUDefFilterFeatures(migCPU, virCPUx86FeatureFilterDropMSR, NULL) < 0)
3705 goto error;
3706
3707 if (fullCPU &&
3708 virCPUDefFilterFeatures(fullCPU, virCPUx86FeatureFilterDropMSR, NULL) < 0)
3709 goto error;
3710 }
3711
3712 virQEMUCapsSetHostModel(qemuCaps, type, cpu, migCPU, fullCPU);
3713
3714 cleanup:
3715 virCPUDefFree(cpuExpanded);
3716 virCPUDefFree(hostCPU);
3717 return;
3718
3719 error:
3720 virCPUDefFree(cpu);
3721 virCPUDefFree(migCPU);
3722 virCPUDefFree(fullCPU);
3723 virResetLastError();
3724 goto cleanup;
3725 }
3726
3727
3728 void
virQEMUCapsUpdateHostCPUModel(virQEMUCaps * qemuCaps,virArch hostArch,virDomainVirtType type)3729 virQEMUCapsUpdateHostCPUModel(virQEMUCaps *qemuCaps,
3730 virArch hostArch,
3731 virDomainVirtType type)
3732 {
3733 virQEMUCapsHostCPUDataClear(&virQEMUCapsGetAccel(qemuCaps, type)->hostCPU);
3734 virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, type);
3735 }
3736
3737 qemuMonitorCPUModelInfo *
virQEMUCapsGetCPUModelInfo(virQEMUCaps * qemuCaps,virDomainVirtType type)3738 virQEMUCapsGetCPUModelInfo(virQEMUCaps *qemuCaps,
3739 virDomainVirtType type)
3740 {
3741 return virQEMUCapsGetAccel(qemuCaps, type)->hostCPU.info;
3742 }
3743
3744
3745 void
virQEMUCapsSetCPUModelInfo(virQEMUCaps * qemuCaps,virDomainVirtType type,qemuMonitorCPUModelInfo * modelInfo)3746 virQEMUCapsSetCPUModelInfo(virQEMUCaps *qemuCaps,
3747 virDomainVirtType type,
3748 qemuMonitorCPUModelInfo *modelInfo)
3749 {
3750 virQEMUCapsGetAccel(qemuCaps, type)->hostCPU.info = modelInfo;
3751 }
3752
3753
3754 static int
virQEMUCapsLoadHostCPUModelInfo(virQEMUCapsAccel * caps,xmlXPathContextPtr ctxt,const char * typeStr)3755 virQEMUCapsLoadHostCPUModelInfo(virQEMUCapsAccel *caps,
3756 xmlXPathContextPtr ctxt,
3757 const char *typeStr)
3758 {
3759 g_autofree char *migratability = NULL;
3760 xmlNodePtr hostCPUNode;
3761 g_autofree xmlNodePtr *nodes = NULL;
3762 VIR_XPATH_NODE_AUTORESTORE(ctxt)
3763 g_autoptr(qemuMonitorCPUModelInfo) hostCPU = NULL;
3764 g_autofree char *xpath = g_strdup_printf("./hostCPU[@type='%s']", typeStr);
3765 size_t i;
3766 int n;
3767 int val;
3768
3769 if (!(hostCPUNode = virXPathNode(xpath, ctxt))) {
3770 return 0;
3771 }
3772
3773 hostCPU = g_new0(qemuMonitorCPUModelInfo, 1);
3774
3775 if (!(hostCPU->name = virXMLPropString(hostCPUNode, "model"))) {
3776 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3777 _("missing host CPU model name in QEMU "
3778 "capabilities cache"));
3779 return -1;
3780 }
3781
3782 if (!(migratability = virXMLPropString(hostCPUNode, "migratability")) ||
3783 (val = virTristateBoolTypeFromString(migratability)) <= 0) {
3784 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3785 _("invalid migratability value for host CPU model"));
3786 return -1;
3787 }
3788 hostCPU->migratability = val == VIR_TRISTATE_BOOL_YES;
3789
3790 ctxt->node = hostCPUNode;
3791
3792 if ((n = virXPathNodeSet("./property", ctxt, &nodes)) > 0) {
3793 hostCPU->props = g_new0(qemuMonitorCPUProperty, n);
3794 hostCPU->nprops = n;
3795
3796 for (i = 0; i < n; i++) {
3797 qemuMonitorCPUProperty *prop = hostCPU->props + i;
3798 g_autofree char *type = NULL;
3799 g_autofree char *migratable = NULL;
3800
3801 ctxt->node = nodes[i];
3802
3803 if (!(prop->name = virXMLPropString(ctxt->node, "name"))) {
3804 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3805 _("missing 'name' attribute for a host CPU"
3806 " model property in QEMU capabilities cache"));
3807 return -1;
3808 }
3809
3810 if (!(type = virXMLPropString(ctxt->node, "type")) ||
3811 (val = qemuMonitorCPUPropertyTypeFromString(type)) < 0) {
3812 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3813 _("missing or invalid CPU model property type "
3814 "in QEMU capabilities cache"));
3815 return -1;
3816 }
3817
3818 prop->type = val;
3819 switch (prop->type) {
3820 case QEMU_MONITOR_CPU_PROPERTY_BOOLEAN:
3821 if (virXPathBoolean("./@value='true'", ctxt))
3822 prop->value.boolean = true;
3823 break;
3824
3825 case QEMU_MONITOR_CPU_PROPERTY_STRING:
3826 prop->value.string = virXMLPropString(ctxt->node, "value");
3827 if (!prop->value.string) {
3828 virReportError(VIR_ERR_INTERNAL_ERROR,
3829 _("invalid string value for '%s' host CPU "
3830 "model property in QEMU capabilities cache"),
3831 prop->name);
3832 return -1;
3833 }
3834 break;
3835
3836 case QEMU_MONITOR_CPU_PROPERTY_NUMBER:
3837 if (virXPathLongLong("string(./@value)", ctxt,
3838 &prop->value.number) < 0) {
3839 virReportError(VIR_ERR_INTERNAL_ERROR,
3840 _("invalid number value for '%s' host CPU "
3841 "model property in QEMU capabilities cache"),
3842 prop->name);
3843 return -1;
3844 }
3845 break;
3846
3847 case QEMU_MONITOR_CPU_PROPERTY_LAST:
3848 break;
3849 }
3850
3851 if ((migratable = virXMLPropString(ctxt->node, "migratable"))) {
3852 if ((val = virTristateBoolTypeFromString(migratable)) <= 0) {
3853 virReportError(VIR_ERR_INTERNAL_ERROR,
3854 _("unknown migratable value for '%s' host "
3855 "CPU model property"),
3856 prop->name);
3857 return -1;
3858 }
3859
3860 prop->migratable = val;
3861 }
3862 }
3863 }
3864
3865 caps->hostCPU.info = g_steal_pointer(&hostCPU);
3866 return 0;
3867 }
3868
3869
3870 static int
virQEMUCapsLoadCPUModels(virQEMUCapsAccel * caps,xmlXPathContextPtr ctxt,const char * typeStr)3871 virQEMUCapsLoadCPUModels(virQEMUCapsAccel *caps,
3872 xmlXPathContextPtr ctxt,
3873 const char *typeStr)
3874 {
3875 g_autoptr(qemuMonitorCPUDefs) defs = NULL;
3876 g_autofree xmlNodePtr * nodes = NULL;
3877 g_autofree char *xpath = g_strdup_printf("./cpu[@type='%s']", typeStr);
3878 size_t i;
3879 int n;
3880 xmlNodePtr node;
3881
3882 if ((n = virXPathNodeSet(xpath, ctxt, &nodes)) < 0) {
3883 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3884 _("failed to parse qemu capabilities cpus"));
3885 return -1;
3886 }
3887
3888 if (n == 0)
3889 return 0;
3890
3891 if (!(defs = qemuMonitorCPUDefsNew(n)))
3892 return -1;
3893
3894 for (i = 0; i < n; i++) {
3895 qemuMonitorCPUDefInfo *cpu = defs->cpus + i;
3896 int usable = VIR_DOMCAPS_CPU_USABLE_UNKNOWN;
3897 g_autofree char * strUsable = NULL;
3898 g_autofree xmlNodePtr * blockerNodes = NULL;
3899 g_autofree char *deprecated = NULL;
3900 int nblockers;
3901
3902 if ((strUsable = virXMLPropString(nodes[i], "usable")) &&
3903 (usable = virDomainCapsCPUUsableTypeFromString(strUsable)) < 0) {
3904 virReportError(VIR_ERR_INTERNAL_ERROR,
3905 _("unknown value '%s' in attribute 'usable'"),
3906 strUsable);
3907 return -1;
3908 }
3909 cpu->usable = usable;
3910
3911 if (!(cpu->name = virXMLPropString(nodes[i], "name"))) {
3912 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3913 _("missing cpu name in QEMU capabilities cache"));
3914 return -1;
3915 }
3916
3917 cpu->type = virXMLPropString(nodes[i], "typename");
3918
3919 node = ctxt->node;
3920 ctxt->node = nodes[i];
3921 nblockers = virXPathNodeSet("./blocker", ctxt, &blockerNodes);
3922 ctxt->node = node;
3923
3924 if (nblockers < 0) {
3925 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3926 _("failed to parse CPU blockers in QEMU capabilities"));
3927 return -1;
3928 }
3929
3930 if (nblockers > 0) {
3931 size_t j;
3932
3933 cpu->blockers = g_new0(char *, nblockers + 1);
3934
3935 for (j = 0; j < nblockers; j++) {
3936 if (!(cpu->blockers[j] = virXMLPropString(blockerNodes[j], "name"))) {
3937 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3938 _("missing blocker name in QEMU "
3939 "capabilities cache"));
3940 return -1;
3941 }
3942 }
3943 }
3944
3945 deprecated = virXMLPropString(nodes[i], "deprecated");
3946 if (deprecated &&
3947 STREQ(deprecated, "yes"))
3948 cpu->deprecated = true;
3949 }
3950
3951 caps->cpuModels = g_steal_pointer(&defs);
3952 return 0;
3953 }
3954
3955
3956 static int
virQEMUCapsLoadMachines(virQEMUCapsAccel * caps,xmlXPathContextPtr ctxt,const char * typeStr)3957 virQEMUCapsLoadMachines(virQEMUCapsAccel *caps,
3958 xmlXPathContextPtr ctxt,
3959 const char *typeStr)
3960 {
3961 g_autofree char *xpath = g_strdup_printf("./machine[@type='%s']", typeStr);
3962 g_autofree xmlNodePtr *nodes = NULL;
3963 size_t i;
3964 int n;
3965
3966 if ((n = virXPathNodeSet(xpath, ctxt, &nodes)) < 0) {
3967 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3968 _("failed to parse qemu capabilities machines"));
3969 return -1;
3970 }
3971
3972 if (n == 0)
3973 return 0;
3974
3975 caps->nmachineTypes = n;
3976 caps->machineTypes = g_new0(virQEMUCapsMachineType, caps->nmachineTypes);
3977
3978 for (i = 0; i < n; i++) {
3979 g_autofree char *str = NULL;
3980
3981 if (!(caps->machineTypes[i].name = virXMLPropString(nodes[i], "name"))) {
3982 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3983 _("missing machine name in QEMU capabilities cache"));
3984 return -1;
3985 }
3986 caps->machineTypes[i].alias = virXMLPropString(nodes[i], "alias");
3987
3988 str = virXMLPropString(nodes[i], "maxCpus");
3989 if (str &&
3990 virStrToLong_ui(str, NULL, 10, &(caps->machineTypes[i].maxCpus)) < 0) {
3991 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3992 _("malformed machine cpu count in QEMU capabilities cache"));
3993 return -1;
3994 }
3995 VIR_FREE(str);
3996
3997 str = virXMLPropString(nodes[i], "hotplugCpus");
3998 if (STREQ_NULLABLE(str, "yes"))
3999 caps->machineTypes[i].hotplugCpus = true;
4000 VIR_FREE(str);
4001
4002 str = virXMLPropString(nodes[i], "default");
4003 if (STREQ_NULLABLE(str, "yes"))
4004 caps->machineTypes[i].qemuDefault = true;
4005 VIR_FREE(str);
4006
4007 str = virXMLPropString(nodes[i], "numaMemSupported");
4008 if (STREQ_NULLABLE(str, "yes"))
4009 caps->machineTypes[i].numaMemSupported = true;
4010 VIR_FREE(str);
4011
4012 caps->machineTypes[i].defaultCPU = virXMLPropString(nodes[i], "defaultCPU");
4013 caps->machineTypes[i].defaultRAMid = virXMLPropString(nodes[i], "defaultRAMid");
4014
4015 str = virXMLPropString(nodes[i], "deprecated");
4016 if (STREQ_NULLABLE(str, "yes"))
4017 caps->machineTypes[i].deprecated = true;
4018 VIR_FREE(str);
4019 }
4020
4021 return 0;
4022 }
4023
4024
4025 static int
virQEMUCapsLoadAccel(virQEMUCaps * qemuCaps,xmlXPathContextPtr ctxt,virDomainVirtType type)4026 virQEMUCapsLoadAccel(virQEMUCaps *qemuCaps,
4027 xmlXPathContextPtr ctxt,
4028 virDomainVirtType type)
4029 {
4030 virQEMUCapsAccel *caps = virQEMUCapsGetAccel(qemuCaps, type);
4031 const char *typeStr;
4032
4033 if (type == VIR_DOMAIN_VIRT_KVM)
4034 typeStr = "kvm";
4035 else if (type == VIR_DOMAIN_VIRT_NVMM)
4036 typeStr = "nvmm";
4037 else
4038 typeStr = "tcg";
4039
4040 if (virQEMUCapsLoadHostCPUModelInfo(caps, ctxt, typeStr) < 0)
4041 return -1;
4042
4043 if (virQEMUCapsLoadCPUModels(caps, ctxt, typeStr) < 0)
4044 return -1;
4045
4046 if (virQEMUCapsLoadMachines(caps, ctxt, typeStr) < 0)
4047 return -1;
4048
4049 return 0;
4050 }
4051
4052
4053 struct _virQEMUCapsCachePriv {
4054 char *libDir;
4055 uid_t runUid;
4056 gid_t runGid;
4057 virArch hostArch;
4058 unsigned int microcodeVersion;
4059 virCPUData *cpuData;
4060 char *kernelVersion;
4061 char *hostCPUSignature;
4062
4063 /* cache whether /dev/kvm is usable as runUid:runGuid */
4064 virTristateBool kvmUsable;
4065 time_t kvmCtime;
4066 };
4067 typedef struct _virQEMUCapsCachePriv virQEMUCapsCachePriv;
4068
4069
4070 static void
virQEMUCapsCachePrivFree(void * privData)4071 virQEMUCapsCachePrivFree(void *privData)
4072 {
4073 virQEMUCapsCachePriv *priv = privData;
4074
4075 g_free(priv->libDir);
4076 g_free(priv->kernelVersion);
4077 virCPUDataFree(priv->cpuData);
4078 g_free(priv->hostCPUSignature);
4079 g_free(priv);
4080 }
4081
4082
4083 static int
virQEMUCapsParseSEVInfo(virQEMUCaps * qemuCaps,xmlXPathContextPtr ctxt)4084 virQEMUCapsParseSEVInfo(virQEMUCaps *qemuCaps, xmlXPathContextPtr ctxt)
4085 {
4086 g_autoptr(virSEVCapability) sev = NULL;
4087
4088 if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SEV_GUEST))
4089 return 0;
4090
4091 if (virXPathBoolean("boolean(./sev)", ctxt) == 0) {
4092 virReportError(VIR_ERR_XML_ERROR, "%s",
4093 _("missing SEV platform data in QEMU "
4094 "capabilities cache"));
4095 return -1;
4096 }
4097
4098 sev = g_new0(virSEVCapability, 1);
4099
4100 if (virXPathUInt("string(./sev/cbitpos)", ctxt, &sev->cbitpos) < 0) {
4101 virReportError(VIR_ERR_XML_ERROR, "%s",
4102 _("missing or malformed SEV cbitpos information "
4103 "in QEMU capabilities cache"));
4104 return -1;
4105 }
4106
4107 if (virXPathUInt("string(./sev/reducedPhysBits)", ctxt,
4108 &sev->reduced_phys_bits) < 0) {
4109 virReportError(VIR_ERR_XML_ERROR, "%s",
4110 _("missing or malformed SEV reducedPhysBits information "
4111 "in QEMU capabilities cache"));
4112 return -1;
4113 }
4114
4115 if (!(sev->pdh = virXPathString("string(./sev/pdh)", ctxt))) {
4116 virReportError(VIR_ERR_XML_ERROR, "%s",
4117 _("missing SEV pdh information "
4118 "in QEMU capabilities cache"));
4119 return -1;
4120 }
4121
4122 if (!(sev->cert_chain = virXPathString("string(./sev/certChain)", ctxt))) {
4123 virReportError(VIR_ERR_XML_ERROR, "%s",
4124 _("missing SEV certChain information "
4125 "in QEMU capabilities cache"));
4126 return -1;
4127 }
4128
4129 qemuCaps->sevCapabilities = g_steal_pointer(&sev);
4130 return 0;
4131 }
4132
4133
4134 static int
virQEMUCapsParseFlags(virQEMUCaps * qemuCaps,xmlXPathContextPtr ctxt)4135 virQEMUCapsParseFlags(virQEMUCaps *qemuCaps, xmlXPathContextPtr ctxt)
4136 {
4137 g_autofree xmlNodePtr *nodes = NULL;
4138 size_t i;
4139 int n;
4140
4141 if ((n = virXPathNodeSet("./flag", ctxt, &nodes)) < 0) {
4142 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
4143 _("failed to parse qemu capabilities flags"));
4144 return -1;
4145 }
4146
4147 VIR_DEBUG("Got flags %d", n);
4148 for (i = 0; i < n; i++) {
4149 g_autofree char *str = NULL;
4150 int flag;
4151
4152 if (!(str = virXMLPropString(nodes[i], "name"))) {
4153 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
4154 _("missing flag name in QEMU capabilities cache"));
4155 return -1;
4156 }
4157
4158 flag = virQEMUCapsTypeFromString(str);
4159 if (flag < 0) {
4160 virReportError(VIR_ERR_INTERNAL_ERROR,
4161 _("Unknown qemu capabilities flag %s"), str);
4162 return -1;
4163 }
4164
4165 virQEMUCapsSet(qemuCaps, flag);
4166 }
4167
4168 return 0;
4169 }
4170
4171
4172 static int
virQEMUCapsParseGIC(virQEMUCaps * qemuCaps,xmlXPathContextPtr ctxt)4173 virQEMUCapsParseGIC(virQEMUCaps *qemuCaps, xmlXPathContextPtr ctxt)
4174 {
4175 g_autofree xmlNodePtr *nodes = NULL;
4176 size_t i;
4177 int n;
4178
4179 if ((n = virXPathNodeSet("./gic", ctxt, &nodes)) < 0) {
4180 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
4181 _("failed to parse qemu capabilities gic"));
4182 return -1;
4183 }
4184
4185 if (n > 0) {
4186 unsigned int uintValue;
4187 bool boolValue;
4188
4189 qemuCaps->ngicCapabilities = n;
4190 qemuCaps->gicCapabilities = g_new0(virGICCapability, n);
4191
4192 for (i = 0; i < n; i++) {
4193 virGICCapability *cap = &qemuCaps->gicCapabilities[i];
4194 g_autofree char *version = NULL;
4195 g_autofree char *kernel = NULL;
4196 g_autofree char *emulated = NULL;
4197
4198 if (!(version = virXMLPropString(nodes[i], "version"))) {
4199 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
4200 _("missing GIC version "
4201 "in QEMU capabilities cache"));
4202 return -1;
4203 }
4204 if (virStrToLong_ui(version, NULL, 10, &uintValue) < 0) {
4205 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
4206 _("malformed GIC version "
4207 "in QEMU capabilities cache"));
4208 return -1;
4209 }
4210 cap->version = uintValue;
4211
4212 if (!(kernel = virXMLPropString(nodes[i], "kernel"))) {
4213 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
4214 _("missing in-kernel GIC information "
4215 "in QEMU capabilities cache"));
4216 return -1;
4217 }
4218 if (!(boolValue = STREQ(kernel, "yes")) && STRNEQ(kernel, "no")) {
4219 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
4220 _("malformed in-kernel GIC information "
4221 "in QEMU capabilities cache"));
4222 return -1;
4223 }
4224 if (boolValue)
4225 cap->implementation |= VIR_GIC_IMPLEMENTATION_KERNEL;
4226
4227 if (!(emulated = virXMLPropString(nodes[i], "emulated"))) {
4228 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
4229 _("missing emulated GIC information "
4230 "in QEMU capabilities cache"));
4231 return -1;
4232 }
4233 if (!(boolValue = STREQ(emulated, "yes")) && STRNEQ(emulated, "no")) {
4234 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
4235 _("malformed emulated GIC information "
4236 "in QEMU capabilities cache"));
4237 return -1;
4238 }
4239 if (boolValue)
4240 cap->implementation |= VIR_GIC_IMPLEMENTATION_EMULATED;
4241 }
4242 }
4243
4244 return 0;
4245 }
4246
4247
4248 static int
virQEMUCapsValidateEmulator(virQEMUCaps * qemuCaps,xmlXPathContextPtr ctxt)4249 virQEMUCapsValidateEmulator(virQEMUCaps *qemuCaps, xmlXPathContextPtr ctxt)
4250 {
4251 g_autofree char *str = NULL;
4252
4253 if (!(str = virXPathString("string(./emulator)", ctxt))) {
4254 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
4255 _("missing emulator in QEMU capabilities cache"));
4256 return -1;
4257 }
4258
4259 if (STRNEQ(str, qemuCaps->binary)) {
4260 virReportError(VIR_ERR_INTERNAL_ERROR,
4261 _("Expected caps for '%s' but saw '%s'"),
4262 qemuCaps->binary, str);
4263 return -1;
4264 }
4265
4266 return 0;
4267 }
4268
4269
4270 static int
virQEMUCapsValidateArch(virQEMUCaps * qemuCaps,xmlXPathContextPtr ctxt)4271 virQEMUCapsValidateArch(virQEMUCaps *qemuCaps, xmlXPathContextPtr ctxt)
4272 {
4273 g_autofree char *str = NULL;
4274
4275 if (!(str = virXPathString("string(./arch)", ctxt))) {
4276 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
4277 _("missing arch in QEMU capabilities cache"));
4278 return -1;
4279 }
4280 if (!(qemuCaps->arch = virArchFromString(str))) {
4281 virReportError(VIR_ERR_INTERNAL_ERROR,
4282 _("unknown arch %s in QEMU capabilities cache"), str);
4283 return -1;
4284 }
4285
4286 return 0;
4287 }
4288
4289
4290 /*
4291 * Parsing a doc that looks like
4292 *
4293 * <qemuCaps>
4294 * <emulator>/some/path</emulator>
4295 * <qemuctime>234235253</qemuctime>
4296 * <qemumoddirmtime>234235253</qemumoddirmtime>
4297 * <selfctime>234235253</selfctime>
4298 * <selfvers>1002016</selfvers>
4299 * <flag name='foo'/>
4300 * <flag name='bar'/>
4301 * ...
4302 * <cpu name="pentium3"/>
4303 * ...
4304 * <machine name='pc-1.0' alias='pc' hotplugCpus='yes' maxCpus='4' default='yes' numaMemSupported='yes'/>
4305 * ...
4306 * </qemuCaps>
4307 *
4308 * Returns 0 on success, 1 if outdated, -1 on error
4309 */
4310 int
virQEMUCapsLoadCache(virArch hostArch,virQEMUCaps * qemuCaps,const char * filename,bool skipInvalidation)4311 virQEMUCapsLoadCache(virArch hostArch,
4312 virQEMUCaps *qemuCaps,
4313 const char *filename,
4314 bool skipInvalidation)
4315 {
4316 g_autoptr(xmlDoc) doc = NULL;
4317 g_autoptr(xmlXPathContext) ctxt = NULL;
4318 long long int l;
4319 unsigned long lu;
4320
4321 if (!(doc = virXMLParseFile(filename)))
4322 return -1;
4323
4324 if (!(ctxt = virXMLXPathContextNew(doc)))
4325 return -1;
4326
4327 ctxt->node = xmlDocGetRootElement(doc);
4328
4329 if (STRNEQ((const char *)ctxt->node->name, "qemuCaps")) {
4330 virReportError(VIR_ERR_XML_ERROR,
4331 _("unexpected root element <%s>, "
4332 "expecting <qemuCaps>"),
4333 ctxt->node->name);
4334 return -1;
4335 }
4336
4337 if (virXPathLongLong("string(./selfctime)", ctxt, &l) < 0) {
4338 virReportError(VIR_ERR_XML_ERROR, "%s",
4339 _("missing selfctime in QEMU capabilities XML"));
4340 return -1;
4341 }
4342 qemuCaps->libvirtCtime = (time_t)l;
4343
4344 qemuCaps->libvirtVersion = 0;
4345 if (virXPathULong("string(./selfvers)", ctxt, &lu) == 0)
4346 qemuCaps->libvirtVersion = lu;
4347
4348 if (!skipInvalidation &&
4349 (qemuCaps->libvirtCtime != virGetSelfLastChanged() ||
4350 qemuCaps->libvirtVersion != LIBVIR_VERSION_NUMBER)) {
4351 VIR_DEBUG("Outdated capabilities in %s: libvirt changed "
4352 "(%lld vs %lld, %lu vs %lu), stopping load",
4353 qemuCaps->binary,
4354 (long long)qemuCaps->libvirtCtime,
4355 (long long)virGetSelfLastChanged(),
4356 (unsigned long)qemuCaps->libvirtVersion,
4357 (unsigned long)LIBVIR_VERSION_NUMBER);
4358 return 1;
4359 }
4360
4361 if (virQEMUCapsValidateEmulator(qemuCaps, ctxt) < 0)
4362 return -1;
4363
4364 if (virXPathLongLong("string(./qemuctime)", ctxt, &l) < 0) {
4365 virReportError(VIR_ERR_XML_ERROR, "%s",
4366 _("missing qemuctime in QEMU capabilities XML"));
4367 return -1;
4368 }
4369 qemuCaps->ctime = (time_t)l;
4370
4371 if (virXPathLongLong("string(./qemumoddirmtime)", ctxt, &l) == 0)
4372 qemuCaps->modDirMtime = (time_t)l;
4373
4374 if (virQEMUCapsParseFlags(qemuCaps, ctxt) < 0)
4375 return -1;
4376
4377 if (virXPathUInt("string(./version)", ctxt, &qemuCaps->version) < 0) {
4378 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
4379 _("missing version in QEMU capabilities cache"));
4380 return -1;
4381 }
4382
4383 if (virXPathUInt("string(./kvmVersion)", ctxt, &qemuCaps->kvmVersion) < 0) {
4384 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
4385 _("missing version in QEMU capabilities cache"));
4386 return -1;
4387 }
4388
4389 if (virXPathUInt("string(./microcodeVersion)", ctxt,
4390 &qemuCaps->microcodeVersion) < 0) {
4391 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
4392 _("missing microcode version in QEMU capabilities cache"));
4393 return -1;
4394 }
4395
4396 qemuCaps->hostCPUSignature = virXPathString("string(./hostCPUSignature)", ctxt);
4397
4398 if (virXPathBoolean("boolean(./package)", ctxt) > 0) {
4399 qemuCaps->package = virXPathString("string(./package)", ctxt);
4400 if (!qemuCaps->package)
4401 qemuCaps->package = g_strdup("");
4402 }
4403
4404 if (virXPathBoolean("boolean(./kernelVersion)", ctxt) > 0) {
4405 qemuCaps->kernelVersion = virXPathString("string(./kernelVersion)", ctxt);
4406 if (!qemuCaps->kernelVersion)
4407 return -1;
4408 }
4409
4410 if (virQEMUCapsValidateArch(qemuCaps, ctxt) < 0)
4411 return -1;
4412
4413 if (virXPathBoolean("boolean(./cpudata)", ctxt) > 0) {
4414 qemuCaps->cpuData = virCPUDataParseNode(virXPathNode("./cpudata", ctxt));
4415 if (!qemuCaps->cpuData)
4416 return -1;
4417 }
4418
4419 if (virQEMUCapsLoadAccel(qemuCaps, ctxt, VIR_DOMAIN_VIRT_KVM) < 0 ||
4420 virQEMUCapsLoadAccel(qemuCaps, ctxt, VIR_DOMAIN_VIRT_NVMM) < 0 ||
4421 virQEMUCapsLoadAccel(qemuCaps, ctxt, VIR_DOMAIN_VIRT_QEMU) < 0)
4422 return -1;
4423
4424 if (virQEMUCapsParseGIC(qemuCaps, ctxt) < 0)
4425 return -1;
4426
4427 if (virQEMUCapsParseSEVInfo(qemuCaps, ctxt) < 0)
4428 return -1;
4429
4430 virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_KVM);
4431 virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_NVMM);
4432 virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_QEMU);
4433
4434 if (virXPathBoolean("boolean(./kvmSupportsNesting)", ctxt) > 0)
4435 qemuCaps->kvmSupportsNesting = true;
4436
4437 if (virXPathBoolean("boolean(./kvmSupportsSecureGuest)", ctxt) > 0)
4438 qemuCaps->kvmSupportsSecureGuest = true;
4439
4440 if (skipInvalidation)
4441 qemuCaps->invalidation = false;
4442
4443 return 0;
4444 }
4445
4446
4447 static void
virQEMUCapsFormatHostCPUModelInfo(virQEMUCapsAccel * caps,virBuffer * buf,const char * typeStr)4448 virQEMUCapsFormatHostCPUModelInfo(virQEMUCapsAccel *caps,
4449 virBuffer *buf,
4450 const char *typeStr)
4451 {
4452 qemuMonitorCPUModelInfo *model = caps->hostCPU.info;
4453 size_t i;
4454
4455 if (!model)
4456 return;
4457
4458 virBufferAsprintf(buf,
4459 "<hostCPU type='%s' model='%s' migratability='%s'>\n",
4460 typeStr, model->name,
4461 model->migratability ? "yes" : "no");
4462 virBufferAdjustIndent(buf, 2);
4463
4464 for (i = 0; i < model->nprops; i++) {
4465 qemuMonitorCPUProperty *prop = model->props + i;
4466
4467 virBufferAsprintf(buf, "<property name='%s' type='%s' ",
4468 prop->name,
4469 qemuMonitorCPUPropertyTypeToString(prop->type));
4470
4471 switch (prop->type) {
4472 case QEMU_MONITOR_CPU_PROPERTY_BOOLEAN:
4473 virBufferAsprintf(buf, "value='%s'",
4474 prop->value.boolean ? "true" : "false");
4475 break;
4476
4477 case QEMU_MONITOR_CPU_PROPERTY_STRING:
4478 virBufferEscapeString(buf, "value='%s'", prop->value.string);
4479 break;
4480
4481 case QEMU_MONITOR_CPU_PROPERTY_NUMBER:
4482 virBufferAsprintf(buf, "value='%lld'", prop->value.number);
4483 break;
4484
4485 case QEMU_MONITOR_CPU_PROPERTY_LAST:
4486 break;
4487 }
4488
4489 if (prop->migratable > 0)
4490 virBufferAsprintf(buf, " migratable='%s'",
4491 virTristateBoolTypeToString(prop->migratable));
4492
4493 virBufferAddLit(buf, "/>\n");
4494 }
4495
4496 virBufferAdjustIndent(buf, -2);
4497 virBufferAddLit(buf, "</hostCPU>\n");
4498 }
4499
4500
4501 static void
virQEMUCapsFormatCPUModels(virQEMUCapsAccel * caps,virBuffer * buf,const char * typeStr)4502 virQEMUCapsFormatCPUModels(virQEMUCapsAccel *caps,
4503 virBuffer *buf,
4504 const char *typeStr)
4505 {
4506 qemuMonitorCPUDefs *defs = caps->cpuModels;
4507 size_t i;
4508
4509 if (!defs)
4510 return;
4511
4512 for (i = 0; i < defs->ncpus; i++) {
4513 qemuMonitorCPUDefInfo *cpu = defs->cpus + i;
4514
4515 virBufferAsprintf(buf, "<cpu type='%s' ", typeStr);
4516 virBufferEscapeString(buf, "name='%s'", cpu->name);
4517 virBufferEscapeString(buf, " typename='%s'", cpu->type);
4518 if (cpu->usable) {
4519 virBufferAsprintf(buf, " usable='%s'",
4520 virDomainCapsCPUUsableTypeToString(cpu->usable));
4521 }
4522 if (cpu->deprecated)
4523 virBufferAddLit(buf, " deprecated='yes'");
4524
4525 if (cpu->blockers) {
4526 size_t j;
4527
4528 virBufferAddLit(buf, ">\n");
4529 virBufferAdjustIndent(buf, 2);
4530
4531 for (j = 0; cpu->blockers[j]; j++)
4532 virBufferAsprintf(buf, "<blocker name='%s'/>\n", cpu->blockers[j]);
4533
4534 virBufferAdjustIndent(buf, -2);
4535 virBufferAddLit(buf, "</cpu>\n");
4536 } else {
4537 virBufferAddLit(buf, "/>\n");
4538 }
4539 }
4540 }
4541
4542
4543 static void
virQEMUCapsFormatMachines(virQEMUCapsAccel * caps,virBuffer * buf,const char * typeStr)4544 virQEMUCapsFormatMachines(virQEMUCapsAccel *caps,
4545 virBuffer *buf,
4546 const char *typeStr)
4547 {
4548 size_t i;
4549
4550 for (i = 0; i < caps->nmachineTypes; i++) {
4551 virBufferAsprintf(buf, "<machine type='%s'", typeStr);
4552 virBufferEscapeString(buf, " name='%s'",
4553 caps->machineTypes[i].name);
4554 virBufferEscapeString(buf, " alias='%s'",
4555 caps->machineTypes[i].alias);
4556 if (caps->machineTypes[i].hotplugCpus)
4557 virBufferAddLit(buf, " hotplugCpus='yes'");
4558 virBufferAsprintf(buf, " maxCpus='%u'",
4559 caps->machineTypes[i].maxCpus);
4560 if (caps->machineTypes[i].qemuDefault)
4561 virBufferAddLit(buf, " default='yes'");
4562 virBufferEscapeString(buf, " defaultCPU='%s'",
4563 caps->machineTypes[i].defaultCPU);
4564 if (caps->machineTypes[i].numaMemSupported)
4565 virBufferAddLit(buf, " numaMemSupported='yes'");
4566 virBufferEscapeString(buf, " defaultRAMid='%s'",
4567 caps->machineTypes[i].defaultRAMid);
4568 if (caps->machineTypes[i].deprecated)
4569 virBufferAddLit(buf, " deprecated='yes'");
4570 virBufferAddLit(buf, "/>\n");
4571 }
4572 }
4573
4574
4575 static void
virQEMUCapsFormatAccel(virQEMUCaps * qemuCaps,virBuffer * buf,virDomainVirtType type)4576 virQEMUCapsFormatAccel(virQEMUCaps *qemuCaps,
4577 virBuffer *buf,
4578 virDomainVirtType type)
4579 {
4580 virQEMUCapsAccel *caps = virQEMUCapsGetAccel(qemuCaps, type);
4581 const char *typeStr;
4582
4583 if (type == VIR_DOMAIN_VIRT_KVM)
4584 typeStr = "kvm";
4585 else if (type == VIR_DOMAIN_VIRT_NVMM)
4586 typeStr = "nvmm";
4587 else
4588 typeStr = "tcg";
4589
4590 virQEMUCapsFormatHostCPUModelInfo(caps, buf, typeStr);
4591 virQEMUCapsFormatCPUModels(caps, buf, typeStr);
4592 virQEMUCapsFormatMachines(caps, buf, typeStr);
4593
4594 }
4595
4596
4597 static void
virQEMUCapsFormatSEVInfo(virQEMUCaps * qemuCaps,virBuffer * buf)4598 virQEMUCapsFormatSEVInfo(virQEMUCaps *qemuCaps, virBuffer *buf)
4599 {
4600 virSEVCapability *sev = virQEMUCapsGetSEVCapabilities(qemuCaps);
4601
4602 virBufferAddLit(buf, "<sev>\n");
4603 virBufferAdjustIndent(buf, 2);
4604 virBufferAsprintf(buf, "<cbitpos>%u</cbitpos>\n", sev->cbitpos);
4605 virBufferAsprintf(buf, "<reducedPhysBits>%u</reducedPhysBits>\n",
4606 sev->reduced_phys_bits);
4607 virBufferEscapeString(buf, "<pdh>%s</pdh>\n", sev->pdh);
4608 virBufferEscapeString(buf, "<certChain>%s</certChain>\n",
4609 sev->cert_chain);
4610 virBufferAdjustIndent(buf, -2);
4611 virBufferAddLit(buf, "</sev>\n");
4612 }
4613
4614
4615 char *
virQEMUCapsFormatCache(virQEMUCaps * qemuCaps)4616 virQEMUCapsFormatCache(virQEMUCaps *qemuCaps)
4617 {
4618 g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
4619 size_t i;
4620
4621 virBufferAddLit(&buf, "<qemuCaps>\n");
4622 virBufferAdjustIndent(&buf, 2);
4623
4624 virBufferEscapeString(&buf, "<emulator>%s</emulator>\n",
4625 qemuCaps->binary);
4626 virBufferAsprintf(&buf, "<qemuctime>%llu</qemuctime>\n",
4627 (long long)qemuCaps->ctime);
4628 if (qemuCaps->modDirMtime > 0) {
4629 virBufferAsprintf(&buf, "<qemumoddirmtime>%llu</qemumoddirmtime>\n",
4630 (long long)qemuCaps->modDirMtime);
4631 }
4632 virBufferAsprintf(&buf, "<selfctime>%llu</selfctime>\n",
4633 (long long)qemuCaps->libvirtCtime);
4634 virBufferAsprintf(&buf, "<selfvers>%lu</selfvers>\n",
4635 (unsigned long)qemuCaps->libvirtVersion);
4636
4637 for (i = 0; i < QEMU_CAPS_LAST; i++) {
4638 if (virQEMUCapsGet(qemuCaps, i)) {
4639 virBufferAsprintf(&buf, "<flag name='%s'/>\n",
4640 virQEMUCapsTypeToString(i));
4641 }
4642 }
4643
4644 virBufferAsprintf(&buf, "<version>%d</version>\n",
4645 qemuCaps->version);
4646
4647 virBufferAsprintf(&buf, "<kvmVersion>%d</kvmVersion>\n",
4648 qemuCaps->kvmVersion);
4649
4650 virBufferAsprintf(&buf, "<microcodeVersion>%u</microcodeVersion>\n",
4651 qemuCaps->microcodeVersion);
4652 virBufferEscapeString(&buf, "<hostCPUSignature>%s</hostCPUSignature>\n",
4653 qemuCaps->hostCPUSignature);
4654
4655 if (qemuCaps->package)
4656 virBufferAsprintf(&buf, "<package>%s</package>\n",
4657 qemuCaps->package);
4658
4659 if (qemuCaps->kernelVersion)
4660 virBufferAsprintf(&buf, "<kernelVersion>%s</kernelVersion>\n",
4661 qemuCaps->kernelVersion);
4662
4663 if (qemuCaps->cpuData) {
4664 g_autofree char * cpudata = virCPUDataFormat(qemuCaps->cpuData);
4665 virBufferAsprintf(&buf, "%s", cpudata);
4666 }
4667
4668 virBufferAsprintf(&buf, "<arch>%s</arch>\n",
4669 virArchToString(qemuCaps->arch));
4670
4671 virQEMUCapsFormatAccel(qemuCaps, &buf, VIR_DOMAIN_VIRT_KVM);
4672 virQEMUCapsFormatAccel(qemuCaps, &buf, VIR_DOMAIN_VIRT_NVMM);
4673 virQEMUCapsFormatAccel(qemuCaps, &buf, VIR_DOMAIN_VIRT_QEMU);
4674
4675 for (i = 0; i < qemuCaps->ngicCapabilities; i++) {
4676 virGICCapability *cap;
4677 bool kernel;
4678 bool emulated;
4679
4680 cap = &qemuCaps->gicCapabilities[i];
4681 kernel = (cap->implementation & VIR_GIC_IMPLEMENTATION_KERNEL);
4682 emulated = (cap->implementation & VIR_GIC_IMPLEMENTATION_EMULATED);
4683
4684 virBufferAsprintf(&buf,
4685 "<gic version='%d' kernel='%s' emulated='%s'/>\n",
4686 cap->version,
4687 kernel ? "yes" : "no",
4688 emulated ? "yes" : "no");
4689 }
4690
4691 if (qemuCaps->sevCapabilities)
4692 virQEMUCapsFormatSEVInfo(qemuCaps, &buf);
4693
4694 if (qemuCaps->kvmSupportsNesting)
4695 virBufferAddLit(&buf, "<kvmSupportsNesting/>\n");
4696
4697 if (qemuCaps->kvmSupportsSecureGuest)
4698 virBufferAddLit(&buf, "<kvmSupportsSecureGuest/>\n");
4699
4700 virBufferAdjustIndent(&buf, -2);
4701 virBufferAddLit(&buf, "</qemuCaps>\n");
4702
4703 return virBufferContentAndReset(&buf);
4704 }
4705
4706
4707 static int
virQEMUCapsSaveFile(void * data,const char * filename,void * privData G_GNUC_UNUSED)4708 virQEMUCapsSaveFile(void *data,
4709 const char *filename,
4710 void *privData G_GNUC_UNUSED)
4711 {
4712 virQEMUCaps *qemuCaps = data;
4713 g_autofree char *xml = NULL;
4714
4715 xml = virQEMUCapsFormatCache(qemuCaps);
4716
4717 if (virFileWriteStr(filename, xml, 0600) < 0) {
4718 virReportSystemError(errno,
4719 _("Failed to save '%s' for '%s'"),
4720 filename, qemuCaps->binary);
4721 return -1;
4722 }
4723
4724 VIR_DEBUG("Saved caps '%s' for '%s' with (%lld, %lld)",
4725 filename, qemuCaps->binary,
4726 (long long)qemuCaps->ctime,
4727 (long long)qemuCaps->libvirtCtime);
4728
4729 return 0;
4730 }
4731
4732
4733 /*
4734 * Check whether IBM Secure Execution (S390) is enabled
4735 */
4736 static bool
virQEMUCapsKVMSupportsSecureGuestS390(void)4737 virQEMUCapsKVMSupportsSecureGuestS390(void)
4738 {
4739
4740 g_autofree char *cmdline = NULL;
4741 static const char *kValues[] = {"y", "Y", "on", "ON", "oN", "On", "1"};
4742
4743 if (!virFileIsDir("/sys/firmware/uv"))
4744 return false;
4745
4746 if (virFileReadValueString(&cmdline, "/proc/cmdline") < 0)
4747 return false;
4748
4749 /* we're prefix matching rather than equality matching here, because kernel
4750 * would treat even something like prot_virt='yFOO' as enabled */
4751 if (virKernelCmdlineMatchParam(cmdline, "prot_virt", kValues,
4752 G_N_ELEMENTS(kValues),
4753 VIR_KERNEL_CMDLINE_FLAGS_SEARCH_FIRST |
4754 VIR_KERNEL_CMDLINE_FLAGS_CMP_PREFIX))
4755 return true;
4756
4757 return false;
4758 }
4759
4760
4761 /*
4762 * Check whether AMD Secure Encrypted Virtualization (x86) is enabled
4763 */
4764 static bool
virQEMUCapsKVMSupportsSecureGuestAMD(void)4765 virQEMUCapsKVMSupportsSecureGuestAMD(void)
4766 {
4767 g_autofree char *modValue = NULL;
4768
4769 if (virFileReadValueString(&modValue, "/sys/module/kvm_amd/parameters/sev") < 0)
4770 return false;
4771
4772 if (modValue[0] != '1' && modValue[0] != 'Y' && modValue[0] != 'y')
4773 return false;
4774
4775 if (virFileExists(QEMU_DEV_SEV))
4776 return true;
4777
4778 return false;
4779 }
4780
4781
4782 /*
4783 * Check whether the secure guest functionality is enabled.
4784 * See the specific architecture function for details on the verifications made.
4785 */
4786 static bool
virQEMUCapsKVMSupportsSecureGuest(void)4787 virQEMUCapsKVMSupportsSecureGuest(void)
4788 {
4789 virArch arch = virArchFromHost();
4790
4791 if (ARCH_IS_S390(arch))
4792 return virQEMUCapsKVMSupportsSecureGuestS390();
4793
4794 if (ARCH_IS_X86(arch))
4795 return virQEMUCapsKVMSupportsSecureGuestAMD();
4796
4797 return false;
4798 }
4799
4800
4801 /* Check the kernel module parameters 'nested' file to determine if enabled
4802 *
4803 * Intel: 'kvm_intel' uses 'Y'
4804 * AMD: 'kvm_amd' uses '1'
4805 * PPC64: 'kvm_hv' uses 'Y'
4806 * S390: 'kvm' uses '1'
4807 */
4808 static bool
virQEMUCapsKVMSupportsNesting(void)4809 virQEMUCapsKVMSupportsNesting(void)
4810 {
4811 static char const * const kmod[] = {"kvm_intel", "kvm_amd",
4812 "kvm_hv", "kvm"};
4813 g_autofree char *value = NULL;
4814 int rc;
4815 size_t i;
4816
4817 for (i = 0; i < G_N_ELEMENTS(kmod); i++) {
4818 VIR_FREE(value);
4819 rc = virFileReadValueString(&value, "/sys/module/%s/parameters/nested",
4820 kmod[i]);
4821 if (rc == -2)
4822 continue;
4823 if (rc < 0) {
4824 virResetLastError();
4825 return false;
4826 }
4827
4828 if (value[0] == 'Y' || value[0] == 'y' || value[0] == '1')
4829 return true;
4830 }
4831
4832 return false;
4833 }
4834
4835
4836 /* Determine whether '/dev/kvm' is usable as QEMU user:QEMU group. */
4837 static bool
virQEMUCapsKVMUsable(virQEMUCapsCachePriv * priv)4838 virQEMUCapsKVMUsable(virQEMUCapsCachePriv *priv)
4839 {
4840 struct stat sb;
4841 static const char *kvm_device = "/dev/kvm";
4842 virTristateBool value;
4843 virTristateBool cached_value = priv->kvmUsable;
4844 time_t kvm_ctime;
4845 time_t cached_kvm_ctime = priv->kvmCtime;
4846
4847 if (stat(kvm_device, &sb) < 0) {
4848 if (errno != ENOENT) {
4849 virReportSystemError(errno,
4850 _("Failed to stat %s"), kvm_device);
4851 }
4852 return false;
4853 }
4854 kvm_ctime = sb.st_ctime;
4855
4856 if (kvm_ctime != cached_kvm_ctime) {
4857 VIR_DEBUG("%s has changed (%lld vs %lld)", kvm_device,
4858 (long long)kvm_ctime, (long long)cached_kvm_ctime);
4859 cached_value = VIR_TRISTATE_BOOL_ABSENT;
4860 }
4861
4862 if (cached_value != VIR_TRISTATE_BOOL_ABSENT)
4863 return cached_value == VIR_TRISTATE_BOOL_YES;
4864
4865 if (virFileAccessibleAs(kvm_device, R_OK | W_OK,
4866 priv->runUid, priv->runGid) == 0) {
4867 value = VIR_TRISTATE_BOOL_YES;
4868 } else {
4869 value = VIR_TRISTATE_BOOL_NO;
4870 }
4871
4872 /* There is a race window between 'stat' and
4873 * 'virFileAccessibleAs'. However, since we're only interested in
4874 * detecting changes *after* the virFileAccessibleAs check, we can
4875 * neglect this here.
4876 */
4877 priv->kvmCtime = kvm_ctime;
4878 priv->kvmUsable = value;
4879
4880 return value == VIR_TRISTATE_BOOL_YES;
4881 }
4882
4883
4884 static bool
virQEMUCapsIsValid(void * data,void * privData)4885 virQEMUCapsIsValid(void *data,
4886 void *privData)
4887 {
4888 virQEMUCaps *qemuCaps = data;
4889 virQEMUCapsCachePriv *priv = privData;
4890 bool kvmUsable;
4891 struct stat sb;
4892 bool kvmSupportsNesting;
4893
4894 if (!qemuCaps->invalidation)
4895 return true;
4896
4897 if (!qemuCaps->binary)
4898 return true;
4899
4900 if (virFileExists(QEMU_MODDIR)) {
4901 if (stat(QEMU_MODDIR, &sb) < 0) {
4902 VIR_DEBUG("Failed to stat QEMU module directory '%s': %s",
4903 QEMU_MODDIR,
4904 g_strerror(errno));
4905 return false;
4906 }
4907
4908 if (sb.st_mtime != qemuCaps->modDirMtime) {
4909 VIR_DEBUG("Outdated capabilities for '%s': QEMU modules "
4910 "directory '%s' changed (%lld vs %lld)",
4911 qemuCaps->binary, QEMU_MODDIR,
4912 (long long)sb.st_mtime, (long long)qemuCaps->modDirMtime);
4913 return false;
4914 }
4915 }
4916
4917 if (qemuCaps->libvirtCtime != virGetSelfLastChanged() ||
4918 qemuCaps->libvirtVersion != LIBVIR_VERSION_NUMBER) {
4919 VIR_DEBUG("Outdated capabilities for '%s': libvirt changed "
4920 "(%lld vs %lld, %lu vs %lu)",
4921 qemuCaps->binary,
4922 (long long)qemuCaps->libvirtCtime,
4923 (long long)virGetSelfLastChanged(),
4924 (unsigned long)qemuCaps->libvirtVersion,
4925 (unsigned long)LIBVIR_VERSION_NUMBER);
4926 return false;
4927 }
4928
4929 if (stat(qemuCaps->binary, &sb) < 0) {
4930 VIR_DEBUG("Failed to stat QEMU binary '%s': %s",
4931 qemuCaps->binary,
4932 g_strerror(errno));
4933 return false;
4934 }
4935
4936 if (sb.st_ctime != qemuCaps->ctime) {
4937 VIR_DEBUG("Outdated capabilities for '%s': QEMU binary changed "
4938 "(%lld vs %lld)",
4939 qemuCaps->binary,
4940 (long long)sb.st_ctime, (long long)qemuCaps->ctime);
4941 return false;
4942 }
4943
4944 if (!virQEMUCapsGuestIsNative(priv->hostArch, qemuCaps->arch)) {
4945 VIR_DEBUG("Guest arch (%s) is not native to host arch (%s), "
4946 "skipping KVM-related checks",
4947 virArchToString(qemuCaps->arch),
4948 virArchToString(priv->hostArch));
4949 return true;
4950 }
4951
4952 kvmUsable = virQEMUCapsKVMUsable(priv);
4953
4954 if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM) &&
4955 kvmUsable) {
4956 VIR_DEBUG("KVM was not enabled when probing '%s', "
4957 "but it should be usable now",
4958 qemuCaps->binary);
4959 return false;
4960 }
4961
4962 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM) &&
4963 !kvmUsable) {
4964 VIR_DEBUG("KVM was enabled when probing '%s', "
4965 "but it is not available now",
4966 qemuCaps->binary);
4967 return false;
4968 }
4969
4970 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
4971 if (STRNEQ_NULLABLE(priv->hostCPUSignature, qemuCaps->hostCPUSignature)) {
4972 VIR_DEBUG("Outdated capabilities for '%s': host CPU changed "
4973 "('%s' vs '%s')",
4974 qemuCaps->binary,
4975 priv->hostCPUSignature,
4976 qemuCaps->hostCPUSignature);
4977 return false;
4978 }
4979
4980 if (priv->microcodeVersion != qemuCaps->microcodeVersion) {
4981 VIR_DEBUG("Outdated capabilities for '%s': microcode version "
4982 "changed (%u vs %u)",
4983 qemuCaps->binary,
4984 priv->microcodeVersion,
4985 qemuCaps->microcodeVersion);
4986 return false;
4987 }
4988
4989 if (STRNEQ_NULLABLE(priv->kernelVersion, qemuCaps->kernelVersion)) {
4990 VIR_DEBUG("Outdated capabilities for '%s': kernel version changed "
4991 "('%s' vs '%s')",
4992 qemuCaps->binary,
4993 priv->kernelVersion,
4994 qemuCaps->kernelVersion);
4995 return false;
4996 }
4997
4998 if (virCPUDataIsIdentical(priv->cpuData, qemuCaps->cpuData) !=
4999 VIR_CPU_COMPARE_IDENTICAL) {
5000 VIR_DEBUG("Outdated capabilities for '%s': host cpuid changed",
5001 qemuCaps->binary);
5002 return false;
5003 }
5004
5005 kvmSupportsNesting = virQEMUCapsKVMSupportsNesting();
5006 if (kvmSupportsNesting != qemuCaps->kvmSupportsNesting) {
5007 VIR_DEBUG("Outdated capabilities for '%s': kvm kernel nested "
5008 "value changed from %d",
5009 qemuCaps->binary, qemuCaps->kvmSupportsNesting);
5010 return false;
5011 }
5012
5013 if (virQEMUCapsKVMSupportsSecureGuest() != qemuCaps->kvmSupportsSecureGuest) {
5014 VIR_DEBUG("Outdated capabilities for '%s': kvm kernel secure guest "
5015 "value changed from %d",
5016 qemuCaps->binary, qemuCaps->kvmSupportsSecureGuest);
5017 return false;
5018 }
5019 }
5020
5021 return true;
5022 }
5023
5024
5025 /**
5026 * virQEMUCapsInitQMPArch:
5027 * @qemuCaps: QEMU capabilities
5028 * @mon: QEMU monitor
5029 *
5030 * Initialize the architecture for @qemuCaps by asking @mon.
5031 *
5032 * Returns: 0 on success, <0 on failure
5033 */
5034 static int
virQEMUCapsInitQMPArch(virQEMUCaps * qemuCaps,qemuMonitor * mon)5035 virQEMUCapsInitQMPArch(virQEMUCaps *qemuCaps,
5036 qemuMonitor *mon)
5037 {
5038 g_autofree char *archstr = NULL;
5039
5040 if (!(archstr = qemuMonitorGetTargetArch(mon)))
5041 return -1;
5042
5043 if ((qemuCaps->arch = virQEMUCapsArchFromString(archstr)) == VIR_ARCH_NONE) {
5044 virReportError(VIR_ERR_INTERNAL_ERROR,
5045 _("Unknown QEMU arch %s"), archstr);
5046 return -1;
5047 }
5048
5049 return 0;
5050 }
5051
5052
5053 /**
5054 * virQEMUCapsInitQMPBasicArch:
5055 * @qemuCaps: QEMU capabilities
5056 *
5057 * Initialize @qemuCaps with basic always present and architecture-dependent
5058 * capabilities.
5059 */
5060 void
virQEMUCapsInitQMPBasicArch(virQEMUCaps * qemuCaps)5061 virQEMUCapsInitQMPBasicArch(virQEMUCaps *qemuCaps)
5062 {
5063 switch (qemuCaps->arch) {
5064 case VIR_ARCH_I686:
5065 case VIR_ARCH_X86_64:
5066 /* ACPI only works on x86 and aarch64 */
5067 virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_ACPI);
5068
5069 /* HPET is x86 specific */
5070 virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_HPET);
5071 break;
5072
5073 case VIR_ARCH_AARCH64:
5074 /* ACPI only works on x86 and aarch64 */
5075 virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_ACPI);
5076
5077 /* -cpu ...,aarch64=off is not detectable via qmp at this point */
5078 virQEMUCapsSet(qemuCaps, QEMU_CAPS_CPU_AARCH64_OFF);
5079
5080 /* gic is arm specific */
5081 virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACH_VIRT_GIC_VERSION);
5082 break;
5083
5084 case VIR_ARCH_PPC64:
5085 case VIR_ARCH_PPC64LE:
5086 virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT);
5087 virQEMUCapsSet(qemuCaps, QEMU_CAPS_MACHINE_PSERIES_MAX_CPU_COMPAT);
5088 break;
5089
5090 case VIR_ARCH_S390:
5091 case VIR_ARCH_S390X:
5092 virQEMUCapsSet(qemuCaps, QEMU_CAPS_AES_KEY_WRAP);
5093 virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEA_KEY_WRAP);
5094 virQEMUCapsSet(qemuCaps, QEMU_CAPS_LOADPARM);
5095 break;
5096
5097 case VIR_ARCH_ALPHA:
5098 case VIR_ARCH_PPC:
5099 case VIR_ARCH_PPCEMB:
5100 case VIR_ARCH_SH4:
5101 case VIR_ARCH_SH4EB:
5102 case VIR_ARCH_RISCV32:
5103 case VIR_ARCH_RISCV64:
5104 case VIR_ARCH_SPARC:
5105 case VIR_ARCH_SPARC64:
5106 case VIR_ARCH_ARMV6L:
5107 case VIR_ARCH_ARMV7L:
5108 case VIR_ARCH_ARMV7B:
5109 case VIR_ARCH_CRIS:
5110 case VIR_ARCH_ITANIUM:
5111 case VIR_ARCH_LM32:
5112 case VIR_ARCH_M68K:
5113 case VIR_ARCH_MICROBLAZE:
5114 case VIR_ARCH_MICROBLAZEEL:
5115 case VIR_ARCH_MIPS:
5116 case VIR_ARCH_MIPSEL:
5117 case VIR_ARCH_MIPS64:
5118 case VIR_ARCH_MIPS64EL:
5119 case VIR_ARCH_OR32:
5120 case VIR_ARCH_PARISC:
5121 case VIR_ARCH_PARISC64:
5122 case VIR_ARCH_PPCLE:
5123 case VIR_ARCH_UNICORE32:
5124 case VIR_ARCH_XTENSA:
5125 case VIR_ARCH_XTENSAEB:
5126 case VIR_ARCH_NONE:
5127 case VIR_ARCH_LAST:
5128 default:
5129 break;
5130 }
5131 }
5132
5133
5134 /**
5135 * virQEMUCapsInitQMPVersionCaps:
5136 * @qemuCaps: QEMU capabilities
5137 *
5138 * Add all QEMU capabilities based on version of QEMU.
5139 */
5140 static void
virQEMUCapsInitQMPVersionCaps(virQEMUCaps * qemuCaps)5141 virQEMUCapsInitQMPVersionCaps(virQEMUCaps *qemuCaps)
5142 {
5143 /* -enable-fips is deprecated in QEMU 5.2.0, and QEMU
5144 * should be built with gcrypt to achieve FIPS compliance
5145 * automatically / implicitly
5146 */
5147 if (qemuCaps->version < 5002000)
5148 virQEMUCapsSet(qemuCaps, QEMU_CAPS_ENABLE_FIPS);
5149 }
5150
5151
5152 /**
5153 * virQEMUCapsInitProcessCapsInterlock:
5154 * @qemuCaps: QEMU capabilities
5155 *
5156 * A capability which requires a different capability being present in order
5157 * for libvirt to be able to drive it properly should be processed here.
5158 */
5159 void
virQEMUCapsInitProcessCapsInterlock(virQEMUCaps * qemuCaps)5160 virQEMUCapsInitProcessCapsInterlock(virQEMUCaps *qemuCaps)
5161 {
5162 if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_BLOCKDEV))
5163 virQEMUCapsClear(qemuCaps, QEMU_CAPS_BLOCKDEV_BACKUP);
5164
5165 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_BLOCKDEV_BACKUP) &&
5166 virQEMUCapsGet(qemuCaps, QEMU_CAPS_BLOCKDEV_REOPEN) &&
5167 virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATION_PARAM_BLOCK_BITMAP_MAPPING))
5168 virQEMUCapsSet(qemuCaps, QEMU_CAPS_INCREMENTAL_BACKUP);
5169
5170 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_USB_STORAGE) &&
5171 !virQEMUCapsGet(qemuCaps, QEMU_CAPS_USB_STORAGE_WERROR)) {
5172 virQEMUCapsClear(qemuCaps, QEMU_CAPS_STORAGE_WERROR);
5173 }
5174
5175 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_BLOCKDEV))
5176 virQEMUCapsSet(qemuCaps, QEMU_CAPS_BLOCKDEV_HOSTDEV_SCSI);
5177
5178 /* The -compat qemu command line argument is implemented using a newer
5179 * method which doesn't show up in query-command-line-options. As we'll use
5180 * it only for development and testing purposes we can base the capability
5181 * on a not entirely related witness. */
5182 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_JSON))
5183 virQEMUCapsSet(qemuCaps, QEMU_CAPS_COMPAT_DEPRECATED);
5184 }
5185
5186
5187 /**
5188 * virQEMUCapsInitProcessCaps:
5189 * @qemuCaps: QEMU capabilities
5190 *
5191 * Some capability bits are enabled or disabled according to specific logic.
5192 * This function collects all capability processing after the capabilities
5193 * are detected.
5194 */
5195 static void
virQEMUCapsInitProcessCaps(virQEMUCaps * qemuCaps)5196 virQEMUCapsInitProcessCaps(virQEMUCaps *qemuCaps)
5197 {
5198 /* versions prior to the introduction of 'query-display-options' had SDL
5199 * mostly compiled in */
5200 if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_DISPLAY_OPTIONS)) {
5201 virQEMUCapsSet(qemuCaps, QEMU_CAPS_SDL);
5202 virQEMUCapsSet(qemuCaps, QEMU_CAPS_EGL_HEADLESS);
5203 }
5204
5205 if (ARCH_IS_X86(qemuCaps->arch) &&
5206 virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION)) {
5207 virQEMUCapsSet(qemuCaps, QEMU_CAPS_CPU_CACHE);
5208
5209 /* Old x86 QEMU supported migratable:false property in
5210 * query-cpu-model-expansion arguments even though it was not properly
5211 * advertised as a CPU property.
5212 */
5213 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_CPU_MIGRATABLE) ||
5214 qemuCaps->version < 2012000)
5215 virQEMUCapsSet(qemuCaps, QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION_MIGRATABLE);
5216 }
5217
5218 if (ARCH_IS_S390(qemuCaps->arch)) {
5219 /* Legacy assurance for QEMU_CAPS_CCW */
5220 if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CCW) &&
5221 virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_CCW))
5222 virQEMUCapsSet(qemuCaps, QEMU_CAPS_CCW);
5223 if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CCW_CSSID_UNRESTRICTED))
5224 virQEMUCapsClear(qemuCaps, QEMU_CAPS_DEVICE_VFIO_CCW);
5225 }
5226
5227 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_CPU_UNAVAILABLE_FEATURES))
5228 virQEMUCapsSet(qemuCaps, QEMU_CAPS_CANONICAL_CPU_FEATURES);
5229
5230 /* To avoid guest ABI regression, blockdev shall be enabled only when
5231 * we are able to pass the custom 'device_id' for SCSI disks and cdroms. */
5232 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_BLOCK_FILE_AUTO_READONLY_DYNAMIC) &&
5233 virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_DISK_DEVICE_ID) &&
5234 virQEMUCapsGet(qemuCaps, QEMU_CAPS_SAVEVM_MONITOR_NODES))
5235 virQEMUCapsSet(qemuCaps, QEMU_CAPS_BLOCKDEV);
5236
5237 /* We can't probe "esp" as a type via virQEMUCapsObjectTypes
5238 * array as it is only usable when builtin to the machine type
5239 */
5240 if (qemuCaps->arch == VIR_ARCH_SPARC ||
5241 qemuCaps->arch == VIR_ARCH_M68K ||
5242 qemuCaps->arch == VIR_ARCH_MIPS)
5243 virQEMUCapsSet(qemuCaps, QEMU_CAPS_SCSI_NCR53C90);
5244
5245 virQEMUCapsInitProcessCapsInterlock(qemuCaps);
5246 }
5247
5248
5249 static int
virQEMUCapsProbeQMPSchemaCapabilities(virQEMUCaps * qemuCaps,qemuMonitor * mon)5250 virQEMUCapsProbeQMPSchemaCapabilities(virQEMUCaps *qemuCaps,
5251 qemuMonitor *mon)
5252 {
5253 struct virQEMUCapsStringFlags *entry;
5254 virJSONValue *schemareply;
5255 g_autoptr(GHashTable) schema = NULL;
5256 size_t i;
5257
5258 if (!(schemareply = qemuMonitorQueryQMPSchema(mon)))
5259 return -1;
5260
5261 if (!(schema = virQEMUQAPISchemaConvert(schemareply)))
5262 return -1;
5263 schemareply = NULL;
5264
5265 for (i = 0; i < G_N_ELEMENTS(virQEMUCapsQMPSchemaQueries); i++) {
5266 entry = virQEMUCapsQMPSchemaQueries + i;
5267
5268 if (virQEMUQAPISchemaPathExists(entry->value, schema))
5269 virQEMUCapsSet(qemuCaps, entry->flag);
5270 }
5271
5272 /* probe also for basic event support */
5273 for (i = 0; i < G_N_ELEMENTS(virQEMUCapsEvents); i++) {
5274 entry = virQEMUCapsEvents + i;
5275
5276 if (virQEMUQAPISchemaPathExists(entry->value, schema))
5277 virQEMUCapsSet(qemuCaps, entry->flag);
5278 }
5279
5280 return 0;
5281 }
5282
5283 #define QEMU_MIN_MAJOR 2
5284 #define QEMU_MIN_MINOR 11
5285 #define QEMU_MIN_MICRO 0
5286
5287 virDomainVirtType
virQEMUCapsGetVirtType(virQEMUCaps * qemuCaps)5288 virQEMUCapsGetVirtType(virQEMUCaps *qemuCaps)
5289 {
5290 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
5291 return VIR_DOMAIN_VIRT_KVM;
5292
5293 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NVMM))
5294 return VIR_DOMAIN_VIRT_NVMM;
5295
5296 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_TCG))
5297 return VIR_DOMAIN_VIRT_QEMU;
5298
5299 return VIR_DOMAIN_VIRT_NONE;
5300 }
5301
5302 int
virQEMUCapsInitQMPMonitor(virQEMUCaps * qemuCaps,qemuMonitor * mon)5303 virQEMUCapsInitQMPMonitor(virQEMUCaps *qemuCaps,
5304 qemuMonitor *mon)
5305 {
5306 int major, minor, micro;
5307 g_autofree char *package = NULL;
5308 virQEMUCapsAccel *accel;
5309 virDomainVirtType type;
5310
5311 /* @mon is supposed to be locked by callee */
5312
5313 if (qemuMonitorGetVersion(mon, &major, &minor, µ, &package) < 0)
5314 return -1;
5315
5316 VIR_DEBUG("Got version %d.%d.%d (%s)",
5317 major, minor, micro, NULLSTR(package));
5318
5319 if (major < QEMU_MIN_MAJOR ||
5320 (major == QEMU_MIN_MAJOR && minor < QEMU_MIN_MINOR)) {
5321 virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
5322 _("QEMU version >= %d.%d.%d is required, but %d.%d.%d found"),
5323 QEMU_MIN_MAJOR, QEMU_MIN_MINOR, QEMU_MIN_MICRO,
5324 major, minor, micro);
5325 return -1;
5326 }
5327
5328 qemuCaps->version = major * 1000000 + minor * 1000 + micro;
5329 qemuCaps->package = g_steal_pointer(&package);
5330
5331 if (virQEMUCapsInitQMPArch(qemuCaps, mon) < 0)
5332 return -1;
5333
5334 virQEMUCapsInitQMPBasicArch(qemuCaps);
5335
5336 /* initiate all capabilities based on qemu version */
5337 virQEMUCapsInitQMPVersionCaps(qemuCaps);
5338
5339 if (virQEMUCapsProbeQMPSchemaCapabilities(qemuCaps, mon) < 0)
5340 return -1;
5341 if (virQEMUCapsProbeQMPCommands(qemuCaps, mon) < 0)
5342 return -1;
5343
5344 /* Some capabilities may differ depending on KVM state */
5345 if (virQEMUCapsProbeQMPKVMState(qemuCaps, mon) < 0)
5346 return -1;
5347
5348 /* Some capabilities may differ depending on NVMM state */
5349 if (virQEMUCapsProbeQMPNVMMState(qemuCaps, mon) < 0)
5350 return -1;
5351
5352 type = virQEMUCapsGetVirtType(qemuCaps);
5353 accel = virQEMUCapsGetAccel(qemuCaps, type);
5354
5355 if (virQEMUCapsProbeQMPObjectTypes(qemuCaps, mon) < 0)
5356 return -1;
5357 if (virQEMUCapsProbeQMPDeviceProperties(qemuCaps, mon) < 0)
5358 return -1;
5359 if (virQEMUCapsProbeQMPObjectProperties(qemuCaps, mon) < 0)
5360 return -1;
5361 if (virQEMUCapsProbeQMPMachineTypes(qemuCaps, type, mon) < 0)
5362 return -1;
5363 if (virQEMUCapsProbeQMPMachineProps(qemuCaps, type, mon) < 0)
5364 return -1;
5365 if (virQEMUCapsProbeQMPCPUDefinitions(qemuCaps, accel, mon) < 0)
5366 return -1;
5367 if (virQEMUCapsProbeQMPTPM(qemuCaps, mon) < 0)
5368 return -1;
5369 if (virQEMUCapsProbeQMPCommandLine(qemuCaps, mon) < 0)
5370 return -1;
5371 if (virQEMUCapsProbeQMPMigrationCapabilities(qemuCaps, mon) < 0)
5372 return -1;
5373 if (virQEMUCapsProbeQMPGICCapabilities(qemuCaps, mon) < 0)
5374 return -1;
5375 if (virQEMUCapsProbeQMPSEVCapabilities(qemuCaps, mon) < 0)
5376 return -1;
5377
5378
5379 virQEMUCapsInitProcessCaps(qemuCaps);
5380
5381 /* The following probes rely on other previously probed capabilities.
5382 * No capabilities bits should be set below this point. */
5383
5384 if (virQEMUCapsProbeQMPHostCPU(qemuCaps, accel, mon, type) < 0)
5385 return -1;
5386
5387 return 0;
5388 }
5389
5390
5391 int
virQEMUCapsInitQMPMonitorTCG(virQEMUCaps * qemuCaps,qemuMonitor * mon)5392 virQEMUCapsInitQMPMonitorTCG(virQEMUCaps *qemuCaps,
5393 qemuMonitor *mon)
5394 {
5395 virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, VIR_DOMAIN_VIRT_QEMU);
5396
5397 if (virQEMUCapsProbeQMPCPUDefinitions(qemuCaps, accel, mon) < 0)
5398 return -1;
5399
5400 if (virQEMUCapsProbeQMPHostCPU(qemuCaps, accel, mon, VIR_DOMAIN_VIRT_QEMU) < 0)
5401 return -1;
5402
5403 if (virQEMUCapsProbeQMPMachineTypes(qemuCaps, VIR_DOMAIN_VIRT_QEMU, mon) < 0)
5404 return -1;
5405
5406 return 0;
5407 }
5408
5409
5410 #define MESSAGE_ID_CAPS_PROBE_FAILURE "8ae2f3fb-2dbe-498e-8fbd-012d40afa361"
5411
5412 static void
virQEMUCapsLogProbeFailure(const char * binary)5413 virQEMUCapsLogProbeFailure(const char *binary)
5414 {
5415 virLogMetadata meta[] = {
5416 { .key = "MESSAGE_ID", .s = MESSAGE_ID_CAPS_PROBE_FAILURE, .iv = 0 },
5417 { .key = "LIBVIRT_QEMU_BINARY", .s = binary, .iv = 0 },
5418 { .key = NULL },
5419 };
5420
5421 virLogMessage(&virLogSelf,
5422 VIR_LOG_WARN,
5423 __FILE__, __LINE__, __func__,
5424 meta,
5425 _("Failed to probe capabilities for %s: %s"),
5426 binary, virGetLastErrorMessage());
5427 }
5428
5429
5430 static int
virQEMUCapsInitQMPSingle(virQEMUCaps * qemuCaps,const char * libDir,uid_t runUid,gid_t runGid,bool onlyTCG)5431 virQEMUCapsInitQMPSingle(virQEMUCaps *qemuCaps,
5432 const char *libDir,
5433 uid_t runUid,
5434 gid_t runGid,
5435 bool onlyTCG)
5436 {
5437 g_autoptr(qemuProcessQMP) proc = NULL;
5438 int ret = -1;
5439
5440 if (!(proc = qemuProcessQMPNew(qemuCaps->binary, libDir,
5441 runUid, runGid, onlyTCG)))
5442 goto cleanup;
5443
5444 if (qemuProcessQMPStart(proc) < 0)
5445 goto cleanup;
5446
5447 if (onlyTCG)
5448 ret = virQEMUCapsInitQMPMonitorTCG(qemuCaps, proc->mon);
5449 else
5450 ret = virQEMUCapsInitQMPMonitor(qemuCaps, proc->mon);
5451
5452 cleanup:
5453 if (ret < 0)
5454 virQEMUCapsLogProbeFailure(qemuCaps->binary);
5455
5456 return ret;
5457 }
5458
5459
5460 static int
virQEMUCapsInitQMP(virQEMUCaps * qemuCaps,const char * libDir,uid_t runUid,gid_t runGid)5461 virQEMUCapsInitQMP(virQEMUCaps *qemuCaps,
5462 const char *libDir,
5463 uid_t runUid,
5464 gid_t runGid)
5465 {
5466 if (virQEMUCapsInitQMPSingle(qemuCaps, libDir, runUid, runGid, false) < 0)
5467 return -1;
5468
5469 /*
5470 * If KVM was enabled during the first probe, we need to explicitly probe
5471 * for TCG capabilities by asking the same binary again and turning KVM
5472 * off.
5473 */
5474 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM) &&
5475 virQEMUCapsGet(qemuCaps, QEMU_CAPS_TCG) &&
5476 virQEMUCapsInitQMPSingle(qemuCaps, libDir, runUid, runGid, true) < 0)
5477 return -1;
5478
5479 /*
5480 * If NVMM was enabled during the first probe, we need to explicitly probe
5481 * for TCG capabilities by asking the same binary again and turning KVM
5482 * off.
5483 */
5484 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NVMM) &&
5485 virQEMUCapsGet(qemuCaps, QEMU_CAPS_TCG) &&
5486 virQEMUCapsInitQMPSingle(qemuCaps, libDir, runUid, runGid, true) < 0)
5487 return -1;
5488
5489 return 0;
5490 }
5491
5492
5493 virQEMUCaps *
virQEMUCapsNewForBinaryInternal(virArch hostArch,const char * binary,const char * libDir,uid_t runUid,gid_t runGid,const char * hostCPUSignature,unsigned int microcodeVersion,const char * kernelVersion,virCPUData * cpuData)5494 virQEMUCapsNewForBinaryInternal(virArch hostArch,
5495 const char *binary,
5496 const char *libDir,
5497 uid_t runUid,
5498 gid_t runGid,
5499 const char *hostCPUSignature,
5500 unsigned int microcodeVersion,
5501 const char *kernelVersion,
5502 virCPUData* cpuData)
5503 {
5504 g_autoptr(virQEMUCaps) qemuCaps = NULL;
5505 struct stat sb;
5506
5507 if (!(qemuCaps = virQEMUCapsNewBinary(binary)))
5508 return NULL;
5509
5510 /* We would also want to check faccessat if we cared about ACLs,
5511 * but we don't. */
5512 if (stat(binary, &sb) < 0) {
5513 virReportSystemError(errno, _("Cannot check QEMU binary %s"),
5514 binary);
5515 return NULL;
5516 }
5517 qemuCaps->ctime = sb.st_ctime;
5518
5519 /* Make sure the binary we are about to try exec'ing exists.
5520 * Technically we could catch the exec() failure, but that's
5521 * in a sub-process so it's hard to feed back a useful error.
5522 */
5523 if (!virFileIsExecutable(binary)) {
5524 virReportSystemError(errno, _("QEMU binary %s is not executable"),
5525 binary);
5526 return NULL;
5527 }
5528
5529 if (virFileExists(QEMU_MODDIR)) {
5530 if (stat(QEMU_MODDIR, &sb) < 0) {
5531 virReportSystemError(errno, _("Cannot check QEMU module directory %s"),
5532 QEMU_MODDIR);
5533 return NULL;
5534 }
5535 qemuCaps->modDirMtime = sb.st_mtime;
5536 }
5537
5538 if (virQEMUCapsInitQMP(qemuCaps, libDir, runUid, runGid) < 0)
5539 return NULL;
5540
5541 qemuCaps->libvirtCtime = virGetSelfLastChanged();
5542 qemuCaps->libvirtVersion = LIBVIR_VERSION_NUMBER;
5543
5544 virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_KVM);
5545 virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_NVMM);
5546 virQEMUCapsInitHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_QEMU);
5547
5548 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
5549 qemuCaps->hostCPUSignature = g_strdup(hostCPUSignature);
5550 qemuCaps->microcodeVersion = microcodeVersion;
5551 qemuCaps->cpuData = virCPUDataNewCopy(cpuData);
5552
5553 qemuCaps->kernelVersion = g_strdup(kernelVersion);
5554
5555 qemuCaps->kvmSupportsNesting = virQEMUCapsKVMSupportsNesting();
5556
5557 qemuCaps->kvmSupportsSecureGuest = virQEMUCapsKVMSupportsSecureGuest();
5558 }
5559
5560 return g_steal_pointer(&qemuCaps);
5561 }
5562
5563 static void *
virQEMUCapsNewData(const char * binary,void * privData)5564 virQEMUCapsNewData(const char *binary,
5565 void *privData)
5566 {
5567 virQEMUCapsCachePriv *priv = privData;
5568
5569 return virQEMUCapsNewForBinaryInternal(priv->hostArch,
5570 binary,
5571 priv->libDir,
5572 priv->runUid,
5573 priv->runGid,
5574 priv->hostCPUSignature,
5575 virHostCPUGetMicrocodeVersion(priv->hostArch),
5576 priv->kernelVersion,
5577 priv->cpuData);
5578 }
5579
5580
5581 static void *
virQEMUCapsLoadFile(const char * filename,const char * binary,void * privData,bool * outdated)5582 virQEMUCapsLoadFile(const char *filename,
5583 const char *binary,
5584 void *privData,
5585 bool *outdated)
5586 {
5587 g_autoptr(virQEMUCaps) qemuCaps = virQEMUCapsNewBinary(binary);
5588 virQEMUCapsCachePriv *priv = privData;
5589 int ret;
5590
5591 if (!qemuCaps)
5592 return NULL;
5593
5594 ret = virQEMUCapsLoadCache(priv->hostArch, qemuCaps, filename, false);
5595 if (ret < 0)
5596 return NULL;
5597 if (ret == 1) {
5598 *outdated = true;
5599 return NULL;
5600 }
5601
5602 return g_steal_pointer(&qemuCaps);
5603 }
5604
5605
5606 struct virQEMUCapsMachineTypeFilter {
5607 const char *machineType;
5608 virQEMUCapsFlags *flags;
5609 size_t nflags;
5610 };
5611
5612 static const struct virQEMUCapsMachineTypeFilter virQEMUCapsMachineFilter[] = {
5613 /* { "blah", virQEMUCapsMachineBLAHFilter,
5614 G_N_ELEMENTS(virQEMUCapsMachineBLAHFilter) }, */
5615 { "", NULL, 0 },
5616 };
5617
5618
5619 void
virQEMUCapsFilterByMachineType(virQEMUCaps * qemuCaps,virDomainVirtType virtType,const char * machineType)5620 virQEMUCapsFilterByMachineType(virQEMUCaps *qemuCaps,
5621 virDomainVirtType virtType,
5622 const char *machineType)
5623 {
5624 size_t i;
5625
5626 if (!machineType)
5627 return;
5628
5629 for (i = 0; i < G_N_ELEMENTS(virQEMUCapsMachineFilter); i++) {
5630 const struct virQEMUCapsMachineTypeFilter *filter = &virQEMUCapsMachineFilter[i];
5631 size_t j;
5632
5633 if (STRNEQ(filter->machineType, machineType))
5634 continue;
5635
5636 for (j = 0; j < filter->nflags; j++)
5637 virQEMUCapsClear(qemuCaps, filter->flags[j]);
5638 }
5639
5640 if (!virQEMUCapsGetMachineHotplugCpus(qemuCaps, virtType, machineType))
5641 virQEMUCapsClear(qemuCaps, QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS);
5642 }
5643
5644
5645 virFileCacheHandlers qemuCapsCacheHandlers = {
5646 .isValid = virQEMUCapsIsValid,
5647 .newData = virQEMUCapsNewData,
5648 .loadFile = virQEMUCapsLoadFile,
5649 .saveFile = virQEMUCapsSaveFile,
5650 .privFree = virQEMUCapsCachePrivFree,
5651 };
5652
5653
5654 virFileCache *
virQEMUCapsCacheNew(const char * libDir,const char * cacheDir,uid_t runUid,gid_t runGid)5655 virQEMUCapsCacheNew(const char *libDir,
5656 const char *cacheDir,
5657 uid_t runUid,
5658 gid_t runGid)
5659 {
5660 g_autofree char *capsCacheDir = NULL;
5661 virFileCache *cache = NULL;
5662 virQEMUCapsCachePriv *priv = NULL;
5663 struct utsname uts;
5664
5665 capsCacheDir = g_strdup_printf("%s/capabilities", cacheDir);
5666
5667 if (!(cache = virFileCacheNew(capsCacheDir, "xml", &qemuCapsCacheHandlers)))
5668 goto error;
5669
5670 priv = g_new0(virQEMUCapsCachePriv, 1);
5671 virFileCacheSetPriv(cache, priv);
5672
5673 priv->libDir = g_strdup(libDir);
5674
5675 priv->hostArch = virArchFromHost();
5676
5677 if (virHostCPUGetSignature(&priv->hostCPUSignature) < 0)
5678 goto error;
5679
5680 priv->runUid = runUid;
5681 priv->runGid = runGid;
5682 priv->kvmUsable = VIR_TRISTATE_BOOL_ABSENT;
5683
5684 if (uname(&uts) == 0)
5685 priv->kernelVersion = g_strdup_printf("%s %s", uts.release, uts.version);
5686
5687 priv->cpuData = virCPUDataGetHost();
5688 return cache;
5689
5690 error:
5691 virObjectUnref(cache);
5692 return NULL;
5693 }
5694
5695
5696 virQEMUCaps *
virQEMUCapsCacheLookup(virFileCache * cache,const char * binary)5697 virQEMUCapsCacheLookup(virFileCache *cache,
5698 const char *binary)
5699 {
5700 virQEMUCapsCachePriv *priv = virFileCacheGetPriv(cache);
5701 virQEMUCaps *ret = NULL;
5702
5703 priv->microcodeVersion = virHostCPUGetMicrocodeVersion(priv->hostArch);
5704
5705 ret = virFileCacheLookup(cache, binary);
5706
5707 VIR_DEBUG("Returning caps %p for %s", ret, binary);
5708 return ret;
5709 }
5710
5711
5712 virQEMUCaps *
virQEMUCapsCacheLookupCopy(virFileCache * cache,virDomainVirtType virtType,const char * binary,const char * machineType)5713 virQEMUCapsCacheLookupCopy(virFileCache *cache,
5714 virDomainVirtType virtType,
5715 const char *binary,
5716 const char *machineType)
5717 {
5718 virQEMUCaps *qemuCaps = virQEMUCapsCacheLookup(cache, binary);
5719 virQEMUCaps *ret;
5720
5721 if (!qemuCaps)
5722 return NULL;
5723
5724 ret = virQEMUCapsNewCopy(qemuCaps);
5725 virObjectUnref(qemuCaps);
5726
5727 if (!ret)
5728 return NULL;
5729
5730 virQEMUCapsFilterByMachineType(ret, virtType, machineType);
5731 return ret;
5732 }
5733
5734
5735 /**
5736 * virQEMUCapsCacheLookupDefault:
5737 * @cache: QEMU capabilities cache
5738 * @binary: optional path to QEMU binary
5739 * @archStr: optional guest architecture
5740 * @virttypeStr: optional virt type
5741 * @machine: optional machine type
5742 * @retArch: if non-NULL, guest architecture will be returned here
5743 * @retVirttype: if non-NULL, domain virt type will be returned here
5744 * @retMachine: if non-NULL, canonical machine type will be returned here
5745 *
5746 * Looks up the QEMU binary specified by @binary and @archStr, checks it can
5747 * provide the required @virttypeStr and @machine and returns its capabilities.
5748 * Sensible defaults are used for any argument which is NULL (the function can
5749 * even be called with all NULL arguments).
5750 *
5751 * Returns QEMU capabilities matching the requirements, NULL on error.
5752 */
5753 virQEMUCaps *
virQEMUCapsCacheLookupDefault(virFileCache * cache,const char * binary,const char * archStr,const char * virttypeStr,const char * machine,virArch * retArch,virDomainVirtType * retVirttype,const char ** retMachine)5754 virQEMUCapsCacheLookupDefault(virFileCache *cache,
5755 const char *binary,
5756 const char *archStr,
5757 const char *virttypeStr,
5758 const char *machine,
5759 virArch *retArch,
5760 virDomainVirtType *retVirttype,
5761 const char **retMachine)
5762 {
5763 int virttype = VIR_DOMAIN_VIRT_NONE;
5764 virArch hostarch = virArchFromHost();
5765 virArch arch = hostarch;
5766 virDomainVirtType capsType;
5767 g_autoptr(virQEMUCaps) qemuCaps = NULL;
5768 virArch arch_from_caps;
5769 g_autofree char *probedbinary = NULL;
5770
5771 if (virttypeStr &&
5772 (virttype = virDomainVirtTypeFromString(virttypeStr)) < 0) {
5773 virReportError(VIR_ERR_INVALID_ARG,
5774 _("unknown virttype: %s"), virttypeStr);
5775 return NULL;
5776 }
5777
5778 if (archStr &&
5779 (arch = virArchFromString(archStr)) == VIR_ARCH_NONE) {
5780 virReportError(VIR_ERR_INVALID_ARG,
5781 _("unknown architecture: %s"), archStr);
5782 return NULL;
5783 }
5784
5785 if (!binary) {
5786 probedbinary = virQEMUCapsGetDefaultEmulator(hostarch, arch);
5787 binary = probedbinary;
5788 }
5789 if (!binary) {
5790 virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
5791 _("unable to find any emulator to serve '%s' architecture"),
5792 archStr);
5793 return NULL;
5794 }
5795
5796 if (!(qemuCaps = virQEMUCapsCacheLookup(cache, binary)))
5797 return NULL;
5798
5799 arch_from_caps = virQEMUCapsGetArch(qemuCaps);
5800
5801 if (arch_from_caps != arch &&
5802 !((ARCH_IS_X86(arch) && ARCH_IS_X86(arch_from_caps)) ||
5803 (ARCH_IS_PPC(arch) && ARCH_IS_PPC(arch_from_caps)) ||
5804 (ARCH_IS_ARM(arch) && ARCH_IS_ARM(arch_from_caps)) ||
5805 (ARCH_IS_S390(arch) && ARCH_IS_S390(arch_from_caps)))) {
5806 virReportError(VIR_ERR_INVALID_ARG,
5807 _("architecture from emulator '%s' doesn't "
5808 "match given architecture '%s'"),
5809 virArchToString(arch_from_caps),
5810 virArchToString(arch));
5811 return NULL;
5812 }
5813
5814 capsType = virQEMUCapsGetVirtType(qemuCaps);
5815
5816 if (virttype == VIR_DOMAIN_VIRT_NONE)
5817 virttype = capsType;
5818
5819 if (virttype == VIR_DOMAIN_VIRT_KVM && capsType == VIR_DOMAIN_VIRT_QEMU) {
5820 virReportError(VIR_ERR_INVALID_ARG,
5821 _("KVM is not supported by '%s' on this host"),
5822 binary);
5823 return NULL;
5824 }
5825
5826 if (machine) {
5827 /* Turn @machine into canonical name */
5828 machine = virQEMUCapsGetCanonicalMachine(qemuCaps, virttype, machine);
5829
5830 if (!virQEMUCapsIsMachineSupported(qemuCaps, virttype, machine)) {
5831 virReportError(VIR_ERR_INVALID_ARG,
5832 _("the machine '%s' is not supported by emulator '%s'"),
5833 machine, binary);
5834 return NULL;
5835 }
5836 } else {
5837 machine = virQEMUCapsGetPreferredMachine(qemuCaps, virttype);
5838 }
5839
5840 if (retArch)
5841 *retArch = arch;
5842 if (retVirttype)
5843 *retVirttype = virttype;
5844 if (retMachine)
5845 *retMachine = machine;
5846
5847 return g_steal_pointer(&qemuCaps);
5848 }
5849
5850 bool
virQEMUCapsSupportsVmport(virQEMUCaps * qemuCaps,const virDomainDef * def)5851 virQEMUCapsSupportsVmport(virQEMUCaps *qemuCaps,
5852 const virDomainDef *def)
5853 {
5854 if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MACHINE_VMPORT_OPT))
5855 return false;
5856
5857 return qemuDomainIsI440FX(def) ||
5858 qemuDomainIsQ35(def) ||
5859 STREQ(def->os.machine, "isapc");
5860 }
5861
5862
5863 /*
5864 * The preferred machine to use if none is listed explicitly
5865 * Note that this may differ from QEMU's own default machine
5866 */
5867 const char *
virQEMUCapsGetPreferredMachine(virQEMUCaps * qemuCaps,virDomainVirtType virtType)5868 virQEMUCapsGetPreferredMachine(virQEMUCaps *qemuCaps,
5869 virDomainVirtType virtType)
5870 {
5871 virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, virtType);
5872
5873 if (!accel->nmachineTypes)
5874 return NULL;
5875 return accel->machineTypes[0].name;
5876 }
5877
5878
5879 static int
virQEMUCapsFillDomainLoaderCaps(virDomainCapsLoader * capsLoader,bool secure,virFirmware ** firmwares,size_t nfirmwares)5880 virQEMUCapsFillDomainLoaderCaps(virDomainCapsLoader *capsLoader,
5881 bool secure,
5882 virFirmware **firmwares,
5883 size_t nfirmwares)
5884 {
5885 size_t i;
5886
5887 capsLoader->supported = VIR_TRISTATE_BOOL_YES;
5888 capsLoader->type.report = true;
5889 capsLoader->readonly.report = true;
5890 capsLoader->secure.report = true;
5891
5892 capsLoader->values.values = g_new0(char *, nfirmwares);
5893
5894 for (i = 0; i < nfirmwares; i++) {
5895 const char *filename = firmwares[i]->name;
5896 size_t j;
5897
5898 if (!virFileExists(filename)) {
5899 VIR_DEBUG("loader filename=%s does not exist", filename);
5900 continue;
5901 }
5902
5903 /* Put only unique FW images onto the list */
5904 for (j = 0; j < capsLoader->values.nvalues; j++) {
5905 if (STREQ(filename, capsLoader->values.values[j]))
5906 break;
5907 }
5908
5909 if (j != capsLoader->values.nvalues)
5910 continue;
5911
5912 capsLoader->values.values[capsLoader->values.nvalues] = g_strdup(filename);
5913 capsLoader->values.nvalues++;
5914 }
5915
5916 VIR_DOMAIN_CAPS_ENUM_SET(capsLoader->type,
5917 VIR_DOMAIN_LOADER_TYPE_ROM);
5918
5919 VIR_DOMAIN_CAPS_ENUM_SET(capsLoader->type,
5920 VIR_DOMAIN_LOADER_TYPE_PFLASH);
5921
5922
5923 VIR_DOMAIN_CAPS_ENUM_SET(capsLoader->readonly,
5924 VIR_TRISTATE_BOOL_YES,
5925 VIR_TRISTATE_BOOL_NO);
5926
5927 VIR_DOMAIN_CAPS_ENUM_SET(capsLoader->secure,
5928 VIR_TRISTATE_BOOL_NO);
5929
5930 if (secure)
5931 VIR_DOMAIN_CAPS_ENUM_SET(capsLoader->secure,
5932 VIR_TRISTATE_BOOL_YES);
5933
5934 return 0;
5935 }
5936
5937
5938 static int
virQEMUCapsFillDomainOSCaps(virDomainCapsOS * os,const char * machine,virArch arch,bool privileged,virFirmware ** firmwares,size_t nfirmwares)5939 virQEMUCapsFillDomainOSCaps(virDomainCapsOS *os,
5940 const char *machine,
5941 virArch arch,
5942 bool privileged,
5943 virFirmware **firmwares,
5944 size_t nfirmwares)
5945 {
5946 virDomainCapsLoader *capsLoader = &os->loader;
5947 uint64_t autoFirmwares = 0;
5948 bool secure = false;
5949 virFirmware **firmwaresAlt = NULL;
5950 size_t nfirmwaresAlt = 0;
5951 int ret = -1;
5952
5953 os->supported = VIR_TRISTATE_BOOL_YES;
5954 os->firmware.report = true;
5955
5956 if (qemuFirmwareGetSupported(machine, arch, privileged,
5957 &autoFirmwares, &secure,
5958 &firmwaresAlt, &nfirmwaresAlt) < 0)
5959 return -1;
5960
5961 if (autoFirmwares & (1ULL << VIR_DOMAIN_OS_DEF_FIRMWARE_BIOS))
5962 VIR_DOMAIN_CAPS_ENUM_SET(os->firmware, VIR_DOMAIN_OS_DEF_FIRMWARE_BIOS);
5963 if (autoFirmwares & (1ULL << VIR_DOMAIN_OS_DEF_FIRMWARE_EFI))
5964 VIR_DOMAIN_CAPS_ENUM_SET(os->firmware, VIR_DOMAIN_OS_DEF_FIRMWARE_EFI);
5965
5966 if (virQEMUCapsFillDomainLoaderCaps(capsLoader, secure,
5967 firmwaresAlt ? firmwaresAlt : firmwares,
5968 firmwaresAlt ? nfirmwaresAlt : nfirmwares) < 0)
5969 goto cleanup;
5970
5971 ret = 0;
5972 cleanup:
5973 virFirmwareFreeList(firmwaresAlt, nfirmwaresAlt);
5974 return ret;
5975 }
5976
5977
5978 static void
virQEMUCapsFillDomainCPUCaps(virQEMUCaps * qemuCaps,virArch hostarch,virDomainCaps * domCaps)5979 virQEMUCapsFillDomainCPUCaps(virQEMUCaps *qemuCaps,
5980 virArch hostarch,
5981 virDomainCaps *domCaps)
5982 {
5983 if (virQEMUCapsIsCPUModeSupported(qemuCaps, hostarch, domCaps->virttype,
5984 VIR_CPU_MODE_HOST_PASSTHROUGH,
5985 domCaps->machine)) {
5986 domCaps->cpu.hostPassthrough = true;
5987
5988 domCaps->cpu.hostPassthroughMigratable.report = true;
5989 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_CPU_MIGRATABLE)) {
5990 VIR_DOMAIN_CAPS_ENUM_SET(domCaps->cpu.hostPassthroughMigratable,
5991 VIR_TRISTATE_SWITCH_ON);
5992 }
5993 VIR_DOMAIN_CAPS_ENUM_SET(domCaps->cpu.hostPassthroughMigratable,
5994 VIR_TRISTATE_SWITCH_OFF);
5995 }
5996
5997 if (virQEMUCapsIsCPUModeSupported(qemuCaps, hostarch, domCaps->virttype,
5998 VIR_CPU_MODE_MAXIMUM,
5999 domCaps->machine)) {
6000 domCaps->cpu.maximum = true;
6001
6002 domCaps->cpu.maximumMigratable.report = true;
6003 VIR_DOMAIN_CAPS_ENUM_SET(domCaps->cpu.maximumMigratable,
6004 VIR_TRISTATE_SWITCH_ON);
6005 VIR_DOMAIN_CAPS_ENUM_SET(domCaps->cpu.maximumMigratable,
6006 VIR_TRISTATE_SWITCH_OFF);
6007 }
6008
6009 if (virQEMUCapsIsCPUModeSupported(qemuCaps, hostarch, domCaps->virttype,
6010 VIR_CPU_MODE_HOST_MODEL,
6011 domCaps->machine)) {
6012 virCPUDef *cpu = virQEMUCapsGetHostModel(qemuCaps, domCaps->virttype,
6013 VIR_QEMU_CAPS_HOST_CPU_REPORTED);
6014 domCaps->cpu.hostModel = virCPUDefCopy(cpu);
6015 }
6016
6017 if (virQEMUCapsIsCPUModeSupported(qemuCaps, hostarch, domCaps->virttype,
6018 VIR_CPU_MODE_CUSTOM,
6019 domCaps->machine)) {
6020 const char *forbidden[] = { "host", NULL };
6021 g_auto(GStrv) models = NULL;
6022
6023 if (virCPUGetModels(domCaps->arch, &models) >= 0) {
6024 domCaps->cpu.custom = virQEMUCapsGetCPUModels(qemuCaps,
6025 domCaps->virttype,
6026 (const char **)models,
6027 forbidden);
6028 } else {
6029 domCaps->cpu.custom = NULL;
6030 }
6031 }
6032 }
6033
6034
6035 struct virQEMUCapsDomainFeatureCapabilityTuple {
6036 virDomainCapsFeature domcap;
6037 virQEMUCapsFlags qemucap;
6038 };
6039
6040 /**
6041 * This maps the qemu features to the entries in <features> of the domain
6042 * capability XML.
6043 * */
6044 static const struct virQEMUCapsDomainFeatureCapabilityTuple domCapsTuples[] = {
6045 { VIR_DOMAIN_CAPS_FEATURE_IOTHREADS, QEMU_CAPS_OBJECT_IOTHREAD },
6046 { VIR_DOMAIN_CAPS_FEATURE_VMCOREINFO, QEMU_CAPS_DEVICE_VMCOREINFO },
6047 { VIR_DOMAIN_CAPS_FEATURE_GENID, QEMU_CAPS_DEVICE_VMGENID },
6048 { VIR_DOMAIN_CAPS_FEATURE_BACKING_STORE_INPUT, QEMU_CAPS_BLOCKDEV },
6049 { VIR_DOMAIN_CAPS_FEATURE_BACKUP, QEMU_CAPS_INCREMENTAL_BACKUP },
6050 };
6051
6052
6053 static void
virQEMUCapsFillDomainFeaturesFromQEMUCaps(virQEMUCaps * qemuCaps,virDomainCaps * domCaps)6054 virQEMUCapsFillDomainFeaturesFromQEMUCaps(virQEMUCaps *qemuCaps,
6055 virDomainCaps *domCaps)
6056 {
6057 size_t i;
6058
6059 for (i = 0; i < G_N_ELEMENTS(domCapsTuples); i++) {
6060 if (virQEMUCapsGet(qemuCaps, domCapsTuples[i].qemucap))
6061 domCaps->features[domCapsTuples[i].domcap] = VIR_TRISTATE_BOOL_YES;
6062 else
6063 domCaps->features[domCapsTuples[i].domcap] = VIR_TRISTATE_BOOL_NO;
6064 }
6065 }
6066
6067
6068 void
virQEMUCapsFillDomainMemoryBackingCaps(virQEMUCaps * qemuCaps,virDomainCapsMemoryBacking * memoryBacking)6069 virQEMUCapsFillDomainMemoryBackingCaps(virQEMUCaps *qemuCaps,
6070 virDomainCapsMemoryBacking *memoryBacking)
6071 {
6072 memoryBacking->supported = VIR_TRISTATE_BOOL_YES;
6073 memoryBacking->sourceType.report = true;
6074
6075 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_MEMORY_MEMFD))
6076 VIR_DOMAIN_CAPS_ENUM_SET(memoryBacking->sourceType,
6077 VIR_DOMAIN_MEMORY_SOURCE_MEMFD);
6078
6079 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_MEMORY_FILE))
6080 VIR_DOMAIN_CAPS_ENUM_SET(memoryBacking->sourceType,
6081 VIR_DOMAIN_MEMORY_SOURCE_FILE);
6082
6083 VIR_DOMAIN_CAPS_ENUM_SET(memoryBacking->sourceType,
6084 VIR_DOMAIN_MEMORY_SOURCE_ANONYMOUS);
6085 }
6086
6087
6088 static void
virQEMUCapsFillDomainDeviceDiskCaps(virQEMUCaps * qemuCaps,const char * machine,virDomainCapsDeviceDisk * disk)6089 virQEMUCapsFillDomainDeviceDiskCaps(virQEMUCaps *qemuCaps,
6090 const char *machine,
6091 virDomainCapsDeviceDisk *disk)
6092 {
6093 disk->supported = VIR_TRISTATE_BOOL_YES;
6094 disk->diskDevice.report = true;
6095 disk->bus.report = true;
6096 disk->model.report = true;
6097
6098 /* QEMU supports all of these */
6099 VIR_DOMAIN_CAPS_ENUM_SET(disk->diskDevice,
6100 VIR_DOMAIN_DISK_DEVICE_DISK,
6101 VIR_DOMAIN_DISK_DEVICE_CDROM,
6102 VIR_DOMAIN_DISK_DEVICE_LUN);
6103
6104 /* PowerPC pseries based VMs do not support floppy device */
6105 if (!qemuDomainMachineIsPSeries(machine, qemuCaps->arch)) {
6106 VIR_DOMAIN_CAPS_ENUM_SET(disk->diskDevice, VIR_DOMAIN_DISK_DEVICE_FLOPPY);
6107 VIR_DOMAIN_CAPS_ENUM_SET(disk->bus, VIR_DOMAIN_DISK_BUS_FDC);
6108 }
6109
6110 if (qemuDomainMachineHasBuiltinIDE(machine, qemuCaps->arch))
6111 VIR_DOMAIN_CAPS_ENUM_SET(disk->bus, VIR_DOMAIN_DISK_BUS_IDE);
6112
6113 VIR_DOMAIN_CAPS_ENUM_SET(disk->bus,
6114 VIR_DOMAIN_DISK_BUS_SCSI,
6115 VIR_DOMAIN_DISK_BUS_VIRTIO,
6116 /* VIR_DOMAIN_DISK_BUS_SD */);
6117
6118 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_USB_STORAGE))
6119 VIR_DOMAIN_CAPS_ENUM_SET(disk->bus, VIR_DOMAIN_DISK_BUS_USB);
6120
6121 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_ICH9_AHCI))
6122 VIR_DOMAIN_CAPS_ENUM_SET(disk->bus, VIR_DOMAIN_DISK_BUS_SATA);
6123
6124 /* disk->model values */
6125 VIR_DOMAIN_CAPS_ENUM_SET(disk->model, VIR_DOMAIN_DISK_MODEL_VIRTIO);
6126 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY) ||
6127 virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL)) {
6128 VIR_DOMAIN_CAPS_ENUM_SET(disk->model,
6129 VIR_DOMAIN_DISK_MODEL_VIRTIO_TRANSITIONAL);
6130 VIR_DOMAIN_CAPS_ENUM_SET(disk->model,
6131 VIR_DOMAIN_DISK_MODEL_VIRTIO_NON_TRANSITIONAL);
6132 }
6133 }
6134
6135
6136 void
virQEMUCapsFillDomainDeviceGraphicsCaps(virQEMUCaps * qemuCaps,virDomainCapsDeviceGraphics * dev)6137 virQEMUCapsFillDomainDeviceGraphicsCaps(virQEMUCaps *qemuCaps,
6138 virDomainCapsDeviceGraphics *dev)
6139 {
6140 dev->supported = VIR_TRISTATE_BOOL_YES;
6141 dev->type.report = true;
6142
6143 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SDL))
6144 VIR_DOMAIN_CAPS_ENUM_SET(dev->type, VIR_DOMAIN_GRAPHICS_TYPE_SDL);
6145 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VNC))
6146 VIR_DOMAIN_CAPS_ENUM_SET(dev->type, VIR_DOMAIN_GRAPHICS_TYPE_VNC);
6147 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SPICE))
6148 VIR_DOMAIN_CAPS_ENUM_SET(dev->type, VIR_DOMAIN_GRAPHICS_TYPE_SPICE);
6149 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_EGL_HEADLESS))
6150 VIR_DOMAIN_CAPS_ENUM_SET(dev->type, VIR_DOMAIN_GRAPHICS_TYPE_EGL_HEADLESS);
6151 }
6152
6153
6154 void
virQEMUCapsFillDomainDeviceVideoCaps(virQEMUCaps * qemuCaps,virDomainCapsDeviceVideo * dev)6155 virQEMUCapsFillDomainDeviceVideoCaps(virQEMUCaps *qemuCaps,
6156 virDomainCapsDeviceVideo *dev)
6157 {
6158 dev->supported = VIR_TRISTATE_BOOL_YES;
6159 dev->modelType.report = true;
6160
6161 VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_NONE);
6162 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VGA))
6163 VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_VGA);
6164 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_CIRRUS_VGA))
6165 VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_CIRRUS);
6166 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VMWARE_SVGA))
6167 VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_VMVGA);
6168 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QXL))
6169 VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_QXL);
6170 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VIRTIO_GPU))
6171 VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_VIRTIO);
6172 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_BOCHS_DISPLAY))
6173 VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_BOCHS);
6174 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_RAMFB))
6175 VIR_DOMAIN_CAPS_ENUM_SET(dev->modelType, VIR_DOMAIN_VIDEO_TYPE_RAMFB);
6176 }
6177
6178
6179 static void
virQEMUCapsFillDomainDeviceHostdevCaps(virQEMUCaps * qemuCaps,virDomainCapsDeviceHostdev * hostdev)6180 virQEMUCapsFillDomainDeviceHostdevCaps(virQEMUCaps *qemuCaps,
6181 virDomainCapsDeviceHostdev *hostdev)
6182 {
6183 bool supportsPassthroughVFIO = qemuHostdevHostSupportsPassthroughVFIO();
6184
6185 hostdev->supported = VIR_TRISTATE_BOOL_YES;
6186 hostdev->mode.report = true;
6187 hostdev->startupPolicy.report = true;
6188 hostdev->subsysType.report = true;
6189 hostdev->capsType.report = true;
6190 hostdev->pciBackend.report = true;
6191
6192 /* VIR_DOMAIN_HOSTDEV_MODE_CAPABILITIES is for containers only */
6193 VIR_DOMAIN_CAPS_ENUM_SET(hostdev->mode,
6194 VIR_DOMAIN_HOSTDEV_MODE_SUBSYS);
6195
6196 VIR_DOMAIN_CAPS_ENUM_SET(hostdev->startupPolicy,
6197 VIR_DOMAIN_STARTUP_POLICY_DEFAULT,
6198 VIR_DOMAIN_STARTUP_POLICY_MANDATORY,
6199 VIR_DOMAIN_STARTUP_POLICY_REQUISITE,
6200 VIR_DOMAIN_STARTUP_POLICY_OPTIONAL);
6201
6202 VIR_DOMAIN_CAPS_ENUM_SET(hostdev->subsysType,
6203 VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI,
6204 VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI);
6205
6206 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_PIIX3_USB_UHCI) ||
6207 virQEMUCapsGet(qemuCaps, QEMU_CAPS_PIIX4_USB_UHCI) ||
6208 virQEMUCapsGet(qemuCaps, QEMU_CAPS_USB_EHCI) ||
6209 virQEMUCapsGet(qemuCaps, QEMU_CAPS_ICH9_USB_EHCI1) ||
6210 virQEMUCapsGet(qemuCaps, QEMU_CAPS_VT82C686B_USB_UHCI) ||
6211 virQEMUCapsGet(qemuCaps, QEMU_CAPS_PCI_OHCI) ||
6212 virQEMUCapsGet(qemuCaps, QEMU_CAPS_NEC_USB_XHCI) ||
6213 virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QEMU_XHCI)) {
6214 VIR_DOMAIN_CAPS_ENUM_SET(hostdev->subsysType,
6215 VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB);
6216 }
6217
6218 /* No virDomainHostdevCapsType for QEMU */
6219 virDomainCapsEnumClear(&hostdev->capsType);
6220
6221 virDomainCapsEnumClear(&hostdev->pciBackend);
6222 if (supportsPassthroughVFIO &&
6223 virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VFIO_PCI)) {
6224 VIR_DOMAIN_CAPS_ENUM_SET(hostdev->pciBackend,
6225 VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT,
6226 VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO);
6227 }
6228 }
6229
6230
6231 void
virQEMUCapsFillDomainDeviceRNGCaps(virQEMUCaps * qemuCaps,virDomainCapsDeviceRNG * rng)6232 virQEMUCapsFillDomainDeviceRNGCaps(virQEMUCaps *qemuCaps,
6233 virDomainCapsDeviceRNG *rng)
6234 {
6235 rng->supported = VIR_TRISTATE_BOOL_YES;
6236 rng->model.report = true;
6237 rng->backendModel.report = true;
6238
6239 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VIRTIO_RNG)) {
6240 VIR_DOMAIN_CAPS_ENUM_SET(rng->model, VIR_DOMAIN_RNG_MODEL_VIRTIO);
6241
6242 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_PCI_TRANSITIONAL) ||
6243 virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY)) {
6244 VIR_DOMAIN_CAPS_ENUM_SET(rng->model,
6245 VIR_DOMAIN_RNG_MODEL_VIRTIO_TRANSITIONAL,
6246 VIR_DOMAIN_RNG_MODEL_VIRTIO_NON_TRANSITIONAL);
6247 }
6248 }
6249
6250 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_RNG_EGD))
6251 VIR_DOMAIN_CAPS_ENUM_SET(rng->backendModel, VIR_DOMAIN_RNG_BACKEND_EGD);
6252 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_RNG_RANDOM))
6253 VIR_DOMAIN_CAPS_ENUM_SET(rng->backendModel, VIR_DOMAIN_RNG_BACKEND_RANDOM);
6254 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_RNG_BUILTIN))
6255 VIR_DOMAIN_CAPS_ENUM_SET(rng->backendModel, VIR_DOMAIN_RNG_BACKEND_BUILTIN);
6256 }
6257
6258
6259 void
virQEMUCapsFillDomainDeviceFSCaps(virQEMUCaps * qemuCaps,virDomainCapsDeviceFilesystem * filesystem)6260 virQEMUCapsFillDomainDeviceFSCaps(virQEMUCaps *qemuCaps,
6261 virDomainCapsDeviceFilesystem *filesystem)
6262 {
6263 filesystem->supported = VIR_TRISTATE_BOOL_YES;
6264 filesystem->driverType.report = true;
6265
6266 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VHOST_USER_FS))
6267 VIR_DOMAIN_CAPS_ENUM_SET(filesystem->driverType,
6268 VIR_DOMAIN_FS_DRIVER_TYPE_VIRTIOFS);
6269
6270 VIR_DOMAIN_CAPS_ENUM_SET(filesystem->driverType,
6271 VIR_DOMAIN_FS_DRIVER_TYPE_PATH,
6272 VIR_DOMAIN_FS_DRIVER_TYPE_HANDLE);
6273 }
6274
6275
6276 /**
6277 * virQEMUCapsSupportsGICVersion:
6278 * @qemuCaps: QEMU capabilities
6279 * @virtType: domain type
6280 * @version: GIC version
6281 *
6282 * Checks the QEMU binary with capabilities @qemuCaps supports a specific
6283 * GIC version for a domain of type @virtType. If @qemuCaps is NULL, the GIC
6284 * @version is considered unsupported.
6285 *
6286 * Returns: true if the binary supports the requested GIC version, false
6287 * otherwise
6288 */
6289 bool
virQEMUCapsSupportsGICVersion(virQEMUCaps * qemuCaps,virDomainVirtType virtType,virGICVersion version)6290 virQEMUCapsSupportsGICVersion(virQEMUCaps *qemuCaps,
6291 virDomainVirtType virtType,
6292 virGICVersion version)
6293 {
6294 size_t i;
6295
6296 if (!qemuCaps)
6297 return false;
6298
6299 for (i = 0; i < qemuCaps->ngicCapabilities; i++) {
6300 virGICCapability *cap = &(qemuCaps->gicCapabilities[i]);
6301
6302 if (cap->version != version)
6303 continue;
6304
6305 if (virtType == VIR_DOMAIN_VIRT_KVM &&
6306 cap->implementation & VIR_GIC_IMPLEMENTATION_KERNEL)
6307 return true;
6308
6309 if (virtType == VIR_DOMAIN_VIRT_QEMU &&
6310 cap->implementation & VIR_GIC_IMPLEMENTATION_EMULATED)
6311 return true;
6312 }
6313
6314 return false;
6315 }
6316
6317
6318 /**
6319 * virQEMUCapsFillDomainFeatureGICCaps:
6320 * @qemuCaps: QEMU capabilities
6321 * @domCaps: domain capabilities
6322 *
6323 * Take the information about GIC capabilities that has been obtained
6324 * using the 'query-gic-capabilities' QMP command and stored in @qemuCaps
6325 * and convert it to a form suitable for @domCaps.
6326 *
6327 * @qemuCaps contains complete information about the GIC capabilities for
6328 * the corresponding QEMU binary, stored as custom objects; @domCaps, on
6329 * the other hand, should only contain information about the GIC versions
6330 * available for the specific combination of architecture, machine type
6331 * and virtualization type. Moreover, a common format is used to store
6332 * information about enumerations in @domCaps, so further processing is
6333 * required.
6334 */
6335 static void
virQEMUCapsFillDomainFeatureGICCaps(virQEMUCaps * qemuCaps,virDomainCaps * domCaps)6336 virQEMUCapsFillDomainFeatureGICCaps(virQEMUCaps *qemuCaps,
6337 virDomainCaps *domCaps)
6338 {
6339 virDomainCapsFeatureGIC *gic = &domCaps->gic;
6340 virGICVersion version;
6341
6342 gic->supported = VIR_TRISTATE_BOOL_NO;
6343
6344 if (!qemuDomainMachineIsARMVirt(domCaps->machine, domCaps->arch))
6345 return;
6346
6347 for (version = VIR_GIC_VERSION_LAST - 1;
6348 version > VIR_GIC_VERSION_NONE;
6349 version--) {
6350 if (!virQEMUCapsSupportsGICVersion(qemuCaps,
6351 domCaps->virttype,
6352 version))
6353 continue;
6354
6355 gic->supported = VIR_TRISTATE_BOOL_YES;
6356 gic->version.report = true;
6357 VIR_DOMAIN_CAPS_ENUM_SET(gic->version,
6358 version);
6359 }
6360 }
6361
6362
6363 /**
6364 * virQEMUCapsFillDomainFeatureSEVCaps:
6365 * @qemuCaps: QEMU capabilities
6366 * @domCaps: domain capabilities
6367 *
6368 * Take the information about SEV capabilities that has been obtained
6369 * using the 'query-sev-capabilities' QMP command and stored in @qemuCaps
6370 * and convert it to a form suitable for @domCaps.
6371 */
6372 static void
virQEMUCapsFillDomainFeatureSEVCaps(virQEMUCaps * qemuCaps,virDomainCaps * domCaps)6373 virQEMUCapsFillDomainFeatureSEVCaps(virQEMUCaps *qemuCaps,
6374 virDomainCaps *domCaps)
6375 {
6376 virSEVCapability *cap = qemuCaps->sevCapabilities;
6377
6378 if (!cap)
6379 return;
6380
6381 domCaps->sev = g_new0(virSEVCapability, 1);
6382
6383 domCaps->sev->pdh = g_strdup(cap->pdh);
6384 domCaps->sev->cert_chain = g_strdup(cap->cert_chain);
6385 domCaps->sev->cbitpos = cap->cbitpos;
6386 domCaps->sev->reduced_phys_bits = cap->reduced_phys_bits;
6387 }
6388
6389
6390 static void
virQEMUCapsFillDomainFeatureS390PVCaps(virQEMUCaps * qemuCaps,virDomainCaps * domCaps)6391 virQEMUCapsFillDomainFeatureS390PVCaps(virQEMUCaps *qemuCaps,
6392 virDomainCaps *domCaps)
6393 {
6394 if (ARCH_IS_S390(qemuCaps->arch)) {
6395 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_MACHINE_CONFIDENTAL_GUEST_SUPPORT) &&
6396 virQEMUCapsGet(qemuCaps, QEMU_CAPS_S390_PV_GUEST) &&
6397 virQEMUCapsGetKVMSupportsSecureGuest(qemuCaps))
6398 domCaps->features[VIR_DOMAIN_CAPS_FEATURE_S390_PV] = VIR_TRISTATE_BOOL_YES;
6399 else
6400 domCaps->features[VIR_DOMAIN_CAPS_FEATURE_S390_PV] = VIR_TRISTATE_BOOL_NO;
6401 }
6402 }
6403
6404
6405 int
virQEMUCapsFillDomainCaps(virQEMUCaps * qemuCaps,virArch hostarch,virDomainCaps * domCaps,bool privileged,virFirmware ** firmwares,size_t nfirmwares)6406 virQEMUCapsFillDomainCaps(virQEMUCaps *qemuCaps,
6407 virArch hostarch,
6408 virDomainCaps *domCaps,
6409 bool privileged,
6410 virFirmware **firmwares,
6411 size_t nfirmwares)
6412 {
6413 virDomainCapsOS *os = &domCaps->os;
6414 virDomainCapsDeviceDisk *disk = &domCaps->disk;
6415 virDomainCapsDeviceHostdev *hostdev = &domCaps->hostdev;
6416 virDomainCapsDeviceGraphics *graphics = &domCaps->graphics;
6417 virDomainCapsDeviceVideo *video = &domCaps->video;
6418 virDomainCapsDeviceRNG *rng = &domCaps->rng;
6419 virDomainCapsDeviceFilesystem *filesystem = &domCaps->filesystem;
6420 virDomainCapsMemoryBacking *memoryBacking = &domCaps->memoryBacking;
6421
6422 virQEMUCapsFillDomainFeaturesFromQEMUCaps(qemuCaps, domCaps);
6423
6424 domCaps->maxvcpus = virQEMUCapsGetMachineMaxCpus(qemuCaps,
6425 domCaps->virttype,
6426 domCaps->machine);
6427 if (domCaps->virttype == VIR_DOMAIN_VIRT_KVM) {
6428 int hostmaxvcpus;
6429
6430 if ((hostmaxvcpus = virHostCPUGetKVMMaxVCPUs()) < 0)
6431 return -1;
6432
6433 domCaps->maxvcpus = MIN(domCaps->maxvcpus, hostmaxvcpus);
6434 }
6435
6436 if (virQEMUCapsFillDomainOSCaps(os,
6437 domCaps->machine,
6438 domCaps->arch,
6439 privileged,
6440 firmwares, nfirmwares) < 0)
6441 return -1;
6442
6443 virQEMUCapsFillDomainCPUCaps(qemuCaps, hostarch, domCaps);
6444 virQEMUCapsFillDomainMemoryBackingCaps(qemuCaps, memoryBacking);
6445 virQEMUCapsFillDomainDeviceDiskCaps(qemuCaps, domCaps->machine, disk);
6446 virQEMUCapsFillDomainDeviceGraphicsCaps(qemuCaps, graphics);
6447 virQEMUCapsFillDomainDeviceVideoCaps(qemuCaps, video);
6448 virQEMUCapsFillDomainDeviceHostdevCaps(qemuCaps, hostdev);
6449 virQEMUCapsFillDomainDeviceRNGCaps(qemuCaps, rng);
6450 virQEMUCapsFillDomainDeviceFSCaps(qemuCaps, filesystem);
6451 virQEMUCapsFillDomainFeatureGICCaps(qemuCaps, domCaps);
6452 virQEMUCapsFillDomainFeatureSEVCaps(qemuCaps, domCaps);
6453 virQEMUCapsFillDomainFeatureS390PVCaps(qemuCaps, domCaps);
6454
6455 return 0;
6456 }
6457
6458
6459 void
virQEMUCapsSetMicrocodeVersion(virQEMUCaps * qemuCaps,unsigned int microcodeVersion)6460 virQEMUCapsSetMicrocodeVersion(virQEMUCaps *qemuCaps,
6461 unsigned int microcodeVersion)
6462 {
6463 qemuCaps->microcodeVersion = microcodeVersion;
6464 }
6465
6466
6467 static void
virQEMUCapsStripMachineAliasesForVirtType(virQEMUCaps * qemuCaps,virDomainVirtType virtType)6468 virQEMUCapsStripMachineAliasesForVirtType(virQEMUCaps *qemuCaps,
6469 virDomainVirtType virtType)
6470 {
6471 virQEMUCapsAccel *accel = virQEMUCapsGetAccel(qemuCaps, virtType);
6472 size_t i;
6473
6474 for (i = 0; i < accel->nmachineTypes; i++) {
6475 virQEMUCapsMachineType *mach = &accel->machineTypes[i];
6476 g_autofree char *name = g_steal_pointer(&mach->alias);
6477
6478 if (name) {
6479 virQEMUCapsAddMachine(qemuCaps, virtType, name, NULL, mach->defaultCPU,
6480 mach->maxCpus, mach->hotplugCpus, mach->qemuDefault,
6481 mach->numaMemSupported, mach->defaultRAMid,
6482 mach->deprecated);
6483 }
6484 }
6485 }
6486
6487
6488 /**
6489 * virQEMUCapsStripMachineAliases:
6490 * @qemuCaps: capabilities object to process
6491 *
6492 * Replace all aliases by the copy of the machine type they point to without
6493 * actually having to modify the name. This allows us to add tests with the
6494 * aliased machine without having to change the output files all the time.
6495 *
6496 * Remove all aliases so that the tests depending on the latest capabilities
6497 * file can be stable when new files are added.
6498 */
6499 void
virQEMUCapsStripMachineAliases(virQEMUCaps * qemuCaps)6500 virQEMUCapsStripMachineAliases(virQEMUCaps *qemuCaps)
6501 {
6502 virQEMUCapsStripMachineAliasesForVirtType(qemuCaps, VIR_DOMAIN_VIRT_KVM);
6503 virQEMUCapsStripMachineAliasesForVirtType(qemuCaps, VIR_DOMAIN_VIRT_QEMU);
6504 }
6505