1 /*
2 * qemu_domain_address.c: QEMU domain address
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_domain_address.h"
25 #include "qemu_domain.h"
26 #include "viralloc.h"
27 #include "virerror.h"
28 #include "virlog.h"
29
30 #define VIR_FROM_THIS VIR_FROM_QEMU
31
32 VIR_LOG_INIT("qemu.qemu_domain_address");
33
34 #define VIO_ADDR_NET 0x1000ul
35 #define VIO_ADDR_SCSI 0x2000ul
36 #define VIO_ADDR_SERIAL 0x30000000ul
37 #define VIO_ADDR_NVRAM 0x3000ul
38 #define VIO_ADDR_TPM 0x4000ul
39
40
41 /**
42 * @def: Domain definition
43 * @cont: Domain controller def
44 * @qemuCaps: qemu capabilities
45 *
46 * If the controller model is already defined, return it immediately;
47 * otherwise, based on the @qemuCaps return a default model value.
48 *
49 * Returns model on success, -1 on failure with error set.
50 */
51 int
qemuDomainGetSCSIControllerModel(const virDomainDef * def,const virDomainControllerDef * cont,virQEMUCaps * qemuCaps)52 qemuDomainGetSCSIControllerModel(const virDomainDef *def,
53 const virDomainControllerDef *cont,
54 virQEMUCaps *qemuCaps)
55 {
56 if (cont->model > 0)
57 return cont->model;
58
59 if (qemuDomainIsPSeries(def))
60 return VIR_DOMAIN_CONTROLLER_MODEL_SCSI_IBMVSCSI;
61 if (ARCH_IS_S390(def->os.arch))
62 return VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_SCSI;
63 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_LSI))
64 return VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC;
65 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_SCSI))
66 return VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_SCSI;
67 if (qemuDomainHasBuiltinESP(def))
68 return VIR_DOMAIN_CONTROLLER_MODEL_SCSI_NCR53C90;
69
70 virReportError(VIR_ERR_INTERNAL_ERROR,
71 _("Unable to determine model for SCSI controller idx=%d"),
72 cont->idx);
73 return -1;
74 }
75
76
77 /**
78 * @def: Domain definition
79 * @cont: Domain controller def
80 * @qemuCaps: qemu capabilities
81 *
82 * Set the controller model based on the existing value and the
83 * capabilities if possible.
84 *
85 * Returns 0 on success, -1 on failure with error set.
86 */
87 int
qemuDomainSetSCSIControllerModel(const virDomainDef * def,virDomainControllerDef * cont,virQEMUCaps * qemuCaps)88 qemuDomainSetSCSIControllerModel(const virDomainDef *def,
89 virDomainControllerDef *cont,
90 virQEMUCaps *qemuCaps)
91 {
92 int model = qemuDomainGetSCSIControllerModel(def, cont, qemuCaps);
93
94 if (model < 0)
95 return -1;
96
97 cont->model = model;
98 return 0;
99 }
100
101
102 /**
103 * @def: Domain definition
104 * @info: Domain device info
105 *
106 * Using the device info, find the controller related to the
107 * device by index and use that controller to return the model.
108 *
109 * Returns the model if found, -1 if not with an error message set
110 */
111 int
qemuDomainFindSCSIControllerModel(const virDomainDef * def,virDomainDeviceInfo * info)112 qemuDomainFindSCSIControllerModel(const virDomainDef *def,
113 virDomainDeviceInfo *info)
114 {
115 virDomainControllerDef *cont;
116
117 if (!(cont = virDomainDeviceFindSCSIController(def, &info->addr.drive))) {
118 virReportError(VIR_ERR_INTERNAL_ERROR,
119 _("unable to find a SCSI controller for idx=%d"),
120 info->addr.drive.controller);
121 return -1;
122 }
123
124 return cont->model;
125 }
126
127
128 static int
qemuDomainAssignVirtioSerialAddresses(virDomainDef * def)129 qemuDomainAssignVirtioSerialAddresses(virDomainDef *def)
130 {
131 int ret = -1;
132 size_t i;
133 virDomainVirtioSerialAddrSet *addrs = NULL;
134
135 if (!(addrs = virDomainVirtioSerialAddrSetCreateFromDomain(def)))
136 goto cleanup;
137
138 VIR_DEBUG("Finished reserving existing ports");
139
140 for (i = 0; i < def->nconsoles; i++) {
141 virDomainChrDef *chr = def->consoles[i];
142 if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE &&
143 chr->targetType == VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO &&
144 !virDomainVirtioSerialAddrIsComplete(&chr->info) &&
145 virDomainVirtioSerialAddrAutoAssignFromCache(def, addrs,
146 &chr->info, true) < 0)
147 goto cleanup;
148 }
149
150 for (i = 0; i < def->nchannels; i++) {
151 virDomainChrDef *chr = def->channels[i];
152 if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL &&
153 chr->targetType == VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO &&
154 !virDomainVirtioSerialAddrIsComplete(&chr->info) &&
155 virDomainVirtioSerialAddrAutoAssignFromCache(def, addrs,
156 &chr->info, false) < 0)
157 goto cleanup;
158 }
159
160 ret = 0;
161
162 cleanup:
163 virDomainVirtioSerialAddrSetFree(addrs);
164 return ret;
165 }
166
167
168 static int
qemuDomainSpaprVIOFindByReg(virDomainDef * def G_GNUC_UNUSED,virDomainDeviceDef * device G_GNUC_UNUSED,virDomainDeviceInfo * info,void * opaque)169 qemuDomainSpaprVIOFindByReg(virDomainDef *def G_GNUC_UNUSED,
170 virDomainDeviceDef *device G_GNUC_UNUSED,
171 virDomainDeviceInfo *info, void *opaque)
172 {
173 virDomainDeviceInfo *target = opaque;
174
175 if (info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO)
176 return 0;
177
178 /* Match a dev that has a reg, is not us, and has a matching reg */
179 if (info->addr.spaprvio.has_reg && info != target &&
180 info->addr.spaprvio.reg == target->addr.spaprvio.reg)
181 /* Has to be < 0 so virDomainDeviceInfoIterate() will exit */
182 return -1;
183
184 return 0;
185 }
186
187
188 static int
qemuDomainAssignSpaprVIOAddress(virDomainDef * def,virDomainDeviceInfo * info,unsigned long long default_reg)189 qemuDomainAssignSpaprVIOAddress(virDomainDef *def,
190 virDomainDeviceInfo *info,
191 unsigned long long default_reg)
192 {
193 bool user_reg;
194 int ret;
195
196 if (info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO)
197 return 0;
198
199 /* Check if the user has assigned the reg already, if so use it */
200 user_reg = info->addr.spaprvio.has_reg;
201 if (!user_reg) {
202 info->addr.spaprvio.reg = default_reg;
203 info->addr.spaprvio.has_reg = true;
204 }
205
206 ret = virDomainDeviceInfoIterate(def, qemuDomainSpaprVIOFindByReg, info);
207 while (ret != 0) {
208 if (user_reg) {
209 virReportError(VIR_ERR_XML_ERROR,
210 _("spapr-vio address %#llx already in use"),
211 info->addr.spaprvio.reg);
212 return -EEXIST;
213 }
214
215 /* We assigned the reg, so try a new value */
216 info->addr.spaprvio.reg += 0x1000;
217 ret = virDomainDeviceInfoIterate(def, qemuDomainSpaprVIOFindByReg,
218 info);
219 }
220
221 return 0;
222 }
223
224
225 static int
qemuDomainAssignSpaprVIOAddresses(virDomainDef * def)226 qemuDomainAssignSpaprVIOAddresses(virDomainDef *def)
227 {
228 size_t i;
229
230 /* Default values match QEMU. See spapr_(llan|vscsi|vty).c */
231
232 for (i = 0; i < def->nnets; i++) {
233 virDomainNetDef *net = def->nets[i];
234
235 if (net->model == VIR_DOMAIN_NET_MODEL_SPAPR_VLAN)
236 net->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO;
237
238 if (qemuDomainAssignSpaprVIOAddress(def, &net->info, VIO_ADDR_NET) < 0)
239 return -1;
240 }
241
242 for (i = 0; i < def->ncontrollers; i++) {
243 virDomainControllerDef *cont = def->controllers[i];
244
245 if (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_IBMVSCSI &&
246 cont->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI) {
247 cont->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO;
248 }
249 if (qemuDomainAssignSpaprVIOAddress(def, &cont->info,
250 VIO_ADDR_SCSI) < 0) {
251 return -1;
252 }
253 }
254
255 for (i = 0; i < def->nserials; i++) {
256 if (def->serials[i]->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL &&
257 def->serials[i]->targetType == VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_SPAPR_VIO) {
258 def->serials[i]->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO;
259 }
260 if (qemuDomainAssignSpaprVIOAddress(def, &def->serials[i]->info,
261 VIO_ADDR_SERIAL) < 0)
262 return -1;
263 }
264
265 if (def->nvram) {
266 if (qemuDomainIsPSeries(def))
267 def->nvram->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO;
268 if (qemuDomainAssignSpaprVIOAddress(def, &def->nvram->info,
269 VIO_ADDR_NVRAM) < 0)
270 return -1;
271 }
272
273 for (i = 0; i < def->ntpms; i++) {
274 virDomainTPMDef *tpm = def->tpms[i];
275
276 if (tpm->model != VIR_DOMAIN_TPM_MODEL_SPAPR_PROXY &&
277 qemuDomainIsPSeries(def))
278 tpm->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO;
279 if (qemuDomainAssignSpaprVIOAddress(def, &tpm->info,
280 VIO_ADDR_TPM) < 0)
281 return -1;
282 }
283
284 /* No other devices are currently supported on spapr-vio */
285
286 return 0;
287 }
288
289
290 static void
qemuDomainPrimeVfioDeviceAddresses(virDomainDef * def,virDomainDeviceAddressType type)291 qemuDomainPrimeVfioDeviceAddresses(virDomainDef *def,
292 virDomainDeviceAddressType type)
293 {
294 size_t i;
295
296 for (i = 0; i < def->nhostdevs; i++) {
297 virDomainHostdevSubsys *subsys = &def->hostdevs[i]->source.subsys;
298
299 if (virHostdevIsMdevDevice(def->hostdevs[i]) &&
300 subsys->u.mdev.model == VIR_MDEV_MODEL_TYPE_VFIO_CCW &&
301 def->hostdevs[i]->info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
302 def->hostdevs[i]->info->type = type;
303
304 if (virHostdevIsMdevDevice(def->hostdevs[i]) &&
305 subsys->u.mdev.model == VIR_MDEV_MODEL_TYPE_VFIO_AP)
306 def->hostdevs[i]->info->type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE;
307 }
308 }
309
310
311 static void
qemuDomainPrimeVirtioDeviceAddresses(virDomainDef * def,virDomainDeviceAddressType type)312 qemuDomainPrimeVirtioDeviceAddresses(virDomainDef *def,
313 virDomainDeviceAddressType type)
314 {
315 /*
316 Declare address-less virtio devices to be of address type 'type'
317 disks, networks, videos, consoles, controllers, hostdevs, memballoon,
318 rngs and memories in this order.
319 If type is ccw filesystem and vsock devices are declared to be of
320 address type ccw.
321 */
322 size_t i;
323
324 for (i = 0; i < def->ndisks; i++) {
325 if (def->disks[i]->bus == VIR_DOMAIN_DISK_BUS_VIRTIO &&
326 def->disks[i]->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
327 def->disks[i]->info.type = type;
328 }
329
330 for (i = 0; i < def->nnets; i++) {
331 virDomainNetDef *net = def->nets[i];
332
333 if (virDomainNetIsVirtioModel(net) &&
334 net->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
335 net->info.type = type;
336 }
337 }
338
339 for (i = 0; i < def->nvideos; i++) {
340 virDomainVideoDef *video = def->videos[i];
341
342 if (video->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE &&
343 video->type == VIR_DOMAIN_VIDEO_TYPE_VIRTIO)
344 video->info.type = type;
345 }
346
347 for (i = 0; i < def->ninputs; i++) {
348 if (def->inputs[i]->bus == VIR_DOMAIN_INPUT_BUS_VIRTIO &&
349 def->inputs[i]->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
350 def->inputs[i]->info.type = type;
351 }
352
353 for (i = 0; i < def->ncontrollers; i++) {
354 virDomainControllerDef *cont = def->controllers[i];
355
356 if ((cont->type == VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL ||
357 cont->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI) &&
358 cont->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
359 cont->info.type = type;
360 }
361 }
362
363 for (i = 0; i < def->nhostdevs; i++) {
364 if (def->hostdevs[i]->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
365 def->hostdevs[i]->source.subsys.type ==
366 VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI_HOST &&
367 def->hostdevs[i]->info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
368 def->hostdevs[i]->info->type = type;
369 }
370
371 /* All memballoon devices accepted by the qemu driver are virtio */
372 if (virDomainDefHasMemballoon(def) &&
373 def->memballoon->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
374 def->memballoon->info.type = type;
375
376 for (i = 0; i < def->nrngs; i++) {
377 /* All <rng> devices accepted by the qemu driver are virtio */
378 if (def->rngs[i]->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
379 def->rngs[i]->info.type = type;
380 }
381
382 for (i = 0; i < def->nmems; i++) {
383 switch (def->mems[i]->model) {
384 case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
385 case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM:
386 if (def->mems[i]->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
387 def->mems[i]->info.type = type;
388 break;
389 case VIR_DOMAIN_MEMORY_MODEL_NONE:
390 case VIR_DOMAIN_MEMORY_MODEL_DIMM:
391 case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
392 case VIR_DOMAIN_MEMORY_MODEL_LAST:
393 break;
394 }
395 }
396
397 if (type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW) {
398 for (i = 0; i < def->nfss; i++) {
399 if (def->fss[i]->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
400 def->fss[i]->info.type = type;
401 }
402 if (def->vsock &&
403 def->vsock->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
404 def->vsock->info.type = type;
405 }
406 }
407 }
408
409
410 /*
411 * Three steps populating CCW devnos
412 * 1. Allocate empty address set
413 * 2. Gather addresses with explicit devno
414 * 3. Assign defaults to the rest
415 */
416 static int
qemuDomainAssignS390Addresses(virDomainDef * def,virQEMUCaps * qemuCaps)417 qemuDomainAssignS390Addresses(virDomainDef *def,
418 virQEMUCaps *qemuCaps)
419 {
420 int ret = -1;
421 virDomainCCWAddressSet *addrs = NULL;
422
423 if (qemuDomainIsS390CCW(def) &&
424 virQEMUCapsGet(qemuCaps, QEMU_CAPS_CCW)) {
425 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VFIO_CCW))
426 qemuDomainPrimeVfioDeviceAddresses(def, VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW);
427
428 qemuDomainPrimeVirtioDeviceAddresses(def, VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW);
429
430 if (!(addrs = virDomainCCWAddressSetCreateFromDomain(def)))
431 goto cleanup;
432
433 }
434
435 ret = 0;
436
437 cleanup:
438 virDomainCCWAddressSetFree(addrs);
439
440 return ret;
441 }
442
443
444 static int
qemuDomainHasVirtioMMIODevicesCallback(virDomainDef * def G_GNUC_UNUSED,virDomainDeviceDef * dev G_GNUC_UNUSED,virDomainDeviceInfo * info,void * opaque)445 qemuDomainHasVirtioMMIODevicesCallback(virDomainDef *def G_GNUC_UNUSED,
446 virDomainDeviceDef *dev G_GNUC_UNUSED,
447 virDomainDeviceInfo *info,
448 void *opaque)
449 {
450 if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_MMIO) {
451 /* We can stop iterating as soon as we find the first
452 * virtio-mmio device */
453 *((bool *)opaque) = true;
454 return -1;
455 }
456
457 return 0;
458 }
459
460
461 /**
462 * qemuDomainHasVirtioMMIODevices:
463 * @def: domain definition
464 *
465 * Scan @def looking for devices with a virtio-mmio address.
466 *
467 * Returns: true if there are any, false otherwise
468 */
469 static bool
qemuDomainHasVirtioMMIODevices(virDomainDef * def)470 qemuDomainHasVirtioMMIODevices(virDomainDef *def)
471 {
472 bool result = false;
473
474 virDomainDeviceInfoIterate(def,
475 qemuDomainHasVirtioMMIODevicesCallback,
476 &result);
477
478 return result;
479 }
480
481
482 static void
qemuDomainAssignVirtioMMIOAddresses(virDomainDef * def,virQEMUCaps * qemuCaps)483 qemuDomainAssignVirtioMMIOAddresses(virDomainDef *def,
484 virQEMUCaps *qemuCaps)
485 {
486 if (def->os.arch != VIR_ARCH_ARMV6L &&
487 def->os.arch != VIR_ARCH_ARMV7L &&
488 def->os.arch != VIR_ARCH_AARCH64 &&
489 !ARCH_IS_RISCV(def->os.arch)) {
490 return;
491 }
492
493 if (!(STRPREFIX(def->os.machine, "vexpress-") ||
494 qemuDomainIsARMVirt(def) ||
495 qemuDomainIsRISCVVirt(def))) {
496 return;
497 }
498
499 /* We use virtio-mmio by default on virt guests only if they already
500 * have at least one virtio-mmio device: in all other cases, assuming
501 * the QEMU binary supports all necessary capabilities (PCIe Root plus
502 * some kind of PCIe Root Port), we prefer virtio-pci */
503 if (qemuDomainHasPCIeRoot(def) &&
504 (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_PCIE_ROOT_PORT) ||
505 virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_IOH3420)) &&
506 !qemuDomainHasVirtioMMIODevices(def)) {
507 qemuDomainPrimeVirtioDeviceAddresses(def,
508 VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI);
509 } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VIRTIO_MMIO)) {
510 qemuDomainPrimeVirtioDeviceAddresses(def,
511 VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_MMIO);
512 }
513 }
514
515
516 static bool
qemuDomainDeviceSupportZPCI(virDomainDeviceDef * device)517 qemuDomainDeviceSupportZPCI(virDomainDeviceDef *device)
518 {
519 switch ((virDomainDeviceType)device->type) {
520 case VIR_DOMAIN_DEVICE_CHR:
521 return false;
522
523 case VIR_DOMAIN_DEVICE_CONTROLLER:
524 case VIR_DOMAIN_DEVICE_DISK:
525 case VIR_DOMAIN_DEVICE_LEASE:
526 case VIR_DOMAIN_DEVICE_FS:
527 case VIR_DOMAIN_DEVICE_NET:
528 case VIR_DOMAIN_DEVICE_INPUT:
529 case VIR_DOMAIN_DEVICE_SOUND:
530 case VIR_DOMAIN_DEVICE_VIDEO:
531 case VIR_DOMAIN_DEVICE_HOSTDEV:
532 case VIR_DOMAIN_DEVICE_WATCHDOG:
533 case VIR_DOMAIN_DEVICE_GRAPHICS:
534 case VIR_DOMAIN_DEVICE_HUB:
535 case VIR_DOMAIN_DEVICE_REDIRDEV:
536 case VIR_DOMAIN_DEVICE_SMARTCARD:
537 case VIR_DOMAIN_DEVICE_MEMBALLOON:
538 case VIR_DOMAIN_DEVICE_NVRAM:
539 case VIR_DOMAIN_DEVICE_RNG:
540 case VIR_DOMAIN_DEVICE_SHMEM:
541 case VIR_DOMAIN_DEVICE_TPM:
542 case VIR_DOMAIN_DEVICE_PANIC:
543 case VIR_DOMAIN_DEVICE_MEMORY:
544 case VIR_DOMAIN_DEVICE_IOMMU:
545 case VIR_DOMAIN_DEVICE_VSOCK:
546 case VIR_DOMAIN_DEVICE_AUDIO:
547 break;
548
549 case VIR_DOMAIN_DEVICE_NONE:
550 case VIR_DOMAIN_DEVICE_LAST:
551 default:
552 virReportEnumRangeError(virDomainDeviceType, device->type);
553 return false;
554 }
555
556 return true;
557 }
558
559
560 static virPCIDeviceAddressExtensionFlags
qemuDomainDeviceCalculatePCIAddressExtensionFlags(virQEMUCaps * qemuCaps,virDomainDeviceDef * dev)561 qemuDomainDeviceCalculatePCIAddressExtensionFlags(virQEMUCaps *qemuCaps,
562 virDomainDeviceDef *dev)
563 {
564 virPCIDeviceAddressExtensionFlags extFlags = 0;
565
566 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_ZPCI) &&
567 qemuDomainDeviceSupportZPCI(dev)) {
568 extFlags |= VIR_PCI_ADDRESS_EXTENSION_ZPCI;
569 }
570
571 return extFlags;
572 }
573
574
575 /**
576 * qemuDomainDeviceCalculatePCIConnectFlags:
577 *
578 * @dev: The device to be checked
579 * @pcieFlags: flags to use for a known PCI Express device
580 * @virtioFlags: flags to use for a virtio device (properly vetted
581 * for the current qemu binary and arch/machinetype)
582 *
583 * Lowest level function to determine PCI connectFlags for a
584 * device. This function relies on the next higher-level function
585 * determining the value for pcieFlags and virtioFlags in advance -
586 * this is to make it more efficient to call multiple times.
587 *
588 * Returns appropriate virDomainPCIConnectFlags for this device in
589 * this domain, or 0 if the device doesn't connect using PCI. There
590 * is no failure.
591 */
592 static virDomainPCIConnectFlags
qemuDomainDeviceCalculatePCIConnectFlags(virDomainDeviceDef * dev,virDomainPCIConnectFlags pcieFlags,virDomainPCIConnectFlags virtioFlags)593 qemuDomainDeviceCalculatePCIConnectFlags(virDomainDeviceDef *dev,
594 virDomainPCIConnectFlags pcieFlags,
595 virDomainPCIConnectFlags virtioFlags)
596 {
597 virDomainPCIConnectFlags pciFlags = (VIR_PCI_CONNECT_TYPE_PCI_DEVICE |
598 VIR_PCI_CONNECT_AUTOASSIGN);
599
600 switch ((virDomainDeviceType)dev->type) {
601 case VIR_DOMAIN_DEVICE_CONTROLLER: {
602 virDomainControllerDef *cont = dev->data.controller;
603
604 switch ((virDomainControllerType)cont->type) {
605 case VIR_DOMAIN_CONTROLLER_TYPE_PCI:
606 return virDomainPCIControllerModelToConnectType(cont->model);
607
608 case VIR_DOMAIN_CONTROLLER_TYPE_SATA:
609 return pciFlags;
610
611 case VIR_DOMAIN_CONTROLLER_TYPE_USB:
612 switch ((virDomainControllerModelUSB) cont->model) {
613 case VIR_DOMAIN_CONTROLLER_MODEL_USB_DEFAULT:
614 /* qemuDomainControllerDefPostParse should have
615 * changed 'model' to an explicit USB model in
616 * most cases. Since we're still on the default
617 * though, we must be going to use "-usb", which
618 * is assumed to be a PCI default
619 */
620 return pciFlags;
621
622 case VIR_DOMAIN_CONTROLLER_MODEL_USB_NEC_XHCI:
623 case VIR_DOMAIN_CONTROLLER_MODEL_USB_QEMU_XHCI:
624 return pcieFlags;
625
626 case VIR_DOMAIN_CONTROLLER_MODEL_USB_EHCI:
627 case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_EHCI1:
628 case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI1:
629 case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI2:
630 case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI3:
631 case VIR_DOMAIN_CONTROLLER_MODEL_USB_VT82C686B_UHCI:
632 case VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX3_UHCI:
633 case VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX4_UHCI:
634 case VIR_DOMAIN_CONTROLLER_MODEL_USB_PCI_OHCI:
635 return pciFlags;
636
637 case VIR_DOMAIN_CONTROLLER_MODEL_USB_QUSB1: /* xen only */
638 case VIR_DOMAIN_CONTROLLER_MODEL_USB_QUSB2: /* xen only */
639 case VIR_DOMAIN_CONTROLLER_MODEL_USB_NONE:
640 case VIR_DOMAIN_CONTROLLER_MODEL_USB_LAST:
641 return 0;
642 }
643 break;
644
645 case VIR_DOMAIN_CONTROLLER_TYPE_IDE:
646 return pciFlags;
647
648 case VIR_DOMAIN_CONTROLLER_TYPE_SCSI:
649 switch ((virDomainControllerModelSCSI) cont->model) {
650 case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_DEFAULT:
651 case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_NCR53C90:
652 return 0;
653
654 case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_SCSI:
655 case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_NON_TRANSITIONAL:
656 return virtioFlags;
657
658 /* Transitional devices only work in conventional PCI slots */
659 case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_TRANSITIONAL:
660 case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_AUTO:
661 case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_BUSLOGIC:
662 case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC:
663 case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSISAS1068:
664 case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VMPVSCSI:
665 case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_IBMVSCSI:
666 case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSISAS1078:
667 case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_DC390:
668 case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_AM53C974:
669 return pciFlags;
670
671 case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LAST:
672 return 0;
673 }
674 break;
675
676 case VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL:
677 switch ((virDomainControllerModelVirtioSerial) cont->model) {
678 case VIR_DOMAIN_CONTROLLER_MODEL_VIRTIO_SERIAL_VIRTIO_TRANSITIONAL:
679 /* Transitional devices only work in conventional PCI slots */
680 return pciFlags;
681
682 case VIR_DOMAIN_CONTROLLER_MODEL_VIRTIO_SERIAL_VIRTIO:
683 case VIR_DOMAIN_CONTROLLER_MODEL_VIRTIO_SERIAL_VIRTIO_NON_TRANSITIONAL:
684 case VIR_DOMAIN_CONTROLLER_MODEL_VIRTIO_SERIAL_DEFAULT:
685 return virtioFlags;
686
687 case VIR_DOMAIN_CONTROLLER_MODEL_VIRTIO_SERIAL_LAST:
688 return 0;
689 }
690 break;
691
692 case VIR_DOMAIN_CONTROLLER_TYPE_FDC:
693 case VIR_DOMAIN_CONTROLLER_TYPE_CCID:
694 case VIR_DOMAIN_CONTROLLER_TYPE_XENBUS:
695 case VIR_DOMAIN_CONTROLLER_TYPE_ISA:
696 case VIR_DOMAIN_CONTROLLER_TYPE_LAST:
697 return 0;
698 }
699 }
700 break;
701
702 case VIR_DOMAIN_DEVICE_FS:
703 switch ((virDomainFSDriverType) dev->data.fs->fsdriver) {
704 case VIR_DOMAIN_FS_DRIVER_TYPE_DEFAULT:
705 case VIR_DOMAIN_FS_DRIVER_TYPE_PATH:
706 case VIR_DOMAIN_FS_DRIVER_TYPE_HANDLE:
707 /* these drivers are handled by virtio-9p-pci */
708 switch ((virDomainFSModel) dev->data.fs->model) {
709 case VIR_DOMAIN_FS_MODEL_VIRTIO_TRANSITIONAL:
710 /* Transitional devices only work in conventional PCI slots */
711 return pciFlags;
712 case VIR_DOMAIN_FS_MODEL_VIRTIO:
713 case VIR_DOMAIN_FS_MODEL_VIRTIO_NON_TRANSITIONAL:
714 case VIR_DOMAIN_FS_MODEL_DEFAULT:
715 return virtioFlags;
716 case VIR_DOMAIN_FS_MODEL_LAST:
717 break;
718 }
719 break;
720
721 case VIR_DOMAIN_FS_DRIVER_TYPE_VIRTIOFS:
722 /* vhost-user-fs-pci */
723 return virtioFlags;
724
725 case VIR_DOMAIN_FS_DRIVER_TYPE_LOOP:
726 case VIR_DOMAIN_FS_DRIVER_TYPE_NBD:
727 case VIR_DOMAIN_FS_DRIVER_TYPE_PLOOP:
728 case VIR_DOMAIN_FS_DRIVER_TYPE_LAST:
729 return 0;
730 }
731
732 return 0;
733
734 case VIR_DOMAIN_DEVICE_NET: {
735 virDomainNetDef *net = dev->data.net;
736
737 /* NB: a type='hostdev' will use PCI, but its
738 * address is assigned when we're assigning the
739 * addresses for other hostdev devices.
740 */
741 if (net->type == VIR_DOMAIN_NET_TYPE_HOSTDEV ||
742 net->model == VIR_DOMAIN_NET_MODEL_USB_NET) {
743 return 0;
744 }
745
746 if (net->model == VIR_DOMAIN_NET_MODEL_VIRTIO ||
747 net->model == VIR_DOMAIN_NET_MODEL_VIRTIO_NON_TRANSITIONAL)
748 return virtioFlags;
749
750 if (net->model == VIR_DOMAIN_NET_MODEL_VIRTIO_TRANSITIONAL)
751 return pciFlags;
752
753 if (net->model == VIR_DOMAIN_NET_MODEL_E1000E)
754 return pcieFlags;
755
756 /* the only time model can be "unknown" is for type='hostdev'
757 * or for type='network' where the network is a pool of
758 * hostdev devices. These will always be pcie on the host, and
759 * should be pcie in the guest if it supports pcie.
760 */
761 if (net->model == VIR_DOMAIN_NET_MODEL_UNKNOWN)
762 return pcieFlags;
763
764 return pciFlags;
765 }
766
767 case VIR_DOMAIN_DEVICE_SOUND:
768 switch (dev->data.sound->model) {
769 case VIR_DOMAIN_SOUND_MODEL_ES1370:
770 case VIR_DOMAIN_SOUND_MODEL_AC97:
771 case VIR_DOMAIN_SOUND_MODEL_ICH6:
772 case VIR_DOMAIN_SOUND_MODEL_ICH9:
773 return pciFlags;
774
775 case VIR_DOMAIN_SOUND_MODEL_SB16:
776 case VIR_DOMAIN_SOUND_MODEL_PCSPK:
777 case VIR_DOMAIN_SOUND_MODEL_USB:
778 case VIR_DOMAIN_SOUND_MODEL_ICH7:
779 case VIR_DOMAIN_SOUND_MODEL_LAST:
780 return 0;
781 }
782 break;
783
784 case VIR_DOMAIN_DEVICE_DISK:
785 switch ((virDomainDiskBus) dev->data.disk->bus) {
786 case VIR_DOMAIN_DISK_BUS_VIRTIO:
787 /* only virtio disks use PCI */
788 switch ((virDomainDiskModel) dev->data.disk->model) {
789 case VIR_DOMAIN_DISK_MODEL_VIRTIO_TRANSITIONAL:
790 /* Transitional devices only work in conventional PCI slots */
791 return pciFlags;
792 case VIR_DOMAIN_DISK_MODEL_VIRTIO:
793 case VIR_DOMAIN_DISK_MODEL_VIRTIO_NON_TRANSITIONAL:
794 case VIR_DOMAIN_DISK_MODEL_DEFAULT:
795 return virtioFlags;
796 case VIR_DOMAIN_DISK_MODEL_LAST:
797 break;
798 }
799 return 0;
800
801 case VIR_DOMAIN_DISK_BUS_IDE:
802 case VIR_DOMAIN_DISK_BUS_FDC:
803 case VIR_DOMAIN_DISK_BUS_SCSI:
804 case VIR_DOMAIN_DISK_BUS_XEN:
805 case VIR_DOMAIN_DISK_BUS_USB:
806 case VIR_DOMAIN_DISK_BUS_UML:
807 case VIR_DOMAIN_DISK_BUS_SATA:
808 case VIR_DOMAIN_DISK_BUS_SD:
809 case VIR_DOMAIN_DISK_BUS_NONE:
810 case VIR_DOMAIN_DISK_BUS_LAST:
811 return 0;
812 }
813 break;
814
815 case VIR_DOMAIN_DEVICE_HOSTDEV: {
816 virDomainHostdevDef *hostdev = dev->data.hostdev;
817 g_autoptr(virPCIDevice) pciDev = NULL;
818 virPCIDeviceAddress *hostAddr = &hostdev->source.subsys.u.pci.addr;
819
820 if (!virHostdevIsMdevDevice(hostdev) &&
821 (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS ||
822 (hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI &&
823 hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI_HOST))) {
824 return 0;
825 }
826
827 if (pciFlags == pcieFlags) {
828 /* This arch/qemu only supports legacy PCI, so there
829 * is no point in checking if the device is an Express
830 * device.
831 */
832 return pciFlags;
833 }
834
835 if (virDeviceInfoPCIAddressIsPresent(hostdev->info)) {
836 /* A guest-side address has already been assigned, so
837 * we can avoid reading the PCI config, and just use
838 * pcieFlags, since the pciConnectFlags checking is
839 * more relaxed when an address is already assigned
840 * than it is when we're looking for a new address (so
841 * validation will pass regardless of whether we set
842 * the flags to PCI or PCIe).
843 */
844 return pcieFlags;
845 }
846
847 /* mdevs don't have corresponding files in /sys that we can poke to
848 * try and figure out whether they are legacy PCI or PCI Express, so
849 * the logic below would never work; instead, we just go ahead and
850 * assume they're PCI Express. This is a very reasonable assumption,
851 * as all current mdev-capable devices are indeed PCI Express */
852 if (hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_MDEV)
853 return pcieFlags;
854
855 /* according to pbonzini, from the guest PoV vhost-scsi devices
856 * are the same as virtio-scsi, so they should follow virtio logic
857 */
858 if (hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI_HOST) {
859 switch ((virDomainHostdevSubsysSCSIVHostModelType) hostdev->source.subsys.u.scsi_host.model) {
860 case VIR_DOMAIN_HOSTDEV_SUBSYS_SCSI_VHOST_MODEL_TYPE_VIRTIO_TRANSITIONAL:
861 /* Transitional devices only work in conventional PCI slots */
862 return pciFlags;
863 case VIR_DOMAIN_HOSTDEV_SUBSYS_SCSI_VHOST_MODEL_TYPE_VIRTIO:
864 case VIR_DOMAIN_HOSTDEV_SUBSYS_SCSI_VHOST_MODEL_TYPE_VIRTIO_NON_TRANSITIONAL:
865 case VIR_DOMAIN_HOSTDEV_SUBSYS_SCSI_VHOST_MODEL_TYPE_DEFAULT:
866 return virtioFlags;
867 case VIR_DOMAIN_HOSTDEV_SUBSYS_SCSI_VHOST_MODEL_TYPE_LAST:
868 break;
869 }
870 return 0;
871 }
872
873 if (!(pciDev = virPCIDeviceNew(hostAddr))) {
874 /* libvirt should be able to perform all the
875 * operations in virPCIDeviceNew() even if it's
876 * running unprivileged, so if this fails, the device
877 * apparently doesn't currently exist on the host.
878 * Since the overwhelming majority of assignable host
879 * devices are PCIe, assume this one is too.
880 */
881 return pcieFlags;
882 }
883
884 if (virPCIDeviceIsPCIExpress(pciDev))
885 return pcieFlags;
886
887 return pciFlags;
888 }
889
890 case VIR_DOMAIN_DEVICE_MEMBALLOON:
891 switch (dev->data.memballoon->model) {
892 case VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO_TRANSITIONAL:
893 /* Transitional devices only work in conventional PCI slots */
894 return pciFlags;
895 case VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO:
896 case VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO_NON_TRANSITIONAL:
897 return virtioFlags;
898
899 case VIR_DOMAIN_MEMBALLOON_MODEL_XEN:
900 case VIR_DOMAIN_MEMBALLOON_MODEL_NONE:
901 case VIR_DOMAIN_MEMBALLOON_MODEL_LAST:
902 return 0;
903 }
904 break;
905
906 case VIR_DOMAIN_DEVICE_RNG:
907 switch ((virDomainRNGModel) dev->data.rng->model) {
908 case VIR_DOMAIN_RNG_MODEL_VIRTIO_TRANSITIONAL:
909 /* Transitional devices only work in conventional PCI slots */
910 return pciFlags;
911 case VIR_DOMAIN_RNG_MODEL_VIRTIO:
912 case VIR_DOMAIN_RNG_MODEL_VIRTIO_NON_TRANSITIONAL:
913 return virtioFlags;
914
915 case VIR_DOMAIN_RNG_MODEL_LAST:
916 return 0;
917 }
918 break;
919
920 case VIR_DOMAIN_DEVICE_WATCHDOG:
921 /* only one model connects using PCI */
922 switch ((virDomainWatchdogModel) dev->data.watchdog->model) {
923 case VIR_DOMAIN_WATCHDOG_MODEL_I6300ESB:
924 return pciFlags;
925
926 case VIR_DOMAIN_WATCHDOG_MODEL_IB700:
927 case VIR_DOMAIN_WATCHDOG_MODEL_DIAG288:
928 case VIR_DOMAIN_WATCHDOG_MODEL_LAST:
929 return 0;
930 }
931 break;
932
933 case VIR_DOMAIN_DEVICE_VIDEO:
934 switch ((virDomainVideoType)dev->data.video->type) {
935 case VIR_DOMAIN_VIDEO_TYPE_VIRTIO:
936 return virtioFlags;
937
938 case VIR_DOMAIN_VIDEO_TYPE_VGA:
939 case VIR_DOMAIN_VIDEO_TYPE_CIRRUS:
940 case VIR_DOMAIN_VIDEO_TYPE_VMVGA:
941 case VIR_DOMAIN_VIDEO_TYPE_XEN:
942 case VIR_DOMAIN_VIDEO_TYPE_VBOX:
943 case VIR_DOMAIN_VIDEO_TYPE_QXL:
944 case VIR_DOMAIN_VIDEO_TYPE_PARALLELS:
945 return pciFlags;
946
947 case VIR_DOMAIN_VIDEO_TYPE_BOCHS:
948 return pcieFlags;
949
950 case VIR_DOMAIN_VIDEO_TYPE_DEFAULT:
951 case VIR_DOMAIN_VIDEO_TYPE_GOP:
952 case VIR_DOMAIN_VIDEO_TYPE_NONE:
953 case VIR_DOMAIN_VIDEO_TYPE_RAMFB:
954 case VIR_DOMAIN_VIDEO_TYPE_LAST:
955 return 0;
956 }
957 break;
958
959 case VIR_DOMAIN_DEVICE_SHMEM:
960 return pciFlags;
961
962 case VIR_DOMAIN_DEVICE_INPUT:
963 switch ((virDomainInputBus) dev->data.input->bus) {
964 case VIR_DOMAIN_INPUT_BUS_VIRTIO:
965 switch ((virDomainInputModel) dev->data.input->model) {
966 case VIR_DOMAIN_INPUT_MODEL_VIRTIO_TRANSITIONAL:
967 /* Transitional devices only work in conventional PCI slots */
968 return pciFlags;
969 case VIR_DOMAIN_INPUT_MODEL_VIRTIO:
970 case VIR_DOMAIN_INPUT_MODEL_VIRTIO_NON_TRANSITIONAL:
971 case VIR_DOMAIN_INPUT_MODEL_DEFAULT:
972 return virtioFlags;
973 case VIR_DOMAIN_INPUT_MODEL_LAST:
974 break;
975 }
976 return 0;
977
978 case VIR_DOMAIN_INPUT_BUS_PS2:
979 case VIR_DOMAIN_INPUT_BUS_USB:
980 case VIR_DOMAIN_INPUT_BUS_XEN:
981 case VIR_DOMAIN_INPUT_BUS_PARALLELS:
982 case VIR_DOMAIN_INPUT_BUS_NONE:
983 case VIR_DOMAIN_INPUT_BUS_LAST:
984 return 0;
985 }
986 break;
987
988 case VIR_DOMAIN_DEVICE_CHR:
989 switch ((virDomainChrSerialTargetType)dev->data.chr->targetType) {
990 case VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_PCI:
991 return pciFlags;
992
993 case VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_ISA:
994 case VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_USB:
995 case VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_SPAPR_VIO:
996 case VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_SYSTEM:
997 case VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_SCLP:
998 case VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_NONE:
999 case VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_LAST:
1000 return 0;
1001 }
1002 break;
1003
1004 case VIR_DOMAIN_DEVICE_VSOCK:
1005 switch ((virDomainVsockModel) dev->data.vsock->model) {
1006 case VIR_DOMAIN_VSOCK_MODEL_VIRTIO_TRANSITIONAL:
1007 /* Transitional devices only work in conventional PCI slots */
1008 return pciFlags;
1009 case VIR_DOMAIN_VSOCK_MODEL_VIRTIO:
1010 case VIR_DOMAIN_VSOCK_MODEL_VIRTIO_NON_TRANSITIONAL:
1011 return virtioFlags;
1012
1013 case VIR_DOMAIN_VSOCK_MODEL_DEFAULT:
1014 case VIR_DOMAIN_VSOCK_MODEL_LAST:
1015 return 0;
1016 }
1017 break;
1018
1019 case VIR_DOMAIN_DEVICE_MEMORY:
1020 switch (dev->data.memory->model) {
1021 case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
1022 case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM:
1023 return virtioFlags;
1024
1025 case VIR_DOMAIN_MEMORY_MODEL_NONE:
1026 case VIR_DOMAIN_MEMORY_MODEL_DIMM:
1027 case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
1028 case VIR_DOMAIN_MEMORY_MODEL_LAST:
1029 return 0;
1030 }
1031 break;
1032
1033 /* These devices don't ever connect with PCI */
1034 case VIR_DOMAIN_DEVICE_NVRAM:
1035 case VIR_DOMAIN_DEVICE_TPM:
1036 case VIR_DOMAIN_DEVICE_PANIC:
1037 case VIR_DOMAIN_DEVICE_HUB:
1038 case VIR_DOMAIN_DEVICE_REDIRDEV:
1039 case VIR_DOMAIN_DEVICE_SMARTCARD:
1040 /* These devices don't even have a DeviceInfo */
1041 case VIR_DOMAIN_DEVICE_LEASE:
1042 case VIR_DOMAIN_DEVICE_GRAPHICS:
1043 case VIR_DOMAIN_DEVICE_IOMMU:
1044 case VIR_DOMAIN_DEVICE_AUDIO:
1045 case VIR_DOMAIN_DEVICE_LAST:
1046 case VIR_DOMAIN_DEVICE_NONE:
1047 return 0;
1048 }
1049
1050 /* We can never get here, because all cases are covered in the
1051 * switch, and they all return, but the compiler will still
1052 * complain "control reaches end of non-void function" unless
1053 * we add the following return.
1054 */
1055 return 0;
1056 }
1057
1058
1059 typedef struct {
1060 virDomainPCIConnectFlags virtioFlags;
1061 virDomainPCIConnectFlags pcieFlags;
1062 virQEMUDriver *driver;
1063 } qemuDomainFillDevicePCIConnectFlagsIterData;
1064
1065
1066 /**
1067 * qemuDomainFillDevicePCIConnectFlagsIterInit:
1068 *
1069 * Initialize the iterator data that is used when calling
1070 * qemuDomainCalculateDevicePCIConnectFlags().
1071 */
1072 static void
qemuDomainFillDevicePCIConnectFlagsIterInit(virDomainDef * def,virQEMUCaps * qemuCaps,virQEMUDriver * driver,qemuDomainFillDevicePCIConnectFlagsIterData * data)1073 qemuDomainFillDevicePCIConnectFlagsIterInit(virDomainDef *def,
1074 virQEMUCaps *qemuCaps,
1075 virQEMUDriver *driver,
1076 qemuDomainFillDevicePCIConnectFlagsIterData *data)
1077 {
1078 data->driver = driver;
1079
1080 if (qemuDomainHasPCIeRoot(def)) {
1081 data->pcieFlags = (VIR_PCI_CONNECT_TYPE_PCIE_DEVICE |
1082 VIR_PCI_CONNECT_AUTOASSIGN);
1083 } else {
1084 data->pcieFlags = (VIR_PCI_CONNECT_TYPE_PCI_DEVICE |
1085 VIR_PCI_CONNECT_AUTOASSIGN);
1086 }
1087
1088 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY)) {
1089 data->virtioFlags = data->pcieFlags;
1090 } else {
1091 data->virtioFlags = (VIR_PCI_CONNECT_TYPE_PCI_DEVICE |
1092 VIR_PCI_CONNECT_AUTOASSIGN);
1093 }
1094 }
1095
1096
1097 /**
1098 * qemuDomainFillDevicePCIConnectFlagsIter:
1099 *
1100 * @def: the entire DomainDef
1101 * @dev: The device to be checked
1102 * @info: virDomainDeviceInfo within the device
1103 * @opaque: points to iterator data setup beforehand.
1104 *
1105 * Sets the pciConnectFlags for a single device's info. Has properly
1106 * formatted arguments to be called by virDomainDeviceInfoIterate().
1107 *
1108 * Always returns 0 - there is no failure.
1109 */
1110 static int
qemuDomainFillDevicePCIConnectFlagsIter(virDomainDef * def G_GNUC_UNUSED,virDomainDeviceDef * dev,virDomainDeviceInfo * info,void * opaque)1111 qemuDomainFillDevicePCIConnectFlagsIter(virDomainDef *def G_GNUC_UNUSED,
1112 virDomainDeviceDef *dev,
1113 virDomainDeviceInfo *info,
1114 void *opaque)
1115 {
1116 qemuDomainFillDevicePCIConnectFlagsIterData *data = opaque;
1117
1118 info->pciConnectFlags
1119 = qemuDomainDeviceCalculatePCIConnectFlags(dev,
1120 data->pcieFlags,
1121 data->virtioFlags);
1122 return 0;
1123 }
1124
1125
1126 /**
1127 * qemuDomainFillAllPCIConnectFlags:
1128 *
1129 * @def: the entire DomainDef
1130 * @qemuCaps: as you'd expect
1131 *
1132 * Set the info->pciConnectFlags for all devices in the domain.
1133 *
1134 * Returns 0 on success or -1 on failure (the only possibility of
1135 * failure would be some internal problem with
1136 * virDomainDeviceInfoIterate())
1137 */
1138 static int
qemuDomainFillAllPCIConnectFlags(virDomainDef * def,virQEMUCaps * qemuCaps,virQEMUDriver * driver)1139 qemuDomainFillAllPCIConnectFlags(virDomainDef *def,
1140 virQEMUCaps *qemuCaps,
1141 virQEMUDriver *driver)
1142 {
1143 qemuDomainFillDevicePCIConnectFlagsIterData data;
1144
1145 qemuDomainFillDevicePCIConnectFlagsIterInit(def, qemuCaps, driver, &data);
1146
1147 return virDomainDeviceInfoIterate(def,
1148 qemuDomainFillDevicePCIConnectFlagsIter,
1149 &data);
1150 }
1151
1152
1153 /**
1154 * qemuDomainFillDevicePCIExtensionFlagsIter:
1155 *
1156 * @def: the entire DomainDef
1157 * @dev: The device to be checked
1158 * @info: virDomainDeviceInfo within the device
1159 * @opaque: qemu capabilities
1160 *
1161 * Sets the pciAddressExtFlags for a single device's info. Has properly
1162 * formatted arguments to be called by virDomainDeviceInfoIterate().
1163 *
1164 * Always returns 0 - there is no failure.
1165 */
1166 static int
qemuDomainFillDevicePCIExtensionFlagsIter(virDomainDef * def G_GNUC_UNUSED,virDomainDeviceDef * dev,virDomainDeviceInfo * info,void * opaque)1167 qemuDomainFillDevicePCIExtensionFlagsIter(virDomainDef *def G_GNUC_UNUSED,
1168 virDomainDeviceDef *dev,
1169 virDomainDeviceInfo *info,
1170 void *opaque)
1171 {
1172 virQEMUCaps *qemuCaps = opaque;
1173
1174 info->pciAddrExtFlags =
1175 qemuDomainDeviceCalculatePCIAddressExtensionFlags(qemuCaps, dev);
1176
1177 return 0;
1178 }
1179
1180
1181 /**
1182 * qemuDomainFillAllPCIExtensionFlags:
1183 *
1184 * @def: the entire DomainDef
1185 * @qemuCaps: as you'd expect
1186 *
1187 * Set the info->pciAddressExtFlags for all devices in the domain.
1188 *
1189 * Returns 0 on success or -1 on failure (the only possibility of
1190 * failure would be some internal problem with
1191 * virDomainDeviceInfoIterate())
1192 */
1193 static int
qemuDomainFillAllPCIExtensionFlags(virDomainDef * def,virQEMUCaps * qemuCaps)1194 qemuDomainFillAllPCIExtensionFlags(virDomainDef *def,
1195 virQEMUCaps *qemuCaps)
1196 {
1197 return virDomainDeviceInfoIterate(def,
1198 qemuDomainFillDevicePCIExtensionFlagsIter,
1199 qemuCaps);
1200 }
1201
1202
1203 /**
1204 * qemuDomainFindUnusedIsolationGroupIter:
1205 * @def: domain definition
1206 * @dev: device definition
1207 * @info: device information
1208 * @opaque: user data
1209 *
1210 * Used to implement qemuDomainFindUnusedIsolationGroup(). You probably
1211 * don't want to call this directly.
1212 *
1213 * Return: 0 if the isolation group is not used by the device, <1 otherwise.
1214 */
1215 static int
qemuDomainFindUnusedIsolationGroupIter(virDomainDef * def G_GNUC_UNUSED,virDomainDeviceDef * dev G_GNUC_UNUSED,virDomainDeviceInfo * info,void * opaque)1216 qemuDomainFindUnusedIsolationGroupIter(virDomainDef *def G_GNUC_UNUSED,
1217 virDomainDeviceDef *dev G_GNUC_UNUSED,
1218 virDomainDeviceInfo *info,
1219 void *opaque)
1220 {
1221 unsigned int *isolationGroup = opaque;
1222
1223 if (info->isolationGroup == *isolationGroup)
1224 return -1;
1225
1226 return 0;
1227 }
1228
1229
1230 /**
1231 * qemuDomainFindUnusedIsolationGroup:
1232 * @def: domain definition
1233 *
1234 * Find an isolation group that is not used by any device in @def yet.
1235 *
1236 * Normally, we'd look up the device's IOMMU group and base its isolation
1237 * group on that; however, when a network interface uses a network backed
1238 * by SR-IOV Virtual Functions, we can't know at PCI address assignment
1239 * time which host device will be used so we can't look up its IOMMU group.
1240 *
1241 * We still want such a device to be isolated: this function can be used
1242 * to obtain a synthetic isolation group usable for the purpose.
1243 *
1244 * Return: unused isolation group
1245 */
1246 static unsigned int
qemuDomainFindUnusedIsolationGroup(virDomainDef * def)1247 qemuDomainFindUnusedIsolationGroup(virDomainDef *def)
1248 {
1249 unsigned int isolationGroup = UINT_MAX;
1250
1251 /* We start from the highest possible isolation group and work our
1252 * way backwards so that we're working in a completely different range
1253 * from IOMMU groups, thus avoiding clashes. We're realistically going
1254 * to call this function just a few times per guest anyway */
1255 while (isolationGroup > 0 &&
1256 virDomainDeviceInfoIterate(def,
1257 qemuDomainFindUnusedIsolationGroupIter,
1258 &isolationGroup) < 0) {
1259 isolationGroup--;
1260 }
1261
1262 return isolationGroup;
1263 }
1264
1265
1266 /**
1267 * qemuDomainFillDeviceIsolationGroup:
1268 * @def: domain definition
1269 * @dev: device definition
1270 *
1271 * Fill isolation group information for a single device.
1272 */
1273 void
qemuDomainFillDeviceIsolationGroup(virDomainDef * def,virDomainDeviceDef * dev)1274 qemuDomainFillDeviceIsolationGroup(virDomainDef *def,
1275 virDomainDeviceDef *dev)
1276 {
1277 /* Only host devices need their isolation group to be different from
1278 * the default. Interfaces of type hostdev are just host devices in
1279 * disguise, but we don't need to handle them separately because for
1280 * each such interface a corresponding hostdev is also added to the
1281 * guest configuration */
1282 if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV) {
1283 virDomainHostdevDef *hostdev = dev->data.hostdev;
1284 virDomainDeviceInfo *info = hostdev->info;
1285 virPCIDeviceAddress *hostAddr;
1286 int tmp;
1287
1288 /* Only PCI host devices are subject to isolation */
1289 if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS ||
1290 hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
1291 return;
1292 }
1293
1294 hostAddr = &hostdev->source.subsys.u.pci.addr;
1295
1296 /* If a non-default isolation has already been assigned to the
1297 * device, we can avoid looking up the information again */
1298 if (info->isolationGroup > 0)
1299 return;
1300
1301 /* The isolation group depends on the IOMMU group assigned by the host */
1302 tmp = virPCIDeviceAddressGetIOMMUGroupNum(hostAddr);
1303
1304 if (tmp < 0) {
1305 VIR_WARN("Can't look up isolation group for host device "
1306 "%04x:%02x:%02x.%x, device won't be isolated",
1307 hostAddr->domain, hostAddr->bus,
1308 hostAddr->slot, hostAddr->function);
1309 return;
1310 }
1311
1312 /* The isolation group for a host device is its IOMMU group,
1313 * increased by one: this is because zero is a valid IOMMU group but
1314 * that's also the default isolation group, which we want to save
1315 * for emulated devices. Shifting isolation groups for host devices
1316 * by one ensures there is no overlap */
1317 info->isolationGroup = tmp + 1;
1318
1319 VIR_DEBUG("Isolation group for host device %04x:%02x:%02x.%x is %u",
1320 hostAddr->domain, hostAddr->bus,
1321 hostAddr->slot, hostAddr->function,
1322 info->isolationGroup);
1323
1324 } else if (dev->type == VIR_DOMAIN_DEVICE_NET) {
1325 virDomainNetDef *iface = dev->data.net;
1326 virDomainDeviceInfo *info = &iface->info;
1327 unsigned int tmp;
1328
1329 /* Network interfaces can ultimately result in the guest being
1330 * assigned a host device if the libvirt network they're connected
1331 * to is of type hostdev. All other kinds of network interfaces don't
1332 * require us to isolate the guest device, so we can skip them */
1333 if (iface->type != VIR_DOMAIN_NET_TYPE_NETWORK ||
1334 virDomainNetResolveActualType(iface) != VIR_DOMAIN_NET_TYPE_HOSTDEV) {
1335 return;
1336 }
1337
1338 /* If a non-default isolation has already been assigned to the
1339 * device, we can avoid looking up the information again */
1340 if (info->isolationGroup > 0)
1341 return;
1342
1343 /* Obtain a synthetic isolation group for the device, since at this
1344 * point in time we don't have access to the IOMMU group of the host
1345 * device that will eventually be used by the guest */
1346 tmp = qemuDomainFindUnusedIsolationGroup(def);
1347
1348 if (tmp == 0) {
1349 VIR_WARN("Can't obtain usable isolation group for interface "
1350 "configured to use hostdev-backed network '%s', "
1351 "device won't be isolated",
1352 iface->data.network.name);
1353 return;
1354 }
1355
1356 info->isolationGroup = tmp;
1357
1358 VIR_DEBUG("Isolation group for interface configured to use "
1359 "hostdev-backed network '%s' is %u",
1360 iface->data.network.name, info->isolationGroup);
1361 }
1362 }
1363
1364
1365 /**
1366 * qemuDomainFillDeviceIsolationGroupIter:
1367 * @def: domain definition
1368 * @dev: device definition
1369 * @info: device information
1370 * @opaque: user data
1371 *
1372 * A version of qemuDomainFillDeviceIsolationGroup() to be used
1373 * with virDomainDeviceInfoIterate()
1374 *
1375 * Return: 0 on success, <0 on failure
1376 */
1377 static int
qemuDomainFillDeviceIsolationGroupIter(virDomainDef * def,virDomainDeviceDef * dev,virDomainDeviceInfo * info G_GNUC_UNUSED,void * opaque G_GNUC_UNUSED)1378 qemuDomainFillDeviceIsolationGroupIter(virDomainDef *def,
1379 virDomainDeviceDef *dev,
1380 virDomainDeviceInfo *info G_GNUC_UNUSED,
1381 void *opaque G_GNUC_UNUSED)
1382 {
1383 qemuDomainFillDeviceIsolationGroup(def, dev);
1384
1385 return 0;
1386 }
1387
1388
1389 /**
1390 * qemuDomainSetupIsolationGroups:
1391 * @def: domain definition
1392 *
1393 * High-level function to set up isolation groups for all devices
1394 * and controllers in @def. Isolation groups will only be set up if
1395 * the guest architecture and machine type require it, so this
1396 * function can and should be called unconditionally before attempting
1397 * to assign any PCI address.
1398 *
1399 * Return: 0 on success, <0 on failure
1400 */
1401 static int
qemuDomainSetupIsolationGroups(virDomainDef * def)1402 qemuDomainSetupIsolationGroups(virDomainDef *def)
1403 {
1404 int idx;
1405
1406 /* Only pSeries guests care about isolation groups at the moment */
1407 if (!qemuDomainIsPSeries(def))
1408 return 0;
1409
1410 idx = virDomainControllerFind(def, VIR_DOMAIN_CONTROLLER_TYPE_PCI, 0);
1411 if (idx < 0)
1412 return -1;
1413
1414 /* We want to prevent hostdevs from being plugged into the default PHB:
1415 * we can make sure that doesn't happen by locking its isolation group */
1416 def->controllers[idx]->info.isolationGroupLocked = true;
1417
1418 /* Fill in isolation groups for all other devices */
1419 if (virDomainDeviceInfoIterate(def,
1420 qemuDomainFillDeviceIsolationGroupIter,
1421 NULL) < 0) {
1422 return -1;
1423 }
1424
1425 return 0;
1426 }
1427
1428
1429 /**
1430 * qemuDomainFillDevicePCIConnectFlags:
1431 *
1432 * @def: the entire DomainDef
1433 * @dev: The device to be checked
1434 * @qemuCaps: as you'd expect
1435 *
1436 * Set the info->pciConnectFlags for a single device.
1437 *
1438 * No return value.
1439 */
1440 static void
qemuDomainFillDevicePCIConnectFlags(virDomainDef * def,virDomainDeviceDef * dev,virQEMUCaps * qemuCaps,virQEMUDriver * driver)1441 qemuDomainFillDevicePCIConnectFlags(virDomainDef *def,
1442 virDomainDeviceDef *dev,
1443 virQEMUCaps *qemuCaps,
1444 virQEMUDriver *driver)
1445 {
1446 virDomainDeviceInfo *info = virDomainDeviceGetInfo(dev);
1447
1448 if (info) {
1449 /* qemuDomainDeviceCalculatePCIConnectFlags() is called with
1450 * the data setup in the ...IterData by ...IterInit() rather
1451 * than setting the values directly here. It may seem like
1452 * pointless posturing, but it's done this way to eliminate
1453 * duplicated setup code while allowing more efficient
1454 * operation when it's being done repeatedly with the device
1455 * iterator (since qemuDomainFillAllPCIConnectFlags() only
1456 * calls ...IterInit() once for all devices).
1457 */
1458 qemuDomainFillDevicePCIConnectFlagsIterData data;
1459
1460 qemuDomainFillDevicePCIConnectFlagsIterInit(def, qemuCaps, driver, &data);
1461
1462 info->pciConnectFlags
1463 = qemuDomainDeviceCalculatePCIConnectFlags(dev,
1464 data.pcieFlags,
1465 data.virtioFlags);
1466 }
1467 }
1468
1469
1470 /**
1471 * qemuDomainFillDevicePCIExtensionFlags:
1472 *
1473 * @dev: The device to be checked
1474 * @info: virDomainDeviceInfo within the device
1475 * @qemuCaps: as you'd expect
1476 *
1477 * Set the info->pciAddressExtFlags for a single device.
1478 *
1479 * No return value.
1480 */
1481 static void
qemuDomainFillDevicePCIExtensionFlags(virDomainDeviceDef * dev,virDomainDeviceInfo * info,virQEMUCaps * qemuCaps)1482 qemuDomainFillDevicePCIExtensionFlags(virDomainDeviceDef *dev,
1483 virDomainDeviceInfo *info,
1484 virQEMUCaps *qemuCaps)
1485 {
1486 info->pciAddrExtFlags =
1487 qemuDomainDeviceCalculatePCIAddressExtensionFlags(qemuCaps, dev);
1488 }
1489
1490
1491 static int
qemuDomainPCIAddressReserveNextAddr(virDomainPCIAddressSet * addrs,virDomainDeviceInfo * dev)1492 qemuDomainPCIAddressReserveNextAddr(virDomainPCIAddressSet *addrs,
1493 virDomainDeviceInfo *dev)
1494 {
1495 return virDomainPCIAddressReserveNextAddr(addrs, dev,
1496 dev->pciConnectFlags, -1);
1497 }
1498
1499
1500 static int
qemuDomainAssignPCIAddressExtension(virDomainDef * def G_GNUC_UNUSED,virDomainDeviceDef * device G_GNUC_UNUSED,virDomainDeviceInfo * info,void * opaque)1501 qemuDomainAssignPCIAddressExtension(virDomainDef *def G_GNUC_UNUSED,
1502 virDomainDeviceDef *device G_GNUC_UNUSED,
1503 virDomainDeviceInfo *info,
1504 void *opaque)
1505 {
1506 virDomainPCIAddressSet *addrs = opaque;
1507 virPCIDeviceAddress *addr = &info->addr.pci;
1508
1509 if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)
1510 addr->extFlags = info->pciAddrExtFlags;
1511
1512 if (virDeviceInfoPCIAddressExtensionIsWanted(info))
1513 return virDomainPCIAddressExtensionReserveNextAddr(addrs, addr);
1514
1515 return 0;
1516 }
1517
1518 static int
qemuDomainCollectPCIAddress(virDomainDef * def G_GNUC_UNUSED,virDomainDeviceDef * device,virDomainDeviceInfo * info,void * opaque)1519 qemuDomainCollectPCIAddress(virDomainDef *def G_GNUC_UNUSED,
1520 virDomainDeviceDef *device,
1521 virDomainDeviceInfo *info,
1522 void *opaque)
1523 {
1524 virDomainPCIAddressSet *addrs = opaque;
1525 virPCIDeviceAddress *addr = &info->addr.pci;
1526
1527 if (!virDeviceInfoPCIAddressIsPresent(info) ||
1528 ((device->type == VIR_DOMAIN_DEVICE_HOSTDEV) &&
1529 device->data.hostdev->parentnet)) {
1530 /* If a hostdev has a parent, its info will be a part of the
1531 * parent, and will have its address collected during the scan
1532 * of the parent's device type.
1533 */
1534 return 0;
1535 }
1536
1537 /* If we get to here, the device has a PCI address assigned in the
1538 * config and we should mark it as in-use. But if the
1539 * pciConnectFlags are 0, then this device shouldn't have a PCI
1540 * address associated with it. *BUT* since there are cases in the
1541 * past where we've apparently allowed that, we need to pretend
1542 * for now that it's okay, otherwise an existing domain could
1543 * "disappear" from the list of domains due to a parse failure. We
1544 * can fix this by just forcing the pciConnectFlags to be
1545 * PCI_DEVICE (and then relying on validation functions to report
1546 * inappropriate address types.
1547 */
1548 if (!info->pciConnectFlags) {
1549 g_autofree char *addrStr = virPCIDeviceAddressAsString(&info->addr.pci);
1550
1551 VIR_WARN("qemuDomainDeviceCalculatePCIConnectFlags() thinks that the "
1552 "device with PCI address %s should not have a PCI address",
1553 addrStr ? addrStr : "(unknown)");
1554
1555 info->pciConnectFlags = VIR_PCI_CONNECT_TYPE_PCI_DEVICE;
1556 }
1557
1558 /* Ignore implicit controllers on slot 0:0:1.0:
1559 * implicit IDE controller on 0:0:1.1 (no qemu command line)
1560 * implicit USB controller on 0:0:1.2 (-usb)
1561 *
1562 * If the machine does have a PCI bus, they will get reserved
1563 * in qemuDomainAssignDevicePCISlots().
1564 */
1565
1566 /* These are the IDE and USB controllers in the PIIX3, hardcoded
1567 * to bus 0 slot 1. They cannot be attached to a PCIe slot, only
1568 * PCI.
1569 */
1570 if (device->type == VIR_DOMAIN_DEVICE_CONTROLLER && addr->domain == 0 &&
1571 addr->bus == 0 && addr->slot == 1) {
1572 virDomainControllerDef *cont = device->data.controller;
1573
1574 if ((cont->type == VIR_DOMAIN_CONTROLLER_TYPE_IDE && cont->idx == 0 &&
1575 addr->function == 1) ||
1576 (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_USB && cont->idx == 0 &&
1577 (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX3_UHCI ||
1578 cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_DEFAULT) &&
1579 addr->function == 2)) {
1580 /* Note the check for nbuses > 0 - if there are no PCI
1581 * buses, we skip this check. This is a quirk required for
1582 * some machinetypes such as s390, which pretend to have a
1583 * PCI bus for long enough to generate the "-usb" on the
1584 * commandline, but that don't really care if a PCI bus
1585 * actually exists. */
1586 if (addrs->nbuses > 0 &&
1587 !(addrs->buses[0].flags & VIR_PCI_CONNECT_TYPE_PCI_DEVICE)) {
1588 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1589 _("Bus 0 must be PCI for integrated PIIX3 "
1590 "USB or IDE controllers"));
1591 return -1;
1592 }
1593 return 0;
1594 }
1595 }
1596
1597 if (virDomainPCIAddressReserveAddr(addrs, addr,
1598 info->pciConnectFlags,
1599 info->isolationGroup) < 0) {
1600 return -1;
1601 }
1602
1603 return 0;
1604 }
1605
1606 static int
qemuDomainCollectPCIAddressExtension(virDomainDef * def G_GNUC_UNUSED,virDomainDeviceDef * device,virDomainDeviceInfo * info,void * opaque)1607 qemuDomainCollectPCIAddressExtension(virDomainDef *def G_GNUC_UNUSED,
1608 virDomainDeviceDef *device,
1609 virDomainDeviceInfo *info,
1610 void *opaque)
1611 {
1612 virDomainPCIAddressSet *addrs = opaque;
1613 virPCIDeviceAddress *addr = &info->addr.pci;
1614
1615 if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)
1616 addr->extFlags = info->pciAddrExtFlags;
1617
1618 if (!virDeviceInfoPCIAddressExtensionIsPresent(info) ||
1619 ((device->type == VIR_DOMAIN_DEVICE_HOSTDEV) &&
1620 device->data.hostdev->parentnet)) {
1621 /* If a hostdev has a parent, its info will be a part of the
1622 * parent, and will have its address collected during the scan
1623 * of the parent's device type.
1624 */
1625 return 0;
1626 }
1627
1628 return virDomainPCIAddressExtensionReserveAddr(addrs, addr);
1629 }
1630
1631 static virDomainPCIAddressSet *
qemuDomainPCIAddressSetCreate(virDomainDef * def,virQEMUCaps * qemuCaps,unsigned int nbuses,bool dryRun)1632 qemuDomainPCIAddressSetCreate(virDomainDef *def,
1633 virQEMUCaps *qemuCaps,
1634 unsigned int nbuses,
1635 bool dryRun)
1636 {
1637 virDomainPCIAddressSet *addrs;
1638 size_t i;
1639 bool hasPCIeRoot = false;
1640 virDomainControllerModelPCI defaultModel;
1641 virPCIDeviceAddressExtensionFlags extFlags = VIR_PCI_ADDRESS_EXTENSION_NONE;
1642
1643 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_ZPCI))
1644 extFlags |= VIR_PCI_ADDRESS_EXTENSION_ZPCI;
1645
1646 if ((addrs = virDomainPCIAddressSetAlloc(nbuses, extFlags)) == NULL)
1647 return NULL;
1648
1649 addrs->dryRun = dryRun;
1650
1651 /* pSeries domains support multiple pci-root controllers */
1652 if (qemuDomainIsPSeries(def))
1653 addrs->areMultipleRootsSupported = true;
1654
1655 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_PCIE_PCI_BRIDGE))
1656 addrs->isPCIeToPCIBridgeSupported = true;
1657
1658 for (i = 0; i < def->ncontrollers; i++) {
1659 virDomainControllerDef *cont = def->controllers[i];
1660 size_t idx = cont->idx;
1661 bool allowHotplug = false;
1662
1663 if (cont->type != VIR_DOMAIN_CONTROLLER_TYPE_PCI)
1664 continue;
1665
1666 if (idx >= addrs->nbuses) {
1667 virReportError(VIR_ERR_INTERNAL_ERROR,
1668 _("Inappropriate new pci controller index %zu "
1669 "exceeds addrs array length"), idx);
1670 goto error;
1671 }
1672
1673 if (cont->opts.pciopts.hotplug != VIR_TRISTATE_SWITCH_OFF)
1674 allowHotplug = true;
1675
1676 if (virDomainPCIAddressBusSetModel(&addrs->buses[idx], cont->model, allowHotplug) < 0)
1677 goto error;
1678
1679 /* Forward the information about isolation groups */
1680 addrs->buses[idx].isolationGroup = cont->info.isolationGroup;
1681 addrs->buses[idx].isolationGroupLocked = cont->info.isolationGroupLocked;
1682
1683 if (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT)
1684 hasPCIeRoot = true;
1685 }
1686
1687 if (nbuses > 0 && !addrs->buses[0].model) {
1688 /* This is just here to replicate a safety measure already in
1689 * an older version of this code. In practice, the root bus
1690 * should have already been added at index 0 prior to
1691 * assigning addresses to devices.
1692 */
1693 if (virDomainPCIAddressBusSetModel(&addrs->buses[0],
1694 VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT, true) < 0)
1695 goto error;
1696 }
1697
1698 /* Now fill in a reasonable model for all the buses in the set
1699 * that don't yet have a corresponding controller in the domain
1700 * config.
1701 */
1702 if (qemuDomainIsPSeries(def)) {
1703 /* pSeries guests should use PHBs (pci-root controllers) */
1704 defaultModel = VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT;
1705 } else if (hasPCIeRoot) {
1706 defaultModel = VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT_PORT;
1707 } else {
1708 defaultModel = VIR_DOMAIN_CONTROLLER_MODEL_PCI_BRIDGE;
1709 }
1710
1711 for (i = 1; i < addrs->nbuses; i++) {
1712
1713 if (addrs->buses[i].model)
1714 continue;
1715
1716 if (virDomainPCIAddressBusSetModel(&addrs->buses[i], defaultModel, true) < 0)
1717 goto error;
1718
1719 VIR_DEBUG("Auto-adding <controller type='pci' model='%s' index='%zu'/>",
1720 virDomainControllerModelPCITypeToString(defaultModel), i);
1721 }
1722
1723 if (virDomainDeviceInfoIterate(def, qemuDomainCollectPCIAddress, addrs) < 0)
1724 goto error;
1725
1726 if (virDomainDeviceInfoIterate(def,
1727 qemuDomainCollectPCIAddressExtension,
1728 addrs) < 0) {
1729 goto error;
1730 }
1731
1732 return addrs;
1733
1734 error:
1735 virDomainPCIAddressSetFree(addrs);
1736 return NULL;
1737 }
1738
1739
1740 static int
qemuDomainValidateDevicePCISlotsPIIX3(virDomainDef * def,virDomainPCIAddressSet * addrs)1741 qemuDomainValidateDevicePCISlotsPIIX3(virDomainDef *def,
1742 virDomainPCIAddressSet *addrs)
1743 {
1744 size_t i;
1745 virPCIDeviceAddress tmp_addr;
1746 g_autofree char *addrStr = NULL;
1747 virDomainPCIConnectFlags flags = (VIR_PCI_CONNECT_AUTOASSIGN
1748 | VIR_PCI_CONNECT_TYPE_PCI_DEVICE);
1749
1750 /* Verify that first IDE and USB controllers (if any) is on the PIIX3, fn 1 */
1751 for (i = 0; i < def->ncontrollers; i++) {
1752 virDomainControllerDef *cont = def->controllers[i];
1753 virPCIDeviceAddress primaryIDEAddr = {.domain = 0, .bus = 0,
1754 .slot = 1, .function = 1};
1755 virPCIDeviceAddress piix3USBAddr = {.domain = 0, .bus = 0,
1756 .slot = 1, .function = 2};
1757
1758 /* First IDE controller lives on the PIIX3 at slot=1, function=1 */
1759 if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_IDE &&
1760 cont->idx == 0) {
1761 if (virDeviceInfoPCIAddressIsPresent(&cont->info)) {
1762 if (!virPCIDeviceAddressEqual(&cont->info.addr.pci,
1763 &primaryIDEAddr)) {
1764 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1765 _("Primary IDE controller must have PCI "
1766 "address 0:0:1.1"));
1767 return -1;
1768 }
1769 } else {
1770 cont->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
1771 cont->info.addr.pci = primaryIDEAddr;
1772 }
1773 } else if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
1774 cont->idx == 0 &&
1775 (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX3_UHCI ||
1776 cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_DEFAULT)) {
1777 if (virDeviceInfoPCIAddressIsPresent(&cont->info)) {
1778 if (!virPCIDeviceAddressEqual(&cont->info.addr.pci,
1779 &piix3USBAddr)) {
1780 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1781 _("PIIX3 USB controller at index 0 must "
1782 "have PCI address 0:0:1.2"));
1783 return -1;
1784 }
1785 } else {
1786 cont->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
1787 cont->info.addr.pci = piix3USBAddr;
1788 }
1789 } else {
1790 /* this controller is not skipped in qemuDomainCollectPCIAddress */
1791 continue;
1792 }
1793 if (addrs->nbuses &&
1794 virDomainPCIAddressReserveAddr(addrs, &cont->info.addr.pci, flags, 0) < 0)
1795 return -1;
1796 }
1797
1798 /* Implicit PIIX3 devices living on slot 1 not handled above */
1799 if (addrs->nbuses) {
1800 memset(&tmp_addr, 0, sizeof(tmp_addr));
1801 tmp_addr.slot = 1;
1802 /* ISA Bridge at 00:01.0 */
1803 if (virDomainPCIAddressReserveAddr(addrs, &tmp_addr, flags, 0) < 0)
1804 return -1;
1805 /* Bridge at 00:01.3 */
1806 tmp_addr.function = 3;
1807 if (virDomainPCIAddressReserveAddr(addrs, &tmp_addr, flags, 0) < 0)
1808 return -1;
1809 }
1810
1811 /* ramfb is not a PCI device */
1812 if (def->nvideos > 0 &&
1813 def->videos[0]->type != VIR_DOMAIN_VIDEO_TYPE_NONE &&
1814 def->videos[0]->type != VIR_DOMAIN_VIDEO_TYPE_RAMFB) {
1815 /* Because the PIIX3 integrated IDE/USB controllers are
1816 * already at slot 1, when qemu looks for the first free slot
1817 * to place the VGA controller (which is always the first
1818 * device added after integrated devices), it *always* ends up
1819 * at slot 2.
1820 */
1821 virDomainVideoDef *primaryVideo = def->videos[0];
1822
1823 if (virDeviceInfoPCIAddressIsWanted(&primaryVideo->info)) {
1824 memset(&tmp_addr, 0, sizeof(tmp_addr));
1825 tmp_addr.slot = 2;
1826
1827 if (!(addrStr = virPCIDeviceAddressAsString(&tmp_addr)))
1828 return -1;
1829 if (!virDomainPCIAddressValidate(addrs, &tmp_addr,
1830 addrStr, flags, true))
1831 return -1;
1832
1833 if (virDomainPCIAddressSlotInUse(addrs, &tmp_addr)) {
1834 if (qemuDomainPCIAddressReserveNextAddr(addrs,
1835 &primaryVideo->info) < 0) {
1836 return -1;
1837 }
1838 } else {
1839 if (virDomainPCIAddressReserveAddr(addrs, &tmp_addr, flags, 0) < 0)
1840 return -1;
1841 primaryVideo->info.addr.pci = tmp_addr;
1842 primaryVideo->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
1843 }
1844 }
1845 }
1846 return 0;
1847 }
1848
1849
1850 static int
qemuDomainValidateDevicePCISlotsQ35(virDomainDef * def,virDomainPCIAddressSet * addrs)1851 qemuDomainValidateDevicePCISlotsQ35(virDomainDef *def,
1852 virDomainPCIAddressSet *addrs)
1853 {
1854 size_t i;
1855 virPCIDeviceAddress tmp_addr;
1856 g_autofree char *addrStr = NULL;
1857 virDomainPCIConnectFlags flags = VIR_PCI_CONNECT_TYPE_PCIE_DEVICE;
1858
1859 for (i = 0; i < def->ncontrollers; i++) {
1860 virDomainControllerDef *cont = def->controllers[i];
1861 virPCIDeviceAddress primarySATAAddr = {.domain = 0, .bus = 0,
1862 .slot = 0x1F, .function = 2};
1863
1864 switch (cont->type) {
1865 case VIR_DOMAIN_CONTROLLER_TYPE_SATA:
1866 /* Verify that the first SATA controller is at 00:1F.2 the
1867 * q35 machine type *always* has a SATA controller at this
1868 * address.
1869 */
1870 if (cont->idx == 0) {
1871 if (virDeviceInfoPCIAddressIsPresent(&cont->info)) {
1872 if (!virPCIDeviceAddressEqual(&cont->info.addr.pci,
1873 &primarySATAAddr)) {
1874 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1875 _("Primary SATA controller must have "
1876 "PCI address 0:0:1f.2"));
1877 return -1;
1878 }
1879 } else {
1880 cont->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
1881 cont->info.addr.pci = primarySATAAddr;
1882 }
1883 }
1884 break;
1885
1886 case VIR_DOMAIN_CONTROLLER_TYPE_USB:
1887 if ((cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI1) &&
1888 (cont->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)) {
1889 /* Try to assign the first found USB2 controller to
1890 * 00:1D.0 and 2nd to 00:1A.0 (because that is their
1891 * standard location on real Q35 hardware) unless they
1892 * are already taken, but don't insist on it.
1893 *
1894 * (NB: all other controllers at the same index will
1895 * get assigned to the same slot as the UHCI1 when
1896 * addresses are later assigned to all devices.)
1897 */
1898 bool assign = false;
1899
1900 memset(&tmp_addr, 0, sizeof(tmp_addr));
1901 tmp_addr.slot = 0x1D;
1902 if (!virDomainPCIAddressSlotInUse(addrs, &tmp_addr)) {
1903 assign = true;
1904 } else {
1905 tmp_addr.slot = 0x1A;
1906 if (!virDomainPCIAddressSlotInUse(addrs, &tmp_addr))
1907 assign = true;
1908 }
1909 if (assign) {
1910 if (virDomainPCIAddressReserveAddr(addrs, &tmp_addr, flags, 0) < 0)
1911 return -1;
1912
1913 cont->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
1914 cont->info.addr.pci.domain = 0;
1915 cont->info.addr.pci.bus = 0;
1916 cont->info.addr.pci.slot = tmp_addr.slot;
1917 cont->info.addr.pci.function = 0;
1918 cont->info.addr.pci.multi = VIR_TRISTATE_SWITCH_ON;
1919 }
1920 }
1921 break;
1922
1923 case VIR_DOMAIN_CONTROLLER_TYPE_PCI:
1924 if (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_DMI_TO_PCI_BRIDGE &&
1925 cont->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
1926 /* Try to assign this bridge to 00:1E.0 (because that
1927 * is its standard location on real hardware) unless
1928 * it's already taken, but don't insist on it.
1929 */
1930 memset(&tmp_addr, 0, sizeof(tmp_addr));
1931 tmp_addr.slot = 0x1E;
1932 if (!virDomainPCIAddressSlotInUse(addrs, &tmp_addr)) {
1933 if (virDomainPCIAddressReserveAddr(addrs, &tmp_addr, flags, 0) < 0)
1934 return -1;
1935
1936 cont->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
1937 cont->info.addr.pci.domain = 0;
1938 cont->info.addr.pci.bus = 0;
1939 cont->info.addr.pci.slot = 0x1E;
1940 cont->info.addr.pci.function = 0;
1941 }
1942 }
1943 break;
1944 }
1945 }
1946
1947 /* Reserve slot 0x1F function 0 (ISA bridge, not in config model)
1948 * and function 3 (SMBus, also not (yet) in config model). As with
1949 * the SATA controller, these devices are always present in a q35
1950 * machine; there is no way to not have them.
1951 */
1952 if (addrs->nbuses) {
1953 memset(&tmp_addr, 0, sizeof(tmp_addr));
1954 tmp_addr.slot = 0x1F;
1955 tmp_addr.function = 0;
1956 tmp_addr.multi = VIR_TRISTATE_SWITCH_ON;
1957 if (virDomainPCIAddressReserveAddr(addrs, &tmp_addr, flags, 0) < 0)
1958 return -1;
1959
1960 tmp_addr.function = 3;
1961 tmp_addr.multi = VIR_TRISTATE_SWITCH_ABSENT;
1962 if (virDomainPCIAddressReserveAddr(addrs, &tmp_addr, flags, 0) < 0)
1963 return -1;
1964 }
1965
1966 /* ramfb is not a PCI device */
1967 if (def->nvideos > 0 &&
1968 def->videos[0]->type != VIR_DOMAIN_VIDEO_TYPE_NONE &&
1969 def->videos[0]->type != VIR_DOMAIN_VIDEO_TYPE_RAMFB) {
1970 /* NB: unlike the pc machinetypes, on q35 machinetypes the
1971 * integrated devices are at slot 0x1f, so when qemu looks for
1972 * the first free slot for the first VGA, it will always be at
1973 * slot 1 (which was used up by the integrated PIIX3 devices
1974 * on pc machinetypes).
1975 */
1976 virDomainVideoDef *primaryVideo = def->videos[0];
1977 if (virDeviceInfoPCIAddressIsWanted(&primaryVideo->info)) {
1978 memset(&tmp_addr, 0, sizeof(tmp_addr));
1979 tmp_addr.slot = 1;
1980
1981 if (!(addrStr = virPCIDeviceAddressAsString(&tmp_addr)))
1982 return -1;
1983 if (!virDomainPCIAddressValidate(addrs, &tmp_addr,
1984 addrStr, flags, true))
1985 return -1;
1986
1987 if (virDomainPCIAddressSlotInUse(addrs, &tmp_addr)) {
1988 if (qemuDomainPCIAddressReserveNextAddr(addrs,
1989 &primaryVideo->info) < 0)
1990 return -1;
1991 } else {
1992 if (virDomainPCIAddressReserveAddr(addrs, &tmp_addr, flags, 0) < 0)
1993 return -1;
1994 primaryVideo->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
1995 primaryVideo->info.addr.pci = tmp_addr;
1996 }
1997 }
1998 }
1999
2000 memset(&tmp_addr, 0, sizeof(tmp_addr));
2001 tmp_addr.slot = 0x1B;
2002 if (!virDomainPCIAddressSlotInUse(addrs, &tmp_addr)) {
2003 /* Since real Q35 hardware has an ICH9 chip that has an
2004 * integrated HD audio device at 0000:00:1B.0 put any
2005 * unaddressed ICH9 audio device at that address if it's not
2006 * already taken. If there's something already there, let the
2007 * normal device addressing assign something later.
2008 */
2009 for (i = 0; i < def->nsounds; i++) {
2010 virDomainSoundDef *sound = def->sounds[i];
2011
2012 if (sound->model != VIR_DOMAIN_SOUND_MODEL_ICH9 ||
2013 !virDeviceInfoPCIAddressIsWanted(&sound->info)) {
2014 continue;
2015 }
2016 if (virDomainPCIAddressReserveAddr(addrs, &tmp_addr, flags, 0) < 0)
2017 return -1;
2018
2019 sound->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
2020 sound->info.addr.pci = tmp_addr;
2021 break;
2022 }
2023 }
2024
2025 return 0;
2026 }
2027
2028
2029 static int
qemuDomainValidateDevicePCISlotsChipsets(virDomainDef * def,virDomainPCIAddressSet * addrs)2030 qemuDomainValidateDevicePCISlotsChipsets(virDomainDef *def,
2031 virDomainPCIAddressSet *addrs)
2032 {
2033 if (qemuDomainIsI440FX(def) &&
2034 qemuDomainValidateDevicePCISlotsPIIX3(def, addrs) < 0) {
2035 return -1;
2036 }
2037
2038 if (qemuDomainIsQ35(def) &&
2039 qemuDomainValidateDevicePCISlotsQ35(def, addrs) < 0) {
2040 return -1;
2041 }
2042
2043 return 0;
2044 }
2045
2046
2047 /*
2048 * This assigns static PCI slots to all configured devices.
2049 * The ordering here is chosen to match the ordering used
2050 * with old QEMU < 0.12, so that if a user updates a QEMU
2051 * host from old QEMU to QEMU >= 0.12, their guests should
2052 * get PCI addresses in the same order as before.
2053 *
2054 * NB, if they previously hotplugged devices then all bets
2055 * are off. Hotplug for old QEMU was unfixably broken wrt
2056 * to stable PCI addressing.
2057 *
2058 * Order is:
2059 *
2060 * - Host bridge (slot 0)
2061 * - PIIX3 ISA bridge, IDE controller, something else unknown, USB controller (slot 1)
2062 * - Video (slot 2)
2063 *
2064 * - These integrated devices were already added by
2065 * qemuDomainValidateDevicePCISlotsChipsets invoked right before this function
2066 *
2067 * Incrementally assign slots from 3 onwards:
2068 *
2069 * - Net
2070 * - Sound
2071 * - SCSI controllers
2072 * - VirtIO block
2073 * - VirtIO balloon
2074 * - Host device passthrough
2075 * - Watchdog
2076 * - pci serial devices
2077 *
2078 * Prior to this function being invoked, qemuDomainCollectPCIAddress() will have
2079 * added all existing PCI addresses from the 'def' to 'addrs'. Thus this
2080 * function must only try to reserve addresses if info.type == NONE and
2081 * skip over info.type == PCI
2082 */
2083 static int
qemuDomainAssignDevicePCISlots(virDomainDef * def,virQEMUCaps * qemuCaps,virDomainPCIAddressSet * addrs)2084 qemuDomainAssignDevicePCISlots(virDomainDef *def,
2085 virQEMUCaps *qemuCaps,
2086 virDomainPCIAddressSet *addrs)
2087 {
2088 size_t i, j;
2089
2090 /* PCI controllers */
2091 for (i = 0; i < def->ncontrollers; i++) {
2092 virDomainControllerDef *cont = def->controllers[i];
2093
2094 if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI) {
2095 virDomainControllerModelPCI model = cont->model;
2096
2097 if (model == VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT ||
2098 model == VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT ||
2099 !virDeviceInfoPCIAddressIsWanted(&cont->info))
2100 continue;
2101
2102 if (qemuDomainPCIAddressReserveNextAddr(addrs, &cont->info) < 0)
2103 return -1;
2104 }
2105 }
2106
2107 for (i = 0; i < def->nfss; i++) {
2108 if (!virDeviceInfoPCIAddressIsWanted(&def->fss[i]->info))
2109 continue;
2110
2111 /* Only support VirtIO-9p-pci so far. If that changes,
2112 * we might need to skip devices here */
2113 if (qemuDomainPCIAddressReserveNextAddr(addrs, &def->fss[i]->info) < 0)
2114 return -1;
2115 }
2116
2117 /* Network interfaces */
2118 for (i = 0; i < def->nnets; i++) {
2119 virDomainNetDef *net = def->nets[i];
2120
2121 /* type='hostdev' network devices might be USB, and are also
2122 * in hostdevs list anyway, so handle them with other hostdevs
2123 * instead of here.
2124 */
2125 if ((net->type == VIR_DOMAIN_NET_TYPE_HOSTDEV) ||
2126 !virDeviceInfoPCIAddressIsWanted(&net->info)) {
2127 continue;
2128 }
2129
2130 if (qemuDomainPCIAddressReserveNextAddr(addrs, &net->info) < 0)
2131 return -1;
2132 }
2133
2134 /* Sound cards */
2135 for (i = 0; i < def->nsounds; i++) {
2136 virDomainSoundDef *sound = def->sounds[i];
2137
2138 if (!virDeviceInfoPCIAddressIsWanted(&sound->info))
2139 continue;
2140
2141 /* Skip ISA sound card, PCSPK and usb-audio */
2142 if (sound->model == VIR_DOMAIN_SOUND_MODEL_SB16 ||
2143 sound->model == VIR_DOMAIN_SOUND_MODEL_PCSPK ||
2144 sound->model == VIR_DOMAIN_SOUND_MODEL_USB) {
2145 continue;
2146 }
2147
2148 if (qemuDomainPCIAddressReserveNextAddr(addrs, &sound->info) < 0)
2149 return -1;
2150 }
2151
2152 /* Device controllers (SCSI, USB, but not IDE, FDC or CCID) */
2153 for (i = 0; i < def->ncontrollers; i++) {
2154 virDomainControllerDef *cont = def->controllers[i];
2155
2156 /* PCI controllers have been dealt with earlier */
2157 if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI)
2158 continue;
2159
2160 /* USB controller model 'none' doesn't need a PCI address */
2161 if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
2162 cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_NONE)
2163 continue;
2164
2165 /* FDC lives behind the ISA bridge; CCID is a usb device */
2166 if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_FDC ||
2167 cont->type == VIR_DOMAIN_CONTROLLER_TYPE_CCID)
2168 continue;
2169
2170 /* First IDE controller lives on the PIIX3 at slot=1, function=1,
2171 dealt with earlier on */
2172 if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_IDE &&
2173 cont->idx == 0)
2174 continue;
2175
2176 /* NCR53C90 SCSI controller is always a built-in device */
2177 if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI &&
2178 cont->model == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_NCR53C90)
2179 continue;
2180
2181 if (!virDeviceInfoPCIAddressIsWanted(&cont->info))
2182 continue;
2183
2184 /* USB2 needs special handling to put all companions in the same slot */
2185 if (IS_USB2_CONTROLLER(cont)) {
2186 virPCIDeviceAddress addr = {0};
2187 bool foundAddr = false;
2188
2189 for (j = 0; j < def->ncontrollers; j++) {
2190 if (IS_USB2_CONTROLLER(def->controllers[j]) &&
2191 def->controllers[j]->idx == cont->idx &&
2192 virDeviceInfoPCIAddressIsPresent(&def->controllers[j]->info)) {
2193 addr = def->controllers[j]->info.addr.pci;
2194 foundAddr = true;
2195 break;
2196 }
2197 }
2198
2199 switch (cont->model) {
2200 case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_EHCI1:
2201 addr.function = 7;
2202 addr.multi = VIR_TRISTATE_SWITCH_ABSENT;
2203 break;
2204 case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI1:
2205 addr.function = 0;
2206 addr.multi = VIR_TRISTATE_SWITCH_ON;
2207 break;
2208 case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI2:
2209 addr.function = 1;
2210 addr.multi = VIR_TRISTATE_SWITCH_ABSENT;
2211 break;
2212 case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI3:
2213 addr.function = 2;
2214 addr.multi = VIR_TRISTATE_SWITCH_ABSENT;
2215 break;
2216 }
2217
2218 if (foundAddr) {
2219 /* Reserve this function on the slot we found */
2220 if (virDomainPCIAddressReserveAddr(addrs, &addr,
2221 cont->info.pciConnectFlags,
2222 cont->info.isolationGroup) < 0) {
2223 return -1;
2224 }
2225
2226 cont->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
2227 cont->info.addr.pci = addr;
2228 } else {
2229 /* This is the first part of the controller, so need
2230 * to find a free slot & then reserve this function */
2231 if (virDomainPCIAddressReserveNextAddr(addrs, &cont->info,
2232 cont->info.pciConnectFlags,
2233 addr.function) < 0) {
2234 return -1;
2235 }
2236
2237 cont->info.addr.pci.multi = addr.multi;
2238 }
2239 } else {
2240 if (qemuDomainPCIAddressReserveNextAddr(addrs, &cont->info) < 0)
2241 return -1;
2242 }
2243 }
2244
2245 /* Disks (VirtIO only for now) */
2246 for (i = 0; i < def->ndisks; i++) {
2247 /* Only VirtIO disks use PCI addrs */
2248 if (def->disks[i]->bus != VIR_DOMAIN_DISK_BUS_VIRTIO)
2249 continue;
2250
2251 /* don't touch s390 devices */
2252 if (virDeviceInfoPCIAddressIsPresent(&def->disks[i]->info) ||
2253 def->disks[i]->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW)
2254 continue;
2255
2256 /* Also ignore virtio-mmio disks if our machine allows them */
2257 if (def->disks[i]->info.type ==
2258 VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_MMIO &&
2259 virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VIRTIO_MMIO))
2260 continue;
2261
2262 if (!virDeviceInfoPCIAddressIsWanted(&def->disks[i]->info)) {
2263 virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
2264 _("virtio disk cannot have an address of type '%s'"),
2265 virDomainDeviceAddressTypeToString(def->disks[i]->info.type));
2266 return -1;
2267 }
2268
2269 if (qemuDomainPCIAddressReserveNextAddr(addrs, &def->disks[i]->info) < 0)
2270 return -1;
2271 }
2272
2273 /* Host PCI devices */
2274 for (i = 0; i < def->nhostdevs; i++) {
2275 virDomainHostdevSubsys *subsys = &def->hostdevs[i]->source.subsys;
2276 if (!virDeviceInfoPCIAddressIsWanted(def->hostdevs[i]->info))
2277 continue;
2278 if (def->hostdevs[i]->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS)
2279 continue;
2280 if (subsys->type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI &&
2281 subsys->type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI_HOST &&
2282 !(subsys->type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_MDEV &&
2283 subsys->u.mdev.model == VIR_MDEV_MODEL_TYPE_VFIO_PCI)) {
2284 continue;
2285 }
2286
2287 /* do not reserve address for info->type='unassigned' */
2288 if (def->hostdevs[i]->info->type ==
2289 VIR_DOMAIN_DEVICE_ADDRESS_TYPE_UNASSIGNED)
2290 continue;
2291
2292 if (qemuDomainPCIAddressReserveNextAddr(addrs,
2293 def->hostdevs[i]->info) < 0)
2294 return -1;
2295 }
2296
2297 /* memballoon. the qemu driver only accepts virtio memballoon devices */
2298 if (virDomainDefHasMemballoon(def) &&
2299 virDeviceInfoPCIAddressIsWanted(&def->memballoon->info)) {
2300 if (qemuDomainPCIAddressReserveNextAddr(addrs,
2301 &def->memballoon->info) < 0)
2302 return -1;
2303 }
2304
2305 /* the qemu driver only accepts virtio rng devices */
2306 for (i = 0; i < def->nrngs; i++) {
2307 if (!virDeviceInfoPCIAddressIsWanted(&def->rngs[i]->info))
2308 continue;
2309
2310 if (qemuDomainPCIAddressReserveNextAddr(addrs, &def->rngs[i]->info) < 0)
2311 return -1;
2312 }
2313
2314 /* A watchdog - check if it is a PCI device */
2315 if (def->watchdog &&
2316 def->watchdog->model == VIR_DOMAIN_WATCHDOG_MODEL_I6300ESB &&
2317 virDeviceInfoPCIAddressIsWanted(&def->watchdog->info)) {
2318 if (qemuDomainPCIAddressReserveNextAddr(addrs, &def->watchdog->info) < 0)
2319 return -1;
2320 }
2321
2322 /* Video devices */
2323 for (i = 0; i < def->nvideos; i++) {
2324 if (def->videos[i]->type == VIR_DOMAIN_VIDEO_TYPE_NONE ||
2325 def->videos[i]->type == VIR_DOMAIN_VIDEO_TYPE_RAMFB)
2326 continue;
2327
2328 if (!virDeviceInfoPCIAddressIsWanted(&def->videos[i]->info))
2329 continue;
2330
2331 if (qemuDomainPCIAddressReserveNextAddr(addrs, &def->videos[i]->info) < 0)
2332 return -1;
2333 }
2334
2335 /* Shared Memory */
2336 for (i = 0; i < def->nshmems; i++) {
2337 if (!virDeviceInfoPCIAddressIsWanted(&def->shmems[i]->info))
2338 continue;
2339
2340 if (qemuDomainPCIAddressReserveNextAddr(addrs, &def->shmems[i]->info) < 0)
2341 return -1;
2342 }
2343 for (i = 0; i < def->ninputs; i++) {
2344 if (def->inputs[i]->bus != VIR_DOMAIN_INPUT_BUS_VIRTIO ||
2345 !virDeviceInfoPCIAddressIsWanted(&def->inputs[i]->info))
2346 continue;
2347
2348 if (qemuDomainPCIAddressReserveNextAddr(addrs, &def->inputs[i]->info) < 0)
2349 return -1;
2350 }
2351 for (i = 0; i < def->nparallels; i++) {
2352 /* Nada - none are PCI based (yet) */
2353 }
2354 for (i = 0; i < def->nserials; i++) {
2355 virDomainChrDef *chr = def->serials[i];
2356
2357 if (chr->targetType != VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_PCI ||
2358 !virDeviceInfoPCIAddressIsWanted(&chr->info))
2359 continue;
2360
2361 if (qemuDomainPCIAddressReserveNextAddr(addrs, &chr->info) < 0)
2362 return -1;
2363 }
2364 for (i = 0; i < def->nchannels; i++) {
2365 /* Nada - none are PCI based (yet) */
2366 }
2367 for (i = 0; i < def->nhubs; i++) {
2368 /* Nada - none are PCI based (yet) */
2369 }
2370
2371 if (def->vsock &&
2372 virDeviceInfoPCIAddressIsWanted(&def->vsock->info)) {
2373
2374 if (qemuDomainPCIAddressReserveNextAddr(addrs,
2375 &def->vsock->info) < 0)
2376 return -1;
2377 }
2378
2379 for (i = 0; i < def->nmems; i++) {
2380 virDomainMemoryDef *mem = def->mems[i];
2381
2382 switch (mem->model) {
2383 case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
2384 case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM:
2385 if (virDeviceInfoPCIAddressIsWanted(&mem->info) &&
2386 qemuDomainPCIAddressReserveNextAddr(addrs, &mem->info) < 0)
2387 return -1;
2388 break;
2389 case VIR_DOMAIN_MEMORY_MODEL_NONE:
2390 case VIR_DOMAIN_MEMORY_MODEL_DIMM:
2391 case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
2392 case VIR_DOMAIN_MEMORY_MODEL_LAST:
2393 break;
2394 }
2395 }
2396
2397 return 0;
2398 }
2399
2400
2401 static void
qemuDomainPCIControllerSetDefaultModelName(virDomainControllerDef * cont,virDomainDef * def,virQEMUCaps * qemuCaps)2402 qemuDomainPCIControllerSetDefaultModelName(virDomainControllerDef *cont,
2403 virDomainDef *def,
2404 virQEMUCaps *qemuCaps)
2405 {
2406 virDomainControllerPCIModelName *modelName = &cont->opts.pciopts.modelName;
2407
2408 /* make sure it's not already set */
2409 if (*modelName != VIR_DOMAIN_CONTROLLER_PCI_MODEL_NAME_NONE)
2410 return;
2411
2412 switch ((virDomainControllerModelPCI)cont->model) {
2413 case VIR_DOMAIN_CONTROLLER_MODEL_PCI_BRIDGE:
2414 *modelName = VIR_DOMAIN_CONTROLLER_PCI_MODEL_NAME_PCI_BRIDGE;
2415 break;
2416 case VIR_DOMAIN_CONTROLLER_MODEL_DMI_TO_PCI_BRIDGE:
2417 *modelName = VIR_DOMAIN_CONTROLLER_PCI_MODEL_NAME_I82801B11_BRIDGE;
2418 break;
2419 case VIR_DOMAIN_CONTROLLER_MODEL_PCIE_TO_PCI_BRIDGE:
2420 *modelName = VIR_DOMAIN_CONTROLLER_PCI_MODEL_NAME_PCIE_PCI_BRIDGE;
2421 break;
2422 case VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT_PORT:
2423 /* Use generic PCIe Root Ports if available, falling back to
2424 * ioh3420 otherwise */
2425 if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_PCIE_ROOT_PORT))
2426 *modelName = VIR_DOMAIN_CONTROLLER_PCI_MODEL_NAME_PCIE_ROOT_PORT;
2427 else
2428 *modelName = VIR_DOMAIN_CONTROLLER_PCI_MODEL_NAME_IOH3420;
2429 break;
2430 case VIR_DOMAIN_CONTROLLER_MODEL_PCIE_SWITCH_UPSTREAM_PORT:
2431 *modelName = VIR_DOMAIN_CONTROLLER_PCI_MODEL_NAME_X3130_UPSTREAM;
2432 break;
2433 case VIR_DOMAIN_CONTROLLER_MODEL_PCIE_SWITCH_DOWNSTREAM_PORT:
2434 *modelName = VIR_DOMAIN_CONTROLLER_PCI_MODEL_NAME_XIO3130_DOWNSTREAM;
2435 break;
2436 case VIR_DOMAIN_CONTROLLER_MODEL_PCI_EXPANDER_BUS:
2437 *modelName = VIR_DOMAIN_CONTROLLER_PCI_MODEL_NAME_PXB;
2438 break;
2439 case VIR_DOMAIN_CONTROLLER_MODEL_PCIE_EXPANDER_BUS:
2440 *modelName = VIR_DOMAIN_CONTROLLER_PCI_MODEL_NAME_PXB_PCIE;
2441 break;
2442 case VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT:
2443 if (qemuDomainIsPSeries(def))
2444 *modelName = VIR_DOMAIN_CONTROLLER_PCI_MODEL_NAME_SPAPR_PCI_HOST_BRIDGE;
2445 break;
2446 case VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT:
2447 case VIR_DOMAIN_CONTROLLER_MODEL_PCI_DEFAULT:
2448 case VIR_DOMAIN_CONTROLLER_MODEL_PCI_LAST:
2449 break;
2450 }
2451 }
2452
2453
2454 /**
2455 * qemuDomainAddressFindNewTargetIndex:
2456 * @def: domain definition
2457 *
2458 * Find a target index that can be used for a PCI controller.
2459 *
2460 * Returns: an unused target index, or -1 if all available target
2461 * indexes are already taken.
2462 */
2463 static int
qemuDomainAddressFindNewTargetIndex(virDomainDef * def)2464 qemuDomainAddressFindNewTargetIndex(virDomainDef *def)
2465 {
2466 int targetIndex;
2467
2468 /* Try all indexes between 1 and 31 - QEMU only supports 32
2469 * PHBs, and 0 is reserved for the default, implicit one */
2470 for (targetIndex = 1; targetIndex <= 31; targetIndex++) {
2471 bool found = false;
2472 size_t i;
2473
2474 for (i = 0; i < def->ncontrollers; i++) {
2475 virDomainControllerDef *cont = def->controllers[i];
2476
2477 /* Skip everything but PHBs */
2478 if (!virDomainControllerIsPSeriesPHB(cont))
2479 continue;
2480
2481 /* Stop looking as soon as we find a PHB that's
2482 * already using this specific target index */
2483 if (cont->opts.pciopts.targetIndex == targetIndex) {
2484 found = true;
2485 break;
2486 }
2487 }
2488
2489 /* If no existing PCI controller uses this index, great,
2490 * it means it's free and we can return it to the caller */
2491 if (!found)
2492 return targetIndex;
2493 }
2494
2495 return -1;
2496 }
2497
2498
2499 static int
qemuDomainAddressFindNewBusNr(virDomainDef * def)2500 qemuDomainAddressFindNewBusNr(virDomainDef *def)
2501 {
2502 /* Try to find a nice default for busNr for a new pci-expander-bus.
2503 * This is a bit tricky, since you need to satisfy the following:
2504 *
2505 * 1) There need to be enough unused bus numbers between busNr of this
2506 * bus and busNr of the next highest bus for the guest to assign a
2507 * unique bus number to each PCI bus that is a child of this
2508 * bus. Each PCI controller. On top of this, the pxb device (which
2509 * implements the pci-expander-bus) includes a pci-bridge within
2510 * it, and that bridge also uses one bus number (so each pxb device
2511 * requires at least 2 bus numbers).
2512 *
2513 * 2) There need to be enough bus numbers *below* this for all the
2514 * child controllers of the pci-expander-bus with the next lower
2515 * busNr (or the pci-root bus if there are no lower
2516 * pci-expander-buses).
2517 *
2518 * 3) If at all possible, we want to avoid needing to change the busNr
2519 * of a bus in the future, as that changes the guest's device ABI,
2520 * which could potentially lead to issues with a guest OS that is
2521 * picky about such things.
2522 *
2523 * Due to the impossibility of predicting what might be added to the
2524 * config in the future, we can't make a foolproof choice, but since
2525 * a pci-expander-bus (pxb) has slots for 32 devices, and the only
2526 * practical use for it is to assign real devices on a particular
2527 * NUMA node in the host, it's reasonably safe to assume it should
2528 * never need any additional child buses (probably only a few of the
2529 * 32 will ever be used). So for pci-expander-bus we find the lowest
2530 * existing busNr, and set this one to the current lowest - 2 (one
2531 * for the pxb, one for the integrated pci-bridge), thus leaving the
2532 * maximum possible bus numbers available for other buses plugged
2533 * into pci-root (i.e. pci-bridges and other
2534 * pci-expander-buses). Anyone who needs more than 32 devices
2535 * descended from one pci-expander-bus should set the busNr manually
2536 * in the config.
2537 *
2538 * There is room for more error checking here - in particular we
2539 * can/should determine the ultimate parent (root-bus) of each PCI
2540 * controller and determine if there is enough space for all the
2541 * buses within the current range allotted to the bus just prior to
2542 * this one.
2543 */
2544
2545 size_t i;
2546 int lowestBusNr = 256;
2547
2548 for (i = 0; i < def->ncontrollers; i++) {
2549 virDomainControllerDef *cont = def->controllers[i];
2550
2551 if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI) {
2552 int thisBusNr = cont->opts.pciopts.busNr;
2553
2554 if (thisBusNr >= 0 && thisBusNr < lowestBusNr)
2555 lowestBusNr = thisBusNr;
2556 }
2557 }
2558
2559 /* If we already have a busNR = 1, then we can't auto-assign (0 is
2560 * the pci[e]-root, and the others may have been assigned
2561 * purposefully).
2562 */
2563 if (lowestBusNr <= 2)
2564 return -1;
2565
2566 return lowestBusNr - 2;
2567 }
2568
2569
2570 static int
qemuDomainAssignPCIAddresses(virDomainDef * def,virQEMUCaps * qemuCaps,virQEMUDriver * driver,virDomainObj * obj)2571 qemuDomainAssignPCIAddresses(virDomainDef *def,
2572 virQEMUCaps *qemuCaps,
2573 virQEMUDriver *driver,
2574 virDomainObj *obj)
2575 {
2576 int ret = -1;
2577 virDomainPCIAddressSet *addrs = NULL;
2578 qemuDomainObjPrivate *priv = NULL;
2579 int max_idx = -1;
2580 int nbuses = 0;
2581 size_t i;
2582 int rv;
2583
2584 for (i = 0; i < def->ncontrollers; i++) {
2585 virDomainControllerDef *cont = def->controllers[i];
2586
2587 if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI) {
2588 if ((int)cont->idx > max_idx)
2589 max_idx = cont->idx;
2590 }
2591 }
2592
2593 nbuses = max_idx + 1;
2594
2595 /* set the connect type flags (pci vs. pcie) in the DeviceInfo
2596 * of all devices. This will be used to pick an appropriate
2597 * bus when assigning addresses.
2598 */
2599 if (qemuDomainFillAllPCIConnectFlags(def, qemuCaps, driver) < 0)
2600 goto cleanup;
2601
2602 if (qemuDomainFillAllPCIExtensionFlags(def, qemuCaps) < 0)
2603 goto cleanup;
2604
2605 if (qemuDomainSetupIsolationGroups(def) < 0)
2606 goto cleanup;
2607
2608 if (nbuses > 0) {
2609 /* 1st pass to figure out how many PCI bridges we need */
2610 if (!(addrs = qemuDomainPCIAddressSetCreate(def, qemuCaps, nbuses, true)))
2611 goto cleanup;
2612
2613 if (qemuDomainValidateDevicePCISlotsChipsets(def, addrs) < 0)
2614 goto cleanup;
2615
2616 /* For domains that have pci-root, reserve 1 extra slot for a
2617 * (potential) bridge (for future expansion) only if buses are
2618 * not fully reserved yet (if all buses are fully reserved
2619 * with manually/previously assigned addresses, any attempt to
2620 * reserve an extra slot would fail anyway. But if all buses
2621 * are *not* fully reserved, this extra reservation might push
2622 * the config to add a new pci-bridge to plug into the final
2623 * available slot, thus preserving the ability to expand)
2624 *
2625 * We only do this for those domains that have pci-root, since
2626 * those with pcie-root will usually want to expand using PCIe
2627 * controllers, which we will do after assigning addresses for
2628 * all *actual* devices.
2629 */
2630
2631 if (qemuDomainHasPCIRoot(def)) {
2632 /* This is a dummy info used to reserve a slot for a
2633 * legacy PCI device that doesn't exist, but may in the
2634 * future, e.g. if another device is hotplugged into the
2635 * domain.
2636 */
2637 virDomainDeviceInfo info = {
2638 .pciConnectFlags = (VIR_PCI_CONNECT_AUTOASSIGN |
2639 VIR_PCI_CONNECT_TYPE_PCI_DEVICE),
2640 .pciAddrExtFlags = VIR_PCI_ADDRESS_EXTENSION_NONE
2641 };
2642 bool buses_reserved = true;
2643
2644 for (i = 0; i < addrs->nbuses; i++) {
2645 if (!virDomainPCIAddressBusIsFullyReserved(&addrs->buses[i])) {
2646 buses_reserved = false;
2647 break;
2648 }
2649 }
2650 if (!buses_reserved &&
2651 qemuDomainPCIAddressReserveNextAddr(addrs, &info) < 0)
2652 goto cleanup;
2653 }
2654
2655 if (qemuDomainAssignDevicePCISlots(def, qemuCaps, addrs) < 0)
2656 goto cleanup;
2657
2658 if (virDomainDeviceInfoIterate(def, qemuDomainAssignPCIAddressExtension, addrs) < 0)
2659 goto cleanup;
2660
2661 /* Only for *new* domains with pcie-root (and no other
2662 * manually specified PCI controllers in the definition): If,
2663 * after assigning addresses/reserving slots for all devices,
2664 * we see that any extra buses have been auto-added, we
2665 * understand that the application has left management of PCI
2666 * addresses and controllers up to libvirt. In order to allow
2667 * such applications to easily support hotplug, we will do a
2668 * "one time" reservation of one extra PCIE|HOTPLUGGABLE
2669 * slots, which should cause us to auto-add 1 extra
2670 * pcie-root-port. The single slot in this root-port will be
2671 * available for hotplug, or may also be used when a device is
2672 * added to the config offline.
2673 */
2674
2675 if (max_idx <= 0 &&
2676 addrs->nbuses > max_idx + 1 &&
2677 qemuDomainHasPCIeRoot(def)) {
2678 virDomainDeviceInfo info = {
2679 .pciConnectFlags = (VIR_PCI_CONNECT_AUTOASSIGN |
2680 VIR_PCI_CONNECT_TYPE_PCIE_DEVICE),
2681 .pciAddrExtFlags = VIR_PCI_ADDRESS_EXTENSION_NONE
2682 };
2683
2684 /* if there isn't an empty pcie-root-port, this will
2685 * cause one to be added
2686 */
2687 if (qemuDomainPCIAddressReserveNextAddr(addrs, &info) < 0)
2688 goto cleanup;
2689 }
2690
2691 /* now reflect any controllers auto-added to addrs into the
2692 * domain controllers list
2693 */
2694 for (i = 1; i < addrs->nbuses; i++) {
2695 virDomainDeviceDef dev;
2696 int contIndex;
2697 virDomainPCIAddressBus *bus = &addrs->buses[i];
2698
2699 if ((rv = virDomainDefMaybeAddController(
2700 def, VIR_DOMAIN_CONTROLLER_TYPE_PCI,
2701 i, bus->model)) < 0)
2702 goto cleanup;
2703
2704 if (rv == 0)
2705 continue; /* no new controller added */
2706
2707 /* We did add a new controller, so we will need one more
2708 * address (and we need to set the new controller's
2709 * pciConnectFlags)
2710 */
2711 contIndex = virDomainControllerFind(def,
2712 VIR_DOMAIN_CONTROLLER_TYPE_PCI,
2713 i);
2714 if (contIndex < 0) {
2715 /* this should never happen - we just added it */
2716 virReportError(VIR_ERR_INTERNAL_ERROR,
2717 _("Could not find auto-added %s controller "
2718 "with index %zu"),
2719 virDomainControllerModelPCITypeToString(bus->model),
2720 i);
2721 goto cleanup;
2722 }
2723 dev.type = VIR_DOMAIN_DEVICE_CONTROLLER;
2724 dev.data.controller = def->controllers[contIndex];
2725 /* set connect flags so it will be properly addressed */
2726 qemuDomainFillDevicePCIConnectFlags(def, &dev, qemuCaps, driver);
2727
2728 /* Reserve an address for the controller. pci-root and pcie-root
2729 * controllers don't plug into any other PCI controller, hence
2730 * they should skip this step */
2731 if (bus->model != VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT &&
2732 bus->model != VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT &&
2733 qemuDomainPCIAddressReserveNextAddr(addrs,
2734 &dev.data.controller->info) < 0) {
2735 goto cleanup;
2736 }
2737 }
2738
2739 nbuses = addrs->nbuses;
2740 virDomainPCIAddressSetFree(addrs);
2741 addrs = NULL;
2742 }
2743
2744 if (!(addrs = qemuDomainPCIAddressSetCreate(def, qemuCaps, nbuses, false)))
2745 goto cleanup;
2746
2747 if (qemuDomainSupportsPCI(def, qemuCaps)) {
2748 if (qemuDomainValidateDevicePCISlotsChipsets(def, addrs) < 0)
2749 goto cleanup;
2750
2751 if (qemuDomainAssignDevicePCISlots(def, qemuCaps, addrs) < 0)
2752 goto cleanup;
2753
2754 if (virDomainDeviceInfoIterate(def, qemuDomainAssignPCIAddressExtension, addrs) < 0)
2755 goto cleanup;
2756
2757 /* set multi attribute for devices at function 0 of
2758 * any slot that has multiple functions in use
2759 */
2760 virDomainPCIAddressSetAllMulti(def);
2761
2762 for (i = 0; i < def->ncontrollers; i++) {
2763 virDomainControllerDef *cont = def->controllers[i];
2764 int idx = cont->idx;
2765 virPCIDeviceAddress *addr;
2766 virDomainPCIControllerOpts *options;
2767
2768 if (cont->type != VIR_DOMAIN_CONTROLLER_TYPE_PCI)
2769 continue;
2770
2771 addr = &cont->info.addr.pci;
2772 options = &cont->opts.pciopts;
2773
2774 /* set default model name (the actual name of the
2775 * device in qemu) for any controller that doesn't yet
2776 * have it set.
2777 */
2778 qemuDomainPCIControllerSetDefaultModelName(cont, def, qemuCaps);
2779
2780 /* set defaults for any other auto-generated config
2781 * options for this controller that haven't been
2782 * specified in config.
2783 */
2784 switch ((virDomainControllerModelPCI)cont->model) {
2785 case VIR_DOMAIN_CONTROLLER_MODEL_PCI_BRIDGE:
2786 if (options->chassisNr == -1)
2787 options->chassisNr = cont->idx;
2788 break;
2789 case VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT_PORT:
2790 if (options->chassis == -1)
2791 options->chassis = cont->idx;
2792 if (options->port == -1)
2793 options->port = (addr->slot << 3) + addr->function;
2794 break;
2795 case VIR_DOMAIN_CONTROLLER_MODEL_PCIE_SWITCH_DOWNSTREAM_PORT:
2796 if (options->chassis == -1)
2797 options->chassis = cont->idx;
2798 if (options->port == -1)
2799 options->port = addr->slot;
2800 break;
2801 case VIR_DOMAIN_CONTROLLER_MODEL_PCI_EXPANDER_BUS:
2802 case VIR_DOMAIN_CONTROLLER_MODEL_PCIE_EXPANDER_BUS:
2803 if (options->busNr == -1)
2804 options->busNr = qemuDomainAddressFindNewBusNr(def);
2805 if (options->busNr == -1) {
2806 virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
2807 _("No free busNr lower than current "
2808 "lowest busNr is available to "
2809 "auto-assign to bus %d. Must be "
2810 "manually assigned"),
2811 addr->bus);
2812 goto cleanup;
2813 }
2814 break;
2815 case VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT:
2816 if (!qemuDomainIsPSeries(def))
2817 break;
2818 if (options->targetIndex == -1) {
2819 if (cont->idx == 0) {
2820 /* The pci-root controller with controller index 0
2821 * must always be assigned target index 0, because
2822 * it represents the implicit PHB which is treated
2823 * differently than all other PHBs */
2824 options->targetIndex = 0;
2825 } else {
2826 /* For all other PHBs the target index doesn't need
2827 * to match the controller index or have any
2828 * particular value, really */
2829 options->targetIndex = qemuDomainAddressFindNewTargetIndex(def);
2830 }
2831 }
2832 if (options->targetIndex == -1) {
2833 virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
2834 _("No usable target index found for %d"),
2835 addr->bus);
2836 goto cleanup;
2837 }
2838 break;
2839 case VIR_DOMAIN_CONTROLLER_MODEL_DMI_TO_PCI_BRIDGE:
2840 case VIR_DOMAIN_CONTROLLER_MODEL_PCIE_TO_PCI_BRIDGE:
2841 case VIR_DOMAIN_CONTROLLER_MODEL_PCIE_SWITCH_UPSTREAM_PORT:
2842 case VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT:
2843 case VIR_DOMAIN_CONTROLLER_MODEL_PCI_DEFAULT:
2844 case VIR_DOMAIN_CONTROLLER_MODEL_PCI_LAST:
2845 break;
2846 }
2847
2848 /* check if every PCI bridge controller's index is larger than
2849 * the bus it is placed onto
2850 */
2851 if (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCI_BRIDGE &&
2852 idx <= addr->bus) {
2853 virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
2854 _("PCI controller at index %d (0x%02x) has "
2855 "bus='0x%02x', but index must be "
2856 "larger than bus"),
2857 idx, idx, addr->bus);
2858 goto cleanup;
2859 }
2860 }
2861 }
2862
2863 if (obj && obj->privateData) {
2864 priv = obj->privateData;
2865 /* if this is the live domain object, we persist the PCI addresses */
2866 priv->pciaddrs = g_steal_pointer(&addrs);
2867 }
2868
2869 ret = 0;
2870
2871 cleanup:
2872 virDomainPCIAddressSetFree(addrs);
2873
2874 return ret;
2875 }
2876
2877
2878 struct qemuAssignUSBIteratorInfo {
2879 virDomainUSBAddressSet *addrs;
2880 size_t count;
2881 };
2882
2883
2884 static int
qemuDomainAssignUSBPortsIterator(virDomainDeviceInfo * info,void * opaque)2885 qemuDomainAssignUSBPortsIterator(virDomainDeviceInfo *info,
2886 void *opaque)
2887 {
2888 struct qemuAssignUSBIteratorInfo *data = opaque;
2889
2890 if (info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE &&
2891 info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_USB)
2892 return 0;
2893
2894 if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_USB &&
2895 virDomainUSBAddressPortIsValid(info->addr.usb.port))
2896 return 0;
2897
2898 return virDomainUSBAddressAssign(data->addrs, info);
2899 }
2900
2901
2902 static int
qemuDomainAssignUSBHubs(virDomainUSBAddressSet * addrs,virDomainDef * def)2903 qemuDomainAssignUSBHubs(virDomainUSBAddressSet *addrs,
2904 virDomainDef *def)
2905 {
2906 size_t i;
2907
2908 for (i = 0; i < def->nhubs; i++) {
2909 virDomainHubDef *hub = def->hubs[i];
2910 if (hub->type != VIR_DOMAIN_HUB_TYPE_USB)
2911 continue;
2912
2913 if (hub->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_USB &&
2914 virDomainUSBAddressPortIsValid(hub->info.addr.usb.port))
2915 continue;
2916 if (virDomainUSBAddressAssign(addrs, &hub->info) < 0)
2917 return -1;
2918
2919 if (virDomainUSBAddressSetAddHub(addrs, hub) < 0)
2920 return -1;
2921 }
2922
2923 return 0;
2924 }
2925
2926
2927 static int
qemuDomainAssignUSBPorts(virDomainUSBAddressSet * addrs,virDomainDef * def)2928 qemuDomainAssignUSBPorts(virDomainUSBAddressSet *addrs,
2929 virDomainDef *def)
2930 {
2931 struct qemuAssignUSBIteratorInfo data = { .addrs = addrs };
2932
2933 return virDomainUSBDeviceDefForeach(def,
2934 qemuDomainAssignUSBPortsIterator,
2935 &data,
2936 true);
2937 }
2938
2939
2940 static int
qemuDomainAssignUSBPortsCounter(virDomainDeviceInfo * info G_GNUC_UNUSED,void * opaque)2941 qemuDomainAssignUSBPortsCounter(virDomainDeviceInfo *info G_GNUC_UNUSED,
2942 void *opaque)
2943 {
2944 struct qemuAssignUSBIteratorInfo *data = opaque;
2945
2946 data->count++;
2947 return 0;
2948 }
2949
2950
2951 static int
qemuDomainUSBAddressAddHubs(virDomainDef * def)2952 qemuDomainUSBAddressAddHubs(virDomainDef *def)
2953 {
2954 struct qemuAssignUSBIteratorInfo data = { .count = 0 };
2955 virDomainHubDef *hub = NULL;
2956 size_t available_ports;
2957 size_t hubs_needed = 0;
2958 size_t i;
2959
2960 available_ports = virDomainUSBAddressCountAllPorts(def);
2961 ignore_value(virDomainUSBDeviceDefForeach(def,
2962 qemuDomainAssignUSBPortsCounter,
2963 &data,
2964 false));
2965
2966 if (data.count > 0 && !virDomainDefHasUSB(def)) {
2967 virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
2968 _("USB is disabled for this domain, but USB devices "
2969 "are present in the domain XML"));
2970 return -1;
2971 }
2972
2973 if (data.count > available_ports)
2974 hubs_needed = VIR_DIV_UP(data.count - available_ports + 1,
2975 VIR_DOMAIN_USB_HUB_PORTS - 1);
2976
2977 VIR_DEBUG("Found %zu USB devices and %zu provided USB ports; adding %zu hubs",
2978 data.count, available_ports, hubs_needed);
2979
2980 for (i = 0; i < hubs_needed; i++) {
2981 hub = g_new0(virDomainHubDef, 1);
2982 hub->type = VIR_DOMAIN_HUB_TYPE_USB;
2983
2984 VIR_APPEND_ELEMENT(def->hubs, def->nhubs, hub);
2985 }
2986
2987 return 0;
2988 }
2989
2990
2991 static virBitmap *
qemuDomainGetMemorySlotMap(const virDomainDef * def)2992 qemuDomainGetMemorySlotMap(const virDomainDef *def)
2993 {
2994 virBitmap *ret = virBitmapNew(def->mem.memory_slots);
2995 virDomainMemoryDef *mem;
2996 size_t i;
2997
2998 for (i = 0; i < def->nmems; i++) {
2999 mem = def->mems[i];
3000
3001 if (mem->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DIMM)
3002 ignore_value(virBitmapSetBit(ret, mem->info.addr.dimm.slot));
3003 }
3004
3005 return ret;
3006 }
3007
3008
3009 static int
qemuAssignMemoryDeviceSlot(virDomainMemoryDef * mem,virBitmap * slotmap)3010 qemuAssignMemoryDeviceSlot(virDomainMemoryDef *mem,
3011 virBitmap *slotmap)
3012 {
3013 ssize_t nextslot = -1;
3014
3015 if (mem->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DIMM)
3016 return 0;
3017
3018 if ((nextslot = virBitmapNextClearBit(slotmap, -1)) < 0) {
3019 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3020 _("failed to find an empty memory slot"));
3021 return -1;
3022 }
3023
3024 ignore_value(virBitmapSetBit(slotmap, nextslot));
3025 mem->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DIMM;
3026 mem->info.addr.dimm.slot = nextslot;
3027
3028 return 0;
3029 }
3030
3031
3032 int
qemuDomainAssignMemoryDeviceSlot(virDomainObj * vm,virDomainMemoryDef * mem)3033 qemuDomainAssignMemoryDeviceSlot(virDomainObj *vm,
3034 virDomainMemoryDef *mem)
3035 {
3036 g_autoptr(virBitmap) slotmap = NULL;
3037 virDomainDeviceDef dev = {.type = VIR_DOMAIN_DEVICE_MEMORY, .data.memory = mem};
3038
3039 switch (mem->model) {
3040 case VIR_DOMAIN_MEMORY_MODEL_DIMM:
3041 case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
3042 if (!(slotmap = qemuDomainGetMemorySlotMap(vm->def)))
3043 return -1;
3044
3045 return qemuAssignMemoryDeviceSlot(mem, slotmap);
3046 break;
3047
3048 case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
3049 case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM:
3050 return qemuDomainEnsurePCIAddress(vm, &dev);
3051 break;
3052
3053 case VIR_DOMAIN_MEMORY_MODEL_NONE:
3054 case VIR_DOMAIN_MEMORY_MODEL_LAST:
3055 break;
3056 }
3057
3058 return 0;
3059 }
3060
3061
3062 void
qemuDomainReleaseMemoryDeviceSlot(virDomainObj * vm,virDomainMemoryDef * mem)3063 qemuDomainReleaseMemoryDeviceSlot(virDomainObj *vm,
3064 virDomainMemoryDef *mem)
3065 {
3066 switch (mem->model) {
3067 case VIR_DOMAIN_MEMORY_MODEL_DIMM:
3068 case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
3069 /* We don't need to release anything. Slot map is not
3070 * kept around. It's constructed every time when
3071 * assigning new slot. */
3072 break;
3073
3074 case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
3075 case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM:
3076 qemuDomainReleaseDeviceAddress(vm, &mem->info);
3077 break;
3078
3079 case VIR_DOMAIN_MEMORY_MODEL_NONE:
3080 case VIR_DOMAIN_MEMORY_MODEL_LAST:
3081 break;
3082 }
3083 }
3084
3085
3086 static int
qemuDomainAssignMemorySlots(virDomainDef * def)3087 qemuDomainAssignMemorySlots(virDomainDef *def)
3088 {
3089 virBitmap *slotmap = NULL;
3090 int ret = -1;
3091 size_t i;
3092
3093 if (!virDomainDefHasMemoryHotplug(def))
3094 return 0;
3095
3096 if (!(slotmap = qemuDomainGetMemorySlotMap(def)))
3097 return -1;
3098
3099 for (i = 0; i < def->nmems; i++) {
3100 virDomainMemoryDef *mem = def->mems[i];
3101
3102 switch (mem->model) {
3103 case VIR_DOMAIN_MEMORY_MODEL_DIMM:
3104 case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
3105 if (qemuAssignMemoryDeviceSlot(def->mems[i], slotmap) < 0)
3106 goto cleanup;
3107 break;
3108
3109 case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
3110 case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM:
3111 /* handled in qemuDomainAssignPCIAddresses() */
3112 break;
3113 case VIR_DOMAIN_MEMORY_MODEL_NONE:
3114 case VIR_DOMAIN_MEMORY_MODEL_LAST:
3115 break;
3116 }
3117 }
3118
3119 ret = 0;
3120
3121 cleanup:
3122 virBitmapFree(slotmap);
3123 return ret;
3124
3125 }
3126
3127
3128 static int
qemuDomainAssignUSBAddresses(virDomainDef * def,virDomainObj * obj,bool newDomain)3129 qemuDomainAssignUSBAddresses(virDomainDef *def,
3130 virDomainObj *obj,
3131 bool newDomain)
3132 {
3133 int ret = -1;
3134 virDomainUSBAddressSet *addrs = NULL;
3135 qemuDomainObjPrivate *priv = NULL;
3136
3137 if (!newDomain) {
3138 /* only create the address cache for:
3139 * new domains
3140 * domains that already have all the addresses specified
3141 * otherwise libvirt's attempt to recreate the USB topology via
3142 * QEMU command line might fail */
3143 if (virDomainUSBDeviceDefForeach(def, virDomainUSBAddressPresent, NULL,
3144 false) < 0)
3145 return 0;
3146 }
3147
3148 if (!(addrs = virDomainUSBAddressSetCreate()))
3149 goto cleanup;
3150
3151 if (qemuDomainUSBAddressAddHubs(def) < 0)
3152 goto cleanup;
3153
3154 if (virDomainUSBAddressSetAddControllers(addrs, def) < 0)
3155 goto cleanup;
3156
3157 if (virDomainUSBDeviceDefForeach(def, virDomainUSBAddressReserve, addrs,
3158 true) < 0)
3159 goto cleanup;
3160
3161 VIR_DEBUG("Existing USB addresses have been reserved");
3162
3163 if (qemuDomainAssignUSBHubs(addrs, def) < 0)
3164 goto cleanup;
3165
3166 if (qemuDomainAssignUSBPorts(addrs, def) < 0)
3167 goto cleanup;
3168
3169 VIR_DEBUG("Finished assigning USB ports");
3170
3171 if (obj && obj->privateData) {
3172 priv = obj->privateData;
3173 priv->usbaddrs = g_steal_pointer(&addrs);
3174 }
3175 ret = 0;
3176
3177 cleanup:
3178 virDomainUSBAddressSetFree(addrs);
3179 return ret;
3180 }
3181
3182
3183 int
qemuDomainAssignAddresses(virDomainDef * def,virQEMUCaps * qemuCaps,virQEMUDriver * driver,virDomainObj * obj,bool newDomain)3184 qemuDomainAssignAddresses(virDomainDef *def,
3185 virQEMUCaps *qemuCaps,
3186 virQEMUDriver *driver,
3187 virDomainObj *obj,
3188 bool newDomain)
3189 {
3190 if (qemuDomainAssignVirtioSerialAddresses(def) < 0)
3191 return -1;
3192
3193 if (qemuDomainAssignSpaprVIOAddresses(def) < 0)
3194 return -1;
3195
3196 if (qemuDomainAssignS390Addresses(def, qemuCaps) < 0)
3197 return -1;
3198
3199 qemuDomainAssignVirtioMMIOAddresses(def, qemuCaps);
3200
3201 if (qemuDomainAssignPCIAddresses(def, qemuCaps, driver, obj) < 0)
3202 return -1;
3203
3204 if (qemuDomainAssignUSBAddresses(def, obj, newDomain) < 0)
3205 return -1;
3206
3207 if (qemuDomainAssignMemorySlots(def) < 0)
3208 return -1;
3209
3210 return 0;
3211 }
3212
3213 /**
3214 * qemuDomainEnsurePCIAddress:
3215 *
3216 * @obj: the virDomainObj *f or the domain. This will include
3217 * qemuCaps and address cache (if there is one)
3218 *
3219 * @dev: the device that we need to ensure has a PCI address
3220 *
3221 * if @dev should have a PCI address but doesn't, assign an address on
3222 * a compatible PCI bus, and set it in @dev->...info. If there is an
3223 * address already, validate that it is on a compatible bus, based on
3224 * @dev->...info.pciConnectFlags.
3225 *
3226 * returns 0 on success -1 on failure.
3227 */
3228 int
qemuDomainEnsurePCIAddress(virDomainObj * obj,virDomainDeviceDef * dev)3229 qemuDomainEnsurePCIAddress(virDomainObj *obj,
3230 virDomainDeviceDef *dev)
3231 {
3232 qemuDomainObjPrivate *priv = obj->privateData;
3233 virDomainDeviceInfo *info = virDomainDeviceGetInfo(dev);
3234
3235 if (!info)
3236 return 0;
3237
3238 qemuDomainFillDevicePCIConnectFlags(obj->def, dev, priv->qemuCaps, priv->driver);
3239
3240 qemuDomainFillDevicePCIExtensionFlags(dev, info, priv->qemuCaps);
3241
3242 return virDomainPCIAddressEnsureAddr(priv->pciaddrs, info,
3243 info->pciConnectFlags);
3244 }
3245
3246 void
qemuDomainReleaseDeviceAddress(virDomainObj * vm,virDomainDeviceInfo * info)3247 qemuDomainReleaseDeviceAddress(virDomainObj *vm,
3248 virDomainDeviceInfo *info)
3249 {
3250 qemuDomainObjPrivate *priv = vm->privateData;
3251
3252 if (virDeviceInfoPCIAddressIsPresent(info)) {
3253 virDomainPCIAddressReleaseAddr(priv->pciaddrs, &info->addr.pci);
3254 virDomainPCIAddressExtensionReleaseAddr(priv->pciaddrs, &info->addr.pci);
3255 }
3256
3257 virDomainUSBAddressRelease(priv->usbaddrs, info);
3258 }
3259
3260
3261 int
qemuDomainEnsureVirtioAddress(bool * releaseAddr,virDomainObj * vm,virDomainDeviceDef * dev)3262 qemuDomainEnsureVirtioAddress(bool *releaseAddr,
3263 virDomainObj *vm,
3264 virDomainDeviceDef *dev)
3265 {
3266 virDomainDeviceInfo *info = virDomainDeviceGetInfo(dev);
3267 qemuDomainObjPrivate *priv = vm->privateData;
3268 virDomainCCWAddressSet *ccwaddrs = NULL;
3269 int ret = -1;
3270
3271 if (!info->type) {
3272 if (qemuDomainIsS390CCW(vm->def) &&
3273 virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_CCW))
3274 info->type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW;
3275 }
3276
3277 if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW) {
3278 if (!(ccwaddrs = virDomainCCWAddressSetCreateFromDomain(vm->def)))
3279 goto cleanup;
3280 if (virDomainCCWAddressAssign(info, ccwaddrs,
3281 !info->addr.ccw.assigned) < 0)
3282 goto cleanup;
3283 } else if (!info->type ||
3284 info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
3285 if (qemuDomainEnsurePCIAddress(vm, dev) < 0)
3286 goto cleanup;
3287 *releaseAddr = true;
3288 }
3289
3290 ret = 0;
3291
3292 cleanup:
3293 virDomainCCWAddressSetFree(ccwaddrs);
3294 return ret;
3295 }
3296