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

#include <config.h>

#include "qemu_alias.h"
#include "viralloc.h"
#include "virlog.h"
#include "virstring.h"
30
#include "network/bridge_driver.h"
31

32 33
#define QEMU_DRIVE_HOST_PREFIX "drive-"

34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
#define VIR_FROM_THIS VIR_FROM_QEMU

VIR_LOG_INIT("qemu.qemu_alias");

int
qemuDomainDeviceAliasIndex(const virDomainDeviceInfo *info,
                           const char *prefix)
{
    int idx;

    if (!info->alias)
        return -1;
    if (!STRPREFIX(info->alias, prefix))
        return -1;

    if (virStrToLong_i(info->alias + strlen(prefix), NULL, 10, &idx) < 0)
        return -1;

    return idx;
}


static ssize_t
qemuGetNextChrDevIndex(virDomainDefPtr def,
                       virDomainChrDefPtr chr,
                       const char *prefix)
{
    const virDomainChrDef **arrPtr;
    size_t cnt;
    size_t i;
    ssize_t idx = 0;
    const char *prefix2 = NULL;

    if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE)
        prefix2 = "serial";

    virDomainChrGetDomainPtrs(def, chr->deviceType, &arrPtr, &cnt);

    for (i = 0; i < cnt; i++) {
        ssize_t thisidx;
        if (((thisidx = qemuDomainDeviceAliasIndex(&arrPtr[i]->info, prefix)) < 0) &&
            (prefix2 &&
76 77
             (thisidx = qemuDomainDeviceAliasIndex(&arrPtr[i]->info, prefix2)) < 0))
            continue;
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
        if (thisidx >= idx)
            idx = thisidx + 1;
    }

    return idx;
}


int
qemuAssignDeviceChrAlias(virDomainDefPtr def,
                         virDomainChrDefPtr chr,
                         ssize_t idx)
{
    const char *prefix = NULL;

93 94 95
    if (chr->info.alias)
        return 0;

96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
    switch ((virDomainChrDeviceType) chr->deviceType) {
    case VIR_DOMAIN_CHR_DEVICE_TYPE_PARALLEL:
        prefix = "parallel";
        break;

    case VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL:
        prefix = "serial";
        break;

    case VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE:
        prefix = "console";
        break;

    case VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL:
        prefix = "channel";
        break;

    case VIR_DOMAIN_CHR_DEVICE_TYPE_LAST:
        return -1;
    }

    if (idx == -1 && (idx = qemuGetNextChrDevIndex(def, chr, prefix)) < 0)
        return -1;

    return virAsprintf(&chr->info.alias, "%s%zd", prefix, idx);
}


int
qemuAssignDeviceControllerAlias(virDomainDefPtr domainDef,
                                virQEMUCapsPtr qemuCaps,
                                virDomainControllerDefPtr controller)
{
    const char *prefix = virDomainControllerTypeToString(controller->type);

131 132 133
    if (controller->info.alias)
        return 0;

134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
    if (controller->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI) {
        if (!virQEMUCapsHasPCIMultiBus(qemuCaps, domainDef)) {
            /* qemus that don't support multiple PCI buses have
             * hardcoded the name of their single PCI controller as
             * "pci".
             */
            return VIR_STRDUP(controller->info.alias, "pci");
        } else if (controller->model == VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT) {
            /* The pcie-root controller on Q35 machinetypes uses a
             * different naming convention ("pcie.0"), because it is
             * hardcoded that way in qemu.
             */
            return virAsprintf(&controller->info.alias, "pcie.%d", controller->idx);
        }
        /* All other PCI controllers use the consistent "pci.%u"
         * (including the hardcoded pci-root controller on
         * multibus-capable qemus).
         */
        return virAsprintf(&controller->info.alias, "pci.%d", controller->idx);
    } else if (controller->type == VIR_DOMAIN_CONTROLLER_TYPE_IDE) {
        /* for any machine based on e.g. I440FX or G3Beige, the
         * first (and currently only) IDE controller is an integrated
         * controller hardcoded with id "ide"
         */
158
        if (qemuDomainHasBuiltinIDE(domainDef) &&
159 160 161 162 163 164
            controller->idx == 0)
            return VIR_STRDUP(controller->info.alias, "ide");
    } else if (controller->type == VIR_DOMAIN_CONTROLLER_TYPE_SATA) {
        /* for any Q35 machine, the first SATA controller is the
         * integrated one, and it too is hardcoded with id "ide"
         */
165
        if (qemuDomainIsQ35(domainDef) && controller->idx == 0)
166 167 168 169 170 171 172 173 174 175 176 177 178 179
            return VIR_STRDUP(controller->info.alias, "ide");
    } else if (controller->type == VIR_DOMAIN_CONTROLLER_TYPE_USB) {
        /* first USB device is "usb", others are normal "usb%d" */
        if (controller->idx == 0)
            return VIR_STRDUP(controller->info.alias, "usb");
    }
    /* all other controllers use the default ${type}${index} naming
     * scheme for alias/id.
     */
    return virAsprintf(&controller->info.alias, "%s%d", prefix, controller->idx);
}


/* Our custom -drive naming scheme used with id= */
180 181 182 183
int
qemuAssignDeviceDiskAlias(virDomainDefPtr def,
                          virDomainDiskDefPtr disk,
                          virQEMUCapsPtr qemuCaps)
184 185 186 187
{
    const char *prefix = virDomainDiskBusTypeToString(disk->bus);
    int controllerModel = -1;

188 189 190
    if (disk->info.alias)
        return 0;

191 192
    if (disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
        if (disk->bus == VIR_DOMAIN_DISK_BUS_SCSI) {
193 194 195 196
            controllerModel = qemuDomainFindSCSIControllerModel(def,
                                                                &disk->info,
                                                                qemuCaps);
            if (controllerModel < 0)
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
                return -1;
        }

        if (disk->bus != VIR_DOMAIN_DISK_BUS_SCSI ||
            controllerModel == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC) {
            if (virAsprintf(&disk->info.alias, "%s%d-%d-%d", prefix,
                            disk->info.addr.drive.controller,
                            disk->info.addr.drive.bus,
                            disk->info.addr.drive.unit) < 0)
                return -1;
        } else {
            if (virAsprintf(&disk->info.alias, "%s%d-%d-%d-%d", prefix,
                            disk->info.addr.drive.controller,
                            disk->info.addr.drive.bus,
                            disk->info.addr.drive.target,
                            disk->info.addr.drive.unit) < 0)
                return -1;
        }
    } else {
        int idx = virDiskNameToIndex(disk->dst);
        if (virAsprintf(&disk->info.alias, "%s-disk%d", prefix, idx) < 0)
            return -1;
    }

    return 0;
}


int
qemuAssignDeviceHostdevAlias(virDomainDefPtr def,
227
                             char **alias,
228 229
                             int idx)
{
230 231 232
    if (*alias)
        return 0;

233 234
    if (idx == -1) {
        size_t i;
235

236 237 238
        idx = 0;
        for (i = 0; i < def->nhostdevs; i++) {
            int thisidx;
239 240 241 242 243 244 245 246 247 248 249 250

            if ((thisidx = qemuDomainDeviceAliasIndex(def->hostdevs[i]->info, "hostdev")) < 0)
                continue; /* error just means the alias wasn't "hostdevN", but something else */
            if (thisidx >= idx)
                idx = thisidx + 1;
        }
        /* network interfaces can also have a hostdevN alias */
        for (i = 0; i < def->nnets; i++) {
            int thisidx;

            if ((thisidx = qemuDomainDeviceAliasIndex(&def->nets[i]->info, "hostdev")) < 0)
                continue;
251 252 253 254 255
            if (thisidx >= idx)
                idx = thisidx + 1;
        }
    }

256
    if (virAsprintf(alias, "hostdev%d", idx) < 0)
257 258 259 260 261 262 263 264 265 266 267
        return -1;

    return 0;
}


int
qemuAssignDeviceNetAlias(virDomainDefPtr def,
                         virDomainNetDefPtr net,
                         int idx)
{
268

269 270 271
    if (net->info.alias)
        return 0;

272 273 274 275 276 277 278
    /* <interface type='hostdev'> uses "hostdevN" as the alias
     * We must use "-1" as the index because the caller doesn't know
     * that we're now looking for a unique hostdevN rather than netN
     */
    if (networkGetActualType(net) == VIR_DOMAIN_NET_TYPE_HOSTDEV)
        return qemuAssignDeviceHostdevAlias(def, &net->info.alias, -1);

279 280
    if (idx == -1) {
        size_t i;
281

282 283 284 285
        idx = 0;
        for (i = 0; i < def->nnets; i++) {
            int thisidx;

286 287
            if ((thisidx = qemuDomainDeviceAliasIndex(&def->nets[i]->info, "net")) < 0)
                continue; /* failure could be due to "hostdevN" */
288 289 290 291 292 293 294 295 296 297 298
            if (thisidx >= idx)
                idx = thisidx + 1;
        }
    }

    if (virAsprintf(&net->info.alias, "net%d", idx) < 0)
        return -1;
    return 0;
}


299 300 301 302
static int
qemuAssignDeviceFSAlias(virDomainFSDefPtr fss,
                        int idx)
{
303 304 305
    if (fss->info.alias)
        return 0;

306 307 308 309 310 311 312 313
    return virAsprintf(&fss->info.alias, "fs%d", idx);
}


static int
qemuAssignDeviceSoundAlias(virDomainSoundDefPtr sound,
                           int idx)
{
314 315 316
    if (sound->info.alias)
        return 0;

317 318 319 320 321 322 323 324
    return virAsprintf(&sound->info.alias, "sound%d", idx);
}


static int
qemuAssignDeviceVideoAlias(virDomainVideoDefPtr video,
                           int idx)
{
325 326 327
    if (video->info.alias)
        return 0;

328 329 330 331 332 333 334 335
    return virAsprintf(&video->info.alias, "video%d", idx);
}


static int
qemuAssignDeviceHubAlias(virDomainHubDefPtr hub,
                         int idx)
{
336 337 338
    if (hub->info.alias)
        return 0;

339 340 341 342 343 344 345 346
    return virAsprintf(&hub->info.alias, "hub%d", idx);
}


static int
qemuAssignDeviceSmartcardAlias(virDomainSmartcardDefPtr smartcard,
                               int idx)
{
347 348 349
    if (smartcard->info.alias)
        return 0;

350 351 352 353 354 355 356 357
    return virAsprintf(&smartcard->info.alias, "smartcard%d", idx);
}


static int
qemuAssingDeviceMemballoonAlias(virDomainMemballoonDefPtr memballoon,
                                int idx)
{
358 359 360
    if (memballoon->info.alias)
        return 0;

361 362 363 364 365 366 367 368
    return virAsprintf(&memballoon->info.alias, "balloon%d", idx);
}


static int
qemuAssignDeviceTPMAlias(virDomainTPMDefPtr tpm,
                         int idx)
{
369 370 371
    if (tpm->info.alias)
        return 0;

372 373 374 375
    return virAsprintf(&tpm->info.alias, "tpm%d", idx);
}


376 377 378 379 380
int
qemuAssignDeviceRedirdevAlias(virDomainDefPtr def,
                              virDomainRedirdevDefPtr redirdev,
                              int idx)
{
381 382 383
    if (redirdev->info.alias)
        return 0;

384 385 386 387 388
    if (idx == -1) {
        size_t i;
        idx = 0;
        for (i = 0; i < def->nredirdevs; i++) {
            int thisidx;
389 390
            if ((thisidx = qemuDomainDeviceAliasIndex(&def->redirdevs[i]->info, "redir")) < 0)
                continue;
391 392 393 394 395 396 397 398 399 400 401 402
            if (thisidx >= idx)
                idx = thisidx + 1;
        }
    }

    if (virAsprintf(&redirdev->info.alias, "redir%d", idx) < 0)
        return -1;
    return 0;
}


int
403 404
qemuAssignDeviceRNGAlias(virDomainDefPtr def,
                         virDomainRNGDefPtr rng)
405
{
406 407 408 409
    size_t i;
    int maxidx = 0;
    int idx;

410 411 412
    if (rng->info.alias)
        return 0;

413 414 415 416 417 418
    for (i = 0; i < def->nrngs; i++) {
        if ((idx = qemuDomainDeviceAliasIndex(&def->rngs[i]->info, "rng")) >= maxidx)
            maxidx = idx + 1;
    }

    if (virAsprintf(&rng->info.alias, "rng%d", maxidx) < 0)
419 420 421 422 423 424
        return -1;

    return 0;
}


425 426 427 428 429 430 431 432 433 434 435 436
/**
 * qemuAssignDeviceMemoryAlias:
 * @def: domain definition. Necessary only if @oldAlias is true.
 * @mem: memory device definition
 * @oldAlias: Generate the alias according to the order of the device in @def
 *            rather than according to the slot number for legacy reasons.
 *
 * Generates alias for a memory device according to slot number if @oldAlias is
 * false or according to order in @def->mems otherwise.
 *
 * Returns 0 on success, -1 on error.
 */
437 438
int
qemuAssignDeviceMemoryAlias(virDomainDefPtr def,
439 440
                            virDomainMemoryDefPtr mem,
                            bool oldAlias)
441 442 443 444
{
    size_t i;
    int maxidx = 0;
    int idx;
M
Michal Privoznik 已提交
445 446
    const char *prefix;

447 448 449
    if (mem->info.alias)
        return 0;

M
Michal Privoznik 已提交
450 451 452 453
    if (mem->model == VIR_DOMAIN_MEMORY_MODEL_DIMM)
        prefix = "dimm";
    else
        prefix = "nvdimm";
454

455 456
    if (oldAlias) {
        for (i = 0; i < def->nmems; i++) {
M
Michal Privoznik 已提交
457
            if ((idx = qemuDomainDeviceAliasIndex(&def->mems[i]->info, prefix)) >= maxidx)
458 459 460 461
                maxidx = idx + 1;
        }
    } else {
        maxidx = mem->info.addr.dimm.slot;
462 463
    }

M
Michal Privoznik 已提交
464
    if (virAsprintf(&mem->info.alias, "%s%d", prefix, maxidx) < 0)
465 466 467 468 469 470
        return -1;

    return 0;
}


471 472 473 474 475
int
qemuAssignDeviceShmemAlias(virDomainDefPtr def,
                           virDomainShmemDefPtr shmem,
                           int idx)
{
476 477 478
    if (shmem->info.alias)
        return 0;

479 480 481 482 483 484 485
    if (idx == -1) {
        size_t i;
        idx = 0;
        for (i = 0; i < def->nshmems; i++) {
            int thisidx;

            if ((thisidx = qemuDomainDeviceAliasIndex(&def->shmems[i]->info,
486 487
                                                      "shmem")) < 0)
                continue;
488 489 490 491 492 493 494 495 496 497 498 499

            if (thisidx >= idx)
                idx = thisidx + 1;
        }
    }

    if (virAsprintf(&shmem->info.alias, "shmem%d", idx) < 0)
        return -1;
    return 0;
}


M
Michal Privoznik 已提交
500 501 502 503 504
int
qemuAssignDeviceWatchdogAlias(virDomainWatchdogDefPtr watchdog)
{
    /* Currently, there's just one watchdog per domain */

505 506 507
    if (watchdog->info.alias)
        return 0;

M
Michal Privoznik 已提交
508 509
    if (VIR_STRDUP(watchdog->info.alias, "watchdog0") < 0)
        return -1;
J
Ján Tomko 已提交
510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531

    return 0;
}

int
qemuAssignDeviceInputAlias(virDomainDefPtr def,
                           virDomainInputDefPtr input,
                           int idx)
{
    if (idx == -1) {
        int thisidx;
        size_t i;

        for (i = 0; i < def->ninputs; i++) {
            if ((thisidx = qemuDomainDeviceAliasIndex(&def->inputs[i]->info, "input")) >= idx)
                idx = thisidx + 1;
        }
    }

    if (virAsprintf(&input->info.alias, "input%d", idx) < 0)
        return -1;

M
Michal Privoznik 已提交
532 533 534 535
    return 0;
}


536 537 538 539 540 541 542 543 544 545
int
qemuAssignDeviceAliases(virDomainDefPtr def, virQEMUCapsPtr qemuCaps)
{
    size_t i;

    for (i = 0; i < def->ndisks; i++) {
        if (qemuAssignDeviceDiskAlias(def, def->disks[i], qemuCaps) < 0)
            return -1;
    }
    for (i = 0; i < def->nnets; i++) {
546
        if (qemuAssignDeviceNetAlias(def, def->nets[i], -1) < 0)
547 548 549 550
            return -1;
    }

    for (i = 0; i < def->nfss; i++) {
551
        if (qemuAssignDeviceFSAlias(def->fss[i], i) < 0)
552 553 554
            return -1;
    }
    for (i = 0; i < def->nsounds; i++) {
555
        if (qemuAssignDeviceSoundAlias(def->sounds[i], i) < 0)
556 557 558
            return -1;
    }
    for (i = 0; i < def->nhostdevs; i++) {
559 560 561 562 563
        /* we can't start assigning at 0, since netdevs may have used
         * up some hostdevN entries already. Also if the HostdevDef is
         * linked to a NetDef, they will share an info and the alias
         * will already be set, so don't try to set it again.
         */
564
        if (qemuAssignDeviceHostdevAlias(def, &def->hostdevs[i]->info->alias, -1) < 0)
565 566 567 568 569 570 571
            return -1;
    }
    for (i = 0; i < def->nredirdevs; i++) {
        if (qemuAssignDeviceRedirdevAlias(def, def->redirdevs[i], i) < 0)
            return -1;
    }
    for (i = 0; i < def->nvideos; i++) {
572
        if (qemuAssignDeviceVideoAlias(def->videos[i], i) < 0)
573 574 575 576 577 578 579
            return -1;
    }
    for (i = 0; i < def->ncontrollers; i++) {
        if (qemuAssignDeviceControllerAlias(def, qemuCaps, def->controllers[i]) < 0)
            return -1;
    }
    for (i = 0; i < def->ninputs; i++) {
J
Ján Tomko 已提交
580
        if (qemuAssignDeviceInputAlias(def, def->inputs[i], i) < 0)
581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599
            return -1;
    }
    for (i = 0; i < def->nparallels; i++) {
        if (qemuAssignDeviceChrAlias(def, def->parallels[i], i) < 0)
            return -1;
    }
    for (i = 0; i < def->nserials; i++) {
        if (qemuAssignDeviceChrAlias(def, def->serials[i], i) < 0)
            return -1;
    }
    for (i = 0; i < def->nchannels; i++) {
        if (qemuAssignDeviceChrAlias(def, def->channels[i], i) < 0)
            return -1;
    }
    for (i = 0; i < def->nconsoles; i++) {
        if (qemuAssignDeviceChrAlias(def, def->consoles[i], i) < 0)
            return -1;
    }
    for (i = 0; i < def->nhubs; i++) {
600
        if (qemuAssignDeviceHubAlias(def->hubs[i], i) < 0)
601 602 603
            return -1;
    }
    for (i = 0; i < def->nshmems; i++) {
604
        if (qemuAssignDeviceShmemAlias(def, def->shmems[i], i) < 0)
605 606 607
            return -1;
    }
    for (i = 0; i < def->nsmartcards; i++) {
608
        if (qemuAssignDeviceSmartcardAlias(def->smartcards[i], i) < 0)
609 610 611
            return -1;
    }
    if (def->watchdog) {
M
Michal Privoznik 已提交
612
        if (qemuAssignDeviceWatchdogAlias(def->watchdog) < 0)
613 614 615
            return -1;
    }
    if (def->memballoon) {
616
        if (qemuAssingDeviceMemballoonAlias(def->memballoon, 0) < 0)
617 618 619
            return -1;
    }
    for (i = 0; i < def->nrngs; i++) {
620
        if (qemuAssignDeviceRNGAlias(def, def->rngs[i]) < 0)
621 622 623
            return -1;
    }
    if (def->tpm) {
624
        if (qemuAssignDeviceTPMAlias(def->tpm, 0) < 0)
625 626 627
            return -1;
    }
    for (i = 0; i < def->nmems; i++) {
628
        if (qemuAssignDeviceMemoryAlias(NULL, def->mems[i], false) < 0)
629 630 631 632 633
            return -1;
    }

    return 0;
}
P
Peter Krempa 已提交
634 635


636 637 638 639 640 641 642
/* qemuAliasFromDisk
 * @disk: Pointer to a disk definition
 *
 * Generate and return an alias for the device disk '-drive'
 *
 * Returns NULL with error or a string containing the alias
 */
P
Peter Krempa 已提交
643 644 645 646 647 648
char *
qemuAliasFromDisk(const virDomainDiskDef *disk)
{
    char *ret;

    if (!disk->info.alias) {
649 650
        virReportError(VIR_ERR_INVALID_ARG, "%s",
                       _("disk does not have an alias"));
P
Peter Krempa 已提交
651 652 653
        return NULL;
    }

654 655
    ignore_value(virAsprintf(&ret, "%s%s", QEMU_DRIVE_HOST_PREFIX,
                             disk->info.alias));
P
Peter Krempa 已提交
656 657 658

    return ret;
}
659 660


661 662 663 664 665 666 667 668 669 670 671 672 673 674 675
/* qemuAliasDiskDriveSkipPrefix:
 * @dev_name: Pointer to a const char string
 *
 * If the QEMU_DRIVE_HOST_PREFIX exists in the input string, then
 * increment the pointer and return it
 */
const char *
qemuAliasDiskDriveSkipPrefix(const char *dev_name)
{
    if (STRPREFIX(dev_name, QEMU_DRIVE_HOST_PREFIX))
        dev_name += strlen(QEMU_DRIVE_HOST_PREFIX);
    return dev_name;
}


676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698
/* qemuAliasFromHostdev
 * @hostdev: Pointer to host device
 *
 * Generate and return a string containing a drive alias
 */
char *
qemuAliasFromHostdev(const virDomainHostdevDef *hostdev)
{
    char *ret;

    if (!hostdev->info->alias) {
        virReportError(VIR_ERR_INVALID_ARG, "%s",
                       _("hostdev does not have an alias"));
        return NULL;
    }

    ignore_value(virAsprintf(&ret, "%s-%s",
                 virDomainDeviceAddressTypeToString(hostdev->info->type),
                 hostdev->info->alias));
    return ret;
}


699 700 701 702 703 704 705 706 707 708 709 710 711 712 713
/* qemuDomainGetMasterKeyAlias:
 *
 * Generate and return the masterKey alias
 *
 * Returns NULL or a string containing the master key alias
 */
char *
qemuDomainGetMasterKeyAlias(void)
{
    char *alias;

    ignore_value(VIR_STRDUP(alias, "masterKey0"));

    return alias;
}
714 715 716


/* qemuDomainGetSecretAESAlias:
717 718
 * @srcalias: Source alias used to generate the secret alias
 * @isLuks: True when we are generating a secret for LUKS encrypt/decrypt
719 720 721 722 723 724
 *
 * Generate and return an alias for the encrypted secret
 *
 * Returns NULL or a string containing the alias
 */
char *
725 726
qemuDomainGetSecretAESAlias(const char *srcalias,
                            bool isLuks)
727 728 729 730 731 732 733 734 735
{
    char *alias;

    if (!srcalias) {
        virReportError(VIR_ERR_INVALID_ARG, "%s",
                       _("encrypted secret alias requires valid source alias"));
        return NULL;
    }

736 737 738 739
    if (isLuks)
        ignore_value(virAsprintf(&alias, "%s-luks-secret0", srcalias));
    else
        ignore_value(virAsprintf(&alias, "%s-secret0", srcalias));
740 741 742

    return alias;
}
743 744


745 746
/* qemuAliasTLSObjFromSrcAlias
 * @srcAlias: Pointer to a source alias string
747 748 749 750
 *
 * Generate and return a string to be used as the TLS object alias
 */
char *
751
qemuAliasTLSObjFromSrcAlias(const char *srcAlias)
752 753 754
{
    char *ret;

755
    ignore_value(virAsprintf(&ret, "obj%s_tls0", srcAlias));
756 757 758

    return ret;
}
759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774


/* qemuAliasChardevFromDevAlias:
 * @devAlias: pointer do device alias
 *
 * Generate and return a string to be used as chardev alias.
 */
char *
qemuAliasChardevFromDevAlias(const char *devAlias)
{
    char *ret;

    ignore_value(virAsprintf(&ret, "char%s", devAlias));

    return ret;
}