1 /*
2 * qemu_alias.c: QEMU alias manipulation
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_alias.h"
25 #include "viralloc.h"
26 #include "virlog.h"
27 #include "virstring.h"
28 #include "virutil.h"
29
30 #define QEMU_DRIVE_HOST_PREFIX "drive-"
31
32 #define VIR_FROM_THIS VIR_FROM_QEMU
33
34 VIR_LOG_INIT("qemu.qemu_alias");
35
36 int
qemuDomainDeviceAliasIndex(const virDomainDeviceInfo * info,const char * prefix)37 qemuDomainDeviceAliasIndex(const virDomainDeviceInfo *info,
38 const char *prefix)
39 {
40 int idx;
41
42 if (!info->alias)
43 return -1;
44 if (!STRPREFIX(info->alias, prefix))
45 return -1;
46
47 if (virStrToLong_i(info->alias + strlen(prefix), NULL, 10, &idx) < 0)
48 return -1;
49
50 return idx;
51 }
52
53
54 static ssize_t
qemuGetNextChrDevIndex(virDomainDef * def,virDomainChrDef * chr,const char * prefix)55 qemuGetNextChrDevIndex(virDomainDef *def,
56 virDomainChrDef *chr,
57 const char *prefix)
58 {
59 const virDomainChrDef **arrPtr;
60 size_t cnt;
61 size_t i;
62 ssize_t idx = 0;
63 const char *prefix2 = NULL;
64
65 if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE)
66 prefix2 = "serial";
67
68 virDomainChrGetDomainPtrs(def, chr->deviceType, &arrPtr, &cnt);
69
70 for (i = 0; i < cnt; i++) {
71 ssize_t thisidx;
72 if (((thisidx = qemuDomainDeviceAliasIndex(&arrPtr[i]->info, prefix)) < 0) &&
73 (prefix2 &&
74 (thisidx = qemuDomainDeviceAliasIndex(&arrPtr[i]->info, prefix2)) < 0))
75 continue;
76 if (thisidx >= idx)
77 idx = thisidx + 1;
78 }
79
80 return idx;
81 }
82
83
84 int
qemuAssignDeviceChrAlias(virDomainDef * def,virDomainChrDef * chr,ssize_t idx)85 qemuAssignDeviceChrAlias(virDomainDef *def,
86 virDomainChrDef *chr,
87 ssize_t idx)
88 {
89 const char *prefix = NULL;
90
91 if (chr->info.alias)
92 return 0;
93
94 switch ((virDomainChrDeviceType)chr->deviceType) {
95 case VIR_DOMAIN_CHR_DEVICE_TYPE_PARALLEL:
96 prefix = "parallel";
97 break;
98
99 case VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL:
100 prefix = "serial";
101 break;
102
103 case VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE:
104 prefix = "console";
105 break;
106
107 case VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL:
108 prefix = "channel";
109 break;
110
111 case VIR_DOMAIN_CHR_DEVICE_TYPE_LAST:
112 return -1;
113 }
114
115 if (idx == -1 && (idx = qemuGetNextChrDevIndex(def, chr, prefix)) < 0)
116 return -1;
117
118 chr->info.alias = g_strdup_printf("%s%zd", prefix, idx);
119 return 0;
120 }
121
122
123 void
qemuAssignDeviceControllerAlias(virDomainDef * domainDef,virDomainControllerDef * controller)124 qemuAssignDeviceControllerAlias(virDomainDef *domainDef,
125 virDomainControllerDef *controller)
126 {
127 const char *prefix = virDomainControllerTypeToString(controller->type);
128
129 if (controller->info.alias)
130 return;
131
132 if (controller->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI) {
133 if (!virQEMUCapsHasPCIMultiBus(domainDef)) {
134 /* qemus that don't support multiple PCI buses have
135 * hardcoded the name of their single PCI controller as
136 * "pci".
137 */
138 controller->info.alias = g_strdup("pci");
139 return;
140 }
141 if (controller->model == VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT) {
142 /* The pcie-root controller on Q35 machinetypes uses a
143 * different naming convention ("pcie.0"), because it is
144 * hardcoded that way in qemu.
145 */
146 controller->info.alias = g_strdup_printf("pcie.%d", controller->idx);
147 return;
148 }
149 /* All other PCI controllers use the consistent "pci.%u"
150 * (including the hardcoded pci-root controller on
151 * multibus-capable qemus).
152 */
153 controller->info.alias = g_strdup_printf("pci.%d", controller->idx);
154 return;
155 }
156 if (controller->type == VIR_DOMAIN_CONTROLLER_TYPE_IDE) {
157 /* for any machine based on e.g. I440FX or G3Beige, the
158 * first (and currently only) IDE controller is an integrated
159 * controller hardcoded with id "ide"
160 */
161 if (qemuDomainHasBuiltinIDE(domainDef) &&
162 controller->idx == 0) {
163 controller->info.alias = g_strdup("ide");
164 return;
165 }
166 } else if (controller->type == VIR_DOMAIN_CONTROLLER_TYPE_SATA) {
167 /* for any Q35 machine, the first SATA controller is the
168 * integrated one, and it too is hardcoded with id "ide"
169 */
170 if (qemuDomainIsQ35(domainDef) && controller->idx == 0) {
171 controller->info.alias = g_strdup("ide");
172 return;
173 }
174 } else if (controller->type == VIR_DOMAIN_CONTROLLER_TYPE_USB) {
175 /* first USB device is "usb", others are normal "usb%d" */
176 if (controller->idx == 0) {
177 controller->info.alias = g_strdup("usb");
178 return;
179 }
180 } else if (controller->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI) {
181 if (controller->model == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_NCR53C90 &&
182 controller->idx == 0) {
183 controller->info.alias = g_strdup("scsi");
184 return;
185 }
186 }
187 /* all other controllers use the default ${type}${index} naming
188 * scheme for alias/id.
189 */
190 controller->info.alias = g_strdup_printf("%s%d", prefix, controller->idx);
191 }
192
193
194 int
qemuAssignDeviceDiskAlias(virDomainDef * def,virDomainDiskDef * disk,virQEMUCaps * qemuCaps)195 qemuAssignDeviceDiskAlias(virDomainDef *def,
196 virDomainDiskDef *disk,
197 virQEMUCaps *qemuCaps)
198 {
199 qemuDomainDiskPrivate *diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
200 const char *prefix = virDomainDiskBusTypeToString(disk->bus);
201 int controllerModel = -1;
202
203 if (!disk->info.alias) {
204 if (disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
205 if (disk->bus == VIR_DOMAIN_DISK_BUS_SCSI) {
206 controllerModel = qemuDomainFindSCSIControllerModel(def,
207 &disk->info);
208 if (controllerModel < 0)
209 return -1;
210 }
211
212 if (disk->bus != VIR_DOMAIN_DISK_BUS_SCSI ||
213 controllerModel == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC) {
214 disk->info.alias = g_strdup_printf("%s%d-%d-%d", prefix,
215 disk->info.addr.drive.controller,
216 disk->info.addr.drive.bus,
217 disk->info.addr.drive.unit);
218 } else {
219 disk->info.alias = g_strdup_printf("%s%d-%d-%d-%d", prefix,
220 disk->info.addr.drive.controller,
221 disk->info.addr.drive.bus,
222 disk->info.addr.drive.target,
223 disk->info.addr.drive.unit);
224 }
225 } else {
226 int idx = virDiskNameToIndex(disk->dst);
227 disk->info.alias = g_strdup_printf("%s-disk%d", prefix, idx);
228 }
229 }
230
231 /* For -blockdev we need to know the qom names of the disk which are based
232 * on the alias in qemu. While certain disk types use just the alias, some
233 * need the full path into /machine/peripheral as a historical artifact.
234 */
235 if (!diskPriv->qomName &&
236 virQEMUCapsGet(qemuCaps, QEMU_CAPS_BLOCKDEV)) {
237 switch ((virDomainDiskBus) disk->bus) {
238 case VIR_DOMAIN_DISK_BUS_FDC:
239 case VIR_DOMAIN_DISK_BUS_IDE:
240 case VIR_DOMAIN_DISK_BUS_SATA:
241 case VIR_DOMAIN_DISK_BUS_SCSI:
242 diskPriv->qomName = g_strdup(disk->info.alias);
243 break;
244
245 case VIR_DOMAIN_DISK_BUS_VIRTIO:
246 diskPriv->qomName = g_strdup_printf("/machine/peripheral/%s/virtio-backend",
247 disk->info.alias);
248 break;
249
250 case VIR_DOMAIN_DISK_BUS_USB:
251 diskPriv->qomName = g_strdup_printf("/machine/peripheral/%s/%s.0/legacy[0]",
252 disk->info.alias, disk->info.alias);
253 break;
254
255 case VIR_DOMAIN_DISK_BUS_XEN:
256 case VIR_DOMAIN_DISK_BUS_UML:
257 case VIR_DOMAIN_DISK_BUS_SD:
258 case VIR_DOMAIN_DISK_BUS_NONE:
259 case VIR_DOMAIN_DISK_BUS_LAST:
260 break;
261 }
262 }
263
264 return 0;
265 }
266
267
268 void
qemuAssignDeviceHostdevAlias(virDomainDef * def,char ** alias,int idx)269 qemuAssignDeviceHostdevAlias(virDomainDef *def,
270 char **alias,
271 int idx)
272 {
273 if (*alias)
274 return;
275
276 if (idx == -1) {
277 size_t i;
278
279 idx = 0;
280 for (i = 0; i < def->nhostdevs; i++) {
281 int thisidx;
282
283 if ((thisidx = qemuDomainDeviceAliasIndex(def->hostdevs[i]->info, "hostdev")) < 0)
284 continue; /* error just means the alias wasn't "hostdevN", but something else */
285 if (thisidx >= idx)
286 idx = thisidx + 1;
287 }
288 /* network interfaces can also have a hostdevN alias */
289 for (i = 0; i < def->nnets; i++) {
290 int thisidx;
291
292 if ((thisidx = qemuDomainDeviceAliasIndex(&def->nets[i]->info, "hostdev")) < 0)
293 continue;
294 if (thisidx >= idx)
295 idx = thisidx + 1;
296 }
297 }
298
299 *alias = g_strdup_printf("hostdev%d", idx);
300 }
301
302
303 void
qemuAssignDeviceNetAlias(virDomainDef * def,virDomainNetDef * net,int idx)304 qemuAssignDeviceNetAlias(virDomainDef *def,
305 virDomainNetDef *net,
306 int idx)
307 {
308 if (net->info.alias)
309 return;
310
311 /* <interface type='hostdev'> uses "hostdevN" as the alias
312 * We must use "-1" as the index because the caller doesn't know
313 * that we're now looking for a unique hostdevN rather than netN
314 */
315 if (virDomainNetResolveActualType(net) == VIR_DOMAIN_NET_TYPE_HOSTDEV) {
316 qemuAssignDeviceHostdevAlias(def, &net->info.alias, -1);
317 return;
318 }
319
320 if (idx == -1) {
321 size_t i;
322
323 idx = 0;
324 for (i = 0; i < def->nnets; i++) {
325 int thisidx;
326
327 if ((thisidx = qemuDomainDeviceAliasIndex(&def->nets[i]->info, "net")) < 0)
328 continue; /* failure could be due to "hostdevN" */
329 if (thisidx >= idx)
330 idx = thisidx + 1;
331 }
332 }
333
334 net->info.alias = g_strdup_printf("net%d", idx);
335 }
336
337
338 void
qemuAssignDeviceFSAlias(virDomainDef * def,virDomainFSDef * fss)339 qemuAssignDeviceFSAlias(virDomainDef *def,
340 virDomainFSDef *fss)
341 {
342 size_t i;
343 int maxidx = 0;
344
345 if (fss->info.alias)
346 return;
347
348 for (i = 0; i < def->nfss; i++) {
349 int idx;
350
351 if ((idx = qemuDomainDeviceAliasIndex(&def->fss[i]->info, "fs")) >= maxidx)
352 maxidx = idx + 1;
353 }
354
355 fss->info.alias = g_strdup_printf("fs%d", maxidx);
356 }
357
358
359 static void
qemuAssignDeviceSoundAlias(virDomainSoundDef * sound,int idx)360 qemuAssignDeviceSoundAlias(virDomainSoundDef *sound,
361 int idx)
362 {
363 if (!sound->info.alias)
364 sound->info.alias = g_strdup_printf("sound%d", idx);
365 }
366
367
368 static void
qemuAssignDeviceVideoAlias(virDomainVideoDef * video,int idx)369 qemuAssignDeviceVideoAlias(virDomainVideoDef *video,
370 int idx)
371 {
372 if (!video->info.alias)
373 video->info.alias = g_strdup_printf("video%d", idx);
374 }
375
376
377 static void
qemuAssignDeviceHubAlias(virDomainHubDef * hub,int idx)378 qemuAssignDeviceHubAlias(virDomainHubDef *hub,
379 int idx)
380 {
381 if (!hub->info.alias)
382 hub->info.alias = g_strdup_printf("hub%d", idx);
383 }
384
385
386 static void
qemuAssignDeviceSmartcardAlias(virDomainSmartcardDef * smartcard,int idx)387 qemuAssignDeviceSmartcardAlias(virDomainSmartcardDef *smartcard,
388 int idx)
389 {
390 if (!smartcard->info.alias)
391 smartcard->info.alias = g_strdup_printf("smartcard%d", idx);
392 }
393
394
395 static void
qemuAssignDeviceMemballoonAlias(virDomainMemballoonDef * memballoon,int idx)396 qemuAssignDeviceMemballoonAlias(virDomainMemballoonDef *memballoon,
397 int idx)
398 {
399 if (!memballoon->info.alias)
400 memballoon->info.alias = g_strdup_printf("balloon%d", idx);
401 }
402
403
404 static void
qemuAssignDeviceTPMAlias(virDomainTPMDef * tpm,int idx)405 qemuAssignDeviceTPMAlias(virDomainTPMDef *tpm,
406 int idx)
407 {
408 if (!tpm->info.alias)
409 tpm->info.alias = g_strdup_printf("tpm%d", idx);
410 }
411
412
413 void
qemuAssignDeviceRedirdevAlias(virDomainDef * def,virDomainRedirdevDef * redirdev,int idx)414 qemuAssignDeviceRedirdevAlias(virDomainDef *def,
415 virDomainRedirdevDef *redirdev,
416 int idx)
417 {
418 if (redirdev->info.alias)
419 return;
420
421 if (idx == -1) {
422 size_t i;
423 idx = 0;
424 for (i = 0; i < def->nredirdevs; i++) {
425 int thisidx;
426 if ((thisidx = qemuDomainDeviceAliasIndex(&def->redirdevs[i]->info, "redir")) < 0)
427 continue;
428 if (thisidx >= idx)
429 idx = thisidx + 1;
430 }
431 }
432
433 redirdev->info.alias = g_strdup_printf("redir%d", idx);
434 }
435
436
437 void
qemuAssignDeviceRNGAlias(virDomainDef * def,virDomainRNGDef * rng)438 qemuAssignDeviceRNGAlias(virDomainDef *def,
439 virDomainRNGDef *rng)
440 {
441 size_t i;
442 int maxidx = 0;
443 int idx;
444
445 if (rng->info.alias)
446 return;
447
448 for (i = 0; i < def->nrngs; i++) {
449 if ((idx = qemuDomainDeviceAliasIndex(&def->rngs[i]->info, "rng")) >= maxidx)
450 maxidx = idx + 1;
451 }
452
453 rng->info.alias = g_strdup_printf("rng%d", maxidx);
454 }
455
456
457 static int
qemuDeviceMemoryGetAliasID(virDomainDef * def,virDomainMemoryDef * mem,bool oldAlias,const char * prefix)458 qemuDeviceMemoryGetAliasID(virDomainDef *def,
459 virDomainMemoryDef *mem,
460 bool oldAlias,
461 const char *prefix)
462 {
463 size_t i;
464 int maxidx = 0;
465
466 /* virtio-pmem and virtio-mem go onto PCI bus and thus DIMM address is not
467 * valid */
468 if (!oldAlias &&
469 mem->model != VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM &&
470 mem->model != VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM)
471 return mem->info.addr.dimm.slot;
472
473 for (i = 0; i < def->nmems; i++) {
474 int idx;
475 if ((idx = qemuDomainDeviceAliasIndex(&def->mems[i]->info, prefix)) >= maxidx)
476 maxidx = idx + 1;
477 }
478
479 return maxidx;
480 }
481
482
483 /**
484 * qemuAssignDeviceMemoryAlias:
485 * @def: domain definition. Necessary only if @oldAlias is true.
486 * @mem: memory device definition
487 * @oldAlias: Generate the alias according to the order of the device in @def
488 * rather than according to the slot number for legacy reasons.
489 *
490 * Generates alias for a memory device according to slot number if @oldAlias is
491 * false or according to order in @def->mems otherwise.
492 *
493 * Returns 0 on success, -1 on error.
494 */
495 int
qemuAssignDeviceMemoryAlias(virDomainDef * def,virDomainMemoryDef * mem,bool oldAlias)496 qemuAssignDeviceMemoryAlias(virDomainDef *def,
497 virDomainMemoryDef *mem,
498 bool oldAlias)
499 {
500 const char *prefix = NULL;
501 int idx = 0;
502
503 if (mem->info.alias)
504 return 0;
505
506 switch (mem->model) {
507 case VIR_DOMAIN_MEMORY_MODEL_DIMM:
508 prefix = "dimm";
509 break;
510 case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
511 prefix = "nvdimm";
512 break;
513 case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_PMEM:
514 prefix = "virtiopmem";
515 break;
516 case VIR_DOMAIN_MEMORY_MODEL_VIRTIO_MEM:
517 prefix = "virtiomem";
518 break;
519 case VIR_DOMAIN_MEMORY_MODEL_NONE:
520 case VIR_DOMAIN_MEMORY_MODEL_LAST:
521 default:
522 virReportEnumRangeError(virDomainMemoryModel, mem->model);
523 return -1;
524 break;
525 }
526
527 idx = qemuDeviceMemoryGetAliasID(def, mem, oldAlias, prefix);
528 mem->info.alias = g_strdup_printf("%s%d", prefix, idx);
529
530 return 0;
531 }
532
533
534 void
qemuAssignDeviceShmemAlias(virDomainDef * def,virDomainShmemDef * shmem,int idx)535 qemuAssignDeviceShmemAlias(virDomainDef *def,
536 virDomainShmemDef *shmem,
537 int idx)
538 {
539 if (shmem->info.alias)
540 return;
541
542 if (idx == -1) {
543 size_t i;
544 idx = 0;
545 for (i = 0; i < def->nshmems; i++) {
546 int thisidx;
547
548 if ((thisidx = qemuDomainDeviceAliasIndex(&def->shmems[i]->info,
549 "shmem")) < 0)
550 continue;
551
552 if (thisidx >= idx)
553 idx = thisidx + 1;
554 }
555 }
556
557 shmem->info.alias = g_strdup_printf("shmem%d", idx);
558 }
559
560
561 void
qemuAssignDeviceWatchdogAlias(virDomainWatchdogDef * watchdog)562 qemuAssignDeviceWatchdogAlias(virDomainWatchdogDef *watchdog)
563 {
564 /* Currently, there's just one watchdog per domain */
565
566 if (!watchdog->info.alias)
567 watchdog->info.alias = g_strdup("watchdog0");
568 }
569
570
571 void
qemuAssignDeviceInputAlias(virDomainDef * def,virDomainInputDef * input,int idx)572 qemuAssignDeviceInputAlias(virDomainDef *def,
573 virDomainInputDef *input,
574 int idx)
575 {
576 if (input->info.alias)
577 return;
578
579 if (idx == -1) {
580 int thisidx;
581 size_t i;
582
583 for (i = 0; i < def->ninputs; i++) {
584 if ((thisidx = qemuDomainDeviceAliasIndex(&def->inputs[i]->info, "input")) >= idx)
585 idx = thisidx + 1;
586 }
587 }
588
589 input->info.alias = g_strdup_printf("input%d", idx);
590 }
591
592
593 void
qemuAssignDeviceVsockAlias(virDomainVsockDef * vsock)594 qemuAssignDeviceVsockAlias(virDomainVsockDef *vsock)
595 {
596 if (!vsock->info.alias)
597 vsock->info.alias = g_strdup("vsock0");
598 }
599
600
601 int
qemuAssignDeviceAliases(virDomainDef * def,virQEMUCaps * qemuCaps)602 qemuAssignDeviceAliases(virDomainDef *def, virQEMUCaps *qemuCaps)
603 {
604 size_t i;
605
606 for (i = 0; i < def->ndisks; i++) {
607 if (qemuAssignDeviceDiskAlias(def, def->disks[i], qemuCaps) < 0)
608 return -1;
609 }
610 for (i = 0; i < def->nnets; i++) {
611 qemuAssignDeviceNetAlias(def, def->nets[i], -1);
612 }
613
614 for (i = 0; i < def->nfss; i++) {
615 qemuAssignDeviceFSAlias(def, def->fss[i]);
616 }
617 for (i = 0; i < def->nsounds; i++) {
618 qemuAssignDeviceSoundAlias(def->sounds[i], i);
619 }
620 for (i = 0; i < def->nhostdevs; i++) {
621 /* we can't start assigning at 0, since netdevs may have used
622 * up some hostdevN entries already. Also if the HostdevDef is
623 * linked to a NetDef, they will share an info and the alias
624 * will already be set, so don't try to set it again.
625 */
626 qemuAssignDeviceHostdevAlias(def, &def->hostdevs[i]->info->alias, -1);
627 }
628 for (i = 0; i < def->nredirdevs; i++) {
629 qemuAssignDeviceRedirdevAlias(def, def->redirdevs[i], i);
630 }
631 for (i = 0; i < def->nvideos; i++) {
632 qemuAssignDeviceVideoAlias(def->videos[i], i);
633 }
634 for (i = 0; i < def->ncontrollers; i++) {
635 qemuAssignDeviceControllerAlias(def, def->controllers[i]);
636 }
637 for (i = 0; i < def->ninputs; i++) {
638 qemuAssignDeviceInputAlias(def, def->inputs[i], i);
639 }
640 for (i = 0; i < def->nparallels; i++) {
641 if (qemuAssignDeviceChrAlias(def, def->parallels[i], i) < 0)
642 return -1;
643 }
644 for (i = 0; i < def->nserials; i++) {
645 if (qemuAssignDeviceChrAlias(def, def->serials[i], i) < 0)
646 return -1;
647 }
648 for (i = 0; i < def->nchannels; i++) {
649 if (qemuAssignDeviceChrAlias(def, def->channels[i], i) < 0)
650 return -1;
651 }
652 for (i = 0; i < def->nconsoles; i++) {
653 if (qemuAssignDeviceChrAlias(def, def->consoles[i], i) < 0)
654 return -1;
655 }
656 for (i = 0; i < def->nhubs; i++) {
657 qemuAssignDeviceHubAlias(def->hubs[i], i);
658 }
659 for (i = 0; i < def->nshmems; i++) {
660 qemuAssignDeviceShmemAlias(def, def->shmems[i], i);
661 }
662 for (i = 0; i < def->nsmartcards; i++) {
663 qemuAssignDeviceSmartcardAlias(def->smartcards[i], i);
664 }
665 if (def->watchdog) {
666 qemuAssignDeviceWatchdogAlias(def->watchdog);
667 }
668 if (def->memballoon &&
669 def->memballoon->model != VIR_DOMAIN_MEMBALLOON_MODEL_NONE) {
670 qemuAssignDeviceMemballoonAlias(def->memballoon, 0);
671 }
672 for (i = 0; i < def->nrngs; i++) {
673 qemuAssignDeviceRNGAlias(def, def->rngs[i]);
674 }
675 for (i = 0; i < def->ntpms; i++) {
676 qemuAssignDeviceTPMAlias(def->tpms[i], i);
677 }
678 for (i = 0; i < def->nmems; i++) {
679 if (qemuAssignDeviceMemoryAlias(def, def->mems[i], false) < 0)
680 return -1;
681 }
682 if (def->vsock) {
683 qemuAssignDeviceVsockAlias(def->vsock);
684 }
685
686 return 0;
687 }
688
689
690 /* qemuAliasDiskDriveFromDisk
691 * @disk: Pointer to a disk definition
692 *
693 * Generate and return an alias for the device disk '-drive'
694 *
695 * Returns NULL with error or a string containing the alias
696 */
697 char *
qemuAliasDiskDriveFromDisk(const virDomainDiskDef * disk)698 qemuAliasDiskDriveFromDisk(const virDomainDiskDef *disk)
699 {
700 if (!disk->info.alias) {
701 virReportError(VIR_ERR_INVALID_ARG, "%s",
702 _("disk does not have an alias"));
703 return NULL;
704 }
705
706 return g_strdup_printf("%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias);
707 }
708
709
710 /* qemuAliasDiskDriveSkipPrefix:
711 * @dev_name: Pointer to a const char string
712 *
713 * If the QEMU_DRIVE_HOST_PREFIX exists in the input string, then
714 * increment the pointer and return it
715 */
716 const char *
qemuAliasDiskDriveSkipPrefix(const char * dev_name)717 qemuAliasDiskDriveSkipPrefix(const char *dev_name)
718 {
719 if (STRPREFIX(dev_name, QEMU_DRIVE_HOST_PREFIX))
720 dev_name += strlen(QEMU_DRIVE_HOST_PREFIX);
721 return dev_name;
722 }
723
724
725 /* qemuAliasFromHostdev
726 * @hostdev: Pointer to host device
727 *
728 * Generate and return a string containing a drive alias
729 */
730 char *
qemuAliasFromHostdev(const virDomainHostdevDef * hostdev)731 qemuAliasFromHostdev(const virDomainHostdevDef *hostdev)
732 {
733 if (!hostdev->info->alias) {
734 virReportError(VIR_ERR_INVALID_ARG, "%s",
735 _("hostdev does not have an alias"));
736 return NULL;
737 }
738
739 return g_strdup_printf("%s-%s",
740 virDomainDeviceAddressTypeToString(hostdev->info->type),
741 hostdev->info->alias);
742 }
743
744
745 /* qemuDomainGetMasterKeyAlias:
746 *
747 * Generate and return the masterKey alias
748 *
749 * Returns NULL or a string containing the master key alias
750 */
751 char *
qemuDomainGetMasterKeyAlias(void)752 qemuDomainGetMasterKeyAlias(void)
753 {
754 return g_strdup("masterKey0");
755 }
756
757
758 /* qemuAliasForSecret:
759 * @parentalias: alias of the parent object
760 * @obj: optional sub-object of the parent device the secret is for
761 *
762 * Generate alias for a secret object used by @parentalias device or one of
763 * the dependencies of the device described by @obj.
764 */
765 char *
qemuAliasForSecret(const char * parentalias,const char * obj)766 qemuAliasForSecret(const char *parentalias,
767 const char *obj)
768 {
769 if (obj)
770 return g_strdup_printf("%s-%s-secret0", parentalias, obj);
771 return g_strdup_printf("%s-secret0", parentalias);
772 }
773
774 /* qemuAliasTLSObjFromSrcAlias
775 * @srcAlias: Pointer to a source alias string
776 *
777 * Generate and return a string to be used as the TLS object alias
778 */
779 char *
qemuAliasTLSObjFromSrcAlias(const char * srcAlias)780 qemuAliasTLSObjFromSrcAlias(const char *srcAlias)
781 {
782 return g_strdup_printf("obj%s_tls0", srcAlias);
783 }
784
785
786 /* qemuAliasChardevFromDevAlias:
787 * @devAlias: pointer do device alias
788 *
789 * Generate and return a string to be used as chardev alias.
790 */
791 char *
qemuAliasChardevFromDevAlias(const char * devAlias)792 qemuAliasChardevFromDevAlias(const char *devAlias)
793 {
794 return g_strdup_printf("char%s", devAlias);
795 }
796
797
798 const char *
qemuDomainGetManagedPRAlias(void)799 qemuDomainGetManagedPRAlias(void)
800 {
801 return "pr-helper0";
802 }
803
804
805 char *
qemuDomainGetUnmanagedPRAlias(const char * parentalias)806 qemuDomainGetUnmanagedPRAlias(const char *parentalias)
807 {
808 return g_strdup_printf("pr-helper-%s", parentalias);
809 }
810
811
812 const char *
qemuDomainGetDBusVMStateAlias(void)813 qemuDomainGetDBusVMStateAlias(void)
814 {
815 return "dbus-vmstate0";
816 }
817
818 char *
qemuDomainGetVhostUserChrAlias(const char * devalias)819 qemuDomainGetVhostUserChrAlias(const char *devalias)
820 {
821 return g_strdup_printf("chr-vu-%s", devalias);
822 }
823