qemu_domain.c 240.7 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 "viralloc.h"
35
#include "virlog.h"
36
#include "virerror.h"
37
#include "c-ctype.h"
38
#include "cpu/cpu.h"
39
#include "viruuid.h"
E
Eric Blake 已提交
40
#include "virfile.h"
41
#include "domain_addr.h"
42
#include "domain_event.h"
43
#include "virtime.h"
44
#include "virstoragefile.h"
45
#include "virstring.h"
46
#include "virthreadjob.h"
47
#include "viratomic.h"
48
#include "virprocess.h"
49
#include "vircrypto.h"
50
#include "secret_util.h"
51
#include "logging/log_manager.h"
52
#include "locking/domain_lock.h"
53

54 55
#include "storage/storage_driver.h"

56 57 58 59 60
#ifdef MAJOR_IN_MKDEV
# include <sys/mkdev.h>
#elif MAJOR_IN_SYSMACROS
# include <sys/sysmacros.h>
#endif
61
#include <sys/time.h>
62
#include <fcntl.h>
63 64 65
#if defined(HAVE_SYS_MOUNT_H)
# include <sys/mount.h>
#endif
66

67 68 69 70
#include <libxml/xpathInternals.h>

#define VIR_FROM_THIS VIR_FROM_QEMU

71 72
VIR_LOG_INIT("qemu.qemu_domain");

73 74
#define QEMU_NAMESPACE_HREF "http://libvirt.org/schemas/domain/qemu/1.0"

75 76 77 78 79 80
VIR_ENUM_IMPL(qemuDomainJob, QEMU_JOB_LAST,
              "none",
              "query",
              "destroy",
              "suspend",
              "modify",
81
              "abort",
82
              "migration operation",
83 84 85 86 87 88 89 90 91 92
              "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",
93
              "snapshot",
94
              "start",
95 96
);

97 98 99 100 101 102 103 104 105 106 107 108 109 110
VIR_ENUM_IMPL(qemuDomainNamespace, QEMU_DOMAIN_NS_LAST,
              "mount",
);


static struct {
    const char *path;
    const char *suffix;
} devPreserveMounts[] = {
    {"/dev/pts", "devpts"},
    {"/dev/shm", "devshm"},
    {"/dev/mqueue", "mqueue"},
};

111

112 113 114
struct _qemuDomainLogContext {
    int refs;
    int writefd;
115
    int readfd; /* Only used if manager == NULL */
116
    off_t pos;
117
    ino_t inode; /* Only used if manager != NULL */
118
    char *path;
119
    virLogManagerPtr manager;
120 121
};

J
Jiri Denemark 已提交
122
const char *
123
qemuDomainAsyncJobPhaseToString(qemuDomainAsyncJob job,
J
Jiri Denemark 已提交
124 125 126 127 128
                                int phase ATTRIBUTE_UNUSED)
{
    switch (job) {
    case QEMU_ASYNC_JOB_MIGRATION_OUT:
    case QEMU_ASYNC_JOB_MIGRATION_IN:
129 130
        return qemuMigrationJobPhaseTypeToString(phase);

J
Jiri Denemark 已提交
131 132
    case QEMU_ASYNC_JOB_SAVE:
    case QEMU_ASYNC_JOB_DUMP:
133
    case QEMU_ASYNC_JOB_SNAPSHOT:
134
    case QEMU_ASYNC_JOB_START:
J
Jiri Denemark 已提交
135 136 137 138 139 140 141 142 143
    case QEMU_ASYNC_JOB_NONE:
    case QEMU_ASYNC_JOB_LAST:
        ; /* fall through */
    }

    return "none";
}

int
144
qemuDomainAsyncJobPhaseFromString(qemuDomainAsyncJob job,
J
Jiri Denemark 已提交
145 146 147 148 149 150 151 152
                                  const char *phase)
{
    if (!phase)
        return 0;

    switch (job) {
    case QEMU_ASYNC_JOB_MIGRATION_OUT:
    case QEMU_ASYNC_JOB_MIGRATION_IN:
153 154
        return qemuMigrationJobPhaseTypeFromString(phase);

J
Jiri Denemark 已提交
155 156
    case QEMU_ASYNC_JOB_SAVE:
    case QEMU_ASYNC_JOB_DUMP:
157
    case QEMU_ASYNC_JOB_SNAPSHOT:
158
    case QEMU_ASYNC_JOB_START:
J
Jiri Denemark 已提交
159 160 161 162 163 164 165 166 167 168 169
    case QEMU_ASYNC_JOB_NONE:
    case QEMU_ASYNC_JOB_LAST:
        ; /* fall through */
    }

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

170

171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 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;
}


static int
qemuDomainGetPreservedMounts(virQEMUDriverPtr driver,
                             virDomainObjPtr vm,
                             char ***devMountsPath,
                             size_t *ndevMountsPath)
{
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    char **paths;
    size_t i;

    if (VIR_ALLOC_N(paths, ARRAY_CARDINALITY(devPreserveMounts)) < 0)
        goto error;

    for (i = 0; i < ARRAY_CARDINALITY(devPreserveMounts); i++) {
        if (virAsprintf(&paths[i], "%s/%s.%s",
                        cfg->stateDir, vm->def->name,
                        devPreserveMounts[i].suffix) < 0)
            goto error;
    }

    *devMountsPath = paths;
    *ndevMountsPath = ARRAY_CARDINALITY(devPreserveMounts);
    virObjectUnref(cfg);
    return 0;

 error:
    virStringListFreeCount(paths, ARRAY_CARDINALITY(devPreserveMounts));
    virObjectUnref(cfg);
    return -1;
}


235
void qemuDomainEventQueue(virQEMUDriverPtr driver,
236
                          virObjectEventPtr event)
237
{
238 239
    if (event)
        virObjectEventStateQueue(driver->domainEventState, event);
240 241 242
}


243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
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);
}


267 268 269 270 271 272 273 274
static int
qemuDomainObjInitJob(qemuDomainObjPrivatePtr priv)
{
    memset(&priv->job, 0, sizeof(priv->job));

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

275
    if (virCondInit(&priv->job.asyncCond) < 0) {
276
        virCondDestroy(&priv->job.cond);
277 278 279
        return -1;
    }

280 281 282 283 284 285 286 287 288
    return 0;
}

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

    job->active = QEMU_JOB_NONE;
289
    job->owner = 0;
290
    job->ownerAPI = NULL;
J
Jiri Denemark 已提交
291
    job->started = 0;
292 293 294 295 296 297 298 299
}

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

    job->asyncJob = QEMU_ASYNC_JOB_NONE;
300
    job->asyncOwner = 0;
301
    job->asyncOwnerAPI = NULL;
J
Jiri Denemark 已提交
302
    job->asyncStarted = 0;
J
Jiri Denemark 已提交
303
    job->phase = 0;
304
    job->mask = QEMU_JOB_DEFAULT_MASK;
305
    job->dump_memory_only = false;
306
    job->abortJob = false;
307
    job->spiceMigration = false;
308
    job->spiceMigrated = false;
309
    job->postcopyEnabled = false;
J
Jiri Denemark 已提交
310
    VIR_FREE(job->current);
311 312
}

313 314 315 316 317 318 319 320
void
qemuDomainObjRestoreJob(virDomainObjPtr obj,
                        struct qemuDomainJobObj *job)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

    memset(job, 0, sizeof(*job));
    job->active = priv->job.active;
321
    job->owner = priv->job.owner;
322
    job->asyncJob = priv->job.asyncJob;
323
    job->asyncOwner = priv->job.asyncOwner;
J
Jiri Denemark 已提交
324
    job->phase = priv->job.phase;
325 326 327 328 329

    qemuDomainObjResetJob(priv);
    qemuDomainObjResetAsyncJob(priv);
}

330 331 332
static void
qemuDomainObjFreeJob(qemuDomainObjPrivatePtr priv)
{
J
Jiri Denemark 已提交
333
    VIR_FREE(priv->job.current);
334
    VIR_FREE(priv->job.completed);
335 336
    virCondDestroy(&priv->job.cond);
    virCondDestroy(&priv->job.asyncCond);
337 338
}

339
static bool
340
qemuDomainTrackJob(qemuDomainJob job)
341 342 343 344
{
    return (QEMU_DOMAIN_TRACK_JOBS & JOB_MASK(job)) != 0;
}

345

J
Jiri Denemark 已提交
346 347 348 349 350 351 352 353 354 355 356
int
qemuDomainJobInfoUpdateTime(qemuDomainJobInfoPtr jobInfo)
{
    unsigned long long now;

    if (!jobInfo->started)
        return 0;

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

357 358 359 360 361 362
    if (now < jobInfo->started) {
        VIR_WARN("Async job starts in the future");
        jobInfo->started = 0;
        return 0;
    }

J
Jiri Denemark 已提交
363 364 365 366
    jobInfo->timeElapsed = now - jobInfo->started;
    return 0;
}

367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
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;
    }

384 385
    jobInfo->stats.downtime = now - jobInfo->stopped;
    jobInfo->stats.downtime_set = true;
386 387 388
    return 0;
}

J
Jiri Denemark 已提交
389 390 391 392
int
qemuDomainJobInfoToInfo(qemuDomainJobInfoPtr jobInfo,
                        virDomainJobInfoPtr info)
{
393
    info->type = jobInfo->type;
J
Jiri Denemark 已提交
394 395 396
    info->timeElapsed = jobInfo->timeElapsed;
    info->timeRemaining = jobInfo->timeRemaining;

397 398 399
    info->memTotal = jobInfo->stats.ram_total;
    info->memRemaining = jobInfo->stats.ram_remaining;
    info->memProcessed = jobInfo->stats.ram_transferred;
J
Jiri Denemark 已提交
400

401 402 403
    info->fileTotal = jobInfo->stats.disk_total;
    info->fileRemaining = jobInfo->stats.disk_remaining;
    info->fileProcessed = jobInfo->stats.disk_transferred;
J
Jiri Denemark 已提交
404 405 406 407 408 409 410 411 412 413 414 415 416 417

    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)
{
418
    qemuMonitorMigrationStats *stats = &jobInfo->stats;
J
Jiri Denemark 已提交
419 420 421 422 423 424 425 426 427
    virTypedParameterPtr par = NULL;
    int maxpar = 0;
    int npar = 0;

    if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_TIME_ELAPSED,
                                jobInfo->timeElapsed) < 0)
        goto error;

428 429 430 431 432 433 434
    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 已提交
435 436 437 438 439 440
    if (jobInfo->type == VIR_DOMAIN_JOB_BOUNDED &&
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_TIME_REMAINING,
                                jobInfo->timeRemaining) < 0)
        goto error;

441
    if (stats->downtime_set &&
J
Jiri Denemark 已提交
442 443
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DOWNTIME,
444
                                stats->downtime) < 0)
J
Jiri Denemark 已提交
445 446
        goto error;

447
    if (stats->downtime_set &&
448
        jobInfo->timeDeltaSet &&
449
        stats->downtime > jobInfo->timeDelta &&
450 451
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DOWNTIME_NET,
452
                                stats->downtime - jobInfo->timeDelta) < 0)
453 454
        goto error;

455
    if (stats->setup_time_set &&
456 457
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_SETUP_TIME,
458
                                stats->setup_time) < 0)
459 460
        goto error;

J
Jiri Denemark 已提交
461 462
    if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DATA_TOTAL,
463 464
                                stats->ram_total +
                                stats->disk_total) < 0 ||
J
Jiri Denemark 已提交
465 466
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DATA_PROCESSED,
467 468
                                stats->ram_transferred +
                                stats->disk_transferred) < 0 ||
J
Jiri Denemark 已提交
469 470
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DATA_REMAINING,
471 472
                                stats->ram_remaining +
                                stats->disk_remaining) < 0)
J
Jiri Denemark 已提交
473 474 475 476
        goto error;

    if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_MEMORY_TOTAL,
477
                                stats->ram_total) < 0 ||
J
Jiri Denemark 已提交
478 479
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_MEMORY_PROCESSED,
480
                                stats->ram_transferred) < 0 ||
J
Jiri Denemark 已提交
481 482
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_MEMORY_REMAINING,
483
                                stats->ram_remaining) < 0)
J
Jiri Denemark 已提交
484 485
        goto error;

486
    if (stats->ram_bps &&
487 488
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_MEMORY_BPS,
489
                                stats->ram_bps) < 0)
490 491
        goto error;

492
    if (stats->ram_duplicate_set) {
J
Jiri Denemark 已提交
493 494
        if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_MEMORY_CONSTANT,
495
                                    stats->ram_duplicate) < 0 ||
J
Jiri Denemark 已提交
496 497
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_MEMORY_NORMAL,
498
                                    stats->ram_normal) < 0 ||
J
Jiri Denemark 已提交
499 500
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES,
501
                                    stats->ram_normal_bytes) < 0)
J
Jiri Denemark 已提交
502 503 504
            goto error;
    }

505 506 507 508 509 510 511 512
    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 已提交
513 514
    if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DISK_TOTAL,
515
                                stats->disk_total) < 0 ||
J
Jiri Denemark 已提交
516 517
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DISK_PROCESSED,
518
                                stats->disk_transferred) < 0 ||
J
Jiri Denemark 已提交
519 520
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DISK_REMAINING,
521
                                stats->disk_remaining) < 0)
J
Jiri Denemark 已提交
522 523
        goto error;

524
    if (stats->disk_bps &&
525 526
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DISK_BPS,
527
                                stats->disk_bps) < 0)
528 529
        goto error;

530
    if (stats->xbzrle_set) {
J
Jiri Denemark 已提交
531 532
        if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_COMPRESSION_CACHE,
533
                                    stats->xbzrle_cache_size) < 0 ||
J
Jiri Denemark 已提交
534 535
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_COMPRESSION_BYTES,
536
                                    stats->xbzrle_bytes) < 0 ||
J
Jiri Denemark 已提交
537 538
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_COMPRESSION_PAGES,
539
                                    stats->xbzrle_pages) < 0 ||
J
Jiri Denemark 已提交
540 541
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES,
542
                                    stats->xbzrle_cache_miss) < 0 ||
J
Jiri Denemark 已提交
543 544
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW,
545
                                    stats->xbzrle_overflow) < 0)
J
Jiri Denemark 已提交
546 547 548
            goto error;
    }

549 550 551 552 553 554
    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 已提交
555 556 557 558 559 560 561 562 563 564 565
    *type = jobInfo->type;
    *params = par;
    *nparams = npar;
    return 0;

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


J
John Ferlan 已提交
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587
/* 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:
588 589
 * @driver: qemu driver data
 * @vm: Pointer to the vm object
J
John Ferlan 已提交
590 591 592 593 594
 *
 * 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
 */
595
int
M
Martin Kletzander 已提交
596 597
qemuDomainWriteMasterKeyFile(virQEMUDriverPtr driver,
                             virDomainObjPtr vm)
J
John Ferlan 已提交
598 599 600 601
{
    char *path;
    int fd = -1;
    int ret = -1;
M
Martin Kletzander 已提交
602
    qemuDomainObjPrivatePtr priv = vm->privateData;
J
John Ferlan 已提交
603

604 605 606 607
    /* Only gets filled in if we have the capability */
    if (!priv->masterKey)
        return 0;

J
John Ferlan 已提交
608 609 610 611 612 613 614 615 616 617 618 619 620 621 622
    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;
    }

623 624
    if (virSecurityManagerDomainSetPathLabel(driver->securityManager,
                                             vm->def, path) < 0)
M
Martin Kletzander 已提交
625 626
        goto cleanup;

J
John Ferlan 已提交
627 628 629 630 631 632 633 634 635 636
    ret = 0;

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

    return ret;
}


637 638 639 640 641 642 643 644 645
static void
qemuDomainMasterKeyFree(qemuDomainObjPrivatePtr priv)
{
    if (!priv->masterKey)
        return;

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

J
John Ferlan 已提交
646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 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
/* 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 */
744
    qemuDomainMasterKeyFree(priv);
J
John Ferlan 已提交
745 746 747 748 749 750 751 752 753 754

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

    VIR_FREE(path);
}


/* qemuDomainMasterKeyCreate:
755
 * @vm: Pointer to the domain object
J
John Ferlan 已提交
756 757 758 759 760 761 762 763
 *
 * 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
764
qemuDomainMasterKeyCreate(virDomainObjPtr vm)
J
John Ferlan 已提交
765
{
M
Martin Kletzander 已提交
766 767
    qemuDomainObjPrivatePtr priv = vm->privateData;

J
John Ferlan 已提交
768 769 770 771 772
    /* If we don't have the capability, then do nothing. */
    if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_OBJECT_SECRET))
        return 0;

    if (!(priv->masterKey =
773
          virCryptoGenerateRandom(QEMU_DOMAIN_MASTER_KEY_LEN)))
774
        return -1;
J
John Ferlan 已提交
775 776 777 778 779 780 781

    priv->masterKeyLen = QEMU_DOMAIN_MASTER_KEY_LEN;

    return 0;
}


782
static void
783
qemuDomainSecretPlainClear(qemuDomainSecretPlain secret)
784 785
{
    VIR_FREE(secret.username);
786
    VIR_DISPOSE_N(secret.secret, secret.secretlen);
787 788 789
}


J
John Ferlan 已提交
790
static void
791
qemuDomainSecretAESClear(qemuDomainSecretAES secret)
J
John Ferlan 已提交
792 793 794 795 796 797 798 799
{
    VIR_FREE(secret.username);
    VIR_FREE(secret.alias);
    VIR_FREE(secret.iv);
    VIR_FREE(secret.ciphertext);
}


800 801 802 803 804 805
static void
qemuDomainSecretInfoFree(qemuDomainSecretInfoPtr *secinfo)
{
    if (!*secinfo)
        return;

J
John Ferlan 已提交
806 807
    switch ((qemuDomainSecretInfoType) (*secinfo)->type) {
    case VIR_DOMAIN_SECRET_INFO_TYPE_PLAIN:
808
        qemuDomainSecretPlainClear((*secinfo)->s.plain);
J
John Ferlan 已提交
809 810
        break;

811
    case VIR_DOMAIN_SECRET_INFO_TYPE_AES:
812
        qemuDomainSecretAESClear((*secinfo)->s.aes);
J
John Ferlan 已提交
813 814 815 816 817 818
        break;

    case VIR_DOMAIN_SECRET_INFO_TYPE_LAST:
        break;
    }

819 820 821 822
    VIR_FREE(*secinfo);
}


823
static virClassPtr qemuDomainDiskPrivateClass;
824
static void qemuDomainDiskPrivateDispose(void *obj);
825 826 827 828 829 830 831

static int
qemuDomainDiskPrivateOnceInit(void)
{
    qemuDomainDiskPrivateClass = virClassNew(virClassForObject(),
                                             "qemuDomainDiskPrivate",
                                             sizeof(qemuDomainDiskPrivate),
832
                                             qemuDomainDiskPrivateDispose);
833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855
    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;
}


856 857 858 859 860 861
static void
qemuDomainDiskPrivateDispose(void *obj)
{
    qemuDomainDiskPrivatePtr priv = obj;

    qemuDomainSecretInfoFree(&priv->secinfo);
J
John Ferlan 已提交
862
    qemuDomainSecretInfoFree(&priv->encinfo);
863 864 865
}


866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 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
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);
}


909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942
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
943
qemuDomainVcpuPrivateDispose(void *obj)
944
{
945 946 947 948
    qemuDomainVcpuPrivatePtr priv = obj;

    VIR_FREE(priv->type);
    VIR_FREE(priv->alias);
949 950 951 952
    return;
}


953 954
static virClassPtr qemuDomainChrSourcePrivateClass;
static void qemuDomainChrSourcePrivateDispose(void *obj);
955 956

static int
957
qemuDomainChrSourcePrivateOnceInit(void)
958
{
959
    qemuDomainChrSourcePrivateClass =
960
        virClassNew(virClassForObject(),
961 962 963 964
                    "qemuDomainChrSourcePrivate",
                    sizeof(qemuDomainChrSourcePrivate),
                    qemuDomainChrSourcePrivateDispose);
    if (!qemuDomainChrSourcePrivateClass)
965 966 967 968 969
        return -1;
    else
        return 0;
}

970
VIR_ONCE_GLOBAL_INIT(qemuDomainChrSourcePrivate)
971 972

static virObjectPtr
973
qemuDomainChrSourcePrivateNew(void)
974
{
975
    qemuDomainChrSourcePrivatePtr priv;
976

977
    if (qemuDomainChrSourcePrivateInitialize() < 0)
978 979
        return NULL;

980
    if (!(priv = virObjectNew(qemuDomainChrSourcePrivateClass)))
981 982 983 984 985 986 987
        return NULL;

    return (virObjectPtr) priv;
}


static void
988
qemuDomainChrSourcePrivateDispose(void *obj)
989
{
990
    qemuDomainChrSourcePrivatePtr priv = obj;
991 992 993 994 995

    qemuDomainSecretInfoFree(&priv->secinfo);
}


996 997 998
/* qemuDomainSecretPlainSetup:
 * @conn: Pointer to connection
 * @secinfo: Pointer to secret info
999
 * @secretUsageType: The virSecretUsageType
1000 1001
 * @username: username to use for authentication (may be NULL)
 * @seclookupdef: Pointer to seclookupdef data
1002 1003 1004 1005 1006 1007 1008 1009
 *
 * 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,
1010
                           virSecretUsageType secretUsageType,
1011 1012
                           const char *username,
                           virSecretLookupTypeDefPtr seclookupdef)
1013
{
1014
    secinfo->type = VIR_DOMAIN_SECRET_INFO_TYPE_PLAIN;
1015
    if (VIR_STRDUP(secinfo->s.plain.username, username) < 0)
1016 1017
        return -1;

1018
    return virSecretGetSecretString(conn, seclookupdef, secretUsageType,
1019 1020
                                    &secinfo->s.plain.secret,
                                    &secinfo->s.plain.secretlen);
1021 1022 1023
}


1024 1025 1026 1027 1028
/* 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
1029
 * @secretUsageType: The virSecretUsageType
1030 1031
 * @username: username to use for authentication (may be NULL)
 * @seclookupdef: Pointer to seclookupdef data
1032
 * @isLuks: True/False for is for luks (alias generation)
1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
 *
 * 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,
1043
                         virSecretUsageType secretUsageType,
1044
                         const char *username,
1045 1046
                         virSecretLookupTypeDefPtr seclookupdef,
                         bool isLuks)
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
{
    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;
1057
    if (VIR_STRDUP(secinfo->s.aes.username, username) < 0)
1058 1059
        return -1;

1060
    if (!(secinfo->s.aes.alias = qemuDomainGetSecretAESAlias(srcalias, isLuks)))
1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071
        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 */
1072
    if (virSecretGetSecretString(conn, seclookupdef, secretUsageType,
1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100
                                 &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;
}


1101 1102
/* qemuDomainSecretSetup:
 * @conn: Pointer to connection
1103
 * @priv: pointer to domain private object
1104
 * @secinfo: Pointer to secret info
1105
 * @srcalias: Alias of the disk/hostdev used to generate the secret alias
1106
 * @secretUsageType: The virSecretUsageType
1107 1108
 * @username: username to use for authentication (may be NULL)
 * @seclookupdef: Pointer to seclookupdef data
1109
 * @isLuks: True when is luks (generates different alias)
1110
 *
1111 1112 1113 1114
 * 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.
1115 1116 1117 1118 1119
 *
 * Returns 0 on success, -1 on failure
 */
static int
qemuDomainSecretSetup(virConnectPtr conn,
1120
                      qemuDomainObjPrivatePtr priv,
1121
                      qemuDomainSecretInfoPtr secinfo,
1122
                      const char *srcalias,
1123
                      virSecretUsageType secretUsageType,
1124
                      const char *username,
1125 1126
                      virSecretLookupTypeDefPtr seclookupdef,
                      bool isLuks)
1127
{
1128 1129
    if (virCryptoHaveCipher(VIR_CRYPTO_CIPHER_AES256CBC) &&
        virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_OBJECT_SECRET) &&
1130
        (secretUsageType == VIR_SECRET_USAGE_TYPE_CEPH ||
1131 1132
         secretUsageType == VIR_SECRET_USAGE_TYPE_VOLUME ||
         secretUsageType == VIR_SECRET_USAGE_TYPE_TLS)) {
1133
        if (qemuDomainSecretAESSetup(conn, priv, secinfo, srcalias,
1134
                                     secretUsageType, username,
1135
                                     seclookupdef, isLuks) < 0)
1136 1137
            return -1;
    } else {
1138
        if (qemuDomainSecretPlainSetup(conn, secinfo, secretUsageType,
1139
                                       username, seclookupdef) < 0)
1140 1141 1142
            return -1;
    }
    return 0;
1143 1144 1145
}


1146 1147 1148 1149 1150 1151 1152 1153 1154 1155
/* 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);

1156
    if (!diskPriv || !diskPriv->secinfo)
1157 1158 1159 1160 1161 1162
        return;

    qemuDomainSecretInfoFree(&diskPriv->secinfo);
}


1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176
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;
}


1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188
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;
}


1189 1190
/* qemuDomainSecretDiskPrepare:
 * @conn: Pointer to connection
J
John Ferlan 已提交
1191
 * @priv: pointer to domain private object
1192 1193 1194 1195 1196 1197 1198 1199
 * @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,
1200
                            qemuDomainObjPrivatePtr priv,
1201 1202 1203
                            virDomainDiskDefPtr disk)
{
    virStorageSourcePtr src = disk->src;
1204
    qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
1205 1206
    qemuDomainSecretInfoPtr secinfo = NULL;

1207
    if (qemuDomainSecretDiskCapable(src)) {
1208
        virSecretUsageType secretUsageType = VIR_SECRET_USAGE_TYPE_ISCSI;
1209 1210 1211 1212

        if (VIR_ALLOC(secinfo) < 0)
            return -1;

1213 1214 1215
        if (src->protocol == VIR_STORAGE_NET_PROTOCOL_RBD)
            secretUsageType = VIR_SECRET_USAGE_TYPE_CEPH;

1216
        if (qemuDomainSecretSetup(conn, priv, secinfo, disk->info.alias,
1217
                                  secretUsageType, src->auth->username,
1218
                                  &src->auth->seclookupdef, false) < 0)
1219 1220 1221 1222 1223
            goto error;

        diskPriv->secinfo = secinfo;
    }

1224
    if (qemuDomainDiskHasEncryptionSecret(src)) {
1225 1226 1227 1228 1229 1230 1231 1232 1233 1234

        if (VIR_ALLOC(secinfo) < 0)
            return -1;

        if (qemuDomainSecretSetup(conn, priv, secinfo, disk->info.alias,
                                  VIR_SECRET_USAGE_TYPE_VOLUME, NULL,
                                  &src->encryption->secrets[0]->seclookupdef,
                                  true) < 0)
            goto error;

1235 1236 1237 1238 1239 1240 1241
        if (secinfo->type == VIR_DOMAIN_SECRET_INFO_TYPE_PLAIN) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("luks encryption requires encrypted secrets "
                             "to be supported"));
            goto error;
        }

1242 1243 1244
        diskPriv->encinfo = secinfo;
    }

1245 1246 1247 1248 1249 1250 1251 1252
    return 0;

 error:
    qemuDomainSecretInfoFree(&secinfo);
    return -1;
}


1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263
/* 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);

1264
    if (!hostdevPriv || !hostdevPriv->secinfo)
1265 1266 1267 1268 1269 1270 1271 1272
        return;

    qemuDomainSecretInfoFree(&hostdevPriv->secinfo);
}


/* qemuDomainSecretHostdevPrepare:
 * @conn: Pointer to connection
J
John Ferlan 已提交
1273
 * @priv: pointer to domain private object
1274 1275 1276 1277 1278 1279 1280 1281
 * @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,
1282
                               qemuDomainObjPrivatePtr priv,
1283 1284 1285 1286
                               virDomainHostdevDefPtr hostdev)
{
    qemuDomainSecretInfoPtr secinfo = NULL;

1287
    if (virHostdevIsSCSIDevice(hostdev)) {
1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299
        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);

            if (VIR_ALLOC(secinfo) < 0)
                return -1;

1300
            if (qemuDomainSecretSetup(conn, priv, secinfo, hostdev->info->alias,
1301
                                      VIR_SECRET_USAGE_TYPE_ISCSI,
1302
                                      iscsisrc->auth->username,
1303
                                      &iscsisrc->auth->seclookupdef, false) < 0)
1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317
                goto error;

            hostdevPriv->secinfo = secinfo;
        }
    }

    return 0;

 error:
    qemuDomainSecretInfoFree(&secinfo);
    return -1;
}


1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404
/* 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)
{
    virSecretLookupTypeDef seclookupdef = {0};
    qemuDomainSecretInfoPtr secinfo = NULL;
    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 (virUUIDParse(cfg->chardevTLSx509secretUUID,
                         seclookupdef.u.uuid) < 0) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("malformed chardev TLS secret uuid in qemu.conf"));
            goto error;
        }
        seclookupdef.type = VIR_SECRET_LOOKUP_TYPE_UUID;

        if (VIR_ALLOC(secinfo) < 0)
            goto error;

        if (!(charAlias = qemuAliasChardevFromDevAlias(chrAlias)))
            goto error;

        if (qemuDomainSecretSetup(conn, priv, secinfo, charAlias,
                                  VIR_SECRET_USAGE_TYPE_TLS, NULL,
                                  &seclookupdef, false) < 0)
            goto error;

        if (secinfo->type == VIR_DOMAIN_SECRET_INFO_TYPE_PLAIN) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("TLS X.509 requires encrypted secrets "
                             "to be supported"));
            goto error;
        }

        chrSourcePriv->secinfo = secinfo;
    }

    VIR_FREE(charAlias);
    return 0;

 error:
    qemuDomainSecretInfoFree(&secinfo);
    return -1;
}


1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417
/* 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]);
1418 1419 1420

    for (i = 0; i < vm->def->nhostdevs; i++)
        qemuDomainSecretHostdevDestroy(vm->def->hostdevs[i]);
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446

    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);
1447 1448 1449 1450 1451
}


/* qemuDomainSecretPrepare:
 * @conn: Pointer to connection
1452
 * @driver: Pointer to driver object
1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464
 * @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,
1465
                        virQEMUDriverPtr driver,
1466 1467
                        virDomainObjPtr vm)
{
J
John Ferlan 已提交
1468
    qemuDomainObjPrivatePtr priv = vm->privateData;
1469
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
1470
    size_t i;
1471
    int ret = -1;
1472 1473

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

1478
    for (i = 0; i < vm->def->nhostdevs; i++) {
J
John Ferlan 已提交
1479 1480
        if (qemuDomainSecretHostdevPrepare(conn, priv,
                                           vm->def->hostdevs[i]) < 0)
1481
            goto cleanup;
1482 1483
    }

1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539
    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;
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
/* 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
1570 1571
qemuDomainSetPrivatePaths(virQEMUDriverPtr driver,
                          virDomainObjPtr vm)
1572
{
1573 1574
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    qemuDomainObjPrivatePtr priv = vm->privateData;
1575
    char *domname = virDomainObjGetShortName(vm->def);
1576
    int ret = -1;
1577

M
Martin Kletzander 已提交
1578 1579 1580
    if (!domname)
        goto cleanup;

1581
    if (!priv->libDir &&
M
Martin Kletzander 已提交
1582
        virAsprintf(&priv->libDir, "%s/domain-%s", cfg->libDir, domname) < 0)
1583
        goto cleanup;
1584

1585
    if (!priv->channelTargetDir &&
M
Martin Kletzander 已提交
1586 1587
        virAsprintf(&priv->channelTargetDir, "%s/domain-%s",
                    cfg->channelTargetDir, domname) < 0)
1588
        goto cleanup;
1589

1590 1591 1592
    ret = 0;
 cleanup:
    virObjectUnref(cfg);
M
Martin Kletzander 已提交
1593
    VIR_FREE(domname);
1594
    return ret;
1595 1596 1597
}


1598 1599 1600 1601 1602 1603 1604 1605 1606 1607
void
qemuDomainClearPrivatePaths(virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;

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


1608 1609
static void *
qemuDomainObjPrivateAlloc(void)
1610 1611 1612 1613 1614 1615
{
    qemuDomainObjPrivatePtr priv;

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

1616 1617 1618
    if (qemuDomainObjInitJob(priv) < 0) {
        virReportSystemError(errno, "%s",
                             _("Unable to init qemu driver mutexes"));
1619
        goto error;
1620
    }
1621

1622
    if (!(priv->devs = virChrdevAlloc()))
1623 1624
        goto error;

1625
    priv->migMaxBandwidth = QEMU_DOMAIN_MIG_BANDWIDTH_MAX;
1626

1627
    return priv;
1628

1629
 error:
1630 1631
    VIR_FREE(priv);
    return NULL;
1632 1633
}

1634 1635
static void
qemuDomainObjPrivateFree(void *data)
1636 1637 1638
{
    qemuDomainObjPrivatePtr priv = data;

1639
    virObjectUnref(priv->qemuCaps);
1640

1641 1642
    virBitmapFree(priv->namespaces);

1643
    virCgroupFree(&priv->cgroup);
1644
    virDomainPCIAddressSetFree(priv->pciaddrs);
J
Ján Tomko 已提交
1645
    virDomainUSBAddressSetFree(priv->usbaddrs);
1646
    virDomainChrSourceDefFree(priv->monConfig);
1647
    qemuDomainObjFreeJob(priv);
1648
    VIR_FREE(priv->lockState);
J
Jiri Denemark 已提交
1649
    VIR_FREE(priv->origname);
1650

1651
    virStringListFree(priv->qemuDevices);
1652
    virChrdevFree(priv->devs);
1653

1654 1655
    /* This should never be non-NULL if we get here, but just in case... */
    if (priv->mon) {
1656
        VIR_ERROR(_("Unexpected QEMU monitor still active during domain deletion"));
1657 1658
        qemuMonitorClose(priv->mon);
    }
D
Daniel P. Berrange 已提交
1659 1660 1661 1662
    if (priv->agent) {
        VIR_ERROR(_("Unexpected QEMU agent still active during domain deletion"));
        qemuAgentClose(priv->agent);
    }
1663
    VIR_FREE(priv->cleanupCallbacks);
1664
    virBitmapFree(priv->autoNodeset);
1665
    virBitmapFree(priv->autoCpuset);
1666 1667 1668

    VIR_FREE(priv->libDir);
    VIR_FREE(priv->channelTargetDir);
1669
    qemuDomainMasterKeyFree(priv);
1670

1671 1672 1673 1674
    VIR_FREE(priv);
}


1675 1676
static void
qemuDomainObjPrivateXMLFormatVcpus(virBufferPtr buf,
1677
                                   virDomainDefPtr def)
1678 1679
{
    size_t i;
1680 1681 1682
    size_t maxvcpus = virDomainDefGetVcpusMax(def);
    virDomainVcpuDefPtr vcpu;
    pid_t tid;
1683 1684 1685 1686

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

1687 1688 1689 1690 1691 1692 1693 1694 1695
    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);
    }
1696 1697 1698 1699 1700 1701

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


1702
static int
1703 1704
qemuDomainObjPrivateXMLFormat(virBufferPtr buf,
                              virDomainObjPtr vm)
1705
{
1706
    qemuDomainObjPrivatePtr priv = vm->privateData;
1707
    const char *monitorpath;
1708
    qemuDomainJob job;
1709 1710 1711

    /* priv->monitor_chr is set only for qemu */
    if (priv->monConfig) {
1712
        switch (priv->monConfig->type) {
1713
        case VIR_DOMAIN_CHR_TYPE_UNIX:
1714
            monitorpath = priv->monConfig->data.nix.path;
1715 1716 1717
            break;
        default:
        case VIR_DOMAIN_CHR_TYPE_PTY:
1718
            monitorpath = priv->monConfig->data.file.path;
1719 1720 1721
            break;
        }

1722
        virBufferEscapeString(buf, "<monitor path='%s'", monitorpath);
1723 1724
        if (priv->monJSON)
            virBufferAddLit(buf, " json='1'");
1725
        virBufferAsprintf(buf, " type='%s'/>\n",
1726
                          virDomainChrTypeToString(priv->monConfig->type));
1727 1728
    }

1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739
    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");
    }

1740
    qemuDomainObjPrivateXMLFormatVcpus(buf, vm->def);
1741

1742
    if (priv->qemuCaps) {
1743
        size_t i;
1744 1745
        virBufferAddLit(buf, "<qemuCaps>\n");
        virBufferAdjustIndent(buf, 2);
1746
        for (i = 0; i < QEMU_CAPS_LAST; i++) {
1747
            if (virQEMUCapsGet(priv->qemuCaps, i)) {
1748
                virBufferAsprintf(buf, "<flag name='%s'/>\n",
1749
                                  virQEMUCapsTypeToString(i));
1750 1751
            }
        }
1752 1753
        virBufferAdjustIndent(buf, -2);
        virBufferAddLit(buf, "</qemuCaps>\n");
1754 1755
    }

1756
    if (priv->lockState)
1757
        virBufferAsprintf(buf, "<lockstate>%s</lockstate>\n", priv->lockState);
1758

1759 1760 1761 1762
    job = priv->job.active;
    if (!qemuDomainTrackJob(job))
        priv->job.active = QEMU_JOB_NONE;

1763
    if (priv->job.active || priv->job.asyncJob) {
1764
        virBufferAsprintf(buf, "<job type='%s' async='%s'",
1765 1766
                          qemuDomainJobTypeToString(priv->job.active),
                          qemuDomainAsyncJobTypeToString(priv->job.asyncJob));
J
Jiri Denemark 已提交
1767 1768 1769 1770 1771
        if (priv->job.phase) {
            virBufferAsprintf(buf, " phase='%s'",
                              qemuDomainAsyncJobPhaseToString(
                                    priv->job.asyncJob, priv->job.phase));
        }
1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792
        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");
        }
1793
    }
1794
    priv->job.active = job;
1795

1796
    if (priv->fakeReboot)
1797
        virBufferAddLit(buf, "<fakereboot/>\n");
1798

1799 1800
    if (priv->qemuDevices && *priv->qemuDevices) {
        char **tmp = priv->qemuDevices;
1801 1802
        virBufferAddLit(buf, "<devices>\n");
        virBufferAdjustIndent(buf, 2);
1803
        while (*tmp) {
1804
            virBufferAsprintf(buf, "<device alias='%s'/>\n", *tmp);
1805 1806
            tmp++;
        }
1807 1808
        virBufferAdjustIndent(buf, -2);
        virBufferAddLit(buf, "</devices>\n");
1809 1810
    }

1811 1812 1813 1814 1815 1816 1817 1818 1819 1820
    if (priv->autoNodeset) {
        char *nodeset = virBitmapFormat(priv->autoNodeset);

        if (!nodeset)
            return -1;

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

1821 1822 1823 1824 1825
    /* Various per-domain paths */
    virBufferEscapeString(buf, "<libDir path='%s'/>\n", priv->libDir);
    virBufferEscapeString(buf, "<channelTargetDir path='%s'/>\n",
                          priv->channelTargetDir);

1826 1827 1828
    return 0;
}

1829 1830 1831 1832

static int
qemuDomainObjPrivateXMLParseVcpu(xmlNodePtr node,
                                 unsigned int idx,
1833
                                 virDomainDefPtr def)
1834
{
1835
    virDomainVcpuDefPtr vcpu;
1836
    char *idstr;
1837
    char *pidstr;
1838
    unsigned int tmp;
1839 1840
    int ret = -1;

1841 1842
    idstr = virXMLPropString(node, "id");

1843 1844
    if (idstr &&
        (virStrToLong_uip(idstr, NULL, 10, &idx) < 0)) {
1845
        virReportError(VIR_ERR_INTERNAL_ERROR,
1846 1847 1848 1849 1850 1851
                       _("cannot parse vcpu index '%s'"), idstr);
        goto cleanup;
    }
    if (!(vcpu = virDomainDefGetVcpu(def, idx))) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("invalid vcpu index '%u'"), idx);
1852
        goto cleanup;
1853 1854
    }

1855 1856 1857
    if (!(pidstr = virXMLPropString(node, "pid")))
        goto cleanup;

1858
    if (virStrToLong_uip(pidstr, NULL, 10, &tmp) < 0)
1859 1860
        goto cleanup;

1861 1862
    QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->tid = tmp;

1863 1864 1865
    ret = 0;

 cleanup:
1866
    VIR_FREE(idstr);
1867 1868 1869 1870 1871
    VIR_FREE(pidstr);
    return ret;
}


1872
static int
1873
qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt,
1874
                             virDomainObjPtr vm,
1875
                             virDomainDefParserConfigPtr config)
1876
{
1877
    qemuDomainObjPrivatePtr priv = vm->privateData;
1878
    virQEMUDriverPtr driver = config->priv;
1879
    char *monitorpath;
1880
    char *tmp = NULL;
1881 1882
    int n;
    size_t i;
1883
    xmlNodePtr *nodes = NULL;
1884
    xmlNodePtr node = NULL;
1885
    virQEMUCapsPtr qemuCaps = NULL;
1886
    virCapsPtr caps = NULL;
1887

1888
    if (VIR_ALLOC(priv->monConfig) < 0)
1889 1890 1891 1892
        goto error;

    if (!(monitorpath =
          virXPathString("string(./monitor[1]/@path)", ctxt))) {
1893 1894
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("no monitor path"));
1895 1896 1897 1898 1899
        goto error;
    }

    tmp = virXPathString("string(./monitor[1]/@type)", ctxt);
    if (tmp)
1900
        priv->monConfig->type = virDomainChrTypeFromString(tmp);
1901
    else
1902
        priv->monConfig->type = VIR_DOMAIN_CHR_TYPE_PTY;
1903 1904
    VIR_FREE(tmp);

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

1908
    switch (priv->monConfig->type) {
1909
    case VIR_DOMAIN_CHR_TYPE_PTY:
1910
        priv->monConfig->data.file.path = monitorpath;
1911 1912
        break;
    case VIR_DOMAIN_CHR_TYPE_UNIX:
1913
        priv->monConfig->data.nix.path = monitorpath;
1914 1915 1916
        break;
    default:
        VIR_FREE(monitorpath);
1917 1918 1919
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("unsupported monitor type '%s'"),
                       virDomainChrTypeToString(priv->monConfig->type));
1920 1921 1922
        goto error;
    }

1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946
    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;
    }

1947
    if ((n = virXPathNodeSet("./vcpus/vcpu", ctxt, &nodes)) < 0)
1948 1949
        goto error;

1950
    for (i = 0; i < n; i++) {
1951
        if (qemuDomainObjPrivateXMLParseVcpu(nodes[i], i, vm->def) < 0)
1952
            goto error;
1953
    }
1954
    VIR_FREE(nodes);
1955

1956
    if ((n = virXPathNodeSet("./qemuCaps/flag", ctxt, &nodes)) < 0) {
1957 1958
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("failed to parse qemu capabilities flags"));
1959 1960 1961
        goto error;
    }
    if (n > 0) {
1962
        if (!(qemuCaps = virQEMUCapsNew()))
1963 1964
            goto error;

1965
        for (i = 0; i < n; i++) {
1966 1967
            char *str = virXMLPropString(nodes[i], "name");
            if (str) {
1968
                int flag = virQEMUCapsTypeFromString(str);
1969
                if (flag < 0) {
1970 1971
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("Unknown qemu capabilities flag %s"), str);
1972
                    VIR_FREE(str);
1973 1974
                    goto error;
                }
1975
                VIR_FREE(str);
1976
                virQEMUCapsSet(qemuCaps, flag);
1977 1978 1979
            }
        }

1980
        priv->qemuCaps = qemuCaps;
1981
        qemuCaps = NULL;
1982 1983 1984
    }
    VIR_FREE(nodes);

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

1987 1988 1989 1990
    if ((tmp = virXPathString("string(./job[1]/@type)", ctxt))) {
        int type;

        if ((type = qemuDomainJobTypeFromString(tmp)) < 0) {
1991 1992
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Unknown job type %s"), tmp);
1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003
            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) {
2004 2005
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Unknown async job type %s"), tmp);
2006 2007 2008 2009 2010
            VIR_FREE(tmp);
            goto error;
        }
        VIR_FREE(tmp);
        priv->job.asyncJob = async;
J
Jiri Denemark 已提交
2011 2012 2013 2014

        if ((tmp = virXPathString("string(./job[1]/@phase)", ctxt))) {
            priv->job.phase = qemuDomainAsyncJobPhaseFromString(async, tmp);
            if (priv->job.phase < 0) {
2015 2016
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Unknown job phase %s"), tmp);
J
Jiri Denemark 已提交
2017 2018 2019 2020 2021
                VIR_FREE(tmp);
                goto error;
            }
            VIR_FREE(tmp);
        }
2022 2023
    }

2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046
    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);

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

2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069
    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);

2070 2071 2072 2073
    if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
        goto error;

    if ((tmp = virXPathString("string(./numad/@nodeset)", ctxt))) {
2074
        if (virBitmapParse(tmp, &priv->autoNodeset,
2075 2076 2077 2078 2079 2080 2081 2082 2083 2084
                           caps->host.nnumaCell_max) < 0)
            goto error;

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

2085 2086 2087 2088 2089 2090 2091 2092 2093
    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;

2094 2095
    return 0;

2096
 error:
2097
    VIR_FREE(nodes);
2098
    VIR_FREE(tmp);
2099 2100 2101 2102
    virBitmapFree(priv->namespaces);
    priv->namespaces = NULL;
    virDomainChrSourceDefFree(priv->monConfig);
    priv->monConfig = NULL;
2103
    virStringListFree(priv->qemuDevices);
2104
    priv->qemuDevices = NULL;
2105
    virObjectUnref(qemuCaps);
2106
    virObjectUnref(caps);
2107 2108 2109 2110
    return -1;
}


2111 2112 2113
virDomainXMLPrivateDataCallbacks virQEMUDriverPrivateDataCallbacks = {
    .alloc = qemuDomainObjPrivateAlloc,
    .free = qemuDomainObjPrivateFree,
2114
    .diskNew = qemuDomainDiskPrivateNew,
2115
    .vcpuNew = qemuDomainVcpuPrivateNew,
2116
    .hostdevNew = qemuDomainHostdevPrivateNew,
2117
    .chrSourceNew = qemuDomainChrSourcePrivateNew,
2118 2119 2120 2121 2122
    .parse = qemuDomainObjPrivateXMLParse,
    .format = qemuDomainObjPrivateXMLFormat,
};


2123 2124 2125 2126 2127
static void
qemuDomainDefNamespaceFree(void *nsdata)
{
    qemuDomainCmdlineDefPtr cmd = nsdata;

2128
    qemuDomainCmdlineDefFree(cmd);
2129 2130 2131
}

static int
P
Philipp Hahn 已提交
2132 2133
qemuDomainDefNamespaceParse(xmlDocPtr xml ATTRIBUTE_UNUSED,
                            xmlNodePtr root ATTRIBUTE_UNUSED,
2134 2135 2136 2137
                            xmlXPathContextPtr ctxt,
                            void **data)
{
    qemuDomainCmdlineDefPtr cmd = NULL;
P
Philipp Hahn 已提交
2138
    bool uses_qemu_ns = false;
2139
    xmlNodePtr *nodes = NULL;
2140 2141
    int n;
    size_t i;
2142

P
Philipp Hahn 已提交
2143
    if (xmlXPathRegisterNs(ctxt, BAD_CAST "qemu", BAD_CAST QEMU_NAMESPACE_HREF) < 0) {
2144 2145 2146
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Failed to register xml namespace '%s'"),
                       QEMU_NAMESPACE_HREF);
2147 2148 2149
        return -1;
    }

2150
    if (VIR_ALLOC(cmd) < 0)
2151 2152 2153 2154 2155 2156
        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 已提交
2157
    uses_qemu_ns |= n > 0;
2158 2159

    if (n && VIR_ALLOC_N(cmd->args, n) < 0)
2160
        goto error;
2161 2162 2163 2164

    for (i = 0; i < n; i++) {
        cmd->args[cmd->num_args] = virXMLPropString(nodes[i], "value");
        if (cmd->args[cmd->num_args] == NULL) {
2165 2166
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("No qemu command-line argument specified"));
2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177
            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 已提交
2178
    uses_qemu_ns |= n > 0;
2179 2180

    if (n && VIR_ALLOC_N(cmd->env_name, n) < 0)
2181
        goto error;
2182 2183

    if (n && VIR_ALLOC_N(cmd->env_value, n) < 0)
2184
        goto error;
2185 2186 2187 2188 2189 2190

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

        tmp = virXMLPropString(nodes[i], "name");
        if (tmp == NULL) {
2191 2192
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("No qemu environment name specified"));
2193 2194 2195
            goto error;
        }
        if (tmp[0] == '\0') {
2196 2197
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("Empty qemu environment name specified"));
2198 2199 2200
            goto error;
        }
        if (!c_isalpha(tmp[0]) && tmp[0] != '_') {
2201 2202
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("Invalid environment name, it must begin with a letter or underscore"));
2203 2204 2205
            goto error;
        }
        if (strspn(tmp, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_") != strlen(tmp)) {
2206 2207
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("Invalid environment name, it must contain only alphanumerics and underscore"));
2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219
            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 已提交
2220 2221 2222 2223
    if (uses_qemu_ns)
        *data = cmd;
    else
        VIR_FREE(cmd);
2224 2225 2226

    return 0;

2227
 error:
2228 2229 2230 2231 2232 2233 2234 2235 2236 2237
    VIR_FREE(nodes);
    qemuDomainDefNamespaceFree(cmd);
    return -1;
}

static int
qemuDomainDefNamespaceFormatXML(virBufferPtr buf,
                                void *nsdata)
{
    qemuDomainCmdlineDefPtr cmd = nsdata;
2238
    size_t i;
2239 2240 2241 2242

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

2243 2244 2245
    virBufferAddLit(buf, "<qemu:commandline>\n");
    virBufferAdjustIndent(buf, 2);

2246
    for (i = 0; i < cmd->num_args; i++)
2247
        virBufferEscapeString(buf, "<qemu:arg value='%s'/>\n",
2248 2249
                              cmd->args[i]);
    for (i = 0; i < cmd->num_env; i++) {
2250
        virBufferAsprintf(buf, "<qemu:env name='%s'", cmd->env_name[i]);
2251 2252 2253 2254 2255
        if (cmd->env_value[i])
            virBufferEscapeString(buf, " value='%s'", cmd->env_value[i]);
        virBufferAddLit(buf, "/>\n");
    }

2256 2257
    virBufferAdjustIndent(buf, -2);
    virBufferAddLit(buf, "</qemu:commandline>\n");
2258 2259 2260 2261 2262 2263 2264 2265 2266 2267
    return 0;
}

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


2268 2269 2270 2271 2272 2273
virDomainXMLNamespace virQEMUDriverDomainXMLNamespace = {
    .parse = qemuDomainDefNamespaceParse,
    .free = qemuDomainDefNamespaceFree,
    .format = qemuDomainDefNamespaceFormatXML,
    .href = qemuDomainDefNamespaceHref,
};
2274

2275

P
Pavel Hrdina 已提交
2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294
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;
}


2295
static int
2296 2297
qemuDomainDefAddDefaultDevices(virDomainDefPtr def,
                               virQEMUCapsPtr qemuCaps)
2298
{
2299
    bool addDefaultUSB = true;
2300
    int usbModel = -1; /* "default for machinetype" */
2301
    int pciRoot;       /* index within def->controllers */
2302
    bool addImplicitSATA = false;
2303
    bool addPCIRoot = false;
L
Laine Stump 已提交
2304
    bool addPCIeRoot = false;
2305
    bool addDefaultMemballoon = true;
2306 2307
    bool addDefaultUSBKBD = false;
    bool addDefaultUSBMouse = false;
2308
    bool addPanicDevice = false;
2309
    int ret = -1;
2310

P
Pavel Hrdina 已提交
2311 2312 2313 2314
    /* add implicit input devices */
    if (qemuDomainDefAddImplicitInputDevice(def) < 0)
        goto cleanup;

2315 2316 2317 2318
    /* 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 已提交
2319
        if (STREQ(def->os.machine, "isapc")) {
2320
            addDefaultUSB = false;
2321
            break;
2322
        }
2323
        if (qemuDomainMachineIsQ35(def)) {
2324 2325
            addPCIeRoot = true;
            addImplicitSATA = true;
2326

2327 2328 2329 2330
            /* 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.
2331
             */
2332 2333 2334
            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))
2335 2336 2337
                usbModel = VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_EHCI1;
            else
                addDefaultUSB = false;
2338
            break;
L
Laine Stump 已提交
2339
        }
2340 2341
        if (qemuDomainMachineIsI440FX(def))
            addPCIRoot = true;
2342 2343
        break;

2344
    case VIR_ARCH_ARMV7L:
2345
    case VIR_ARCH_AARCH64:
2346 2347
        addDefaultUSB = false;
        addDefaultMemballoon = false;
J
Ján Tomko 已提交
2348
        if (qemuDomainMachineIsVirt(def))
2349 2350
            addPCIeRoot = virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_GPEX);
        break;
2351

2352
    case VIR_ARCH_PPC64:
2353
    case VIR_ARCH_PPC64LE:
2354 2355 2356
        addPCIRoot = true;
        addDefaultUSBKBD = true;
        addDefaultUSBMouse = true;
2357 2358 2359
        /* For pSeries guests, the firmware provides the same
         * functionality as the pvpanic device, so automatically
         * add the definition if not already present */
2360
        if (qemuDomainMachineIsPSeries(def))
2361
            addPanicDevice = true;
2362 2363
        break;

2364 2365 2366 2367 2368 2369 2370
    case VIR_ARCH_ALPHA:
    case VIR_ARCH_PPC:
    case VIR_ARCH_PPCEMB:
    case VIR_ARCH_SH4:
    case VIR_ARCH_SH4EB:
        addPCIRoot = true;
        break;
2371

2372 2373 2374
    case VIR_ARCH_S390:
    case VIR_ARCH_S390X:
        addDefaultUSB = false;
2375
        addPanicDevice = true;
2376
        break;
2377 2378 2379 2380 2381 2382

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

2383 2384 2385 2386
    default:
        break;
    }

2387
    if (addDefaultUSB &&
2388 2389
        virDomainControllerFind(def, VIR_DOMAIN_CONTROLLER_TYPE_USB, 0) < 0 &&
        virDomainDefAddUSBController(def, 0, usbModel) < 0)
2390
        goto cleanup;
2391

2392 2393 2394
    if (addImplicitSATA &&
        virDomainDefMaybeAddController(
            def, VIR_DOMAIN_CONTROLLER_TYPE_SATA, 0, -1) < 0)
2395
        goto cleanup;
2396

2397 2398
    pciRoot = virDomainControllerFind(def, VIR_DOMAIN_CONTROLLER_TYPE_PCI, 0);

2399 2400 2401
    /* NB: any machine that sets addPCIRoot to true must also return
     * true from the function qemuDomainSupportsPCI().
     */
2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416
    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;
        }
    }
2417

2418 2419 2420
    /* 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
2421 2422 2423
     *
     * NB: any machine that sets addPCIeRoot to true must also return
     * true from the function qemuDomainSupportsPCI().
2424 2425
     */
    if (addPCIeRoot) {
2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438
        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;
        }
2439
    }
2440

2441
    if (addDefaultMemballoon && !def->memballoon) {
2442 2443
        virDomainMemballoonDefPtr memballoon;
        if (VIR_ALLOC(memballoon) < 0)
2444
            goto cleanup;
2445 2446 2447 2448 2449

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

2450 2451 2452 2453 2454
    if (addDefaultUSBKBD &&
        def->ngraphics > 0 &&
        virDomainDefMaybeAddInput(def,
                                  VIR_DOMAIN_INPUT_TYPE_KBD,
                                  VIR_DOMAIN_INPUT_BUS_USB) < 0)
2455
        goto cleanup;
2456 2457 2458 2459 2460 2461

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

D
Dmitry Andreev 已提交
2464 2465 2466 2467
    if (addPanicDevice) {
        size_t j;
        for (j = 0; j < def->npanics; j++) {
            if (def->panics[j]->model == VIR_DOMAIN_PANIC_MODEL_DEFAULT ||
2468 2469 2470 2471
                (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 已提交
2472 2473
                break;
        }
2474

D
Dmitry Andreev 已提交
2475 2476 2477 2478 2479 2480 2481 2482 2483
        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;
            }
        }
2484 2485
    }

2486 2487 2488 2489 2490 2491
    ret = 0;
 cleanup:
    return ret;
}


A
Andrea Bolognani 已提交
2492 2493 2494
/**
 * qemuDomainDefEnableDefaultFeatures:
 * @def: domain definition
2495
 * @qemuCaps: QEMU capabilities
A
Andrea Bolognani 已提交
2496 2497 2498 2499 2500
 *
 * Make sure that features that should be enabled by default are actually
 * enabled and configure default values related to those features.
 */
static void
2501 2502
qemuDomainDefEnableDefaultFeatures(virDomainDefPtr def,
                                   virQEMUCapsPtr qemuCaps)
A
Andrea Bolognani 已提交
2503
{
2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523
    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 &&
        qemuDomainMachineIsVirt(def)) {

        VIR_DEBUG("Looking for usable GIC version in domain capabilities");
        for (version = VIR_GIC_VERSION_LAST - 1;
             version > VIR_GIC_VERSION_NONE;
             version--) {
            if (virQEMUCapsSupportsGICVersion(qemuCaps,
                                              def->virtType,
                                              version)) {
                VIR_DEBUG("Using GIC version %s",
                          virGICVersionTypeToString(version));
                def->gic_version = version;
                break;
            }
2524 2525
        }

2526 2527 2528
        /* 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;
2529 2530
    }

2531
    /* Use the default GIC version if no version was specified */
A
Andrea Bolognani 已提交
2532 2533
    if (def->features[VIR_DOMAIN_FEATURE_GIC] == VIR_TRISTATE_SWITCH_ON &&
        def->gic_version == VIR_GIC_VERSION_NONE)
2534
        def->gic_version = VIR_GIC_VERSION_DEFAULT;
A
Andrea Bolognani 已提交
2535 2536 2537
}


2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557
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;
}


2558
static int
2559 2560 2561 2562 2563
qemuDomainRecheckInternalPaths(virDomainDefPtr def,
                               virQEMUDriverConfigPtr cfg,
                               unsigned int flags)
{
    size_t i = 0;
2564
    size_t j = 0;
2565 2566 2567 2568

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

2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586
        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
             * the auto-generated socket base on config option from qemu.conf
             * 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 &&
                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;
                }
2587
            }
2588 2589
        }
    }
2590 2591

    return 0;
2592 2593 2594
}


2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664
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;
}


2665 2666 2667
static int
qemuDomainDefPostParse(virDomainDefPtr def,
                       virCapsPtr caps,
2668
                       unsigned int parseFlags,
2669
                       void *opaque,
2670
                       void *parseOpaque)
2671 2672
{
    virQEMUDriverPtr driver = opaque;
2673
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
2674
    virQEMUCapsPtr qemuCaps = parseOpaque;
2675 2676 2677 2678 2679
    int ret = -1;

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

2683 2684 2685
    if (!def->os.machine) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("missing machine type"));
2686
        goto cleanup;
2687 2688
    }

2689 2690 2691 2692 2693 2694 2695 2696 2697
    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;
    }

2698 2699 2700
    /* check for emulator and create a default one if needed */
    if (!def->emulator &&
        !(def->emulator = virDomainDefGetDefaultEmulator(def, caps)))
2701
        goto cleanup;
2702

2703 2704 2705 2706 2707 2708 2709 2710
    if (qemuCaps) {
        virObjectRef(qemuCaps);
    } else {
        if (!(qemuCaps = virQEMUCapsCacheLookup(caps,
                                                driver->qemuCapsCache,
                                                def->emulator)))
            goto cleanup;
    }
2711 2712 2713 2714

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

2715 2716 2717
    if (qemuCanonicalizeMachine(def, qemuCaps) < 0)
        goto cleanup;

2718
    qemuDomainDefEnableDefaultFeatures(def, qemuCaps);
A
Andrea Bolognani 已提交
2719

2720 2721
    if (qemuDomainRecheckInternalPaths(def, cfg, parseFlags) < 0)
        goto cleanup;
2722

2723 2724 2725
    if (virSecurityManagerVerify(driver->securityManager, def) < 0)
        goto cleanup;

2726 2727 2728
    if (qemuDomainDefVcpusPostParse(def) < 0)
        goto cleanup;

2729 2730 2731
    ret = 0;
 cleanup:
    virObjectUnref(qemuCaps);
2732
    virObjectUnref(cfg);
2733
    return ret;
2734 2735
}

2736

2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763
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 &&
2764 2765
            video->type != VIR_DOMAIN_VIDEO_TYPE_QXL &&
            video->type != VIR_DOMAIN_VIDEO_TYPE_VIRTIO) {
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 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808
            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;
}


2809 2810
static int
qemuDomainDefValidate(const virDomainDef *def,
2811
                      virCapsPtr caps,
2812
                      void *opaque)
2813
{
2814 2815
    virQEMUDriverPtr driver = opaque;
    virQEMUCapsPtr qemuCaps = NULL;
2816
    unsigned int topologycpus;
2817 2818
    int ret = -1;

2819 2820
    if (!(qemuCaps = virQEMUCapsCacheLookup(caps,
                                            driver->qemuCapsCache,
2821 2822 2823
                                            def->emulator)))
        goto cleanup;

2824 2825 2826
    if (def->mem.min_guarantee) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("Parameter 'min_guarantee' not supported by QEMU."));
2827
        goto cleanup;
2828 2829
    }

M
Michal Privoznik 已提交
2830 2831 2832 2833 2834 2835 2836 2837
    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. */

        if (!qemuDomainMachineIsQ35(def)) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Secure boot is supported with q35 machine types only"));
2838
            goto cleanup;
M
Michal Privoznik 已提交
2839 2840 2841 2842 2843 2844 2845 2846
        }

        /* 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"));
2847
            goto cleanup;
M
Michal Privoznik 已提交
2848 2849 2850 2851 2852
        }

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

2857
    /* qemu as of 2.5.0 rejects SMP topologies that don't match the cpu count */
2858 2859 2860 2861 2862 2863 2864
    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;
2865 2866 2867
        }
    }

2868 2869 2870
    if (qemuDomainDefValidateVideo(def) < 0)
        goto cleanup;

2871 2872 2873 2874 2875
    ret = 0;

 cleanup:
    virObjectUnref(qemuCaps);
    return ret;
2876 2877 2878
}


2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897
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;
        }
2898 2899 2900 2901 2902 2903 2904

        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;
        }
2905 2906 2907 2908 2909 2910 2911 2912 2913
    }

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


2914
static const char *
2915 2916
qemuDomainDefaultNetModel(const virDomainDef *def,
                          virQEMUCapsPtr qemuCaps)
2917
{
2918
    if (ARCH_IS_S390(def->os.arch))
2919 2920
        return "virtio";

2921 2922
    if (def->os.arch == VIR_ARCH_ARMV7L ||
        def->os.arch == VIR_ARCH_AARCH64) {
2923 2924 2925
        if (STREQ(def->os.machine, "versatilepb"))
            return "smc91c111";

J
Ján Tomko 已提交
2926
        if (qemuDomainMachineIsVirt(def))
2927 2928
            return "virtio";

2929 2930 2931 2932 2933
        /* Incomplete. vexpress (and a few others) use this, but not all
         * arm boards */
        return "lan9118";
    }

2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945
    /* 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 */
2946 2947
    return "rtl8139";
}
2948

2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961

/*
 * Clear auto generated unix socket path, i.e., the one which starts with our
 * channel directory.
 */
static void
qemuDomainChrDefDropDefaultPath(virDomainChrDefPtr chr,
                                virQEMUDriverPtr driver)
{
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);

    if (chr->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL &&
        chr->targetType == VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO &&
2962 2963 2964 2965
        chr->source->type == VIR_DOMAIN_CHR_TYPE_UNIX &&
        chr->source->data.nix.path &&
        STRPREFIX(chr->source->data.nix.path, cfg->channelTargetDir)) {
        VIR_FREE(chr->source->data.nix.path);
2966 2967 2968 2969 2970 2971
    }

    virObjectUnref(cfg);
}


2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021
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;
}


3022 3023
static int
qemuDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
3024
                             const virDomainDef *def,
3025
                             virCapsPtr caps,
3026
                             unsigned int parseFlags,
3027
                             void *opaque,
3028
                             void *parseOpaque)
3029
{
3030
    virQEMUDriverPtr driver = opaque;
3031
    virQEMUCapsPtr qemuCaps = parseOpaque;
3032
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
3033
    int ret = -1;
3034

3035 3036 3037 3038 3039 3040
    if (qemuCaps) {
        virObjectRef(qemuCaps);
    } else {
        qemuCaps = virQEMUCapsCacheLookup(caps, driver->qemuCapsCache,
                                          def->emulator);
    }
3041

3042
    if (dev->type == VIR_DOMAIN_DEVICE_NET &&
3043 3044
        dev->data.net->type != VIR_DOMAIN_NET_TYPE_HOSTDEV &&
        !dev->data.net->model) {
3045
        if (VIR_STRDUP(dev->data.net->model,
3046
                       qemuDomainDefaultNetModel(def, qemuCaps)) < 0)
3047
            goto cleanup;
3048
    }
3049

3050 3051 3052 3053
    /* set default disk types and drivers */
    if (dev->type == VIR_DOMAIN_DEVICE_DISK) {
        virDomainDiskDefPtr disk = dev->data.disk;

3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081
        /* 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;
3082 3083 3084
        }
    }

3085 3086 3087 3088
    /* 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 &&
3089
        ARCH_IS_S390(def->os.arch))
3090 3091
        dev->data.chr->targetType = VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO;

3092 3093 3094 3095 3096
    /* set the default USB model to none for s390 unless an address is found */
    if (dev->type == VIR_DOMAIN_DEVICE_CONTROLLER &&
        dev->data.controller->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
        dev->data.controller->model == -1 &&
        dev->data.controller->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE &&
3097
        ARCH_IS_S390(def->os.arch))
3098 3099
        dev->data.controller->model = VIR_DOMAIN_CONTROLLER_MODEL_USB_NONE;

3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112
    /* forbid usb model 'qusb1' and 'qusb2' in this kind of hyperviosr */
    if (dev->type == VIR_DOMAIN_DEVICE_CONTROLLER &&
        dev->data.controller->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
        (dev->data.controller->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_QUSB1 ||
         dev->data.controller->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));
        goto cleanup;
    }


3113 3114 3115 3116 3117 3118 3119
    /* set the default SCSI controller model for S390 arches */
    if (dev->type == VIR_DOMAIN_DEVICE_CONTROLLER &&
        dev->data.controller->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI &&
        dev->data.controller->model == -1 &&
        ARCH_IS_S390(def->os.arch))
        dev->data.controller->model = VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_SCSI;

3120 3121
    /* clear auto generated unix socket path for inactive definitions */
    if ((parseFlags & VIR_DOMAIN_DEF_PARSE_INACTIVE) &&
3122 3123
        dev->type == VIR_DOMAIN_DEVICE_CHR)
        qemuDomainChrDefDropDefaultPath(dev->data.chr, driver);
3124

3125 3126 3127 3128 3129 3130 3131 3132 3133 3134
    /* 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;
    }

3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149
    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 {
3150
            dev->data.video->vgamem = QEMU_QXL_VGAMEM_DEFAULT;
3151 3152 3153
        }
    }

3154 3155
    if (dev->type == VIR_DOMAIN_DEVICE_PANIC &&
        dev->data.panic->model == VIR_DOMAIN_PANIC_MODEL_DEFAULT) {
3156
        if (qemuDomainMachineIsPSeries(def))
3157
            dev->data.panic->model = VIR_DOMAIN_PANIC_MODEL_PSERIES;
3158 3159
        else if (ARCH_IS_S390(def->os.arch))
            dev->data.panic->model = VIR_DOMAIN_PANIC_MODEL_S390;
3160 3161 3162 3163
        else
            dev->data.panic->model = VIR_DOMAIN_PANIC_MODEL_ISA;
    }

3164 3165 3166 3167

    if (dev->type == VIR_DOMAIN_DEVICE_CONTROLLER) {
        virDomainControllerDefPtr cont = dev->data.controller;

3168 3169 3170
        if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI) {
            if (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCI_EXPANDER_BUS &&
                !qemuDomainMachineIsI440FX(def)) {
3171 3172 3173 3174 3175
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("pci-expander-bus controllers are only supported "
                                 "on 440fx-based machinetypes"));
                goto cleanup;
            }
3176 3177 3178 3179 3180 3181 3182
            if (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCIE_EXPANDER_BUS &&
                !qemuDomainMachineIsQ35(def)) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("pcie-expander-bus controllers are only supported "
                                 "on q35-based machinetypes"));
                goto cleanup;
            }
3183 3184 3185 3186 3187 3188

            /* 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.
             */
3189 3190 3191
            if ((cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCI_EXPANDER_BUS ||
                 cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCIE_EXPANDER_BUS) &&
                (int) virDomainNumaGetNodeCount(def->numa)
3192 3193
                <= cont->opts.pciopts.numaNode) {
                virReportError(VIR_ERR_XML_ERROR,
3194
                               _("%s with index %d is "
3195 3196 3197
                                 "configured for a NUMA node (%d) "
                                 "not present in the domain's "
                                 "<cpu><numa> array (%zu)"),
3198
                               virDomainControllerModelPCITypeToString(cont->model),
3199 3200 3201 3202
                               cont->idx, cont->opts.pciopts.numaNode,
                               virDomainNumaGetNodeCount(def->numa));
                goto cleanup;
            }
3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222
        } else if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
                   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() */
            if (ARCH_IS_PPC64(def->os.arch)) {
                /* Default USB controller for ppc64 is pci-ohci */
                if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_PCI_OHCI))
                    cont->model = VIR_DOMAIN_CONTROLLER_MODEL_USB_PCI_OHCI;
            } else {
                /* Default USB controller for anything else is piix3-uhci */
                if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_PIIX3_USB_UHCI))
                    cont->model = VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX3_UHCI;
            }
3223 3224 3225
        }
    }

3226 3227 3228 3229
    if (dev->type == VIR_DOMAIN_DEVICE_SHMEM &&
        qemuDomainShmemDefPostParse(dev->data.shmem) < 0)
        goto cleanup;

3230 3231
    ret = 0;

3232
 cleanup:
3233
    virObjectUnref(qemuCaps);
3234 3235
    virObjectUnref(cfg);
    return ret;
3236 3237 3238
}


3239 3240
static int
qemuDomainDefAssignAddresses(virDomainDef *def,
3241
                             virCapsPtr caps,
3242
                             unsigned int parseFlags ATTRIBUTE_UNUSED,
3243
                             void *opaque,
3244
                             void *parseOpaque)
3245 3246
{
    virQEMUDriverPtr driver = opaque;
3247
    virQEMUCapsPtr qemuCaps = parseOpaque;
3248
    int ret = -1;
3249
    bool newDomain = parseFlags & VIR_DOMAIN_DEF_PARSE_ABI_UPDATE;
3250

3251 3252 3253 3254 3255 3256 3257 3258
    if (qemuCaps) {
        virObjectRef(qemuCaps);
    } else {
        if (!(qemuCaps = virQEMUCapsCacheLookup(caps,
                                                driver->qemuCapsCache,
                                                def->emulator)))
            goto cleanup;
    }
3259

3260
    if (qemuDomainAssignAddresses(def, qemuCaps, driver, NULL, newDomain) < 0)
3261 3262 3263 3264 3265 3266 3267 3268 3269
        goto cleanup;

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


3270 3271
virDomainDefParserConfig virQEMUDriverDomainDefParserConfig = {
    .devicesPostParseCallback = qemuDomainDeviceDefPostParse,
3272
    .domainPostParseCallback = qemuDomainDefPostParse,
3273
    .assignAddressesCallback = qemuDomainDefAssignAddresses,
3274
    .domainValidateCallback = qemuDomainDefValidate,
3275 3276
    .deviceValidateCallback = qemuDomainDeviceDefValidate,

3277
    .features = VIR_DOMAIN_DEF_FEATURE_MEMORY_HOTPLUG |
3278 3279
                VIR_DOMAIN_DEF_FEATURE_OFFLINE_VCPUPIN |
                VIR_DOMAIN_DEF_FEATURE_INDIVIDUAL_VCPUS,
3280 3281 3282
};


3283
static void
3284
qemuDomainObjSaveJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
3285
{
3286 3287 3288
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);

    if (virDomainObjIsActive(obj)) {
3289
        if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, obj, driver->caps) < 0)
3290
            VIR_WARN("Failed to save status on vm %s", obj->def->name);
3291
    }
3292

3293
    virObjectUnref(cfg);
3294 3295
}

J
Jiri Denemark 已提交
3296
void
3297
qemuDomainObjSetJobPhase(virQEMUDriverPtr driver,
J
Jiri Denemark 已提交
3298 3299 3300 3301
                         virDomainObjPtr obj,
                         int phase)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
3302
    unsigned long long me = virThreadSelfID();
J
Jiri Denemark 已提交
3303 3304 3305 3306

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

3307 3308 3309 3310 3311
    VIR_DEBUG("Setting '%s' phase to '%s'",
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
              qemuDomainAsyncJobPhaseToString(priv->job.asyncJob, phase));

    if (priv->job.asyncOwner && me != priv->job.asyncOwner) {
3312
        VIR_WARN("'%s' async job is owned by thread %llu",
3313 3314 3315 3316
                 qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
                 priv->job.asyncOwner);
    }

J
Jiri Denemark 已提交
3317
    priv->job.phase = phase;
3318
    priv->job.asyncOwner = me;
J
Jiri Denemark 已提交
3319 3320 3321
    qemuDomainObjSaveJob(driver, obj);
}

3322
void
3323 3324
qemuDomainObjSetAsyncJobMask(virDomainObjPtr obj,
                             unsigned long long allowedJobs)
3325 3326 3327
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

3328 3329 3330 3331 3332 3333 3334
    if (!priv->job.asyncJob)
        return;

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

void
3335
qemuDomainObjDiscardAsyncJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
3336 3337 3338 3339 3340 3341
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

    if (priv->job.active == QEMU_JOB_ASYNC_NESTED)
        qemuDomainObjResetJob(priv);
    qemuDomainObjResetAsyncJob(priv);
3342
    qemuDomainObjSaveJob(driver, obj);
3343 3344
}

3345 3346 3347 3348 3349 3350 3351 3352 3353
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()) {
3354
        VIR_WARN("'%s' async job is owned by thread %llu",
3355 3356 3357 3358 3359 3360
                 qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
                 priv->job.asyncOwner);
    }
    priv->job.asyncOwner = 0;
}

3361
static bool
3362
qemuDomainNestedJobAllowed(qemuDomainObjPrivatePtr priv, qemuDomainJob job)
3363 3364
{
    return !priv->job.asyncJob || (priv->job.mask & JOB_MASK(job)) != 0;
3365 3366
}

3367
bool
3368
qemuDomainJobAllowed(qemuDomainObjPrivatePtr priv, qemuDomainJob job)
3369 3370 3371 3372
{
    return !priv->job.active && qemuDomainNestedJobAllowed(priv, job);
}

3373 3374 3375
/* Give up waiting for mutex after 30 seconds */
#define QEMU_JOB_WAIT_TIME (1000ull * 30)

3376
/*
3377
 * obj must be locked before calling
3378
 */
3379
static int ATTRIBUTE_NONNULL(1)
3380
qemuDomainObjBeginJobInternal(virQEMUDriverPtr driver,
3381
                              virDomainObjPtr obj,
3382 3383
                              qemuDomainJob job,
                              qemuDomainAsyncJob asyncJob)
3384 3385
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
J
Jiri Denemark 已提交
3386
    unsigned long long now;
3387
    unsigned long long then;
3388
    bool nested = job == QEMU_JOB_ASYNC_NESTED;
J
Jiri Denemark 已提交
3389
    bool async = job == QEMU_JOB_ASYNC;
3390
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
3391
    const char *blocker = NULL;
J
Jiri Denemark 已提交
3392
    int ret = -1;
J
Jiri Denemark 已提交
3393 3394
    unsigned long long duration = 0;
    unsigned long long asyncDuration = 0;
J
Jiri Denemark 已提交
3395
    const char *jobStr;
3396

J
Jiri Denemark 已提交
3397 3398 3399 3400 3401 3402 3403 3404 3405
    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));
3406

3407 3408
    if (virTimeMillisNow(&now) < 0) {
        virObjectUnref(cfg);
3409
        return -1;
3410 3411
    }

3412
    priv->jobs_queued++;
J
Jiri Denemark 已提交
3413
    then = now + QEMU_JOB_WAIT_TIME;
3414

3415
 retry:
3416 3417
    if (cfg->maxQueuedJobs &&
        priv->jobs_queued > cfg->maxQueuedJobs) {
3418 3419 3420
        goto error;
    }

3421
    while (!nested && !qemuDomainNestedJobAllowed(priv, job)) {
3422
        VIR_DEBUG("Waiting for async job (vm=%p name=%s)", obj, obj->def->name);
3423
        if (virCondWaitUntil(&priv->job.asyncCond, &obj->parent.lock, then) < 0)
3424 3425 3426
            goto error;
    }

3427
    while (priv->job.active) {
3428
        VIR_DEBUG("Waiting for job (vm=%p name=%s)", obj, obj->def->name);
3429
        if (virCondWaitUntil(&priv->job.cond, &obj->parent.lock, then) < 0)
3430
            goto error;
3431
    }
3432 3433 3434

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

3438
    qemuDomainObjResetJob(priv);
3439

J
Jiri Denemark 已提交
3440 3441
    ignore_value(virTimeMillisNow(&now));

3442
    if (job != QEMU_JOB_ASYNC) {
3443
        VIR_DEBUG("Started job: %s (async=%s vm=%p name=%s)",
3444
                   qemuDomainJobTypeToString(job),
3445 3446
                  qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
                  obj, obj->def->name);
3447
        priv->job.active = job;
3448
        priv->job.owner = virThreadSelfID();
3449
        priv->job.ownerAPI = virThreadJobGet();
J
Jiri Denemark 已提交
3450
        priv->job.started = now;
3451
    } else {
3452 3453 3454
        VIR_DEBUG("Started async job: %s (vm=%p name=%s)",
                  qemuDomainAsyncJobTypeToString(asyncJob),
                  obj, obj->def->name);
3455
        qemuDomainObjResetAsyncJob(priv);
J
Jiri Denemark 已提交
3456 3457
        if (VIR_ALLOC(priv->job.current) < 0)
            goto cleanup;
3458
        priv->job.asyncJob = asyncJob;
3459
        priv->job.asyncOwner = virThreadSelfID();
3460
        priv->job.asyncOwnerAPI = virThreadJobGet();
J
Jiri Denemark 已提交
3461
        priv->job.asyncStarted = now;
J
Jiri Denemark 已提交
3462
        priv->job.current->started = now;
3463
    }
3464

3465 3466
    if (qemuDomainTrackJob(job))
        qemuDomainObjSaveJob(driver, obj);
3467

3468
    virObjectUnref(cfg);
3469
    return 0;
3470

3471
 error:
J
Jiri Denemark 已提交
3472 3473 3474 3475 3476 3477
    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;

3478
    VIR_WARN("Cannot start job (%s, %s) for domain %s; "
J
Jiri Denemark 已提交
3479 3480
             "current job is (%s, %s) owned by (%llu %s, %llu %s) "
             "for (%llus, %llus)",
3481 3482 3483 3484 3485
             qemuDomainJobTypeToString(job),
             qemuDomainAsyncJobTypeToString(asyncJob),
             obj->def->name,
             qemuDomainJobTypeToString(priv->job.active),
             qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
3486
             priv->job.owner, NULLSTR(priv->job.ownerAPI),
J
Jiri Denemark 已提交
3487 3488
             priv->job.asyncOwner, NULLSTR(priv->job.asyncOwnerAPI),
             duration / 1000, asyncDuration / 1000);
3489 3490 3491 3492 3493

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

3495 3496
    ret = -1;
    if (errno == ETIMEDOUT) {
3497 3498 3499 3500 3501 3502 3503 3504
        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"));
        }
3505 3506 3507
        ret = -2;
    } else if (cfg->maxQueuedJobs &&
               priv->jobs_queued > cfg->maxQueuedJobs) {
3508 3509 3510 3511 3512 3513 3514 3515 3516 3517
        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"));
        }
3518 3519
        ret = -2;
    } else {
3520
        virReportSystemError(errno, "%s", _("cannot acquire job mutex"));
3521
    }
J
Jiri Denemark 已提交
3522 3523

 cleanup:
3524
    priv->jobs_queued--;
3525
    virObjectUnref(cfg);
3526
    return ret;
3527 3528 3529
}

/*
3530
 * obj must be locked before calling
3531 3532 3533 3534
 *
 * This must be called by anything that will change the VM state
 * in any way, or anything that will use the QEMU monitor.
 *
3535
 * Successful calls must be followed by EndJob eventually
3536
 */
3537
int qemuDomainObjBeginJob(virQEMUDriverPtr driver,
3538
                          virDomainObjPtr obj,
3539
                          qemuDomainJob job)
3540
{
3541 3542 3543 3544 3545
    if (qemuDomainObjBeginJobInternal(driver, obj, job,
                                      QEMU_ASYNC_JOB_NONE) < 0)
        return -1;
    else
        return 0;
3546 3547
}

3548
int qemuDomainObjBeginAsyncJob(virQEMUDriverPtr driver,
3549
                               virDomainObjPtr obj,
3550
                               qemuDomainAsyncJob asyncJob)
3551
{
3552 3553 3554 3555 3556
    if (qemuDomainObjBeginJobInternal(driver, obj, QEMU_JOB_ASYNC,
                                      asyncJob) < 0)
        return -1;
    else
        return 0;
3557 3558
}

3559
int
3560 3561
qemuDomainObjBeginNestedJob(virQEMUDriverPtr driver,
                            virDomainObjPtr obj,
3562
                            qemuDomainAsyncJob asyncJob)
3563 3564 3565 3566 3567 3568 3569 3570 3571 3572
{
    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()) {
3573
        VIR_WARN("This thread doesn't seem to be the async job owner: %llu",
3574 3575 3576 3577 3578 3579 3580 3581
                 priv->job.asyncOwner);
    }

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

3582

3583
/*
3584
 * obj must be locked and have a reference before calling
3585 3586 3587 3588
 *
 * To be called after completing the work associated with the
 * earlier qemuDomainBeginJob() call
 */
3589 3590
void
qemuDomainObjEndJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
3591 3592
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
3593
    qemuDomainJob job = priv->job.active;
3594

3595 3596
    priv->jobs_queued--;

3597
    VIR_DEBUG("Stopping job: %s (async=%s vm=%p name=%s)",
3598
              qemuDomainJobTypeToString(job),
3599 3600
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
              obj, obj->def->name);
3601

3602
    qemuDomainObjResetJob(priv);
3603 3604
    if (qemuDomainTrackJob(job))
        qemuDomainObjSaveJob(driver, obj);
3605
    virCondSignal(&priv->job.cond);
3606 3607
}

3608
void
3609
qemuDomainObjEndAsyncJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
3610 3611
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
3612

3613 3614
    priv->jobs_queued--;

3615 3616 3617
    VIR_DEBUG("Stopping async job: %s (vm=%p name=%s)",
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
              obj, obj->def->name);
3618

3619
    qemuDomainObjResetAsyncJob(priv);
3620
    qemuDomainObjSaveJob(driver, obj);
3621 3622 3623
    virCondBroadcast(&priv->job.asyncCond);
}

3624 3625 3626 3627 3628
void
qemuDomainObjAbortAsyncJob(virDomainObjPtr obj)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

3629 3630 3631
    VIR_DEBUG("Requesting abort of async job: %s (vm=%p name=%s)",
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
              obj, obj->def->name);
3632

3633 3634
    priv->job.abortJob = true;
    virDomainObjBroadcast(obj);
3635 3636
}

3637 3638 3639 3640 3641 3642 3643 3644 3645
/*
 * 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
 */
3646
static int
3647
qemuDomainObjEnterMonitorInternal(virQEMUDriverPtr driver,
3648
                                  virDomainObjPtr obj,
3649
                                  qemuDomainAsyncJob asyncJob)
3650 3651 3652
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

3653
    if (asyncJob != QEMU_ASYNC_JOB_NONE) {
3654 3655 3656
        int ret;
        if ((ret = qemuDomainObjBeginNestedJob(driver, obj, asyncJob)) < 0)
            return ret;
3657
        if (!virDomainObjIsActive(obj)) {
3658 3659
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("domain is no longer running"));
3660
            qemuDomainObjEndJob(driver, obj);
3661 3662
            return -1;
        }
3663 3664 3665
    } 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");
3666 3667
    }

3668 3669
    VIR_DEBUG("Entering monitor (mon=%p vm=%p name=%s)",
              priv->mon, obj, obj->def->name);
3670
    virObjectLock(priv->mon);
3671
    virObjectRef(priv->mon);
3672
    ignore_value(virTimeMillisNow(&priv->monStart));
3673
    virObjectUnlock(obj);
3674 3675

    return 0;
3676 3677
}

3678
static void ATTRIBUTE_NONNULL(1)
3679
qemuDomainObjExitMonitorInternal(virQEMUDriverPtr driver,
3680
                                 virDomainObjPtr obj)
3681 3682
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
3683
    bool hasRefs;
3684

3685
    hasRefs = virObjectUnref(priv->mon);
3686

3687
    if (hasRefs)
3688
        virObjectUnlock(priv->mon);
3689

3690
    virObjectLock(obj);
3691 3692
    VIR_DEBUG("Exited monitor (mon=%p vm=%p name=%s)",
              priv->mon, obj, obj->def->name);
3693

3694
    priv->monStart = 0;
3695
    if (!hasRefs)
3696
        priv->mon = NULL;
3697

J
Jiri Denemark 已提交
3698 3699
    if (priv->job.active == QEMU_JOB_ASYNC_NESTED)
        qemuDomainObjEndJob(driver, obj);
3700 3701
}

3702
void qemuDomainObjEnterMonitor(virQEMUDriverPtr driver,
3703
                               virDomainObjPtr obj)
3704
{
3705
    ignore_value(qemuDomainObjEnterMonitorInternal(driver, obj,
3706
                                                   QEMU_ASYNC_JOB_NONE));
3707 3708
}

3709
/* obj must NOT be locked before calling
3710 3711
 *
 * Should be paired with an earlier qemuDomainObjEnterMonitor() call
3712 3713 3714 3715 3716 3717
 *
 * 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.
3718
 */
3719 3720
int qemuDomainObjExitMonitor(virQEMUDriverPtr driver,
                             virDomainObjPtr obj)
3721
{
3722
    qemuDomainObjExitMonitorInternal(driver, obj);
3723
    if (!virDomainObjIsActive(obj)) {
3724 3725 3726
        if (!virGetLastError())
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("domain is no longer running"));
3727 3728 3729
        return -1;
    }
    return 0;
3730
}
3731 3732

/*
3733
 * obj must be locked before calling
3734 3735
 *
 * To be called immediately before any QEMU monitor API call.
3736
 * Must have already either called qemuDomainObjBeginJob()
3737 3738 3739 3740 3741
 * 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
3742 3743 3744
 * 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).
3745 3746
 */
int
3747
qemuDomainObjEnterMonitorAsync(virQEMUDriverPtr driver,
3748
                               virDomainObjPtr obj,
3749
                               qemuDomainAsyncJob asyncJob)
3750
{
3751
    return qemuDomainObjEnterMonitorInternal(driver, obj, asyncJob);
3752 3753
}

D
Daniel P. Berrange 已提交
3754

3755 3756 3757 3758 3759 3760 3761 3762 3763
/*
 * 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
 */
3764
qemuAgentPtr
3765
qemuDomainObjEnterAgent(virDomainObjPtr obj)
D
Daniel P. Berrange 已提交
3766 3767
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
3768
    qemuAgentPtr agent = priv->agent;
D
Daniel P. Berrange 已提交
3769

3770 3771
    VIR_DEBUG("Entering agent (agent=%p vm=%p name=%s)",
              priv->agent, obj, obj->def->name);
3772 3773 3774

    virObjectLock(agent);
    virObjectRef(agent);
3775
    virObjectUnlock(obj);
3776 3777

    return agent;
D
Daniel P. Berrange 已提交
3778 3779
}

3780 3781 3782 3783 3784 3785

/* obj must NOT be locked before calling
 *
 * Should be paired with an earlier qemuDomainObjEnterAgent() call
 */
void
3786
qemuDomainObjExitAgent(virDomainObjPtr obj, qemuAgentPtr agent)
D
Daniel P. Berrange 已提交
3787
{
3788 3789
    virObjectUnlock(agent);
    virObjectUnref(agent);
3790
    virObjectLock(obj);
D
Daniel P. Berrange 已提交
3791

3792 3793
    VIR_DEBUG("Exited agent (agent=%p vm=%p name=%s)",
              agent, obj, obj->def->name);
D
Daniel P. Berrange 已提交
3794 3795
}

3796
void qemuDomainObjEnterRemote(virDomainObjPtr obj)
3797
{
3798 3799
    VIR_DEBUG("Entering remote (vm=%p name=%s)",
              obj, obj->def->name);
3800
    virObjectUnlock(obj);
3801 3802
}

3803
void qemuDomainObjExitRemote(virDomainObjPtr obj)
3804
{
3805
    virObjectLock(obj);
3806 3807
    VIR_DEBUG("Exited remote (vm=%p name=%s)",
              obj, obj->def->name);
3808
}
3809 3810


3811 3812 3813 3814 3815 3816 3817 3818
virDomainDefPtr
qemuDomainDefCopy(virQEMUDriverPtr driver,
                  virDomainDefPtr src,
                  unsigned int flags)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    virDomainDefPtr ret = NULL;
    virCapsPtr caps = NULL;
3819
    char *xml = NULL;
3820 3821 3822 3823 3824 3825 3826 3827 3828

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

    xml = virBufferContentAndReset(&buf);

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

3829
    if (!(ret = virDomainDefParseString(xml, caps, driver->xmlopt, NULL,
3830
                                        VIR_DOMAIN_DEF_PARSE_INACTIVE |
3831
                                        VIR_DOMAIN_DEF_PARSE_SKIP_VALIDATE)))
3832 3833
        goto cleanup;

3834
 cleanup:
3835 3836 3837 3838 3839
    VIR_FREE(xml);
    virObjectUnref(caps);
    return ret;
}

3840
int
3841
qemuDomainDefFormatBuf(virQEMUDriverPtr driver,
3842 3843 3844
                       virDomainDefPtr def,
                       unsigned int flags,
                       virBuffer *buf)
3845
{
3846
    int ret = -1;
3847
    virDomainDefPtr copy = NULL;
3848 3849 3850 3851
    virCapsPtr caps = NULL;

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

3853 3854 3855
    if (!(flags & (VIR_DOMAIN_XML_UPDATE_CPU | VIR_DOMAIN_XML_MIGRATABLE)))
        goto format;

3856
    if (!(copy = virDomainDefCopy(def, caps, driver->xmlopt, NULL,
3857 3858 3859 3860 3861
                                  flags & VIR_DOMAIN_XML_MIGRATABLE)))
        goto cleanup;

    def = copy;

3862
    /* Update guest CPU requirements according to host CPU */
3863
    if ((flags & VIR_DOMAIN_XML_UPDATE_CPU) &&
3864
        def->cpu &&
3865 3866
        (def->cpu->mode != VIR_CPU_MODE_CUSTOM ||
         def->cpu->model)) {
J
Jiri Denemark 已提交
3867
        if (virCPUUpdate(def->os.arch, def->cpu, caps->host.cpu) < 0)
3868 3869 3870
            goto cleanup;
    }

3871
    if ((flags & VIR_DOMAIN_XML_MIGRATABLE)) {
3872
        size_t i;
3873
        int toremove = 0;
3874
        virDomainControllerDefPtr usb = NULL, pci = NULL;
3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889

        /* 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];
            }
        }
3890 3891 3892 3893 3894 3895 3896 3897 3898

        /* 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'/>.
3899
         */
3900
        if (ARCH_IS_X86(def->os.arch) && qemuDomainMachineIsI440FX(def) &&
3901 3902 3903
            usb && usb->idx == 0 &&
            (usb->model == -1 ||
             usb->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX3_UHCI)) {
3904 3905
            VIR_DEBUG("Removing default USB controller from domain '%s'"
                      " for migration compatibility", def->name);
3906
            toremove++;
3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924
        } 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 已提交
3925
            VIR_DEBUG("Removing default pci-root from domain '%s'"
3926
                      " for migration compatibility", def->name);
3927
            toremove++;
3928 3929 3930 3931
        } else {
            pci = NULL;
        }

3932
        if (toremove) {
3933 3934 3935
            virDomainControllerDefPtr *controllers = def->controllers;
            int ncontrollers = def->ncontrollers;

3936
            if (VIR_ALLOC_N(def->controllers, ncontrollers - toremove) < 0) {
3937
                def->controllers = controllers;
3938 3939 3940 3941 3942
                goto cleanup;
            }

            def->ncontrollers = 0;
            for (i = 0; i < ncontrollers; i++) {
3943
                if (controllers[i] != usb && controllers[i] != pci)
3944 3945
                    def->controllers[def->ncontrollers++] = controllers[i];
            }
3946 3947 3948 3949

            VIR_FREE(controllers);
            virDomainControllerDefFree(pci);
            virDomainControllerDefFree(usb);
3950
        }
3951

3952 3953 3954 3955 3956 3957 3958 3959 3960
        /* 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;
            }
        }

3961 3962
        for (i = 0; i < def->nchannels; i++)
            qemuDomainChrDefDropDefaultPath(def->channels[i], driver);
3963 3964
    }

3965 3966
 format:
    ret = virDomainDefFormatInternal(def, caps,
3967 3968
                                     virDomainDefFormatConvertXMLFlags(flags),
                                     buf);
3969

3970
 cleanup:
3971
    virDomainDefFree(copy);
3972
    virObjectUnref(caps);
3973 3974
    return ret;
}
3975

3976
char *qemuDomainDefFormatXML(virQEMUDriverPtr driver,
3977
                             virDomainDefPtr def,
3978
                             unsigned int flags)
3979 3980 3981
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

3982
    if (qemuDomainDefFormatBuf(driver, def, flags, &buf) < 0) {
3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995
        virBufferFreeAndReset(&buf);
        return NULL;
    }

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

    return virBufferContentAndReset(&buf);
}

3996
char *qemuDomainFormatXML(virQEMUDriverPtr driver,
3997
                          virDomainObjPtr vm,
3998
                          unsigned int flags)
3999 4000 4001
{
    virDomainDefPtr def;

4002
    if ((flags & VIR_DOMAIN_XML_INACTIVE) && vm->newDef) {
4003
        def = vm->newDef;
4004
    } else {
4005
        def = vm->def;
4006 4007 4008
        if (virDomainObjIsActive(vm))
            flags &= ~VIR_DOMAIN_XML_UPDATE_CPU;
    }
4009

4010
    return qemuDomainDefFormatXML(driver, def, flags);
4011 4012
}

4013
char *
4014
qemuDomainDefFormatLive(virQEMUDriverPtr driver,
4015
                        virDomainDefPtr def,
4016 4017
                        bool inactive,
                        bool compatible)
4018 4019 4020 4021 4022
{
    unsigned int flags = QEMU_DOMAIN_FORMAT_LIVE_FLAGS;

    if (inactive)
        flags |= VIR_DOMAIN_XML_INACTIVE;
4023 4024
    if (compatible)
        flags |= VIR_DOMAIN_XML_MIGRATABLE;
4025

4026
    return qemuDomainDefFormatXML(driver, def, flags);
4027 4028
}

4029

4030
void qemuDomainObjTaint(virQEMUDriverPtr driver,
4031
                        virDomainObjPtr obj,
4032
                        virDomainTaintFlags taint,
4033
                        qemuDomainLogContextPtr logCtxt)
4034
{
4035
    virErrorPtr orig_err = NULL;
4036
    bool closeLog = false;
4037

4038 4039 4040 4041 4042 4043 4044 4045 4046
    if (virDomainObjTaint(obj, taint)) {
        char uuidstr[VIR_UUID_STRING_BUFLEN];
        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));
4047 4048 4049 4050 4051

        /* We don't care about errors logging taint info, so
         * preserve original error, and clear any error that
         * is raised */
        orig_err = virSaveLastError();
4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069
        if (logCtxt == NULL) {
            logCtxt = qemuDomainLogContextNew(driver, obj,
                                              QEMU_DOMAIN_LOG_CONTEXT_MODE_ATTACH);
            if (!logCtxt) {
                if (orig_err) {
                    virSetError(orig_err);
                    virFreeError(orig_err);
                }
                VIR_WARN("Unable to open domainlog");
                return;
            }
            closeLog = true;
        }

        if (qemuDomainLogContextWrite(logCtxt,
                                      "Domain id=%d is tainted: %s\n",
                                      obj->def->id,
                                      virDomainTaintTypeToString(taint)) < 0)
4070
            virResetLastError();
4071 4072
        if (closeLog)
            qemuDomainLogContextFree(logCtxt);
4073 4074 4075 4076
        if (orig_err) {
            virSetError(orig_err);
            virFreeError(orig_err);
        }
4077 4078 4079 4080
    }
}


4081
void qemuDomainObjCheckTaint(virQEMUDriverPtr driver,
4082
                             virDomainObjPtr obj,
4083
                             qemuDomainLogContextPtr logCtxt)
4084
{
4085
    size_t i;
4086
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
4087
    qemuDomainObjPrivatePtr priv = obj->privateData;
4088

4089
    if (virQEMUDriverIsPrivileged(driver) &&
4090 4091 4092
        (!cfg->clearEmulatorCapabilities ||
         cfg->user == 0 ||
         cfg->group == 0))
4093
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HIGH_PRIVILEGES, logCtxt);
4094

4095
    if (priv->hookRun)
4096
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HOOK, logCtxt);
4097

4098 4099 4100
    if (obj->def->namespaceData) {
        qemuDomainCmdlineDefPtr qemucmd = obj->def->namespaceData;
        if (qemucmd->num_args || qemucmd->num_env)
4101
            qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_CUSTOM_ARGV, logCtxt);
4102 4103
    }

4104
    if (obj->def->cpu && obj->def->cpu->mode == VIR_CPU_MODE_HOST_PASSTHROUGH)
4105
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HOST_CPU, logCtxt);
4106

4107
    for (i = 0; i < obj->def->ndisks; i++)
4108
        qemuDomainObjCheckDiskTaint(driver, obj, obj->def->disks[i], logCtxt);
4109

4110 4111
    for (i = 0; i < obj->def->nhostdevs; i++)
        qemuDomainObjCheckHostdevTaint(driver, obj, obj->def->hostdevs[i],
4112
                                       logCtxt);
4113

4114
    for (i = 0; i < obj->def->nnets; i++)
4115
        qemuDomainObjCheckNetTaint(driver, obj, obj->def->nets[i], logCtxt);
4116

4117
    if (obj->def->os.dtb)
4118
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_CUSTOM_DTB, logCtxt);
4119

4120
    virObjectUnref(cfg);
4121 4122 4123
}


4124
void qemuDomainObjCheckDiskTaint(virQEMUDriverPtr driver,
4125
                                 virDomainObjPtr obj,
4126
                                 virDomainDiskDefPtr disk,
4127
                                 qemuDomainLogContextPtr logCtxt)
4128
{
4129
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
4130
    int format = virDomainDiskGetFormat(disk);
4131

4132
    if ((!format || format == VIR_STORAGE_FILE_AUTO) &&
4133
        cfg->allowDiskFormatProbing)
4134
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_DISK_PROBING, logCtxt);
4135

4136 4137
    if (disk->rawio == VIR_TRISTATE_BOOL_YES)
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HIGH_PRIVILEGES,
4138
                           logCtxt);
4139

4140 4141 4142 4143
    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,
4144
                           logCtxt);
4145

4146
    virObjectUnref(cfg);
4147 4148 4149
}


4150 4151 4152
void qemuDomainObjCheckHostdevTaint(virQEMUDriverPtr driver,
                                    virDomainObjPtr obj,
                                    virDomainHostdevDefPtr hostdev,
4153
                                    qemuDomainLogContextPtr logCtxt)
4154
{
4155
    if (!virHostdevIsSCSIDevice(hostdev))
4156
        return;
4157

4158 4159
    if (hostdev->source.subsys.u.scsi.rawio == VIR_TRISTATE_BOOL_YES)
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HIGH_PRIVILEGES, logCtxt);
4160 4161 4162
}


4163
void qemuDomainObjCheckNetTaint(virQEMUDriverPtr driver,
4164
                                virDomainObjPtr obj,
4165
                                virDomainNetDefPtr net,
4166
                                qemuDomainLogContextPtr logCtxt)
4167
{
4168 4169 4170 4171 4172 4173
    /* 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)
4174
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_SHELL_SCRIPTS, logCtxt);
4175
}
4176 4177


4178 4179 4180 4181 4182 4183 4184 4185 4186 4187
qemuDomainLogContextPtr qemuDomainLogContextNew(virQEMUDriverPtr driver,
                                                virDomainObjPtr vm,
                                                qemuDomainLogContextMode mode)
{
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    qemuDomainLogContextPtr ctxt = NULL;

    if (VIR_ALLOC(ctxt) < 0)
        goto error;

4188
    VIR_DEBUG("Context new %p stdioLogD=%d", ctxt, cfg->stdioLogD);
4189 4190 4191 4192
    ctxt->writefd = -1;
    ctxt->readfd = -1;
    virAtomicIntSet(&ctxt->refs, 1);

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

4196 4197 4198 4199
    if (cfg->stdioLogD) {
        ctxt->manager = virLogManagerNew(virQEMUDriverIsPrivileged(driver));
        if (!ctxt->manager)
            goto error;
4200

4201 4202 4203 4204
        ctxt->writefd = virLogManagerDomainOpenLogFile(ctxt->manager,
                                                       "qemu",
                                                       vm->def->uuid,
                                                       vm->def->name,
4205
                                                       ctxt->path,
4206 4207 4208 4209 4210 4211
                                                       0,
                                                       &ctxt->inode,
                                                       &ctxt->pos);
        if (ctxt->writefd < 0)
            goto error;
    } else {
4212
        if ((ctxt->writefd = open(ctxt->path, O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR)) < 0) {
4213
            virReportSystemError(errno, _("failed to create logfile %s"),
4214
                                 ctxt->path);
4215 4216
            goto error;
        }
4217
        if (virSetCloseExec(ctxt->writefd) < 0) {
4218
            virReportSystemError(errno, _("failed to set close-on-exec flag on %s"),
4219
                                 ctxt->path);
4220 4221 4222
            goto error;
        }

4223 4224 4225 4226 4227 4228 4229
        /* 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"),
4230
                                 ctxt->path);
4231 4232 4233 4234
            goto error;
        }

        if (mode == QEMU_DOMAIN_LOG_CONTEXT_MODE_START) {
4235
            if ((ctxt->readfd = open(ctxt->path, O_RDONLY, S_IRUSR | S_IWUSR)) < 0) {
4236
                virReportSystemError(errno, _("failed to open logfile %s"),
4237
                                     ctxt->path);
4238 4239 4240 4241
                goto error;
            }
            if (virSetCloseExec(ctxt->readfd) < 0) {
                virReportSystemError(errno, _("failed to set close-on-exec flag on %s"),
4242
                                     ctxt->path);
4243 4244 4245 4246
                goto error;
            }
        }

4247 4248
        if ((ctxt->pos = lseek(ctxt->writefd, 0, SEEK_END)) < 0) {
            virReportSystemError(errno, _("failed to seek in log file %s"),
4249
                                 ctxt->path);
4250 4251 4252 4253
            goto error;
        }
    }

4254
 cleanup:
4255 4256 4257 4258 4259
    virObjectUnref(cfg);
    return ctxt;

 error:
    qemuDomainLogContextFree(ctxt);
4260 4261
    ctxt = NULL;
    goto cleanup;
4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275
}


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;
4276 4277
    if (!ctxt->manager &&
        lseek(ctxt->writefd, 0, SEEK_END) < 0) {
4278
        virReportSystemError(errno, "%s",
4279
                             _("Unable to seek to end of domain logfile"));
4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299
        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)
{
4300 4301 4302 4303
    VIR_DEBUG("Context read %p manager=%p inode=%llu pos=%llu",
              ctxt, ctxt->manager,
              (unsigned long long)ctxt->inode,
              (unsigned long long)ctxt->pos);
4304
    char *buf;
4305 4306 4307
    size_t buflen;
    if (ctxt->manager) {
        buf = virLogManagerDomainReadLogFile(ctxt->manager,
4308
                                             ctxt->path,
4309 4310 4311 4312 4313 4314 4315 4316 4317
                                             ctxt->inode,
                                             ctxt->pos,
                                             1024 * 128,
                                             0);
        if (!buf)
            return -1;
        buflen = strlen(buf);
    } else {
        ssize_t got;
4318

4319
        buflen = 1024 * 128;
4320

4321 4322
        /* Best effort jump to start of messages */
        ignore_value(lseek(ctxt->readfd, ctxt->pos, SEEK_SET));
4323

4324 4325
        if (VIR_ALLOC_N(buf, buflen) < 0)
            return -1;
4326

4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339
        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;
    }
4340 4341 4342

    *msg = buf;

4343
    return buflen;
4344 4345 4346
}


4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408
/**
 * 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;
}


4409 4410 4411 4412 4413 4414 4415 4416
int qemuDomainLogContextGetWriteFD(qemuDomainLogContextPtr ctxt)
{
    return ctxt->writefd;
}


void qemuDomainLogContextMarkPosition(qemuDomainLogContextPtr ctxt)
{
4417 4418
    if (ctxt->manager)
        virLogManagerDomainGetLogFilePosition(ctxt->manager,
4419
                                              ctxt->path,
4420 4421 4422 4423 4424
                                              0,
                                              &ctxt->inode,
                                              &ctxt->pos);
    else
        ctxt->pos = lseek(ctxt->writefd, 0, SEEK_END);
4425 4426 4427 4428 4429
}


void qemuDomainLogContextRef(qemuDomainLogContextPtr ctxt)
{
4430
    VIR_DEBUG("Context ref %p", ctxt);
4431 4432 4433 4434
    virAtomicIntInc(&ctxt->refs);
}


4435 4436 4437 4438 4439 4440
virLogManagerPtr qemuDomainLogContextGetManager(qemuDomainLogContextPtr ctxt)
{
    return ctxt->manager;
}


4441 4442 4443 4444 4445 4446 4447 4448
void qemuDomainLogContextFree(qemuDomainLogContextPtr ctxt)
{
    bool lastRef;

    if (!ctxt)
        return;

    lastRef = virAtomicIntDecAndTest(&ctxt->refs);
4449
    VIR_DEBUG("Context free %p lastref=%d", ctxt, lastRef);
4450 4451 4452
    if (!lastRef)
        return;

4453
    virLogManagerFree(ctxt->manager);
4454
    VIR_FREE(ctxt->path);
4455 4456 4457 4458 4459 4460
    VIR_FORCE_CLOSE(ctxt->writefd);
    VIR_FORCE_CLOSE(ctxt->readfd);
    VIR_FREE(ctxt);
}


4461 4462
/* Locate an appropriate 'qemu-img' binary.  */
const char *
4463
qemuFindQemuImgBinary(virQEMUDriverPtr driver)
4464
{
4465 4466
    if (!driver->qemuImgBinary)
        virReportError(VIR_ERR_INTERNAL_ERROR,
4467
                       "%s", _("unable to find qemu-img"));
4468 4469 4470 4471 4472 4473 4474

    return driver->qemuImgBinary;
}

int
qemuDomainSnapshotWriteMetadata(virDomainObjPtr vm,
                                virDomainSnapshotObjPtr snapshot,
4475
                                virCapsPtr caps,
4476 4477 4478 4479 4480 4481 4482 4483 4484
                                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);
4485
    newxml = virDomainSnapshotDefFormat(
4486
        uuidstr, snapshot->def, caps,
4487 4488
        virDomainDefFormatConvertXMLFlags(QEMU_DOMAIN_FORMAT_LIVE_FLAGS),
        1);
4489
    if (newxml == NULL)
4490 4491
        return -1;

4492
    if (virAsprintf(&snapDir, "%s/%s", snapshotDir, vm->def->name) < 0)
4493 4494 4495 4496 4497 4498 4499
        goto cleanup;
    if (virFileMakePath(snapDir) < 0) {
        virReportSystemError(errno, _("cannot create snapshot directory '%s'"),
                             snapDir);
        goto cleanup;
    }

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

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

4505
 cleanup:
4506 4507 4508 4509 4510 4511 4512 4513
    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.  */
4514
static int
4515
qemuDomainSnapshotForEachQcow2Raw(virQEMUDriverPtr driver,
4516 4517 4518 4519 4520
                                  virDomainDefPtr def,
                                  const char *name,
                                  const char *op,
                                  bool try_all,
                                  int ndisks)
4521 4522
{
    const char *qemuimgarg[] = { NULL, "snapshot", NULL, NULL, NULL, NULL };
4523
    size_t i;
4524 4525 4526 4527 4528 4529 4530 4531 4532
    bool skipped = false;

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

    qemuimgarg[2] = op;
4533
    qemuimgarg[3] = name;
4534

4535
    for (i = 0; i < ndisks; i++) {
4536
        /* FIXME: we also need to handle LVM here */
4537
        if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
4538 4539 4540
            int format = virDomainDiskGetFormat(def->disks[i]);

            if (format > 0 && format != VIR_STORAGE_FILE_QCOW2) {
4541 4542 4543 4544 4545
                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",
4546
                             def->disks[i]->dst);
4547 4548
                    skipped = true;
                    continue;
4549 4550 4551 4552 4553
                } else if (STREQ(op, "-c") && i) {
                    /* We must roll back partial creation by deleting
                     * all earlier snapshots.  */
                    qemuDomainSnapshotForEachQcow2Raw(driver, def, name,
                                                      "-d", false, i);
4554
                }
4555 4556 4557 4558
                virReportError(VIR_ERR_OPERATION_INVALID,
                               _("Disk device '%s' does not support"
                                 " snapshotting"),
                               def->disks[i]->dst);
4559 4560 4561
                return -1;
            }

4562
            qemuimgarg[4] = virDomainDiskGetSource(def->disks[i]);
4563 4564 4565 4566

            if (virRun(qemuimgarg, NULL) < 0) {
                if (try_all) {
                    VIR_WARN("skipping snapshot action on %s",
4567
                             def->disks[i]->dst);
4568 4569
                    skipped = true;
                    continue;
4570 4571 4572 4573 4574
                } else if (STREQ(op, "-c") && i) {
                    /* We must roll back partial creation by deleting
                     * all earlier snapshots.  */
                    qemuDomainSnapshotForEachQcow2Raw(driver, def, name,
                                                      "-d", false, i);
4575 4576 4577 4578 4579 4580 4581 4582 4583
                }
                return -1;
            }
        }
    }

    return skipped ? 1 : 0;
}

4584 4585 4586
/* 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
4587
qemuDomainSnapshotForEachQcow2(virQEMUDriverPtr driver,
4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603
                               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);
}

4604 4605
/* Discard one snapshot (or its metadata), without reparenting any children.  */
int
4606
qemuDomainSnapshotDiscard(virQEMUDriverPtr driver,
4607 4608 4609 4610 4611 4612 4613 4614 4615
                          virDomainObjPtr vm,
                          virDomainSnapshotObjPtr snap,
                          bool update_current,
                          bool metadata_only)
{
    char *snapFile = NULL;
    int ret = -1;
    qemuDomainObjPrivatePtr priv;
    virDomainSnapshotObjPtr parentsnap = NULL;
4616
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
4617 4618 4619 4620 4621 4622 4623 4624 4625

    if (!metadata_only) {
        if (!virDomainObjIsActive(vm)) {
            /* Ignore any skipped disks */
            if (qemuDomainSnapshotForEachQcow2(driver, vm, snap, "-d",
                                               true) < 0)
                goto cleanup;
        } else {
            priv = vm->privateData;
4626
            qemuDomainObjEnterMonitor(driver, vm);
4627 4628
            /* we continue on even in the face of error */
            qemuMonitorDeleteSnapshot(priv->mon, snap->def->name);
4629
            ignore_value(qemuDomainObjExitMonitor(driver, vm));
4630 4631 4632
        }
    }

4633
    if (virAsprintf(&snapFile, "%s/%s/%s.xml", cfg->snapshotDir,
4634
                    vm->def->name, snap->def->name) < 0)
4635 4636 4637 4638
        goto cleanup;

    if (snap == vm->current_snapshot) {
        if (update_current && snap->def->parent) {
4639
            parentsnap = virDomainSnapshotFindByName(vm->snapshots,
4640 4641 4642 4643 4644 4645
                                                     snap->def->parent);
            if (!parentsnap) {
                VIR_WARN("missing parent snapshot matching name '%s'",
                         snap->def->parent);
            } else {
                parentsnap->def->current = true;
4646
                if (qemuDomainSnapshotWriteMetadata(vm, parentsnap, driver->caps,
4647
                                                    cfg->snapshotDir) < 0) {
4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659
                    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);
4660
    virDomainSnapshotObjListRemove(vm->snapshots, snap);
4661 4662 4663

    ret = 0;

4664
 cleanup:
4665
    VIR_FREE(snapFile);
4666
    virObjectUnref(cfg);
4667 4668 4669 4670
    return ret;
}

/* Hash iterator callback to discard multiple snapshots.  */
4671 4672 4673
int qemuDomainSnapshotDiscardAll(void *payload,
                                 const void *name ATTRIBUTE_UNUSED,
                                 void *data)
4674 4675
{
    virDomainSnapshotObjPtr snap = payload;
4676
    virQEMUSnapRemovePtr curr = data;
4677 4678 4679 4680 4681 4682 4683 4684
    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;
4685
    return 0;
4686 4687 4688
}

int
4689
qemuDomainSnapshotDiscardAllMetadata(virQEMUDriverPtr driver,
4690 4691
                                     virDomainObjPtr vm)
{
4692
    virQEMUSnapRemove rem;
4693 4694 4695 4696 4697

    rem.driver = driver;
    rem.vm = vm;
    rem.metadata_only = true;
    rem.err = 0;
4698 4699
    virDomainSnapshotForEach(vm->snapshots, qemuDomainSnapshotDiscardAll,
                             &rem);
4700 4701 4702 4703 4704

    return rem.err;
}

/*
4705
 * The caller must hold a lock the vm.
4706 4707
 */
void
4708
qemuDomainRemoveInactive(virQEMUDriverPtr driver,
4709 4710
                         virDomainObjPtr vm)
{
4711
    bool haveJob = true;
4712
    char *snapDir;
4713 4714 4715 4716 4717 4718 4719 4720
    virQEMUDriverConfigPtr cfg;

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

    cfg = virQEMUDriverGetConfig(driver);
4721

4722 4723 4724
    if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
        haveJob = false;

4725 4726 4727 4728 4729
    /* 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);
    }
4730
    else if (virAsprintf(&snapDir, "%s/%s", cfg->snapshotDir,
4731 4732
                         vm->def->name) < 0) {
        VIR_WARN("unable to remove snapshot directory %s/%s",
4733
                 cfg->snapshotDir, vm->def->name);
4734 4735 4736 4737 4738
    } else {
        if (rmdir(snapDir) < 0 && errno != ENOENT)
            VIR_WARN("unable to remove snapshot directory %s", snapDir);
        VIR_FREE(snapDir);
    }
4739 4740 4741

    virObjectRef(vm);

4742
    virDomainObjListRemove(driver->domains, vm);
4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755
    /*
     * 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);
4756
    virObjectUnref(cfg);
4757 4758

    if (haveJob)
4759
        qemuDomainObjEndJob(driver, vm);
4760 4761

    virObjectUnref(vm);
4762
}
4763 4764

void
4765
qemuDomainSetFakeReboot(virQEMUDriverPtr driver,
4766 4767 4768 4769
                        virDomainObjPtr vm,
                        bool value)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
4770
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
4771 4772

    if (priv->fakeReboot == value)
4773
        goto cleanup;
4774 4775 4776

    priv->fakeReboot = value;

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

4780
 cleanup:
4781
    virObjectUnref(cfg);
4782
}
M
Michal Privoznik 已提交
4783

4784
static void
4785 4786
qemuDomainCheckRemoveOptionalDisk(virQEMUDriverPtr driver,
                                  virDomainObjPtr vm,
4787
                                  size_t diskIndex)
4788 4789
{
    char uuid[VIR_UUID_STRING_BUFLEN];
4790
    virObjectEventPtr event = NULL;
4791
    virDomainDiskDefPtr disk = vm->def->disks[diskIndex];
4792
    const char *src = virDomainDiskGetSource(disk);
4793 4794 4795 4796 4797

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

    VIR_DEBUG("Dropping disk '%s' on domain '%s' (UUID '%s') "
              "due to inaccessible source '%s'",
4798
              disk->dst, vm->def->name, uuid, src);
4799 4800 4801 4802

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

4803
        event = virDomainEventDiskChangeNewFromObj(vm, src, NULL,
4804 4805
                                                   disk->info.alias,
                                                   VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START);
4806
        ignore_value(virDomainDiskSetSource(disk, NULL));
4807 4808
        /* keeping the old startup policy would be invalid for new images */
        disk->startupPolicy = VIR_DOMAIN_STARTUP_POLICY_DEFAULT;
4809
    } else {
4810
        event = virDomainEventDiskChangeNewFromObj(vm, src, NULL,
4811 4812
                                                   disk->info.alias,
                                                   VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START);
4813 4814
        virDomainDiskRemove(vm->def, diskIndex);
        virDomainDiskDefFree(disk);
4815 4816
    }

4817
    qemuDomainEventQueue(driver, event);
4818 4819
}

4820 4821 4822
static int
qemuDomainCheckDiskStartupPolicy(virQEMUDriverPtr driver,
                                 virDomainObjPtr vm,
4823
                                 size_t diskIndex,
4824 4825
                                 bool cold_boot)
{
4826
    int startupPolicy = vm->def->disks[diskIndex]->startupPolicy;
4827
    int device = vm->def->disks[diskIndex]->device;
4828

4829
    switch ((virDomainStartupPolicy) startupPolicy) {
4830
        case VIR_DOMAIN_STARTUP_POLICY_OPTIONAL:
4831 4832 4833 4834 4835 4836
            /* 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)
4837
                return -1;
4838 4839
            break;

4840
        case VIR_DOMAIN_STARTUP_POLICY_DEFAULT:
4841
        case VIR_DOMAIN_STARTUP_POLICY_MANDATORY:
4842
            return -1;
4843 4844

        case VIR_DOMAIN_STARTUP_POLICY_REQUISITE:
4845
            if (cold_boot)
4846
                return -1;
4847 4848 4849 4850 4851 4852 4853
            break;

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

4854
    qemuDomainCheckRemoveOptionalDisk(driver, vm, diskIndex);
4855
    virResetLastError();
4856 4857 4858
    return 0;
}

4859

M
Michal Privoznik 已提交
4860
int
4861 4862
qemuDomainCheckDiskPresence(virConnectPtr conn,
                            virQEMUDriverPtr driver,
M
Michal Privoznik 已提交
4863
                            virDomainObjPtr vm,
4864
                            unsigned int flags)
M
Michal Privoznik 已提交
4865
{
4866
    size_t i;
4867 4868
    bool pretend = flags & VIR_QEMU_PROCESS_START_PRETEND;
    bool cold_boot = flags & VIR_QEMU_PROCESS_START_COLD;
M
Michal Privoznik 已提交
4869

4870
    VIR_DEBUG("Checking for disk presence");
4871
    for (i = vm->def->ndisks; i > 0; i--) {
4872 4873
        size_t idx = i - 1;
        virDomainDiskDefPtr disk = vm->def->disks[idx];
4874
        virStorageFileFormat format = virDomainDiskGetFormat(disk);
M
Michal Privoznik 已提交
4875

4876 4877 4878 4879 4880 4881 4882 4883 4884 4885
        if (virStorageTranslateDiskSourcePool(conn, vm->def->disks[idx]) < 0) {
            if (pretend ||
                qemuDomainCheckDiskStartupPolicy(driver, vm, idx, cold_boot) < 0)
                return -1;
            continue;
        }

        if (pretend)
            continue;

4886
        if (virStorageSourceIsEmpty(disk->src))
4887 4888 4889 4890 4891
            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 */
4892
        if (virStorageSourceIsLocalStorage(disk->src) &&
4893
            format > VIR_STORAGE_FILE_NONE &&
4894
            format < VIR_STORAGE_FILE_BACKING &&
4895
            virFileExists(virDomainDiskGetSource(disk)))
M
Michal Privoznik 已提交
4896 4897
            continue;

4898
        if (qemuDomainDetermineDiskChain(driver, vm, disk, true, true) >= 0)
M
Michal Privoznik 已提交
4899
            continue;
4900

4901
        if (qemuDomainCheckDiskStartupPolicy(driver, vm, idx, cold_boot) >= 0)
4902
            continue;
M
Michal Privoznik 已提交
4903

4904
        return -1;
M
Michal Privoznik 已提交
4905 4906
    }

4907
    return 0;
M
Michal Privoznik 已提交
4908
}
4909 4910 4911 4912 4913 4914 4915 4916 4917 4918

/*
 * The vm must be locked when any of the following cleanup functions is
 * called.
 */
int
qemuDomainCleanupAdd(virDomainObjPtr vm,
                     qemuDomainCleanupCallback cb)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
4919
    size_t i;
4920 4921 4922 4923 4924 4925 4926 4927 4928 4929

    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,
4930
                     priv->ncleanupCallbacks, 1) < 0)
4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941
        return -1;

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

void
qemuDomainCleanupRemove(virDomainObjPtr vm,
                        qemuDomainCleanupCallback cb)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
4942
    size_t i;
4943 4944 4945 4946

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

    for (i = 0; i < priv->ncleanupCallbacks; i++) {
4947 4948 4949
        if (priv->cleanupCallbacks[i] == cb)
            VIR_DELETE_ELEMENT_INPLACE(priv->cleanupCallbacks,
                                       i, priv->ncleanupCallbacks);
4950 4951 4952 4953 4954 4955 4956 4957
    }

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

void
4958
qemuDomainCleanupRun(virQEMUDriverPtr driver,
4959 4960 4961
                     virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
4962
    size_t i;
4963 4964 4965 4966

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

    /* run cleanup callbacks in reverse order */
4967 4968
    for (i = 0; i < priv->ncleanupCallbacks; i++) {
        if (priv->cleanupCallbacks[priv->ncleanupCallbacks - (i + 1)])
4969 4970 4971 4972 4973 4974 4975
            priv->cleanupCallbacks[i](driver, vm);
    }

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

4977 4978 4979
static void
qemuDomainGetImageIds(virQEMUDriverConfigPtr cfg,
                      virDomainObjPtr vm,
4980
                      virStorageSourcePtr src,
4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998
                      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;
    }

4999 5000
    if (vm && (vmlabel = virDomainDefGetSecurityLabelDef(vm->def, "dac")) &&
        vmlabel->label)
5001 5002
        virParseOwnershipIds(vmlabel->label, uid, gid);

5003
    if ((disklabel = virStorageSourceGetSecurityLabelDef(src, "dac")) &&
5004
        disklabel->label)
5005 5006 5007 5008
        virParseOwnershipIds(disklabel->label, uid, gid);
}


5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031
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;
}


5032 5033 5034 5035 5036
char *
qemuDomainStorageAlias(const char *device, int depth)
{
    char *alias;

5037
    device = qemuAliasDiskDriveSkipPrefix(device);
5038 5039 5040 5041 5042 5043 5044 5045 5046

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


5047
int
5048
qemuDomainDetermineDiskChain(virQEMUDriverPtr driver,
5049
                             virDomainObjPtr vm,
5050
                             virDomainDiskDefPtr disk,
5051 5052
                             bool force_probe,
                             bool report_broken)
5053
{
5054 5055
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    int ret = 0;
5056 5057
    uid_t uid;
    gid_t gid;
5058

5059
    if (virStorageSourceIsEmpty(disk->src))
5060
        goto cleanup;
5061

5062
    if (disk->src->backingStore) {
5063
        if (force_probe)
5064
            virStorageSourceBackingStoreClear(disk->src);
5065
        else
5066
            goto cleanup;
5067
    }
5068

5069
    qemuDomainGetImageIds(cfg, vm, disk->src, &uid, &gid);
5070

5071
    if (virStorageFileGetMetadata(disk->src,
5072
                                  uid, gid,
5073
                                  cfg->allowDiskFormatProbing,
5074
                                  report_broken) < 0)
5075 5076
        ret = -1;

5077
 cleanup:
5078 5079
    virObjectUnref(cfg);
    return ret;
5080
}
5081

5082

5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145
/**
 * 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)
{
    if (virSecurityManagerRestoreImageLabel(driver->securityManager,
                                            vm->def, elem) < 0)
        VIR_WARN("Unable to restore security label on %s", NULLSTR(elem->path));

    if (qemuTeardownImageCgroup(vm, elem) < 0)
        VIR_WARN("Failed to teardown cgroup for disk path %s",
                 NULLSTR(elem->path));

    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;

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

    if (virSecurityManagerSetImageLabel(driver->securityManager, vm->def,
                                        elem) < 0)
        goto cleanup;

    ret = 0;

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


5146
bool
5147
qemuDomainDiskSourceDiffers(virDomainDiskDefPtr disk,
5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162
                            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;

5163 5164 5165 5166
    /* 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)
5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179
        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;
}


5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202
/*
 * 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);
5203 5204 5205 5206
    CHECK_EQ(bus, "bus", false);
    if (STRNEQ(disk->dst, orig_disk->dst)) {
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("cannot modify field '%s' of the disk"),
5207
                       "target");
5208 5209 5210 5211
        return false;
    }
    CHECK_EQ(tray_status, "tray", true);
    CHECK_EQ(removable, "removable", true);
5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294

    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;
    }

5295 5296 5297 5298 5299 5300 5301
    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);
5302
    /* "snapshot" is a libvirt internal field and thus can be changed */
5303
    /* startupPolicy is allowed to be updated. Therefore not checked here. */
5304
    CHECK_EQ(transient, "transient", true);
5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317

    /* 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;
    }

5318
    CHECK_EQ(info.bootIndex, "boot order", true);
5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330
    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;
    }
5331

5332 5333 5334 5335 5336 5337
    /* 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);

5338 5339 5340 5341 5342
#undef CHECK_EQ

    return true;
}

5343 5344 5345
bool
qemuDomainDiskBlockJobIsActive(virDomainDiskDefPtr disk)
{
5346 5347
    qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);

5348 5349 5350 5351 5352 5353 5354 5355
    if (disk->mirror) {
        virReportError(VIR_ERR_BLOCK_COPY_ACTIVE,
                       _("disk '%s' already in active block job"),
                       disk->dst);

        return true;
    }

5356
    if (diskPriv->blockjob) {
5357 5358 5359 5360 5361 5362 5363 5364 5365 5366
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("disk '%s' already in active block job"),
                       disk->dst);
        return true;
    }

    return false;
}


5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381
/**
 * 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++) {
5382 5383 5384 5385
        virDomainDiskDefPtr disk = vm->def->disks[i];
        qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);

        if (!copy_only && diskPriv->blockjob)
5386 5387
            return true;

5388
        if (disk->mirror && disk->mirrorJob == VIR_DOMAIN_BLOCK_JOB_TYPE_COPY)
5389 5390 5391 5392 5393 5394 5395
            return true;
    }

    return false;
}


5396 5397
int
qemuDomainUpdateDeviceList(virQEMUDriverPtr driver,
5398 5399
                           virDomainObjPtr vm,
                           int asyncJob)
5400 5401 5402
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    char **aliases;
5403
    int rc;
5404 5405 5406 5407

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

5408 5409
    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
        return -1;
5410 5411 5412 5413
    rc = qemuMonitorGetDeviceAliases(priv->mon, &aliases);
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        return -1;
    if (rc < 0)
5414 5415
        return -1;

5416
    virStringListFree(priv->qemuDevices);
5417 5418 5419
    priv->qemuDevices = aliases;
    return 0;
}
5420

5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469

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);

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

    /* 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;
}


5470 5471 5472 5473 5474 5475 5476
bool
qemuDomainDefCheckABIStability(virQEMUDriverPtr driver,
                               virDomainDefPtr src,
                               virDomainDefPtr dst)
{
    virDomainDefPtr migratableDefSrc = NULL;
    virDomainDefPtr migratableDefDst = NULL;
5477 5478 5479 5480
    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;
5481 5482 5483 5484 5485 5486
    bool ret = false;

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

5487 5488 5489 5490 5491 5492 5493 5494 5495
    if (!virDomainDefCheckABIStabilityFlags(migratableDefSrc,
                                            migratableDefDst,
                                            check_flags))
        goto cleanup;

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

    ret = true;
5496

5497
 cleanup:
5498 5499 5500 5501
    virDomainDefFree(migratableDefSrc);
    virDomainDefFree(migratableDefDst);
    return ret;
}
5502 5503

bool
5504
qemuDomainAgentAvailable(virDomainObjPtr vm,
5505 5506
                         bool reportError)
{
5507 5508
    qemuDomainObjPrivatePtr priv = vm->privateData;

5509 5510 5511 5512 5513 5514 5515
    if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING) {
        if (reportError) {
            virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                           _("domain is not running"));
        }
        return false;
    }
5516 5517 5518 5519 5520 5521 5522 5523 5524
    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) {
5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536
        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;
5537 5538 5539 5540
        }
    }
    return true;
}
5541

5542

5543
static unsigned long long
5544
qemuDomainGetMemorySizeAlignment(virDomainDefPtr def)
5545
{
5546 5547 5548 5549 5550
    /* 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;

5551 5552 5553 5554 5555 5556 5557
    /* Align memory size. QEMU requires rounding to next 4KiB block.
     * We'll take the "traditional" path and round it to 1MiB*/

    return 1024;
}


5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572
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;
}


5573 5574 5575
int
qemuDomainAlignMemorySizes(virDomainDefPtr def)
{
5576 5577
    unsigned long long maxmemkb = virMemoryMaxValue(false) >> 10;
    unsigned long long maxmemcapped = virMemoryMaxValue(true) >> 10;
5578
    unsigned long long initialmem = 0;
5579
    unsigned long long hotplugmem = 0;
5580
    unsigned long long mem;
5581
    unsigned long long align = qemuDomainGetMemorySizeAlignment(def);
5582 5583 5584 5585 5586
    size_t ncells = virDomainNumaGetNodeCount(def->numa);
    size_t i;

    /* align NUMA cell sizes if relevant */
    for (i = 0; i < ncells; i++) {
5587 5588
        mem = VIR_ROUND_UP(virDomainNumaGetNodeMemorySize(def->numa, i), align);
        initialmem += mem;
5589 5590 5591 5592 5593 5594 5595

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

5599 5600 5601 5602 5603
    /* 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);

5604 5605 5606 5607 5608 5609
    if (initialmem > maxmemcapped) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("initial memory size overflowed after alignment"));
        return -1;
    }

5610
    def->mem.max_memory = VIR_ROUND_UP(def->mem.max_memory, align);
5611 5612 5613 5614 5615
    if (def->mem.max_memory > maxmemkb) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("maximum memory size overflowed after alignment"));
        return -1;
    }
5616

5617
    /* Align memory module sizes */
5618 5619
    for (i = 0; i < def->nmems; i++) {
        align = qemuDomainGetMemoryModuleSizeAlignment(def, def->mems[i]);
5620
        def->mems[i]->size = VIR_ROUND_UP(def->mems[i]->size, align);
5621
        hotplugmem += def->mems[i]->size;
5622 5623 5624 5625 5626 5627 5628

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

5631 5632
    virDomainDefSetMemoryTotal(def, initialmem + hotplugmem);

5633 5634
    return 0;
}
5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645


/**
 * 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
5646 5647
qemuDomainMemoryDeviceAlignSize(virDomainDefPtr def,
                                virDomainMemoryDefPtr mem)
5648
{
5649
    mem->size = VIR_ROUND_UP(mem->size, qemuDomainGetMemorySizeAlignment(def));
5650
}
5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663


/**
 * qemuDomainGetMonitor:
 * @vm: domain object
 *
 * Returns the monitor pointer corresponding to the domain object @vm.
 */
qemuMonitorPtr
qemuDomainGetMonitor(virDomainObjPtr vm)
{
    return ((qemuDomainObjPrivatePtr) vm->privateData)->mon;
}
5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679


/**
 * 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;
5680 5681
    bool asynchronous = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_ASYNC);
    bool synchronous = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_SYNC);
5682

5683
    if (!synchronous && !asynchronous) {
5684 5685 5686 5687 5688 5689
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("block jobs not supported with this QEMU binary"));
        return -1;
    }

    if (modern)
5690
        *modern = asynchronous;
5691 5692 5693

    return 0;
}
5694 5695 5696 5697 5698 5699 5700 5701 5702


/**
 * 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.
 */
5703
virDomainChrDefPtr
5704 5705 5706 5707 5708 5709 5710 5711 5712 5713
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;

5714 5715
        if (STREQ_NULLABLE(channel->target.name, "org.qemu.guest_agent.0"))
            return channel;
5716 5717
    }

5718
    return NULL;
5719
}
5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738


bool
qemuDomainMachineIsQ35(const virDomainDef *def)
{
    return (STRPREFIX(def->os.machine, "pc-q35") ||
            STREQ(def->os.machine, "q35"));
}


bool
qemuDomainMachineIsI440FX(const virDomainDef *def)
{
    return (STREQ(def->os.machine, "pc") ||
            STRPREFIX(def->os.machine, "pc-0.") ||
            STRPREFIX(def->os.machine, "pc-1.") ||
            STRPREFIX(def->os.machine, "pc-i440") ||
            STRPREFIX(def->os.machine, "rhel"));
}
5739 5740


5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770
bool
qemuDomainMachineHasPCIRoot(const virDomainDef *def)
{
    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
qemuDomainMachineHasPCIeRoot(const virDomainDef *def)
{
    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;
}


5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788
bool
qemuDomainMachineNeedsFDC(const virDomainDef *def)
{
    char *p = STRSKIP(def->os.machine, "pc-q35-");

    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;
}


5789 5790 5791 5792 5793 5794
bool
qemuDomainMachineIsS390CCW(const virDomainDef *def)
{
    return STRPREFIX(def->os.machine, "s390-ccw");
}

5795

J
Ján Tomko 已提交
5796 5797 5798
bool
qemuDomainMachineIsVirt(const virDomainDef *def)
{
5799 5800 5801 5802 5803 5804 5805 5806 5807
    if (def->os.arch != VIR_ARCH_ARMV7L &&
        def->os.arch != VIR_ARCH_AARCH64)
        return false;

    if (STRNEQ(def->os.machine, "virt") &&
        !STRPREFIX(def->os.machine, "virt-"))
        return false;

    return true;
J
Ján Tomko 已提交
5808 5809 5810
}


5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824
bool
qemuDomainMachineIsPSeries(const virDomainDef *def)
{
    if (!ARCH_IS_PPC64(def->os.arch))
        return false;

    if (STRNEQ(def->os.machine, "pseries") &&
        !STRPREFIX(def->os.machine, "pseries-"))
        return false;

    return true;
}


5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871
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:
        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;
        }

5872 5873 5874
        if (virDomainNumaGetNodeCount(def->numa) != 0) {
            if (mem->targetNode == -1) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
Y
Yuri Chornoivan 已提交
5875
                               _("target NUMA node needs to be specified for "
5876 5877 5878
                                 "memory device"));
                return -1;
            }
5879 5880
        }

5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904
        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;
}


5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932
/**
 * 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;
    size_t i;

    hotplugSpace = def->mem.max_memory - virDomainDefGetMemoryInitial(def);

    if (mem) {
        nmems++;
        hotplugMemory = mem->size;
5933 5934 5935

        if (qemuDomainDefValidateMemoryHotplugDevice(mem, def) < 0)
            return -1;
5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949 5950 5951 5952 5953 5954
    }

    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;
    }

    if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_PC_DIMM)) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("memory hotplug isn't supported by this QEMU binary"));
        return -1;
    }

5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965
    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;
        }
5966 5967 5968 5969 5970 5971 5972 5973 5974
    }

    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;
    }

5975
    for (i = 0; i < def->nmems; i++) {
5976 5977
        hotplugMemory += def->mems[i]->size;

5978 5979 5980 5981 5982 5983
        /* already existing devices don't need to be checked on hotplug */
        if (!mem &&
            qemuDomainDefValidateMemoryHotplugDevice(def->mems[i], def) < 0)
            return -1;
    }

5984 5985 5986 5987 5988 5989 5990 5991 5992 5993
    if (hotplugMemory > hotplugSpace) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("memory device total size exceeds hotplug space"));
        return -1;
    }

    return 0;
}


5994 5995 5996 5997 5998 5999 6000 6001 6002 6003
bool
qemuDomainMachineHasBuiltinIDE(const virDomainDef *def)
{
    return qemuDomainMachineIsI440FX(def) ||
        STREQ(def->os.machine, "malta") ||
        STREQ(def->os.machine, "sun4u") ||
        STREQ(def->os.machine, "g3beige");
}


6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027
/**
 * 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 */
6028
    if (!virDomainDefHasMemballoon(vm->def)) {
6029
        vm->def->mem.cur_balloon = virDomainDefGetMemoryTotal(vm->def);
6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061
        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;

6062 6063
        vm->def->mem.cur_balloon = balloon;
    }
6064 6065 6066

    return 0;
}
6067 6068 6069


/**
6070
 * qemuDomainGetMemLockLimitBytes:
6071 6072 6073 6074
 *
 * @def: domain definition
 *
 * Returns the size of the memory in bytes that needs to be set as
6075
 * RLIMIT_MEMLOCK for the QEMU process.
6076 6077 6078 6079
 * If a mem.hard_limit is set, then that value is preferred; otherwise, the
 * value returned may depend upon the architecture or devices present.
 */
unsigned long long
6080
qemuDomainGetMemLockLimitBytes(virDomainDefPtr def)
6081 6082 6083
{
    unsigned long long memKB;

6084 6085 6086 6087 6088 6089
    /* prefer the hard limit */
    if (virMemoryLimitIsSet(def->mem.hard_limit)) {
        memKB = def->mem.hard_limit;
        goto done;
    }

6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113
    if (ARCH_IS_PPC64(def->os.arch)) {
        unsigned long long maxMemory;
        unsigned long long memory;
        unsigned long long baseLimit;
        unsigned long long passthroughLimit;
        size_t nPCIHostBridges;
        size_t i;
        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;
            }
        }

6114
        memory = virDomainDefGetMemoryTotal(def);
6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167

        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;
    }

6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185
    /* 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.
     */
6186
    memKB = virDomainDefGetMemoryTotal(def) + 1024 * 1024;
6187

6188
 done:
6189 6190
    return memKB << 10;
}
6191 6192 6193 6194 6195


/**
 * @def: domain definition
 *
6196 6197 6198
 * Returns true if the locked memory limit needs to be set or updated because
 * of domain configuration, VFIO passthrough devices or architecture-specific
 * requirements.
6199 6200
 * */
bool
6201
qemuDomainRequiresMemLock(virDomainDefPtr def)
6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216
{
    size_t i;

    if (def->mem.locked)
        return true;

    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)
            return true;
    }

6217 6218 6219 6220
    /* ppc64 KVM domains need to lock some memory even when VFIO is not used */
    if (ARCH_IS_PPC64(def->os.arch) && def->virtType == VIR_DOMAIN_VIRT_KVM)
        return true;

6221 6222
    return false;
}
6223

6224 6225 6226 6227 6228 6229 6230
/**
 * qemuDomainAdjustMaxMemLock:
 * @vm: domain
 *
 * Adjust the memory locking limit for the QEMU process associated to @vm, in
 * order to comply with VFIO or architecture requirements.
 *
6231 6232 6233 6234
 * 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.
6235 6236 6237 6238 6239 6240 6241 6242 6243
 *
 * Returns: 0 on success, <0 on failure
 */
int
qemuDomainAdjustMaxMemLock(virDomainObjPtr vm)
{
    unsigned long long bytes = 0;
    int ret = -1;

6244
    if (qemuDomainRequiresMemLock(vm->def)) {
6245 6246 6247 6248 6249 6250 6251 6252
        /* 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;
        }
6253
        bytes = qemuDomainGetMemLockLimitBytes(vm->def);
6254 6255 6256 6257 6258 6259
    } 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;
    }
6260 6261 6262 6263 6264 6265 6266 6267 6268 6269

    /* 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;
}
6270 6271 6272 6273 6274 6275 6276 6277 6278 6279

/**
 * qemuDomainHasVcpuPids:
 * @vm: Domain object
 *
 * Returns true if we were able to successfully detect vCPU pids for the VM.
 */
bool
qemuDomainHasVcpuPids(virDomainObjPtr vm)
{
6280 6281 6282 6283 6284 6285
    size_t i;
    size_t maxvcpus = virDomainDefGetVcpusMax(vm->def);
    virDomainVcpuDefPtr vcpu;

    for (i = 0; i < maxvcpus; i++) {
        vcpu = virDomainDefGetVcpu(vm->def, i);
6286

6287 6288 6289 6290 6291
        if (QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->tid > 0)
            return true;
    }

    return false;
6292
}
6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303


/**
 * 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,
6304
                     unsigned int vcpuid)
6305
{
6306 6307
    virDomainVcpuDefPtr vcpu = virDomainDefGetVcpu(vm->def, vcpuid);
    return QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->tid;
6308
}
6309 6310


6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352
/**
 * 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;
}


6353 6354 6355 6356 6357 6358 6359 6360 6361
bool
qemuDomainSupportsNewVcpuHotplug(virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;

    return virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS);
}


6362
/**
6363
 * qemuDomainRefreshVcpuInfo:
6364 6365 6366
 * @driver: qemu driver data
 * @vm: domain object
 * @asyncJob: current asynchronous job type
6367
 * @state: refresh vcpu state
6368
 *
6369 6370
 * Updates vCPU information private data of @vm. Due to historical reasons this
 * function returns success even if some data were not reported by qemu.
6371
 *
6372 6373
 * If @state is true, the vcpu state is refreshed as reported by the monitor.
 *
6374
 * Returns 0 on success and -1 on fatal error.
6375 6376
 */
int
6377 6378
qemuDomainRefreshVcpuInfo(virQEMUDriverPtr driver,
                          virDomainObjPtr vm,
6379 6380
                          int asyncJob,
                          bool state)
6381
{
6382
    virDomainVcpuDefPtr vcpu;
6383 6384
    qemuDomainVcpuPrivatePtr vcpupriv;
    qemuMonitorCPUInfoPtr info = NULL;
6385 6386
    size_t maxvcpus = virDomainDefGetVcpusMax(vm->def);
    size_t i;
6387
    bool hotplug;
6388
    int rc;
6389
    int ret = -1;
6390

6391
    hotplug = qemuDomainSupportsNewVcpuHotplug(vm);
6392 6393 6394

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

6396
    rc = qemuMonitorGetCPUInfo(qemuDomainGetMonitor(vm), &info, maxvcpus, hotplug);
6397

6398
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
6399 6400
        goto cleanup;

6401
    if (rc < 0)
6402 6403 6404 6405
        goto cleanup;

    for (i = 0; i < maxvcpus; i++) {
        vcpu = virDomainDefGetVcpu(vm->def, i);
6406
        vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpu);
6407

6408 6409 6410 6411 6412 6413 6414 6415 6416 6417 6418 6419 6420 6421 6422 6423 6424 6425 6426 6427 6428 6429 6430 6431 6432 6433 6434 6435 6436 6437 6438 6439 6440 6441 6442 6443 6444 6445 6446 6447
        /*
         * 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;
6448
        vcpupriv->qemu_id = info[i].qemu_id;
6449

6450
        if (hotplug && state) {
6451 6452 6453 6454 6455
            vcpu->online = info[i].online;
            if (info[i].hotpluggable)
                vcpu->hotpluggable = VIR_TRISTATE_BOOL_YES;
            else
                vcpu->hotpluggable = VIR_TRISTATE_BOOL_NO;
6456
        }
6457 6458
    }

6459
    ret = 0;
6460 6461

 cleanup:
6462
    qemuMonitorCPUInfoFree(info, maxvcpus);
6463
    return ret;
6464
}
6465

6466 6467 6468 6469 6470 6471 6472 6473 6474 6475 6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488 6489 6490 6491 6492 6493 6494 6495 6496
/**
 * 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;
6497
    qemuDomainVcpuPrivatePtr vcpupriv;
6498
    size_t maxvcpus = virDomainDefGetVcpusMax(vm->def);
6499
    virBitmapPtr haltedmap = NULL;
6500 6501 6502 6503 6504 6505 6506 6507 6508 6509
    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;

6510
    haltedmap = qemuMonitorGetCpuHalted(qemuDomainGetMonitor(vm), maxvcpus);
6511

6512
    if (qemuDomainObjExitMonitor(driver, vm) < 0 || !haltedmap)
6513 6514 6515 6516
        goto cleanup;

    for (i = 0; i < maxvcpus; i++) {
        vcpu = virDomainDefGetVcpu(vm->def, i);
6517 6518
        vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpu);
        vcpupriv->halted = virBitmapIsBitSet(haltedmap, vcpupriv->qemu_id);
6519 6520 6521 6522 6523
    }

    ret = 0;

 cleanup:
6524
    virBitmapFree(haltedmap);
6525 6526
    return ret;
}
6527 6528 6529 6530 6531 6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546

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)
{
6547
    if (!qemuDomainSupportsNicdev(def, net))
6548 6549 6550
        return false;
    return virQEMUCapsGet(qemuCaps, QEMU_CAPS_NETDEV);
}
J
John Ferlan 已提交
6551 6552 6553 6554 6555 6556 6557


int
qemuDomainNetVLAN(virDomainNetDefPtr def)
{
    return qemuDomainDeviceAliasIndex(&def->info, "net");
}
P
Peter Krempa 已提交
6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568 6569 6570 6571 6572 6573


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;
}
6574 6575 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


/**
 * 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;
}
6605 6606 6607 6608 6609 6610 6611


int
qemuDomainPrepareChannel(virDomainChrDefPtr channel,
                         const char *domainChannelTargetDir)
{
    if (channel->targetType == VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO &&
6612 6613 6614
        channel->source->type == VIR_DOMAIN_CHR_TYPE_UNIX &&
        !channel->source->data.nix.path) {
        if (virAsprintf(&channel->source->data.nix.path,
6615 6616 6617 6618 6619
                        "%s/%s", domainChannelTargetDir,
                        channel->target.name ? channel->target.name
                        : "unknown.sock") < 0)
            return -1;

6620
        channel->source->data.nix.listen = true;
6621 6622 6623 6624
    }

    return 0;
}
6625 6626


6627 6628 6629 6630 6631 6632 6633 6634 6635 6636 6637 6638 6639 6640 6641 6642 6643 6644
/* 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;
6645
            source->data.tcp.tlsFromConfig = true;
6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 6657 6658 6659 6660 6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687 6688 6689 6690 6691 6692 6693
        }
    }
}


/* 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);
}



6694 6695 6696 6697 6698 6699 6700 6701 6702 6703 6704 6705 6706
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);
}


6707 6708 6709 6710 6711 6712 6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734 6735 6736 6737 6738 6739
/**
 * 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);
}
6740 6741 6742 6743 6744 6745 6746 6747 6748 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


/**
 * 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;
        }
    }
}
6774 6775 6776 6777 6778 6779 6780 6781 6782 6783 6784 6785 6786 6787 6788 6789 6790 6791 6792 6793


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;
}
6794 6795 6796 6797 6798 6799 6800 6801 6802 6803 6804 6805


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;
}
6806 6807


6808 6809 6810 6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 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 6889 6890 6891 6892 6893 6894 6895 6896 6897 6898 6899 6900 6901 6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919
static int
qemuDomainGetHostdevPath(virDomainHostdevDefPtr dev,
                         char **path)
{
    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;
    virPCIDevicePtr pci = NULL;
    virUSBDevicePtr usb = NULL;
    virSCSIDevicePtr scsi = NULL;
    virSCSIVHostDevicePtr host = NULL;
    char *tmpPath = NULL;
    bool freeTmpPath = false;

    *path = NULL;

    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;
            }
            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;
            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;
            }
            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;
            }
            break;
        }

        case VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_LAST:
            break;
        }
        break;

    case VIR_DOMAIN_HOSTDEV_MODE_CAPABILITIES:
    case VIR_DOMAIN_HOSTDEV_MODE_LAST:
        /* nada */
        break;
    }

    if (VIR_STRDUP(*path, tmpPath) < 0)
        goto cleanup;

    ret = 0;
 cleanup:
    virPCIDeviceFree(pci);
    virUSBDeviceFree(usb);
    virSCSIDeviceFree(scsi);
    virSCSIVHostDeviceFree(host);
    if (freeTmpPath)
        VIR_FREE(tmpPath);
    return ret;
}


6920 6921
#define DEVPREFIX "/dev/"

6922
#if defined(__linux__)
6923 6924 6925 6926 6927 6928 6929 6930 6931
static int
qemuDomainCreateDevice(const char *device,
                       const char *path,
                       bool allow_noent)
{
    char *devicePath = NULL;
    struct stat sb;
    int ret = -1;

6932
    if (!STRPREFIX(device, DEVPREFIX)) {
6933 6934 6935 6936 6937 6938 6939
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("invalid device: %s"),
                       device);
        goto cleanup;
    }

    if (virAsprintf(&devicePath, "%s/%s",
6940
                    path, device + strlen(DEVPREFIX)) < 0)
6941 6942 6943 6944 6945 6946 6947 6948 6949 6950 6951 6952 6953 6954 6955 6956 6957 6958 6959 6960 6961
        goto cleanup;

    if (stat(device, &sb) < 0) {
        if (errno == ENOENT && allow_noent) {
            /* Ignore non-existent device. */
            ret = 0;
            goto cleanup;
        }

        virReportSystemError(errno, _("Unable to stat %s"), device);
        goto cleanup;
    }

    if (virFileMakeParentPath(devicePath) < 0) {
        virReportSystemError(errno,
                             _("Unable to create %s"),
                             devicePath);
        goto cleanup;
    }

    if (mknod(devicePath, sb.st_mode, sb.st_rdev) < 0) {
6962 6963 6964 6965 6966 6967 6968
        if (errno == EEXIST) {
            ret = 0;
        } else {
            virReportSystemError(errno,
                                 _("Failed to make device %s"),
                                 devicePath);
        }
6969 6970 6971 6972 6973 6974 6975 6976 6977 6978 6979 6980 6981 6982 6983 6984 6985 6986 6987 6988 6989 6990 6991 6992 6993 6994 6995 6996 6997 6998 6999 7000 7001 7002 7003 7004 7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 7015 7016 7017 7018 7019 7020 7021 7022 7023 7024 7025 7026 7027 7028 7029 7030 7031 7032 7033 7034 7035 7036 7037 7038 7039 7040 7041 7042 7043 7044 7045 7046 7047 7048 7049 7050 7051 7052 7053 7054 7055 7056 7057 7058 7059
        goto cleanup;
    }

    if (chown(devicePath, sb.st_uid, sb.st_gid) < 0) {
        virReportSystemError(errno,
                             _("Failed to chown device %s"),
                             devicePath);
        goto cleanup;
    }

    if (virFileCopyACLs(device, devicePath) < 0 &&
        errno != ENOTSUP) {
        virReportSystemError(errno,
                             _("Failed to copy ACLs on device %s"),
                             devicePath);
        goto cleanup;
    }

    ret = 0;
 cleanup:
    VIR_FREE(devicePath);
    return ret;
}



static int
qemuDomainPopulateDevices(virQEMUDriverPtr driver,
                          virDomainObjPtr vm ATTRIBUTE_UNUSED,
                          const char *path)
{
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    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++) {
        if (qemuDomainCreateDevice(devices[i], path, true) < 0)
            goto cleanup;
    }

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


static int
qemuDomainSetupDev(virQEMUDriverPtr driver,
                   virDomainObjPtr vm,
                   const char *path)
{
    char *mount_options = NULL;
    char *opts = NULL;
    int ret = -1;

    VIR_DEBUG("Setting up /dev/ for domain %s", vm->def->name);

    mount_options = virSecurityManagerGetMountOptions(driver->securityManager,
                                                      vm->def);

    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;

    if (virFileSetupDev(path, opts) < 0)
        goto cleanup;

    if (qemuDomainPopulateDevices(driver, vm, path) < 0)
        goto cleanup;

    ret = 0;
 cleanup:
    VIR_FREE(opts);
    VIR_FREE(mount_options);
    return ret;
}


7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 7070
static int
qemuDomainSetupDisk(virQEMUDriverPtr driver ATTRIBUTE_UNUSED,
                    virDomainDiskDefPtr disk,
                    const char *devPath)
{
    virStorageSourcePtr next;
    char *dst = NULL;
    int ret = -1;

    for (next = disk->src; next; next = next->backingStore) {
        if (!next->path || !virStorageSourceIsLocalStorage(next) ||
7071
            !STRPREFIX(next->path, DEVPREFIX)) {
7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087 7088 7089 7090 7091 7092 7093 7094 7095 7096 7097 7098 7099 7100 7101 7102 7103 7104 7105 7106
            /* Not creating device. Just continue. */
            continue;
        }

        if (qemuDomainCreateDevice(next->path, devPath, false) < 0)
            goto cleanup;
    }

    ret = 0;
 cleanup:
    VIR_FREE(dst);
    return ret;
}


static int
qemuDomainSetupAllDisks(virQEMUDriverPtr driver,
                        virDomainObjPtr vm,
                        const char *devPath)
{
    size_t i;
    VIR_DEBUG("Setting up disks");

    for (i = 0; i < vm->def->ndisks; i++) {
        if (qemuDomainSetupDisk(driver,
                                vm->def->disks[i],
                                devPath) < 0)
            return -1;
    }

    VIR_DEBUG("Setup all disks");
    return 0;
}


7107 7108 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
static int
qemuDomainSetupHostdev(virQEMUDriverPtr driver ATTRIBUTE_UNUSED,
                       virDomainHostdevDefPtr dev,
                       const char *devPath)
{
    int ret = -1;
    char *path = NULL;

    if (qemuDomainGetHostdevPath(dev, &path) < 0)
        goto cleanup;

    if (!path) {
        /* There's no /dev device that we need to create. Claim success. */
        ret = 0;
        goto cleanup;
    }

    if (qemuDomainCreateDevice(path, devPath, false) < 0)
        goto cleanup;

    ret = 0;
 cleanup:
    VIR_FREE(path);
    return ret;
}


static int
qemuDomainSetupAllHostdevs(virQEMUDriverPtr driver,
                           virDomainObjPtr vm,
                           const char *devPath)
{
    size_t i;

    VIR_DEBUG("Setting up hostdevs");
    for (i = 0; i < vm->def->nhostdevs; i++) {
        if (qemuDomainSetupHostdev(driver,
                                   vm->def->hostdevs[i],
                                   devPath) < 0)
            return -1;
    }
    VIR_DEBUG("Setup all hostdevs");
    return 0;
}


7153 7154 7155 7156 7157 7158 7159 7160 7161 7162 7163 7164 7165 7166 7167 7168 7169 7170 7171 7172 7173 7174 7175 7176 7177 7178 7179 7180 7181 7182 7183 7184
static int
qemuDomainSetupChardev(virDomainDefPtr def ATTRIBUTE_UNUSED,
                       virDomainChrDefPtr dev,
                       void *opaque)
{
    const char *devPath = opaque;

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

    return qemuDomainCreateDevice(dev->source->data.file.path, devPath, false);
}


static int
qemuDomainSetupAllChardevs(virQEMUDriverPtr driver ATTRIBUTE_UNUSED,
                           virDomainObjPtr vm,
                           const char *devPath)
{
    VIR_DEBUG("Setting up chardevs");

    if (virDomainChrDefForeach(vm->def,
                               true,
                               qemuDomainSetupChardev,
                               (void *) devPath) < 0)
        return -1;

    VIR_DEBUG("Setup all chardevs");
    return 0;
}


7185 7186 7187 7188 7189 7190 7191 7192 7193 7194 7195 7196 7197 7198 7199 7200 7201 7202 7203 7204 7205 7206 7207 7208 7209 7210 7211 7212 7213
static int
qemuDomainSetupTPM(virQEMUDriverPtr driver ATTRIBUTE_UNUSED,
                   virDomainObjPtr vm,
                   const char *devPath)
{
    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,
                                   devPath, false) < 0)
            return -1;
        break;

    case VIR_DOMAIN_TPM_TYPE_LAST:
        /* nada */
        break;
    }

    VIR_DEBUG("Setup TPM");
    return 0;
}


7214 7215 7216 7217 7218 7219 7220 7221 7222 7223 7224 7225 7226 7227 7228 7229 7230 7231 7232 7233 7234 7235 7236 7237 7238 7239 7240 7241 7242 7243 7244 7245 7246 7247 7248 7249 7250 7251 7252 7253 7254 7255 7256 7257 7258 7259
static int
qemuDomainSetupInput(virQEMUDriverPtr driver ATTRIBUTE_UNUSED,
                     virDomainInputDefPtr input,
                     const char *devPath)
{
    int ret = -1;

    switch ((virDomainInputType) input->type) {
    case VIR_DOMAIN_INPUT_TYPE_PASSTHROUGH:
        if (qemuDomainCreateDevice(input->source.evdev, devPath, false) < 0)
            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
qemuDomainSetupAllInputs(virQEMUDriverPtr driver,
                         virDomainObjPtr vm,
                         const char *devPath)
{
    size_t i;

    VIR_DEBUG("Setting up disks");
    for (i = 0; i < vm->def->ninputs; i++) {
        if (qemuDomainSetupInput(driver,
                                 vm->def->inputs[i],
                                 devPath) < 0)
            return -1;
    }
    VIR_DEBUG("Setup all disks");
    return 0;
}


7260 7261 7262 7263 7264 7265 7266 7267 7268 7269 7270 7271 7272 7273 7274 7275 7276 7277 7278 7279 7280 7281 7282 7283 7284 7285 7286 7287 7288 7289 7290 7291 7292 7293 7294 7295 7296 7297 7298 7299
static int
qemuDomainSetupRNG(virQEMUDriverPtr driver ATTRIBUTE_UNUSED,
                   virDomainRNGDefPtr rng,
                   const char *devPath)
{
    switch ((virDomainRNGBackend) rng->backend) {
    case VIR_DOMAIN_RNG_BACKEND_RANDOM:
        if (qemuDomainCreateDevice(rng->source.file, devPath, false) < 0)
            return -1;

    case VIR_DOMAIN_RNG_BACKEND_EGD:
    case VIR_DOMAIN_RNG_BACKEND_LAST:
        /* nada */
        break;
    }

    return 0;
}


static int
qemuDomainSetupAllRNGs(virQEMUDriverPtr driver,
                       virDomainObjPtr vm,
                       const char *devPath)
{
    size_t i;

    VIR_DEBUG("Setting up RNGs");
    for (i = 0; i < vm->def->nrngs; i++) {
        if (qemuDomainSetupRNG(driver,
                               vm->def->rngs[i],
                               devPath) < 0)
            return -1;
    }

    VIR_DEBUG("Setup all RNGs");
    return 0;
}


7300 7301 7302 7303 7304 7305 7306 7307 7308 7309 7310 7311 7312 7313 7314 7315 7316 7317 7318 7319 7320 7321 7322 7323 7324 7325 7326 7327 7328 7329 7330 7331 7332 7333 7334 7335 7336 7337
int
qemuDomainBuildNamespace(virQEMUDriverPtr driver,
                         virDomainObjPtr vm)
{
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    const unsigned long mount_flags = MS_MOVE;
    char *devPath = NULL;
    char **devMountsPath = NULL;
    size_t ndevMountsPath = 0, i;
    int ret = -1;

    if (!qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT)) {
        ret = 0;
        goto cleanup;
    }

    if (virAsprintf(&devPath, "%s/%s.dev",
                    cfg->stateDir, vm->def->name) < 0)
        goto cleanup;

    if (qemuDomainGetPreservedMounts(driver, vm,
                                     &devMountsPath, &ndevMountsPath) < 0)
        goto cleanup;

    if (qemuDomainSetupDev(driver, vm, devPath) < 0)
        goto cleanup;

    /* Save some mount points because we want to share them with the host */
    for (i = 0; i < ndevMountsPath; i++) {
        if (mount(devPreserveMounts[i].path, devMountsPath[i],
                  NULL, mount_flags, NULL) < 0) {
            virReportSystemError(errno,
                                 _("Unable to move %s mount"),
                                 devPreserveMounts[i].path);
            goto cleanup;
        }
    }

7338 7339
    if (qemuDomainSetupAllDisks(driver, vm, devPath) < 0)
        goto cleanup;
7340 7341 7342

    if (qemuDomainSetupAllHostdevs(driver, vm, devPath) < 0)
        goto cleanup;
7343 7344 7345

    if (qemuDomainSetupAllChardevs(driver, vm, devPath) < 0)
        goto cleanup;
7346 7347 7348

    if (qemuDomainSetupTPM(driver, vm, devPath) < 0)
        goto cleanup;
7349 7350 7351

    if (qemuDomainSetupAllInputs(driver, vm, devPath) < 0)
        goto cleanup;
7352 7353 7354

    if (qemuDomainSetupAllRNGs(driver, vm, devPath) < 0)
        goto cleanup;
7355

7356 7357 7358 7359 7360 7361 7362 7363 7364 7365 7366 7367 7368 7369 7370 7371 7372 7373 7374 7375 7376 7377 7378 7379 7380 7381 7382 7383 7384 7385 7386 7387 7388 7389 7390 7391 7392 7393 7394 7395 7396 7397 7398
    if (mount(devPath, "/dev", NULL, mount_flags, NULL) < 0) {
        virReportSystemError(errno,
                             _("Failed to mount %s on /dev"),
                             devPath);
        goto cleanup;
    }

    for (i = 0; i < ndevMountsPath; i++) {
        if (virFileMakePath(devPreserveMounts[i].path) < 0) {
            virReportSystemError(errno, _("Cannot create %s"),
                                 devPreserveMounts[i].path);
            goto cleanup;
        }

        if (mount(devMountsPath[i], devPreserveMounts[i].path,
                  NULL, mount_flags, NULL) < 0) {
            virReportSystemError(errno,
                                 _("Failed to mount %s on %s"),
                                 devMountsPath[i],
                                 devPreserveMounts[i].path);
            goto cleanup;
        }
    }

    ret = 0;
 cleanup:
    virObjectUnref(cfg);
    VIR_FREE(devPath);
    virStringListFreeCount(devMountsPath, ndevMountsPath);
    return ret;
}


int
qemuDomainCreateNamespace(virQEMUDriverPtr driver,
                          virDomainObjPtr vm)
{
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    int ret = -1;
    char *devPath = NULL;
    char **devMountsPath = NULL;
    size_t ndevMountsPath = 0, i;

7399 7400
    if (!virBitmapIsBitSet(cfg->namespaces, QEMU_DOMAIN_NS_MOUNT) ||
        !virQEMUDriverIsPrivileged(driver)) {
7401 7402 7403 7404 7405 7406 7407 7408 7409 7410 7411 7412 7413 7414 7415 7416 7417 7418 7419 7420 7421 7422 7423 7424 7425 7426 7427 7428
        ret = 0;
        goto cleanup;
    }

    if (virAsprintf(&devPath, "%s/%s.dev",
                    cfg->stateDir, vm->def->name) < 0)
        goto cleanup;

    if (qemuDomainGetPreservedMounts(driver, vm,
                                     &devMountsPath, &ndevMountsPath) < 0)
        goto cleanup;

    if (virFileMakePath(devPath) < 0) {
        virReportSystemError(errno,
                             _("Failed to create %s"),
                             devPath);
        goto cleanup;
    }

    for (i = 0; i < ndevMountsPath; i++) {
        if (virFileMakePath(devMountsPath[i]) < 0) {
            virReportSystemError(errno,
                                 _("Failed to create %s"),
                                 devMountsPath[i]);
            goto cleanup;
        }
    }

M
Michal Privoznik 已提交
7429 7430
    if (qemuDomainEnableNamespace(vm, QEMU_DOMAIN_NS_MOUNT) < 0)
        goto cleanup;
7431 7432 7433 7434 7435 7436 7437 7438 7439 7440 7441 7442 7443 7444 7445 7446 7447

    ret = 0;
 cleanup:
    if (ret < 0) {
        if (devPath)
            unlink(devPath);
        for (i = 0; i < ndevMountsPath; i++)
            unlink(devMountsPath[i]);
    }
    virStringListFreeCount(devMountsPath, ndevMountsPath);
    VIR_FREE(devPath);
    virObjectUnref(cfg);
    return ret;
}

#else /* !defined(__linux__) */

7448 7449 7450 7451 7452 7453 7454 7455 7456 7457
int
qemuDomainBuildNamespace(virQEMUDriverPtr driver ATTRIBUTE_UNUSED,
                         virDomainObjPtr vm ATTRIBUTE_UNUSED)
{
    /* Namespaces are Linux specific. On other platforms just
     * carry on with the old behaviour. */
    return 0;
}


7458 7459 7460 7461 7462 7463 7464 7465 7466 7467 7468 7469 7470 7471 7472 7473 7474 7475 7476 7477 7478 7479 7480 7481 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
int
qemuDomainCreateNamespace(virQEMUDriverPtr driver ATTRIBUTE_UNUSED,
                          virDomainObjPtr vm ATTRIBUTE_UNUSED)
{
    /* Namespaces are Linux specific. On other platforms just
     * carry on with the old behaviour. */
    return 0;
}
#endif /* !defined(__linux__) */


void
qemuDomainDeleteNamespace(virQEMUDriverPtr driver,
                          virDomainObjPtr vm)
{
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    char *devPath = NULL;
    char **devMountsPath = NULL;
    size_t ndevMountsPath = 0, i;


    if (!qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
        return;

    if (virAsprintf(&devPath, "%s/%s.dev",
                    cfg->stateDir, vm->def->name) < 0)
        goto cleanup;

    if (qemuDomainGetPreservedMounts(driver, vm,
                                     &devMountsPath, &ndevMountsPath) < 0)
        goto cleanup;

    if (rmdir(devPath) < 0) {
        virReportSystemError(errno,
                             _("Unable to remove %s"),
                             devPath);
        /* Bet effort. Fall through. */
    }

    for (i = 0; i < ndevMountsPath; i++) {
        if (rmdir(devMountsPath[i]) < 0) {
            virReportSystemError(errno,
                                 _("Unable to remove %s"),
                                 devMountsPath[i]);
            /* Bet effort. Fall through. */
        }
    }
 cleanup:
    virObjectUnref(cfg);
    virStringListFreeCount(devMountsPath, ndevMountsPath);
    VIR_FREE(devPath);
}
7510 7511 7512 7513 7514 7515 7516 7517 7518 7519 7520 7521 7522 7523 7524 7525 7526 7527


struct qemuDomainAttachDeviceMknodData {
    virQEMUDriverPtr driver;
    virDomainObjPtr vm;
    virDomainDeviceDefPtr devDef;
    const char *file;
    struct stat sb;
    void *acl;
};


static int
qemuDomainAttachDeviceMknodHelper(pid_t pid ATTRIBUTE_UNUSED,
                                  void *opaque)
{
    struct qemuDomainAttachDeviceMknodData *data = opaque;
    int ret = -1;
7528
    bool delDevice = false;
7529 7530 7531 7532 7533 7534 7535 7536 7537 7538 7539 7540 7541 7542 7543 7544 7545 7546 7547 7548 7549 7550

    virSecurityManagerPostFork(data->driver->securityManager);

    if (virFileMakeParentPath(data->file) < 0) {
        virReportSystemError(errno,
                             _("Unable to create %s"), data->file);
        goto cleanup;
    }

    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;
        }
7551 7552
    } else {
        delDevice = true;
7553 7554 7555 7556 7557 7558 7559 7560 7561 7562 7563 7564 7565 7566 7567 7568 7569 7570 7571 7572 7573 7574
    }

    if (virFileSetACLs(data->file, data->acl) < 0 &&
        errno != ENOTSUP) {
        virReportSystemError(errno,
                             _("Unable to set ACLs on %s"), data->file);
        goto cleanup;
    }

    switch ((virDomainDeviceType) data->devDef->type) {
    case VIR_DOMAIN_DEVICE_DISK: {
        virDomainDiskDefPtr def = data->devDef->data.disk;
        char *tmpsrc = def->src->path;
        def->src->path = (char *) data->file;
        if (virSecurityManagerSetDiskLabel(data->driver->securityManager,
                                           data->vm->def, def) < 0) {
            def->src->path = tmpsrc;
            goto cleanup;
        }
        def->src->path = tmpsrc;
    }   break;

7575 7576 7577 7578 7579 7580 7581
    case VIR_DOMAIN_DEVICE_HOSTDEV: {
        virDomainHostdevDefPtr def = data->devDef->data.hostdev;
        if (virSecurityManagerSetHostdevLabel(data->driver->securityManager,
                                              data->vm->def, def, NULL) < 0)
            goto cleanup;
    }   break;

7582
    case VIR_DOMAIN_DEVICE_CHR:
7583
    case VIR_DOMAIN_DEVICE_RNG:
7584 7585 7586
        /* No labelling. */
        break;

7587 7588 7589 7590 7591 7592 7593 7594 7595 7596 7597 7598 7599 7600 7601 7602 7603 7604 7605 7606 7607 7608 7609 7610 7611 7612 7613 7614 7615
    case VIR_DOMAIN_DEVICE_NONE:
    case VIR_DOMAIN_DEVICE_LEASE:
    case VIR_DOMAIN_DEVICE_FS:
    case VIR_DOMAIN_DEVICE_NET:
    case VIR_DOMAIN_DEVICE_INPUT:
    case VIR_DOMAIN_DEVICE_SOUND:
    case VIR_DOMAIN_DEVICE_VIDEO:
    case VIR_DOMAIN_DEVICE_WATCHDOG:
    case VIR_DOMAIN_DEVICE_CONTROLLER:
    case VIR_DOMAIN_DEVICE_GRAPHICS:
    case VIR_DOMAIN_DEVICE_HUB:
    case VIR_DOMAIN_DEVICE_REDIRDEV:
    case VIR_DOMAIN_DEVICE_SMARTCARD:
    case VIR_DOMAIN_DEVICE_MEMBALLOON:
    case VIR_DOMAIN_DEVICE_NVRAM:
    case VIR_DOMAIN_DEVICE_SHMEM:
    case VIR_DOMAIN_DEVICE_TPM:
    case VIR_DOMAIN_DEVICE_PANIC:
    case VIR_DOMAIN_DEVICE_MEMORY:
    case VIR_DOMAIN_DEVICE_IOMMU:
    case VIR_DOMAIN_DEVICE_LAST:
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Unexpected device type %d"),
                       data->devDef->type);
        goto cleanup;
    }

    ret = 0;
 cleanup:
7616
    if (ret < 0 && delDevice)
7617 7618 7619 7620 7621 7622 7623 7624 7625 7626 7627 7628 7629 7630 7631 7632 7633 7634 7635 7636 7637 7638 7639 7640 7641 7642 7643 7644 7645 7646 7647 7648 7649 7650 7651 7652 7653 7654 7655 7656 7657 7658 7659 7660 7661 7662 7663 7664 7665 7666 7667 7668 7669 7670
        unlink(data->file);
    virFileFreeACLs(&data->acl);
    return ret;
}


static int
qemuDomainAttachDeviceMknod(virQEMUDriverPtr driver,
                            virDomainObjPtr vm,
                            virDomainDeviceDefPtr devDef,
                            const char *file)
{
    struct qemuDomainAttachDeviceMknodData data;
    int ret = -1;

    memset(&data, 0, sizeof(data));

    data.driver = driver;
    data.vm = vm;
    data.devDef = devDef;
    data.file = file;

    if (stat(file, &data.sb) < 0) {
        virReportSystemError(errno,
                             _("Unable to access %s"), file);
        return ret;
    }

    if (virFileGetACLs(file, &data.acl) < 0 &&
        errno != ENOTSUP) {
        virReportSystemError(errno,
                             _("Unable to get ACLs on %s"), file);
        return ret;
    }

    if (virSecurityManagerPreFork(driver->securityManager) < 0)
        goto cleanup;

    if (virProcessRunInMountNamespace(vm->pid,
                                      qemuDomainAttachDeviceMknodHelper,
                                      &data) < 0) {
        virSecurityManagerPostFork(driver->securityManager);
        goto cleanup;
    }

    virSecurityManagerPostFork(driver->securityManager);

    ret = 0;
 cleanup:
    virFileFreeACLs(&data.acl);
    return 0;
}


7671 7672 7673 7674 7675 7676 7677 7678 7679 7680 7681 7682 7683 7684 7685 7686 7687 7688 7689 7690 7691 7692 7693 7694 7695 7696 7697 7698 7699 7700 7701 7702 7703 7704 7705 7706 7707 7708 7709 7710 7711 7712 7713 7714 7715 7716 7717
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
qemuDomainDetachDeviceUnlink(virQEMUDriverPtr driver,
                             virDomainObjPtr vm,
                             virDomainDeviceDefPtr dev,
                             const char *file)
{
    /* Technically, this is not needed. Yet. But in the future
     * security managers might do some reference counting over
     * Set/Restore label and thus for every SetLabel() there
     * should be corresponding RestoreLabel(). */
    switch ((virDomainDeviceType) dev->type) {
    case VIR_DOMAIN_DEVICE_DISK: {
        virDomainDiskDefPtr def = dev->data.disk;
        char *tmpsrc = def->src->path;
        def->src->path = (char *) file;
        if (virSecurityManagerRestoreDiskLabel(driver->securityManager,
                                               vm->def, def) < 0) {
            def->src->path = tmpsrc;
            return -1;
        }
        def->src->path = tmpsrc;
    }   break;

    case VIR_DOMAIN_DEVICE_HOSTDEV: {
        virDomainHostdevDefPtr def = dev->data.hostdev;
        if (virSecurityManagerRestoreHostdevLabel(driver->securityManager,
                                                  vm->def, def, NULL) < 0)
            return -1;
    }   break;

7718
    case VIR_DOMAIN_DEVICE_CHR:
7719
    case VIR_DOMAIN_DEVICE_RNG:
7720 7721 7722
        /* No labelling. */
        break;

7723 7724 7725 7726 7727 7728 7729 7730 7731 7732 7733 7734 7735 7736 7737 7738 7739 7740 7741 7742 7743 7744 7745 7746 7747 7748 7749 7750 7751 7752 7753 7754 7755 7756 7757 7758
    case VIR_DOMAIN_DEVICE_NONE:
    case VIR_DOMAIN_DEVICE_LEASE:
    case VIR_DOMAIN_DEVICE_FS:
    case VIR_DOMAIN_DEVICE_NET:
    case VIR_DOMAIN_DEVICE_INPUT:
    case VIR_DOMAIN_DEVICE_SOUND:
    case VIR_DOMAIN_DEVICE_VIDEO:
    case VIR_DOMAIN_DEVICE_WATCHDOG:
    case VIR_DOMAIN_DEVICE_CONTROLLER:
    case VIR_DOMAIN_DEVICE_GRAPHICS:
    case VIR_DOMAIN_DEVICE_HUB:
    case VIR_DOMAIN_DEVICE_REDIRDEV:
    case VIR_DOMAIN_DEVICE_SMARTCARD:
    case VIR_DOMAIN_DEVICE_MEMBALLOON:
    case VIR_DOMAIN_DEVICE_NVRAM:
    case VIR_DOMAIN_DEVICE_SHMEM:
    case VIR_DOMAIN_DEVICE_TPM:
    case VIR_DOMAIN_DEVICE_PANIC:
    case VIR_DOMAIN_DEVICE_MEMORY:
    case VIR_DOMAIN_DEVICE_IOMMU:
    case VIR_DOMAIN_DEVICE_LAST:
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Unexpected device type %d"),
                       dev->type);
        return -1;
    }

    if (virProcessRunInMountNamespace(vm->pid,
                                      qemuDomainDetachDeviceUnlinkHelper,
                                      (void *)file) < 0)
        return -1;

    return 0;
}


7759 7760 7761 7762 7763 7764 7765 7766 7767 7768 7769 7770 7771 7772 7773 7774
int
qemuDomainNamespaceSetupDisk(virQEMUDriverPtr driver,
                             virDomainObjPtr vm,
                             virDomainDiskDefPtr disk)
{
    virDomainDeviceDef dev = {.type = VIR_DOMAIN_DEVICE_DISK, .data.disk = disk};
    virStorageSourcePtr next;
    const char *src = NULL;
    struct stat sb;
    int ret = -1;

    if (!qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
        return 0;

    for (next = disk->src; next; next = next->backingStore) {
        if (!next->path || !virStorageSourceIsBlockLocal(disk->src) ||
7775
            !STRPREFIX(next->path, DEVPREFIX)) {
7776 7777 7778 7779 7780 7781 7782 7783 7784 7785 7786 7787 7788 7789 7790 7791 7792 7793 7794 7795 7796 7797 7798 7799 7800 7801 7802 7803 7804 7805 7806 7807 7808 7809 7810 7811 7812 7813 7814 7815 7816 7817 7818
            /* Not creating device. Just continue. */
            continue;
        }

        if (stat(next->path, &sb) < 0) {
            virReportSystemError(errno,
                                 _("Unable to access %s"), src);
            goto cleanup;
        }

        if (!S_ISBLK(sb.st_mode)) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
                           _("Disk source %s must be a block device"),
                           src);
            goto cleanup;
        }

        if (qemuDomainAttachDeviceMknod(driver,
                                        vm,
                                        &dev,
                                        next->path) < 0)
            goto cleanup;
    }

    ret = 0;
 cleanup:
    return ret;
}


int
qemuDomainNamespaceTeardownDisk(virQEMUDriverPtr driver ATTRIBUTE_UNUSED,
                                virDomainObjPtr vm ATTRIBUTE_UNUSED,
                                virDomainDiskDefPtr disk ATTRIBUTE_UNUSED)
{
    /* 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;
}
7819 7820 7821 7822 7823 7824 7825 7826 7827 7828 7829 7830 7831 7832 7833 7834 7835 7836 7837 7838 7839 7840 7841 7842 7843 7844 7845 7846 7847 7848 7849 7850 7851 7852 7853 7854 7855 7856 7857 7858 7859 7860 7861 7862 7863 7864 7865 7866 7867 7868 7869 7870 7871 7872 7873 7874 7875 7876 7877 7878 7879 7880 7881 7882


int
qemuDomainNamespaceSetupHostdev(virQEMUDriverPtr driver,
                                virDomainObjPtr vm,
                                virDomainHostdevDefPtr hostdev)
{
    virDomainDeviceDef dev = {.type = VIR_DOMAIN_DEVICE_HOSTDEV, .data.hostdev = hostdev};
    int ret = -1;
    char *path = NULL;

    if (!qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
        return 0;

    if (qemuDomainGetHostdevPath(hostdev, &path) < 0)
        goto cleanup;

    if (!path) {
        /* There's no /dev device that we need to create. Claim success. */
        ret = 0;
        goto cleanup;
    }

    if (qemuDomainAttachDeviceMknod(driver,
                                    vm,
                                    &dev,
                                    path) < 0)
        goto cleanup;
    ret = 0;
 cleanup:
    VIR_FREE(path);
    return ret;
}


int
qemuDomainNamespaceTeardownHostdev(virQEMUDriverPtr driver,
                                   virDomainObjPtr vm,
                                   virDomainHostdevDefPtr hostdev)
{
    virDomainDeviceDef dev = {.type = VIR_DOMAIN_DEVICE_HOSTDEV, .data.hostdev = hostdev};
    int ret = -1;
    char *path = NULL;

    if (!qemuDomainNamespaceEnabled(vm, QEMU_DOMAIN_NS_MOUNT))
        return 0;

    if (qemuDomainGetHostdevPath(hostdev, &path) < 0)
        goto cleanup;

    if (!path) {
        /* There's no /dev device that we need to create. Claim success. */
        ret = 0;
        goto cleanup;
    }

    if (qemuDomainDetachDeviceUnlink(driver, vm, &dev, path) < 0)
        goto cleanup;

    ret = 0;
 cleanup:
    VIR_FREE(path);
    return ret;
}
7883 7884 7885 7886 7887 7888 7889 7890 7891 7892 7893 7894 7895 7896 7897 7898 7899 7900 7901 7902 7903 7904 7905 7906 7907 7908 7909 7910 7911 7912 7913 7914 7915 7916 7917 7918 7919 7920 7921 7922 7923 7924 7925 7926 7927 7928 7929 7930 7931 7932 7933 7934 7935 7936


int
qemuDomainNamespaceSetupChardev(virQEMUDriverPtr driver,
                                virDomainObjPtr vm,
                                virDomainChrDefPtr chr)
{
    virDomainDeviceDef dev = {.type = VIR_DOMAIN_DEVICE_CHR, .data.chr = chr};
    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;

    if (qemuDomainAttachDeviceMknod(driver,
                                    vm,
                                    &dev,
                                    path) < 0)
        goto cleanup;
    ret = 0;
 cleanup:
    return ret;
}


int
qemuDomainNamespaceTeardownChardev(virQEMUDriverPtr driver,
                                   virDomainObjPtr vm,
                                   virDomainChrDefPtr chr)
{
    virDomainDeviceDef dev = {.type = VIR_DOMAIN_DEVICE_CHR, .data.chr = chr};
    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;

    if (qemuDomainDetachDeviceUnlink(driver, vm, &dev, path) < 0)
        goto cleanup;

    ret = 0;
 cleanup:
    return ret;
}
7937 7938 7939 7940 7941 7942 7943 7944 7945 7946 7947 7948 7949 7950 7951 7952 7953 7954 7955 7956 7957 7958 7959 7960 7961 7962 7963 7964 7965 7966 7967 7968 7969 7970 7971 7972 7973 7974 7975 7976 7977 7978 7979 7980 7981 7982 7983 7984 7985 7986 7987 7988 7989 7990 7991 7992 7993 7994 7995 7996 7997 7998 7999 8000 8001 8002


int
qemuDomainNamespaceSetupRNG(virQEMUDriverPtr driver,
                            virDomainObjPtr vm,
                            virDomainRNGDefPtr rng)
{
    virDomainDeviceDef dev = {.type = VIR_DOMAIN_DEVICE_RNG, .data.rng = rng};
    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;
    }

    if (qemuDomainAttachDeviceMknod(driver,
                                    vm,
                                    &dev,
                                    path) < 0)
        goto cleanup;
    ret = 0;
 cleanup:
    return ret;
}


int
qemuDomainNamespaceTeardownRNG(virQEMUDriverPtr driver,
                               virDomainObjPtr vm,
                               virDomainRNGDefPtr rng)
{
    virDomainDeviceDef dev = {.type = VIR_DOMAIN_DEVICE_RNG, .data.rng = rng};
    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;
    }

    if (qemuDomainDetachDeviceUnlink(driver, vm, &dev, path) < 0)
        goto cleanup;

    ret = 0;
 cleanup:
    return ret;
}