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

#include <config.h>

#include "qemu_domain.h"
J
John Ferlan 已提交
27
#include "qemu_alias.h"
28
#include "qemu_cgroup.h"
29
#include "qemu_command.h"
30
#include "qemu_process.h"
31
#include "qemu_parse_command.h"
32
#include "qemu_capabilities.h"
33
#include "qemu_migration.h"
34
#include "qemu_security.h"
35
#include "viralloc.h"
36
#include "virlog.h"
37
#include "virerror.h"
38
#include "c-ctype.h"
39
#include "cpu/cpu.h"
40
#include "viruuid.h"
E
Eric Blake 已提交
41
#include "virfile.h"
42
#include "domain_addr.h"
43
#include "domain_event.h"
44
#include "virtime.h"
45
#include "virnetdevopenvswitch.h"
46
#include "virstoragefile.h"
47
#include "virstring.h"
48
#include "virthreadjob.h"
49
#include "viratomic.h"
50
#include "virprocess.h"
51
#include "vircrypto.h"
52
#include "secret_util.h"
53
#include "logging/log_manager.h"
54
#include "locking/domain_lock.h"
55

56 57
#include "storage/storage_driver.h"

58 59 60 61 62
#ifdef MAJOR_IN_MKDEV
# include <sys/mkdev.h>
#elif MAJOR_IN_SYSMACROS
# include <sys/sysmacros.h>
#endif
63
#include <sys/time.h>
64
#include <fcntl.h>
65 66 67
#if defined(HAVE_SYS_MOUNT_H)
# include <sys/mount.h>
#endif
68 69 70
#ifdef WITH_SELINUX
# include <selinux/selinux.h>
#endif
71

72
#include <libxml/xpathInternals.h>
73
#include "dosname.h"
74 75 76

#define VIR_FROM_THIS VIR_FROM_QEMU

77 78
VIR_LOG_INIT("qemu.qemu_domain");

79 80
#define QEMU_NAMESPACE_HREF "http://libvirt.org/schemas/domain/qemu/1.0"

81 82 83 84 85 86
VIR_ENUM_IMPL(qemuDomainJob, QEMU_JOB_LAST,
              "none",
              "query",
              "destroy",
              "suspend",
              "modify",
87
              "abort",
88
              "migration operation",
89 90 91 92 93 94 95 96 97 98
              "none",   /* async job is never stored in job.active */
              "async nested",
);

VIR_ENUM_IMPL(qemuDomainAsyncJob, QEMU_ASYNC_JOB_LAST,
              "none",
              "migration out",
              "migration in",
              "save",
              "dump",
99
              "snapshot",
100
              "start",
101 102
);

103 104 105 106 107
VIR_ENUM_IMPL(qemuDomainNamespace, QEMU_DOMAIN_NS_LAST,
              "mount",
);


108 109
#define PROC_MOUNTS "/proc/mounts"
#define DEVPREFIX "/dev/"
110
#define DEV_VFIO "/dev/vfio/vfio"
111

112

113
struct _qemuDomainLogContext {
114 115
    virObject parent;

116
    int writefd;
117
    int readfd; /* Only used if manager == NULL */
118
    off_t pos;
119
    ino_t inode; /* Only used if manager != NULL */
120
    char *path;
121
    virLogManagerPtr manager;
122 123
};

124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
static virClassPtr qemuDomainLogContextClass;

static void qemuDomainLogContextDispose(void *obj);

static int
qemuDomainLogContextOnceInit(void)
{
    if (!(qemuDomainLogContextClass = virClassNew(virClassForObject(),
                                                 "qemuDomainLogContext",
                                                 sizeof(qemuDomainLogContext),
                                                 qemuDomainLogContextDispose)))
        return -1;

    return 0;
}

VIR_ONCE_GLOBAL_INIT(qemuDomainLogContext)

static void
qemuDomainLogContextDispose(void *obj)
{
    qemuDomainLogContextPtr ctxt = obj;
    VIR_DEBUG("ctxt=%p", ctxt);

    virLogManagerFree(ctxt->manager);
    VIR_FREE(ctxt->path);
    VIR_FORCE_CLOSE(ctxt->writefd);
    VIR_FORCE_CLOSE(ctxt->readfd);
}

J
Jiri Denemark 已提交
154
const char *
155
qemuDomainAsyncJobPhaseToString(qemuDomainAsyncJob job,
J
Jiri Denemark 已提交
156 157 158 159 160
                                int phase ATTRIBUTE_UNUSED)
{
    switch (job) {
    case QEMU_ASYNC_JOB_MIGRATION_OUT:
    case QEMU_ASYNC_JOB_MIGRATION_IN:
161 162
        return qemuMigrationJobPhaseTypeToString(phase);

J
Jiri Denemark 已提交
163 164
    case QEMU_ASYNC_JOB_SAVE:
    case QEMU_ASYNC_JOB_DUMP:
165
    case QEMU_ASYNC_JOB_SNAPSHOT:
166
    case QEMU_ASYNC_JOB_START:
J
Jiri Denemark 已提交
167 168 169 170 171 172 173 174 175
    case QEMU_ASYNC_JOB_NONE:
    case QEMU_ASYNC_JOB_LAST:
        ; /* fall through */
    }

    return "none";
}

int
176
qemuDomainAsyncJobPhaseFromString(qemuDomainAsyncJob job,
J
Jiri Denemark 已提交
177 178 179 180 181 182 183 184
                                  const char *phase)
{
    if (!phase)
        return 0;

    switch (job) {
    case QEMU_ASYNC_JOB_MIGRATION_OUT:
    case QEMU_ASYNC_JOB_MIGRATION_IN:
185 186
        return qemuMigrationJobPhaseTypeFromString(phase);

J
Jiri Denemark 已提交
187 188
    case QEMU_ASYNC_JOB_SAVE:
    case QEMU_ASYNC_JOB_DUMP:
189
    case QEMU_ASYNC_JOB_SNAPSHOT:
190
    case QEMU_ASYNC_JOB_START:
J
Jiri Denemark 已提交
191 192 193 194 195 196 197 198 199 200 201
    case QEMU_ASYNC_JOB_NONE:
    case QEMU_ASYNC_JOB_LAST:
        ; /* fall through */
    }

    if (STREQ(phase, "none"))
        return 0;
    else
        return -1;
}

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 227 228 229 230 231 232 233 234
bool
qemuDomainNamespaceEnabled(virDomainObjPtr vm,
                           qemuDomainNamespace ns)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;

    return priv->namespaces &&
        virBitmapIsBitSet(priv->namespaces, ns);
}


static int
qemuDomainEnableNamespace(virDomainObjPtr vm,
                          qemuDomainNamespace ns)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;

    if (!priv->namespaces &&
        !(priv->namespaces = virBitmapNew(QEMU_DOMAIN_NS_LAST)))
        return -1;

    if (virBitmapSetBit(priv->namespaces, ns) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Unable to enable namespace: %s"),
                       qemuDomainNamespaceTypeToString(ns));
        return -1;
    }

    return 0;
}


235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
static void
qemuDomainDisableNamespace(virDomainObjPtr vm,
                           qemuDomainNamespace ns)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;

    if (priv->namespaces) {
        ignore_value(virBitmapClearBit(priv->namespaces, ns));
        if (virBitmapIsAllClear(priv->namespaces)) {
            virBitmapFree(priv->namespaces);
            priv->namespaces = NULL;
        }
    }
}


251
void qemuDomainEventQueue(virQEMUDriverPtr driver,
252
                          virObjectEventPtr event)
253
{
254 255
    if (event)
        virObjectEventStateQueue(driver->domainEventState, event);
256 257 258
}


259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
void
qemuDomainEventEmitJobCompleted(virQEMUDriverPtr driver,
                                virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    virObjectEventPtr event;
    virTypedParameterPtr params = NULL;
    int nparams = 0;
    int type;

    if (!priv->job.completed)
        return;

    if (qemuDomainJobInfoToParams(priv->job.completed, &type,
                                  &params, &nparams) < 0) {
        VIR_WARN("Could not get stats for completed job; domain %s",
                 vm->def->name);
    }

    event = virDomainEventJobCompletedNewFromObj(vm, params, nparams);
    qemuDomainEventQueue(driver, event);
}


283 284 285 286 287 288 289 290
static int
qemuDomainObjInitJob(qemuDomainObjPrivatePtr priv)
{
    memset(&priv->job, 0, sizeof(priv->job));

    if (virCondInit(&priv->job.cond) < 0)
        return -1;

291
    if (virCondInit(&priv->job.asyncCond) < 0) {
292
        virCondDestroy(&priv->job.cond);
293 294 295
        return -1;
    }

296 297 298 299 300 301 302 303 304
    return 0;
}

static void
qemuDomainObjResetJob(qemuDomainObjPrivatePtr priv)
{
    struct qemuDomainJobObj *job = &priv->job;

    job->active = QEMU_JOB_NONE;
305
    job->owner = 0;
306
    job->ownerAPI = NULL;
J
Jiri Denemark 已提交
307
    job->started = 0;
308 309 310 311 312 313 314 315
}

static void
qemuDomainObjResetAsyncJob(qemuDomainObjPrivatePtr priv)
{
    struct qemuDomainJobObj *job = &priv->job;

    job->asyncJob = QEMU_ASYNC_JOB_NONE;
316
    job->asyncOwner = 0;
317
    job->asyncOwnerAPI = NULL;
J
Jiri Denemark 已提交
318
    job->asyncStarted = 0;
J
Jiri Denemark 已提交
319
    job->phase = 0;
320
    job->mask = QEMU_JOB_DEFAULT_MASK;
321
    job->dump_memory_only = false;
322
    job->abortJob = false;
323
    job->spiceMigration = false;
324
    job->spiceMigrated = false;
325
    job->postcopyEnabled = false;
J
Jiri Denemark 已提交
326
    VIR_FREE(job->current);
327 328
}

329 330 331 332 333 334 335 336
void
qemuDomainObjRestoreJob(virDomainObjPtr obj,
                        struct qemuDomainJobObj *job)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

    memset(job, 0, sizeof(*job));
    job->active = priv->job.active;
337
    job->owner = priv->job.owner;
338
    job->asyncJob = priv->job.asyncJob;
339
    job->asyncOwner = priv->job.asyncOwner;
J
Jiri Denemark 已提交
340
    job->phase = priv->job.phase;
341 342 343 344 345

    qemuDomainObjResetJob(priv);
    qemuDomainObjResetAsyncJob(priv);
}

346 347 348
static void
qemuDomainObjFreeJob(qemuDomainObjPrivatePtr priv)
{
J
Jiri Denemark 已提交
349
    VIR_FREE(priv->job.current);
350
    VIR_FREE(priv->job.completed);
351 352
    virCondDestroy(&priv->job.cond);
    virCondDestroy(&priv->job.asyncCond);
353 354
}

355
static bool
356
qemuDomainTrackJob(qemuDomainJob job)
357 358 359 360
{
    return (QEMU_DOMAIN_TRACK_JOBS & JOB_MASK(job)) != 0;
}

361

J
Jiri Denemark 已提交
362 363 364 365 366 367 368 369 370 371 372
int
qemuDomainJobInfoUpdateTime(qemuDomainJobInfoPtr jobInfo)
{
    unsigned long long now;

    if (!jobInfo->started)
        return 0;

    if (virTimeMillisNow(&now) < 0)
        return -1;

373 374 375 376 377 378
    if (now < jobInfo->started) {
        VIR_WARN("Async job starts in the future");
        jobInfo->started = 0;
        return 0;
    }

J
Jiri Denemark 已提交
379 380 381 382
    jobInfo->timeElapsed = now - jobInfo->started;
    return 0;
}

383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399
int
qemuDomainJobInfoUpdateDowntime(qemuDomainJobInfoPtr jobInfo)
{
    unsigned long long now;

    if (!jobInfo->stopped)
        return 0;

    if (virTimeMillisNow(&now) < 0)
        return -1;

    if (now < jobInfo->stopped) {
        VIR_WARN("Guest's CPUs stopped in the future");
        jobInfo->stopped = 0;
        return 0;
    }

400 401
    jobInfo->stats.downtime = now - jobInfo->stopped;
    jobInfo->stats.downtime_set = true;
402 403 404
    return 0;
}

J
Jiri Denemark 已提交
405 406 407 408
int
qemuDomainJobInfoToInfo(qemuDomainJobInfoPtr jobInfo,
                        virDomainJobInfoPtr info)
{
409
    info->type = jobInfo->type;
J
Jiri Denemark 已提交
410 411 412
    info->timeElapsed = jobInfo->timeElapsed;
    info->timeRemaining = jobInfo->timeRemaining;

413 414 415
    info->memTotal = jobInfo->stats.ram_total;
    info->memRemaining = jobInfo->stats.ram_remaining;
    info->memProcessed = jobInfo->stats.ram_transferred;
J
Jiri Denemark 已提交
416

417 418 419
    info->fileTotal = jobInfo->stats.disk_total;
    info->fileRemaining = jobInfo->stats.disk_remaining;
    info->fileProcessed = jobInfo->stats.disk_transferred;
J
Jiri Denemark 已提交
420 421 422 423 424 425 426 427 428 429 430 431 432 433

    info->dataTotal = info->memTotal + info->fileTotal;
    info->dataRemaining = info->memRemaining + info->fileRemaining;
    info->dataProcessed = info->memProcessed + info->fileProcessed;

    return 0;
}

int
qemuDomainJobInfoToParams(qemuDomainJobInfoPtr jobInfo,
                          int *type,
                          virTypedParameterPtr *params,
                          int *nparams)
{
434
    qemuMonitorMigrationStats *stats = &jobInfo->stats;
J
Jiri Denemark 已提交
435 436 437 438
    virTypedParameterPtr par = NULL;
    int maxpar = 0;
    int npar = 0;

439 440 441 442 443
    if (virTypedParamsAddInt(&par, &npar, &maxpar,
                             VIR_DOMAIN_JOB_OPERATION,
                             jobInfo->operation) < 0)
        goto error;

J
Jiri Denemark 已提交
444 445 446 447 448
    if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_TIME_ELAPSED,
                                jobInfo->timeElapsed) < 0)
        goto error;

449 450 451 452 453 454 455
    if (jobInfo->timeDeltaSet &&
        jobInfo->timeElapsed > jobInfo->timeDelta &&
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_TIME_ELAPSED_NET,
                                jobInfo->timeElapsed - jobInfo->timeDelta) < 0)
        goto error;

J
Jiri Denemark 已提交
456 457 458 459 460 461
    if (jobInfo->type == VIR_DOMAIN_JOB_BOUNDED &&
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_TIME_REMAINING,
                                jobInfo->timeRemaining) < 0)
        goto error;

462
    if (stats->downtime_set &&
J
Jiri Denemark 已提交
463 464
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DOWNTIME,
465
                                stats->downtime) < 0)
J
Jiri Denemark 已提交
466 467
        goto error;

468
    if (stats->downtime_set &&
469
        jobInfo->timeDeltaSet &&
470
        stats->downtime > jobInfo->timeDelta &&
471 472
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DOWNTIME_NET,
473
                                stats->downtime - jobInfo->timeDelta) < 0)
474 475
        goto error;

476
    if (stats->setup_time_set &&
477 478
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_SETUP_TIME,
479
                                stats->setup_time) < 0)
480 481
        goto error;

J
Jiri Denemark 已提交
482 483
    if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DATA_TOTAL,
484 485
                                stats->ram_total +
                                stats->disk_total) < 0 ||
J
Jiri Denemark 已提交
486 487
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DATA_PROCESSED,
488 489
                                stats->ram_transferred +
                                stats->disk_transferred) < 0 ||
J
Jiri Denemark 已提交
490 491
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DATA_REMAINING,
492 493
                                stats->ram_remaining +
                                stats->disk_remaining) < 0)
J
Jiri Denemark 已提交
494 495 496 497
        goto error;

    if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_MEMORY_TOTAL,
498
                                stats->ram_total) < 0 ||
J
Jiri Denemark 已提交
499 500
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_MEMORY_PROCESSED,
501
                                stats->ram_transferred) < 0 ||
J
Jiri Denemark 已提交
502 503
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_MEMORY_REMAINING,
504
                                stats->ram_remaining) < 0)
J
Jiri Denemark 已提交
505 506
        goto error;

507
    if (stats->ram_bps &&
508 509
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_MEMORY_BPS,
510
                                stats->ram_bps) < 0)
511 512
        goto error;

513
    if (stats->ram_duplicate_set) {
J
Jiri Denemark 已提交
514 515
        if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_MEMORY_CONSTANT,
516
                                    stats->ram_duplicate) < 0 ||
J
Jiri Denemark 已提交
517 518
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_MEMORY_NORMAL,
519
                                    stats->ram_normal) < 0 ||
J
Jiri Denemark 已提交
520 521
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES,
522
                                    stats->ram_normal_bytes) < 0)
J
Jiri Denemark 已提交
523 524 525
            goto error;
    }

526 527 528 529 530 531 532 533
    if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_MEMORY_DIRTY_RATE,
                                stats->ram_dirty_rate) < 0 ||
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_MEMORY_ITERATION,
                                stats->ram_iteration) < 0)
        goto error;

J
Jiri Denemark 已提交
534 535
    if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DISK_TOTAL,
536
                                stats->disk_total) < 0 ||
J
Jiri Denemark 已提交
537 538
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DISK_PROCESSED,
539
                                stats->disk_transferred) < 0 ||
J
Jiri Denemark 已提交
540 541
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DISK_REMAINING,
542
                                stats->disk_remaining) < 0)
J
Jiri Denemark 已提交
543 544
        goto error;

545
    if (stats->disk_bps &&
546 547
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DISK_BPS,
548
                                stats->disk_bps) < 0)
549 550
        goto error;

551
    if (stats->xbzrle_set) {
J
Jiri Denemark 已提交
552 553
        if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_COMPRESSION_CACHE,
554
                                    stats->xbzrle_cache_size) < 0 ||
J
Jiri Denemark 已提交
555 556
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_COMPRESSION_BYTES,
557
                                    stats->xbzrle_bytes) < 0 ||
J
Jiri Denemark 已提交
558 559
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_COMPRESSION_PAGES,
560
                                    stats->xbzrle_pages) < 0 ||
J
Jiri Denemark 已提交
561 562
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES,
563
                                    stats->xbzrle_cache_miss) < 0 ||
J
Jiri Denemark 已提交
564 565
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW,
566
                                    stats->xbzrle_overflow) < 0)
J
Jiri Denemark 已提交
567 568 569
            goto error;
    }

570 571 572 573 574 575
    if (stats->cpu_throttle_percentage &&
        virTypedParamsAddInt(&par, &npar, &maxpar,
                             VIR_DOMAIN_JOB_AUTO_CONVERGE_THROTTLE,
                             stats->cpu_throttle_percentage) < 0)
        goto error;

J
Jiri Denemark 已提交
576 577 578 579 580 581 582 583 584 585 586
    *type = jobInfo->type;
    *params = par;
    *nparams = npar;
    return 0;

 error:
    virTypedParamsFree(par, npar);
    return -1;
}


J
John Ferlan 已提交
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
/* qemuDomainGetMasterKeyFilePath:
 * @libDir: Directory path to domain lib files
 *
 * Generate a path to the domain master key file for libDir.
 * It's up to the caller to handle checking if path exists.
 *
 * Returns path to memory containing the name of the file. It is up to the
 * caller to free; otherwise, NULL on failure.
 */
char *
qemuDomainGetMasterKeyFilePath(const char *libDir)
{
    if (!libDir) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("invalid path for master key file"));
        return NULL;
    }
    return virFileBuildPath(libDir, "master-key.aes", NULL);
}


/* qemuDomainWriteMasterKeyFile:
609 610
 * @driver: qemu driver data
 * @vm: Pointer to the vm object
J
John Ferlan 已提交
611 612 613 614 615
 *
 * Get the desired path to the masterKey file and store it in the path.
 *
 * Returns 0 on success, -1 on failure with error message indicating failure
 */
616
int
M
Martin Kletzander 已提交
617 618
qemuDomainWriteMasterKeyFile(virQEMUDriverPtr driver,
                             virDomainObjPtr vm)
J
John Ferlan 已提交
619 620 621 622
{
    char *path;
    int fd = -1;
    int ret = -1;
M
Martin Kletzander 已提交
623
    qemuDomainObjPrivatePtr priv = vm->privateData;
J
John Ferlan 已提交
624

625 626 627 628
    /* Only gets filled in if we have the capability */
    if (!priv->masterKey)
        return 0;

J
John Ferlan 已提交
629 630 631 632 633 634 635 636 637 638 639 640 641 642 643
    if (!(path = qemuDomainGetMasterKeyFilePath(priv->libDir)))
        return -1;

    if ((fd = open(path, O_WRONLY|O_TRUNC|O_CREAT, 0600)) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("failed to open domain master key file for write"));
        goto cleanup;
    }

    if (safewrite(fd, priv->masterKey, priv->masterKeyLen) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("failed to write master key file for domain"));
        goto cleanup;
    }

644 645
    if (qemuSecurityDomainSetPathLabel(driver->securityManager,
                                       vm->def, path) < 0)
M
Martin Kletzander 已提交
646 647
        goto cleanup;

J
John Ferlan 已提交
648 649 650 651 652 653 654 655 656 657
    ret = 0;

 cleanup:
    VIR_FORCE_CLOSE(fd);
    VIR_FREE(path);

    return ret;
}


658 659 660 661 662 663 664 665 666
static void
qemuDomainMasterKeyFree(qemuDomainObjPrivatePtr priv)
{
    if (!priv->masterKey)
        return;

    VIR_DISPOSE_N(priv->masterKey, priv->masterKeyLen);
}

J
John Ferlan 已提交
667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764
/* qemuDomainMasterKeyReadFile:
 * @priv: pointer to domain private object
 *
 * Expected to be called during qemuProcessReconnect once the domain
 * libDir has been generated through qemuStateInitialize calling
 * virDomainObjListLoadAllConfigs which will restore the libDir path
 * to the domain private object.
 *
 * This function will get the path to the master key file and if it
 * exists, it will read the contents of the file saving it in priv->masterKey.
 *
 * Once the file exists, the validity checks may cause failures; however,
 * if the file doesn't exist or the capability doesn't exist, we just
 * return (mostly) quietly.
 *
 * Returns 0 on success or lack of capability
 *        -1 on failure with error message indicating failure
 */
int
qemuDomainMasterKeyReadFile(qemuDomainObjPrivatePtr priv)
{
    char *path;
    int fd = -1;
    uint8_t *masterKey = NULL;
    ssize_t masterKeyLen = 0;

    /* If we don't have the capability, then do nothing. */
    if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_OBJECT_SECRET))
        return 0;

    if (!(path = qemuDomainGetMasterKeyFilePath(priv->libDir)))
        return -1;

    if (!virFileExists(path)) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("domain master key file doesn't exist in %s"),
                       priv->libDir);
        goto error;
    }

    if ((fd = open(path, O_RDONLY)) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("failed to open domain master key file for read"));
        goto error;
    }

    if (VIR_ALLOC_N(masterKey, 1024) < 0)
        goto error;

    if ((masterKeyLen = saferead(fd, masterKey, 1024)) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("unable to read domain master key file"));
        goto error;
    }

    if (masterKeyLen != QEMU_DOMAIN_MASTER_KEY_LEN) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("invalid master key read, size=%zd"), masterKeyLen);
        goto error;
    }

    ignore_value(VIR_REALLOC_N_QUIET(masterKey, masterKeyLen));

    priv->masterKey = masterKey;
    priv->masterKeyLen = masterKeyLen;

    VIR_FORCE_CLOSE(fd);
    VIR_FREE(path);

    return 0;

 error:
    if (masterKeyLen > 0)
        memset(masterKey, 0, masterKeyLen);
    VIR_FREE(masterKey);

    VIR_FORCE_CLOSE(fd);
    VIR_FREE(path);

    return -1;
}


/* qemuDomainMasterKeyRemove:
 * @priv: Pointer to the domain private object
 *
 * Remove the traces of the master key, clear the heap, clear the file,
 * delete the file.
 */
void
qemuDomainMasterKeyRemove(qemuDomainObjPrivatePtr priv)
{
    char *path = NULL;

    if (!priv->masterKey)
        return;

    /* Clear the contents */
765
    qemuDomainMasterKeyFree(priv);
J
John Ferlan 已提交
766 767 768 769 770 771 772 773 774 775

    /* Delete the master key file */
    path = qemuDomainGetMasterKeyFilePath(priv->libDir);
    unlink(path);

    VIR_FREE(path);
}


/* qemuDomainMasterKeyCreate:
776
 * @vm: Pointer to the domain object
J
John Ferlan 已提交
777 778 779 780 781 782 783 784
 *
 * As long as the underlying qemu has the secret capability,
 * generate and store 'raw' in a file a random 32-byte key to
 * be used as a secret shared with qemu to share sensitive data.
 *
 * Returns: 0 on success, -1 w/ error message on failure
 */
int
785
qemuDomainMasterKeyCreate(virDomainObjPtr vm)
J
John Ferlan 已提交
786
{
M
Martin Kletzander 已提交
787 788
    qemuDomainObjPrivatePtr priv = vm->privateData;

J
John Ferlan 已提交
789 790 791 792 793
    /* If we don't have the capability, then do nothing. */
    if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_OBJECT_SECRET))
        return 0;

    if (!(priv->masterKey =
794
          virCryptoGenerateRandom(QEMU_DOMAIN_MASTER_KEY_LEN)))
795
        return -1;
J
John Ferlan 已提交
796 797 798 799 800 801 802

    priv->masterKeyLen = QEMU_DOMAIN_MASTER_KEY_LEN;

    return 0;
}


803
static void
804
qemuDomainSecretPlainClear(qemuDomainSecretPlain secret)
805 806
{
    VIR_FREE(secret.username);
807
    VIR_DISPOSE_N(secret.secret, secret.secretlen);
808 809 810
}


J
John Ferlan 已提交
811
static void
812
qemuDomainSecretAESClear(qemuDomainSecretAES secret)
J
John Ferlan 已提交
813 814 815 816 817 818 819 820
{
    VIR_FREE(secret.username);
    VIR_FREE(secret.alias);
    VIR_FREE(secret.iv);
    VIR_FREE(secret.ciphertext);
}


821
void
822 823 824 825 826
qemuDomainSecretInfoFree(qemuDomainSecretInfoPtr *secinfo)
{
    if (!*secinfo)
        return;

J
John Ferlan 已提交
827 828
    switch ((qemuDomainSecretInfoType) (*secinfo)->type) {
    case VIR_DOMAIN_SECRET_INFO_TYPE_PLAIN:
829
        qemuDomainSecretPlainClear((*secinfo)->s.plain);
J
John Ferlan 已提交
830 831
        break;

832
    case VIR_DOMAIN_SECRET_INFO_TYPE_AES:
833
        qemuDomainSecretAESClear((*secinfo)->s.aes);
J
John Ferlan 已提交
834 835 836 837 838 839
        break;

    case VIR_DOMAIN_SECRET_INFO_TYPE_LAST:
        break;
    }

840 841 842 843
    VIR_FREE(*secinfo);
}


844
static virClassPtr qemuDomainDiskPrivateClass;
845
static void qemuDomainDiskPrivateDispose(void *obj);
846 847 848 849 850 851 852

static int
qemuDomainDiskPrivateOnceInit(void)
{
    qemuDomainDiskPrivateClass = virClassNew(virClassForObject(),
                                             "qemuDomainDiskPrivate",
                                             sizeof(qemuDomainDiskPrivate),
853
                                             qemuDomainDiskPrivateDispose);
854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876
    if (!qemuDomainDiskPrivateClass)
        return -1;
    else
        return 0;
}

VIR_ONCE_GLOBAL_INIT(qemuDomainDiskPrivate)

static virObjectPtr
qemuDomainDiskPrivateNew(void)
{
    qemuDomainDiskPrivatePtr priv;

    if (qemuDomainDiskPrivateInitialize() < 0)
        return NULL;

    if (!(priv = virObjectNew(qemuDomainDiskPrivateClass)))
        return NULL;

    return (virObjectPtr) priv;
}


877 878 879 880 881 882
static void
qemuDomainDiskPrivateDispose(void *obj)
{
    qemuDomainDiskPrivatePtr priv = obj;

    qemuDomainSecretInfoFree(&priv->secinfo);
J
John Ferlan 已提交
883
    qemuDomainSecretInfoFree(&priv->encinfo);
884 885 886
}


887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929
static virClassPtr qemuDomainHostdevPrivateClass;
static void qemuDomainHostdevPrivateDispose(void *obj);

static int
qemuDomainHostdevPrivateOnceInit(void)
{
    qemuDomainHostdevPrivateClass =
        virClassNew(virClassForObject(),
                    "qemuDomainHostdevPrivate",
                    sizeof(qemuDomainHostdevPrivate),
                    qemuDomainHostdevPrivateDispose);
    if (!qemuDomainHostdevPrivateClass)
        return -1;
    else
        return 0;
}

VIR_ONCE_GLOBAL_INIT(qemuDomainHostdevPrivate)

static virObjectPtr
qemuDomainHostdevPrivateNew(void)
{
    qemuDomainHostdevPrivatePtr priv;

    if (qemuDomainHostdevPrivateInitialize() < 0)
        return NULL;

    if (!(priv = virObjectNew(qemuDomainHostdevPrivateClass)))
        return NULL;

    return (virObjectPtr) priv;
}


static void
qemuDomainHostdevPrivateDispose(void *obj)
{
    qemuDomainHostdevPrivatePtr priv = obj;

    qemuDomainSecretInfoFree(&priv->secinfo);
}


930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963
static virClassPtr qemuDomainVcpuPrivateClass;
static void qemuDomainVcpuPrivateDispose(void *obj);

static int
qemuDomainVcpuPrivateOnceInit(void)
{
    qemuDomainVcpuPrivateClass = virClassNew(virClassForObject(),
                                             "qemuDomainVcpuPrivate",
                                             sizeof(qemuDomainVcpuPrivate),
                                             qemuDomainVcpuPrivateDispose);
    if (!qemuDomainVcpuPrivateClass)
        return -1;
    else
        return 0;
}

VIR_ONCE_GLOBAL_INIT(qemuDomainVcpuPrivate)

static virObjectPtr
qemuDomainVcpuPrivateNew(void)
{
    qemuDomainVcpuPrivatePtr priv;

    if (qemuDomainVcpuPrivateInitialize() < 0)
        return NULL;

    if (!(priv = virObjectNew(qemuDomainVcpuPrivateClass)))
        return NULL;

    return (virObjectPtr) priv;
}


static void
964
qemuDomainVcpuPrivateDispose(void *obj)
965
{
966 967 968 969
    qemuDomainVcpuPrivatePtr priv = obj;

    VIR_FREE(priv->type);
    VIR_FREE(priv->alias);
970 971 972 973
    return;
}


974 975
static virClassPtr qemuDomainChrSourcePrivateClass;
static void qemuDomainChrSourcePrivateDispose(void *obj);
976 977

static int
978
qemuDomainChrSourcePrivateOnceInit(void)
979
{
980
    qemuDomainChrSourcePrivateClass =
981
        virClassNew(virClassForObject(),
982 983 984 985
                    "qemuDomainChrSourcePrivate",
                    sizeof(qemuDomainChrSourcePrivate),
                    qemuDomainChrSourcePrivateDispose);
    if (!qemuDomainChrSourcePrivateClass)
986 987 988 989 990
        return -1;
    else
        return 0;
}

991
VIR_ONCE_GLOBAL_INIT(qemuDomainChrSourcePrivate)
992 993

static virObjectPtr
994
qemuDomainChrSourcePrivateNew(void)
995
{
996
    qemuDomainChrSourcePrivatePtr priv;
997

998
    if (qemuDomainChrSourcePrivateInitialize() < 0)
999 1000
        return NULL;

1001
    if (!(priv = virObjectNew(qemuDomainChrSourcePrivateClass)))
1002 1003 1004 1005 1006 1007 1008
        return NULL;

    return (virObjectPtr) priv;
}


static void
1009
qemuDomainChrSourcePrivateDispose(void *obj)
1010
{
1011
    qemuDomainChrSourcePrivatePtr priv = obj;
1012 1013 1014 1015 1016

    qemuDomainSecretInfoFree(&priv->secinfo);
}


1017 1018 1019
/* qemuDomainSecretPlainSetup:
 * @conn: Pointer to connection
 * @secinfo: Pointer to secret info
J
John Ferlan 已提交
1020
 * @usageType: The virSecretUsageType
1021 1022
 * @username: username to use for authentication (may be NULL)
 * @seclookupdef: Pointer to seclookupdef data
1023 1024 1025 1026 1027 1028 1029 1030
 *
 * Taking a secinfo, fill in the plaintext information
 *
 * Returns 0 on success, -1 on failure with error message
 */
static int
qemuDomainSecretPlainSetup(virConnectPtr conn,
                           qemuDomainSecretInfoPtr secinfo,
J
John Ferlan 已提交
1031
                           virSecretUsageType usageType,
1032 1033
                           const char *username,
                           virSecretLookupTypeDefPtr seclookupdef)
1034
{
1035
    secinfo->type = VIR_DOMAIN_SECRET_INFO_TYPE_PLAIN;
1036
    if (VIR_STRDUP(secinfo->s.plain.username, username) < 0)
1037 1038
        return -1;

J
John Ferlan 已提交
1039
    return virSecretGetSecretString(conn, seclookupdef, usageType,
1040 1041
                                    &secinfo->s.plain.secret,
                                    &secinfo->s.plain.secretlen);
1042 1043 1044
}


1045 1046 1047 1048 1049
/* qemuDomainSecretAESSetup:
 * @conn: Pointer to connection
 * @priv: pointer to domain private object
 * @secinfo: Pointer to secret info
 * @srcalias: Alias of the disk/hostdev used to generate the secret alias
J
John Ferlan 已提交
1050
 * @usageType: The virSecretUsageType
1051 1052
 * @username: username to use for authentication (may be NULL)
 * @seclookupdef: Pointer to seclookupdef data
1053
 * @isLuks: True/False for is for luks (alias generation)
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063
 *
 * Taking a secinfo, fill in the AES specific information using the
 *
 * Returns 0 on success, -1 on failure with error message
 */
static int
qemuDomainSecretAESSetup(virConnectPtr conn,
                         qemuDomainObjPrivatePtr priv,
                         qemuDomainSecretInfoPtr secinfo,
                         const char *srcalias,
J
John Ferlan 已提交
1064
                         virSecretUsageType usageType,
1065
                         const char *username,
1066 1067
                         virSecretLookupTypeDefPtr seclookupdef,
                         bool isLuks)
1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
{
    int ret = -1;
    uint8_t *raw_iv = NULL;
    size_t ivlen = QEMU_DOMAIN_AES_IV_LEN;
    uint8_t *secret = NULL;
    size_t secretlen = 0;
    uint8_t *ciphertext = NULL;
    size_t ciphertextlen = 0;

    secinfo->type = VIR_DOMAIN_SECRET_INFO_TYPE_AES;
1078
    if (VIR_STRDUP(secinfo->s.aes.username, username) < 0)
1079 1080
        return -1;

1081
    if (!(secinfo->s.aes.alias = qemuDomainGetSecretAESAlias(srcalias, isLuks)))
1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
        return -1;

    /* Create a random initialization vector */
    if (!(raw_iv = virCryptoGenerateRandom(ivlen)))
        return -1;

    /* Encode the IV and save that since qemu will need it */
    if (!(secinfo->s.aes.iv = virStringEncodeBase64(raw_iv, ivlen)))
        goto cleanup;

    /* Grab the unencoded secret */
J
John Ferlan 已提交
1093
    if (virSecretGetSecretString(conn, seclookupdef, usageType,
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
                                 &secret, &secretlen) < 0)
        goto cleanup;

    if (virCryptoEncryptData(VIR_CRYPTO_CIPHER_AES256CBC,
                             priv->masterKey, QEMU_DOMAIN_MASTER_KEY_LEN,
                             raw_iv, ivlen, secret, secretlen,
                             &ciphertext, &ciphertextlen) < 0)
        goto cleanup;

    /* Clear out the secret */
    memset(secret, 0, secretlen);

    /* Now encode the ciphertext and store to be passed to qemu */
    if (!(secinfo->s.aes.ciphertext = virStringEncodeBase64(ciphertext,
                                                            ciphertextlen)))
        goto cleanup;

    ret = 0;

 cleanup:
    VIR_DISPOSE_N(raw_iv, ivlen);
    VIR_DISPOSE_N(secret, secretlen);
    VIR_DISPOSE_N(ciphertext, ciphertextlen);

    return ret;
}


1122 1123
/* qemuDomainSecretSetup:
 * @conn: Pointer to connection
1124
 * @priv: pointer to domain private object
1125
 * @secinfo: Pointer to secret info
1126
 * @srcalias: Alias of the disk/hostdev used to generate the secret alias
J
John Ferlan 已提交
1127
 * @usageType: The virSecretUsageType
1128 1129
 * @username: username to use for authentication (may be NULL)
 * @seclookupdef: Pointer to seclookupdef data
1130
 * @isLuks: True when is luks (generates different alias)
1131
 *
1132 1133 1134 1135
 * If we have the encryption API present and can support a secret object, then
 * build the AES secret; otherwise, build the Plain secret. This is the magic
 * decision point for utilizing the AES secrets for an RBD disk. For now iSCSI
 * disks and hostdevs will not be able to utilize this mechanism.
1136 1137 1138 1139 1140
 *
 * Returns 0 on success, -1 on failure
 */
static int
qemuDomainSecretSetup(virConnectPtr conn,
1141
                      qemuDomainObjPrivatePtr priv,
1142
                      qemuDomainSecretInfoPtr secinfo,
1143
                      const char *srcalias,
J
John Ferlan 已提交
1144
                      virSecretUsageType usageType,
1145
                      const char *username,
1146 1147
                      virSecretLookupTypeDefPtr seclookupdef,
                      bool isLuks)
1148
{
1149 1150
    if (virCryptoHaveCipher(VIR_CRYPTO_CIPHER_AES256CBC) &&
        virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_OBJECT_SECRET) &&
J
John Ferlan 已提交
1151 1152 1153
        (usageType == VIR_SECRET_USAGE_TYPE_CEPH ||
         usageType == VIR_SECRET_USAGE_TYPE_VOLUME ||
         usageType == VIR_SECRET_USAGE_TYPE_TLS)) {
1154
        if (qemuDomainSecretAESSetup(conn, priv, secinfo, srcalias,
J
John Ferlan 已提交
1155
                                     usageType, username,
1156
                                     seclookupdef, isLuks) < 0)
1157 1158
            return -1;
    } else {
J
John Ferlan 已提交
1159
        if (qemuDomainSecretPlainSetup(conn, secinfo, usageType,
1160
                                       username, seclookupdef) < 0)
1161 1162 1163
            return -1;
    }
    return 0;
1164 1165 1166
}


1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212
/* qemuDomainSecretInfoNew:
 * @conn: Pointer to connection
 * @priv: pointer to domain private object
 * @srcAlias: Alias base to use for TLS object
 * @usageType: Secret usage type
 * @username: username for plain secrets (only)
 * @looupdef: lookup def describing secret
 * @isLuks: boolean for luks lookup
 *
 * Helper function to create a secinfo to be used for secinfo consumers
 *
 * Returns @secinfo on success, NULL on failure. Caller is responsible
 * to eventually free @secinfo.
 */
static qemuDomainSecretInfoPtr
qemuDomainSecretInfoNew(virConnectPtr conn,
                        qemuDomainObjPrivatePtr priv,
                        const char *srcAlias,
                        virSecretUsageType usageType,
                        const char *username,
                        virSecretLookupTypeDefPtr lookupDef,
                        bool isLuks)
{
    qemuDomainSecretInfoPtr secinfo = NULL;

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

    if (qemuDomainSecretSetup(conn, priv, secinfo, srcAlias, usageType,
                              username, lookupDef, isLuks) < 0)
        goto error;

    if (!username && secinfo->type == VIR_DOMAIN_SECRET_INFO_TYPE_PLAIN) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("encrypted secrets are not supported"));
        goto error;
    }

    return secinfo;

 error:
    qemuDomainSecretInfoFree(&secinfo);
    return NULL;
}


1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224
/**
 * qemuDomainSecretInfoTLSNew:
 * @conn: Pointer to connection
 * @priv: pointer to domain private object
 * @srcAlias: Alias base to use for TLS object
 * @secretUUID: Provide a secretUUID value to look up/create the secretInfo
 *
 * Using the passed @secretUUID, generate a seclookupdef that can be used
 * to generate the returned qemuDomainSecretInfoPtr for a TLS based secret.
 *
 * Returns qemuDomainSecretInfoPtr or NULL on error.
 */
1225
qemuDomainSecretInfoPtr
1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
qemuDomainSecretInfoTLSNew(virConnectPtr conn,
                           qemuDomainObjPrivatePtr priv,
                           const char *srcAlias,
                           const char *secretUUID)
{
    virSecretLookupTypeDef seclookupdef = {0};

    if (virUUIDParse(secretUUID, seclookupdef.u.uuid) < 0) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("malformed TLS secret uuid '%s' provided"),
                       secretUUID);
        return NULL;
    }
    seclookupdef.type = VIR_SECRET_LOOKUP_TYPE_UUID;

    return qemuDomainSecretInfoNew(conn, priv, srcAlias,
                                   VIR_SECRET_USAGE_TYPE_TLS, NULL,
                                   &seclookupdef, false);
}


1247 1248 1249 1250 1251 1252 1253 1254 1255 1256
/* qemuDomainSecretDiskDestroy:
 * @disk: Pointer to a disk definition
 *
 * Clear and destroy memory associated with the secret
 */
void
qemuDomainSecretDiskDestroy(virDomainDiskDefPtr disk)
{
    qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);

1257
    if (!diskPriv || !diskPriv->secinfo)
1258 1259 1260 1261 1262 1263
        return;

    qemuDomainSecretInfoFree(&diskPriv->secinfo);
}


1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
bool
qemuDomainSecretDiskCapable(virStorageSourcePtr src)
{
    if (!virStorageSourceIsEmpty(src) &&
        virStorageSourceGetActualType(src) == VIR_STORAGE_TYPE_NETWORK &&
        src->auth &&
        (src->protocol == VIR_STORAGE_NET_PROTOCOL_ISCSI ||
         src->protocol == VIR_STORAGE_NET_PROTOCOL_RBD))
        return true;

    return false;
}


1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289
bool
qemuDomainDiskHasEncryptionSecret(virStorageSourcePtr src)
{
    if (!virStorageSourceIsEmpty(src) && src->encryption &&
        src->encryption->format == VIR_STORAGE_ENCRYPTION_FORMAT_LUKS &&
        src->encryption->nsecrets > 0)
        return true;

    return false;
}


1290 1291
/* qemuDomainSecretDiskPrepare:
 * @conn: Pointer to connection
J
John Ferlan 已提交
1292
 * @priv: pointer to domain private object
1293 1294 1295 1296 1297 1298 1299 1300
 * @disk: Pointer to a disk definition
 *
 * For the right disk, generate the qemuDomainSecretInfo structure.
 *
 * Returns 0 on success, -1 on failure
 */
int
qemuDomainSecretDiskPrepare(virConnectPtr conn,
1301
                            qemuDomainObjPrivatePtr priv,
1302 1303 1304
                            virDomainDiskDefPtr disk)
{
    virStorageSourcePtr src = disk->src;
1305
    qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
1306

1307
    if (qemuDomainSecretDiskCapable(src)) {
J
John Ferlan 已提交
1308
        virSecretUsageType usageType = VIR_SECRET_USAGE_TYPE_ISCSI;
1309

1310
        if (src->protocol == VIR_STORAGE_NET_PROTOCOL_RBD)
J
John Ferlan 已提交
1311
            usageType = VIR_SECRET_USAGE_TYPE_CEPH;
1312

1313 1314
        if (!(diskPriv->secinfo =
              qemuDomainSecretInfoNew(conn, priv, disk->info.alias,
J
John Ferlan 已提交
1315
                                      usageType, src->auth->username,
1316 1317
                                      &src->auth->seclookupdef, false)))
              return -1;
1318 1319
    }

1320
    if (qemuDomainDiskHasEncryptionSecret(src)) {
1321 1322 1323 1324 1325 1326
        if (!(diskPriv->encinfo =
              qemuDomainSecretInfoNew(conn, priv, disk->info.alias,
                                      VIR_SECRET_USAGE_TYPE_VOLUME, NULL,
                                      &src->encryption->secrets[0]->seclookupdef,
                                      true)))
              return -1;
1327 1328
    }

1329 1330 1331 1332
    return 0;
}


1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343
/* qemuDomainSecretHostdevDestroy:
 * @disk: Pointer to a hostdev definition
 *
 * Clear and destroy memory associated with the secret
 */
void
qemuDomainSecretHostdevDestroy(virDomainHostdevDefPtr hostdev)
{
    qemuDomainHostdevPrivatePtr hostdevPriv =
        QEMU_DOMAIN_HOSTDEV_PRIVATE(hostdev);

1344
    if (!hostdevPriv || !hostdevPriv->secinfo)
1345 1346 1347 1348 1349 1350 1351 1352
        return;

    qemuDomainSecretInfoFree(&hostdevPriv->secinfo);
}


/* qemuDomainSecretHostdevPrepare:
 * @conn: Pointer to connection
J
John Ferlan 已提交
1353
 * @priv: pointer to domain private object
1354 1355 1356 1357 1358 1359 1360 1361
 * @hostdev: Pointer to a hostdev definition
 *
 * For the right host device, generate the qemuDomainSecretInfo structure.
 *
 * Returns 0 on success, -1 on failure
 */
int
qemuDomainSecretHostdevPrepare(virConnectPtr conn,
1362
                               qemuDomainObjPrivatePtr priv,
1363 1364
                               virDomainHostdevDefPtr hostdev)
{
1365
    if (virHostdevIsSCSIDevice(hostdev)) {
1366 1367 1368 1369 1370 1371 1372 1373 1374
        virDomainHostdevSubsysSCSIPtr scsisrc = &hostdev->source.subsys.u.scsi;
        virDomainHostdevSubsysSCSIiSCSIPtr iscsisrc = &scsisrc->u.iscsi;

        if (scsisrc->protocol == VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_ISCSI &&
            iscsisrc->auth) {

            qemuDomainHostdevPrivatePtr hostdevPriv =
                QEMU_DOMAIN_HOSTDEV_PRIVATE(hostdev);

1375 1376 1377 1378 1379 1380
            if (!(hostdevPriv->secinfo =
                  qemuDomainSecretInfoNew(conn, priv, hostdev->info->alias,
                                          VIR_SECRET_USAGE_TYPE_ISCSI,
                                          iscsisrc->auth->username,
                                          &iscsisrc->auth->seclookupdef,
                                          false)))
1381 1382 1383 1384 1385 1386 1387 1388
                return -1;
        }
    }

    return 0;
}


1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
/* qemuDomainSecretChardevDestroy:
 * @disk: Pointer to a chardev definition
 *
 * Clear and destroy memory associated with the secret
 */
void
qemuDomainSecretChardevDestroy(virDomainChrSourceDefPtr dev)
{
    qemuDomainChrSourcePrivatePtr chrSourcePriv =
        QEMU_DOMAIN_CHR_SOURCE_PRIVATE(dev);

    if (!chrSourcePriv || !chrSourcePriv->secinfo)
        return;

    qemuDomainSecretInfoFree(&chrSourcePriv->secinfo);
}


/* qemuDomainSecretChardevPrepare:
 * @conn: Pointer to connection
 * @cfg: Pointer to driver config object
 * @priv: pointer to domain private object
 * @chrAlias: Alias of the chr device
 * @dev: Pointer to a char source definition
 *
 * For a TCP character device, generate a qemuDomainSecretInfo to be used
 * by the command line code to generate the secret for the tls-creds to use.
 *
 * Returns 0 on success, -1 on failure
 */
int
qemuDomainSecretChardevPrepare(virConnectPtr conn,
                               virQEMUDriverConfigPtr cfg,
                               qemuDomainObjPrivatePtr priv,
                               const char *chrAlias,
                               virDomainChrSourceDefPtr dev)
{
    char *charAlias = NULL;

    if (dev->type != VIR_DOMAIN_CHR_TYPE_TCP)
        return 0;

    if (dev->data.tcp.haveTLS == VIR_TRISTATE_BOOL_YES &&
        cfg->chardevTLSx509secretUUID) {
        qemuDomainChrSourcePrivatePtr chrSourcePriv =
            QEMU_DOMAIN_CHR_SOURCE_PRIVATE(dev);

        if (!(charAlias = qemuAliasChardevFromDevAlias(chrAlias)))
1437
            return -1;
1438

1439 1440 1441
        chrSourcePriv->secinfo =
            qemuDomainSecretInfoTLSNew(conn, priv, charAlias,
                                       cfg->chardevTLSx509secretUUID);
1442
        VIR_FREE(charAlias);
1443 1444 1445

        if (!chrSourcePriv->secinfo)
            return -1;
1446 1447 1448 1449 1450 1451
    }

    return 0;
}


1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464
/* qemuDomainSecretDestroy:
 * @vm: Domain object
 *
 * Once completed with the generation of the command line it is
 * expect to remove the secrets
 */
void
qemuDomainSecretDestroy(virDomainObjPtr vm)
{
    size_t i;

    for (i = 0; i < vm->def->ndisks; i++)
        qemuDomainSecretDiskDestroy(vm->def->disks[i]);
1465 1466 1467

    for (i = 0; i < vm->def->nhostdevs; i++)
        qemuDomainSecretHostdevDestroy(vm->def->hostdevs[i]);
1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493

    for (i = 0; i < vm->def->nserials; i++)
        qemuDomainSecretChardevDestroy(vm->def->serials[i]->source);

    for (i = 0; i < vm->def->nparallels; i++)
        qemuDomainSecretChardevDestroy(vm->def->parallels[i]->source);

    for (i = 0; i < vm->def->nchannels; i++)
        qemuDomainSecretChardevDestroy(vm->def->channels[i]->source);

    for (i = 0; i < vm->def->nconsoles; i++)
        qemuDomainSecretChardevDestroy(vm->def->consoles[i]->source);

    for (i = 0; i < vm->def->nsmartcards; i++) {
        if (vm->def->smartcards[i]->type ==
            VIR_DOMAIN_SMARTCARD_TYPE_PASSTHROUGH)
            qemuDomainSecretChardevDestroy(vm->def->smartcards[i]->data.passthru);
    }

    for (i = 0; i < vm->def->nrngs; i++) {
        if (vm->def->rngs[i]->backend == VIR_DOMAIN_RNG_BACKEND_EGD)
            qemuDomainSecretChardevDestroy(vm->def->rngs[i]->source.chardev);
    }

    for (i = 0; i < vm->def->nredirdevs; i++)
        qemuDomainSecretChardevDestroy(vm->def->redirdevs[i]->source);
1494 1495 1496 1497 1498
}


/* qemuDomainSecretPrepare:
 * @conn: Pointer to connection
1499
 * @driver: Pointer to driver object
1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511
 * @vm: Domain object
 *
 * For any objects that may require an auth/secret setup, create a
 * qemuDomainSecretInfo and save it in the approriate place within
 * the private structures. This will be used by command line build
 * code in order to pass the secret along to qemu in order to provide
 * the necessary authentication data.
 *
 * Returns 0 on success, -1 on failure with error message set
 */
int
qemuDomainSecretPrepare(virConnectPtr conn,
1512
                        virQEMUDriverPtr driver,
1513 1514
                        virDomainObjPtr vm)
{
J
John Ferlan 已提交
1515
    qemuDomainObjPrivatePtr priv = vm->privateData;
1516
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
1517
    size_t i;
1518
    int ret = -1;
1519 1520

    for (i = 0; i < vm->def->ndisks; i++) {
J
John Ferlan 已提交
1521
        if (qemuDomainSecretDiskPrepare(conn, priv, vm->def->disks[i]) < 0)
1522
            goto cleanup;
1523 1524
    }

1525
    for (i = 0; i < vm->def->nhostdevs; i++) {
J
John Ferlan 已提交
1526 1527
        if (qemuDomainSecretHostdevPrepare(conn, priv,
                                           vm->def->hostdevs[i]) < 0)
1528
            goto cleanup;
1529 1530
    }

1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586
    for (i = 0; i < vm->def->nserials; i++) {
        if (qemuDomainSecretChardevPrepare(conn, cfg, priv,
                                           vm->def->serials[i]->info.alias,
                                           vm->def->serials[i]->source) < 0)
            goto cleanup;
    }

    for (i = 0; i < vm->def->nparallels; i++) {
        if (qemuDomainSecretChardevPrepare(conn, cfg, priv,
                                           vm->def->parallels[i]->info.alias,
                                           vm->def->parallels[i]->source) < 0)
            goto cleanup;
    }

    for (i = 0; i < vm->def->nchannels; i++) {
        if (qemuDomainSecretChardevPrepare(conn, cfg, priv,
                                           vm->def->channels[i]->info.alias,
                                           vm->def->channels[i]->source) < 0)
            goto cleanup;
    }

    for (i = 0; i < vm->def->nconsoles; i++) {
        if (qemuDomainSecretChardevPrepare(conn, cfg, priv,
                                           vm->def->consoles[i]->info.alias,
                                           vm->def->consoles[i]->source) < 0)
            goto cleanup;
    }

    for (i = 0; i < vm->def->nsmartcards; i++)
        if (vm->def->smartcards[i]->type ==
            VIR_DOMAIN_SMARTCARD_TYPE_PASSTHROUGH &&
            qemuDomainSecretChardevPrepare(conn, cfg, priv,
                                           vm->def->smartcards[i]->info.alias,
                                           vm->def->smartcards[i]->data.passthru) < 0)
            goto cleanup;

    for (i = 0; i < vm->def->nrngs; i++) {
        if (vm->def->rngs[i]->backend == VIR_DOMAIN_RNG_BACKEND_EGD &&
            qemuDomainSecretChardevPrepare(conn, cfg, priv,
                                           vm->def->rngs[i]->info.alias,
                                           vm->def->rngs[i]->source.chardev) < 0)
            goto cleanup;
    }

    for (i = 0; i < vm->def->nredirdevs; i++) {
        if (qemuDomainSecretChardevPrepare(conn, cfg, priv,
                                           vm->def->redirdevs[i]->info.alias,
                                           vm->def->redirdevs[i]->source) < 0)
            goto cleanup;
    }

    ret = 0;

 cleanup:
    virObjectUnref(cfg);
    return ret;
1587 1588 1589
}


1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616
/* This is the old way of setting up per-domain directories */
static int
qemuDomainSetPrivatePathsOld(virQEMUDriverPtr driver,
                             virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    int ret = -1;

    if (!priv->libDir &&
        virAsprintf(&priv->libDir, "%s/domain-%s",
                    cfg->libDir, vm->def->name) < 0)
        goto cleanup;

    if (!priv->channelTargetDir &&
        virAsprintf(&priv->channelTargetDir, "%s/domain-%s",
                    cfg->channelTargetDir, vm->def->name) < 0)
        goto cleanup;

    ret = 0;
 cleanup:
    virObjectUnref(cfg);
    return ret;
}


int
1617 1618
qemuDomainSetPrivatePaths(virQEMUDriverPtr driver,
                          virDomainObjPtr vm)
1619
{
1620 1621
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    qemuDomainObjPrivatePtr priv = vm->privateData;
1622
    char *domname = virDomainObjGetShortName(vm->def);
1623
    int ret = -1;
1624

M
Martin Kletzander 已提交
1625 1626 1627
    if (!domname)
        goto cleanup;

1628
    if (!priv->libDir &&
M
Martin Kletzander 已提交
1629
        virAsprintf(&priv->libDir, "%s/domain-%s", cfg->libDir, domname) < 0)
1630
        goto cleanup;
1631

1632
    if (!priv->channelTargetDir &&
M
Martin Kletzander 已提交
1633 1634
        virAsprintf(&priv->channelTargetDir, "%s/domain-%s",
                    cfg->channelTargetDir, domname) < 0)
1635
        goto cleanup;
1636

1637 1638 1639
    ret = 0;
 cleanup:
    virObjectUnref(cfg);
M
Martin Kletzander 已提交
1640
    VIR_FREE(domname);
1641
    return ret;
1642 1643 1644
}


1645 1646 1647 1648 1649 1650 1651 1652 1653 1654
void
qemuDomainClearPrivatePaths(virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;

    VIR_FREE(priv->libDir);
    VIR_FREE(priv->channelTargetDir);
}


1655 1656
static void *
qemuDomainObjPrivateAlloc(void)
1657 1658 1659 1660 1661 1662
{
    qemuDomainObjPrivatePtr priv;

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

1663 1664 1665
    if (qemuDomainObjInitJob(priv) < 0) {
        virReportSystemError(errno, "%s",
                             _("Unable to init qemu driver mutexes"));
1666
        goto error;
1667
    }
1668

1669
    if (!(priv->devs = virChrdevAlloc()))
1670 1671
        goto error;

1672
    priv->migMaxBandwidth = QEMU_DOMAIN_MIG_BANDWIDTH_MAX;
1673

1674
    return priv;
1675

1676
 error:
1677 1678
    VIR_FREE(priv);
    return NULL;
1679 1680
}

1681 1682
static void
qemuDomainObjPrivateFree(void *data)
1683 1684 1685
{
    qemuDomainObjPrivatePtr priv = data;

1686
    virObjectUnref(priv->qemuCaps);
1687

1688 1689
    virBitmapFree(priv->namespaces);

1690
    virCgroupFree(&priv->cgroup);
1691
    virDomainPCIAddressSetFree(priv->pciaddrs);
J
Ján Tomko 已提交
1692
    virDomainUSBAddressSetFree(priv->usbaddrs);
1693
    virDomainChrSourceDefFree(priv->monConfig);
1694
    qemuDomainObjFreeJob(priv);
1695
    VIR_FREE(priv->lockState);
J
Jiri Denemark 已提交
1696
    VIR_FREE(priv->origname);
1697

1698
    virStringListFree(priv->qemuDevices);
1699
    virChrdevFree(priv->devs);
1700

1701 1702
    /* This should never be non-NULL if we get here, but just in case... */
    if (priv->mon) {
1703
        VIR_ERROR(_("Unexpected QEMU monitor still active during domain deletion"));
1704 1705
        qemuMonitorClose(priv->mon);
    }
D
Daniel P. Berrange 已提交
1706 1707 1708 1709
    if (priv->agent) {
        VIR_ERROR(_("Unexpected QEMU agent still active during domain deletion"));
        qemuAgentClose(priv->agent);
    }
1710
    VIR_FREE(priv->cleanupCallbacks);
1711
    virBitmapFree(priv->autoNodeset);
1712
    virBitmapFree(priv->autoCpuset);
1713 1714 1715

    VIR_FREE(priv->libDir);
    VIR_FREE(priv->channelTargetDir);
1716 1717 1718

    qemuDomainSecretInfoFree(&priv->migSecinfo);
    VIR_FREE(priv->migTLSAlias);
1719
    qemuDomainMasterKeyFree(priv);
1720

1721 1722 1723 1724
    VIR_FREE(priv);
}


1725 1726
static void
qemuDomainObjPrivateXMLFormatVcpus(virBufferPtr buf,
1727
                                   virDomainDefPtr def)
1728 1729
{
    size_t i;
1730 1731 1732
    size_t maxvcpus = virDomainDefGetVcpusMax(def);
    virDomainVcpuDefPtr vcpu;
    pid_t tid;
1733 1734 1735 1736

    virBufferAddLit(buf, "<vcpus>\n");
    virBufferAdjustIndent(buf, 2);

1737 1738 1739 1740 1741 1742 1743 1744 1745
    for (i = 0; i < maxvcpus; i++) {
        vcpu = virDomainDefGetVcpu(def, i);
        tid = QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->tid;

        if (!vcpu->online || tid == 0)
            continue;

        virBufferAsprintf(buf, "<vcpu id='%zu' pid='%d'/>\n", i, tid);
    }
1746 1747 1748 1749 1750 1751

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


1752
static int
1753 1754
qemuDomainObjPrivateXMLFormat(virBufferPtr buf,
                              virDomainObjPtr vm)
1755
{
1756
    qemuDomainObjPrivatePtr priv = vm->privateData;
1757
    const char *monitorpath;
1758
    qemuDomainJob job;
1759 1760 1761

    /* priv->monitor_chr is set only for qemu */
    if (priv->monConfig) {
1762
        switch (priv->monConfig->type) {
1763
        case VIR_DOMAIN_CHR_TYPE_UNIX:
1764
            monitorpath = priv->monConfig->data.nix.path;
1765 1766 1767
            break;
        default:
        case VIR_DOMAIN_CHR_TYPE_PTY:
1768
            monitorpath = priv->monConfig->data.file.path;
1769 1770 1771
            break;
        }

1772
        virBufferEscapeString(buf, "<monitor path='%s'", monitorpath);
1773 1774
        if (priv->monJSON)
            virBufferAddLit(buf, " json='1'");
1775
        virBufferAsprintf(buf, " type='%s'/>\n",
1776
                          virDomainChrTypeToString(priv->monConfig->type));
1777 1778
    }

1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789
    if (priv->namespaces) {
        ssize_t ns = -1;

        virBufferAddLit(buf, "<namespaces>\n");
        virBufferAdjustIndent(buf, 2);
        while ((ns = virBitmapNextSetBit(priv->namespaces, ns)) >= 0)
            virBufferAsprintf(buf, "<%s/>\n", qemuDomainNamespaceTypeToString(ns));
        virBufferAdjustIndent(buf, -2);
        virBufferAddLit(buf, "</namespaces>\n");
    }

1790
    qemuDomainObjPrivateXMLFormatVcpus(buf, vm->def);
1791

1792
    if (priv->qemuCaps) {
1793
        size_t i;
1794 1795
        virBufferAddLit(buf, "<qemuCaps>\n");
        virBufferAdjustIndent(buf, 2);
1796
        for (i = 0; i < QEMU_CAPS_LAST; i++) {
1797
            if (virQEMUCapsGet(priv->qemuCaps, i)) {
1798
                virBufferAsprintf(buf, "<flag name='%s'/>\n",
1799
                                  virQEMUCapsTypeToString(i));
1800 1801
            }
        }
1802 1803
        virBufferAdjustIndent(buf, -2);
        virBufferAddLit(buf, "</qemuCaps>\n");
1804 1805
    }

1806
    if (priv->lockState)
1807
        virBufferAsprintf(buf, "<lockstate>%s</lockstate>\n", priv->lockState);
1808

1809 1810 1811 1812
    job = priv->job.active;
    if (!qemuDomainTrackJob(job))
        priv->job.active = QEMU_JOB_NONE;

1813
    if (priv->job.active || priv->job.asyncJob) {
1814
        virBufferAsprintf(buf, "<job type='%s' async='%s'",
1815 1816
                          qemuDomainJobTypeToString(priv->job.active),
                          qemuDomainAsyncJobTypeToString(priv->job.asyncJob));
J
Jiri Denemark 已提交
1817 1818 1819 1820 1821
        if (priv->job.phase) {
            virBufferAsprintf(buf, " phase='%s'",
                              qemuDomainAsyncJobPhaseToString(
                                    priv->job.asyncJob, priv->job.phase));
        }
1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842
        if (priv->job.asyncJob != QEMU_ASYNC_JOB_MIGRATION_OUT) {
            virBufferAddLit(buf, "/>\n");
        } else {
            size_t i;
            virDomainDiskDefPtr disk;
            qemuDomainDiskPrivatePtr diskPriv;

            virBufferAddLit(buf, ">\n");
            virBufferAdjustIndent(buf, 2);

            for (i = 0; i < vm->def->ndisks; i++) {
                disk = vm->def->disks[i];
                diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
                virBufferAsprintf(buf, "<disk dev='%s' migrating='%s'/>\n",
                                  disk->dst,
                                  diskPriv->migrating ? "yes" : "no");
            }

            virBufferAdjustIndent(buf, -2);
            virBufferAddLit(buf, "</job>\n");
        }
1843
    }
1844
    priv->job.active = job;
1845

1846
    if (priv->fakeReboot)
1847
        virBufferAddLit(buf, "<fakereboot/>\n");
1848

1849 1850
    if (priv->qemuDevices && *priv->qemuDevices) {
        char **tmp = priv->qemuDevices;
1851 1852
        virBufferAddLit(buf, "<devices>\n");
        virBufferAdjustIndent(buf, 2);
1853
        while (*tmp) {
1854
            virBufferAsprintf(buf, "<device alias='%s'/>\n", *tmp);
1855 1856
            tmp++;
        }
1857 1858
        virBufferAdjustIndent(buf, -2);
        virBufferAddLit(buf, "</devices>\n");
1859 1860
    }

1861 1862 1863 1864 1865 1866 1867 1868 1869 1870
    if (priv->autoNodeset) {
        char *nodeset = virBitmapFormat(priv->autoNodeset);

        if (!nodeset)
            return -1;

        virBufferAsprintf(buf, "<numad nodeset='%s'/>\n", nodeset);
        VIR_FREE(nodeset);
    }

1871 1872 1873 1874 1875
    /* Various per-domain paths */
    virBufferEscapeString(buf, "<libDir path='%s'/>\n", priv->libDir);
    virBufferEscapeString(buf, "<channelTargetDir path='%s'/>\n",
                          priv->channelTargetDir);

1876 1877 1878
    return 0;
}

1879 1880 1881 1882

static int
qemuDomainObjPrivateXMLParseVcpu(xmlNodePtr node,
                                 unsigned int idx,
1883
                                 virDomainDefPtr def)
1884
{
1885
    virDomainVcpuDefPtr vcpu;
1886
    char *idstr;
1887
    char *pidstr;
1888
    unsigned int tmp;
1889 1890
    int ret = -1;

1891 1892
    idstr = virXMLPropString(node, "id");

1893 1894
    if (idstr &&
        (virStrToLong_uip(idstr, NULL, 10, &idx) < 0)) {
1895
        virReportError(VIR_ERR_INTERNAL_ERROR,
1896 1897 1898 1899 1900 1901
                       _("cannot parse vcpu index '%s'"), idstr);
        goto cleanup;
    }
    if (!(vcpu = virDomainDefGetVcpu(def, idx))) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("invalid vcpu index '%u'"), idx);
1902
        goto cleanup;
1903 1904
    }

1905 1906 1907
    if (!(pidstr = virXMLPropString(node, "pid")))
        goto cleanup;

1908
    if (virStrToLong_uip(pidstr, NULL, 10, &tmp) < 0)
1909 1910
        goto cleanup;

1911 1912
    QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->tid = tmp;

1913 1914 1915
    ret = 0;

 cleanup:
1916
    VIR_FREE(idstr);
1917 1918 1919 1920 1921
    VIR_FREE(pidstr);
    return ret;
}


1922
static int
1923
qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt,
1924
                             virDomainObjPtr vm,
1925
                             virDomainDefParserConfigPtr config)
1926
{
1927
    qemuDomainObjPrivatePtr priv = vm->privateData;
1928
    virQEMUDriverPtr driver = config->priv;
1929
    char *monitorpath;
1930
    char *tmp = NULL;
1931 1932
    int n;
    size_t i;
1933
    xmlNodePtr *nodes = NULL;
1934
    xmlNodePtr node = NULL;
1935
    virQEMUCapsPtr qemuCaps = NULL;
1936
    virCapsPtr caps = NULL;
1937

1938
    if (VIR_ALLOC(priv->monConfig) < 0)
1939 1940 1941 1942
        goto error;

    if (!(monitorpath =
          virXPathString("string(./monitor[1]/@path)", ctxt))) {
1943 1944
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("no monitor path"));
1945 1946 1947 1948 1949
        goto error;
    }

    tmp = virXPathString("string(./monitor[1]/@type)", ctxt);
    if (tmp)
1950
        priv->monConfig->type = virDomainChrTypeFromString(tmp);
1951
    else
1952
        priv->monConfig->type = VIR_DOMAIN_CHR_TYPE_PTY;
1953 1954
    VIR_FREE(tmp);

E
Eric Blake 已提交
1955 1956
    priv->monJSON = virXPathBoolean("count(./monitor[@json = '1']) > 0",
                                    ctxt) > 0;
1957

1958
    switch (priv->monConfig->type) {
1959
    case VIR_DOMAIN_CHR_TYPE_PTY:
1960
        priv->monConfig->data.file.path = monitorpath;
1961 1962
        break;
    case VIR_DOMAIN_CHR_TYPE_UNIX:
1963
        priv->monConfig->data.nix.path = monitorpath;
1964 1965 1966
        break;
    default:
        VIR_FREE(monitorpath);
1967 1968 1969
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("unsupported monitor type '%s'"),
                       virDomainChrTypeToString(priv->monConfig->type));
1970 1971 1972
        goto error;
    }

1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996
    if ((node = virXPathNode("./namespaces", ctxt))) {
        xmlNodePtr next;

        for (next = node->children; next; next = next->next) {
            int ns = qemuDomainNamespaceTypeFromString((const char *) next->name);

            if (ns < 0) {
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("malformed namespace name: %s"),
                               next->name);
                goto error;
            }

            if (qemuDomainEnableNamespace(vm, ns) < 0)
                goto error;
        }
    }

    if (priv->namespaces &&
        virBitmapIsAllClear(priv->namespaces)) {
        virBitmapFree(priv->namespaces);
        priv->namespaces = NULL;
    }

1997
    if ((n = virXPathNodeSet("./vcpus/vcpu", ctxt, &nodes)) < 0)
1998 1999
        goto error;

2000
    for (i = 0; i < n; i++) {
2001
        if (qemuDomainObjPrivateXMLParseVcpu(nodes[i], i, vm->def) < 0)
2002
            goto error;
2003
    }
2004
    VIR_FREE(nodes);
2005

2006
    if ((n = virXPathNodeSet("./qemuCaps/flag", ctxt, &nodes)) < 0) {
2007 2008
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("failed to parse qemu capabilities flags"));
2009 2010 2011
        goto error;
    }
    if (n > 0) {
2012
        if (!(qemuCaps = virQEMUCapsNew()))
2013 2014
            goto error;

2015
        for (i = 0; i < n; i++) {
2016 2017
            char *str = virXMLPropString(nodes[i], "name");
            if (str) {
2018
                int flag = virQEMUCapsTypeFromString(str);
2019
                if (flag < 0) {
2020 2021
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("Unknown qemu capabilities flag %s"), str);
2022
                    VIR_FREE(str);
2023 2024
                    goto error;
                }
2025
                VIR_FREE(str);
2026
                virQEMUCapsSet(qemuCaps, flag);
2027 2028 2029
            }
        }

2030
        priv->qemuCaps = qemuCaps;
2031
        qemuCaps = NULL;
2032 2033 2034
    }
    VIR_FREE(nodes);

2035
    priv->lockState = virXPathString("string(./lockstate)", ctxt);
2036

2037 2038 2039 2040
    if ((tmp = virXPathString("string(./job[1]/@type)", ctxt))) {
        int type;

        if ((type = qemuDomainJobTypeFromString(tmp)) < 0) {
2041 2042
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Unknown job type %s"), tmp);
2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053
            VIR_FREE(tmp);
            goto error;
        }
        VIR_FREE(tmp);
        priv->job.active = type;
    }

    if ((tmp = virXPathString("string(./job[1]/@async)", ctxt))) {
        int async;

        if ((async = qemuDomainAsyncJobTypeFromString(tmp)) < 0) {
2054 2055
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Unknown async job type %s"), tmp);
2056 2057 2058 2059 2060
            VIR_FREE(tmp);
            goto error;
        }
        VIR_FREE(tmp);
        priv->job.asyncJob = async;
J
Jiri Denemark 已提交
2061 2062 2063 2064

        if ((tmp = virXPathString("string(./job[1]/@phase)", ctxt))) {
            priv->job.phase = qemuDomainAsyncJobPhaseFromString(async, tmp);
            if (priv->job.phase < 0) {
2065 2066
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Unknown job phase %s"), tmp);
J
Jiri Denemark 已提交
2067 2068 2069 2070 2071
                VIR_FREE(tmp);
                goto error;
            }
            VIR_FREE(tmp);
        }
2072 2073
    }

2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096
    if ((n = virXPathNodeSet("./job[1]/disk[@migrating='yes']",
                             ctxt, &nodes)) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("failed to parse list of disks marked for migration"));
        goto error;
    }
    if (n > 0) {
        if (priv->job.asyncJob != QEMU_ASYNC_JOB_MIGRATION_OUT) {
            VIR_WARN("Found disks marked for migration but we were not "
                     "migrating");
            n = 0;
        }
        for (i = 0; i < n; i++) {
            char *dst = virXMLPropString(nodes[i], "dev");
            virDomainDiskDefPtr disk;

            if (dst && (disk = virDomainDiskByName(vm->def, dst, false)))
                QEMU_DOMAIN_DISK_PRIVATE(disk)->migrating = true;
            VIR_FREE(dst);
        }
    }
    VIR_FREE(nodes);

2097 2098
    priv->fakeReboot = virXPathBoolean("boolean(./fakereboot)", ctxt) == 1;

2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119
    if ((n = virXPathNodeSet("./devices/device", ctxt, &nodes)) < 0) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("failed to parse qemu device list"));
        goto error;
    }
    if (n > 0) {
        /* NULL-terminated list */
        if (VIR_ALLOC_N(priv->qemuDevices, n + 1) < 0)
            goto error;

        for (i = 0; i < n; i++) {
            priv->qemuDevices[i] = virXMLPropString(nodes[i], "alias");
            if (!priv->qemuDevices[i]) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("failed to parse qemu device list"));
                goto error;
            }
        }
    }
    VIR_FREE(nodes);

2120 2121 2122 2123
    if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
        goto error;

    if ((tmp = virXPathString("string(./numad/@nodeset)", ctxt))) {
2124
        if (virBitmapParse(tmp, &priv->autoNodeset,
2125 2126 2127 2128 2129 2130 2131 2132 2133 2134
                           caps->host.nnumaCell_max) < 0)
            goto error;

        if (!(priv->autoCpuset = virCapabilitiesGetCpusForNodemask(caps,
                                                                   priv->autoNodeset)))
            goto error;
    }
    virObjectUnref(caps);
    VIR_FREE(tmp);

2135 2136 2137 2138 2139 2140 2141 2142 2143
    if ((tmp = virXPathString("string(./libDir/@path)", ctxt)))
        priv->libDir = tmp;
    if ((tmp = virXPathString("string(./channelTargetDir/@path)", ctxt)))
        priv->channelTargetDir = tmp;
    tmp = NULL;

    if (qemuDomainSetPrivatePathsOld(driver, vm) < 0)
        goto error;

2144 2145
    return 0;

2146
 error:
2147
    VIR_FREE(nodes);
2148
    VIR_FREE(tmp);
2149 2150 2151 2152
    virBitmapFree(priv->namespaces);
    priv->namespaces = NULL;
    virDomainChrSourceDefFree(priv->monConfig);
    priv->monConfig = NULL;
2153
    virStringListFree(priv->qemuDevices);
2154
    priv->qemuDevices = NULL;
2155
    virObjectUnref(qemuCaps);
2156
    virObjectUnref(caps);
2157 2158 2159 2160
    return -1;
}


2161 2162 2163
virDomainXMLPrivateDataCallbacks virQEMUDriverPrivateDataCallbacks = {
    .alloc = qemuDomainObjPrivateAlloc,
    .free = qemuDomainObjPrivateFree,
2164
    .diskNew = qemuDomainDiskPrivateNew,
2165
    .vcpuNew = qemuDomainVcpuPrivateNew,
2166
    .hostdevNew = qemuDomainHostdevPrivateNew,
2167
    .chrSourceNew = qemuDomainChrSourcePrivateNew,
2168 2169 2170 2171 2172
    .parse = qemuDomainObjPrivateXMLParse,
    .format = qemuDomainObjPrivateXMLFormat,
};


2173 2174 2175 2176 2177
static void
qemuDomainDefNamespaceFree(void *nsdata)
{
    qemuDomainCmdlineDefPtr cmd = nsdata;

2178
    qemuDomainCmdlineDefFree(cmd);
2179 2180 2181
}

static int
P
Philipp Hahn 已提交
2182 2183
qemuDomainDefNamespaceParse(xmlDocPtr xml ATTRIBUTE_UNUSED,
                            xmlNodePtr root ATTRIBUTE_UNUSED,
2184 2185 2186 2187
                            xmlXPathContextPtr ctxt,
                            void **data)
{
    qemuDomainCmdlineDefPtr cmd = NULL;
P
Philipp Hahn 已提交
2188
    bool uses_qemu_ns = false;
2189
    xmlNodePtr *nodes = NULL;
2190 2191
    int n;
    size_t i;
2192

P
Philipp Hahn 已提交
2193
    if (xmlXPathRegisterNs(ctxt, BAD_CAST "qemu", BAD_CAST QEMU_NAMESPACE_HREF) < 0) {
2194 2195 2196
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Failed to register xml namespace '%s'"),
                       QEMU_NAMESPACE_HREF);
2197 2198 2199
        return -1;
    }

2200
    if (VIR_ALLOC(cmd) < 0)
2201 2202 2203 2204 2205 2206
        return -1;

    /* first handle the extra command-line arguments */
    n = virXPathNodeSet("./qemu:commandline/qemu:arg", ctxt, &nodes);
    if (n < 0)
        goto error;
P
Philipp Hahn 已提交
2207
    uses_qemu_ns |= n > 0;
2208 2209

    if (n && VIR_ALLOC_N(cmd->args, n) < 0)
2210
        goto error;
2211 2212 2213 2214

    for (i = 0; i < n; i++) {
        cmd->args[cmd->num_args] = virXMLPropString(nodes[i], "value");
        if (cmd->args[cmd->num_args] == NULL) {
2215 2216
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("No qemu command-line argument specified"));
2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227
            goto error;
        }
        cmd->num_args++;
    }

    VIR_FREE(nodes);

    /* now handle the extra environment variables */
    n = virXPathNodeSet("./qemu:commandline/qemu:env", ctxt, &nodes);
    if (n < 0)
        goto error;
P
Philipp Hahn 已提交
2228
    uses_qemu_ns |= n > 0;
2229 2230

    if (n && VIR_ALLOC_N(cmd->env_name, n) < 0)
2231
        goto error;
2232 2233

    if (n && VIR_ALLOC_N(cmd->env_value, n) < 0)
2234
        goto error;
2235 2236 2237 2238 2239 2240

    for (i = 0; i < n; i++) {
        char *tmp;

        tmp = virXMLPropString(nodes[i], "name");
        if (tmp == NULL) {
2241 2242
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("No qemu environment name specified"));
2243 2244 2245
            goto error;
        }
        if (tmp[0] == '\0') {
2246 2247
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("Empty qemu environment name specified"));
2248 2249 2250
            goto error;
        }
        if (!c_isalpha(tmp[0]) && tmp[0] != '_') {
2251 2252
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("Invalid environment name, it must begin with a letter or underscore"));
2253 2254 2255
            goto error;
        }
        if (strspn(tmp, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_") != strlen(tmp)) {
2256 2257
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("Invalid environment name, it must contain only alphanumerics and underscore"));
2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269
            goto error;
        }

        cmd->env_name[cmd->num_env] = tmp;

        cmd->env_value[cmd->num_env] = virXMLPropString(nodes[i], "value");
        /* a NULL value for command is allowed, since it might be empty */
        cmd->num_env++;
    }

    VIR_FREE(nodes);

P
Philipp Hahn 已提交
2270 2271 2272 2273
    if (uses_qemu_ns)
        *data = cmd;
    else
        VIR_FREE(cmd);
2274 2275 2276

    return 0;

2277
 error:
2278 2279 2280 2281 2282 2283 2284 2285 2286 2287
    VIR_FREE(nodes);
    qemuDomainDefNamespaceFree(cmd);
    return -1;
}

static int
qemuDomainDefNamespaceFormatXML(virBufferPtr buf,
                                void *nsdata)
{
    qemuDomainCmdlineDefPtr cmd = nsdata;
2288
    size_t i;
2289 2290 2291 2292

    if (!cmd->num_args && !cmd->num_env)
        return 0;

2293 2294 2295
    virBufferAddLit(buf, "<qemu:commandline>\n");
    virBufferAdjustIndent(buf, 2);

2296
    for (i = 0; i < cmd->num_args; i++)
2297
        virBufferEscapeString(buf, "<qemu:arg value='%s'/>\n",
2298 2299
                              cmd->args[i]);
    for (i = 0; i < cmd->num_env; i++) {
2300
        virBufferAsprintf(buf, "<qemu:env name='%s'", cmd->env_name[i]);
2301 2302 2303 2304 2305
        if (cmd->env_value[i])
            virBufferEscapeString(buf, " value='%s'", cmd->env_value[i]);
        virBufferAddLit(buf, "/>\n");
    }

2306 2307
    virBufferAdjustIndent(buf, -2);
    virBufferAddLit(buf, "</qemu:commandline>\n");
2308 2309 2310 2311 2312 2313 2314 2315 2316 2317
    return 0;
}

static const char *
qemuDomainDefNamespaceHref(void)
{
    return "xmlns:qemu='" QEMU_NAMESPACE_HREF "'";
}


2318 2319 2320 2321 2322 2323
virDomainXMLNamespace virQEMUDriverDomainXMLNamespace = {
    .parse = qemuDomainDefNamespaceParse,
    .free = qemuDomainDefNamespaceFree,
    .format = qemuDomainDefNamespaceFormatXML,
    .href = qemuDomainDefNamespaceHref,
};
2324

2325

P
Pavel Hrdina 已提交
2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344
static int
qemuDomainDefAddImplicitInputDevice(virDomainDef *def)
{
    if (ARCH_IS_X86(def->os.arch)) {
        if (virDomainDefMaybeAddInput(def,
                                      VIR_DOMAIN_INPUT_TYPE_MOUSE,
                                      VIR_DOMAIN_INPUT_BUS_PS2) < 0)
            return -1;

        if (virDomainDefMaybeAddInput(def,
                                      VIR_DOMAIN_INPUT_TYPE_KBD,
                                      VIR_DOMAIN_INPUT_BUS_PS2) < 0)
            return -1;
    }

    return 0;
}


2345
static int
2346 2347
qemuDomainDefAddDefaultDevices(virDomainDefPtr def,
                               virQEMUCapsPtr qemuCaps)
2348
{
2349
    bool addDefaultUSB = true;
2350
    int usbModel = -1; /* "default for machinetype" */
2351
    int pciRoot;       /* index within def->controllers */
2352
    bool addImplicitSATA = false;
2353
    bool addPCIRoot = false;
L
Laine Stump 已提交
2354
    bool addPCIeRoot = false;
2355
    bool addDefaultMemballoon = true;
2356 2357
    bool addDefaultUSBKBD = false;
    bool addDefaultUSBMouse = false;
2358
    bool addPanicDevice = false;
2359
    int ret = -1;
2360

P
Pavel Hrdina 已提交
2361 2362 2363 2364
    /* add implicit input devices */
    if (qemuDomainDefAddImplicitInputDevice(def) < 0)
        goto cleanup;

2365 2366 2367 2368
    /* Add implicit PCI root controller if the machine has one */
    switch (def->os.arch) {
    case VIR_ARCH_I686:
    case VIR_ARCH_X86_64:
L
Laine Stump 已提交
2369
        if (STREQ(def->os.machine, "isapc")) {
2370
            addDefaultUSB = false;
2371
            break;
2372
        }
2373
        if (qemuDomainIsQ35(def)) {
2374 2375
            addPCIeRoot = true;
            addImplicitSATA = true;
2376

2377 2378 2379 2380
            /* Prefer adding USB3 controller if supported
             * (nec-usb-xhci). Failing that, add a USB2 controller set
             * if the ich9-usb-ehci1 device is supported. Otherwise
             * don't add anything.
2381
             */
2382 2383 2384
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NEC_USB_XHCI))
                usbModel = VIR_DOMAIN_CONTROLLER_MODEL_USB_NEC_XHCI;
            else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_ICH9_USB_EHCI1))
2385 2386 2387
                usbModel = VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_EHCI1;
            else
                addDefaultUSB = false;
2388
            break;
L
Laine Stump 已提交
2389
        }
2390
        if (qemuDomainIsI440FX(def))
2391
            addPCIRoot = true;
2392 2393
        break;

2394
    case VIR_ARCH_ARMV7L:
2395
    case VIR_ARCH_AARCH64:
2396 2397
        addDefaultUSB = false;
        addDefaultMemballoon = false;
2398
        if (qemuDomainIsVirt(def))
2399 2400
            addPCIeRoot = virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_GPEX);
        break;
2401

2402
    case VIR_ARCH_PPC64:
2403
    case VIR_ARCH_PPC64LE:
2404 2405 2406
        addPCIRoot = true;
        addDefaultUSBKBD = true;
        addDefaultUSBMouse = true;
2407 2408 2409
        /* For pSeries guests, the firmware provides the same
         * functionality as the pvpanic device, so automatically
         * add the definition if not already present */
2410
        if (qemuDomainIsPSeries(def))
2411
            addPanicDevice = true;
2412 2413
        break;

2414 2415 2416 2417 2418 2419 2420
    case VIR_ARCH_ALPHA:
    case VIR_ARCH_PPC:
    case VIR_ARCH_PPCEMB:
    case VIR_ARCH_SH4:
    case VIR_ARCH_SH4EB:
        addPCIRoot = true;
        break;
2421

2422 2423 2424
    case VIR_ARCH_S390:
    case VIR_ARCH_S390X:
        addDefaultUSB = false;
2425
        addPanicDevice = true;
2426
        break;
2427 2428 2429 2430 2431 2432

    case VIR_ARCH_SPARC:
    case VIR_ARCH_SPARC64:
        addPCIRoot = true;
        break;

2433 2434 2435 2436
    default:
        break;
    }

2437
    if (addDefaultUSB &&
2438 2439
        virDomainControllerFind(def, VIR_DOMAIN_CONTROLLER_TYPE_USB, 0) < 0 &&
        virDomainDefAddUSBController(def, 0, usbModel) < 0)
2440
        goto cleanup;
2441

2442 2443 2444
    if (addImplicitSATA &&
        virDomainDefMaybeAddController(
            def, VIR_DOMAIN_CONTROLLER_TYPE_SATA, 0, -1) < 0)
2445
        goto cleanup;
2446

2447 2448
    pciRoot = virDomainControllerFind(def, VIR_DOMAIN_CONTROLLER_TYPE_PCI, 0);

2449 2450 2451
    /* NB: any machine that sets addPCIRoot to true must also return
     * true from the function qemuDomainSupportsPCI().
     */
2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466
    if (addPCIRoot) {
        if (pciRoot >= 0) {
            if (def->controllers[pciRoot]->model != VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT) {
                virReportError(VIR_ERR_XML_ERROR,
                               _("The PCI controller with index='0' must be "
                                 "model='pci-root' for this machine type, "
                                 "but model='%s' was found instead"),
                               virDomainControllerModelPCITypeToString(def->controllers[pciRoot]->model));
                goto cleanup;
            }
        } else if (!virDomainDefAddController(def, VIR_DOMAIN_CONTROLLER_TYPE_PCI, 0,
                                              VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT)) {
            goto cleanup;
        }
    }
2467

2468 2469 2470
    /* When a machine has a pcie-root, make sure that there is always
     * a dmi-to-pci-bridge controller added as bus 1, and a pci-bridge
     * as bus 2, so that standard PCI devices can be connected
2471 2472 2473
     *
     * NB: any machine that sets addPCIeRoot to true must also return
     * true from the function qemuDomainSupportsPCI().
2474 2475
     */
    if (addPCIeRoot) {
2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488
        if (pciRoot >= 0) {
            if (def->controllers[pciRoot]->model != VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT) {
                virReportError(VIR_ERR_XML_ERROR,
                               _("The PCI controller with index='0' must be "
                                 "model='pcie-root' for this machine type, "
                                 "but model='%s' was found instead"),
                               virDomainControllerModelPCITypeToString(def->controllers[pciRoot]->model));
                goto cleanup;
            }
        } else if (!virDomainDefAddController(def, VIR_DOMAIN_CONTROLLER_TYPE_PCI, 0,
                                             VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT)) {
            goto cleanup;
        }
2489
    }
2490

2491
    if (addDefaultMemballoon && !def->memballoon) {
2492 2493
        virDomainMemballoonDefPtr memballoon;
        if (VIR_ALLOC(memballoon) < 0)
2494
            goto cleanup;
2495 2496 2497 2498 2499

        memballoon->model = VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO;
        def->memballoon = memballoon;
    }

2500 2501 2502 2503 2504
    if (addDefaultUSBKBD &&
        def->ngraphics > 0 &&
        virDomainDefMaybeAddInput(def,
                                  VIR_DOMAIN_INPUT_TYPE_KBD,
                                  VIR_DOMAIN_INPUT_BUS_USB) < 0)
2505
        goto cleanup;
2506 2507 2508 2509 2510 2511

    if (addDefaultUSBMouse &&
        def->ngraphics > 0 &&
        virDomainDefMaybeAddInput(def,
                                  VIR_DOMAIN_INPUT_TYPE_MOUSE,
                                  VIR_DOMAIN_INPUT_BUS_USB) < 0)
2512
        goto cleanup;
2513

D
Dmitry Andreev 已提交
2514 2515 2516 2517
    if (addPanicDevice) {
        size_t j;
        for (j = 0; j < def->npanics; j++) {
            if (def->panics[j]->model == VIR_DOMAIN_PANIC_MODEL_DEFAULT ||
2518 2519 2520 2521
                (ARCH_IS_PPC64(def->os.arch) &&
                     def->panics[j]->model == VIR_DOMAIN_PANIC_MODEL_PSERIES) ||
                (ARCH_IS_S390(def->os.arch) &&
                     def->panics[j]->model == VIR_DOMAIN_PANIC_MODEL_S390))
D
Dmitry Andreev 已提交
2522 2523
                break;
        }
2524

D
Dmitry Andreev 已提交
2525 2526 2527 2528 2529 2530 2531 2532 2533
        if (j == def->npanics) {
            virDomainPanicDefPtr panic;
            if (VIR_ALLOC(panic) < 0 ||
                VIR_APPEND_ELEMENT_COPY(def->panics,
                                        def->npanics, panic) < 0) {
                VIR_FREE(panic);
                goto cleanup;
            }
        }
2534 2535
    }

2536 2537 2538 2539 2540 2541
    ret = 0;
 cleanup:
    return ret;
}


A
Andrea Bolognani 已提交
2542 2543 2544
/**
 * qemuDomainDefEnableDefaultFeatures:
 * @def: domain definition
2545
 * @qemuCaps: QEMU capabilities
A
Andrea Bolognani 已提交
2546 2547 2548 2549 2550
 *
 * Make sure that features that should be enabled by default are actually
 * enabled and configure default values related to those features.
 */
static void
2551 2552
qemuDomainDefEnableDefaultFeatures(virDomainDefPtr def,
                                   virQEMUCapsPtr qemuCaps)
A
Andrea Bolognani 已提交
2553
{
2554 2555 2556 2557 2558 2559
    virGICVersion version;

    /* The virt machine type always uses GIC: if the relevant element
     * was not included in the domain XML, we need to choose a suitable
     * GIC version ourselves */
    if (def->features[VIR_DOMAIN_FEATURE_GIC] == VIR_TRISTATE_SWITCH_ABSENT &&
2560
        qemuDomainIsVirt(def)) {
2561 2562 2563 2564 2565

        VIR_DEBUG("Looking for usable GIC version in domain capabilities");
        for (version = VIR_GIC_VERSION_LAST - 1;
             version > VIR_GIC_VERSION_NONE;
             version--) {
2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583

            /* We want to use the highest available GIC version for guests;
             * however, the emulated GICv3 is currently lacking a MSI controller,
             * making it unsuitable for the pure PCIe topology we aim for.
             *
             * For that reason, we skip this step entirely for TCG guests,
             * and rely on the code below to pick the default version, GICv2,
             * which supports all the features we need.
             *
             * We'll want to revisit this once MSI support for GICv3 has been
             * implemented in QEMU.
             *
             * See https://bugzilla.redhat.com/show_bug.cgi?id=1414081 */
            if (version == VIR_GIC_VERSION_3 &&
                def->virtType == VIR_DOMAIN_VIRT_QEMU) {
                continue;
            }

2584 2585 2586 2587 2588 2589 2590 2591
            if (virQEMUCapsSupportsGICVersion(qemuCaps,
                                              def->virtType,
                                              version)) {
                VIR_DEBUG("Using GIC version %s",
                          virGICVersionTypeToString(version));
                def->gic_version = version;
                break;
            }
2592 2593
        }

2594 2595 2596
        /* Even if we haven't found a usable GIC version in the domain
         * capabilities, we still want to enable this */
        def->features[VIR_DOMAIN_FEATURE_GIC] = VIR_TRISTATE_SWITCH_ON;
2597 2598
    }

2599
    /* Use the default GIC version (GICv2) if no version was specified */
A
Andrea Bolognani 已提交
2600
    if (def->features[VIR_DOMAIN_FEATURE_GIC] == VIR_TRISTATE_SWITCH_ON &&
2601
        def->gic_version == VIR_GIC_VERSION_NONE) {
2602 2603
        VIR_DEBUG("Using GIC version 2 (default)");
        def->gic_version = VIR_GIC_VERSION_2;
2604
    }
A
Andrea Bolognani 已提交
2605 2606 2607
}


2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627
static int
qemuCanonicalizeMachine(virDomainDefPtr def, virQEMUCapsPtr qemuCaps)
{
    const char *canon;

    if (!(canon = virQEMUCapsGetCanonicalMachine(qemuCaps, def->os.machine)))
        return 0;

    if (STRNEQ(canon, def->os.machine)) {
        char *tmp;
        if (VIR_STRDUP(tmp, canon) < 0)
            return -1;
        VIR_FREE(def->os.machine);
        def->os.machine = tmp;
    }

    return 0;
}


2628
static int
2629 2630 2631 2632 2633
qemuDomainRecheckInternalPaths(virDomainDefPtr def,
                               virQEMUDriverConfigPtr cfg,
                               unsigned int flags)
{
    size_t i = 0;
2634
    size_t j = 0;
2635 2636 2637 2638

    for (i = 0; i < def->ngraphics; ++i) {
        virDomainGraphicsDefPtr graphics = def->graphics[i];

2639 2640 2641 2642 2643 2644
        for (j = 0; j < graphics->nListens; ++j) {
            virDomainGraphicsListenDefPtr glisten =  &graphics->listens[j];

            /* This will happen only if we parse XML from old libvirts where
             * unix socket was available only for VNC graphics.  In this
             * particular case we should follow the behavior and if we remove
2645
             * the auto-generated socket based on config option from qemu.conf
2646 2647 2648 2649
             * we need to change the listen type to address. */
            if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
                glisten->type == VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_SOCKET &&
                glisten->socket &&
2650
                !glisten->autoGenerated &&
2651 2652 2653 2654 2655 2656 2657
                STRPREFIX(glisten->socket, cfg->libDir)) {
                if (flags & VIR_DOMAIN_DEF_PARSE_INACTIVE) {
                    VIR_FREE(glisten->socket);
                    glisten->type = VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS;
                } else {
                    glisten->fromConfig = true;
                }
2658
            }
2659 2660
        }
    }
2661 2662

    return 0;
2663 2664 2665
}


2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735
static int
qemuDomainDefVcpusPostParse(virDomainDefPtr def)
{
    unsigned int maxvcpus = virDomainDefGetVcpusMax(def);
    virDomainVcpuDefPtr vcpu;
    virDomainVcpuDefPtr prevvcpu;
    size_t i;
    bool has_order = false;

    /* vcpu 0 needs to be present, first, and non-hotpluggable */
    vcpu = virDomainDefGetVcpu(def, 0);
    if (!vcpu->online) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("vcpu 0 can't be offline"));
        return -1;
    }
    if (vcpu->hotpluggable == VIR_TRISTATE_BOOL_YES) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("vcpu0 can't be hotpluggable"));
        return -1;
    }
    if (vcpu->order != 0 && vcpu->order != 1) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("vcpu0 must be enabled first"));
        return -1;
    }

    if (vcpu->order != 0)
        has_order = true;

    prevvcpu = vcpu;

    /* all online vcpus or non online vcpu need to have order set */
    for (i = 1; i < maxvcpus; i++) {
        vcpu = virDomainDefGetVcpu(def, i);

        if (vcpu->online &&
            (vcpu->order != 0) != has_order) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("all vcpus must have either set or unset order"));
            return -1;
        }

        /* few conditions for non-hotpluggable (thus online) vcpus */
        if (vcpu->hotpluggable == VIR_TRISTATE_BOOL_NO) {
            /* they can be ordered only at the beginning */
            if (prevvcpu->hotpluggable == VIR_TRISTATE_BOOL_YES) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("online non-hotpluggable vcpus need to be "
                                 "ordered prior to hotplugable vcpus"));
                return -1;
            }

            /* they need to be in order (qemu doesn't support any order yet).
             * Also note that multiple vcpus may share order on some platforms */
            if (prevvcpu->order > vcpu->order) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("online non-hotpluggable vcpus must be ordered "
                                 "in ascending order"));
                return -1;
            }
        }

        prevvcpu = vcpu;
    }

    return 0;
}


2736 2737 2738 2739 2740 2741
static int
qemuDomainDefCPUPostParse(virDomainDefPtr def)
{
    if (!def->cpu)
        return 0;

2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795
    if (def->cpu->cache) {
        virCPUCacheDefPtr cache = def->cpu->cache;

        if (!ARCH_IS_X86(def->os.arch)) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("CPU cache specification is not supported "
                             "for '%s' architecture"),
                           virArchToString(def->os.arch));
            return -1;
        }

        switch (cache->mode) {
        case VIR_CPU_CACHE_MODE_EMULATE:
            if (cache->level != 3) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               _("CPU cache mode '%s' can only be used with "
                                 "level='3'"),
                               virCPUCacheModeTypeToString(cache->mode));
                return -1;
            }
            break;

        case VIR_CPU_CACHE_MODE_PASSTHROUGH:
            if (def->cpu->mode != VIR_CPU_MODE_HOST_PASSTHROUGH) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               _("CPU cache mode '%s' can only be used with "
                                 "'%s' CPUs"),
                               virCPUCacheModeTypeToString(cache->mode),
                               virCPUModeTypeToString(VIR_CPU_MODE_HOST_PASSTHROUGH));
                return -1;
            }

            if (cache->level != -1) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               _("unsupported CPU cache level for mode '%s'"),
                               virCPUCacheModeTypeToString(cache->mode));
                return -1;
            }
            break;

        case VIR_CPU_CACHE_MODE_DISABLE:
            if (cache->level != -1) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               _("unsupported CPU cache level for mode '%s'"),
                               virCPUCacheModeTypeToString(cache->mode));
                return -1;
            }
            break;

        case VIR_CPU_CACHE_MODE_LAST:
            break;
        }
    }

2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828
    /* Nothing to be done if only CPU topology is specified. */
    if (def->cpu->mode == VIR_CPU_MODE_CUSTOM &&
        !def->cpu->model)
        return 0;

    if (def->cpu->check != VIR_CPU_CHECK_DEFAULT)
        return 0;

    switch ((virCPUMode) def->cpu->mode) {
    case VIR_CPU_MODE_HOST_PASSTHROUGH:
        def->cpu->check = VIR_CPU_CHECK_NONE;
        break;

    case VIR_CPU_MODE_HOST_MODEL:
        def->cpu->check = VIR_CPU_CHECK_PARTIAL;
        break;

    case VIR_CPU_MODE_CUSTOM:
        /* Custom CPUs in TCG mode are not compared to host CPU by default. */
        if (def->virtType == VIR_DOMAIN_VIRT_QEMU)
            def->cpu->check = VIR_CPU_CHECK_NONE;
        else
            def->cpu->check = VIR_CPU_CHECK_PARTIAL;
        break;

    case VIR_CPU_MODE_LAST:
        break;
    }

    return 0;
}


2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844
static int
qemuDomainDefVerifyFeatures(const virDomainDef *def)
{
    if (def->features[VIR_DOMAIN_FEATURE_IOAPIC] == VIR_TRISTATE_SWITCH_ON &&
        !ARCH_IS_X86(def->os.arch)) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("I/O APIC tuning is not supported "
                         "for '%s' architecture"),
                       virArchToString(def->os.arch));
        return -1;
    }

    return 0;
}


2845 2846 2847
static int
qemuDomainDefPostParse(virDomainDefPtr def,
                       virCapsPtr caps,
2848
                       unsigned int parseFlags,
2849
                       void *opaque,
2850
                       void *parseOpaque)
2851 2852
{
    virQEMUDriverPtr driver = opaque;
2853
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
2854
    virQEMUCapsPtr qemuCaps = parseOpaque;
2855 2856 2857 2858 2859
    int ret = -1;

    if (def->os.bootloader || def->os.bootloaderArgs) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("bootloader is not supported by QEMU"));
2860
        goto cleanup;
2861 2862
    }

2863 2864 2865
    if (!def->os.machine) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("missing machine type"));
2866
        goto cleanup;
2867 2868
    }

2869 2870 2871 2872 2873 2874 2875 2876 2877
    if (def->os.loader &&
        def->os.loader->type == VIR_DOMAIN_LOADER_TYPE_PFLASH &&
        def->os.loader->readonly == VIR_TRISTATE_SWITCH_ON &&
        !def->os.loader->nvram) {
        if (virAsprintf(&def->os.loader->nvram, "%s/%s_VARS.fd",
                        cfg->nvramDir, def->name) < 0)
            goto cleanup;
    }

2878 2879 2880
    /* check for emulator and create a default one if needed */
    if (!def->emulator &&
        !(def->emulator = virDomainDefGetDefaultEmulator(def, caps)))
2881
        goto cleanup;
2882

2883 2884 2885 2886 2887 2888 2889 2890
    if (qemuCaps) {
        virObjectRef(qemuCaps);
    } else {
        if (!(qemuCaps = virQEMUCapsCacheLookup(caps,
                                                driver->qemuCapsCache,
                                                def->emulator)))
            goto cleanup;
    }
2891 2892 2893 2894

    if (qemuDomainDefAddDefaultDevices(def, qemuCaps) < 0)
        goto cleanup;

2895 2896 2897
    if (qemuCanonicalizeMachine(def, qemuCaps) < 0)
        goto cleanup;

2898
    qemuDomainDefEnableDefaultFeatures(def, qemuCaps);
A
Andrea Bolognani 已提交
2899

2900 2901 2902
    if (qemuDomainDefVerifyFeatures(def) < 0)
        goto cleanup;

2903 2904
    if (qemuDomainRecheckInternalPaths(def, cfg, parseFlags) < 0)
        goto cleanup;
2905

2906
    if (qemuSecurityVerify(driver->securityManager, def) < 0)
2907 2908
        goto cleanup;

2909 2910 2911
    if (qemuDomainDefVcpusPostParse(def) < 0)
        goto cleanup;

2912 2913 2914
    if (qemuDomainDefCPUPostParse(def) < 0)
        goto cleanup;

2915 2916 2917
    ret = 0;
 cleanup:
    virObjectUnref(qemuCaps);
2918
    virObjectUnref(cfg);
2919
    return ret;
2920 2921
}

2922

2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949
static int
qemuDomainDefValidateVideo(const virDomainDef *def)
{
    size_t i;
    virDomainVideoDefPtr video;

    for (i = 0; i < def->nvideos; i++) {
        video = def->videos[i];

        switch (video->type) {
        case VIR_DOMAIN_VIDEO_TYPE_XEN:
        case VIR_DOMAIN_VIDEO_TYPE_VBOX:
        case VIR_DOMAIN_VIDEO_TYPE_PARALLELS:
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("video type '%s' is not supported with QEMU"),
                           virDomainVideoTypeToString(video->type));
            return -1;
        case VIR_DOMAIN_VIDEO_TYPE_VGA:
        case VIR_DOMAIN_VIDEO_TYPE_CIRRUS:
        case VIR_DOMAIN_VIDEO_TYPE_VMVGA:
        case VIR_DOMAIN_VIDEO_TYPE_QXL:
        case VIR_DOMAIN_VIDEO_TYPE_VIRTIO:
        case VIR_DOMAIN_VIDEO_TYPE_LAST:
            break;
        }

        if (!video->primary &&
2950 2951
            video->type != VIR_DOMAIN_VIDEO_TYPE_QXL &&
            video->type != VIR_DOMAIN_VIDEO_TYPE_VIRTIO) {
2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("video type '%s' is only valid as primary "
                             "video device"),
                           virDomainVideoTypeToString(video->type));
            return -1;
        }

        if (video->accel && video->accel->accel2d == VIR_TRISTATE_SWITCH_ON) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("qemu does not support the accel2d setting"));
            return -1;
        }

        if (video->type == VIR_DOMAIN_VIDEO_TYPE_QXL) {
            if (video->vram > (UINT_MAX / 1024)) {
                virReportError(VIR_ERR_OVERFLOW,
                               _("value for 'vram' must be less than '%u'"),
                               UINT_MAX / 1024);
                return -1;
            }
            if (video->ram > (UINT_MAX / 1024)) {
                virReportError(VIR_ERR_OVERFLOW,
                               _("value for 'ram' must be less than '%u'"),
                               UINT_MAX / 1024);
                return -1;
            }
        }

        if (video->type == VIR_DOMAIN_VIDEO_TYPE_VGA ||
            video->type == VIR_DOMAIN_VIDEO_TYPE_VMVGA) {
            if (video->vram && video->vram < 1024) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               "%s", _("value for 'vram' must be at least "
                                       "1 MiB (1024 KiB)"));
                return -1;
            }
        }
    }

    return 0;
}


2995 2996 2997
#define QEMU_MAX_VCPUS_WITHOUT_EIM 255


2998 2999
static int
qemuDomainDefValidate(const virDomainDef *def,
3000
                      virCapsPtr caps,
3001
                      void *opaque)
3002
{
3003 3004
    virQEMUDriverPtr driver = opaque;
    virQEMUCapsPtr qemuCaps = NULL;
3005
    unsigned int topologycpus;
3006 3007
    int ret = -1;

3008 3009
    if (!(qemuCaps = virQEMUCapsCacheLookup(caps,
                                            driver->qemuCapsCache,
3010 3011 3012
                                            def->emulator)))
        goto cleanup;

3013 3014 3015
    if (def->mem.min_guarantee) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("Parameter 'min_guarantee' not supported by QEMU."));
3016
        goto cleanup;
3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036
    }

    /* On x86, UEFI requires ACPI */
    if (def->os.loader &&
        def->os.loader->type == VIR_DOMAIN_LOADER_TYPE_PFLASH &&
        ARCH_IS_X86(def->os.arch) &&
        def->features[VIR_DOMAIN_FEATURE_ACPI] != VIR_TRISTATE_SWITCH_ON) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("UEFI requires ACPI on this architecture"));
        goto cleanup;
    }

    /* On aarch64, ACPI requires UEFI */
    if (def->features[VIR_DOMAIN_FEATURE_ACPI] == VIR_TRISTATE_SWITCH_ON &&
        def->os.arch == VIR_ARCH_AARCH64 &&
        (!def->os.loader ||
         def->os.loader->type != VIR_DOMAIN_LOADER_TYPE_PFLASH)) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("ACPI requires UEFI on this architecture"));
        goto cleanup;
3037 3038
    }

M
Michal Privoznik 已提交
3039 3040 3041 3042 3043
    if (def->os.loader &&
        def->os.loader->secure == VIR_TRISTATE_BOOL_YES) {
        /* These are the QEMU implementation limitations. But we
         * have to live with them for now. */

3044
        if (!qemuDomainIsQ35(def)) {
M
Michal Privoznik 已提交
3045 3046
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Secure boot is supported with q35 machine types only"));
3047
            goto cleanup;
M
Michal Privoznik 已提交
3048 3049 3050 3051 3052 3053 3054 3055
        }

        /* Now, technically it is possible to have secure boot on
         * 32bits too, but that would require some -cpu xxx magic
         * too. Not worth it unless we are explicitly asked. */
        if (def->os.arch != VIR_ARCH_X86_64) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Secure boot is supported for x86_64 architecture only"));
3056
            goto cleanup;
M
Michal Privoznik 已提交
3057 3058 3059 3060 3061
        }

        if (def->features[VIR_DOMAIN_FEATURE_SMM] != VIR_TRISTATE_SWITCH_ON) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Secure boot requires SMM feature enabled"));
3062
            goto cleanup;
M
Michal Privoznik 已提交
3063 3064 3065
        }
    }

3066
    /* qemu as of 2.5.0 rejects SMP topologies that don't match the cpu count */
3067 3068 3069 3070 3071 3072 3073
    if (virDomainDefGetVcpusTopology(def, &topologycpus) == 0 &&
        topologycpus != virDomainDefGetVcpusMax(def)) {
        /* presence of query-hotpluggable-cpus should be a good enough witness */
        if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS)) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("CPU topology doesn't match maximum vcpu count"));
            goto cleanup;
3074 3075 3076
        }
    }

3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094
    if (ARCH_IS_X86(def->os.arch) &&
        virDomainDefGetVcpusMax(def) > QEMU_MAX_VCPUS_WITHOUT_EIM) {
        if (!qemuDomainIsQ35(def)) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("more than %d vCPUs are only supported on "
                             "q35-based machine types"),
                           QEMU_MAX_VCPUS_WITHOUT_EIM);
            goto cleanup;
        }
        if (!def->iommu || def->iommu->eim != VIR_TRISTATE_SWITCH_ON) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("more than %d vCPUs require extended interrupt "
                             "mode enabled on the iommu device"),
                           QEMU_MAX_VCPUS_WITHOUT_EIM);
            goto cleanup;
        }
    }

3095 3096 3097
    if (qemuDomainDefValidateVideo(def) < 0)
        goto cleanup;

3098 3099 3100 3101 3102
    ret = 0;

 cleanup:
    virObjectUnref(qemuCaps);
    return ret;
3103 3104 3105
}


3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129
static bool
qemuDomainNetSupportsCoalesce(virDomainNetType type)
{
    switch (type) {
    case VIR_DOMAIN_NET_TYPE_NETWORK:
    case VIR_DOMAIN_NET_TYPE_BRIDGE:
        return true;
    case VIR_DOMAIN_NET_TYPE_VHOSTUSER:
    case VIR_DOMAIN_NET_TYPE_ETHERNET:
    case VIR_DOMAIN_NET_TYPE_DIRECT:
    case VIR_DOMAIN_NET_TYPE_HOSTDEV:
    case VIR_DOMAIN_NET_TYPE_USER:
    case VIR_DOMAIN_NET_TYPE_SERVER:
    case VIR_DOMAIN_NET_TYPE_CLIENT:
    case VIR_DOMAIN_NET_TYPE_MCAST:
    case VIR_DOMAIN_NET_TYPE_INTERNAL:
    case VIR_DOMAIN_NET_TYPE_UDP:
    case VIR_DOMAIN_NET_TYPE_LAST:
        break;
    }
    return false;
}


3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148
static int
qemuDomainDeviceDefValidate(const virDomainDeviceDef *dev,
                            const virDomainDef *def ATTRIBUTE_UNUSED,
                            void *opaque)
{
    virQEMUDriverPtr driver = opaque;
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    int ret = -1;

    if (dev->type == VIR_DOMAIN_DEVICE_NET) {
        const virDomainNetDef *net = dev->data.net;

        if (net->guestIP.nroutes || net->guestIP.nips) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Invalid attempt to set network interface "
                             "guest-side IP route and/or address info, "
                             "not supported by QEMU"));
            goto cleanup;
        }
3149 3150 3151 3152 3153 3154 3155

        if (STREQ_NULLABLE(net->model, "virtio") &&
            net->driver.virtio.rx_queue_size & (net->driver.virtio.rx_queue_size - 1)) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("rx_queue_size has to be a power of two"));
            goto cleanup;
        }
3156 3157 3158 3159 3160 3161 3162 3163

        if (net->mtu &&
            !qemuDomainNetSupportsMTU(net->type)) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("setting MTU on interface type %s is not supported yet"),
                           virDomainNetTypeToString(net->type));
            goto cleanup;
        }
3164 3165 3166 3167 3168 3169 3170

        if (net->coalesce && !qemuDomainNetSupportsCoalesce(net->type)) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("coalesce settings on interface type %s are not supported"),
                           virDomainNetTypeToString(net->type));
            goto cleanup;
        }
3171 3172 3173 3174 3175 3176 3177 3178 3179
    }

    ret = 0;
 cleanup:
    virObjectUnref(cfg);
    return ret;
}


3180
static const char *
3181 3182
qemuDomainDefaultNetModel(const virDomainDef *def,
                          virQEMUCapsPtr qemuCaps)
3183
{
3184
    if (ARCH_IS_S390(def->os.arch))
3185 3186
        return "virtio";

3187 3188
    if (def->os.arch == VIR_ARCH_ARMV7L ||
        def->os.arch == VIR_ARCH_AARCH64) {
3189 3190 3191
        if (STREQ(def->os.machine, "versatilepb"))
            return "smc91c111";

3192
        if (qemuDomainIsVirt(def))
3193 3194
            return "virtio";

3195 3196 3197 3198 3199
        /* Incomplete. vexpress (and a few others) use this, but not all
         * arm boards */
        return "lan9118";
    }

3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211
    /* Try several network devices in turn; each of these devices is
     * less likely be supported out-of-the-box by the guest operating
     * system than the previous one */
    if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_RTL8139))
        return "rtl8139";
    else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_E1000))
        return "e1000";
    else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VIRTIO_NET))
        return "virtio";

    /* We've had no luck detecting support for any network device,
     * but we have to return something: might as well be rtl8139 */
3212 3213
    return "rtl8139";
}
3214

3215 3216

/*
3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232
 * Clear auto generated unix socket paths:
 *
 * libvirt 1.2.18 and older:
 *     {cfg->channelTargetDir}/{dom-name}.{target-name}
 *
 * libvirt 1.2.19 - 1.3.2:
 *     {cfg->channelTargetDir}/domain-{dom-name}/{target-name}
 *
 * libvirt 1.3.3 and newer:
 *     {cfg->channelTargetDir}/domain-{dom-id}-{short-dom-name}/{target-name}
 *
 * The unix socket path was stored in config XML until libvirt 1.3.0.
 * If someone specifies the same path as we generate, they shouldn't do it.
 *
 * This function clears the path for migration as well, so we need to clear
 * the path even if we are not storing it in the XML.
3233
 */
3234
static int
3235 3236 3237
qemuDomainChrDefDropDefaultPath(virDomainChrDefPtr chr,
                                virQEMUDriverPtr driver)
{
3238 3239 3240 3241
    virQEMUDriverConfigPtr cfg;
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    char *regexp = NULL;
    int ret = -1;
3242

3243 3244 3245 3246 3247
    if (chr->deviceType != VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL ||
        chr->targetType != VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO ||
        chr->source->type != VIR_DOMAIN_CHR_TYPE_UNIX ||
        !chr->source->data.nix.path) {
        return 0;
3248 3249
    }

3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266
    cfg = virQEMUDriverGetConfig(driver);

    virBufferEscapeRegex(&buf, "^%s", cfg->channelTargetDir);
    virBufferAddLit(&buf, "/([^/]+\\.)|(domain-[^/]+/)");
    virBufferEscapeRegex(&buf, "%s$", chr->target.name);

    if (virBufferCheckError(&buf) < 0)
        goto cleanup;

    regexp = virBufferContentAndReset(&buf);

    if (virStringMatch(chr->source->data.nix.path, regexp))
        VIR_FREE(chr->source->data.nix.path);

    ret = 0;
 cleanup:
    VIR_FREE(regexp);
3267
    virObjectUnref(cfg);
3268
    return ret;
3269 3270 3271
}


3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321
static int
qemuDomainShmemDefPostParse(virDomainShmemDefPtr shm)
{
    /* This was the default since the introduction of this device. */
    if (shm->model != VIR_DOMAIN_SHMEM_MODEL_IVSHMEM_DOORBELL && !shm->size)
        shm->size = 4 << 20;

    /* Nothing more to check/change for IVSHMEM */
    if (shm->model == VIR_DOMAIN_SHMEM_MODEL_IVSHMEM)
        return 0;

    if (!shm->server.enabled) {
        if (shm->model == VIR_DOMAIN_SHMEM_MODEL_IVSHMEM_DOORBELL) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("shmem model '%s' is supported "
                             "only with server option enabled"),
                           virDomainShmemModelTypeToString(shm->model));
            return -1;
        }

        if (shm->msi.enabled) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("shmem model '%s' doesn't support "
                             "msi"),
                           virDomainShmemModelTypeToString(shm->model));
        }
    } else {
        if (shm->model == VIR_DOMAIN_SHMEM_MODEL_IVSHMEM_PLAIN) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("shmem model '%s' is supported "
                             "only with server option disabled"),
                           virDomainShmemModelTypeToString(shm->model));
            return -1;
        }

        if (shm->size) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("shmem model '%s' does not support size setting"),
                           virDomainShmemModelTypeToString(shm->model));
            return -1;
        }
        shm->msi.enabled = true;
        if (!shm->msi.ioeventfd)
            shm->msi.ioeventfd = VIR_TRISTATE_SWITCH_ON;
    }

    return 0;
}


3322
#define QEMU_USB_XHCI_MAXPORTS 15
3323 3324


3325 3326 3327
static int
qemuDomainControllerDefPostParse(virDomainControllerDefPtr cont,
                                 const virDomainDef *def,
3328 3329
                                 virQEMUCapsPtr qemuCaps,
                                 unsigned int parseFlags)
3330
{
3331 3332 3333 3334 3335 3336 3337 3338
    switch ((virDomainControllerType)cont->type) {
    case VIR_DOMAIN_CONTROLLER_TYPE_SCSI:
        /* set the default SCSI controller model for S390 arches */
        if (cont->model == -1 &&
            ARCH_IS_S390(def->os.arch)) {
            cont->model = VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_SCSI;
        }
        break;
3339

3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350
    case VIR_DOMAIN_CONTROLLER_TYPE_USB:
        if (cont->model == -1) {
            /* Pick a suitable default model for the USB controller if none
             * has been selected by the user.
             *
             * We rely on device availability instead of setting the model
             * unconditionally because, for some machine types, there's a
             * chance we will get away with using the legacy USB controller
             * when the relevant device is not available.
             *
             * See qemuBuildControllerDevCommandLine() */
3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361

            /* Default USB controller is piix3-uhci if available. */
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_PIIX3_USB_UHCI))
                cont->model = VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX3_UHCI;

            if (ARCH_IS_S390(def->os.arch)) {
                if (cont->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
                    /* set the default USB model to none for s390 unless an
                     * address is found */
                    cont->model = VIR_DOMAIN_CONTROLLER_MODEL_USB_NONE;
                }
3362
            } else if (ARCH_IS_PPC64(def->os.arch)) {
3363 3364
                /* To not break migration we need to set default USB controller
                 * for ppc64 to pci-ohci if we cannot change ABI of the VM.
3365 3366
                 * The nec-usb-xhci or qemu-xhci controller is used as default
                 * only for newly defined domains or devices. */
3367
                if ((parseFlags & VIR_DOMAIN_DEF_PARSE_ABI_UPDATE) &&
3368 3369 3370
                    virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QEMU_XHCI)) {
                    cont->model = VIR_DOMAIN_CONTROLLER_MODEL_USB_QEMU_XHCI;
                } else if ((parseFlags & VIR_DOMAIN_DEF_PARSE_ABI_UPDATE) &&
3371 3372 3373
                    virQEMUCapsGet(qemuCaps, QEMU_CAPS_NEC_USB_XHCI)) {
                    cont->model = VIR_DOMAIN_CONTROLLER_MODEL_USB_NEC_XHCI;
                } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_PCI_OHCI)) {
3374
                    cont->model = VIR_DOMAIN_CONTROLLER_MODEL_USB_PCI_OHCI;
3375 3376 3377
                } else {
                    /* Explicitly fallback to legacy USB controller for PPC64. */
                    cont->model = -1;
3378
                }
3379
            } else if (def->os.arch == VIR_ARCH_AARCH64) {
3380 3381 3382
                if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QEMU_XHCI))
                    cont->model = VIR_DOMAIN_CONTROLLER_MODEL_USB_QEMU_XHCI;
                else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NEC_USB_XHCI))
3383
                    cont->model = VIR_DOMAIN_CONTROLLER_MODEL_USB_NEC_XHCI;
3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394
            }
        }
        /* forbid usb model 'qusb1' and 'qusb2' in this kind of hyperviosr */
        if (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_QUSB1 ||
            cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_QUSB2) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("USB controller model type 'qusb1' or 'qusb2' "
                             "is not supported in %s"),
                           virDomainVirtTypeToString(def->virtType));
            return -1;
        }
3395 3396 3397
        if ((cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_NEC_XHCI ||
             cont->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_QEMU_XHCI) &&
            cont->opts.usbopts.ports > QEMU_USB_XHCI_MAXPORTS) {
3398
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
3399 3400 3401
                           _("'%s' controller only supports up to '%u' ports"),
                           virDomainControllerModelUSBTypeToString(cont->model),
                           QEMU_USB_XHCI_MAXPORTS);
3402 3403 3404
            return -1;
        }
        break;
3405

3406
    case VIR_DOMAIN_CONTROLLER_TYPE_PCI:
3407
        if (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCI_EXPANDER_BUS &&
3408
            !qemuDomainIsI440FX(def)) {
3409 3410 3411 3412 3413 3414
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("pci-expander-bus controllers are only supported "
                             "on 440fx-based machinetypes"));
            return -1;
        }
        if (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCIE_EXPANDER_BUS &&
3415
            !qemuDomainIsQ35(def)) {
3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("pcie-expander-bus controllers are only supported "
                             "on q35-based machinetypes"));
            return -1;
        }

        /* if a PCI expander bus has a NUMA node set, make sure
         * that NUMA node is configured in the guest <cpu><numa>
         * array. NUMA cell id's in this array are numbered
         * from 0 .. size-1.
         */
        if ((cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCI_EXPANDER_BUS ||
             cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCIE_EXPANDER_BUS) &&
            (int) virDomainNumaGetNodeCount(def->numa)
            <= cont->opts.pciopts.numaNode) {
            virReportError(VIR_ERR_XML_ERROR,
                           _("%s with index %d is "
                             "configured for a NUMA node (%d) "
                             "not present in the domain's "
                             "<cpu><numa> array (%zu)"),
                           virDomainControllerModelPCITypeToString(cont->model),
                           cont->idx, cont->opts.pciopts.numaNode,
                           virDomainNumaGetNodeCount(def->numa));
            return -1;
        }
3441 3442 3443 3444 3445 3446 3447 3448 3449
        break;

    case VIR_DOMAIN_CONTROLLER_TYPE_SATA:
    case VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL:
    case VIR_DOMAIN_CONTROLLER_TYPE_CCID:
    case VIR_DOMAIN_CONTROLLER_TYPE_IDE:
    case VIR_DOMAIN_CONTROLLER_TYPE_FDC:
    case VIR_DOMAIN_CONTROLLER_TYPE_LAST:
        break;
3450 3451 3452 3453 3454 3455
    }

    return 0;
}


3456 3457
static int
qemuDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
3458
                             const virDomainDef *def,
3459
                             virCapsPtr caps,
3460
                             unsigned int parseFlags,
3461
                             void *opaque,
3462
                             void *parseOpaque)
3463
{
3464
    virQEMUDriverPtr driver = opaque;
3465
    virQEMUCapsPtr qemuCaps = parseOpaque;
3466
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
3467
    int ret = -1;
3468

3469 3470 3471 3472 3473 3474
    if (qemuCaps) {
        virObjectRef(qemuCaps);
    } else {
        qemuCaps = virQEMUCapsCacheLookup(caps, driver->qemuCapsCache,
                                          def->emulator);
    }
3475

3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489
    if (dev->type == VIR_DOMAIN_DEVICE_NET) {
        if (dev->data.net->type != VIR_DOMAIN_NET_TYPE_HOSTDEV &&
            !dev->data.net->model) {
            if (VIR_STRDUP(dev->data.net->model,
                           qemuDomainDefaultNetModel(def, qemuCaps)) < 0)
                goto cleanup;
        }
        if (dev->data.net->type == VIR_DOMAIN_NET_TYPE_VHOSTUSER &&
            !dev->data.net->ifname) {
            if (virNetDevOpenvswitchGetVhostuserIfname(
                   dev->data.net->data.vhostuser->data.nix.path,
                   &dev->data.net->ifname) < 0)
                goto cleanup;
        }
3490
    }
3491

3492 3493 3494 3495
    /* set default disk types and drivers */
    if (dev->type == VIR_DOMAIN_DEVICE_DISK) {
        virDomainDiskDefPtr disk = dev->data.disk;

3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523
        /* assign default storage format and driver according to config */
        if (cfg->allowDiskFormatProbing) {
            /* default disk format for drives */
            if (virDomainDiskGetFormat(disk) == VIR_STORAGE_FILE_NONE &&
                (virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_FILE ||
                 virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_BLOCK))
                virDomainDiskSetFormat(disk, VIR_STORAGE_FILE_AUTO);

            /* default disk format for mirrored drive */
            if (disk->mirror &&
                disk->mirror->format == VIR_STORAGE_FILE_NONE)
                disk->mirror->format = VIR_STORAGE_FILE_AUTO;
        } else {
            /* default driver if probing is forbidden */
            if (!virDomainDiskGetDriver(disk) &&
                virDomainDiskSetDriver(disk, "qemu") < 0)
                goto cleanup;

            /* default disk format for drives */
            if (virDomainDiskGetFormat(disk) == VIR_STORAGE_FILE_NONE &&
                (virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_FILE ||
                 virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_BLOCK))
                virDomainDiskSetFormat(disk, VIR_STORAGE_FILE_RAW);

            /* default disk format for mirrored drive */
            if (disk->mirror &&
                disk->mirror->format == VIR_STORAGE_FILE_NONE)
                disk->mirror->format = VIR_STORAGE_FILE_RAW;
3524 3525 3526
        }
    }

3527 3528 3529 3530
    /* set the default console type for S390 arches */
    if (dev->type == VIR_DOMAIN_DEVICE_CHR &&
        dev->data.chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE &&
        dev->data.chr->targetType == VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_NONE &&
3531
        ARCH_IS_S390(def->os.arch))
3532 3533
        dev->data.chr->targetType = VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO;

3534 3535
    /* clear auto generated unix socket path for inactive definitions */
    if ((parseFlags & VIR_DOMAIN_DEF_PARSE_INACTIVE) &&
3536 3537 3538 3539
        dev->type == VIR_DOMAIN_DEVICE_CHR) {
        if (qemuDomainChrDefDropDefaultPath(dev->data.chr, driver) < 0)
            goto cleanup;
    }
3540

3541 3542 3543 3544 3545 3546 3547 3548 3549 3550
    /* forbid capabilities mode hostdev in this kind of hypervisor */
    if (dev->type == VIR_DOMAIN_DEVICE_HOSTDEV &&
        dev->data.hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_CAPABILITIES) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("hostdev mode 'capabilities' is not "
                         "supported in %s"),
                       virDomainVirtTypeToString(def->virtType));
        goto cleanup;
    }

3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565
    if (dev->type == VIR_DOMAIN_DEVICE_VIDEO &&
        dev->data.video->type == VIR_DOMAIN_VIDEO_TYPE_QXL) {
        if (dev->data.video->vgamem) {
            if (dev->data.video->vgamem < 1024) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("value for 'vgamem' must be at least 1 MiB "
                                 "(1024 KiB)"));
                goto cleanup;
            }
            if (dev->data.video->vgamem != VIR_ROUND_UP_POWER_OF_TWO(dev->data.video->vgamem)) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("value for 'vgamem' must be power of two"));
                goto cleanup;
            }
        } else {
3566
            dev->data.video->vgamem = QEMU_QXL_VGAMEM_DEFAULT;
3567 3568 3569
        }
    }

3570 3571
    if (dev->type == VIR_DOMAIN_DEVICE_PANIC &&
        dev->data.panic->model == VIR_DOMAIN_PANIC_MODEL_DEFAULT) {
3572
        if (qemuDomainIsPSeries(def))
3573
            dev->data.panic->model = VIR_DOMAIN_PANIC_MODEL_PSERIES;
3574 3575
        else if (ARCH_IS_S390(def->os.arch))
            dev->data.panic->model = VIR_DOMAIN_PANIC_MODEL_S390;
3576 3577 3578 3579
        else
            dev->data.panic->model = VIR_DOMAIN_PANIC_MODEL_ISA;
    }

3580 3581
    if (dev->type == VIR_DOMAIN_DEVICE_CONTROLLER &&
        qemuDomainControllerDefPostParse(dev->data.controller, def,
3582
                                         qemuCaps, parseFlags) < 0)
3583
        goto cleanup;
3584

3585 3586 3587 3588
    if (dev->type == VIR_DOMAIN_DEVICE_SHMEM &&
        qemuDomainShmemDefPostParse(dev->data.shmem) < 0)
        goto cleanup;

3589 3590
    ret = 0;

3591
 cleanup:
3592
    virObjectUnref(qemuCaps);
3593 3594
    virObjectUnref(cfg);
    return ret;
3595 3596 3597
}


3598 3599
static int
qemuDomainDefAssignAddresses(virDomainDef *def,
3600
                             virCapsPtr caps,
3601
                             unsigned int parseFlags ATTRIBUTE_UNUSED,
3602
                             void *opaque,
3603
                             void *parseOpaque)
3604 3605
{
    virQEMUDriverPtr driver = opaque;
3606
    virQEMUCapsPtr qemuCaps = parseOpaque;
3607
    int ret = -1;
3608
    bool newDomain = parseFlags & VIR_DOMAIN_DEF_PARSE_ABI_UPDATE;
3609

3610 3611 3612 3613 3614 3615 3616 3617
    if (qemuCaps) {
        virObjectRef(qemuCaps);
    } else {
        if (!(qemuCaps = virQEMUCapsCacheLookup(caps,
                                                driver->qemuCapsCache,
                                                def->emulator)))
            goto cleanup;
    }
3618

3619
    if (qemuDomainAssignAddresses(def, qemuCaps, driver, NULL, newDomain) < 0)
3620 3621 3622 3623 3624 3625 3626 3627 3628
        goto cleanup;

    ret = 0;
 cleanup:
    virObjectUnref(qemuCaps);
    return ret;
}


3629 3630
virDomainDefParserConfig virQEMUDriverDomainDefParserConfig = {
    .devicesPostParseCallback = qemuDomainDeviceDefPostParse,
3631
    .domainPostParseCallback = qemuDomainDefPostParse,
3632
    .assignAddressesCallback = qemuDomainDefAssignAddresses,
3633
    .domainValidateCallback = qemuDomainDefValidate,
3634 3635
    .deviceValidateCallback = qemuDomainDeviceDefValidate,

3636
    .features = VIR_DOMAIN_DEF_FEATURE_MEMORY_HOTPLUG |
3637 3638
                VIR_DOMAIN_DEF_FEATURE_OFFLINE_VCPUPIN |
                VIR_DOMAIN_DEF_FEATURE_INDIVIDUAL_VCPUS,
3639 3640 3641
};


3642
static void
3643
qemuDomainObjSaveJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
3644
{
3645 3646 3647
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);

    if (virDomainObjIsActive(obj)) {
3648
        if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, obj, driver->caps) < 0)
3649
            VIR_WARN("Failed to save status on vm %s", obj->def->name);
3650
    }
3651

3652
    virObjectUnref(cfg);
3653 3654
}

J
Jiri Denemark 已提交
3655
void
3656
qemuDomainObjSetJobPhase(virQEMUDriverPtr driver,
J
Jiri Denemark 已提交
3657 3658 3659 3660
                         virDomainObjPtr obj,
                         int phase)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
3661
    unsigned long long me = virThreadSelfID();
J
Jiri Denemark 已提交
3662 3663 3664 3665

    if (!priv->job.asyncJob)
        return;

3666 3667 3668 3669 3670
    VIR_DEBUG("Setting '%s' phase to '%s'",
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
              qemuDomainAsyncJobPhaseToString(priv->job.asyncJob, phase));

    if (priv->job.asyncOwner && me != priv->job.asyncOwner) {
3671
        VIR_WARN("'%s' async job is owned by thread %llu",
3672 3673 3674 3675
                 qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
                 priv->job.asyncOwner);
    }

J
Jiri Denemark 已提交
3676
    priv->job.phase = phase;
3677
    priv->job.asyncOwner = me;
J
Jiri Denemark 已提交
3678 3679 3680
    qemuDomainObjSaveJob(driver, obj);
}

3681
void
3682 3683
qemuDomainObjSetAsyncJobMask(virDomainObjPtr obj,
                             unsigned long long allowedJobs)
3684 3685 3686
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

3687 3688 3689 3690 3691 3692 3693
    if (!priv->job.asyncJob)
        return;

    priv->job.mask = allowedJobs | JOB_MASK(QEMU_JOB_DESTROY);
}

void
3694
qemuDomainObjDiscardAsyncJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
3695 3696 3697 3698 3699 3700
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

    if (priv->job.active == QEMU_JOB_ASYNC_NESTED)
        qemuDomainObjResetJob(priv);
    qemuDomainObjResetAsyncJob(priv);
3701
    qemuDomainObjSaveJob(driver, obj);
3702 3703
}

3704 3705 3706 3707 3708 3709 3710 3711 3712
void
qemuDomainObjReleaseAsyncJob(virDomainObjPtr obj)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

    VIR_DEBUG("Releasing ownership of '%s' async job",
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob));

    if (priv->job.asyncOwner != virThreadSelfID()) {
3713
        VIR_WARN("'%s' async job is owned by thread %llu",
3714 3715 3716 3717 3718 3719
                 qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
                 priv->job.asyncOwner);
    }
    priv->job.asyncOwner = 0;
}

3720
static bool
3721
qemuDomainNestedJobAllowed(qemuDomainObjPrivatePtr priv, qemuDomainJob job)
3722 3723
{
    return !priv->job.asyncJob || (priv->job.mask & JOB_MASK(job)) != 0;
3724 3725
}

3726
bool
3727
qemuDomainJobAllowed(qemuDomainObjPrivatePtr priv, qemuDomainJob job)
3728 3729 3730 3731
{
    return !priv->job.active && qemuDomainNestedJobAllowed(priv, job);
}

3732 3733 3734
/* Give up waiting for mutex after 30 seconds */
#define QEMU_JOB_WAIT_TIME (1000ull * 30)

3735
/*
3736
 * obj must be locked before calling
3737
 */
3738
static int ATTRIBUTE_NONNULL(1)
3739
qemuDomainObjBeginJobInternal(virQEMUDriverPtr driver,
3740
                              virDomainObjPtr obj,
3741 3742
                              qemuDomainJob job,
                              qemuDomainAsyncJob asyncJob)
3743 3744
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
J
Jiri Denemark 已提交
3745
    unsigned long long now;
3746
    unsigned long long then;
3747
    bool nested = job == QEMU_JOB_ASYNC_NESTED;
J
Jiri Denemark 已提交
3748
    bool async = job == QEMU_JOB_ASYNC;
3749
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
3750
    const char *blocker = NULL;
J
Jiri Denemark 已提交
3751
    int ret = -1;
J
Jiri Denemark 已提交
3752 3753
    unsigned long long duration = 0;
    unsigned long long asyncDuration = 0;
J
Jiri Denemark 已提交
3754
    const char *jobStr;
3755

J
Jiri Denemark 已提交
3756 3757 3758 3759 3760 3761 3762 3763 3764
    if (async)
        jobStr = qemuDomainAsyncJobTypeToString(asyncJob);
    else
        jobStr = qemuDomainJobTypeToString(job);

    VIR_DEBUG("Starting %s: %s (vm=%p name=%s, current job=%s async=%s)",
              async ? "async job" : "job", jobStr, obj, obj->def->name,
              qemuDomainJobTypeToString(priv->job.active),
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob));
3765

3766 3767
    if (virTimeMillisNow(&now) < 0) {
        virObjectUnref(cfg);
3768
        return -1;
3769 3770
    }

3771
    priv->jobs_queued++;
J
Jiri Denemark 已提交
3772
    then = now + QEMU_JOB_WAIT_TIME;
3773

3774
 retry:
3775 3776
    if (cfg->maxQueuedJobs &&
        priv->jobs_queued > cfg->maxQueuedJobs) {
3777 3778 3779
        goto error;
    }

3780
    while (!nested && !qemuDomainNestedJobAllowed(priv, job)) {
3781
        VIR_DEBUG("Waiting for async job (vm=%p name=%s)", obj, obj->def->name);
3782
        if (virCondWaitUntil(&priv->job.asyncCond, &obj->parent.lock, then) < 0)
3783 3784 3785
            goto error;
    }

3786
    while (priv->job.active) {
3787
        VIR_DEBUG("Waiting for job (vm=%p name=%s)", obj, obj->def->name);
3788
        if (virCondWaitUntil(&priv->job.cond, &obj->parent.lock, then) < 0)
3789
            goto error;
3790
    }
3791 3792 3793

    /* No job is active but a new async job could have been started while obj
     * was unlocked, so we need to recheck it. */
3794
    if (!nested && !qemuDomainNestedJobAllowed(priv, job))
3795 3796
        goto retry;

3797
    qemuDomainObjResetJob(priv);
3798

J
Jiri Denemark 已提交
3799 3800
    ignore_value(virTimeMillisNow(&now));

3801
    if (job != QEMU_JOB_ASYNC) {
3802
        VIR_DEBUG("Started job: %s (async=%s vm=%p name=%s)",
3803
                   qemuDomainJobTypeToString(job),
3804 3805
                  qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
                  obj, obj->def->name);
3806
        priv->job.active = job;
3807
        priv->job.owner = virThreadSelfID();
3808
        priv->job.ownerAPI = virThreadJobGet();
J
Jiri Denemark 已提交
3809
        priv->job.started = now;
3810
    } else {
3811 3812 3813
        VIR_DEBUG("Started async job: %s (vm=%p name=%s)",
                  qemuDomainAsyncJobTypeToString(asyncJob),
                  obj, obj->def->name);
3814
        qemuDomainObjResetAsyncJob(priv);
J
Jiri Denemark 已提交
3815 3816
        if (VIR_ALLOC(priv->job.current) < 0)
            goto cleanup;
3817
        priv->job.asyncJob = asyncJob;
3818
        priv->job.asyncOwner = virThreadSelfID();
3819
        priv->job.asyncOwnerAPI = virThreadJobGet();
J
Jiri Denemark 已提交
3820
        priv->job.asyncStarted = now;
J
Jiri Denemark 已提交
3821
        priv->job.current->started = now;
3822
    }
3823

3824 3825
    if (qemuDomainTrackJob(job))
        qemuDomainObjSaveJob(driver, obj);
3826

3827
    virObjectUnref(cfg);
3828
    return 0;
3829

3830
 error:
J
Jiri Denemark 已提交
3831 3832 3833 3834 3835 3836
    ignore_value(virTimeMillisNow(&now));
    if (priv->job.active && priv->job.started)
        duration = now - priv->job.started;
    if (priv->job.asyncJob && priv->job.asyncStarted)
        asyncDuration = now - priv->job.asyncStarted;

3837
    VIR_WARN("Cannot start job (%s, %s) for domain %s; "
J
Jiri Denemark 已提交
3838 3839
             "current job is (%s, %s) owned by (%llu %s, %llu %s) "
             "for (%llus, %llus)",
3840 3841 3842 3843 3844
             qemuDomainJobTypeToString(job),
             qemuDomainAsyncJobTypeToString(asyncJob),
             obj->def->name,
             qemuDomainJobTypeToString(priv->job.active),
             qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
3845
             priv->job.owner, NULLSTR(priv->job.ownerAPI),
J
Jiri Denemark 已提交
3846 3847
             priv->job.asyncOwner, NULLSTR(priv->job.asyncOwnerAPI),
             duration / 1000, asyncDuration / 1000);
3848 3849 3850 3851 3852

    if (nested || qemuDomainNestedJobAllowed(priv, job))
        blocker = priv->job.ownerAPI;
    else
        blocker = priv->job.asyncOwnerAPI;
3853

3854 3855
    ret = -1;
    if (errno == ETIMEDOUT) {
3856 3857 3858 3859 3860 3861 3862 3863
        if (blocker) {
            virReportError(VIR_ERR_OPERATION_TIMEOUT,
                           _("cannot acquire state change lock (held by %s)"),
                           blocker);
        } else {
            virReportError(VIR_ERR_OPERATION_TIMEOUT, "%s",
                           _("cannot acquire state change lock"));
        }
3864 3865 3866
        ret = -2;
    } else if (cfg->maxQueuedJobs &&
               priv->jobs_queued > cfg->maxQueuedJobs) {
3867 3868 3869 3870 3871 3872 3873 3874 3875 3876
        if (blocker) {
            virReportError(VIR_ERR_OPERATION_FAILED,
                           _("cannot acquire state change lock (held by %s) "
                             "due to max_queued limit"),
                           blocker);
        } else {
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("cannot acquire state change lock "
                             "due to max_queued limit"));
        }
3877 3878
        ret = -2;
    } else {
3879
        virReportSystemError(errno, "%s", _("cannot acquire job mutex"));
3880
    }
J
Jiri Denemark 已提交
3881 3882

 cleanup:
3883
    priv->jobs_queued--;
3884
    virObjectUnref(cfg);
3885
    return ret;
3886 3887 3888
}

/*
3889
 * obj must be locked before calling
3890 3891 3892 3893
 *
 * This must be called by anything that will change the VM state
 * in any way, or anything that will use the QEMU monitor.
 *
3894
 * Successful calls must be followed by EndJob eventually
3895
 */
3896
int qemuDomainObjBeginJob(virQEMUDriverPtr driver,
3897
                          virDomainObjPtr obj,
3898
                          qemuDomainJob job)
3899
{
3900 3901 3902 3903 3904
    if (qemuDomainObjBeginJobInternal(driver, obj, job,
                                      QEMU_ASYNC_JOB_NONE) < 0)
        return -1;
    else
        return 0;
3905 3906
}

3907
int qemuDomainObjBeginAsyncJob(virQEMUDriverPtr driver,
3908
                               virDomainObjPtr obj,
3909 3910
                               qemuDomainAsyncJob asyncJob,
                               virDomainJobOperation operation)
3911
{
3912 3913
    qemuDomainObjPrivatePtr priv;

3914 3915 3916
    if (qemuDomainObjBeginJobInternal(driver, obj, QEMU_JOB_ASYNC,
                                      asyncJob) < 0)
        return -1;
3917 3918 3919 3920

    priv = obj->privateData;
    priv->job.current->operation = operation;
    return 0;
3921 3922
}

3923
int
3924 3925
qemuDomainObjBeginNestedJob(virQEMUDriverPtr driver,
                            virDomainObjPtr obj,
3926
                            qemuDomainAsyncJob asyncJob)
3927 3928 3929 3930 3931 3932 3933 3934 3935 3936
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

    if (asyncJob != priv->job.asyncJob) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("unexpected async job %d"), asyncJob);
        return -1;
    }

    if (priv->job.asyncOwner != virThreadSelfID()) {
3937
        VIR_WARN("This thread doesn't seem to be the async job owner: %llu",
3938 3939 3940 3941 3942 3943 3944 3945
                 priv->job.asyncOwner);
    }

    return qemuDomainObjBeginJobInternal(driver, obj,
                                         QEMU_JOB_ASYNC_NESTED,
                                         QEMU_ASYNC_JOB_NONE);
}

3946

3947
/*
3948
 * obj must be locked and have a reference before calling
3949 3950 3951 3952
 *
 * To be called after completing the work associated with the
 * earlier qemuDomainBeginJob() call
 */
3953 3954
void
qemuDomainObjEndJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
3955 3956
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
3957
    qemuDomainJob job = priv->job.active;
3958

3959 3960
    priv->jobs_queued--;

3961
    VIR_DEBUG("Stopping job: %s (async=%s vm=%p name=%s)",
3962
              qemuDomainJobTypeToString(job),
3963 3964
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
              obj, obj->def->name);
3965

3966
    qemuDomainObjResetJob(priv);
3967 3968
    if (qemuDomainTrackJob(job))
        qemuDomainObjSaveJob(driver, obj);
3969
    virCondSignal(&priv->job.cond);
3970 3971
}

3972
void
3973
qemuDomainObjEndAsyncJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
3974 3975
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
3976

3977 3978
    priv->jobs_queued--;

3979 3980 3981
    VIR_DEBUG("Stopping async job: %s (vm=%p name=%s)",
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
              obj, obj->def->name);
3982

3983
    qemuDomainObjResetAsyncJob(priv);
3984
    qemuDomainObjSaveJob(driver, obj);
3985 3986 3987
    virCondBroadcast(&priv->job.asyncCond);
}

3988 3989 3990 3991 3992
void
qemuDomainObjAbortAsyncJob(virDomainObjPtr obj)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

3993 3994 3995
    VIR_DEBUG("Requesting abort of async job: %s (vm=%p name=%s)",
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
              obj, obj->def->name);
3996

3997 3998
    priv->job.abortJob = true;
    virDomainObjBroadcast(obj);
3999 4000
}

4001 4002 4003 4004 4005 4006 4007 4008 4009
/*
 * obj must be locked before calling
 *
 * To be called immediately before any QEMU monitor API call
 * Must have already either called qemuDomainObjBeginJob() and checked
 * that the VM is still active; may not be used for nested async jobs.
 *
 * To be followed with qemuDomainObjExitMonitor() once complete
 */
4010
static int
4011
qemuDomainObjEnterMonitorInternal(virQEMUDriverPtr driver,
4012
                                  virDomainObjPtr obj,
4013
                                  qemuDomainAsyncJob asyncJob)
4014 4015 4016
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

4017
    if (asyncJob != QEMU_ASYNC_JOB_NONE) {
4018 4019 4020
        int ret;
        if ((ret = qemuDomainObjBeginNestedJob(driver, obj, asyncJob)) < 0)
            return ret;
4021
        if (!virDomainObjIsActive(obj)) {
4022 4023
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("domain is no longer running"));
4024
            qemuDomainObjEndJob(driver, obj);
4025 4026
            return -1;
        }
4027 4028 4029
    } else if (priv->job.asyncOwner == virThreadSelfID()) {
        VIR_WARN("This thread seems to be the async job owner; entering"
                 " monitor without asking for a nested job is dangerous");
4030 4031
    }

4032 4033
    VIR_DEBUG("Entering monitor (mon=%p vm=%p name=%s)",
              priv->mon, obj, obj->def->name);
4034
    virObjectLock(priv->mon);
4035
    virObjectRef(priv->mon);
4036
    ignore_value(virTimeMillisNow(&priv->monStart));
4037
    virObjectUnlock(obj);
4038 4039

    return 0;
4040 4041
}

4042
static void ATTRIBUTE_NONNULL(1)
4043
qemuDomainObjExitMonitorInternal(virQEMUDriverPtr driver,
4044
                                 virDomainObjPtr obj)
4045 4046
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
4047
    bool hasRefs;
4048

4049
    hasRefs = virObjectUnref(priv->mon);
4050

4051
    if (hasRefs)
4052
        virObjectUnlock(priv->mon);
4053

4054
    virObjectLock(obj);
4055 4056
    VIR_DEBUG("Exited monitor (mon=%p vm=%p name=%s)",
              priv->mon, obj, obj->def->name);
4057

4058
    priv->monStart = 0;
4059
    if (!hasRefs)
4060
        priv->mon = NULL;
4061

J
Jiri Denemark 已提交
4062 4063
    if (priv->job.active == QEMU_JOB_ASYNC_NESTED)
        qemuDomainObjEndJob(driver, obj);
4064 4065
}

4066
void qemuDomainObjEnterMonitor(virQEMUDriverPtr driver,
4067
                               virDomainObjPtr obj)
4068
{
4069
    ignore_value(qemuDomainObjEnterMonitorInternal(driver, obj,
4070
                                                   QEMU_ASYNC_JOB_NONE));
4071 4072
}

4073
/* obj must NOT be locked before calling
4074 4075
 *
 * Should be paired with an earlier qemuDomainObjEnterMonitor() call
4076 4077 4078 4079 4080 4081
 *
 * Returns -1 if the domain is no longer alive after exiting the monitor.
 * In that case, the caller should be careful when using obj's data,
 * e.g. the live definition in vm->def has been freed by qemuProcessStop
 * and replaced by the persistent definition, so pointers stolen
 * from the live definition could no longer be valid.
4082
 */
4083 4084
int qemuDomainObjExitMonitor(virQEMUDriverPtr driver,
                             virDomainObjPtr obj)
4085
{
4086
    qemuDomainObjExitMonitorInternal(driver, obj);
4087
    if (!virDomainObjIsActive(obj)) {
4088 4089 4090
        if (!virGetLastError())
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("domain is no longer running"));
4091 4092 4093
        return -1;
    }
    return 0;
4094
}
4095 4096

/*
4097
 * obj must be locked before calling
4098 4099
 *
 * To be called immediately before any QEMU monitor API call.
4100
 * Must have already either called qemuDomainObjBeginJob()
4101 4102 4103 4104 4105
 * and checked that the VM is still active, with asyncJob of
 * QEMU_ASYNC_JOB_NONE; or already called qemuDomainObjBeginAsyncJob,
 * with the same asyncJob.
 *
 * Returns 0 if job was started, in which case this must be followed with
4106 4107 4108
 * qemuDomainObjExitMonitor(); -2 if waiting for the nested job times out;
 * or -1 if the job could not be started (probably because the vm exited
 * in the meantime).
4109 4110
 */
int
4111
qemuDomainObjEnterMonitorAsync(virQEMUDriverPtr driver,
4112
                               virDomainObjPtr obj,
4113
                               qemuDomainAsyncJob asyncJob)
4114
{
4115
    return qemuDomainObjEnterMonitorInternal(driver, obj, asyncJob);
4116 4117
}

D
Daniel P. Berrange 已提交
4118

4119 4120 4121 4122 4123 4124 4125 4126 4127
/*
 * obj must be locked before calling
 *
 * To be called immediately before any QEMU agent API call.
 * Must have already called qemuDomainObjBeginJob() and checked
 * that the VM is still active.
 *
 * To be followed with qemuDomainObjExitAgent() once complete
 */
4128
qemuAgentPtr
4129
qemuDomainObjEnterAgent(virDomainObjPtr obj)
D
Daniel P. Berrange 已提交
4130 4131
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
4132
    qemuAgentPtr agent = priv->agent;
D
Daniel P. Berrange 已提交
4133

4134 4135
    VIR_DEBUG("Entering agent (agent=%p vm=%p name=%s)",
              priv->agent, obj, obj->def->name);
4136 4137 4138

    virObjectLock(agent);
    virObjectRef(agent);
4139
    virObjectUnlock(obj);
4140 4141

    return agent;
D
Daniel P. Berrange 已提交
4142 4143
}

4144 4145 4146 4147 4148 4149

/* obj must NOT be locked before calling
 *
 * Should be paired with an earlier qemuDomainObjEnterAgent() call
 */
void
4150
qemuDomainObjExitAgent(virDomainObjPtr obj, qemuAgentPtr agent)
D
Daniel P. Berrange 已提交
4151
{
4152 4153
    virObjectUnlock(agent);
    virObjectUnref(agent);
4154
    virObjectLock(obj);
D
Daniel P. Berrange 已提交
4155

4156 4157
    VIR_DEBUG("Exited agent (agent=%p vm=%p name=%s)",
              agent, obj, obj->def->name);
D
Daniel P. Berrange 已提交
4158 4159
}

4160
void qemuDomainObjEnterRemote(virDomainObjPtr obj)
4161
{
4162 4163
    VIR_DEBUG("Entering remote (vm=%p name=%s)",
              obj, obj->def->name);
4164
    virObjectUnlock(obj);
4165 4166
}

4167
void qemuDomainObjExitRemote(virDomainObjPtr obj)
4168
{
4169
    virObjectLock(obj);
4170 4171
    VIR_DEBUG("Exited remote (vm=%p name=%s)",
              obj, obj->def->name);
4172
}
4173 4174


4175 4176 4177 4178 4179 4180 4181 4182
virDomainDefPtr
qemuDomainDefCopy(virQEMUDriverPtr driver,
                  virDomainDefPtr src,
                  unsigned int flags)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    virDomainDefPtr ret = NULL;
    virCapsPtr caps = NULL;
4183
    char *xml = NULL;
4184 4185 4186 4187 4188 4189 4190 4191 4192

    if (qemuDomainDefFormatBuf(driver, src, flags, &buf) < 0)
        goto cleanup;

    xml = virBufferContentAndReset(&buf);

    if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
        goto cleanup;

4193
    if (!(ret = virDomainDefParseString(xml, caps, driver->xmlopt, NULL,
4194
                                        VIR_DOMAIN_DEF_PARSE_INACTIVE |
4195
                                        VIR_DOMAIN_DEF_PARSE_SKIP_VALIDATE)))
4196 4197
        goto cleanup;

4198
 cleanup:
4199 4200 4201 4202 4203
    VIR_FREE(xml);
    virObjectUnref(caps);
    return ret;
}

4204
int
4205
qemuDomainDefFormatBuf(virQEMUDriverPtr driver,
4206 4207 4208
                       virDomainDefPtr def,
                       unsigned int flags,
                       virBuffer *buf)
4209
{
4210
    int ret = -1;
4211
    virDomainDefPtr copy = NULL;
4212 4213 4214 4215
    virCapsPtr caps = NULL;

    if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
        goto cleanup;
4216

4217 4218 4219
    if (!(flags & (VIR_DOMAIN_XML_UPDATE_CPU | VIR_DOMAIN_XML_MIGRATABLE)))
        goto format;

4220
    if (!(copy = virDomainDefCopy(def, caps, driver->xmlopt, NULL,
4221 4222 4223 4224 4225
                                  flags & VIR_DOMAIN_XML_MIGRATABLE)))
        goto cleanup;

    def = copy;

4226
    /* Update guest CPU requirements according to host CPU */
4227
    if ((flags & VIR_DOMAIN_XML_UPDATE_CPU) &&
4228
        def->cpu &&
4229 4230
        (def->cpu->mode != VIR_CPU_MODE_CUSTOM ||
         def->cpu->model)) {
J
Jiri Denemark 已提交
4231
        if (virCPUUpdate(def->os.arch, def->cpu, caps->host.cpu) < 0)
4232 4233 4234
            goto cleanup;
    }

4235
    if ((flags & VIR_DOMAIN_XML_MIGRATABLE)) {
4236
        size_t i;
4237
        int toremove = 0;
4238
        virDomainControllerDefPtr usb = NULL, pci = NULL;
4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253

        /* If only the default USB controller is present, we can remove it
         * and make the XML compatible with older versions of libvirt which
         * didn't support USB controllers in the XML but always added the
         * default one to qemu anyway.
         */
        for (i = 0; i < def->ncontrollers; i++) {
            if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_USB) {
                if (usb) {
                    usb = NULL;
                    break;
                }
                usb = def->controllers[i];
            }
        }
4254 4255 4256 4257 4258 4259 4260 4261 4262

        /* In order to maintain compatibility with version of libvirt that
         * didn't support <controller type='usb'/> (<= 0.9.4), we need to
         * drop the default USB controller, ie. a USB controller at index
         * zero with no model or with the default piix3-ohci model.
         *
         * However, we only need to do so for x86 i440fx machine types,
         * because other architectures and machine types were introduced
         * when libvirt already supported <controller type='usb'/>.
4263
         */
4264
        if (ARCH_IS_X86(def->os.arch) && qemuDomainIsI440FX(def) &&
4265 4266 4267
            usb && usb->idx == 0 &&
            (usb->model == -1 ||
             usb->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX3_UHCI)) {
4268 4269
            VIR_DEBUG("Removing default USB controller from domain '%s'"
                      " for migration compatibility", def->name);
4270
            toremove++;
4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288
        } else {
            usb = NULL;
        }

        /* Remove the default PCI controller if there is only one present
         * and its model is pci-root */
        for (i = 0; i < def->ncontrollers; i++) {
            if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI) {
                if (pci) {
                    pci = NULL;
                    break;
                }
                pci = def->controllers[i];
            }
        }

        if (pci && pci->idx == 0 &&
            pci->model == VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT) {
L
Laine Stump 已提交
4289
            VIR_DEBUG("Removing default pci-root from domain '%s'"
4290
                      " for migration compatibility", def->name);
4291
            toremove++;
4292 4293 4294 4295
        } else {
            pci = NULL;
        }

4296
        if (toremove) {
4297 4298 4299
            virDomainControllerDefPtr *controllers = def->controllers;
            int ncontrollers = def->ncontrollers;

4300
            if (VIR_ALLOC_N(def->controllers, ncontrollers - toremove) < 0) {
4301
                def->controllers = controllers;
4302 4303 4304 4305 4306
                goto cleanup;
            }

            def->ncontrollers = 0;
            for (i = 0; i < ncontrollers; i++) {
4307
                if (controllers[i] != usb && controllers[i] != pci)
4308 4309
                    def->controllers[def->ncontrollers++] = controllers[i];
            }
4310 4311 4312 4313

            VIR_FREE(controllers);
            virDomainControllerDefFree(pci);
            virDomainControllerDefFree(usb);
4314
        }
4315

4316 4317 4318 4319 4320 4321 4322 4323 4324
        /* Remove the panic device for selected models if present */
        for (i = 0; i < def->npanics; i++) {
            if (def->panics[i]->model == VIR_DOMAIN_PANIC_MODEL_S390 ||
                def->panics[i]->model == VIR_DOMAIN_PANIC_MODEL_PSERIES) {
                VIR_DELETE_ELEMENT(def->panics, i, def->npanics);
                break;
            }
        }

4325 4326 4327 4328
        for (i = 0; i < def->nchannels; i++) {
            if (qemuDomainChrDefDropDefaultPath(def->channels[i], driver) < 0)
                goto cleanup;
        }
4329 4330
    }

4331 4332
 format:
    ret = virDomainDefFormatInternal(def, caps,
4333 4334
                                     virDomainDefFormatConvertXMLFlags(flags),
                                     buf);
4335

4336
 cleanup:
4337
    virDomainDefFree(copy);
4338
    virObjectUnref(caps);
4339 4340
    return ret;
}
4341

4342
char *qemuDomainDefFormatXML(virQEMUDriverPtr driver,
4343
                             virDomainDefPtr def,
4344
                             unsigned int flags)
4345 4346 4347
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

4348
    if (qemuDomainDefFormatBuf(driver, def, flags, &buf) < 0) {
4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361
        virBufferFreeAndReset(&buf);
        return NULL;
    }

    if (virBufferError(&buf)) {
        virReportOOMError();
        virBufferFreeAndReset(&buf);
        return NULL;
    }

    return virBufferContentAndReset(&buf);
}

4362
char *qemuDomainFormatXML(virQEMUDriverPtr driver,
4363
                          virDomainObjPtr vm,
4364
                          unsigned int flags)
4365 4366 4367
{
    virDomainDefPtr def;

4368
    if ((flags & VIR_DOMAIN_XML_INACTIVE) && vm->newDef) {
4369
        def = vm->newDef;
4370
    } else {
4371
        def = vm->def;
4372 4373 4374
        if (virDomainObjIsActive(vm))
            flags &= ~VIR_DOMAIN_XML_UPDATE_CPU;
    }
4375

4376
    return qemuDomainDefFormatXML(driver, def, flags);
4377 4378
}

4379
char *
4380
qemuDomainDefFormatLive(virQEMUDriverPtr driver,
4381
                        virDomainDefPtr def,
4382 4383
                        bool inactive,
                        bool compatible)
4384 4385 4386 4387 4388
{
    unsigned int flags = QEMU_DOMAIN_FORMAT_LIVE_FLAGS;

    if (inactive)
        flags |= VIR_DOMAIN_XML_INACTIVE;
4389 4390
    if (compatible)
        flags |= VIR_DOMAIN_XML_MIGRATABLE;
4391

4392
    return qemuDomainDefFormatXML(driver, def, flags);
4393 4394
}

4395

4396
void qemuDomainObjTaint(virQEMUDriverPtr driver,
4397
                        virDomainObjPtr obj,
4398
                        virDomainTaintFlags taint,
4399
                        qemuDomainLogContextPtr logCtxt)
4400
{
4401
    virErrorPtr orig_err = NULL;
4402
    bool closeLog = false;
4403 4404
    char *timestamp = NULL;
    char uuidstr[VIR_UUID_STRING_BUFLEN];
4405

4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420
    if (!virDomainObjTaint(obj, taint))
        return;

    virUUIDFormat(obj->def->uuid, uuidstr);

    VIR_WARN("Domain id=%d name='%s' uuid=%s is tainted: %s",
             obj->def->id,
             obj->def->name,
             uuidstr,
             virDomainTaintTypeToString(taint));

    /* We don't care about errors logging taint info, so
     * preserve original error, and clear any error that
     * is raised */
    orig_err = virSaveLastError();
4421

4422 4423 4424 4425 4426 4427 4428 4429 4430
    if (!(timestamp = virTimeStringNow()))
        goto cleanup;

    if (logCtxt == NULL) {
        logCtxt = qemuDomainLogContextNew(driver, obj,
                                          QEMU_DOMAIN_LOG_CONTEXT_MODE_ATTACH);
        if (!logCtxt) {
            VIR_WARN("Unable to open domainlog");
            goto cleanup;
4431
        }
4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444
        closeLog = true;
    }

    if (qemuDomainLogContextWrite(logCtxt,
                                  "%s: Domain id=%d is tainted: %s\n",
                                  timestamp,
                                  obj->def->id,
                                  virDomainTaintTypeToString(taint)) < 0)
        virResetLastError();

 cleanup:
    VIR_FREE(timestamp);
    if (closeLog)
4445
        virObjectUnref(logCtxt);
4446 4447 4448
    if (orig_err) {
        virSetError(orig_err);
        virFreeError(orig_err);
4449 4450 4451 4452
    }
}


4453
void qemuDomainObjCheckTaint(virQEMUDriverPtr driver,
4454
                             virDomainObjPtr obj,
4455
                             qemuDomainLogContextPtr logCtxt)
4456
{
4457
    size_t i;
4458
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
4459
    qemuDomainObjPrivatePtr priv = obj->privateData;
4460

4461
    if (virQEMUDriverIsPrivileged(driver) &&
4462 4463 4464
        (!cfg->clearEmulatorCapabilities ||
         cfg->user == 0 ||
         cfg->group == 0))
4465
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HIGH_PRIVILEGES, logCtxt);
4466

4467
    if (priv->hookRun)
4468
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HOOK, logCtxt);
4469

4470 4471 4472
    if (obj->def->namespaceData) {
        qemuDomainCmdlineDefPtr qemucmd = obj->def->namespaceData;
        if (qemucmd->num_args || qemucmd->num_env)
4473
            qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_CUSTOM_ARGV, logCtxt);
4474 4475
    }

4476
    if (obj->def->cpu && obj->def->cpu->mode == VIR_CPU_MODE_HOST_PASSTHROUGH)
4477
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HOST_CPU, logCtxt);
4478

4479
    for (i = 0; i < obj->def->ndisks; i++)
4480
        qemuDomainObjCheckDiskTaint(driver, obj, obj->def->disks[i], logCtxt);
4481

4482 4483
    for (i = 0; i < obj->def->nhostdevs; i++)
        qemuDomainObjCheckHostdevTaint(driver, obj, obj->def->hostdevs[i],
4484
                                       logCtxt);
4485

4486
    for (i = 0; i < obj->def->nnets; i++)
4487
        qemuDomainObjCheckNetTaint(driver, obj, obj->def->nets[i], logCtxt);
4488

4489
    if (obj->def->os.dtb)
4490
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_CUSTOM_DTB, logCtxt);
4491

4492
    virObjectUnref(cfg);
4493 4494 4495
}


4496
void qemuDomainObjCheckDiskTaint(virQEMUDriverPtr driver,
4497
                                 virDomainObjPtr obj,
4498
                                 virDomainDiskDefPtr disk,
4499
                                 qemuDomainLogContextPtr logCtxt)
4500
{
4501
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
4502
    int format = virDomainDiskGetFormat(disk);
4503

4504
    if ((!format || format == VIR_STORAGE_FILE_AUTO) &&
4505
        cfg->allowDiskFormatProbing)
4506
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_DISK_PROBING, logCtxt);
4507

4508 4509
    if (disk->rawio == VIR_TRISTATE_BOOL_YES)
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HIGH_PRIVILEGES,
4510
                           logCtxt);
4511

4512 4513 4514 4515
    if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM &&
        virStorageSourceGetActualType(disk->src) == VIR_STORAGE_TYPE_BLOCK &&
        disk->src->path)
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_CDROM_PASSTHROUGH,
4516
                           logCtxt);
4517

4518
    virObjectUnref(cfg);
4519 4520 4521
}


4522 4523 4524
void qemuDomainObjCheckHostdevTaint(virQEMUDriverPtr driver,
                                    virDomainObjPtr obj,
                                    virDomainHostdevDefPtr hostdev,
4525
                                    qemuDomainLogContextPtr logCtxt)
4526
{
4527
    if (!virHostdevIsSCSIDevice(hostdev))
4528
        return;
4529

4530 4531
    if (hostdev->source.subsys.u.scsi.rawio == VIR_TRISTATE_BOOL_YES)
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HIGH_PRIVILEGES, logCtxt);
4532 4533 4534
}


4535
void qemuDomainObjCheckNetTaint(virQEMUDriverPtr driver,
4536
                                virDomainObjPtr obj,
4537
                                virDomainNetDefPtr net,
4538
                                qemuDomainLogContextPtr logCtxt)
4539
{
4540 4541 4542 4543 4544 4545
    /* script is only useful for NET_TYPE_ETHERNET (qemu) and
     * NET_TYPE_BRIDGE (xen), but could be (incorrectly) specified for
     * any interface type. In any case, it's adding user sauce into
     * the soup, so it should taint the domain.
     */
    if (net->script != NULL)
4546
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_SHELL_SCRIPTS, logCtxt);
4547
}
4548 4549


4550 4551 4552 4553 4554 4555 4556
qemuDomainLogContextPtr qemuDomainLogContextNew(virQEMUDriverPtr driver,
                                                virDomainObjPtr vm,
                                                qemuDomainLogContextMode mode)
{
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    qemuDomainLogContextPtr ctxt = NULL;

4557 4558 4559 4560 4561
    if (qemuDomainLogContextInitialize() < 0)
        goto cleanup;

    if (!(ctxt = virObjectNew(qemuDomainLogContextClass)))
        goto cleanup;
4562

4563
    VIR_DEBUG("Context new %p stdioLogD=%d", ctxt, cfg->stdioLogD);
4564 4565 4566
    ctxt->writefd = -1;
    ctxt->readfd = -1;

4567 4568 4569
    if (virAsprintf(&ctxt->path, "%s/%s.log", cfg->logDir, vm->def->name) < 0)
        goto error;

4570 4571 4572 4573
    if (cfg->stdioLogD) {
        ctxt->manager = virLogManagerNew(virQEMUDriverIsPrivileged(driver));
        if (!ctxt->manager)
            goto error;
4574

4575 4576 4577 4578
        ctxt->writefd = virLogManagerDomainOpenLogFile(ctxt->manager,
                                                       "qemu",
                                                       vm->def->uuid,
                                                       vm->def->name,
4579
                                                       ctxt->path,
4580 4581 4582 4583 4584 4585
                                                       0,
                                                       &ctxt->inode,
                                                       &ctxt->pos);
        if (ctxt->writefd < 0)
            goto error;
    } else {
4586
        if ((ctxt->writefd = open(ctxt->path, O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR)) < 0) {
4587
            virReportSystemError(errno, _("failed to create logfile %s"),
4588
                                 ctxt->path);
4589 4590
            goto error;
        }
4591
        if (virSetCloseExec(ctxt->writefd) < 0) {
4592
            virReportSystemError(errno, _("failed to set close-on-exec flag on %s"),
4593
                                 ctxt->path);
4594 4595 4596
            goto error;
        }

4597 4598 4599 4600 4601 4602 4603
        /* For unprivileged startup we must truncate the file since
         * we can't rely on logrotate. We don't use O_TRUNC since
         * it is better for SELinux policy if we truncate afterwards */
        if (mode == QEMU_DOMAIN_LOG_CONTEXT_MODE_START &&
            !virQEMUDriverIsPrivileged(driver) &&
            ftruncate(ctxt->writefd, 0) < 0) {
            virReportSystemError(errno, _("failed to truncate %s"),
4604
                                 ctxt->path);
4605 4606 4607 4608
            goto error;
        }

        if (mode == QEMU_DOMAIN_LOG_CONTEXT_MODE_START) {
4609
            if ((ctxt->readfd = open(ctxt->path, O_RDONLY, S_IRUSR | S_IWUSR)) < 0) {
4610
                virReportSystemError(errno, _("failed to open logfile %s"),
4611
                                     ctxt->path);
4612 4613 4614 4615
                goto error;
            }
            if (virSetCloseExec(ctxt->readfd) < 0) {
                virReportSystemError(errno, _("failed to set close-on-exec flag on %s"),
4616
                                     ctxt->path);
4617 4618 4619 4620
                goto error;
            }
        }

4621 4622
        if ((ctxt->pos = lseek(ctxt->writefd, 0, SEEK_END)) < 0) {
            virReportSystemError(errno, _("failed to seek in log file %s"),
4623
                                 ctxt->path);
4624 4625 4626 4627
            goto error;
        }
    }

4628
 cleanup:
4629 4630 4631 4632
    virObjectUnref(cfg);
    return ctxt;

 error:
4633
    virObjectUnref(ctxt);
4634 4635
    ctxt = NULL;
    goto cleanup;
4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649
}


int qemuDomainLogContextWrite(qemuDomainLogContextPtr ctxt,
                              const char *fmt, ...)
{
    va_list argptr;
    char *message = NULL;
    int ret = -1;

    va_start(argptr, fmt);

    if (virVasprintf(&message, fmt, argptr) < 0)
        goto cleanup;
4650 4651
    if (!ctxt->manager &&
        lseek(ctxt->writefd, 0, SEEK_END) < 0) {
4652
        virReportSystemError(errno, "%s",
4653
                             _("Unable to seek to end of domain logfile"));
4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673
        goto cleanup;
    }
    if (safewrite(ctxt->writefd, message, strlen(message)) < 0) {
        virReportSystemError(errno, "%s",
                             _("Unable to write to domain logfile"));
        goto cleanup;
    }

    ret = 0;

 cleanup:
    va_end(argptr);
    VIR_FREE(message);
    return ret;
}


ssize_t qemuDomainLogContextRead(qemuDomainLogContextPtr ctxt,
                                 char **msg)
{
4674 4675 4676 4677
    VIR_DEBUG("Context read %p manager=%p inode=%llu pos=%llu",
              ctxt, ctxt->manager,
              (unsigned long long)ctxt->inode,
              (unsigned long long)ctxt->pos);
4678
    char *buf;
4679 4680 4681
    size_t buflen;
    if (ctxt->manager) {
        buf = virLogManagerDomainReadLogFile(ctxt->manager,
4682
                                             ctxt->path,
4683 4684 4685 4686 4687 4688 4689 4690 4691
                                             ctxt->inode,
                                             ctxt->pos,
                                             1024 * 128,
                                             0);
        if (!buf)
            return -1;
        buflen = strlen(buf);
    } else {
        ssize_t got;
4692

4693
        buflen = 1024 * 128;
4694

4695 4696
        /* Best effort jump to start of messages */
        ignore_value(lseek(ctxt->readfd, ctxt->pos, SEEK_SET));
4697

4698 4699
        if (VIR_ALLOC_N(buf, buflen) < 0)
            return -1;
4700

4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713
        got = saferead(ctxt->readfd, buf, buflen - 1);
        if (got < 0) {
            VIR_FREE(buf);
            virReportSystemError(errno, "%s",
                                 _("Unable to read from log file"));
            return -1;
        }

        buf[got] = '\0';

        ignore_value(VIR_REALLOC_N_QUIET(buf, got + 1));
        buflen = got;
    }
4714 4715 4716

    *msg = buf;

4717
    return buflen;
4718 4719 4720
}


4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782
/**
 * qemuDomainLogAppendMessage:
 *
 * This is a best-effort attempt to add a log message to the qemu log file
 * either by using virtlogd or the legacy approach */
int
qemuDomainLogAppendMessage(virQEMUDriverPtr driver,
                           virDomainObjPtr vm,
                           const char *fmt,
                           ...)
{
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    virLogManagerPtr manager = NULL;
    va_list ap;
    char *path = NULL;
    int writefd = -1;
    char *message = NULL;
    int ret = -1;

    va_start(ap, fmt);

    if (virVasprintf(&message, fmt, ap) < 0)
        goto cleanup;

    VIR_DEBUG("Append log message (vm='%s' message='%s) stdioLogD=%d",
              vm->def->name, message, cfg->stdioLogD);

    if (virAsprintf(&path, "%s/%s.log", cfg->logDir, vm->def->name) < 0)
        goto cleanup;

    if (cfg->stdioLogD) {
        if (!(manager = virLogManagerNew(virQEMUDriverIsPrivileged(driver))))
            goto cleanup;

        if (virLogManagerDomainAppendMessage(manager, "qemu", vm->def->uuid,
                                             vm->def->name, path, message, 0) < 0)
            goto cleanup;
    } else {
        if ((writefd = open(path, O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR)) < 0) {
            virReportSystemError(errno, _("failed to create logfile %s"),
                                 path);
            goto cleanup;
        }

        if (safewrite(writefd, message, strlen(message)) < 0)
            goto cleanup;
    }

    ret = 0;

 cleanup:
    va_end(ap);
    VIR_FREE(message);
    VIR_FORCE_CLOSE(writefd);
    virLogManagerFree(manager);
    virObjectUnref(cfg);
    VIR_FREE(path);

    return ret;
}


4783 4784 4785 4786 4787 4788 4789 4790
int qemuDomainLogContextGetWriteFD(qemuDomainLogContextPtr ctxt)
{
    return ctxt->writefd;
}


void qemuDomainLogContextMarkPosition(qemuDomainLogContextPtr ctxt)
{
4791 4792
    if (ctxt->manager)
        virLogManagerDomainGetLogFilePosition(ctxt->manager,
4793
                                              ctxt->path,
4794 4795 4796 4797 4798
                                              0,
                                              &ctxt->inode,
                                              &ctxt->pos);
    else
        ctxt->pos = lseek(ctxt->writefd, 0, SEEK_END);
4799 4800 4801
}


4802 4803 4804 4805 4806 4807
virLogManagerPtr qemuDomainLogContextGetManager(qemuDomainLogContextPtr ctxt)
{
    return ctxt->manager;
}


4808 4809
/* Locate an appropriate 'qemu-img' binary.  */
const char *
4810
qemuFindQemuImgBinary(virQEMUDriverPtr driver)
4811
{
4812 4813
    if (!driver->qemuImgBinary)
        virReportError(VIR_ERR_INTERNAL_ERROR,
4814
                       "%s", _("unable to find qemu-img"));
4815 4816 4817 4818 4819 4820 4821

    return driver->qemuImgBinary;
}

int
qemuDomainSnapshotWriteMetadata(virDomainObjPtr vm,
                                virDomainSnapshotObjPtr snapshot,
4822
                                virCapsPtr caps,
4823 4824 4825 4826 4827 4828 4829 4830 4831
                                char *snapshotDir)
{
    char *newxml = NULL;
    int ret = -1;
    char *snapDir = NULL;
    char *snapFile = NULL;
    char uuidstr[VIR_UUID_STRING_BUFLEN];

    virUUIDFormat(vm->def->uuid, uuidstr);
4832
    newxml = virDomainSnapshotDefFormat(
4833
        uuidstr, snapshot->def, caps,
4834 4835
        virDomainDefFormatConvertXMLFlags(QEMU_DOMAIN_FORMAT_LIVE_FLAGS),
        1);
4836
    if (newxml == NULL)
4837 4838
        return -1;

4839
    if (virAsprintf(&snapDir, "%s/%s", snapshotDir, vm->def->name) < 0)
4840 4841 4842 4843 4844 4845 4846
        goto cleanup;
    if (virFileMakePath(snapDir) < 0) {
        virReportSystemError(errno, _("cannot create snapshot directory '%s'"),
                             snapDir);
        goto cleanup;
    }

4847
    if (virAsprintf(&snapFile, "%s/%s.xml", snapDir, snapshot->def->name) < 0)
4848 4849
        goto cleanup;

J
Ján Tomko 已提交
4850
    ret = virXMLSaveFile(snapFile, NULL, "snapshot-edit", newxml);
4851

4852
 cleanup:
4853 4854 4855 4856 4857 4858 4859 4860
    VIR_FREE(snapFile);
    VIR_FREE(snapDir);
    VIR_FREE(newxml);
    return ret;
}

/* The domain is expected to be locked and inactive. Return -1 on normal
 * failure, 1 if we skipped a disk due to try_all.  */
4861
static int
4862
qemuDomainSnapshotForEachQcow2Raw(virQEMUDriverPtr driver,
4863 4864 4865 4866 4867
                                  virDomainDefPtr def,
                                  const char *name,
                                  const char *op,
                                  bool try_all,
                                  int ndisks)
4868 4869
{
    const char *qemuimgarg[] = { NULL, "snapshot", NULL, NULL, NULL, NULL };
4870
    size_t i;
4871 4872 4873 4874 4875 4876 4877 4878 4879
    bool skipped = false;

    qemuimgarg[0] = qemuFindQemuImgBinary(driver);
    if (qemuimgarg[0] == NULL) {
        /* qemuFindQemuImgBinary set the error */
        return -1;
    }

    qemuimgarg[2] = op;
4880
    qemuimgarg[3] = name;
4881

4882
    for (i = 0; i < ndisks; i++) {
4883
        /* FIXME: we also need to handle LVM here */
4884
        if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
4885 4886 4887
            int format = virDomainDiskGetFormat(def->disks[i]);

            if (format > 0 && format != VIR_STORAGE_FILE_QCOW2) {
4888 4889 4890 4891 4892
                if (try_all) {
                    /* Continue on even in the face of error, since other
                     * disks in this VM may have the same snapshot name.
                     */
                    VIR_WARN("skipping snapshot action on %s",
4893
                             def->disks[i]->dst);
4894 4895
                    skipped = true;
                    continue;
4896 4897 4898 4899 4900
                } else if (STREQ(op, "-c") && i) {
                    /* We must roll back partial creation by deleting
                     * all earlier snapshots.  */
                    qemuDomainSnapshotForEachQcow2Raw(driver, def, name,
                                                      "-d", false, i);
4901
                }
4902 4903 4904 4905
                virReportError(VIR_ERR_OPERATION_INVALID,
                               _("Disk device '%s' does not support"
                                 " snapshotting"),
                               def->disks[i]->dst);
4906 4907 4908
                return -1;
            }

4909
            qemuimgarg[4] = virDomainDiskGetSource(def->disks[i]);
4910 4911 4912 4913

            if (virRun(qemuimgarg, NULL) < 0) {
                if (try_all) {
                    VIR_WARN("skipping snapshot action on %s",
4914
                             def->disks[i]->dst);
4915 4916
                    skipped = true;
                    continue;
4917 4918 4919 4920 4921
                } else if (STREQ(op, "-c") && i) {
                    /* We must roll back partial creation by deleting
                     * all earlier snapshots.  */
                    qemuDomainSnapshotForEachQcow2Raw(driver, def, name,
                                                      "-d", false, i);
4922 4923 4924 4925 4926 4927 4928 4929 4930
                }
                return -1;
            }
        }
    }

    return skipped ? 1 : 0;
}

4931 4932 4933
/* The domain is expected to be locked and inactive. Return -1 on normal
 * failure, 1 if we skipped a disk due to try_all.  */
int
4934
qemuDomainSnapshotForEachQcow2(virQEMUDriverPtr driver,
4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950
                               virDomainObjPtr vm,
                               virDomainSnapshotObjPtr snap,
                               const char *op,
                               bool try_all)
{
    /* Prefer action on the disks in use at the time the snapshot was
     * created; but fall back to current definition if dealing with a
     * snapshot created prior to libvirt 0.9.5.  */
    virDomainDefPtr def = snap->def->dom;

    if (!def)
        def = vm->def;
    return qemuDomainSnapshotForEachQcow2Raw(driver, def, snap->def->name,
                                             op, try_all, def->ndisks);
}

4951 4952
/* Discard one snapshot (or its metadata), without reparenting any children.  */
int
4953
qemuDomainSnapshotDiscard(virQEMUDriverPtr driver,
4954 4955 4956 4957 4958 4959 4960 4961 4962
                          virDomainObjPtr vm,
                          virDomainSnapshotObjPtr snap,
                          bool update_current,
                          bool metadata_only)
{
    char *snapFile = NULL;
    int ret = -1;
    qemuDomainObjPrivatePtr priv;
    virDomainSnapshotObjPtr parentsnap = NULL;
4963
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
4964 4965 4966 4967 4968 4969 4970 4971 4972

    if (!metadata_only) {
        if (!virDomainObjIsActive(vm)) {
            /* Ignore any skipped disks */
            if (qemuDomainSnapshotForEachQcow2(driver, vm, snap, "-d",
                                               true) < 0)
                goto cleanup;
        } else {
            priv = vm->privateData;
4973
            qemuDomainObjEnterMonitor(driver, vm);
4974 4975
            /* we continue on even in the face of error */
            qemuMonitorDeleteSnapshot(priv->mon, snap->def->name);
4976
            ignore_value(qemuDomainObjExitMonitor(driver, vm));
4977 4978 4979
        }
    }

4980
    if (virAsprintf(&snapFile, "%s/%s/%s.xml", cfg->snapshotDir,
4981
                    vm->def->name, snap->def->name) < 0)
4982 4983 4984 4985
        goto cleanup;

    if (snap == vm->current_snapshot) {
        if (update_current && snap->def->parent) {
4986
            parentsnap = virDomainSnapshotFindByName(vm->snapshots,
4987 4988 4989 4990 4991 4992
                                                     snap->def->parent);
            if (!parentsnap) {
                VIR_WARN("missing parent snapshot matching name '%s'",
                         snap->def->parent);
            } else {
                parentsnap->def->current = true;
4993
                if (qemuDomainSnapshotWriteMetadata(vm, parentsnap, driver->caps,
4994
                                                    cfg->snapshotDir) < 0) {
4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006
                    VIR_WARN("failed to set parent snapshot '%s' as current",
                             snap->def->parent);
                    parentsnap->def->current = false;
                    parentsnap = NULL;
                }
            }
        }
        vm->current_snapshot = parentsnap;
    }

    if (unlink(snapFile) < 0)
        VIR_WARN("Failed to unlink %s", snapFile);
5007
    virDomainSnapshotObjListRemove(vm->snapshots, snap);
5008 5009 5010

    ret = 0;

5011
 cleanup:
5012
    VIR_FREE(snapFile);
5013
    virObjectUnref(cfg);
5014 5015 5016 5017
    return ret;
}

/* Hash iterator callback to discard multiple snapshots.  */
5018 5019 5020
int qemuDomainSnapshotDiscardAll(void *payload,
                                 const void *name ATTRIBUTE_UNUSED,
                                 void *data)
5021 5022
{
    virDomainSnapshotObjPtr snap = payload;
5023
    virQEMUSnapRemovePtr curr = data;
5024 5025 5026 5027 5028 5029 5030 5031
    int err;

    if (snap->def->current)
        curr->current = true;
    err = qemuDomainSnapshotDiscard(curr->driver, curr->vm, snap, false,
                                    curr->metadata_only);
    if (err && !curr->err)
        curr->err = err;
5032
    return 0;
5033 5034 5035
}

int
5036
qemuDomainSnapshotDiscardAllMetadata(virQEMUDriverPtr driver,
5037 5038
                                     virDomainObjPtr vm)
{
5039
    virQEMUSnapRemove rem;
5040 5041 5042 5043 5044

    rem.driver = driver;
    rem.vm = vm;
    rem.metadata_only = true;
    rem.err = 0;
5045 5046
    virDomainSnapshotForEach(vm->snapshots, qemuDomainSnapshotDiscardAll,
                             &rem);
5047 5048 5049 5050 5051

    return rem.err;
}

/*
5052
 * The caller must hold a lock the vm.
5053 5054
 */
void
5055
qemuDomainRemoveInactive(virQEMUDriverPtr driver,
5056 5057
                         virDomainObjPtr vm)
{
5058
    bool haveJob = true;
5059
    char *snapDir;
5060 5061 5062 5063 5064 5065 5066 5067
    virQEMUDriverConfigPtr cfg;

    if (vm->persistent) {
        /* Short-circuit, we don't want to remove a persistent domain */
        return;
    }

    cfg = virQEMUDriverGetConfig(driver);
5068

5069 5070 5071
    if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
        haveJob = false;

5072 5073 5074 5075 5076
    /* Remove any snapshot metadata prior to removing the domain */
    if (qemuDomainSnapshotDiscardAllMetadata(driver, vm) < 0) {
        VIR_WARN("unable to remove all snapshots for domain %s",
                 vm->def->name);
    }
5077
    else if (virAsprintf(&snapDir, "%s/%s", cfg->snapshotDir,
5078 5079
                         vm->def->name) < 0) {
        VIR_WARN("unable to remove snapshot directory %s/%s",
5080
                 cfg->snapshotDir, vm->def->name);
5081 5082 5083 5084 5085
    } else {
        if (rmdir(snapDir) < 0 && errno != ENOENT)
            VIR_WARN("unable to remove snapshot directory %s", snapDir);
        VIR_FREE(snapDir);
    }
5086 5087 5088

    virObjectRef(vm);

5089
    virDomainObjListRemove(driver->domains, vm);
5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102
    /*
     * virDomainObjListRemove() leaves the domain unlocked so it can
     * be unref'd for other drivers that depend on that, but we still
     * need to reset a job and we have a reference from the API that
     * called this function.  So we need to lock it back.  This is
     * just a workaround for the qemu driver.
     *
     * XXX: Ideally, the global handling of domain objects and object
     *      lists would be refactored so we don't need hacks like
     *      this, but since that requires refactor of all drivers,
     *      it's a work for another day.
     */
    virObjectLock(vm);
5103
    virObjectUnref(cfg);
5104 5105

    if (haveJob)
5106
        qemuDomainObjEndJob(driver, vm);
5107 5108

    virObjectUnref(vm);
5109
}
5110 5111

void
5112
qemuDomainSetFakeReboot(virQEMUDriverPtr driver,
5113 5114 5115 5116
                        virDomainObjPtr vm,
                        bool value)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
5117
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
5118 5119

    if (priv->fakeReboot == value)
5120
        goto cleanup;
5121 5122 5123

    priv->fakeReboot = value;

5124
    if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, vm, driver->caps) < 0)
5125
        VIR_WARN("Failed to save status on vm %s", vm->def->name);
5126

5127
 cleanup:
5128
    virObjectUnref(cfg);
5129
}
M
Michal Privoznik 已提交
5130

5131
static void
5132 5133
qemuDomainCheckRemoveOptionalDisk(virQEMUDriverPtr driver,
                                  virDomainObjPtr vm,
5134
                                  size_t diskIndex)
5135 5136
{
    char uuid[VIR_UUID_STRING_BUFLEN];
5137
    virObjectEventPtr event = NULL;
5138
    virDomainDiskDefPtr disk = vm->def->disks[diskIndex];
5139
    const char *src = virDomainDiskGetSource(disk);
5140 5141 5142 5143 5144

    virUUIDFormat(vm->def->uuid, uuid);

    VIR_DEBUG("Dropping disk '%s' on domain '%s' (UUID '%s') "
              "due to inaccessible source '%s'",
5145
              disk->dst, vm->def->name, uuid, src);
5146 5147 5148 5149

    if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM ||
        disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY) {

5150
        event = virDomainEventDiskChangeNewFromObj(vm, src, NULL,
5151 5152
                                                   disk->info.alias,
                                                   VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START);
5153
        virDomainDiskEmptySource(disk);
5154 5155
        /* keeping the old startup policy would be invalid for new images */
        disk->startupPolicy = VIR_DOMAIN_STARTUP_POLICY_DEFAULT;
5156
    } else {
5157
        event = virDomainEventDiskChangeNewFromObj(vm, src, NULL,
5158 5159
                                                   disk->info.alias,
                                                   VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START);
5160 5161
        virDomainDiskRemove(vm->def, diskIndex);
        virDomainDiskDefFree(disk);
5162 5163
    }

5164
    qemuDomainEventQueue(driver, event);
5165 5166
}

5167 5168 5169
static int
qemuDomainCheckDiskStartupPolicy(virQEMUDriverPtr driver,
                                 virDomainObjPtr vm,
5170
                                 size_t diskIndex,
5171 5172
                                 bool cold_boot)
{
5173
    int startupPolicy = vm->def->disks[diskIndex]->startupPolicy;
5174
    int device = vm->def->disks[diskIndex]->device;
5175

5176
    switch ((virDomainStartupPolicy) startupPolicy) {
5177
        case VIR_DOMAIN_STARTUP_POLICY_OPTIONAL:
5178 5179 5180 5181 5182 5183
            /* Once started with an optional disk, qemu saves its section
             * in the migration stream, so later, when restoring from it
             * we must make sure the sections match. */
            if (!cold_boot &&
                device != VIR_DOMAIN_DISK_DEVICE_FLOPPY &&
                device != VIR_DOMAIN_DISK_DEVICE_CDROM)
5184
                return -1;
5185 5186
            break;

5187
        case VIR_DOMAIN_STARTUP_POLICY_DEFAULT:
5188
        case VIR_DOMAIN_STARTUP_POLICY_MANDATORY:
5189
            return -1;
5190 5191

        case VIR_DOMAIN_STARTUP_POLICY_REQUISITE:
5192
            if (cold_boot)
5193
                return -1;
5194 5195 5196 5197 5198 5199 5200
            break;

        case VIR_DOMAIN_STARTUP_POLICY_LAST:
            /* this should never happen */
            break;
    }

5201
    qemuDomainCheckRemoveOptionalDisk(driver, vm, diskIndex);
5202
    virResetLastError();
5203 5204 5205
    return 0;
}

5206

M
Michal Privoznik 已提交
5207
int
5208 5209
qemuDomainCheckDiskPresence(virConnectPtr conn,
                            virQEMUDriverPtr driver,
M
Michal Privoznik 已提交
5210
                            virDomainObjPtr vm,
5211
                            unsigned int flags)
M
Michal Privoznik 已提交
5212
{
5213
    size_t i;
5214 5215
    bool pretend = flags & VIR_QEMU_PROCESS_START_PRETEND;
    bool cold_boot = flags & VIR_QEMU_PROCESS_START_COLD;
M
Michal Privoznik 已提交
5216

5217
    VIR_DEBUG("Checking for disk presence");
5218
    for (i = vm->def->ndisks; i > 0; i--) {
5219 5220
        size_t idx = i - 1;
        virDomainDiskDefPtr disk = vm->def->disks[idx];
5221
        virStorageFileFormat format = virDomainDiskGetFormat(disk);
M
Michal Privoznik 已提交
5222

5223 5224 5225 5226 5227 5228 5229 5230 5231 5232
        if (virStorageTranslateDiskSourcePool(conn, vm->def->disks[idx]) < 0) {
            if (pretend ||
                qemuDomainCheckDiskStartupPolicy(driver, vm, idx, cold_boot) < 0)
                return -1;
            continue;
        }

        if (pretend)
            continue;

5233
        if (virStorageSourceIsEmpty(disk->src))
5234 5235 5236 5237 5238
            continue;

        /* There is no need to check the backing chain for disks
         * without backing support, the fact that the file exists is
         * more than enough */
5239
        if (virStorageSourceIsLocalStorage(disk->src) &&
5240
            format > VIR_STORAGE_FILE_NONE &&
5241
            format < VIR_STORAGE_FILE_BACKING &&
5242
            virFileExists(virDomainDiskGetSource(disk)))
M
Michal Privoznik 已提交
5243 5244
            continue;

5245
        if (qemuDomainDetermineDiskChain(driver, vm, disk, true, true) >= 0)
M
Michal Privoznik 已提交
5246
            continue;
5247

5248
        if (qemuDomainCheckDiskStartupPolicy(driver, vm, idx, cold_boot) >= 0)
5249
            continue;
M
Michal Privoznik 已提交
5250

5251
        return -1;
M
Michal Privoznik 已提交
5252 5253
    }

5254
    return 0;
M
Michal Privoznik 已提交
5255
}
5256 5257 5258 5259 5260 5261 5262 5263 5264 5265

/*
 * The vm must be locked when any of the following cleanup functions is
 * called.
 */
int
qemuDomainCleanupAdd(virDomainObjPtr vm,
                     qemuDomainCleanupCallback cb)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
5266
    size_t i;
5267 5268 5269 5270 5271 5272 5273 5274 5275 5276

    VIR_DEBUG("vm=%s, cb=%p", vm->def->name, cb);

    for (i = 0; i < priv->ncleanupCallbacks; i++) {
        if (priv->cleanupCallbacks[i] == cb)
            return 0;
    }

    if (VIR_RESIZE_N(priv->cleanupCallbacks,
                     priv->ncleanupCallbacks_max,
5277
                     priv->ncleanupCallbacks, 1) < 0)
5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288
        return -1;

    priv->cleanupCallbacks[priv->ncleanupCallbacks++] = cb;
    return 0;
}

void
qemuDomainCleanupRemove(virDomainObjPtr vm,
                        qemuDomainCleanupCallback cb)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
5289
    size_t i;
5290 5291 5292 5293

    VIR_DEBUG("vm=%s, cb=%p", vm->def->name, cb);

    for (i = 0; i < priv->ncleanupCallbacks; i++) {
5294 5295 5296
        if (priv->cleanupCallbacks[i] == cb)
            VIR_DELETE_ELEMENT_INPLACE(priv->cleanupCallbacks,
                                       i, priv->ncleanupCallbacks);
5297 5298 5299 5300 5301 5302 5303 5304
    }

    VIR_SHRINK_N(priv->cleanupCallbacks,
                 priv->ncleanupCallbacks_max,
                 priv->ncleanupCallbacks_max - priv->ncleanupCallbacks);
}

void
5305
qemuDomainCleanupRun(virQEMUDriverPtr driver,
5306 5307 5308
                     virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
5309
    size_t i;
5310 5311 5312 5313

    VIR_DEBUG("driver=%p, vm=%s", driver, vm->def->name);

    /* run cleanup callbacks in reverse order */
5314 5315
    for (i = 0; i < priv->ncleanupCallbacks; i++) {
        if (priv->cleanupCallbacks[priv->ncleanupCallbacks - (i + 1)])
5316 5317 5318 5319 5320 5321 5322
            priv->cleanupCallbacks[i](driver, vm);
    }

    VIR_FREE(priv->cleanupCallbacks);
    priv->ncleanupCallbacks = 0;
    priv->ncleanupCallbacks_max = 0;
}
5323

5324 5325 5326
static void
qemuDomainGetImageIds(virQEMUDriverConfigPtr cfg,
                      virDomainObjPtr vm,
5327
                      virStorageSourcePtr src,
5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345
                      uid_t *uid, gid_t *gid)
{
    virSecurityLabelDefPtr vmlabel;
    virSecurityDeviceLabelDefPtr disklabel;

    if (uid)
        *uid = -1;
    if (gid)
        *gid = -1;

    if (cfg) {
        if (uid)
            *uid = cfg->user;

        if (gid)
            *gid = cfg->group;
    }

5346 5347
    if (vm && (vmlabel = virDomainDefGetSecurityLabelDef(vm->def, "dac")) &&
        vmlabel->label)
5348 5349
        virParseOwnershipIds(vmlabel->label, uid, gid);

5350
    if ((disklabel = virStorageSourceGetSecurityLabelDef(src, "dac")) &&
5351
        disklabel->label)
5352 5353 5354 5355
        virParseOwnershipIds(disklabel->label, uid, gid);
}


5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378
int
qemuDomainStorageFileInit(virQEMUDriverPtr driver,
                          virDomainObjPtr vm,
                          virStorageSourcePtr src)
{
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    uid_t uid;
    gid_t gid;
    int ret = -1;

    qemuDomainGetImageIds(cfg, vm, src, &uid, &gid);

    if (virStorageFileInitAs(src, uid, gid) < 0)
        goto cleanup;

    ret = 0;

 cleanup:
    virObjectUnref(cfg);
    return ret;
}


5379 5380 5381 5382 5383
char *
qemuDomainStorageAlias(const char *device, int depth)
{
    char *alias;

5384
    device = qemuAliasDiskDriveSkipPrefix(device);
5385 5386 5387 5388 5389 5390 5391 5392 5393

    if (!depth)
        ignore_value(VIR_STRDUP(alias, device));
    else
        ignore_value(virAsprintf(&alias, "%s.%d", device, depth));
    return alias;
}


5394
int
5395
qemuDomainDetermineDiskChain(virQEMUDriverPtr driver,
5396
                             virDomainObjPtr vm,
5397
                             virDomainDiskDefPtr disk,
5398 5399
                             bool force_probe,
                             bool report_broken)
5400
{
5401 5402
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    int ret = 0;
5403 5404
    uid_t uid;
    gid_t gid;
5405

5406
    if (virStorageSourceIsEmpty(disk->src))
5407
        goto cleanup;
5408

5409
    if (disk->src->backingStore) {
5410
        if (force_probe)
5411
            virStorageSourceBackingStoreClear(disk->src);
5412
        else
5413
            goto cleanup;
5414
    }
5415

5416
    qemuDomainGetImageIds(cfg, vm, disk->src, &uid, &gid);
5417

5418
    if (virStorageFileGetMetadata(disk->src,
5419
                                  uid, gid,
5420
                                  cfg->allowDiskFormatProbing,
5421
                                  report_broken) < 0)
5422 5423
        ret = -1;

5424
 cleanup:
5425 5426
    virObjectUnref(cfg);
    return ret;
5427
}
5428

5429

5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440
/**
 * qemuDomainDiskChainElementRevoke:
 *
 * Revoke access to a single backing chain element. This restores the labels,
 * removes cgroup ACLs for devices and removes locks.
 */
void
qemuDomainDiskChainElementRevoke(virQEMUDriverPtr driver,
                                 virDomainObjPtr vm,
                                 virStorageSourcePtr elem)
{
5441 5442 5443 5444
    if (qemuTeardownImageCgroup(vm, elem) < 0)
        VIR_WARN("Failed to teardown cgroup for disk path %s",
                 NULLSTR(elem->path));

5445
    if (qemuSecurityRestoreImageLabel(driver, vm, elem) < 0)
5446 5447
        VIR_WARN("Unable to restore security label on %s", NULLSTR(elem->path));

5448 5449
    if (qemuDomainNamespaceTeardownDisk(driver, vm, elem) < 0)
        VIR_WARN("Unable to remove /dev entry for %s", NULLSTR(elem->path));
5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478

    if (virDomainLockImageDetach(driver->lockManager, vm, elem) < 0)
        VIR_WARN("Unable to release lock on %s", NULLSTR(elem->path));
}


/**
 * qemuDomainDiskChainElementPrepare:
 *
 * Allow a VM access to a single element of a disk backing chain; this helper
 * ensures that the lock manager, cgroup device controller, and security manager
 * labelling are all aware of each new file before it is added to a chain */
int
qemuDomainDiskChainElementPrepare(virQEMUDriverPtr driver,
                                  virDomainObjPtr vm,
                                  virStorageSourcePtr elem,
                                  bool readonly)
{
    bool was_readonly = elem->readonly;
    virQEMUDriverConfigPtr cfg = NULL;
    int ret = -1;

    cfg = virQEMUDriverGetConfig(driver);

    elem->readonly = readonly;

    if (virDomainLockImageAttach(driver->lockManager, cfg->uri, vm, elem) < 0)
        goto cleanup;

5479 5480 5481
    if (qemuDomainNamespaceSetupDisk(driver, vm, elem) < 0)
        goto cleanup;

5482 5483 5484
    if (qemuSetupImageCgroup(vm, elem) < 0)
        goto cleanup;

5485
    if (qemuSecuritySetImageLabel(driver, vm, elem) < 0)
5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496
        goto cleanup;

    ret = 0;

 cleanup:
    elem->readonly = was_readonly;
    virObjectUnref(cfg);
    return ret;
}


5497
bool
5498
qemuDomainDiskSourceDiffers(virDomainDiskDefPtr disk,
5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513
                            virDomainDiskDefPtr origDisk)
{
    char *diskSrc = NULL, *origDiskSrc = NULL;
    bool diskEmpty, origDiskEmpty;
    bool ret = true;

    diskEmpty = virStorageSourceIsEmpty(disk->src);
    origDiskEmpty = virStorageSourceIsEmpty(origDisk->src);

    if (diskEmpty && origDiskEmpty)
        return false;

    if (diskEmpty ^ origDiskEmpty)
        return true;

5514 5515 5516 5517
    /* This won't be a network storage, so no need to get the diskPriv
     * in order to fetch the secret, thus NULL for param2 */
    if (qemuGetDriveSourceString(disk->src, NULL, &diskSrc) < 0 ||
        qemuGetDriveSourceString(origDisk->src, NULL, &origDiskSrc) < 0)
5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530
        goto cleanup;

    /* So far in qemu disk sources are considered different
     * if either path to disk or its format changes. */
    ret = virDomainDiskGetFormat(disk) != virDomainDiskGetFormat(origDisk) ||
          STRNEQ_NULLABLE(diskSrc, origDiskSrc);
 cleanup:
    VIR_FREE(diskSrc);
    VIR_FREE(origDiskSrc);
    return ret;
}


5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553
/*
 * Makes sure the @disk differs from @orig_disk only by the source
 * path and nothing else.  Fields that are being checked and the
 * information whether they are nullable (may not be specified) or is
 * taken from the virDomainDiskDefFormat() code.
 */
bool
qemuDomainDiskChangeSupported(virDomainDiskDefPtr disk,
                              virDomainDiskDefPtr orig_disk)
{
#define CHECK_EQ(field, field_name, nullable)                           \
    do {                                                                \
        if (nullable && !disk->field)                                   \
            break;                                                      \
        if (disk->field != orig_disk->field) {                          \
            virReportError(VIR_ERR_OPERATION_UNSUPPORTED,               \
                           _("cannot modify field '%s' of the disk"),   \
                           field_name);                                 \
            return false;                                               \
        }                                                               \
    } while (0)

    CHECK_EQ(device, "device", false);
5554 5555 5556 5557
    CHECK_EQ(bus, "bus", false);
    if (STRNEQ(disk->dst, orig_disk->dst)) {
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("cannot modify field '%s' of the disk"),
5558
                       "target");
5559 5560 5561 5562
        return false;
    }
    CHECK_EQ(tray_status, "tray", true);
    CHECK_EQ(removable, "removable", true);
5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645

    if (disk->geometry.cylinders &&
        disk->geometry.heads &&
        disk->geometry.sectors) {
        CHECK_EQ(geometry.cylinders, "geometry cylinders", false);
        CHECK_EQ(geometry.heads, "geometry heads", false);
        CHECK_EQ(geometry.sectors, "geometry sectors", false);
        CHECK_EQ(geometry.trans, "BIOS-translation-modus", true);
    }

    CHECK_EQ(blockio.logical_block_size,
             "blockio logical_block_size", false);
    CHECK_EQ(blockio.physical_block_size,
             "blockio physical_block_size", false);

    CHECK_EQ(blkdeviotune.total_bytes_sec,
             "blkdeviotune total_bytes_sec",
             true);
    CHECK_EQ(blkdeviotune.read_bytes_sec,
             "blkdeviotune read_bytes_sec",
             true);
    CHECK_EQ(blkdeviotune.write_bytes_sec,
             "blkdeviotune write_bytes_sec",
             true);
    CHECK_EQ(blkdeviotune.total_iops_sec,
             "blkdeviotune total_iops_sec",
             true);
    CHECK_EQ(blkdeviotune.read_iops_sec,
             "blkdeviotune read_iops_sec",
             true);
    CHECK_EQ(blkdeviotune.write_iops_sec,
             "blkdeviotune write_iops_sec",
             true);
    CHECK_EQ(blkdeviotune.total_bytes_sec_max,
             "blkdeviotune total_bytes_sec_max",
             true);
    CHECK_EQ(blkdeviotune.read_bytes_sec_max,
             "blkdeviotune read_bytes_sec_max",
             true);
    CHECK_EQ(blkdeviotune.write_bytes_sec_max,
             "blkdeviotune write_bytes_sec_max",
             true);
    CHECK_EQ(blkdeviotune.total_iops_sec_max,
             "blkdeviotune total_iops_sec_max",
             true);
    CHECK_EQ(blkdeviotune.read_iops_sec_max,
             "blkdeviotune read_iops_sec_max",
             true);
    CHECK_EQ(blkdeviotune.write_iops_sec_max,
             "blkdeviotune write_iops_sec_max",
             true);
    CHECK_EQ(blkdeviotune.size_iops_sec,
             "blkdeviotune size_iops_sec",
             true);

    if (disk->serial && STRNEQ_NULLABLE(disk->serial, orig_disk->serial)) {
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("cannot modify field '%s' of the disk"),
                       "serial");
        return false;
    }

    if (disk->wwn && STRNEQ_NULLABLE(disk->wwn, orig_disk->wwn)) {
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("cannot modify field '%s' of the disk"),
                       "wwn");
        return false;
    }

    if (disk->vendor && STRNEQ_NULLABLE(disk->vendor, orig_disk->vendor)) {
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("cannot modify field '%s' of the disk"),
                       "vendor");
        return false;
    }

    if (disk->product && STRNEQ_NULLABLE(disk->product, orig_disk->product)) {
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("cannot modify field '%s' of the disk"),
                       "product");
        return false;
    }

5646 5647 5648 5649 5650 5651 5652
    CHECK_EQ(cachemode, "cache", true);
    CHECK_EQ(error_policy, "error_policy", true);
    CHECK_EQ(rerror_policy, "rerror_policy", true);
    CHECK_EQ(iomode, "io", true);
    CHECK_EQ(ioeventfd, "ioeventfd", true);
    CHECK_EQ(event_idx, "event_idx", true);
    CHECK_EQ(copy_on_read, "copy_on_read", true);
5653
    /* "snapshot" is a libvirt internal field and thus can be changed */
5654
    /* startupPolicy is allowed to be updated. Therefore not checked here. */
5655
    CHECK_EQ(transient, "transient", true);
5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668

    /* Note: For some address types the address auto generation for
     * @disk has still not happened at this point (e.g. driver
     * specific addresses) therefore we can't catch these possible
     * address modifications here. */
    if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE &&
        !virDomainDeviceInfoAddressIsEqual(&disk->info, &orig_disk->info)) {
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("cannot modify field '%s' of the disk"),
                       "address");
        return false;
    }

5669
    CHECK_EQ(info.bootIndex, "boot order", true);
5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681
    CHECK_EQ(rawio, "rawio", true);
    CHECK_EQ(sgio, "sgio", true);
    CHECK_EQ(discard, "discard", true);
    CHECK_EQ(iothread, "iothread", true);

    if (disk->domain_name &&
        STRNEQ_NULLABLE(disk->domain_name, orig_disk->domain_name)) {
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("cannot modify field '%s' of the disk"),
                       "backenddomain");
        return false;
    }
5682

5683 5684 5685 5686 5687 5688
    /* checks for fields stored in disk->src */
    /* unfortunately 'readonly' and 'shared' can't be converted to tristate
     * values thus we need to ignore the check if the new value is 'false' */
    CHECK_EQ(src->readonly, "readonly", true);
    CHECK_EQ(src->shared, "shared", true);

5689 5690 5691 5692 5693
#undef CHECK_EQ

    return true;
}

5694 5695 5696
bool
qemuDomainDiskBlockJobIsActive(virDomainDiskDefPtr disk)
{
5697 5698
    qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);

5699 5700 5701 5702 5703 5704 5705 5706
    if (disk->mirror) {
        virReportError(VIR_ERR_BLOCK_COPY_ACTIVE,
                       _("disk '%s' already in active block job"),
                       disk->dst);

        return true;
    }

5707
    if (diskPriv->blockjob) {
5708 5709 5710 5711 5712 5713 5714 5715 5716 5717
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("disk '%s' already in active block job"),
                       disk->dst);
        return true;
    }

    return false;
}


5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732
/**
 * qemuDomainHasBlockjob:
 * @vm: domain object
 * @copy_only: Reject only block copy job
 *
 * Return true if @vm has at least one disk involved in a current block
 * copy/commit/pull job. If @copy_only is true this returns true only if the
 * disk is involved in a block copy.
 * */
bool
qemuDomainHasBlockjob(virDomainObjPtr vm,
                      bool copy_only)
{
    size_t i;
    for (i = 0; i < vm->def->ndisks; i++) {
5733 5734 5735 5736
        virDomainDiskDefPtr disk = vm->def->disks[i];
        qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);

        if (!copy_only && diskPriv->blockjob)
5737 5738
            return true;

5739
        if (disk->mirror && disk->mirrorJob == VIR_DOMAIN_BLOCK_JOB_TYPE_COPY)
5740 5741 5742 5743 5744 5745 5746
            return true;
    }

    return false;
}


5747 5748
int
qemuDomainUpdateDeviceList(virQEMUDriverPtr driver,
5749 5750
                           virDomainObjPtr vm,
                           int asyncJob)
5751 5752 5753
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    char **aliases;
5754
    int rc;
5755 5756 5757 5758

    if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE_DEL_EVENT))
        return 0;

5759 5760
    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
        return -1;
5761 5762 5763 5764
    rc = qemuMonitorGetDeviceAliases(priv->mon, &aliases);
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        return -1;
    if (rc < 0)
5765 5766
        return -1;

5767
    virStringListFree(priv->qemuDevices);
5768 5769 5770
    priv->qemuDevices = aliases;
    return 0;
}
5771

5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790

int
qemuDomainUpdateMemoryDeviceInfo(virQEMUDriverPtr driver,
                                 virDomainObjPtr vm,
                                 int asyncJob)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    virHashTablePtr meminfo = NULL;
    int rc;
    size_t i;

    if (vm->def->nmems == 0)
        return 0;

    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
        return -1;

    rc = qemuMonitorGetMemoryDeviceInfo(priv->mon, &meminfo);

5791 5792
    if (qemuDomainObjExitMonitor(driver, vm) < 0) {
        virHashFree(meminfo);
5793
        return -1;
5794
    }
5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822

    /* if qemu doesn't support the info request, just carry on */
    if (rc == -2)
        return 0;

    if (rc < 0)
        return -1;

    for (i = 0; i < vm->def->nmems; i++) {
        virDomainMemoryDefPtr mem = vm->def->mems[i];
        qemuMonitorMemoryDeviceInfoPtr dimm;

        if (!mem->info.alias)
            continue;

        if (!(dimm = virHashLookup(meminfo, mem->info.alias)))
            continue;

        mem->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DIMM;
        mem->info.addr.dimm.slot = dimm->slot;
        mem->info.addr.dimm.base = dimm->address;
    }

    virHashFree(meminfo);
    return 0;
}


5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844
static bool
qemuDomainABIStabilityCheck(const virDomainDef *src,
                            const virDomainDef *dst)
{
    if (src->mem.source != dst->mem.source) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("Target memoryBacking source '%s' doesn't "
                         "match source memoryBacking source'%s'"),
                       virDomainMemorySourceTypeToString(dst->mem.source),
                       virDomainMemorySourceTypeToString(src->mem.source));
        return false;
    }

    return true;
}


virDomainABIStability virQEMUDriverDomainABIStability = {
    .domain = qemuDomainABIStabilityCheck,
};


5845 5846 5847 5848 5849 5850 5851
bool
qemuDomainDefCheckABIStability(virQEMUDriverPtr driver,
                               virDomainDefPtr src,
                               virDomainDefPtr dst)
{
    virDomainDefPtr migratableDefSrc = NULL;
    virDomainDefPtr migratableDefDst = NULL;
5852 5853 5854 5855
    const unsigned int flags = VIR_DOMAIN_XML_SECURE |
                               VIR_DOMAIN_XML_UPDATE_CPU |
                               VIR_DOMAIN_XML_MIGRATABLE;
    const unsigned int check_flags = VIR_DOMAIN_DEF_ABI_CHECK_SKIP_VOLATILE;
5856 5857 5858 5859 5860 5861
    bool ret = false;

    if (!(migratableDefSrc = qemuDomainDefCopy(driver, src, flags)) ||
        !(migratableDefDst = qemuDomainDefCopy(driver, dst, flags)))
        goto cleanup;

5862 5863
    if (!virDomainDefCheckABIStabilityFlags(migratableDefSrc,
                                            migratableDefDst,
5864
                                            driver->xmlopt,
5865 5866 5867 5868 5869 5870 5871
                                            check_flags))
        goto cleanup;

    /* Force update any skipped values from the volatile flag */
    dst->mem.cur_balloon = src->mem.cur_balloon;

    ret = true;
5872

5873
 cleanup:
5874 5875 5876 5877
    virDomainDefFree(migratableDefSrc);
    virDomainDefFree(migratableDefDst);
    return ret;
}
5878 5879

bool
5880
qemuDomainAgentAvailable(virDomainObjPtr vm,
5881 5882
                         bool reportError)
{
5883 5884
    qemuDomainObjPrivatePtr priv = vm->privateData;

5885 5886 5887 5888 5889 5890 5891
    if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING) {
        if (reportError) {
            virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                           _("domain is not running"));
        }
        return false;
    }
5892 5893 5894 5895 5896 5897 5898 5899 5900
    if (priv->agentError) {
        if (reportError) {
            virReportError(VIR_ERR_AGENT_UNRESPONSIVE, "%s",
                           _("QEMU guest agent is not "
                             "available due to an error"));
        }
        return false;
    }
    if (!priv->agent) {
5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912
        if (qemuFindAgentConfig(vm->def)) {
            if (reportError) {
                virReportError(VIR_ERR_AGENT_UNRESPONSIVE, "%s",
                               _("QEMU guest agent is not connected"));
            }
            return false;
        } else {
            if (reportError) {
                virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
                               _("QEMU guest agent is not configured"));
            }
            return false;
5913 5914 5915 5916
        }
    }
    return true;
}
5917

5918

5919
static unsigned long long
5920
qemuDomainGetMemorySizeAlignment(virDomainDefPtr def)
5921
{
5922 5923 5924 5925 5926
    /* PPC requires the memory sizes to be rounded to 256MiB increments, so
     * round them to the size always. */
    if (ARCH_IS_PPC64(def->os.arch))
        return 256 * 1024;

5927 5928 5929 5930 5931 5932 5933
    /* Align memory size. QEMU requires rounding to next 4KiB block.
     * We'll take the "traditional" path and round it to 1MiB*/

    return 1024;
}


5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948
static unsigned long long
qemuDomainGetMemoryModuleSizeAlignment(const virDomainDef *def,
                                       const virDomainMemoryDef *mem ATTRIBUTE_UNUSED)
{
    /* PPC requires the memory sizes to be rounded to 256MiB increments, so
     * round them to the size always. */
    if (ARCH_IS_PPC64(def->os.arch))
        return 256 * 1024;

    /* dimm memory modules require 2MiB alignment rather than the 1MiB we are
     * using elsewhere. */
    return 2048;
}


5949 5950 5951
int
qemuDomainAlignMemorySizes(virDomainDefPtr def)
{
5952 5953
    unsigned long long maxmemkb = virMemoryMaxValue(false) >> 10;
    unsigned long long maxmemcapped = virMemoryMaxValue(true) >> 10;
5954
    unsigned long long initialmem = 0;
5955
    unsigned long long hotplugmem = 0;
5956
    unsigned long long mem;
5957
    unsigned long long align = qemuDomainGetMemorySizeAlignment(def);
5958 5959 5960 5961 5962
    size_t ncells = virDomainNumaGetNodeCount(def->numa);
    size_t i;

    /* align NUMA cell sizes if relevant */
    for (i = 0; i < ncells; i++) {
5963 5964
        mem = VIR_ROUND_UP(virDomainNumaGetNodeMemorySize(def->numa, i), align);
        initialmem += mem;
5965 5966 5967 5968 5969 5970 5971

        if (mem > maxmemkb) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("memory size of NUMA node '%zu' overflowed after "
                             "alignment"), i);
            return -1;
        }
5972
        virDomainNumaSetNodeMemorySize(def->numa, i, mem);
5973 5974
    }

5975 5976 5977 5978 5979
    /* align initial memory size, if NUMA is present calculate it as total of
     * individual aligned NUMA node sizes */
    if (initialmem == 0)
        initialmem = VIR_ROUND_UP(virDomainDefGetMemoryInitial(def), align);

5980 5981 5982 5983 5984 5985
    if (initialmem > maxmemcapped) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("initial memory size overflowed after alignment"));
        return -1;
    }

5986
    def->mem.max_memory = VIR_ROUND_UP(def->mem.max_memory, align);
5987 5988 5989 5990 5991
    if (def->mem.max_memory > maxmemkb) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("maximum memory size overflowed after alignment"));
        return -1;
    }
5992

5993
    /* Align memory module sizes */
5994 5995
    for (i = 0; i < def->nmems; i++) {
        align = qemuDomainGetMemoryModuleSizeAlignment(def, def->mems[i]);
5996
        def->mems[i]->size = VIR_ROUND_UP(def->mems[i]->size, align);
5997
        hotplugmem += def->mems[i]->size;
5998 5999 6000 6001 6002 6003 6004

        if (def->mems[i]->size > maxmemkb) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("size of memory module '%zu' overflowed after "
                             "alignment"), i);
            return -1;
        }
6005
    }
6006

6007 6008
    virDomainDefSetMemoryTotal(def, initialmem + hotplugmem);

6009 6010
    return 0;
}
6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021


/**
 * qemuDomainMemoryDeviceAlignSize:
 * @mem: memory device definition object
 *
 * Aligns the size of the memory module as qemu enforces it. The size is updated
 * inplace. Default rounding is now to 1 MiB (qemu requires rouding to page,
 * size so this should be safe).
 */
void
6022 6023
qemuDomainMemoryDeviceAlignSize(virDomainDefPtr def,
                                virDomainMemoryDefPtr mem)
6024
{
6025
    mem->size = VIR_ROUND_UP(mem->size, qemuDomainGetMemorySizeAlignment(def));
6026
}
6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039


/**
 * qemuDomainGetMonitor:
 * @vm: domain object
 *
 * Returns the monitor pointer corresponding to the domain object @vm.
 */
qemuMonitorPtr
qemuDomainGetMonitor(virDomainObjPtr vm)
{
    return ((qemuDomainObjPrivatePtr) vm->privateData)->mon;
}
6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055


/**
 * qemuDomainSupportsBlockJobs:
 * @vm: domain object
 * @modern: pointer to bool that returns whether modern block jobs are supported
 *
 * Returns -1 in case when qemu does not support block jobs at all. Otherwise
 * returns 0 and optionally fills @modern to denote that modern (async) block
 * jobs are supported.
 */
int
qemuDomainSupportsBlockJobs(virDomainObjPtr vm,
                            bool *modern)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
6056 6057
    bool asynchronous = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_ASYNC);
    bool synchronous = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_SYNC);
6058

6059
    if (!synchronous && !asynchronous) {
6060 6061 6062 6063 6064 6065
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("block jobs not supported with this QEMU binary"));
        return -1;
    }

    if (modern)
6066
        *modern = asynchronous;
6067 6068 6069

    return 0;
}
6070 6071 6072 6073 6074 6075 6076 6077 6078


/**
 * qemuFindAgentConfig:
 * @def: domain definition
 *
 * Returns the pointer to the channel definition that is used to access the
 * guest agent if the agent is configured or NULL otherwise.
 */
6079
virDomainChrDefPtr
6080 6081 6082 6083 6084 6085 6086 6087 6088 6089
qemuFindAgentConfig(virDomainDefPtr def)
{
    size_t i;

    for (i = 0; i < def->nchannels; i++) {
        virDomainChrDefPtr channel = def->channels[i];

        if (channel->targetType != VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO)
            continue;

6090 6091
        if (STREQ_NULLABLE(channel->target.name, "org.qemu.guest_agent.0"))
            return channel;
6092 6093
    }

6094
    return NULL;
6095
}
6096 6097 6098


bool
6099
qemuDomainIsQ35(const virDomainDef *def)
6100
{
6101
    return qemuDomainMachineIsQ35(def->os.machine);
6102 6103 6104 6105
}


bool
6106
qemuDomainMachineIsQ35(const char *machine)
6107
{
6108 6109
    return (STRPREFIX(machine, "pc-q35") ||
            STREQ(machine, "q35"));
6110
}
6111 6112


6113
bool
6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132
qemuDomainIsI440FX(const virDomainDef *def)
{
    return qemuDomainMachineIsI440FX(def->os.machine);
}


bool
qemuDomainMachineIsI440FX(const char *machine)
{
    return (STREQ(machine, "pc") ||
            STRPREFIX(machine, "pc-0.") ||
            STRPREFIX(machine, "pc-1.") ||
            STRPREFIX(machine, "pc-i440") ||
            STRPREFIX(machine, "rhel"));
}


bool
qemuDomainHasPCIRoot(const virDomainDef *def)
6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146
{
    int root = virDomainControllerFind(def, VIR_DOMAIN_CONTROLLER_TYPE_PCI, 0);

    if (root < 0)
        return false;

    if (def->controllers[root]->model != VIR_DOMAIN_CONTROLLER_MODEL_PCI_ROOT)
        return false;

    return true;
}


bool
6147
qemuDomainHasPCIeRoot(const virDomainDef *def)
6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160
{
    int root = virDomainControllerFind(def, VIR_DOMAIN_CONTROLLER_TYPE_PCI, 0);

    if (root < 0)
        return false;

    if (def->controllers[root]->model != VIR_DOMAIN_CONTROLLER_MODEL_PCIE_ROOT)
        return false;

    return true;
}


6161
bool
6162
qemuDomainNeedsFDC(const virDomainDef *def)
6163
{
6164 6165 6166 6167 6168 6169 6170 6171
    return qemuDomainMachineNeedsFDC(def->os.machine);
}


bool
qemuDomainMachineNeedsFDC(const char *machine)
{
    const char *p = STRSKIP(machine, "pc-q35-");
6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185

    if (p) {
        if (STRPREFIX(p, "1.") ||
            STRPREFIX(p, "2.0") ||
            STRPREFIX(p, "2.1") ||
            STRPREFIX(p, "2.2") ||
            STRPREFIX(p, "2.3"))
            return false;
        return true;
    }
    return false;
}


6186
bool
6187
qemuDomainIsS390CCW(const virDomainDef *def)
6188
{
6189
    return qemuDomainMachineIsS390CCW(def->os.machine);
6190 6191
}

6192

J
Ján Tomko 已提交
6193
bool
6194
qemuDomainMachineIsS390CCW(const char *machine)
J
Ján Tomko 已提交
6195
{
6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212
    return STRPREFIX(machine, "s390-ccw");
}


bool
qemuDomainIsVirt(const virDomainDef *def)
{
    return qemuDomainMachineIsVirt(def->os.machine, def->os.arch);
}


bool
qemuDomainMachineIsVirt(const char *machine,
                        const virArch arch)
{
    if (arch != VIR_ARCH_ARMV7L &&
        arch != VIR_ARCH_AARCH64)
6213 6214
        return false;

6215 6216
    if (STRNEQ(machine, "virt") &&
        !STRPREFIX(machine, "virt-"))
6217 6218 6219
        return false;

    return true;
J
Ján Tomko 已提交
6220 6221 6222
}


6223
bool
6224
qemuDomainIsPSeries(const virDomainDef *def)
6225
{
6226 6227 6228 6229 6230 6231 6232 6233 6234
    return qemuDomainMachineIsPSeries(def->os.machine, def->os.arch);
}


bool
qemuDomainMachineIsPSeries(const char *machine,
                           const virArch arch)
{
    if (!ARCH_IS_PPC64(arch))
6235 6236
        return false;

6237 6238
    if (STRNEQ(machine, "pseries") &&
        !STRPREFIX(machine, "pseries-"))
6239 6240 6241 6242 6243 6244
        return false;

    return true;
}


6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 6279 6280 6281 6282 6283
static bool
qemuCheckMemoryDimmConflict(const virDomainDef *def,
                            const virDomainMemoryDef *mem)
{
    size_t i;

    for (i = 0; i < def->nmems; i++) {
         virDomainMemoryDefPtr tmp = def->mems[i];

         if (tmp == mem ||
             tmp->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DIMM)
             continue;

         if (mem->info.addr.dimm.slot == tmp->info.addr.dimm.slot) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                            _("memory device slot '%u' is already being "
                              "used by another memory device"),
                            mem->info.addr.dimm.slot);
             return true;
         }

         if (mem->info.addr.dimm.base != 0 &&
             mem->info.addr.dimm.base == tmp->info.addr.dimm.base) {
             virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                            _("memory device base '0x%llx' is already being "
                              "used by another memory device"),
                            mem->info.addr.dimm.base);
             return true;
         }
    }

    return false;
}
static int
qemuDomainDefValidateMemoryHotplugDevice(const virDomainMemoryDef *mem,
                                         const virDomainDef *def)
{
    switch ((virDomainMemoryModel) mem->model) {
    case VIR_DOMAIN_MEMORY_MODEL_DIMM:
M
Michal Privoznik 已提交
6284
    case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
6285 6286 6287 6288 6289 6290 6291 6292
        if (mem->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DIMM &&
            mem->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("only 'dimm' addresses are supported for the "
                             "pc-dimm device"));
            return -1;
        }

6293 6294 6295
        if (virDomainNumaGetNodeCount(def->numa) != 0) {
            if (mem->targetNode == -1) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
Y
Yuri Chornoivan 已提交
6296
                               _("target NUMA node needs to be specified for "
6297 6298 6299
                                 "memory device"));
                return -1;
            }
6300 6301
        }

6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325
        if (mem->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DIMM) {
            if (mem->info.addr.dimm.slot >= def->mem.memory_slots) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                               _("memory device slot '%u' exceeds slots "
                                 "count '%u'"),
                               mem->info.addr.dimm.slot, def->mem.memory_slots);
                return -1;
            }


            if (qemuCheckMemoryDimmConflict(def, mem))
                return -1;
        }
        break;

    case VIR_DOMAIN_MEMORY_MODEL_NONE:
    case VIR_DOMAIN_MEMORY_MODEL_LAST:
        return -1;
    }

    return 0;
}


6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346
/**
 * qemuDomainDefValidateMemoryHotplug:
 * @def: domain definition
 * @qemuCaps: qemu capabilities object
 * @mem: definition of memory device that is to be added to @def with hotplug,
 *       NULL in case of regular VM startup
 *
 * Validates that the domain definition and memory modules have valid
 * configuration and are possibly able to accept @mem via hotplug if it's
 * non-NULL.
 *
 * Returns 0 on success; -1 and a libvirt error on error.
 */
int
qemuDomainDefValidateMemoryHotplug(const virDomainDef *def,
                                   virQEMUCapsPtr qemuCaps,
                                   const virDomainMemoryDef *mem)
{
    unsigned int nmems = def->nmems;
    unsigned long long hotplugSpace;
    unsigned long long hotplugMemory = 0;
M
Michal Privoznik 已提交
6347 6348
    bool needPCDimmCap = false;
    bool needNvdimmCap = false;
6349 6350 6351 6352 6353 6354 6355
    size_t i;

    hotplugSpace = def->mem.max_memory - virDomainDefGetMemoryInitial(def);

    if (mem) {
        nmems++;
        hotplugMemory = mem->size;
6356 6357 6358

        if (qemuDomainDefValidateMemoryHotplugDevice(mem, def) < 0)
            return -1;
6359 6360 6361 6362 6363 6364 6365 6366 6367 6368 6369 6370 6371
    }

    if (!virDomainDefHasMemoryHotplug(def)) {
        if (nmems) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("cannot use/hotplug a memory device when domain "
                             "'maxMemory' is not defined"));
            return -1;
        }

        return 0;
    }

6372 6373 6374 6375 6376 6377 6378 6379 6380 6381 6382
    if (!ARCH_IS_PPC64(def->os.arch)) {
        /* due to guest support, qemu would silently enable NUMA with one node
         * once the memory hotplug backend is enabled. To avoid possible
         * confusion we will enforce user originated numa configuration along
         * with memory hotplug. */
        if (virDomainNumaGetNodeCount(def->numa) == 0) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("At least one numa node has to be configured when "
                             "enabling memory hotplug"));
            return -1;
        }
6383 6384 6385 6386 6387 6388 6389 6390 6391
    }

    if (nmems > def->mem.memory_slots) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                       _("memory device count '%u' exceeds slots count '%u'"),
                       nmems, def->mem.memory_slots);
        return -1;
    }

6392
    for (i = 0; i < def->nmems; i++) {
6393 6394
        hotplugMemory += def->mems[i]->size;

M
Michal Privoznik 已提交
6395 6396 6397 6398 6399 6400 6401 6402 6403 6404 6405 6406 6407 6408
        switch ((virDomainMemoryModel) def->mems[i]->model) {
        case VIR_DOMAIN_MEMORY_MODEL_DIMM:
            needPCDimmCap = true;
            break;

        case VIR_DOMAIN_MEMORY_MODEL_NVDIMM:
            needNvdimmCap = true;
            break;

        case VIR_DOMAIN_MEMORY_MODEL_NONE:
        case VIR_DOMAIN_MEMORY_MODEL_LAST:
            break;
        }

6409 6410 6411 6412 6413 6414
        /* already existing devices don't need to be checked on hotplug */
        if (!mem &&
            qemuDomainDefValidateMemoryHotplugDevice(def->mems[i], def) < 0)
            return -1;
    }

M
Michal Privoznik 已提交
6415 6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428
    if (needPCDimmCap &&
        !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_PC_DIMM)) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("memory hotplug isn't supported by this QEMU binary"));
        return -1;
    }

    if (needNvdimmCap &&
        !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_NVDIMM)) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("nvdimm isn't supported by this QEMU binary"));
        return -1;
    }

6429 6430 6431 6432 6433 6434 6435 6436 6437 6438
    if (hotplugMemory > hotplugSpace) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("memory device total size exceeds hotplug space"));
        return -1;
    }

    return 0;
}


6439
bool
6440 6441 6442 6443 6444 6445 6446 6447
qemuDomainHasBuiltinIDE(const virDomainDef *def)
{
    return qemuDomainMachineHasBuiltinIDE(def->os.machine);
}


bool
qemuDomainMachineHasBuiltinIDE(const char *machine)
6448
{
6449 6450 6451 6452
    return qemuDomainMachineIsI440FX(machine) ||
        STREQ(machine, "malta") ||
        STREQ(machine, "sun4u") ||
        STREQ(machine, "g3beige");
6453 6454 6455
}


6456 6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467 6468 6469 6470 6471 6472 6473 6474 6475 6476 6477 6478 6479
/**
 * qemuDomainUpdateCurrentMemorySize:
 *
 * Updates the current balloon size from the monitor if necessary. In case when
 * the balloon is not present for the domain, the function recalculates the
 * maximum size to reflect possible changes.
 *
 * Returns 0 on success and updates vm->def->mem.cur_balloon if necessary, -1 on
 * error and reports libvirt error.
 */
int
qemuDomainUpdateCurrentMemorySize(virQEMUDriverPtr driver,
                                  virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    unsigned long long balloon;
    int ret = -1;

    /* inactive domain doesn't need size update */
    if (!virDomainObjIsActive(vm))
        return 0;

    /* if no balloning is available, the current size equals to the current
     * full memory size */
6480
    if (!virDomainDefHasMemballoon(vm->def)) {
6481
        vm->def->mem.cur_balloon = virDomainDefGetMemoryTotal(vm->def);
6482 6483 6484 6485 6486 6487 6488 6489 6490 6491 6492 6493 6494 6495 6496 6497 6498 6499 6500 6501 6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513
        return 0;
    }

    /* current size is always automagically updated via the event */
    if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BALLOON_EVENT))
        return 0;

    /* here we need to ask the monitor */

    /* Don't delay if someone's using the monitor, just use existing most
     * recent data instead */
    if (qemuDomainJobAllowed(priv, QEMU_JOB_QUERY)) {
        if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_QUERY) < 0)
            return -1;

        if (!virDomainObjIsActive(vm)) {
            virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                           _("domain is not running"));
            goto endjob;
        }

        qemuDomainObjEnterMonitor(driver, vm);
        ret = qemuMonitorGetBalloonInfo(priv->mon, &balloon);
        if (qemuDomainObjExitMonitor(driver, vm) < 0)
            ret = -1;

 endjob:
        qemuDomainObjEndJob(driver, vm);

        if (ret < 0)
            return -1;

6514 6515
        vm->def->mem.cur_balloon = balloon;
    }
6516 6517 6518

    return 0;
}
6519 6520 6521


/**
6522
 * qemuDomainGetMemLockLimitBytes:
6523 6524
 * @def: domain definition
 *
6525 6526 6527 6528 6529 6530
 * Calculate the memory locking limit that needs to be set in order for
 * the guest to operate properly. The limit depends on a number of factors,
 * including certain configuration options and less immediately apparent ones
 * such as the guest architecture or the use of certain devices.
 *
 * Returns: the memory locking limit, or 0 if setting the limit is not needed
6531 6532
 */
unsigned long long
6533
qemuDomainGetMemLockLimitBytes(virDomainDefPtr def)
6534
{
6535 6536
    unsigned long long memKB = 0;
    size_t i;
6537

6538 6539 6540 6541 6542 6543
    /* prefer the hard limit */
    if (virMemoryLimitIsSet(def->mem.hard_limit)) {
        memKB = def->mem.hard_limit;
        goto done;
    }

6544 6545 6546 6547 6548 6549 6550
    /* If the guest wants its memory to be locked, we need to raise the memory
     * locking limit so that the OS will not refuse allocation requests;
     * however, there is no reliable way for us to figure out how much memory
     * the QEMU process will allocate for its own use, so our only way out is
     * to remove the limit altogether. Use with extreme care */
    if (def->mem.locked)
        return VIR_DOMAIN_MEMORY_PARAM_UNLIMITED;
6551 6552

    if (ARCH_IS_PPC64(def->os.arch) && def->virtType == VIR_DOMAIN_VIRT_KVM) {
6553 6554 6555 6556 6557 6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568 6569 6570 6571 6572 6573 6574
        unsigned long long maxMemory;
        unsigned long long memory;
        unsigned long long baseLimit;
        unsigned long long passthroughLimit;
        size_t nPCIHostBridges;
        bool usesVFIO = false;

        /* TODO: Detect at runtime once we start using more than just
         *       the default PCI Host Bridge */
        nPCIHostBridges = 1;

        for (i = 0; i < def->nhostdevs; i++) {
            virDomainHostdevDefPtr dev = def->hostdevs[i];

            if (dev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
                dev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI &&
                dev->source.subsys.u.pci.backend == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO) {
                usesVFIO = true;
                break;
            }
        }

6575
        memory = virDomainDefGetMemoryTotal(def);
6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592 6593 6594 6595 6596 6597 6598 6599 6600 6601 6602 6603 6604 6605 6606 6607 6608 6609 6610 6611 6612 6613 6614 6615 6616 6617 6618 6619 6620 6621 6622 6623 6624 6625 6626 6627 6628

        if (def->mem.max_memory)
            maxMemory = def->mem.max_memory;
        else
            maxMemory = memory;

        /* baseLimit := maxMemory / 128                                  (a)
         *              + 4 MiB * #PHBs + 8 MiB                          (b)
         *
         * (a) is the hash table
         *
         * (b) is accounting for the 32-bit DMA window - it could be either the
         * KVM accelerated TCE tables for emulated devices, or the VFIO
         * userspace view. The 4 MiB per-PHB (including the default one) covers
         * a 2GiB DMA window: default is 1GiB, but it's possible it'll be
         * increased to help performance. The 8 MiB extra should be plenty for
         * the TCE table index for any reasonable number of PHBs and several
         * spapr-vlan or spapr-vscsi devices (512kB + a tiny bit each) */
        baseLimit = maxMemory / 128 +
                    4096 * nPCIHostBridges +
                    8192;

        /* passthroughLimit := max( 2 GiB * #PHBs,                       (c)
         *                          memory                               (d)
         *                          + memory * 1/512 * #PHBs + 8 MiB )   (e)
         *
         * (c) is the pre-DDW VFIO DMA window accounting. We're allowing 2 GiB
         * rather than 1 GiB
         *
         * (d) is the with-DDW (and memory pre-registration and related
         * features) DMA window accounting - assuming that we only account RAM
         * once, even if mapped to multiple PHBs
         *
         * (e) is the with-DDW userspace view and overhead for the 64-bit DMA
         * window. This is based a bit on expected guest behaviour, but there
         * really isn't a way to completely avoid that. We assume the guest
         * requests a 64-bit DMA window (per PHB) just big enough to map all
         * its RAM. 4 kiB page size gives the 1/512; it will be less with 64
         * kiB pages, less still if the guest is mapped with hugepages (unlike
         * the default 32-bit DMA window, DDW windows can use large IOMMU
         * pages). 8 MiB is for second and further level overheads, like (b) */
        passthroughLimit = MAX(2 * 1024 * 1024 * nPCIHostBridges,
                               memory +
                               memory / 512 * nPCIHostBridges + 8192);

        if (usesVFIO)
            memKB = baseLimit + passthroughLimit;
        else
            memKB = baseLimit;

        goto done;
    }

6629 6630 6631 6632 6633 6634 6635 6636 6637 6638 6639 6640 6641 6642 6643 6644 6645 6646
    /* For device passthrough using VFIO the guest memory and MMIO memory
     * regions need to be locked persistent in order to allow DMA.
     *
     * Currently the below limit is based on assumptions about the x86 platform.
     *
     * The chosen value of 1GiB below originates from x86 systems where it was
     * used as space reserved for the MMIO region for the whole system.
     *
     * On x86_64 systems the MMIO regions of the IOMMU mapped devices don't
     * count towards the locked memory limit since the memory is owned by the
     * device. Emulated devices though do count, but the regions are usually
     * small. Although it's not guaranteed that the limit will be enough for all
     * configurations it didn't pose a problem for now.
     *
     * http://www.redhat.com/archives/libvir-list/2015-November/msg00329.html
     *
     * Note that this may not be valid for all platforms.
     */
6647
    for (i = 0; i < def->nhostdevs; i++) {
6648
        virDomainHostdevSubsysPtr subsys = &def->hostdevs[i]->source.subsys;
6649

6650 6651 6652
        if (def->hostdevs[i]->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
            (subsys->type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_MDEV ||
             (subsys->type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI &&
6653 6654 6655 6656
              subsys->u.pci.backend == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO))) {
            memKB = virDomainDefGetMemoryTotal(def) + 1024 * 1024;
            goto done;
        }
6657 6658
    }

6659 6660
 done:
    return memKB << 10;
6661
}
6662

6663

6664 6665 6666 6667 6668 6669 6670
/**
 * qemuDomainAdjustMaxMemLock:
 * @vm: domain
 *
 * Adjust the memory locking limit for the QEMU process associated to @vm, in
 * order to comply with VFIO or architecture requirements.
 *
6671 6672 6673 6674
 * The limit will not be changed unless doing so is needed; the first time
 * the limit is changed, the original (default) limit is stored in @vm and
 * that value will be restored if qemuDomainAdjustMaxMemLock() is called once
 * memory locking is no longer required.
6675 6676 6677 6678 6679 6680 6681 6682 6683
 *
 * Returns: 0 on success, <0 on failure
 */
int
qemuDomainAdjustMaxMemLock(virDomainObjPtr vm)
{
    unsigned long long bytes = 0;
    int ret = -1;

6684 6685 6686
    bytes = qemuDomainGetMemLockLimitBytes(vm->def);

    if (bytes) {
6687 6688 6689 6690 6691 6692 6693 6694 6695 6696 6697 6698 6699 6700
        /* If this is the first time adjusting the limit, save the current
         * value so that we can restore it once memory locking is no longer
         * required. Failing to obtain the current limit is not a critical
         * failure, it just means we'll be unable to lower it later */
        if (!vm->original_memlock) {
            if (virProcessGetMaxMemLock(vm->pid, &(vm->original_memlock)) < 0)
                vm->original_memlock = 0;
        }
    } else {
        /* Once memory locking is no longer required, we can restore the
         * original, usually very low, limit */
        bytes = vm->original_memlock;
        vm->original_memlock = 0;
    }
6701 6702 6703 6704 6705 6706 6707 6708 6709 6710

    /* Trying to set the memory locking limit to zero is a no-op */
    if (virProcessSetMaxMemLock(vm->pid, bytes) < 0)
        goto out;

    ret = 0;

 out:
     return ret;
}
6711 6712 6713 6714 6715 6716 6717 6718 6719 6720

/**
 * qemuDomainHasVcpuPids:
 * @vm: Domain object
 *
 * Returns true if we were able to successfully detect vCPU pids for the VM.
 */
bool
qemuDomainHasVcpuPids(virDomainObjPtr vm)
{
6721 6722 6723 6724 6725 6726
    size_t i;
    size_t maxvcpus = virDomainDefGetVcpusMax(vm->def);
    virDomainVcpuDefPtr vcpu;

    for (i = 0; i < maxvcpus; i++) {
        vcpu = virDomainDefGetVcpu(vm->def, i);
6727

6728 6729 6730 6731 6732
        if (QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->tid > 0)
            return true;
    }

    return false;
6733
}
6734 6735 6736 6737 6738 6739 6740 6741 6742 6743 6744


/**
 * qemuDomainGetVcpuPid:
 * @vm: domain object
 * @vcpu: cpu id
 *
 * Returns the vCPU pid. If @vcpu is offline or out of range 0 is returned.
 */
pid_t
qemuDomainGetVcpuPid(virDomainObjPtr vm,
6745
                     unsigned int vcpuid)
6746
{
6747 6748
    virDomainVcpuDefPtr vcpu = virDomainDefGetVcpu(vm->def, vcpuid);
    return QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->tid;
6749
}
6750 6751


6752 6753 6754 6755 6756 6757 6758 6759 6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772 6773 6774 6775 6776 6777 6778 6779 6780 6781 6782 6783 6784 6785 6786 6787 6788 6789 6790 6791 6792 6793
/**
 * qemuDomainValidateVcpuInfo:
 *
 * Validates vcpu thread information. If vcpu thread IDs are reported by qemu,
 * this function validates that online vcpus have thread info present and
 * offline vcpus don't.
 *
 * Returns 0 on success -1 on error.
 */
int
qemuDomainValidateVcpuInfo(virDomainObjPtr vm)
{
    size_t maxvcpus = virDomainDefGetVcpusMax(vm->def);
    virDomainVcpuDefPtr vcpu;
    qemuDomainVcpuPrivatePtr vcpupriv;
    size_t i;

    if (!qemuDomainHasVcpuPids(vm))
        return 0;

    for (i = 0; i < maxvcpus; i++) {
        vcpu = virDomainDefGetVcpu(vm->def, i);
        vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpu);

        if (vcpu->online && vcpupriv->tid == 0) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("qemu didn't report thread id for vcpu '%zu'"), i);
            return -1;
        }

        if (!vcpu->online && vcpupriv->tid != 0) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("qemu reported thread id for inactive vcpu '%zu'"),
                           i);
            return -1;
        }
    }

    return 0;
}


6794 6795 6796 6797 6798 6799 6800 6801 6802
bool
qemuDomainSupportsNewVcpuHotplug(virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;

    return virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS);
}


6803
/**
6804
 * qemuDomainRefreshVcpuInfo:
6805 6806 6807
 * @driver: qemu driver data
 * @vm: domain object
 * @asyncJob: current asynchronous job type
6808
 * @state: refresh vcpu state
6809
 *
6810 6811
 * Updates vCPU information private data of @vm. Due to historical reasons this
 * function returns success even if some data were not reported by qemu.
6812
 *
6813 6814
 * If @state is true, the vcpu state is refreshed as reported by the monitor.
 *
6815
 * Returns 0 on success and -1 on fatal error.
6816 6817
 */
int
6818 6819
qemuDomainRefreshVcpuInfo(virQEMUDriverPtr driver,
                          virDomainObjPtr vm,
6820 6821
                          int asyncJob,
                          bool state)
6822
{
6823
    virDomainVcpuDefPtr vcpu;
6824 6825
    qemuDomainVcpuPrivatePtr vcpupriv;
    qemuMonitorCPUInfoPtr info = NULL;
6826 6827
    size_t maxvcpus = virDomainDefGetVcpusMax(vm->def);
    size_t i;
6828
    bool hotplug;
6829
    int rc;
6830
    int ret = -1;
6831

6832
    hotplug = qemuDomainSupportsNewVcpuHotplug(vm);
6833 6834 6835

    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
        return -1;
6836

6837
    rc = qemuMonitorGetCPUInfo(qemuDomainGetMonitor(vm), &info, maxvcpus, hotplug);
6838

6839
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
6840 6841
        goto cleanup;

6842
    if (rc < 0)
6843 6844 6845 6846
        goto cleanup;

    for (i = 0; i < maxvcpus; i++) {
        vcpu = virDomainDefGetVcpu(vm->def, i);
6847
        vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpu);
6848

6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860 6861 6862 6863 6864 6865 6866 6867 6868 6869 6870 6871 6872 6873 6874 6875 6876 6877 6878 6879 6880 6881 6882 6883 6884 6885 6886 6887 6888
        /*
         * Current QEMU *can* report info about host threads mapped
         * to vCPUs, but it is not in a manner we can correctly
         * deal with. The TCG CPU emulation does have a separate vCPU
         * thread, but it runs every vCPU in that same thread. So it
         * is impossible to setup different affinity per thread.
         *
         * What's more the 'query-cpus' command returns bizarre
         * data for the threads. It gives the TCG thread for the
         * vCPU 0, but for vCPUs 1-> N, it actually replies with
         * the main process thread ID.
         *
         * The result is that when we try to set affinity for
         * vCPU 1, it will actually change the affinity of the
         * emulator thread :-( When you try to set affinity for
         * vCPUs 2, 3.... it will fail if the affinity was
         * different from vCPU 1.
         *
         * We *could* allow vcpu pinning with TCG, if we made the
         * restriction that all vCPUs had the same mask. This would
         * at least let us separate emulator from vCPUs threads, as
         * we do for KVM. It would need some changes to our cgroups
         * CPU layout though, and error reporting for the config
         * restrictions.
         *
         * Just disable CPU pinning with TCG until someone wants
         * to try to do this hard work.
         */
        if (vm->def->virtType != VIR_DOMAIN_VIRT_QEMU)
            vcpupriv->tid = info[i].tid;

        vcpupriv->socket_id = info[i].socket_id;
        vcpupriv->core_id = info[i].core_id;
        vcpupriv->thread_id = info[i].thread_id;
        vcpupriv->vcpus = info[i].vcpus;
        VIR_FREE(vcpupriv->type);
        VIR_STEAL_PTR(vcpupriv->type, info[i].type);
        VIR_FREE(vcpupriv->alias);
        VIR_STEAL_PTR(vcpupriv->alias, info[i].alias);
        vcpupriv->enable_id = info[i].id;
6889
        vcpupriv->qemu_id = info[i].qemu_id;
6890

6891
        if (hotplug && state) {
6892 6893 6894 6895 6896
            vcpu->online = info[i].online;
            if (info[i].hotpluggable)
                vcpu->hotpluggable = VIR_TRISTATE_BOOL_YES;
            else
                vcpu->hotpluggable = VIR_TRISTATE_BOOL_NO;
6897
        }
6898 6899
    }

6900
    ret = 0;
6901 6902

 cleanup:
6903
    qemuMonitorCPUInfoFree(info, maxvcpus);
6904
    return ret;
6905
}
6906

6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935 6936 6937
/**
 * qemuDomainGetVcpuHalted:
 * @vm: domain object
 * @vcpu: cpu id
 *
 * Returns the vCPU halted state.
  */
bool
qemuDomainGetVcpuHalted(virDomainObjPtr vm,
                        unsigned int vcpuid)
{
    virDomainVcpuDefPtr vcpu = virDomainDefGetVcpu(vm->def, vcpuid);
    return QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->halted;
}

/**
 * qemuDomainRefreshVcpuHalted:
 * @driver: qemu driver data
 * @vm: domain object
 * @asyncJob: current asynchronous job type
 *
 * Updates vCPU halted state in the private data of @vm.
 *
 * Returns 0 on success and -1 on error
 */
int
qemuDomainRefreshVcpuHalted(virQEMUDriverPtr driver,
                            virDomainObjPtr vm,
                            int asyncJob)
{
    virDomainVcpuDefPtr vcpu;
6938
    qemuDomainVcpuPrivatePtr vcpupriv;
6939
    size_t maxvcpus = virDomainDefGetVcpusMax(vm->def);
6940
    virBitmapPtr haltedmap = NULL;
6941 6942 6943 6944 6945 6946 6947 6948 6949 6950
    size_t i;
    int ret = -1;

    /* Not supported currently for TCG, see qemuDomainRefreshVcpuInfo */
    if (vm->def->virtType == VIR_DOMAIN_VIRT_QEMU)
        return 0;

    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
        return -1;

6951
    haltedmap = qemuMonitorGetCpuHalted(qemuDomainGetMonitor(vm), maxvcpus);
6952

6953
    if (qemuDomainObjExitMonitor(driver, vm) < 0 || !haltedmap)
6954 6955 6956 6957
        goto cleanup;

    for (i = 0; i < maxvcpus; i++) {
        vcpu = virDomainDefGetVcpu(vm->def, i);
6958 6959
        vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpu);
        vcpupriv->halted = virBitmapIsBitSet(haltedmap, vcpupriv->qemu_id);
6960 6961 6962 6963 6964
    }

    ret = 0;

 cleanup:
6965
    virBitmapFree(haltedmap);
6966 6967
    return ret;
}
6968 6969 6970 6971 6972 6973 6974 6975 6976 6977 6978 6979 6980 6981 6982 6983 6984 6985 6986 6987

bool
qemuDomainSupportsNicdev(virDomainDefPtr def,
                         virDomainNetDefPtr net)
{
    /* non-virtio ARM nics require legacy -net nic */
    if (((def->os.arch == VIR_ARCH_ARMV7L) ||
        (def->os.arch == VIR_ARCH_AARCH64)) &&
        net->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_MMIO &&
        net->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)
        return false;

    return true;
}

bool
qemuDomainSupportsNetdev(virDomainDefPtr def,
                         virQEMUCapsPtr qemuCaps,
                         virDomainNetDefPtr net)
{
6988
    if (!qemuDomainSupportsNicdev(def, net))
6989 6990 6991
        return false;
    return virQEMUCapsGet(qemuCaps, QEMU_CAPS_NETDEV);
}
J
John Ferlan 已提交
6992

6993 6994 6995 6996
bool
qemuDomainNetSupportsMTU(virDomainNetType type)
{
    switch (type) {
6997 6998
    case VIR_DOMAIN_NET_TYPE_NETWORK:
    case VIR_DOMAIN_NET_TYPE_BRIDGE:
6999 7000
    case VIR_DOMAIN_NET_TYPE_ETHERNET:
    case VIR_DOMAIN_NET_TYPE_VHOSTUSER:
7001 7002
        return true;
    case VIR_DOMAIN_NET_TYPE_USER:
7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013 7014
    case VIR_DOMAIN_NET_TYPE_SERVER:
    case VIR_DOMAIN_NET_TYPE_CLIENT:
    case VIR_DOMAIN_NET_TYPE_MCAST:
    case VIR_DOMAIN_NET_TYPE_INTERNAL:
    case VIR_DOMAIN_NET_TYPE_DIRECT:
    case VIR_DOMAIN_NET_TYPE_HOSTDEV:
    case VIR_DOMAIN_NET_TYPE_UDP:
    case VIR_DOMAIN_NET_TYPE_LAST:
        break;
    }
    return false;
}
J
John Ferlan 已提交
7015 7016 7017 7018 7019 7020

int
qemuDomainNetVLAN(virDomainNetDefPtr def)
{
    return qemuDomainDeviceAliasIndex(&def->info, "net");
}
P
Peter Krempa 已提交
7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036


virDomainDiskDefPtr
qemuDomainDiskByName(virDomainDefPtr def,
                     const char *name)
{
    virDomainDiskDefPtr ret;

    if (!(ret = virDomainDiskByName(def, name, true))) {
        virReportError(VIR_ERR_INVALID_ARG, "%s",
                       _("No device found for specified path"));
        return NULL;
    }

    return ret;
}
7037 7038 7039 7040 7041 7042 7043 7044 7045 7046 7047 7048 7049 7050 7051 7052 7053 7054 7055 7056 7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067


/**
 * qemuDomainDefValidateDiskLunSource:
 * @src: disk source struct
 *
 * Validate whether the disk source is valid for disk device='lun'.
 *
 * Returns 0 if the configuration is valid -1 and a libvirt error if the soure
 * is invalid.
 */
int
qemuDomainDefValidateDiskLunSource(const virStorageSource *src)
{
    if (virStorageSourceGetActualType(src) == VIR_STORAGE_TYPE_NETWORK) {
        if (src->protocol != VIR_STORAGE_NET_PROTOCOL_ISCSI) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("disk device='lun' is not supported "
                             "for protocol='%s'"),
                           virStorageNetProtocolTypeToString(src->protocol));
            return -1;
        }
    } else if (!virStorageSourceIsBlockLocal(src)) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("disk device='lun' is only valid for block "
                         "type disk source"));
        return -1;
    }

    return 0;
}
7068 7069 7070 7071 7072 7073 7074


int
qemuDomainPrepareChannel(virDomainChrDefPtr channel,
                         const char *domainChannelTargetDir)
{
    if (channel->targetType == VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO &&
7075 7076 7077
        channel->source->type == VIR_DOMAIN_CHR_TYPE_UNIX &&
        !channel->source->data.nix.path) {
        if (virAsprintf(&channel->source->data.nix.path,
7078 7079 7080 7081 7082
                        "%s/%s", domainChannelTargetDir,
                        channel->target.name ? channel->target.name
                        : "unknown.sock") < 0)
            return -1;

7083
        channel->source->data.nix.listen = true;
7084 7085 7086 7087
    }

    return 0;
}
7088 7089


7090 7091 7092 7093 7094 7095 7096 7097 7098 7099 7100 7101 7102 7103 7104 7105 7106 7107
/* qemuProcessPrepareDomainChardevSourceTLS:
 * @source: pointer to host interface data for char devices
 * @cfg: driver configuration
 *
 * Updates host interface TLS encryption setting based on qemu.conf
 * for char devices.  This will be presented as "tls='yes|no'" in
 * live XML of a guest.
 */
void
qemuDomainPrepareChardevSourceTLS(virDomainChrSourceDefPtr source,
                                  virQEMUDriverConfigPtr cfg)
{
    if (source->type == VIR_DOMAIN_CHR_TYPE_TCP) {
        if (source->data.tcp.haveTLS == VIR_TRISTATE_BOOL_ABSENT) {
            if (cfg->chardevTLS)
                source->data.tcp.haveTLS = VIR_TRISTATE_BOOL_YES;
            else
                source->data.tcp.haveTLS = VIR_TRISTATE_BOOL_NO;
7108
            source->data.tcp.tlsFromConfig = true;
7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119 7120 7121 7122 7123 7124 7125 7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136 7137 7138 7139 7140 7141 7142 7143 7144 7145 7146 7147 7148 7149 7150 7151 7152 7153 7154 7155 7156
        }
    }
}


/* qemuProcessPrepareDomainChardevSource:
 * @def: live domain definition
 * @driver: qemu driver
 *
 * Iterate through all devices that use virDomainChrSourceDefPtr as host
 * interface part.
 */
void
qemuDomainPrepareChardevSource(virDomainDefPtr def,
                               virQEMUDriverPtr driver)
{
    size_t i;
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);

    for (i = 0; i < def->nserials; i++)
        qemuDomainPrepareChardevSourceTLS(def->serials[i]->source, cfg);

    for (i = 0; i < def->nparallels; i++)
        qemuDomainPrepareChardevSourceTLS(def->parallels[i]->source, cfg);

    for (i = 0; i < def->nchannels; i++)
        qemuDomainPrepareChardevSourceTLS(def->channels[i]->source, cfg);

    for (i = 0; i < def->nconsoles; i++)
        qemuDomainPrepareChardevSourceTLS(def->consoles[i]->source, cfg);

    for (i = 0; i < def->nrngs; i++)
        if (def->rngs[i]->backend == VIR_DOMAIN_RNG_BACKEND_EGD)
            qemuDomainPrepareChardevSourceTLS(def->rngs[i]->source.chardev, cfg);

    for (i = 0; i < def->nsmartcards; i++)
        if (def->smartcards[i]->type == VIR_DOMAIN_SMARTCARD_TYPE_PASSTHROUGH)
            qemuDomainPrepareChardevSourceTLS(def->smartcards[i]->data.passthru,
                                              cfg);

    for (i = 0; i < def->nredirdevs; i++)
        qemuDomainPrepareChardevSourceTLS(def->redirdevs[i]->source, cfg);

    virObjectUnref(cfg);
}



7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167 7168 7169
int
qemuDomainPrepareShmemChardev(virDomainShmemDefPtr shmem)
{
    if (!shmem->server.enabled ||
        shmem->server.chr.data.nix.path)
        return 0;

    return virAsprintf(&shmem->server.chr.data.nix.path,
                       "/var/lib/libvirt/shmem-%s-sock",
                       shmem->name);
}


7170 7171 7172 7173 7174 7175 7176 7177 7178 7179 7180 7181 7182 7183 7184 7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197 7198 7199 7200 7201 7202
/**
 * qemuDomainVcpuHotplugIsInOrder:
 * @def: domain definition
 *
 * Returns true if online vcpus were added in order (clustered behind vcpu0
 * with increasing order).
 */
bool
qemuDomainVcpuHotplugIsInOrder(virDomainDefPtr def)
{
    size_t maxvcpus = virDomainDefGetVcpusMax(def);
    virDomainVcpuDefPtr vcpu;
    unsigned int prevorder = 0;
    size_t seenonlinevcpus = 0;
    size_t i;

    for (i = 0; i < maxvcpus; i++) {
        vcpu = virDomainDefGetVcpu(def, i);

        if (!vcpu->online)
            break;

        if (vcpu->order < prevorder)
            break;

        if (vcpu->order > prevorder)
            prevorder = vcpu->order;

        seenonlinevcpus++;
    }

    return seenonlinevcpus == virDomainDefGetVcpus(def);
}
7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213 7214 7215 7216 7217 7218 7219 7220 7221 7222 7223 7224 7225 7226 7227 7228 7229 7230 7231 7232 7233 7234 7235 7236


/**
 * qemuDomainVcpuPersistOrder:
 * @def: domain definition
 *
 * Saves the order of vcpus detected from qemu to the domain definition.
 * The private data note the order only for the entry describing the
 * hotpluggable entity. This function copies the order into the definition part
 * of all sub entities.
 */
void
qemuDomainVcpuPersistOrder(virDomainDefPtr def)
{
    size_t maxvcpus = virDomainDefGetVcpusMax(def);
    virDomainVcpuDefPtr vcpu;
    qemuDomainVcpuPrivatePtr vcpupriv;
    unsigned int prevorder = 0;
    size_t i;

    for (i = 0; i < maxvcpus; i++) {
        vcpu = virDomainDefGetVcpu(def, i);
        vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpu);

        if (!vcpu->online) {
            vcpu->order = 0;
        } else {
            if (vcpupriv->enable_id != 0)
                prevorder = vcpupriv->enable_id;

            vcpu->order = prevorder;
        }
    }
}
7237 7238 7239 7240 7241 7242 7243 7244 7245 7246 7247 7248 7249 7250 7251 7252 7253 7254 7255 7256


int
qemuDomainCheckMonitor(virQEMUDriverPtr driver,
                       virDomainObjPtr vm,
                       qemuDomainAsyncJob asyncJob)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    int ret;

    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
        return -1;

    ret = qemuMonitorCheck(priv->mon);

    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        return -1;

    return ret;
}
7257 7258 7259 7260 7261 7262 7263 7264 7265 7266 7267 7268


bool
qemuDomainSupportsVideoVga(virDomainVideoDefPtr video,
                           virQEMUCapsPtr qemuCaps)
{
    if (video->type == VIR_DOMAIN_VIDEO_TYPE_VIRTIO &&
        !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VIRTIO_VGA))
        return false;

    return true;
}
7269 7270


7271 7272
/**
 * qemuDomainGetHostdevPath:
7273
 * @def: domain definition
7274
 * @dev: host device definition
7275
 * @teardown: true if device will be removed
7276
 * @npaths: number of items in @path and @perms arrays
7277 7278 7279
 * @path: resulting path to @dev
 * @perms: Optional pointer to VIR_CGROUP_DEVICE_* perms
 *
7280 7281 7282 7283 7284 7285
 * For given device @dev fetch its host path and store it at
 * @path. If a device requires other paths to be present/allowed
 * they are stored in the @path array after the actual path.
 * Optionally, caller can get @perms on the path (e.g. rw/ro).
 *
 * The caller is responsible for freeing the memory.
7286 7287 7288 7289
 *
 * Returns 0 on success, -1 otherwise.
 */
int
7290 7291 7292
qemuDomainGetHostdevPath(virDomainDefPtr def,
                         virDomainHostdevDefPtr dev,
                         bool teardown,
7293 7294 7295
                         size_t *npaths,
                         char ***path,
                         int **perms)
7296 7297 7298 7299 7300 7301
{
    int ret = -1;
    virDomainHostdevSubsysUSBPtr usbsrc = &dev->source.subsys.u.usb;
    virDomainHostdevSubsysPCIPtr pcisrc = &dev->source.subsys.u.pci;
    virDomainHostdevSubsysSCSIPtr scsisrc = &dev->source.subsys.u.scsi;
    virDomainHostdevSubsysSCSIVHostPtr hostsrc = &dev->source.subsys.u.scsi_host;
7302
    virDomainHostdevSubsysMediatedDevPtr mdevsrc = &dev->source.subsys.u.mdev;
7303 7304 7305 7306 7307 7308
    virPCIDevicePtr pci = NULL;
    virUSBDevicePtr usb = NULL;
    virSCSIDevicePtr scsi = NULL;
    virSCSIVHostDevicePtr host = NULL;
    char *tmpPath = NULL;
    bool freeTmpPath = false;
7309 7310 7311 7312 7313
    bool includeVFIO = false;
    char **tmpPaths = NULL;
    int *tmpPerms = NULL;
    size_t i, tmpNpaths = 0;
    int perm = 0;
7314

7315
    *npaths = 0;
7316 7317 7318 7319 7320 7321 7322 7323 7324 7325 7326 7327 7328 7329 7330 7331

    switch ((virDomainHostdevMode) dev->mode) {
    case VIR_DOMAIN_HOSTDEV_MODE_SUBSYS:
        switch ((virDomainHostdevSubsysType) dev->source.subsys.type) {
        case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI:
            if (pcisrc->backend == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO) {
                pci = virPCIDeviceNew(pcisrc->addr.domain,
                                      pcisrc->addr.bus,
                                      pcisrc->addr.slot,
                                      pcisrc->addr.function);
                if (!pci)
                    goto cleanup;

                if (!(tmpPath = virPCIDeviceGetIOMMUGroupDev(pci)))
                    goto cleanup;
                freeTmpPath = true;
7332 7333

                perm = VIR_CGROUP_DEVICE_RW;
7334 7335 7336 7337 7338 7339 7340 7341 7342 7343 7344 7345 7346 7347 7348
                if (teardown) {
                    size_t nvfios = 0;
                    for (i = 0; i < def->nhostdevs; i++) {
                        virDomainHostdevDefPtr tmp = def->hostdevs[i];
                        if (tmp->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
                            tmp->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI &&
                            tmp->source.subsys.u.pci.backend == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO)
                            nvfios++;
                    }

                    if (nvfios == 0)
                        includeVFIO = true;
                } else {
                    includeVFIO = true;
                }
7349 7350 7351 7352 7353 7354 7355 7356 7357 7358 7359 7360 7361 7362
            }
            break;

        case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB:
            if (dev->missing)
                break;
            usb = virUSBDeviceNew(usbsrc->bus,
                                  usbsrc->device,
                                  NULL);
            if (!usb)
                goto cleanup;

            if (!(tmpPath = (char *) virUSBDeviceGetPath(usb)))
                goto cleanup;
7363
            perm = VIR_CGROUP_DEVICE_RW;
7364 7365 7366 7367 7368 7369 7370 7371 7372 7373 7374 7375 7376 7377 7378 7379 7380 7381 7382 7383 7384 7385 7386 7387
            break;

        case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI:
            if (scsisrc->protocol == VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_ISCSI) {
                virDomainHostdevSubsysSCSIiSCSIPtr iscsisrc = &scsisrc->u.iscsi;
                /* Follow qemuSetupDiskCgroup() and qemuSetImageCgroupInternal()
                 * which does nothing for non local storage
                 */
                VIR_DEBUG("Not updating /dev for hostdev iSCSI path '%s'", iscsisrc->path);
            } else {
                virDomainHostdevSubsysSCSIHostPtr scsihostsrc = &scsisrc->u.host;
                scsi = virSCSIDeviceNew(NULL,
                                        scsihostsrc->adapter,
                                        scsihostsrc->bus,
                                        scsihostsrc->target,
                                        scsihostsrc->unit,
                                        dev->readonly,
                                        dev->shareable);

                if (!scsi)
                    goto cleanup;

                if (!(tmpPath = (char *) virSCSIDeviceGetPath(scsi)))
                    goto cleanup;
7388 7389
                perm = virSCSIDeviceGetReadonly(scsi) ?
                    VIR_CGROUP_DEVICE_READ : VIR_CGROUP_DEVICE_RW;
7390 7391 7392 7393 7394 7395 7396 7397 7398 7399 7400
            }
            break;

        case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI_HOST: {
            if (hostsrc->protocol ==
                VIR_DOMAIN_HOSTDEV_SUBSYS_SCSI_HOST_PROTOCOL_TYPE_VHOST) {
                if (!(host = virSCSIVHostDeviceNew(hostsrc->wwpn)))
                    goto cleanup;

                if (!(tmpPath = (char *) virSCSIVHostDeviceGetPath(host)))
                    goto cleanup;
7401
                perm = VIR_CGROUP_DEVICE_RW;
7402 7403 7404 7405
            }
            break;
        }

7406
        case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_MDEV:
7407
            if (!(tmpPath = virMediatedDeviceGetIOMMUGroupDev(mdevsrc->uuidstr)))
7408 7409 7410 7411 7412 7413
                goto cleanup;

            freeTmpPath = true;
            includeVFIO = true;
            perm = VIR_CGROUP_DEVICE_RW;
            break;
7414 7415 7416 7417 7418 7419 7420 7421 7422 7423 7424
        case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_LAST:
            break;
        }
        break;

    case VIR_DOMAIN_HOSTDEV_MODE_CAPABILITIES:
    case VIR_DOMAIN_HOSTDEV_MODE_LAST:
        /* nada */
        break;
    }

7425 7426 7427 7428 7429
    if (tmpPath) {
        size_t toAlloc = 1;

        if (includeVFIO)
            toAlloc = 2;
7430

7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441 7442 7443 7444 7445 7446 7447 7448 7449 7450 7451 7452
        if (VIR_ALLOC_N(tmpPaths, toAlloc) < 0 ||
            VIR_ALLOC_N(tmpPerms, toAlloc) < 0 ||
            VIR_STRDUP(tmpPaths[0], tmpPath) < 0)
            goto cleanup;
        tmpNpaths = toAlloc;
        tmpPerms[0] = perm;

        if (includeVFIO) {
            if (VIR_STRDUP(tmpPaths[1], DEV_VFIO) < 0)
                goto cleanup;
            tmpPerms[1] = VIR_CGROUP_DEVICE_RW;
        }
    }

    *npaths = tmpNpaths;
    tmpNpaths = 0;
    *path = tmpPaths;
    tmpPaths = NULL;
    if (perms) {
        *perms = tmpPerms;
        tmpPerms = NULL;
    }
7453 7454
    ret = 0;
 cleanup:
7455 7456 7457 7458
    for (i = 0; i < tmpNpaths; i++)
        VIR_FREE(tmpPaths[i]);
    VIR_FREE(tmpPaths);
    VIR_FREE(tmpPerms);
7459 7460 7461 7462 7463 7464 7465 7466 7467 7468
    virPCIDeviceFree(pci);
    virUSBDeviceFree(usb);
    virSCSIDeviceFree(scsi);
    virSCSIVHostDeviceFree(host);
    if (freeTmpPath)
        VIR_FREE(tmpPath);
    return ret;
}


7469 7470 7471 7472 7473 7474 7475 7476 7477 7478 7479 7480
/**
 * qemuDomainGetPreservedMounts:
 *
 * Process list of mounted filesystems and:
 * a) save all FSs mounted under /dev to @devPath
 * b) generate backup path for all the entries in a)
 *
 * Any of the return pointers can be NULL.
 *
 * Returns 0 on success, -1 otherwise (with error reported)
 */
static int
7481
qemuDomainGetPreservedMounts(virQEMUDriverConfigPtr cfg,
7482 7483 7484 7485 7486 7487 7488 7489 7490 7491 7492 7493 7494 7495 7496 7497 7498 7499 7500 7501 7502 7503 7504 7505 7506 7507 7508 7509 7510 7511 7512 7513 7514 7515 7516 7517 7518 7519 7520 7521 7522 7523 7524 7525 7526 7527 7528 7529 7530 7531 7532 7533 7534 7535
                             virDomainObjPtr vm,
                             char ***devPath,
                             char ***devSavePath,
                             size_t *ndevPath)
{
    char **paths = NULL, **mounts = NULL;
    size_t i, nmounts;

    if (virFileGetMountSubtree(PROC_MOUNTS, "/dev",
                               &mounts, &nmounts) < 0)
        goto error;

    if (!nmounts) {
        if (ndevPath)
            *ndevPath = 0;
        return 0;
    }

    if (VIR_ALLOC_N(paths, nmounts) < 0)
        goto error;

    for (i = 0; i < nmounts; i++) {
        const char *suffix = mounts[i] + strlen(DEVPREFIX);

        if (STREQ(mounts[i], "/dev"))
            suffix = "dev";

        if (virAsprintf(&paths[i], "%s/%s.%s",
                        cfg->stateDir, vm->def->name, suffix) < 0)
            goto error;
    }

    if (devPath)
        *devPath = mounts;
    else
        virStringListFreeCount(mounts, nmounts);

    if (devSavePath)
        *devSavePath = paths;
    else
        virStringListFreeCount(paths, nmounts);

    if (ndevPath)
        *ndevPath = nmounts;

    return 0;

 error:
    virStringListFreeCount(mounts, nmounts);
    virStringListFreeCount(paths, nmounts);
    return -1;
}


7536 7537
struct qemuDomainCreateDeviceData {
    const char *path;     /* Path to temp new /dev location */
7538 7539
    char * const *devMountsPath;
    size_t ndevMountsPath;
7540 7541 7542
};


7543
static int
7544
qemuDomainCreateDeviceRecursive(const char *device,
7545
                                const struct qemuDomainCreateDeviceData *data,
7546 7547
                                bool allow_noent,
                                unsigned int ttl)
7548 7549
{
    char *devicePath = NULL;
7550
    char *target = NULL;
7551 7552
    struct stat sb;
    int ret = -1;
7553 7554
    bool isLink = false;
    bool create = false;
7555 7556 7557
#ifdef WITH_SELINUX
    char *tcon = NULL;
#endif
7558

7559 7560 7561 7562 7563 7564 7565
    if (!ttl) {
        virReportSystemError(ELOOP,
                             _("Too many levels of symbolic links: %s"),
                             device);
        return ret;
    }

7566
    if (lstat(device, &sb) < 0) {
7567 7568
        if (errno == ENOENT && allow_noent) {
            /* Ignore non-existent device. */
7569
            return 0;
7570
        }
7571 7572
        virReportSystemError(errno, _("Unable to stat %s"), device);
        return ret;
7573 7574
    }

7575 7576 7577 7578 7579 7580 7581 7582 7583 7584 7585 7586 7587 7588 7589 7590 7591 7592
    isLink = S_ISLNK(sb.st_mode);

    /* Here, @device might be whatever path in the system. We
     * should create the path in the namespace iff it's "/dev"
     * prefixed. However, if it is a symlink, we need to traverse
     * it too (it might point to something in "/dev"). Just
     * consider:
     *
     *   /var/sym1 -> /var/sym2 -> /dev/sda  (because users can)
     *
     * This means, "/var/sym1" is not created (it's shared with
     * the parent namespace), nor "/var/sym2", but "/dev/sda".
     *
     * TODO Remove all `.' and `..' from the @device path.
     * Otherwise we might get fooled with `/dev/../var/my_image'.
     * For now, lets hope callers play nice.
     */
    if (STRPREFIX(device, DEVPREFIX)) {
7593
        size_t i;
7594

7595 7596 7597 7598 7599 7600 7601 7602 7603 7604 7605 7606 7607 7608 7609 7610 7611 7612 7613 7614 7615 7616 7617 7618 7619
        for (i = 0; i < data->ndevMountsPath; i++) {
            if (STREQ(data->devMountsPath[i], "/dev"))
                continue;
            if (STRPREFIX(device, data->devMountsPath[i]))
                break;
        }

        if (i == data->ndevMountsPath) {
            /* Okay, @device is in /dev but not in any mount point under /dev.
             * Create it. */
            if (virAsprintf(&devicePath, "%s/%s",
                            data->path, device + strlen(DEVPREFIX)) < 0)
                goto cleanup;

            if (virFileMakeParentPath(devicePath) < 0) {
                virReportSystemError(errno,
                                     _("Unable to create %s"),
                                     devicePath);
                goto cleanup;
            }
            VIR_DEBUG("Creating dev %s", device);
            create = true;
        } else {
            VIR_DEBUG("Skipping dev %s because of %s mount point",
                      device, data->devMountsPath[i]);
7620
        }
7621 7622
    }

7623 7624 7625 7626 7627 7628 7629 7630 7631
    if (isLink) {
        /* We are dealing with a symlink. Create a dangling symlink and descend
         * down one level which hopefully creates the symlink's target. */
        if (virFileReadLink(device, &target) < 0) {
            virReportSystemError(errno,
                                 _("unable to resolve symlink %s"),
                                 device);
            goto cleanup;
        }
7632

7633 7634 7635 7636 7637 7638 7639 7640 7641
        if (create &&
            symlink(target, devicePath) < 0) {
            if (errno == EEXIST) {
                ret = 0;
            } else {
                virReportSystemError(errno,
                                     _("unable to create symlink %s"),
                                     devicePath);
            }
7642 7643 7644
            goto cleanup;
        }

7645 7646 7647 7648 7649 7650 7651 7652 7653 7654
        /* Tricky part. If the target starts with a slash then we need to take
         * it as it is. Otherwise we need to replace the last component in the
         * original path with the link target:
         * /dev/rtc -> rtc0 (want /dev/rtc0)
         * /dev/disk/by-id/ata-SanDisk_SDSSDXPS480G_161101402485 -> ../../sda
         *   (want /dev/disk/by-id/../../sda)
         * /dev/stdout -> /proc/self/fd/1 (no change needed)
         */
        if (IS_RELATIVE_FILE_NAME(target)) {
            char *c = NULL, *tmp = NULL, *devTmp = NULL;
7655

7656 7657
            if (VIR_STRDUP(devTmp, device) < 0)
                goto cleanup;
7658

7659 7660 7661 7662 7663 7664 7665 7666 7667 7668 7669 7670 7671
            if ((c = strrchr(devTmp, '/')))
                *(c + 1) = '\0';

            if (virAsprintf(&tmp, "%s%s", devTmp, target) < 0) {
                VIR_FREE(devTmp);
                goto cleanup;
            }
            VIR_FREE(devTmp);
            VIR_FREE(target);
            target = tmp;
            tmp = NULL;
        }

7672
        if (qemuDomainCreateDeviceRecursive(target, data,
7673
                                            allow_noent, ttl - 1) < 0)
7674 7675 7676 7677 7678 7679 7680 7681 7682 7683 7684 7685
            goto cleanup;
    } else {
        if (create &&
            mknod(devicePath, sb.st_mode, sb.st_rdev) < 0) {
            if (errno == EEXIST) {
                ret = 0;
            } else {
                virReportSystemError(errno,
                                     _("Failed to make device %s"),
                                     devicePath);
            }
            goto cleanup;
7686
        }
7687 7688 7689 7690 7691 7692 7693 7694 7695 7696

        /* Set the file permissions again: mknod() is affected by the
         * current umask, and as such might not have set them correctly */
        if (create &&
            chmod(devicePath, sb.st_mode) < 0) {
            virReportSystemError(errno,
                                 _("Failed to set permissions for device %s"),
                                 devicePath);
            goto cleanup;
        }
7697 7698 7699 7700
    }

    if (!create) {
        ret = 0;
7701 7702 7703
        goto cleanup;
    }

7704
    if (lchown(devicePath, sb.st_uid, sb.st_gid) < 0) {
7705 7706 7707 7708 7709 7710
        virReportSystemError(errno,
                             _("Failed to chown device %s"),
                             devicePath);
        goto cleanup;
    }

7711 7712 7713
    /* Symlinks don't have ACLs. */
    if (!isLink &&
        virFileCopyACLs(device, devicePath) < 0 &&
7714 7715 7716 7717 7718 7719 7720
        errno != ENOTSUP) {
        virReportSystemError(errno,
                             _("Failed to copy ACLs on device %s"),
                             devicePath);
        goto cleanup;
    }

7721
#ifdef WITH_SELINUX
7722
    if (lgetfilecon_raw(device, &tcon) < 0 &&
7723 7724 7725
        (errno != ENOTSUP && errno != ENODATA)) {
        virReportSystemError(errno,
                             _("Unable to get SELinux label from %s"),
7726
                             device);
7727 7728 7729 7730
        goto cleanup;
    }

    if (tcon &&
7731
        lsetfilecon_raw(devicePath, (VIR_SELINUX_CTX_CONST char *) tcon) < 0) {
7732 7733 7734 7735 7736 7737 7738 7739 7740 7741 7742
        VIR_WARNINGS_NO_WLOGICALOP_EQUAL_EXPR
        if (errno != EOPNOTSUPP && errno != ENOTSUP) {
        VIR_WARNINGS_RESET
            virReportSystemError(errno,
                                 _("Unable to set SELinux label on %s"),
                                 devicePath);
            goto cleanup;
        }
    }
#endif

7743 7744
    ret = 0;
 cleanup:
7745
    VIR_FREE(target);
7746
    VIR_FREE(devicePath);
7747 7748 7749
#ifdef WITH_SELINUX
    freecon(tcon);
#endif
7750 7751 7752 7753
    return ret;
}


7754 7755
static int
qemuDomainCreateDevice(const char *device,
7756
                       const struct qemuDomainCreateDeviceData *data,
7757 7758 7759 7760
                       bool allow_noent)
{
    long symloop_max = sysconf(_SC_SYMLOOP_MAX);

7761
    return qemuDomainCreateDeviceRecursive(device, data,
7762 7763 7764
                                           allow_noent, symloop_max);
}

7765 7766

static int
7767
qemuDomainPopulateDevices(virQEMUDriverConfigPtr cfg,
7768
                          virDomainObjPtr vm ATTRIBUTE_UNUSED,
7769
                          const struct qemuDomainCreateDeviceData *data)
7770 7771 7772 7773 7774 7775 7776 7777 7778
{
    const char *const *devices = (const char *const *) cfg->cgroupDeviceACL;
    size_t i;
    int ret = -1;

    if (!devices)
        devices = defaultDeviceACL;

    for (i = 0; devices[i]; i++) {
7779
        if (qemuDomainCreateDevice(devices[i], data, true) < 0)
7780 7781 7782 7783 7784 7785 7786 7787 7788 7789
            goto cleanup;
    }

    ret = 0;
 cleanup:
    return ret;
}


static int
7790 7791
qemuDomainSetupDev(virQEMUDriverConfigPtr cfg,
                   virSecurityManagerPtr mgr,
7792
                   virDomainObjPtr vm,
7793
                   const struct qemuDomainCreateDeviceData *data)
7794 7795 7796 7797 7798 7799 7800
{
    char *mount_options = NULL;
    char *opts = NULL;
    int ret = -1;

    VIR_DEBUG("Setting up /dev/ for domain %s", vm->def->name);

7801
    mount_options = qemuSecurityGetMountOptions(mgr, vm->def);
7802 7803 7804 7805 7806 7807 7808 7809 7810 7811 7812 7813 7814

    if (!mount_options &&
        VIR_STRDUP(mount_options, "") < 0)
        goto cleanup;

    /*
     * tmpfs is limited to 64kb, since we only have device nodes in there
     * and don't want to DOS the entire OS RAM usage
     */
    if (virAsprintf(&opts,
                    "mode=755,size=65536%s", mount_options) < 0)
        goto cleanup;

7815
    if (virFileSetupDev(data->path, opts) < 0)
7816 7817
        goto cleanup;

7818
    if (qemuDomainPopulateDevices(cfg, vm, data) < 0)
7819 7820 7821 7822 7823 7824 7825 7826 7827 7828
        goto cleanup;

    ret = 0;
 cleanup:
    VIR_FREE(opts);
    VIR_FREE(mount_options);
    return ret;
}


7829
static int
7830
qemuDomainSetupDisk(virQEMUDriverConfigPtr cfg ATTRIBUTE_UNUSED,
7831
                    virDomainDiskDefPtr disk,
7832
                    const struct qemuDomainCreateDeviceData *data)
7833 7834 7835 7836 7837 7838
{
    virStorageSourcePtr next;
    char *dst = NULL;
    int ret = -1;

    for (next = disk->src; next; next = next->backingStore) {
7839
        if (!next->path || !virStorageSourceIsLocalStorage(next)) {
7840 7841 7842 7843
            /* Not creating device. Just continue. */
            continue;
        }

7844
        if (qemuDomainCreateDevice(next->path, data, false) < 0)
7845 7846 7847 7848 7849 7850 7851 7852 7853 7854 7855
            goto cleanup;
    }

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


static int
7856
qemuDomainSetupAllDisks(virQEMUDriverConfigPtr cfg,
7857
                        virDomainObjPtr vm,
7858
                        const struct qemuDomainCreateDeviceData *data)
7859 7860 7861 7862 7863
{
    size_t i;
    VIR_DEBUG("Setting up disks");

    for (i = 0; i < vm->def->ndisks; i++) {
7864
        if (qemuDomainSetupDisk(cfg,
7865
                                vm->def->disks[i],
7866
                                data) < 0)
7867 7868 7869 7870 7871 7872 7873 7874
            return -1;
    }

    VIR_DEBUG("Setup all disks");
    return 0;
}


7875
static int
7876
qemuDomainSetupHostdev(virQEMUDriverConfigPtr cfg ATTRIBUTE_UNUSED,
7877
                       virDomainHostdevDefPtr dev,
7878
                       const struct qemuDomainCreateDeviceData *data)
7879 7880
{
    int ret = -1;
7881 7882
    char **path = NULL;
    size_t i, npaths = 0;
7883

7884
    if (qemuDomainGetHostdevPath(NULL, dev, false, &npaths, &path, NULL) < 0)
7885 7886
        goto cleanup;

7887
    for (i = 0; i < npaths; i++) {
7888
        if (qemuDomainCreateDevice(path[i], data, false) < 0)
7889
            goto cleanup;
7890 7891 7892 7893
    }

    ret = 0;
 cleanup:
7894 7895
    for (i = 0; i < npaths; i++)
        VIR_FREE(path[i]);
7896 7897 7898 7899 7900 7901
    VIR_FREE(path);
    return ret;
}


static int
7902
qemuDomainSetupAllHostdevs(virQEMUDriverConfigPtr cfg,
7903
                           virDomainObjPtr vm,
7904
                           const struct qemuDomainCreateDeviceData *data)
7905 7906 7907 7908 7909
{
    size_t i;

    VIR_DEBUG("Setting up hostdevs");
    for (i = 0; i < vm->def->nhostdevs; i++) {
7910
        if (qemuDomainSetupHostdev(cfg,
7911
                                   vm->def->hostdevs[i],
7912
                                   data) < 0)
7913 7914 7915 7916 7917 7918 7919
            return -1;
    }
    VIR_DEBUG("Setup all hostdevs");
    return 0;
}


M
Michal Privoznik 已提交
7920 7921 7922
static int
qemuDomainSetupMemory(virQEMUDriverConfigPtr cfg ATTRIBUTE_UNUSED,
                      virDomainMemoryDefPtr mem,
7923
                      const struct qemuDomainCreateDeviceData *data)
M
Michal Privoznik 已提交
7924 7925 7926 7927
{
    if (mem->model != VIR_DOMAIN_MEMORY_MODEL_NVDIMM)
        return 0;

7928
    return qemuDomainCreateDevice(mem->nvdimmPath, data, false);
M
Michal Privoznik 已提交
7929 7930 7931 7932 7933 7934
}


static int
qemuDomainSetupAllMemories(virQEMUDriverConfigPtr cfg,
                           virDomainObjPtr vm,
7935
                           const struct qemuDomainCreateDeviceData *data)
M
Michal Privoznik 已提交
7936 7937 7938 7939 7940 7941 7942
{
    size_t i;

    VIR_DEBUG("Setting up memories");
    for (i = 0; i < vm->def->nmems; i++) {
        if (qemuDomainSetupMemory(cfg,
                                  vm->def->mems[i],
7943
                                  data) < 0)
M
Michal Privoznik 已提交
7944 7945 7946 7947 7948 7949 7950
            return -1;
    }
    VIR_DEBUG("Setup all memories");
    return 0;
}


7951 7952 7953 7954 7955
static int
qemuDomainSetupChardev(virDomainDefPtr def ATTRIBUTE_UNUSED,
                       virDomainChrDefPtr dev,
                       void *opaque)
{
7956
    const struct qemuDomainCreateDeviceData *data = opaque;
7957 7958 7959 7960

    if (dev->source->type != VIR_DOMAIN_CHR_TYPE_DEV)
        return 0;

7961
    return qemuDomainCreateDevice(dev->source->data.file.path, data, false);
7962 7963 7964 7965
}


static int
7966
qemuDomainSetupAllChardevs(virQEMUDriverConfigPtr cfg ATTRIBUTE_UNUSED,
7967
                           virDomainObjPtr vm,
7968
                           const struct qemuDomainCreateDeviceData *data)
7969 7970 7971 7972 7973 7974
{
    VIR_DEBUG("Setting up chardevs");

    if (virDomainChrDefForeach(vm->def,
                               true,
                               qemuDomainSetupChardev,
7975
                               (void *) data) < 0)
7976 7977 7978 7979 7980 7981 7982
        return -1;

    VIR_DEBUG("Setup all chardevs");
    return 0;
}


7983
static int
7984
qemuDomainSetupTPM(virQEMUDriverConfigPtr cfg ATTRIBUTE_UNUSED,
7985
                   virDomainObjPtr vm,
7986
                   const struct qemuDomainCreateDeviceData *data)
7987 7988 7989 7990 7991 7992 7993 7994 7995 7996 7997
{
    virDomainTPMDefPtr dev = vm->def->tpm;

    if (!dev)
        return 0;

    VIR_DEBUG("Setting up TPM");

    switch (dev->type) {
    case VIR_DOMAIN_TPM_TYPE_PASSTHROUGH:
        if (qemuDomainCreateDevice(dev->data.passthrough.source.data.file.path,
7998
                                   data, false) < 0)
7999 8000 8001 8002 8003 8004 8005 8006 8007 8008 8009 8010 8011
            return -1;
        break;

    case VIR_DOMAIN_TPM_TYPE_LAST:
        /* nada */
        break;
    }

    VIR_DEBUG("Setup TPM");
    return 0;
}


8012
static int
8013
qemuDomainSetupGraphics(virQEMUDriverConfigPtr cfg ATTRIBUTE_UNUSED,
8014
                        virDomainGraphicsDefPtr gfx,
8015
                        const struct qemuDomainCreateDeviceData *data)
8016 8017 8018 8019 8020 8021 8022 8023
{
    const char *rendernode = gfx->data.spice.rendernode;

    if (gfx->type != VIR_DOMAIN_GRAPHICS_TYPE_SPICE ||
        gfx->data.spice.gl != VIR_TRISTATE_BOOL_YES ||
        !rendernode)
        return 0;

8024
    return qemuDomainCreateDevice(rendernode, data, false);
8025 8026 8027 8028
}


static int
8029
qemuDomainSetupAllGraphics(virQEMUDriverConfigPtr cfg,
8030
                           virDomainObjPtr vm,
8031
                           const struct qemuDomainCreateDeviceData *data)
8032 8033 8034 8035 8036
{
    size_t i;

    VIR_DEBUG("Setting up graphics");
    for (i = 0; i < vm->def->ngraphics; i++) {
8037
        if (qemuDomainSetupGraphics(cfg,
8038
                                    vm->def->graphics[i],
8039
                                    data) < 0)
8040 8041 8042 8043 8044 8045 8046 8047
            return -1;
    }

    VIR_DEBUG("Setup all graphics");
    return 0;
}


8048
static int
8049
qemuDomainSetupInput(virQEMUDriverConfigPtr cfg ATTRIBUTE_UNUSED,
8050
                     virDomainInputDefPtr input,
8051
                     const struct qemuDomainCreateDeviceData *data)
8052 8053 8054 8055 8056
{
    int ret = -1;

    switch ((virDomainInputType) input->type) {
    case VIR_DOMAIN_INPUT_TYPE_PASSTHROUGH:
8057
        if (qemuDomainCreateDevice(input->source.evdev, data, false) < 0)
8058 8059 8060 8061 8062 8063 8064 8065 8066 8067 8068 8069 8070 8071 8072 8073 8074 8075
            goto cleanup;
        break;

    case VIR_DOMAIN_INPUT_TYPE_MOUSE:
    case VIR_DOMAIN_INPUT_TYPE_TABLET:
    case VIR_DOMAIN_INPUT_TYPE_KBD:
    case VIR_DOMAIN_INPUT_TYPE_LAST:
        /* nada */
        break;
    }

    ret = 0;
 cleanup:
    return ret;
}


static int
8076
qemuDomainSetupAllInputs(virQEMUDriverConfigPtr cfg,
8077
                         virDomainObjPtr vm,
8078
                         const struct qemuDomainCreateDeviceData *data)
8079 8080 8081
{
    size_t i;

8082
    VIR_DEBUG("Setting up inputs");
8083
    for (i = 0; i < vm->def->ninputs; i++) {
8084
        if (qemuDomainSetupInput(cfg,
8085
                                 vm->def->inputs[i],
8086
                                 data) < 0)
8087 8088
            return -1;
    }
8089
    VIR_DEBUG("Setup all inputs");
8090 8091 8092 8093
    return 0;
}


8094
static int
8095
qemuDomainSetupRNG(virQEMUDriverConfigPtr cfg ATTRIBUTE_UNUSED,
8096
                   virDomainRNGDefPtr rng,
8097
                   const struct qemuDomainCreateDeviceData *data)
8098 8099 8100
{
    switch ((virDomainRNGBackend) rng->backend) {
    case VIR_DOMAIN_RNG_BACKEND_RANDOM:
8101
        if (qemuDomainCreateDevice(rng->source.file, data, false) < 0)
8102 8103 8104 8105 8106 8107 8108 8109 8110 8111 8112 8113 8114
            return -1;

    case VIR_DOMAIN_RNG_BACKEND_EGD:
    case VIR_DOMAIN_RNG_BACKEND_LAST:
        /* nada */
        break;
    }

    return 0;
}


static int
8115
qemuDomainSetupAllRNGs(virQEMUDriverConfigPtr cfg,
8116
                       virDomainObjPtr vm,
8117
                       const struct qemuDomainCreateDeviceData *data)
8118 8119 8120 8121 8122
{
    size_t i;

    VIR_DEBUG("Setting up RNGs");
    for (i = 0; i < vm->def->nrngs; i++) {
8123
        if (qemuDomainSetupRNG(cfg,
8124
                               vm->def->rngs[i],
8125
                               data) < 0)
8126 8127 8128 8129 8130 8131 8132 8133
            return -1;
    }

    VIR_DEBUG("Setup all RNGs");
    return 0;
}


8134
int
8135 8136
qemuDomainBuildNamespace(virQEMUDriverConfigPtr cfg,
                         virSecurityManagerPtr mgr,
8137 8138
                         virDomainObjPtr vm)
{
8139
    struct qemuDomainCreateDeviceData data;
8140
    char *devPath = NULL;
8141
    char **devMountsPath = NULL, **devMountsSavePath = NULL;
8142 8143 8144 8145 8146 8147 8148 8149
    size_t ndevMountsPath = 0, i;
    int ret = -1;

    if (!qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT)) {
        ret = 0;
        goto cleanup;
    }

8150
    if (qemuDomainGetPreservedMounts(cfg, vm,
8151 8152
                                     &devMountsPath, &devMountsSavePath,
                                     &ndevMountsPath) < 0)
8153 8154
        goto cleanup;

8155 8156 8157 8158 8159 8160 8161 8162 8163 8164 8165 8166 8167
    for (i = 0; i < ndevMountsPath; i++) {
        if (STREQ(devMountsPath[i], "/dev")) {
            devPath = devMountsSavePath[i];
            break;
        }
    }

    if (!devPath) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("Unable to find any /dev mount"));
        goto cleanup;
    }

8168
    data.path = devPath;
8169 8170
    data.devMountsPath = devMountsPath;
    data.ndevMountsPath = ndevMountsPath;
8171

8172 8173 8174
    if (virProcessSetupPrivateMountNS() < 0)
        goto cleanup;

8175
    if (qemuDomainSetupDev(cfg, mgr, vm, &data) < 0)
8176 8177
        goto cleanup;

8178
    if (qemuDomainSetupAllDisks(cfg, vm, &data) < 0)
8179 8180
        goto cleanup;

8181
    if (qemuDomainSetupAllHostdevs(cfg, vm, &data) < 0)
8182 8183
        goto cleanup;

8184
    if (qemuDomainSetupAllMemories(cfg, vm, &data) < 0)
8185 8186
        goto cleanup;

8187
    if (qemuDomainSetupAllChardevs(cfg, vm, &data) < 0)
8188 8189
        goto cleanup;

8190
    if (qemuDomainSetupTPM(cfg, vm, &data) < 0)
8191 8192
        goto cleanup;

8193
    if (qemuDomainSetupAllGraphics(cfg, vm, &data) < 0)
8194 8195
        goto cleanup;

8196
    if (qemuDomainSetupAllInputs(cfg, vm, &data) < 0)
8197 8198
        goto cleanup;

8199
    if (qemuDomainSetupAllRNGs(cfg, vm, &data) < 0)
8200 8201
        goto cleanup;

8202 8203
    /* Save some mount points because we want to share them with the host */
    for (i = 0; i < ndevMountsPath; i++) {
8204 8205
        struct stat sb;

8206 8207 8208
        if (devMountsSavePath[i] == devPath)
            continue;

8209 8210 8211 8212 8213 8214 8215 8216 8217 8218
        if (stat(devMountsPath[i], &sb) < 0) {
            virReportSystemError(errno,
                                 _("Unable to stat: %s"),
                                 devMountsPath[i]);
            goto cleanup;
        }

        /* At this point, devMountsPath is either a regular file or a directory. */
        if ((S_ISDIR(sb.st_mode) && virFileMakePath(devMountsSavePath[i]) < 0) ||
            (S_ISREG(sb.st_mode) && virFileTouch(devMountsSavePath[i], sb.st_mode) < 0)) {
8219 8220 8221 8222 8223 8224
            virReportSystemError(errno,
                                 _("Failed to create %s"),
                                 devMountsSavePath[i]);
            goto cleanup;
        }

8225
        if (virFileMoveMount(devMountsPath[i], devMountsSavePath[i]) < 0)
8226 8227 8228
            goto cleanup;
    }

8229
    if (virFileMoveMount(devPath, "/dev") < 0)
8230 8231 8232
        goto cleanup;

    for (i = 0; i < ndevMountsPath; i++) {
8233 8234
        struct stat sb;

8235 8236 8237
        if (devMountsSavePath[i] == devPath)
            continue;

8238 8239 8240 8241
        if (stat(devMountsSavePath[i], &sb) < 0) {
            virReportSystemError(errno,
                                 _("Unable to stat: %s"),
                                 devMountsSavePath[i]);
8242 8243 8244
            goto cleanup;
        }

8245 8246 8247 8248 8249 8250 8251 8252 8253 8254 8255 8256 8257 8258 8259
        if (S_ISDIR(sb.st_mode)) {
            if (virFileMakePath(devMountsPath[i]) < 0) {
                virReportSystemError(errno, _("Cannot create %s"),
                                     devMountsPath[i]);
                goto cleanup;
            }
        } else {
            if (virFileMakeParentPath(devMountsPath[i]) < 0 ||
                virFileTouch(devMountsPath[i], sb.st_mode) < 0) {
                virReportSystemError(errno, _("Cannot create %s"),
                                     devMountsPath[i]);
                goto cleanup;
            }
        }

8260
        if (virFileMoveMount(devMountsSavePath[i], devMountsPath[i]) < 0)
8261 8262 8263 8264 8265
            goto cleanup;
    }

    ret = 0;
 cleanup:
8266 8267
    for (i = 0; i < ndevMountsPath; i++)
        rmdir(devMountsSavePath[i]);
8268
    virStringListFreeCount(devMountsPath, ndevMountsPath);
8269
    virStringListFreeCount(devMountsSavePath, ndevMountsPath);
8270 8271 8272 8273 8274 8275 8276 8277 8278 8279 8280
    return ret;
}


int
qemuDomainCreateNamespace(virQEMUDriverPtr driver,
                          virDomainObjPtr vm)
{
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    int ret = -1;

8281 8282
    if (virBitmapIsBitSet(cfg->namespaces, QEMU_DOMAIN_NS_MOUNT) &&
        qemuDomainEnableNamespace(vm, QEMU_DOMAIN_NS_MOUNT) < 0)
M
Michal Privoznik 已提交
8283
        goto cleanup;
8284 8285 8286 8287 8288 8289 8290 8291

    ret = 0;
 cleanup:
    virObjectUnref(cfg);
    return ret;
}


8292 8293 8294 8295 8296 8297 8298 8299 8300
void
qemuDomainDestroyNamespace(virQEMUDriverPtr driver ATTRIBUTE_UNUSED,
                           virDomainObjPtr vm)
{
    if (qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
        qemuDomainDisableNamespace(vm, QEMU_DOMAIN_NS_MOUNT);
}


8301 8302 8303 8304 8305 8306 8307 8308 8309 8310 8311 8312 8313 8314 8315 8316 8317 8318 8319 8320 8321 8322 8323 8324 8325 8326 8327 8328 8329
bool
qemuDomainNamespaceAvailable(qemuDomainNamespace ns ATTRIBUTE_UNUSED)
{
#if !defined(__linux__)
    /* Namespaces are Linux specific. */
    return false;

#else /* defined(__linux__) */

    switch (ns) {
    case QEMU_DOMAIN_NS_MOUNT:
# if !defined(HAVE_SYS_ACL_H) || !defined(WITH_SELINUX)
        /* We can't create the exact copy of paths if either of
         * these is not available. */
        return false;
# else
        if (virProcessNamespaceAvailable(VIR_PROCESS_NAMESPACE_MNT) < 0)
            return false;
# endif
        break;
    case QEMU_DOMAIN_NS_LAST:
        break;
    }

    return true;
#endif /* defined(__linux__) */
}


8330 8331 8332 8333
struct qemuDomainAttachDeviceMknodData {
    virQEMUDriverPtr driver;
    virDomainObjPtr vm;
    const char *file;
8334
    const char *target;
8335 8336
    struct stat sb;
    void *acl;
8337 8338 8339
#ifdef WITH_SELINUX
    char *tcon;
#endif
8340 8341 8342 8343 8344 8345 8346 8347 8348
};


static int
qemuDomainAttachDeviceMknodHelper(pid_t pid ATTRIBUTE_UNUSED,
                                  void *opaque)
{
    struct qemuDomainAttachDeviceMknodData *data = opaque;
    int ret = -1;
8349
    bool delDevice = false;
8350
    bool isLink = S_ISLNK(data->sb.st_mode);
8351

8352
    qemuSecurityPostFork(data->driver->securityManager);
8353 8354 8355 8356 8357 8358 8359

    if (virFileMakeParentPath(data->file) < 0) {
        virReportSystemError(errno,
                             _("Unable to create %s"), data->file);
        goto cleanup;
    }

8360 8361 8362 8363 8364 8365 8366 8367 8368 8369 8370
    if (isLink) {
        VIR_DEBUG("Creating symlink %s -> %s", data->file, data->target);
        if (symlink(data->target, data->file) < 0) {
            if (errno != EEXIST) {
                virReportSystemError(errno,
                                     _("Unable to create symlink %s"),
                                     data->target);
                goto cleanup;
            }
        } else {
            delDevice = true;
8371
        }
8372
    } else {
8373 8374 8375 8376 8377 8378 8379 8380 8381 8382 8383 8384 8385 8386 8387 8388
        VIR_DEBUG("Creating dev %s (%d,%d)",
                  data->file, major(data->sb.st_rdev), minor(data->sb.st_rdev));
        if (mknod(data->file, data->sb.st_mode, data->sb.st_rdev) < 0) {
            /* Because we are not removing devices on hotunplug, or
             * we might be creating part of backing chain that
             * already exist due to a different disk plugged to
             * domain, accept EEXIST. */
            if (errno != EEXIST) {
                virReportSystemError(errno,
                                     _("Unable to create device %s"),
                                     data->file);
                goto cleanup;
            }
        } else {
            delDevice = true;
        }
8389 8390
    }

8391 8392 8393 8394 8395 8396 8397 8398 8399 8400
    if (lchown(data->file, data->sb.st_uid, data->sb.st_gid) < 0) {
        virReportSystemError(errno,
                             _("Failed to chown device %s"),
                             data->file);
        goto cleanup;
    }

    /* Symlinks don't have ACLs. */
    if (!isLink &&
        virFileSetACLs(data->file, data->acl) < 0 &&
8401 8402 8403 8404 8405 8406
        errno != ENOTSUP) {
        virReportSystemError(errno,
                             _("Unable to set ACLs on %s"), data->file);
        goto cleanup;
    }

8407
#ifdef WITH_SELINUX
8408 8409
    if (data->tcon &&
        lsetfilecon_raw(data->file, (VIR_SELINUX_CTX_CONST char *) data->tcon) < 0) {
8410 8411 8412 8413 8414 8415 8416 8417 8418 8419 8420
        VIR_WARNINGS_NO_WLOGICALOP_EQUAL_EXPR
        if (errno != EOPNOTSUPP && errno != ENOTSUP) {
        VIR_WARNINGS_RESET
            virReportSystemError(errno,
                                 _("Unable to set SELinux label on %s"),
                                 data->file);
            goto cleanup;
        }
    }
#endif

8421 8422
    ret = 0;
 cleanup:
8423
    if (ret < 0 && delDevice)
8424
        unlink(data->file);
8425 8426 8427
#ifdef WITH_SELINUX
    freecon(data->tcon);
#endif
8428 8429 8430 8431 8432 8433
    virFileFreeACLs(&data->acl);
    return ret;
}


static int
8434 8435 8436
qemuDomainAttachDeviceMknodRecursive(virQEMUDriverPtr driver,
                                     virDomainObjPtr vm,
                                     const char *file,
8437 8438
                                     char * const *devMountsPath,
                                     size_t ndevMountsPath,
8439
                                     unsigned int ttl)
8440 8441 8442
{
    struct qemuDomainAttachDeviceMknodData data;
    int ret = -1;
8443 8444
    char *target = NULL;
    bool isLink;
8445

8446 8447 8448 8449 8450 8451 8452
    if (!ttl) {
        virReportSystemError(ELOOP,
                             _("Too many levels of symbolic links: %s"),
                             file);
        return ret;
    }

8453 8454 8455 8456 8457 8458
    memset(&data, 0, sizeof(data));

    data.driver = driver;
    data.vm = vm;
    data.file = file;

8459
    if (lstat(file, &data.sb) < 0) {
8460 8461 8462 8463 8464
        virReportSystemError(errno,
                             _("Unable to access %s"), file);
        return ret;
    }

8465 8466 8467 8468 8469 8470 8471 8472 8473 8474 8475 8476 8477 8478 8479 8480 8481 8482 8483 8484 8485 8486 8487 8488 8489 8490 8491 8492 8493 8494 8495 8496 8497 8498 8499
    isLink = S_ISLNK(data.sb.st_mode);

    if (isLink) {
        if (virFileReadLink(file, &target) < 0) {
            virReportSystemError(errno,
                                 _("unable to resolve symlink %s"),
                                 file);
            return ret;
        }

        if (IS_RELATIVE_FILE_NAME(target)) {
            char *c = NULL, *tmp = NULL, *fileTmp = NULL;

            if (VIR_STRDUP(fileTmp, file) < 0)
                goto cleanup;

            if ((c = strrchr(fileTmp, '/')))
                *(c + 1) = '\0';

            if (virAsprintf(&tmp, "%s%s", fileTmp, target) < 0) {
                VIR_FREE(fileTmp);
                goto cleanup;
            }
            VIR_FREE(fileTmp);
            VIR_FREE(target);
            target = tmp;
            tmp = NULL;
        }

        data.target = target;
    }

    /* Symlinks don't have ACLs. */
    if (!isLink &&
        virFileGetACLs(file, &data.acl) < 0 &&
8500 8501 8502
        errno != ENOTSUP) {
        virReportSystemError(errno,
                             _("Unable to get ACLs on %s"), file);
8503
        goto cleanup;
8504 8505
    }

8506
#ifdef WITH_SELINUX
8507
    if (lgetfilecon_raw(file, &data.tcon) < 0 &&
8508 8509 8510 8511 8512 8513 8514
        (errno != ENOTSUP && errno != ENODATA)) {
        virReportSystemError(errno,
                             _("Unable to get SELinux label from %s"), file);
        goto cleanup;
    }
#endif

8515
    if (STRPREFIX(file, DEVPREFIX)) {
8516 8517 8518 8519 8520 8521 8522 8523 8524 8525 8526 8527
        size_t i;

        for (i = 0; i < ndevMountsPath; i++) {
            if (STREQ(devMountsPath[i], "/dev"))
                continue;
            if (STRPREFIX(file, devMountsPath[i]))
                break;
        }

        if (i == ndevMountsPath) {
            if (qemuSecurityPreFork(driver->securityManager) < 0)
                goto cleanup;
8528

8529 8530 8531 8532 8533 8534
            if (virProcessRunInMountNamespace(vm->pid,
                                              qemuDomainAttachDeviceMknodHelper,
                                              &data) < 0) {
                qemuSecurityPostFork(driver->securityManager);
                goto cleanup;
            }
8535
            qemuSecurityPostFork(driver->securityManager);
8536 8537 8538
        } else {
            VIR_DEBUG("Skipping dev %s because of %s mount point",
                      file, devMountsPath[i]);
8539
        }
8540 8541
    }

8542
    if (isLink &&
8543 8544 8545
        qemuDomainAttachDeviceMknodRecursive(driver, vm, target,
                                             devMountsPath, ndevMountsPath,
                                             ttl -1) < 0)
8546
        goto cleanup;
8547 8548 8549

    ret = 0;
 cleanup:
8550 8551 8552
#ifdef WITH_SELINUX
    freecon(data.tcon);
#endif
8553
    virFileFreeACLs(&data.acl);
8554
    VIR_FREE(target);
8555
    return ret;
8556 8557 8558
}


8559 8560 8561
static int
qemuDomainAttachDeviceMknod(virQEMUDriverPtr driver,
                            virDomainObjPtr vm,
8562 8563 8564
                            const char *file,
                            char * const *devMountsPath,
                            size_t ndevMountsPath)
8565 8566 8567
{
    long symloop_max = sysconf(_SC_SYMLOOP_MAX);

8568 8569 8570
    return qemuDomainAttachDeviceMknodRecursive(driver, vm, file,
                                                devMountsPath, ndevMountsPath,
                                                symloop_max);
8571 8572 8573
}


8574 8575 8576 8577 8578 8579 8580 8581 8582 8583 8584 8585 8586 8587 8588 8589 8590 8591
static int
qemuDomainDetachDeviceUnlinkHelper(pid_t pid ATTRIBUTE_UNUSED,
                                   void *opaque)
{
    const char *path = opaque;

    VIR_DEBUG("Unlinking %s", path);
    if (unlink(path) < 0 && errno != ENOENT) {
        virReportSystemError(errno,
                             _("Unable to remove device %s"), path);
        return -1;
    }

    return 0;
}


static int
8592
qemuDomainDetachDeviceUnlink(virQEMUDriverPtr driver ATTRIBUTE_UNUSED,
8593
                             virDomainObjPtr vm,
8594 8595 8596
                             const char *file,
                             char * const *devMountsPath,
                             size_t ndevMountsPath)
8597
{
8598 8599
    int ret = -1;
    size_t i;
8600

8601 8602 8603 8604 8605 8606 8607 8608 8609 8610 8611 8612 8613 8614 8615 8616 8617 8618 8619
    if (STRPREFIX(file, DEVPREFIX)) {
        for (i = 0; i < ndevMountsPath; i++) {
            if (STREQ(devMountsPath[i], "/dev"))
                continue;
            if (STRPREFIX(file, devMountsPath[i]))
                break;
        }

        if (i == ndevMountsPath) {
            if (virProcessRunInMountNamespace(vm->pid,
                                              qemuDomainDetachDeviceUnlinkHelper,
                                              (void *)file) < 0)
                goto cleanup;
        }
    }

    ret = 0;
 cleanup:
    return ret;
8620 8621 8622
}


8623 8624 8625
int
qemuDomainNamespaceSetupDisk(virQEMUDriverPtr driver,
                             virDomainObjPtr vm,
8626
                             virStorageSourcePtr src)
8627
{
8628 8629 8630
    virQEMUDriverConfigPtr cfg = NULL;
    char **devMountsPath = NULL;
    size_t ndevMountsPath = 0;
8631 8632 8633 8634 8635 8636 8637
    virStorageSourcePtr next;
    struct stat sb;
    int ret = -1;

    if (!qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
        return 0;

8638 8639 8640 8641 8642 8643
    cfg = virQEMUDriverGetConfig(driver);
    if (qemuDomainGetPreservedMounts(cfg, vm,
                                     &devMountsPath, NULL,
                                     &ndevMountsPath) < 0)
        goto cleanup;

8644
    for (next = src; next; next = next->backingStore) {
8645 8646
        if (virStorageSourceIsEmpty(next) ||
            !virStorageSourceIsLocalStorage(next)) {
8647 8648 8649 8650 8651 8652
            /* Not creating device. Just continue. */
            continue;
        }

        if (stat(next->path, &sb) < 0) {
            virReportSystemError(errno,
8653
                                 _("Unable to access %s"), next->path);
8654 8655 8656
            goto cleanup;
        }

8657 8658
        if (!S_ISBLK(sb.st_mode))
            continue;
8659 8660 8661

        if (qemuDomainAttachDeviceMknod(driver,
                                        vm,
8662 8663
                                        next->path,
                                        devMountsPath, ndevMountsPath) < 0)
8664 8665 8666 8667 8668
            goto cleanup;
    }

    ret = 0;
 cleanup:
8669 8670
    virStringListFreeCount(devMountsPath, ndevMountsPath);
    virObjectUnref(cfg);
8671 8672 8673 8674 8675 8676 8677
    return ret;
}


int
qemuDomainNamespaceTeardownDisk(virQEMUDriverPtr driver ATTRIBUTE_UNUSED,
                                virDomainObjPtr vm ATTRIBUTE_UNUSED,
8678
                                virStorageSourcePtr src ATTRIBUTE_UNUSED)
8679 8680 8681 8682 8683 8684 8685 8686 8687
{
    /* While in hotplug case we create the whole backing chain,
     * here we must limit ourselves. The disk we want to remove
     * might be a part of backing chain of another disk.
     * If you are reading these lines and have some spare time
     * you can come up with and algorithm that checks for that.
     * I don't, therefore: */
    return 0;
}
8688 8689 8690 8691 8692 8693 8694


int
qemuDomainNamespaceSetupHostdev(virQEMUDriverPtr driver,
                                virDomainObjPtr vm,
                                virDomainHostdevDefPtr hostdev)
{
8695 8696 8697
    virQEMUDriverConfigPtr cfg = NULL;
    char **devMountsPath = NULL;
    size_t ndevMountsPath = 0;
8698
    int ret = -1;
8699 8700
    char **path = NULL;
    size_t i, npaths = 0;
8701 8702 8703 8704

    if (!qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
        return 0;

8705
    if (qemuDomainGetHostdevPath(NULL, hostdev, false, &npaths, &path, NULL) < 0)
8706 8707
        goto cleanup;

8708 8709 8710 8711 8712 8713
    cfg = virQEMUDriverGetConfig(driver);
    if (qemuDomainGetPreservedMounts(cfg, vm,
                                     &devMountsPath, NULL,
                                     &ndevMountsPath) < 0)
        goto cleanup;

8714 8715 8716
    for (i = 0; i < npaths; i++) {
        if (qemuDomainAttachDeviceMknod(driver,
                                        vm,
8717 8718
                                        path[i],
                                        devMountsPath, ndevMountsPath) < 0)
8719 8720 8721 8722 8723
        goto cleanup;
    }

    ret = 0;
 cleanup:
8724 8725
    for (i = 0; i < npaths; i++)
        VIR_FREE(path[i]);
8726
    VIR_FREE(path);
8727 8728
    virStringListFreeCount(devMountsPath, ndevMountsPath);
    virObjectUnref(cfg);
8729 8730 8731 8732 8733 8734 8735 8736 8737
    return ret;
}


int
qemuDomainNamespaceTeardownHostdev(virQEMUDriverPtr driver,
                                   virDomainObjPtr vm,
                                   virDomainHostdevDefPtr hostdev)
{
8738 8739 8740
    virQEMUDriverConfigPtr cfg = NULL;
    char **devMountsPath = NULL;
    size_t ndevMountsPath = 0;
8741
    int ret = -1;
8742 8743
    char **path = NULL;
    size_t i, npaths = 0;
8744 8745 8746 8747

    if (!qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
        return 0;

8748 8749
    if (qemuDomainGetHostdevPath(vm->def, hostdev, true,
                                 &npaths, &path, NULL) < 0)
8750 8751
        goto cleanup;

8752 8753 8754 8755 8756 8757
    cfg = virQEMUDriverGetConfig(driver);
    if (qemuDomainGetPreservedMounts(cfg, vm,
                                     &devMountsPath, NULL,
                                     &ndevMountsPath) < 0)
        goto cleanup;

8758
    for (i = 0; i < npaths; i++) {
8759 8760
        if (qemuDomainDetachDeviceUnlink(driver, vm, path[i],
                                         devMountsPath, ndevMountsPath) < 0)
8761 8762
            goto cleanup;
    }
8763 8764 8765

    ret = 0;
 cleanup:
8766 8767
    for (i = 0; i < npaths; i++)
        VIR_FREE(path[i]);
8768
    VIR_FREE(path);
8769 8770
    virStringListFreeCount(devMountsPath, ndevMountsPath);
    virObjectUnref(cfg);
8771 8772
    return ret;
}
8773 8774


M
Michal Privoznik 已提交
8775 8776 8777 8778 8779
int
qemuDomainNamespaceSetupMemory(virQEMUDriverPtr driver,
                               virDomainObjPtr vm,
                               virDomainMemoryDefPtr mem)
{
8780 8781 8782
    virQEMUDriverConfigPtr cfg = NULL;
    char **devMountsPath = NULL;
    size_t ndevMountsPath = 0;
M
Michal Privoznik 已提交
8783 8784 8785 8786 8787 8788 8789 8790
    int ret = -1;

    if (mem->model != VIR_DOMAIN_MEMORY_MODEL_NVDIMM)
        return 0;

    if (!qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
        return 0;

8791 8792 8793 8794 8795 8796 8797 8798
    cfg = virQEMUDriverGetConfig(driver);
    if (qemuDomainGetPreservedMounts(cfg, vm,
                                     &devMountsPath, NULL,
                                     &ndevMountsPath) < 0)
        goto cleanup;

    if (qemuDomainAttachDeviceMknod(driver, vm, mem->nvdimmPath,
                                    devMountsPath, ndevMountsPath) < 0)
M
Michal Privoznik 已提交
8799 8800 8801
        goto cleanup;
    ret = 0;
 cleanup:
8802 8803
    virStringListFreeCount(devMountsPath, ndevMountsPath);
    virObjectUnref(cfg);
M
Michal Privoznik 已提交
8804 8805 8806 8807 8808 8809 8810 8811 8812
    return ret;
}


int
qemuDomainNamespaceTeardownMemory(virQEMUDriverPtr driver,
                                  virDomainObjPtr vm,
                                  virDomainMemoryDefPtr mem)
{
8813 8814 8815
    virQEMUDriverConfigPtr cfg = NULL;
    char **devMountsPath = NULL;
    size_t ndevMountsPath = 0;
M
Michal Privoznik 已提交
8816 8817 8818 8819 8820 8821 8822 8823
    int ret = -1;

    if (mem->model != VIR_DOMAIN_MEMORY_MODEL_NVDIMM)
        return 0;

    if (!qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
        return 0;

8824 8825 8826 8827 8828 8829 8830 8831
    cfg = virQEMUDriverGetConfig(driver);
    if (qemuDomainGetPreservedMounts(cfg, vm,
                                     &devMountsPath, NULL,
                                     &ndevMountsPath) < 0)
        goto cleanup;

    if (qemuDomainDetachDeviceUnlink(driver, vm, mem->nvdimmPath,
                                     devMountsPath, ndevMountsPath) < 0)
M
Michal Privoznik 已提交
8832 8833 8834
        goto cleanup;
    ret = 0;
 cleanup:
8835 8836
    virStringListFreeCount(devMountsPath, ndevMountsPath);
    virObjectUnref(cfg);
M
Michal Privoznik 已提交
8837 8838 8839 8840
    return ret;
}


8841 8842 8843 8844 8845
int
qemuDomainNamespaceSetupChardev(virQEMUDriverPtr driver,
                                virDomainObjPtr vm,
                                virDomainChrDefPtr chr)
{
8846 8847 8848
    virQEMUDriverConfigPtr cfg = NULL;
    char **devMountsPath = NULL;
    size_t ndevMountsPath = 0;
8849 8850 8851 8852 8853 8854 8855 8856 8857 8858 8859
    const char *path;
    int ret = -1;

    if (!qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
        return 0;

    if (chr->source->type != VIR_DOMAIN_CHR_TYPE_DEV)
        return 0;

    path = chr->source->data.file.path;

8860 8861 8862 8863 8864 8865
    cfg = virQEMUDriverGetConfig(driver);
    if (qemuDomainGetPreservedMounts(cfg, vm,
                                     &devMountsPath, NULL,
                                     &ndevMountsPath) < 0)
        goto cleanup;

8866 8867
    if (qemuDomainAttachDeviceMknod(driver,
                                    vm,
8868 8869
                                    path,
                                    devMountsPath, ndevMountsPath) < 0)
8870 8871 8872
        goto cleanup;
    ret = 0;
 cleanup:
8873 8874
    virStringListFreeCount(devMountsPath, ndevMountsPath);
    virObjectUnref(cfg);
8875 8876 8877 8878 8879 8880 8881 8882 8883
    return ret;
}


int
qemuDomainNamespaceTeardownChardev(virQEMUDriverPtr driver,
                                   virDomainObjPtr vm,
                                   virDomainChrDefPtr chr)
{
8884 8885 8886
    virQEMUDriverConfigPtr cfg = NULL;
    char **devMountsPath = NULL;
    size_t ndevMountsPath = 0;
8887 8888 8889 8890 8891 8892 8893 8894 8895 8896 8897
    int ret = -1;
    const char *path = NULL;

    if (!qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
        return 0;

    if (chr->source->type != VIR_DOMAIN_CHR_TYPE_DEV)
        return 0;

    path = chr->source->data.file.path;

8898 8899 8900 8901 8902 8903 8904 8905
    cfg = virQEMUDriverGetConfig(driver);
    if (qemuDomainGetPreservedMounts(cfg, vm,
                                     &devMountsPath, NULL,
                                     &ndevMountsPath) < 0)
        goto cleanup;

    if (qemuDomainDetachDeviceUnlink(driver, vm, path,
                                     devMountsPath, ndevMountsPath) < 0)
8906 8907 8908 8909
        goto cleanup;

    ret = 0;
 cleanup:
8910 8911
    virStringListFreeCount(devMountsPath, ndevMountsPath);
    virObjectUnref(cfg);
8912 8913
    return ret;
}
8914 8915 8916 8917 8918 8919 8920


int
qemuDomainNamespaceSetupRNG(virQEMUDriverPtr driver,
                            virDomainObjPtr vm,
                            virDomainRNGDefPtr rng)
{
8921 8922 8923
    virQEMUDriverConfigPtr cfg = NULL;
    char **devMountsPath = NULL;
    size_t ndevMountsPath = 0;
8924 8925 8926 8927 8928 8929 8930 8931 8932 8933 8934 8935 8936 8937 8938 8939 8940
    const char *path = NULL;
    int ret = -1;

    if (!qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
        return 0;

    switch ((virDomainRNGBackend) rng->backend) {
    case VIR_DOMAIN_RNG_BACKEND_RANDOM:
        path = rng->source.file;
        break;

    case VIR_DOMAIN_RNG_BACKEND_EGD:
    case VIR_DOMAIN_RNG_BACKEND_LAST:
        ret = 0;
        goto cleanup;
    }

8941 8942 8943 8944 8945 8946
    cfg = virQEMUDriverGetConfig(driver);
    if (qemuDomainGetPreservedMounts(cfg, vm,
                                     &devMountsPath, NULL,
                                     &ndevMountsPath) < 0)
        goto cleanup;

8947 8948
    if (qemuDomainAttachDeviceMknod(driver,
                                    vm,
8949 8950
                                    path,
                                    devMountsPath, ndevMountsPath) < 0)
8951 8952 8953
        goto cleanup;
    ret = 0;
 cleanup:
8954 8955
    virStringListFreeCount(devMountsPath, ndevMountsPath);
    virObjectUnref(cfg);
8956 8957 8958 8959 8960 8961 8962 8963 8964
    return ret;
}


int
qemuDomainNamespaceTeardownRNG(virQEMUDriverPtr driver,
                               virDomainObjPtr vm,
                               virDomainRNGDefPtr rng)
{
8965 8966 8967
    virQEMUDriverConfigPtr cfg = NULL;
    char **devMountsPath = NULL;
    size_t ndevMountsPath = 0;
8968 8969 8970 8971 8972 8973 8974 8975 8976 8977 8978 8979 8980 8981 8982 8983 8984
    int ret = -1;
    const char *path = NULL;

    if (!qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
        return 0;

    switch ((virDomainRNGBackend) rng->backend) {
    case VIR_DOMAIN_RNG_BACKEND_RANDOM:
        path = rng->source.file;
        break;

    case VIR_DOMAIN_RNG_BACKEND_EGD:
    case VIR_DOMAIN_RNG_BACKEND_LAST:
        ret = 0;
        goto cleanup;
    }

8985 8986 8987 8988 8989 8990 8991 8992
    cfg = virQEMUDriverGetConfig(driver);
    if (qemuDomainGetPreservedMounts(cfg, vm,
                                     &devMountsPath, NULL,
                                     &ndevMountsPath) < 0)
        goto cleanup;

    if (qemuDomainDetachDeviceUnlink(driver, vm, path,
                                     devMountsPath, ndevMountsPath) < 0)
8993 8994 8995 8996
        goto cleanup;

    ret = 0;
 cleanup:
8997 8998
    virStringListFreeCount(devMountsPath, ndevMountsPath);
    virObjectUnref(cfg);
8999 9000
    return ret;
}
9001 9002 9003 9004 9005 9006 9007 9008 9009 9010 9011 9012 9013 9014 9015 9016 9017 9018 9019 9020 9021 9022 9023 9024 9025 9026 9027 9028 9029 9030 9031 9032 9033 9034 9035 9036 9037 9038 9039 9040 9041 9042 9043


/**
 * qemuDomainDiskLookupByNodename:
 * @def: domain definition to look for the disk
 * @nodename: block backend node name to find
 * @src: filled with the specific backing store element if provided
 * @idx: index of @src in the backing chain, if provided
 *
 * Looks up the disk in the domain via @nodename and returns its definition.
 * Optionally fills @src and @idx if provided with the specific backing chain
 * element which corresponds to the node name.
 */
virDomainDiskDefPtr
qemuDomainDiskLookupByNodename(virDomainDefPtr def,
                               const char *nodename,
                               virStorageSourcePtr *src,
                               unsigned int *idx)
{
    size_t i;
    unsigned int srcindex;
    virStorageSourcePtr tmp = NULL;

    if (!idx)
        idx = &srcindex;

    if (src)
        *src = NULL;

    *idx = 0;

    for (i = 0; i < def->ndisks; i++) {
        if ((tmp = virStorageSourceFindByNodeName(def->disks[i]->src,
                                                  nodename, idx))) {
            if (src)
                *src = tmp;

            return def->disks[i];
        }
    }

    return NULL;
}
9044 9045 9046 9047 9048 9049 9050 9051 9052 9053 9054 9055 9056 9057 9058 9059 9060 9061 9062 9063 9064 9065


/**
 * qemuDomainDiskBackingStoreGetName:
 *
 * Creates a name using the indexed syntax (vda[1])for the given backing store
 * entry for a disk.
 */
char *
qemuDomainDiskBackingStoreGetName(virDomainDiskDefPtr disk,
                                  virStorageSourcePtr src ATTRIBUTE_UNUSED,
                                  unsigned int idx)
{
    char *ret = NULL;

    if (idx)
        ignore_value(virAsprintf(&ret, "%s[%d]", disk->dst, idx));
    else
        ignore_value(VIR_STRDUP(ret, disk->dst));

    return ret;
}
9066 9067 9068 9069 9070 9071 9072 9073 9074 9075 9076 9077 9078 9079 9080 9081 9082 9083 9084 9085 9086 9087 9088 9089 9090 9091 9092


virStorageSourcePtr
qemuDomainGetStorageSourceByDevstr(const char *devstr,
                                   virDomainDefPtr def)
{
    virDomainDiskDefPtr disk = NULL;
    virStorageSourcePtr src = NULL;
    char *target = NULL;
    unsigned int idx;
    size_t i;

    if (virStorageFileParseBackingStoreStr(devstr, &target, &idx) < 0) {
        virReportError(VIR_ERR_INVALID_ARG,
                       _("failed to parse block device '%s'"), devstr);
        return NULL;
    }

    for (i = 0; i < def->ndisks; i++) {
        if (STREQ(target, def->disks[i]->dst)) {
            disk = def->disks[i];
            break;
        }
    }

    if (!disk) {
        virReportError(VIR_ERR_INVALID_ARG,
Y
Yuri Chornoivan 已提交
9093
                       _("failed to find disk '%s'"), target);
9094 9095 9096
        goto cleanup;
    }

9097 9098 9099 9100
    if (idx == 0)
        src = disk->src;
    else
        src = virStorageFileChainLookup(disk->src, NULL, NULL, idx, NULL);
9101 9102 9103 9104 9105

 cleanup:
    VIR_FREE(target);
    return src;
}