qemu_domain.c 177.5 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
#include <sys/time.h>
57
#include <fcntl.h>
58

59 60 61 62
#include <libxml/xpathInternals.h>

#define VIR_FROM_THIS VIR_FROM_QEMU

63 64
VIR_LOG_INIT("qemu.qemu_domain");

65 66
#define QEMU_NAMESPACE_HREF "http://libvirt.org/schemas/domain/qemu/1.0"

67 68 69 70 71 72
VIR_ENUM_IMPL(qemuDomainJob, QEMU_JOB_LAST,
              "none",
              "query",
              "destroy",
              "suspend",
              "modify",
73
              "abort",
74
              "migration operation",
75 76 77 78 79 80 81 82 83 84
              "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",
85
              "snapshot",
86
              "start",
87 88
);

89

90 91 92
struct _qemuDomainLogContext {
    int refs;
    int writefd;
93
    int readfd; /* Only used if manager == NULL */
94
    off_t pos;
95
    ino_t inode; /* Only used if manager != NULL */
96
    char *path;
97
    virLogManagerPtr manager;
98 99
};

J
Jiri Denemark 已提交
100
const char *
101
qemuDomainAsyncJobPhaseToString(qemuDomainAsyncJob job,
J
Jiri Denemark 已提交
102 103 104 105 106
                                int phase ATTRIBUTE_UNUSED)
{
    switch (job) {
    case QEMU_ASYNC_JOB_MIGRATION_OUT:
    case QEMU_ASYNC_JOB_MIGRATION_IN:
107 108
        return qemuMigrationJobPhaseTypeToString(phase);

J
Jiri Denemark 已提交
109 110
    case QEMU_ASYNC_JOB_SAVE:
    case QEMU_ASYNC_JOB_DUMP:
111
    case QEMU_ASYNC_JOB_SNAPSHOT:
112
    case QEMU_ASYNC_JOB_START:
J
Jiri Denemark 已提交
113 114 115 116 117 118 119 120 121
    case QEMU_ASYNC_JOB_NONE:
    case QEMU_ASYNC_JOB_LAST:
        ; /* fall through */
    }

    return "none";
}

int
122
qemuDomainAsyncJobPhaseFromString(qemuDomainAsyncJob job,
J
Jiri Denemark 已提交
123 124 125 126 127 128 129 130
                                  const char *phase)
{
    if (!phase)
        return 0;

    switch (job) {
    case QEMU_ASYNC_JOB_MIGRATION_OUT:
    case QEMU_ASYNC_JOB_MIGRATION_IN:
131 132
        return qemuMigrationJobPhaseTypeFromString(phase);

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

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

148

149
void qemuDomainEventQueue(virQEMUDriverPtr driver,
150
                          virObjectEventPtr event)
151
{
152 153
    if (event)
        virObjectEventStateQueue(driver->domainEventState, event);
154 155 156
}


157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
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);
}


181 182 183 184 185 186 187 188
static int
qemuDomainObjInitJob(qemuDomainObjPrivatePtr priv)
{
    memset(&priv->job, 0, sizeof(priv->job));

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

189
    if (virCondInit(&priv->job.asyncCond) < 0) {
190
        virCondDestroy(&priv->job.cond);
191 192 193
        return -1;
    }

194 195 196 197 198 199 200 201 202
    return 0;
}

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

    job->active = QEMU_JOB_NONE;
203
    job->owner = 0;
204
    job->ownerAPI = NULL;
J
Jiri Denemark 已提交
205
    job->started = 0;
206 207 208 209 210 211 212 213
}

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

    job->asyncJob = QEMU_ASYNC_JOB_NONE;
214
    job->asyncOwner = 0;
215
    job->asyncOwnerAPI = NULL;
J
Jiri Denemark 已提交
216
    job->asyncStarted = 0;
J
Jiri Denemark 已提交
217
    job->phase = 0;
218
    job->mask = QEMU_JOB_DEFAULT_MASK;
219
    job->dump_memory_only = false;
220
    job->abortJob = false;
221
    job->spiceMigration = false;
222
    job->spiceMigrated = false;
223
    job->postcopyEnabled = false;
J
Jiri Denemark 已提交
224
    VIR_FREE(job->current);
225 226
}

227 228 229 230 231 232 233 234
void
qemuDomainObjRestoreJob(virDomainObjPtr obj,
                        struct qemuDomainJobObj *job)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

    memset(job, 0, sizeof(*job));
    job->active = priv->job.active;
235
    job->owner = priv->job.owner;
236
    job->asyncJob = priv->job.asyncJob;
237
    job->asyncOwner = priv->job.asyncOwner;
J
Jiri Denemark 已提交
238
    job->phase = priv->job.phase;
239 240 241 242 243

    qemuDomainObjResetJob(priv);
    qemuDomainObjResetAsyncJob(priv);
}

244 245 246
static void
qemuDomainObjFreeJob(qemuDomainObjPrivatePtr priv)
{
J
Jiri Denemark 已提交
247
    VIR_FREE(priv->job.current);
248
    VIR_FREE(priv->job.completed);
249 250
    virCondDestroy(&priv->job.cond);
    virCondDestroy(&priv->job.asyncCond);
251 252
}

253
static bool
254
qemuDomainTrackJob(qemuDomainJob job)
255 256 257 258
{
    return (QEMU_DOMAIN_TRACK_JOBS & JOB_MASK(job)) != 0;
}

259

J
Jiri Denemark 已提交
260 261 262 263 264 265 266 267 268 269 270
int
qemuDomainJobInfoUpdateTime(qemuDomainJobInfoPtr jobInfo)
{
    unsigned long long now;

    if (!jobInfo->started)
        return 0;

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

271 272 273 274 275 276
    if (now < jobInfo->started) {
        VIR_WARN("Async job starts in the future");
        jobInfo->started = 0;
        return 0;
    }

J
Jiri Denemark 已提交
277 278 279 280
    jobInfo->timeElapsed = now - jobInfo->started;
    return 0;
}

281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
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;
    }

298 299
    jobInfo->stats.downtime = now - jobInfo->stopped;
    jobInfo->stats.downtime_set = true;
300 301 302
    return 0;
}

J
Jiri Denemark 已提交
303 304 305 306
int
qemuDomainJobInfoToInfo(qemuDomainJobInfoPtr jobInfo,
                        virDomainJobInfoPtr info)
{
307
    info->type = jobInfo->type;
J
Jiri Denemark 已提交
308 309 310
    info->timeElapsed = jobInfo->timeElapsed;
    info->timeRemaining = jobInfo->timeRemaining;

311 312 313
    info->memTotal = jobInfo->stats.ram_total;
    info->memRemaining = jobInfo->stats.ram_remaining;
    info->memProcessed = jobInfo->stats.ram_transferred;
J
Jiri Denemark 已提交
314

315 316 317
    info->fileTotal = jobInfo->stats.disk_total;
    info->fileRemaining = jobInfo->stats.disk_remaining;
    info->fileProcessed = jobInfo->stats.disk_transferred;
J
Jiri Denemark 已提交
318 319 320 321 322 323 324 325 326 327 328 329 330 331

    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)
{
332
    qemuMonitorMigrationStats *stats = &jobInfo->stats;
J
Jiri Denemark 已提交
333 334 335 336 337 338 339 340 341
    virTypedParameterPtr par = NULL;
    int maxpar = 0;
    int npar = 0;

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

342 343 344 345 346 347 348
    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 已提交
349 350 351 352 353 354
    if (jobInfo->type == VIR_DOMAIN_JOB_BOUNDED &&
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_TIME_REMAINING,
                                jobInfo->timeRemaining) < 0)
        goto error;

355
    if (stats->downtime_set &&
J
Jiri Denemark 已提交
356 357
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DOWNTIME,
358
                                stats->downtime) < 0)
J
Jiri Denemark 已提交
359 360
        goto error;

361
    if (stats->downtime_set &&
362
        jobInfo->timeDeltaSet &&
363
        stats->downtime > jobInfo->timeDelta &&
364 365
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DOWNTIME_NET,
366
                                stats->downtime - jobInfo->timeDelta) < 0)
367 368
        goto error;

369
    if (stats->setup_time_set &&
370 371
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_SETUP_TIME,
372
                                stats->setup_time) < 0)
373 374
        goto error;

J
Jiri Denemark 已提交
375 376
    if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DATA_TOTAL,
377 378
                                stats->ram_total +
                                stats->disk_total) < 0 ||
J
Jiri Denemark 已提交
379 380
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DATA_PROCESSED,
381 382
                                stats->ram_transferred +
                                stats->disk_transferred) < 0 ||
J
Jiri Denemark 已提交
383 384
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DATA_REMAINING,
385 386
                                stats->ram_remaining +
                                stats->disk_remaining) < 0)
J
Jiri Denemark 已提交
387 388 389 390
        goto error;

    if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_MEMORY_TOTAL,
391
                                stats->ram_total) < 0 ||
J
Jiri Denemark 已提交
392 393
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_MEMORY_PROCESSED,
394
                                stats->ram_transferred) < 0 ||
J
Jiri Denemark 已提交
395 396
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_MEMORY_REMAINING,
397
                                stats->ram_remaining) < 0)
J
Jiri Denemark 已提交
398 399
        goto error;

400
    if (stats->ram_bps &&
401 402
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_MEMORY_BPS,
403
                                stats->ram_bps) < 0)
404 405
        goto error;

406
    if (stats->ram_duplicate_set) {
J
Jiri Denemark 已提交
407 408
        if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_MEMORY_CONSTANT,
409
                                    stats->ram_duplicate) < 0 ||
J
Jiri Denemark 已提交
410 411
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_MEMORY_NORMAL,
412
                                    stats->ram_normal) < 0 ||
J
Jiri Denemark 已提交
413 414
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES,
415
                                    stats->ram_normal_bytes) < 0)
J
Jiri Denemark 已提交
416 417 418
            goto error;
    }

419 420 421 422 423 424 425 426
    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 已提交
427 428
    if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DISK_TOTAL,
429
                                stats->disk_total) < 0 ||
J
Jiri Denemark 已提交
430 431
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DISK_PROCESSED,
432
                                stats->disk_transferred) < 0 ||
J
Jiri Denemark 已提交
433 434
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DISK_REMAINING,
435
                                stats->disk_remaining) < 0)
J
Jiri Denemark 已提交
436 437
        goto error;

438
    if (stats->disk_bps &&
439 440
        virTypedParamsAddULLong(&par, &npar, &maxpar,
                                VIR_DOMAIN_JOB_DISK_BPS,
441
                                stats->disk_bps) < 0)
442 443
        goto error;

444
    if (stats->xbzrle_set) {
J
Jiri Denemark 已提交
445 446
        if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_COMPRESSION_CACHE,
447
                                    stats->xbzrle_cache_size) < 0 ||
J
Jiri Denemark 已提交
448 449
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_COMPRESSION_BYTES,
450
                                    stats->xbzrle_bytes) < 0 ||
J
Jiri Denemark 已提交
451 452
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_COMPRESSION_PAGES,
453
                                    stats->xbzrle_pages) < 0 ||
J
Jiri Denemark 已提交
454 455
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES,
456
                                    stats->xbzrle_cache_miss) < 0 ||
J
Jiri Denemark 已提交
457 458
            virTypedParamsAddULLong(&par, &npar, &maxpar,
                                    VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW,
459
                                    stats->xbzrle_overflow) < 0)
J
Jiri Denemark 已提交
460 461 462
            goto error;
    }

463 464 465 466 467 468
    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 已提交
469 470 471 472 473 474 475 476 477 478 479
    *type = jobInfo->type;
    *params = par;
    *nparams = npar;
    return 0;

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


J
John Ferlan 已提交
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501
/* 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:
502 503
 * @driver: qemu driver data
 * @vm: Pointer to the vm object
J
John Ferlan 已提交
504 505 506 507 508
 *
 * 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
 */
509
int
M
Martin Kletzander 已提交
510 511
qemuDomainWriteMasterKeyFile(virQEMUDriverPtr driver,
                             virDomainObjPtr vm)
J
John Ferlan 已提交
512 513 514 515
{
    char *path;
    int fd = -1;
    int ret = -1;
M
Martin Kletzander 已提交
516
    qemuDomainObjPrivatePtr priv = vm->privateData;
J
John Ferlan 已提交
517

518 519 520 521
    /* Only gets filled in if we have the capability */
    if (!priv->masterKey)
        return 0;

J
John Ferlan 已提交
522 523 524 525 526 527 528 529 530 531 532 533 534 535 536
    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;
    }

537 538
    if (virSecurityManagerDomainSetPathLabel(driver->securityManager,
                                             vm->def, path) < 0)
M
Martin Kletzander 已提交
539 540
        goto cleanup;

J
John Ferlan 已提交
541 542 543 544 545 546 547 548 549 550
    ret = 0;

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

    return ret;
}


551 552 553 554 555 556 557 558 559
static void
qemuDomainMasterKeyFree(qemuDomainObjPrivatePtr priv)
{
    if (!priv->masterKey)
        return;

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

J
John Ferlan 已提交
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657
/* 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 */
658
    qemuDomainMasterKeyFree(priv);
J
John Ferlan 已提交
659 660 661 662 663 664 665 666 667 668

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

    VIR_FREE(path);
}


/* qemuDomainMasterKeyCreate:
669
 * @vm: Pointer to the domain object
J
John Ferlan 已提交
670 671 672 673 674 675 676 677
 *
 * 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
678
qemuDomainMasterKeyCreate(virDomainObjPtr vm)
J
John Ferlan 已提交
679
{
M
Martin Kletzander 已提交
680 681
    qemuDomainObjPrivatePtr priv = vm->privateData;

J
John Ferlan 已提交
682 683 684 685 686
    /* If we don't have the capability, then do nothing. */
    if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_OBJECT_SECRET))
        return 0;

    if (!(priv->masterKey =
687
          virCryptoGenerateRandom(QEMU_DOMAIN_MASTER_KEY_LEN)))
688
        return -1;
J
John Ferlan 已提交
689 690 691 692 693 694 695

    priv->masterKeyLen = QEMU_DOMAIN_MASTER_KEY_LEN;

    return 0;
}


696
static void
697
qemuDomainSecretPlainClear(qemuDomainSecretPlain secret)
698 699
{
    VIR_FREE(secret.username);
700
    VIR_DISPOSE_N(secret.secret, secret.secretlen);
701 702 703
}


J
John Ferlan 已提交
704
static void
705
qemuDomainSecretAESClear(qemuDomainSecretAES secret)
J
John Ferlan 已提交
706 707 708 709 710 711 712 713
{
    VIR_FREE(secret.username);
    VIR_FREE(secret.alias);
    VIR_FREE(secret.iv);
    VIR_FREE(secret.ciphertext);
}


714 715 716 717 718 719
static void
qemuDomainSecretInfoFree(qemuDomainSecretInfoPtr *secinfo)
{
    if (!*secinfo)
        return;

J
John Ferlan 已提交
720 721
    switch ((qemuDomainSecretInfoType) (*secinfo)->type) {
    case VIR_DOMAIN_SECRET_INFO_TYPE_PLAIN:
722
        qemuDomainSecretPlainClear((*secinfo)->s.plain);
J
John Ferlan 已提交
723 724
        break;

725
    case VIR_DOMAIN_SECRET_INFO_TYPE_AES:
726
        qemuDomainSecretAESClear((*secinfo)->s.aes);
J
John Ferlan 已提交
727 728 729 730 731 732
        break;

    case VIR_DOMAIN_SECRET_INFO_TYPE_LAST:
        break;
    }

733 734 735 736
    VIR_FREE(*secinfo);
}


737
static virClassPtr qemuDomainDiskPrivateClass;
738
static void qemuDomainDiskPrivateDispose(void *obj);
739 740 741 742 743 744 745

static int
qemuDomainDiskPrivateOnceInit(void)
{
    qemuDomainDiskPrivateClass = virClassNew(virClassForObject(),
                                             "qemuDomainDiskPrivate",
                                             sizeof(qemuDomainDiskPrivate),
746
                                             qemuDomainDiskPrivateDispose);
747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769
    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;
}


770 771 772 773 774 775
static void
qemuDomainDiskPrivateDispose(void *obj)
{
    qemuDomainDiskPrivatePtr priv = obj;

    qemuDomainSecretInfoFree(&priv->secinfo);
J
John Ferlan 已提交
776
    qemuDomainSecretInfoFree(&priv->encinfo);
777 778 779
}


780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822
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);
}


823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
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
qemuDomainVcpuPrivateDispose(void *obj ATTRIBUTE_UNUSED)
{
    return;
}


863 864 865
/* qemuDomainSecretPlainSetup:
 * @conn: Pointer to connection
 * @secinfo: Pointer to secret info
866
 * @secretUsageType: The virSecretUsageType
867 868
 * @username: username to use for authentication (may be NULL)
 * @seclookupdef: Pointer to seclookupdef data
869 870 871 872 873 874 875 876
 *
 * 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,
877
                           virSecretUsageType secretUsageType,
878 879
                           const char *username,
                           virSecretLookupTypeDefPtr seclookupdef)
880
{
881
    secinfo->type = VIR_DOMAIN_SECRET_INFO_TYPE_PLAIN;
882
    if (VIR_STRDUP(secinfo->s.plain.username, username) < 0)
883 884
        return -1;

885
    return virSecretGetSecretString(conn, seclookupdef, secretUsageType,
886 887
                                    &secinfo->s.plain.secret,
                                    &secinfo->s.plain.secretlen);
888 889 890
}


891 892 893 894 895
/* 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
896
 * @secretUsageType: The virSecretUsageType
897 898
 * @username: username to use for authentication (may be NULL)
 * @seclookupdef: Pointer to seclookupdef data
899
 * @isLuks: True/False for is for luks (alias generation)
900 901 902 903 904 905 906 907 908 909
 *
 * 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,
910
                         virSecretUsageType secretUsageType,
911
                         const char *username,
912 913
                         virSecretLookupTypeDefPtr seclookupdef,
                         bool isLuks)
914 915 916 917 918 919 920 921 922 923
{
    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;
924
    if (VIR_STRDUP(secinfo->s.aes.username, username) < 0)
925 926
        return -1;

927
    if (!(secinfo->s.aes.alias = qemuDomainGetSecretAESAlias(srcalias, isLuks)))
928 929 930 931 932 933 934 935 936 937 938
        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 */
939
    if (virSecretGetSecretString(conn, seclookupdef, secretUsageType,
940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967
                                 &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;
}


968 969
/* qemuDomainSecretSetup:
 * @conn: Pointer to connection
970
 * @priv: pointer to domain private object
971
 * @secinfo: Pointer to secret info
972
 * @srcalias: Alias of the disk/hostdev used to generate the secret alias
973
 * @secretUsageType: The virSecretUsageType
974 975
 * @username: username to use for authentication (may be NULL)
 * @seclookupdef: Pointer to seclookupdef data
976
 * @isLuks: True when is luks (generates different alias)
977
 *
978 979 980 981
 * 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.
982 983 984 985 986
 *
 * Returns 0 on success, -1 on failure
 */
static int
qemuDomainSecretSetup(virConnectPtr conn,
987
                      qemuDomainObjPrivatePtr priv,
988
                      qemuDomainSecretInfoPtr secinfo,
989
                      const char *srcalias,
990
                      virSecretUsageType secretUsageType,
991
                      const char *username,
992 993
                      virSecretLookupTypeDefPtr seclookupdef,
                      bool isLuks)
994
{
995 996
    if (virCryptoHaveCipher(VIR_CRYPTO_CIPHER_AES256CBC) &&
        virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_OBJECT_SECRET) &&
997 998
        (secretUsageType == VIR_SECRET_USAGE_TYPE_CEPH ||
         secretUsageType == VIR_SECRET_USAGE_TYPE_VOLUME)) {
999
        if (qemuDomainSecretAESSetup(conn, priv, secinfo, srcalias,
1000
                                     secretUsageType, username,
1001
                                     seclookupdef, isLuks) < 0)
1002 1003
            return -1;
    } else {
1004
        if (qemuDomainSecretPlainSetup(conn, secinfo, secretUsageType,
1005
                                       username, seclookupdef) < 0)
1006 1007 1008
            return -1;
    }
    return 0;
1009 1010 1011
}


1012 1013 1014 1015 1016 1017 1018 1019 1020 1021
/* 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);

1022
    if (!diskPriv || !diskPriv->secinfo)
1023 1024 1025 1026 1027 1028
        return;

    qemuDomainSecretInfoFree(&diskPriv->secinfo);
}


1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
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;
}


1043 1044
/* qemuDomainSecretDiskPrepare:
 * @conn: Pointer to connection
J
John Ferlan 已提交
1045
 * @priv: pointer to domain private object
1046 1047 1048 1049 1050 1051 1052 1053
 * @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,
1054
                            qemuDomainObjPrivatePtr priv,
1055 1056 1057
                            virDomainDiskDefPtr disk)
{
    virStorageSourcePtr src = disk->src;
1058
    qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);
1059 1060
    qemuDomainSecretInfoPtr secinfo = NULL;

1061 1062 1063 1064
    if (!conn)
        return 0;

    if (qemuDomainSecretDiskCapable(src)) {
1065
        virSecretUsageType secretUsageType = VIR_SECRET_USAGE_TYPE_ISCSI;
1066 1067 1068 1069

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

1070 1071 1072
        if (src->protocol == VIR_STORAGE_NET_PROTOCOL_RBD)
            secretUsageType = VIR_SECRET_USAGE_TYPE_CEPH;

1073
        if (qemuDomainSecretSetup(conn, priv, secinfo, disk->info.alias,
1074
                                  secretUsageType, src->auth->username,
1075
                                  &src->auth->seclookupdef, false) < 0)
1076 1077 1078 1079 1080
            goto error;

        diskPriv->secinfo = secinfo;
    }

1081
    if (!virStorageSourceIsEmpty(src) && src->encryption &&
1082
        src->encryption->format == VIR_STORAGE_ENCRYPTION_FORMAT_LUKS) {
1083 1084 1085 1086 1087 1088 1089 1090 1091 1092

        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;

1093 1094 1095 1096 1097 1098 1099
        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;
        }

1100 1101 1102
        diskPriv->encinfo = secinfo;
    }

1103 1104 1105 1106 1107 1108 1109 1110
    return 0;

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


1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121
/* 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);

1122
    if (!hostdevPriv || !hostdevPriv->secinfo)
1123 1124 1125 1126 1127 1128 1129 1130
        return;

    qemuDomainSecretInfoFree(&hostdevPriv->secinfo);
}


/* qemuDomainSecretHostdevPrepare:
 * @conn: Pointer to connection
J
John Ferlan 已提交
1131
 * @priv: pointer to domain private object
1132 1133 1134 1135 1136 1137 1138 1139
 * @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,
1140
                               qemuDomainObjPrivatePtr priv,
1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160
                               virDomainHostdevDefPtr hostdev)
{
    virDomainHostdevSubsysPtr subsys = &hostdev->source.subsys;
    qemuDomainSecretInfoPtr secinfo = NULL;

    if (conn && hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
        subsys->type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI) {

        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;

1161
            if (qemuDomainSecretSetup(conn, priv, secinfo, hostdev->info->alias,
1162
                                      VIR_SECRET_USAGE_TYPE_ISCSI,
1163
                                      iscsisrc->auth->username,
1164
                                      &iscsisrc->auth->seclookupdef, false) < 0)
1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
                goto error;

            hostdevPriv->secinfo = secinfo;
        }
    }

    return 0;

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


1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191
/* 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]);
1192 1193 1194

    for (i = 0; i < vm->def->nhostdevs; i++)
        qemuDomainSecretHostdevDestroy(vm->def->hostdevs[i]);
1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213
}


/* qemuDomainSecretPrepare:
 * @conn: Pointer to connection
 * @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,
                        virDomainObjPtr vm)
{
J
John Ferlan 已提交
1214
    qemuDomainObjPrivatePtr priv = vm->privateData;
1215 1216 1217
    size_t i;

    for (i = 0; i < vm->def->ndisks; i++) {
J
John Ferlan 已提交
1218
        if (qemuDomainSecretDiskPrepare(conn, priv, vm->def->disks[i]) < 0)
1219 1220 1221
            return -1;
    }

1222
    for (i = 0; i < vm->def->nhostdevs; i++) {
J
John Ferlan 已提交
1223 1224
        if (qemuDomainSecretHostdevPrepare(conn, priv,
                                           vm->def->hostdevs[i]) < 0)
1225 1226 1227
            return -1;
    }

1228 1229 1230 1231
    return 0;
}


1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258
/* 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
1259 1260
qemuDomainSetPrivatePaths(virQEMUDriverPtr driver,
                          virDomainObjPtr vm)
1261
{
1262 1263
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    qemuDomainObjPrivatePtr priv = vm->privateData;
M
Martin Kletzander 已提交
1264
    char *domname = virDomainObjGetShortName(vm);
1265
    int ret = -1;
1266

M
Martin Kletzander 已提交
1267 1268 1269
    if (!domname)
        goto cleanup;

1270
    if (!priv->libDir &&
M
Martin Kletzander 已提交
1271
        virAsprintf(&priv->libDir, "%s/domain-%s", cfg->libDir, domname) < 0)
1272
        goto cleanup;
1273

1274
    if (!priv->channelTargetDir &&
M
Martin Kletzander 已提交
1275 1276
        virAsprintf(&priv->channelTargetDir, "%s/domain-%s",
                    cfg->channelTargetDir, domname) < 0)
1277
        goto cleanup;
1278

1279 1280 1281
    ret = 0;
 cleanup:
    virObjectUnref(cfg);
M
Martin Kletzander 已提交
1282
    VIR_FREE(domname);
1283
    return ret;
1284 1285 1286
}


1287 1288 1289 1290 1291 1292 1293 1294 1295 1296
void
qemuDomainClearPrivatePaths(virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;

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


1297 1298
static void *
qemuDomainObjPrivateAlloc(void)
1299 1300 1301 1302 1303 1304
{
    qemuDomainObjPrivatePtr priv;

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

1305 1306 1307
    if (qemuDomainObjInitJob(priv) < 0) {
        virReportSystemError(errno, "%s",
                             _("Unable to init qemu driver mutexes"));
1308
        goto error;
1309
    }
1310

1311
    if (!(priv->devs = virChrdevAlloc()))
1312 1313
        goto error;

1314
    priv->migMaxBandwidth = QEMU_DOMAIN_MIG_BANDWIDTH_MAX;
1315

1316
    return priv;
1317

1318
 error:
1319 1320
    VIR_FREE(priv);
    return NULL;
1321 1322
}

1323 1324
static void
qemuDomainObjPrivateFree(void *data)
1325 1326 1327
{
    qemuDomainObjPrivatePtr priv = data;

1328
    virObjectUnref(priv->qemuCaps);
1329

1330
    virCgroupFree(&priv->cgroup);
1331
    virDomainPCIAddressSetFree(priv->pciaddrs);
J
Ján Tomko 已提交
1332
    virDomainUSBAddressSetFree(priv->usbaddrs);
1333
    virDomainChrSourceDefFree(priv->monConfig);
1334
    qemuDomainObjFreeJob(priv);
1335
    VIR_FREE(priv->lockState);
J
Jiri Denemark 已提交
1336
    VIR_FREE(priv->origname);
1337

1338
    virStringFreeList(priv->qemuDevices);
1339
    virChrdevFree(priv->devs);
1340

1341 1342
    /* This should never be non-NULL if we get here, but just in case... */
    if (priv->mon) {
1343
        VIR_ERROR(_("Unexpected QEMU monitor still active during domain deletion"));
1344 1345
        qemuMonitorClose(priv->mon);
    }
D
Daniel P. Berrange 已提交
1346 1347 1348 1349
    if (priv->agent) {
        VIR_ERROR(_("Unexpected QEMU agent still active during domain deletion"));
        qemuAgentClose(priv->agent);
    }
1350
    VIR_FREE(priv->cleanupCallbacks);
1351
    virBitmapFree(priv->autoNodeset);
1352
    virBitmapFree(priv->autoCpuset);
1353 1354 1355

    VIR_FREE(priv->libDir);
    VIR_FREE(priv->channelTargetDir);
1356
    qemuDomainMasterKeyFree(priv);
1357

1358 1359 1360 1361
    VIR_FREE(priv);
}


1362 1363
static void
qemuDomainObjPrivateXMLFormatVcpus(virBufferPtr buf,
1364
                                   virDomainDefPtr def)
1365 1366
{
    size_t i;
1367 1368 1369
    size_t maxvcpus = virDomainDefGetVcpusMax(def);
    virDomainVcpuDefPtr vcpu;
    pid_t tid;
1370 1371 1372 1373

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

1374 1375 1376 1377 1378 1379 1380 1381 1382
    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);
    }
1383 1384 1385 1386 1387 1388

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


1389
static int
1390 1391
qemuDomainObjPrivateXMLFormat(virBufferPtr buf,
                              virDomainObjPtr vm)
1392
{
1393
    qemuDomainObjPrivatePtr priv = vm->privateData;
1394
    const char *monitorpath;
1395
    qemuDomainJob job;
1396 1397 1398

    /* priv->monitor_chr is set only for qemu */
    if (priv->monConfig) {
1399
        switch (priv->monConfig->type) {
1400
        case VIR_DOMAIN_CHR_TYPE_UNIX:
1401
            monitorpath = priv->monConfig->data.nix.path;
1402 1403 1404
            break;
        default:
        case VIR_DOMAIN_CHR_TYPE_PTY:
1405
            monitorpath = priv->monConfig->data.file.path;
1406 1407 1408
            break;
        }

1409
        virBufferEscapeString(buf, "<monitor path='%s'", monitorpath);
1410 1411
        if (priv->monJSON)
            virBufferAddLit(buf, " json='1'");
1412
        virBufferAsprintf(buf, " type='%s'/>\n",
1413
                          virDomainChrTypeToString(priv->monConfig->type));
1414 1415
    }

1416
    qemuDomainObjPrivateXMLFormatVcpus(buf, vm->def);
1417

1418
    if (priv->qemuCaps) {
1419
        size_t i;
1420 1421
        virBufferAddLit(buf, "<qemuCaps>\n");
        virBufferAdjustIndent(buf, 2);
1422
        for (i = 0; i < QEMU_CAPS_LAST; i++) {
1423
            if (virQEMUCapsGet(priv->qemuCaps, i)) {
1424
                virBufferAsprintf(buf, "<flag name='%s'/>\n",
1425
                                  virQEMUCapsTypeToString(i));
1426 1427
            }
        }
1428 1429
        virBufferAdjustIndent(buf, -2);
        virBufferAddLit(buf, "</qemuCaps>\n");
1430 1431
    }

1432
    if (priv->lockState)
1433
        virBufferAsprintf(buf, "<lockstate>%s</lockstate>\n", priv->lockState);
1434

1435 1436 1437 1438
    job = priv->job.active;
    if (!qemuDomainTrackJob(job))
        priv->job.active = QEMU_JOB_NONE;

1439
    if (priv->job.active || priv->job.asyncJob) {
1440
        virBufferAsprintf(buf, "<job type='%s' async='%s'",
1441 1442
                          qemuDomainJobTypeToString(priv->job.active),
                          qemuDomainAsyncJobTypeToString(priv->job.asyncJob));
J
Jiri Denemark 已提交
1443 1444 1445 1446 1447
        if (priv->job.phase) {
            virBufferAsprintf(buf, " phase='%s'",
                              qemuDomainAsyncJobPhaseToString(
                                    priv->job.asyncJob, priv->job.phase));
        }
1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468
        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");
        }
1469
    }
1470
    priv->job.active = job;
1471

1472
    if (priv->fakeReboot)
1473
        virBufferAddLit(buf, "<fakereboot/>\n");
1474

1475 1476
    if (priv->qemuDevices && *priv->qemuDevices) {
        char **tmp = priv->qemuDevices;
1477 1478
        virBufferAddLit(buf, "<devices>\n");
        virBufferAdjustIndent(buf, 2);
1479
        while (*tmp) {
1480
            virBufferAsprintf(buf, "<device alias='%s'/>\n", *tmp);
1481 1482
            tmp++;
        }
1483 1484
        virBufferAdjustIndent(buf, -2);
        virBufferAddLit(buf, "</devices>\n");
1485 1486
    }

1487 1488 1489 1490 1491 1492 1493 1494 1495 1496
    if (priv->autoNodeset) {
        char *nodeset = virBitmapFormat(priv->autoNodeset);

        if (!nodeset)
            return -1;

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

1497 1498 1499 1500 1501
    /* Various per-domain paths */
    virBufferEscapeString(buf, "<libDir path='%s'/>\n", priv->libDir);
    virBufferEscapeString(buf, "<channelTargetDir path='%s'/>\n",
                          priv->channelTargetDir);

1502 1503 1504
    return 0;
}

1505 1506 1507 1508

static int
qemuDomainObjPrivateXMLParseVcpu(xmlNodePtr node,
                                 unsigned int idx,
1509
                                 virDomainDefPtr def)
1510
{
1511
    virDomainVcpuDefPtr vcpu;
1512
    char *idstr;
1513
    char *pidstr;
1514
    unsigned int tmp;
1515 1516
    int ret = -1;

1517 1518
    idstr = virXMLPropString(node, "id");

1519 1520
    if (idstr &&
        (virStrToLong_uip(idstr, NULL, 10, &idx) < 0)) {
1521
        virReportError(VIR_ERR_INTERNAL_ERROR,
1522 1523 1524 1525 1526 1527
                       _("cannot parse vcpu index '%s'"), idstr);
        goto cleanup;
    }
    if (!(vcpu = virDomainDefGetVcpu(def, idx))) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("invalid vcpu index '%u'"), idx);
1528
        goto cleanup;
1529 1530
    }

1531 1532 1533
    if (!(pidstr = virXMLPropString(node, "pid")))
        goto cleanup;

1534
    if (virStrToLong_uip(pidstr, NULL, 10, &tmp) < 0)
1535 1536
        goto cleanup;

1537 1538
    QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->tid = tmp;

1539 1540 1541
    ret = 0;

 cleanup:
1542
    VIR_FREE(idstr);
1543 1544 1545 1546 1547
    VIR_FREE(pidstr);
    return ret;
}


1548
static int
1549
qemuDomainObjPrivateXMLParse(xmlXPathContextPtr ctxt,
1550
                             virDomainObjPtr vm,
1551
                             virDomainDefParserConfigPtr config)
1552
{
1553
    qemuDomainObjPrivatePtr priv = vm->privateData;
1554
    virQEMUDriverPtr driver = config->priv;
1555
    char *monitorpath;
1556
    char *tmp = NULL;
1557 1558
    int n;
    size_t i;
1559
    xmlNodePtr *nodes = NULL;
1560
    virQEMUCapsPtr qemuCaps = NULL;
1561
    virCapsPtr caps = NULL;
1562

1563
    if (VIR_ALLOC(priv->monConfig) < 0)
1564 1565 1566 1567
        goto error;

    if (!(monitorpath =
          virXPathString("string(./monitor[1]/@path)", ctxt))) {
1568 1569
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("no monitor path"));
1570 1571 1572 1573 1574
        goto error;
    }

    tmp = virXPathString("string(./monitor[1]/@type)", ctxt);
    if (tmp)
1575
        priv->monConfig->type = virDomainChrTypeFromString(tmp);
1576
    else
1577
        priv->monConfig->type = VIR_DOMAIN_CHR_TYPE_PTY;
1578 1579
    VIR_FREE(tmp);

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

1583
    switch (priv->monConfig->type) {
1584
    case VIR_DOMAIN_CHR_TYPE_PTY:
1585
        priv->monConfig->data.file.path = monitorpath;
1586 1587
        break;
    case VIR_DOMAIN_CHR_TYPE_UNIX:
1588
        priv->monConfig->data.nix.path = monitorpath;
1589 1590 1591
        break;
    default:
        VIR_FREE(monitorpath);
1592 1593 1594
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("unsupported monitor type '%s'"),
                       virDomainChrTypeToString(priv->monConfig->type));
1595 1596 1597
        goto error;
    }

1598
    if ((n = virXPathNodeSet("./vcpus/vcpu", ctxt, &nodes)) < 0)
1599 1600
        goto error;

1601
    for (i = 0; i < n; i++) {
1602
        if (qemuDomainObjPrivateXMLParseVcpu(nodes[i], i, vm->def) < 0)
1603
            goto error;
1604
    }
1605
    VIR_FREE(nodes);
1606

1607
    if ((n = virXPathNodeSet("./qemuCaps/flag", ctxt, &nodes)) < 0) {
1608 1609
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("failed to parse qemu capabilities flags"));
1610 1611 1612
        goto error;
    }
    if (n > 0) {
1613
        if (!(qemuCaps = virQEMUCapsNew()))
1614 1615
            goto error;

1616
        for (i = 0; i < n; i++) {
1617 1618
            char *str = virXMLPropString(nodes[i], "name");
            if (str) {
1619
                int flag = virQEMUCapsTypeFromString(str);
1620
                if (flag < 0) {
1621 1622
                    virReportError(VIR_ERR_INTERNAL_ERROR,
                                   _("Unknown qemu capabilities flag %s"), str);
1623
                    VIR_FREE(str);
1624 1625
                    goto error;
                }
1626
                VIR_FREE(str);
1627
                virQEMUCapsSet(qemuCaps, flag);
1628 1629 1630
            }
        }

1631
        priv->qemuCaps = qemuCaps;
1632
        qemuCaps = NULL;
1633 1634 1635
    }
    VIR_FREE(nodes);

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

1638 1639 1640 1641
    if ((tmp = virXPathString("string(./job[1]/@type)", ctxt))) {
        int type;

        if ((type = qemuDomainJobTypeFromString(tmp)) < 0) {
1642 1643
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Unknown job type %s"), tmp);
1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654
            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) {
1655 1656
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("Unknown async job type %s"), tmp);
1657 1658 1659 1660 1661
            VIR_FREE(tmp);
            goto error;
        }
        VIR_FREE(tmp);
        priv->job.asyncJob = async;
J
Jiri Denemark 已提交
1662 1663 1664 1665

        if ((tmp = virXPathString("string(./job[1]/@phase)", ctxt))) {
            priv->job.phase = qemuDomainAsyncJobPhaseFromString(async, tmp);
            if (priv->job.phase < 0) {
1666 1667
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("Unknown job phase %s"), tmp);
J
Jiri Denemark 已提交
1668 1669 1670 1671 1672
                VIR_FREE(tmp);
                goto error;
            }
            VIR_FREE(tmp);
        }
1673 1674
    }

1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697
    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);

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

1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720
    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);

1721 1722 1723 1724
    if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
        goto error;

    if ((tmp = virXPathString("string(./numad/@nodeset)", ctxt))) {
1725
        if (virBitmapParse(tmp, &priv->autoNodeset,
1726 1727 1728 1729 1730 1731 1732 1733 1734 1735
                           caps->host.nnumaCell_max) < 0)
            goto error;

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

1736 1737 1738 1739 1740 1741 1742 1743 1744
    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;

1745 1746
    return 0;

1747
 error:
1748
    virDomainChrSourceDefFree(priv->monConfig);
1749 1750
    priv->monConfig = NULL;
    VIR_FREE(nodes);
1751
    VIR_FREE(tmp);
1752 1753
    virStringFreeList(priv->qemuDevices);
    priv->qemuDevices = NULL;
1754
    virObjectUnref(qemuCaps);
1755
    virObjectUnref(caps);
1756 1757 1758 1759
    return -1;
}


1760 1761 1762
virDomainXMLPrivateDataCallbacks virQEMUDriverPrivateDataCallbacks = {
    .alloc = qemuDomainObjPrivateAlloc,
    .free = qemuDomainObjPrivateFree,
1763
    .diskNew = qemuDomainDiskPrivateNew,
1764
    .vcpuNew = qemuDomainVcpuPrivateNew,
1765
    .hostdevNew = qemuDomainHostdevPrivateNew,
1766 1767 1768 1769 1770
    .parse = qemuDomainObjPrivateXMLParse,
    .format = qemuDomainObjPrivateXMLFormat,
};


1771 1772 1773 1774 1775
static void
qemuDomainDefNamespaceFree(void *nsdata)
{
    qemuDomainCmdlineDefPtr cmd = nsdata;

1776
    qemuDomainCmdlineDefFree(cmd);
1777 1778 1779
}

static int
P
Philipp Hahn 已提交
1780 1781
qemuDomainDefNamespaceParse(xmlDocPtr xml ATTRIBUTE_UNUSED,
                            xmlNodePtr root ATTRIBUTE_UNUSED,
1782 1783 1784 1785
                            xmlXPathContextPtr ctxt,
                            void **data)
{
    qemuDomainCmdlineDefPtr cmd = NULL;
P
Philipp Hahn 已提交
1786
    bool uses_qemu_ns = false;
1787
    xmlNodePtr *nodes = NULL;
1788 1789
    int n;
    size_t i;
1790

P
Philipp Hahn 已提交
1791
    if (xmlXPathRegisterNs(ctxt, BAD_CAST "qemu", BAD_CAST QEMU_NAMESPACE_HREF) < 0) {
1792 1793 1794
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Failed to register xml namespace '%s'"),
                       QEMU_NAMESPACE_HREF);
1795 1796 1797
        return -1;
    }

1798
    if (VIR_ALLOC(cmd) < 0)
1799 1800 1801 1802 1803 1804
        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 已提交
1805
    uses_qemu_ns |= n > 0;
1806 1807

    if (n && VIR_ALLOC_N(cmd->args, n) < 0)
1808
        goto error;
1809 1810 1811 1812

    for (i = 0; i < n; i++) {
        cmd->args[cmd->num_args] = virXMLPropString(nodes[i], "value");
        if (cmd->args[cmd->num_args] == NULL) {
1813 1814
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("No qemu command-line argument specified"));
1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825
            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 已提交
1826
    uses_qemu_ns |= n > 0;
1827 1828

    if (n && VIR_ALLOC_N(cmd->env_name, n) < 0)
1829
        goto error;
1830 1831

    if (n && VIR_ALLOC_N(cmd->env_value, n) < 0)
1832
        goto error;
1833 1834 1835 1836 1837 1838

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

        tmp = virXMLPropString(nodes[i], "name");
        if (tmp == NULL) {
1839 1840
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("No qemu environment name specified"));
1841 1842 1843
            goto error;
        }
        if (tmp[0] == '\0') {
1844 1845
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("Empty qemu environment name specified"));
1846 1847 1848
            goto error;
        }
        if (!c_isalpha(tmp[0]) && tmp[0] != '_') {
1849 1850
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("Invalid environment name, it must begin with a letter or underscore"));
1851 1852 1853
            goto error;
        }
        if (strspn(tmp, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_") != strlen(tmp)) {
1854 1855
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           "%s", _("Invalid environment name, it must contain only alphanumerics and underscore"));
1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867
            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 已提交
1868 1869 1870 1871
    if (uses_qemu_ns)
        *data = cmd;
    else
        VIR_FREE(cmd);
1872 1873 1874

    return 0;

1875
 error:
1876 1877 1878 1879 1880 1881 1882 1883 1884 1885
    VIR_FREE(nodes);
    qemuDomainDefNamespaceFree(cmd);
    return -1;
}

static int
qemuDomainDefNamespaceFormatXML(virBufferPtr buf,
                                void *nsdata)
{
    qemuDomainCmdlineDefPtr cmd = nsdata;
1886
    size_t i;
1887 1888 1889 1890

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

1891 1892 1893
    virBufferAddLit(buf, "<qemu:commandline>\n");
    virBufferAdjustIndent(buf, 2);

1894
    for (i = 0; i < cmd->num_args; i++)
1895
        virBufferEscapeString(buf, "<qemu:arg value='%s'/>\n",
1896 1897
                              cmd->args[i]);
    for (i = 0; i < cmd->num_env; i++) {
1898
        virBufferAsprintf(buf, "<qemu:env name='%s'", cmd->env_name[i]);
1899 1900 1901 1902 1903
        if (cmd->env_value[i])
            virBufferEscapeString(buf, " value='%s'", cmd->env_value[i]);
        virBufferAddLit(buf, "/>\n");
    }

1904 1905
    virBufferAdjustIndent(buf, -2);
    virBufferAddLit(buf, "</qemu:commandline>\n");
1906 1907 1908 1909 1910 1911 1912 1913 1914 1915
    return 0;
}

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


1916 1917 1918 1919 1920 1921
virDomainXMLNamespace virQEMUDriverDomainXMLNamespace = {
    .parse = qemuDomainDefNamespaceParse,
    .free = qemuDomainDefNamespaceFree,
    .format = qemuDomainDefNamespaceFormatXML,
    .href = qemuDomainDefNamespaceHref,
};
1922

1923

P
Pavel Hrdina 已提交
1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942
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;
}


1943
static int
1944 1945
qemuDomainDefAddDefaultDevices(virDomainDefPtr def,
                               virQEMUCapsPtr qemuCaps)
1946
{
1947
    bool addDefaultUSB = true;
1948
    int usbModel = -1; /* "default for machinetype" */
1949
    int pciRoot;       /* index within def->controllers */
1950
    bool addImplicitSATA = false;
1951
    bool addPCIRoot = false;
L
Laine Stump 已提交
1952
    bool addPCIeRoot = false;
1953
    bool addDefaultMemballoon = true;
1954 1955
    bool addDefaultUSBKBD = false;
    bool addDefaultUSBMouse = false;
1956
    bool addPanicDevice = false;
1957
    int ret = -1;
1958

P
Pavel Hrdina 已提交
1959 1960 1961 1962
    /* add implicit input devices */
    if (qemuDomainDefAddImplicitInputDevice(def) < 0)
        goto cleanup;

1963 1964 1965 1966
    /* 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 已提交
1967
        if (STREQ(def->os.machine, "isapc")) {
1968
            addDefaultUSB = false;
1969
            break;
1970
        }
1971
        if (qemuDomainMachineIsQ35(def)) {
1972 1973
            addPCIeRoot = true;
            addImplicitSATA = true;
1974 1975 1976 1977 1978 1979 1980 1981

            /* add a USB2 controller set, but only if the
             * ich9-usb-ehci1 device is supported
             */
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_ICH9_USB_EHCI1))
                usbModel = VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_EHCI1;
            else
                addDefaultUSB = false;
1982
            break;
L
Laine Stump 已提交
1983
        }
1984 1985
        if (qemuDomainMachineIsI440FX(def))
            addPCIRoot = true;
1986 1987
        break;

1988
    case VIR_ARCH_ARMV7L:
1989
    case VIR_ARCH_AARCH64:
1990 1991
        addDefaultUSB = false;
        addDefaultMemballoon = false;
J
Ján Tomko 已提交
1992
        if (qemuDomainMachineIsVirt(def))
1993 1994
            addPCIeRoot = virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_GPEX);
        break;
1995

1996
    case VIR_ARCH_PPC64:
1997
    case VIR_ARCH_PPC64LE:
1998 1999 2000
        addPCIRoot = true;
        addDefaultUSBKBD = true;
        addDefaultUSBMouse = true;
2001 2002 2003
        /* For pSeries guests, the firmware provides the same
         * functionality as the pvpanic device, so automatically
         * add the definition if not already present */
2004
        if (qemuDomainMachineIsPSeries(def))
2005
            addPanicDevice = true;
2006 2007
        break;

2008 2009 2010 2011 2012 2013 2014
    case VIR_ARCH_ALPHA:
    case VIR_ARCH_PPC:
    case VIR_ARCH_PPCEMB:
    case VIR_ARCH_SH4:
    case VIR_ARCH_SH4EB:
        addPCIRoot = true;
        break;
2015

2016 2017 2018
    case VIR_ARCH_S390:
    case VIR_ARCH_S390X:
        addDefaultUSB = false;
2019
        addPanicDevice = true;
2020
        break;
2021 2022 2023 2024 2025 2026

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

2027 2028 2029 2030
    default:
        break;
    }

2031
    if (addDefaultUSB &&
2032 2033
        virDomainControllerFind(def, VIR_DOMAIN_CONTROLLER_TYPE_USB, 0) < 0 &&
        virDomainDefAddUSBController(def, 0, usbModel) < 0)
2034
        goto cleanup;
2035

2036 2037 2038
    if (addImplicitSATA &&
        virDomainDefMaybeAddController(
            def, VIR_DOMAIN_CONTROLLER_TYPE_SATA, 0, -1) < 0)
2039
        goto cleanup;
2040

2041 2042
    pciRoot = virDomainControllerFind(def, VIR_DOMAIN_CONTROLLER_TYPE_PCI, 0);

2043 2044 2045
    /* NB: any machine that sets addPCIRoot to true must also return
     * true from the function qemuDomainSupportsPCI().
     */
2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060
    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;
        }
    }
2061

2062 2063 2064
    /* 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
2065 2066 2067
     *
     * NB: any machine that sets addPCIeRoot to true must also return
     * true from the function qemuDomainSupportsPCI().
2068 2069
     */
    if (addPCIeRoot) {
2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082
        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;
        }
2083
        /* Add a dmi-to-pci-bridge bridge if there are no PCI controllers
2084
         * other than the pcie-root. This is so that there will be hot-pluggable
2085 2086 2087 2088
         * PCI slots available.
         *
         * We skip this step for aarch64 mach-virt guests, where we want to
         * be able to have a pure virtio-mmio topology
2089 2090
         */
        if (virDomainControllerFind(def, VIR_DOMAIN_CONTROLLER_TYPE_PCI, 1) < 0 &&
2091
            !qemuDomainMachineIsVirt(def) &&
2092
            !virDomainDefAddController(def, VIR_DOMAIN_CONTROLLER_TYPE_PCI, 1,
2093
                                       VIR_DOMAIN_CONTROLLER_MODEL_DMI_TO_PCI_BRIDGE))
2094
            goto cleanup;
2095
    }
2096

2097
    if (addDefaultMemballoon && !def->memballoon) {
2098 2099
        virDomainMemballoonDefPtr memballoon;
        if (VIR_ALLOC(memballoon) < 0)
2100
            goto cleanup;
2101 2102 2103 2104 2105

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

2106 2107 2108 2109 2110
    if (addDefaultUSBKBD &&
        def->ngraphics > 0 &&
        virDomainDefMaybeAddInput(def,
                                  VIR_DOMAIN_INPUT_TYPE_KBD,
                                  VIR_DOMAIN_INPUT_BUS_USB) < 0)
2111
        goto cleanup;
2112 2113 2114 2115 2116 2117

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

D
Dmitry Andreev 已提交
2120 2121 2122 2123
    if (addPanicDevice) {
        size_t j;
        for (j = 0; j < def->npanics; j++) {
            if (def->panics[j]->model == VIR_DOMAIN_PANIC_MODEL_DEFAULT ||
2124 2125 2126 2127
                (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 已提交
2128 2129
                break;
        }
2130

D
Dmitry Andreev 已提交
2131 2132 2133 2134 2135 2136 2137 2138 2139
        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;
            }
        }
2140 2141
    }

2142 2143 2144 2145 2146 2147
    ret = 0;
 cleanup:
    return ret;
}


A
Andrea Bolognani 已提交
2148 2149 2150
/**
 * qemuDomainDefEnableDefaultFeatures:
 * @def: domain definition
2151
 * @qemuCaps: QEMU capabilities
A
Andrea Bolognani 已提交
2152 2153 2154 2155 2156
 *
 * Make sure that features that should be enabled by default are actually
 * enabled and configure default values related to those features.
 */
static void
2157 2158
qemuDomainDefEnableDefaultFeatures(virDomainDefPtr def,
                                   virQEMUCapsPtr qemuCaps)
A
Andrea Bolognani 已提交
2159
{
2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179
    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;
            }
2180 2181
        }

2182 2183 2184
        /* 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;
2185 2186
    }

2187
    /* Use the default GIC version if no version was specified */
A
Andrea Bolognani 已提交
2188 2189
    if (def->features[VIR_DOMAIN_FEATURE_GIC] == VIR_TRISTATE_SWITCH_ON &&
        def->gic_version == VIR_GIC_VERSION_NONE)
2190
        def->gic_version = VIR_GIC_VERSION_DEFAULT;
A
Andrea Bolognani 已提交
2191 2192 2193
}


2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213
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;
}


2214
static int
2215 2216 2217 2218 2219
qemuDomainRecheckInternalPaths(virDomainDefPtr def,
                               virQEMUDriverConfigPtr cfg,
                               unsigned int flags)
{
    size_t i = 0;
2220
    size_t j = 0;
2221 2222 2223 2224

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

2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242
        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;
                }
2243
            }
2244 2245
        }
    }
2246 2247

    return 0;
2248 2249 2250
}


2251 2252 2253
static int
qemuDomainDefPostParse(virDomainDefPtr def,
                       virCapsPtr caps,
2254
                       unsigned int parseFlags,
2255 2256 2257
                       void *opaque)
{
    virQEMUDriverPtr driver = opaque;
2258
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
2259 2260 2261 2262 2263 2264
    virQEMUCapsPtr qemuCaps = NULL;
    int ret = -1;

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

2268 2269 2270
    if (!def->os.machine) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("missing machine type"));
2271
        goto cleanup;
2272 2273
    }

2274 2275 2276 2277 2278 2279 2280 2281 2282
    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;
    }

2283 2284 2285
    /* check for emulator and create a default one if needed */
    if (!def->emulator &&
        !(def->emulator = virDomainDefGetDefaultEmulator(def, caps)))
2286
        goto cleanup;
2287

2288 2289 2290
    if (!(qemuCaps = virQEMUCapsCacheLookup(driver->qemuCapsCache,
                                            def->emulator)))
        goto cleanup;
2291 2292 2293 2294

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

2295 2296 2297
    if (qemuCanonicalizeMachine(def, qemuCaps) < 0)
        goto cleanup;

2298
    qemuDomainDefEnableDefaultFeatures(def, qemuCaps);
A
Andrea Bolognani 已提交
2299

2300 2301
    if (qemuDomainRecheckInternalPaths(def, cfg, parseFlags) < 0)
        goto cleanup;
2302

2303 2304 2305
    if (virSecurityManagerVerify(driver->securityManager, def) < 0)
        goto cleanup;

2306 2307 2308
    ret = 0;
 cleanup:
    virObjectUnref(qemuCaps);
2309
    virObjectUnref(cfg);
2310
    return ret;
2311 2312
}

2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328

static int
qemuDomainDefValidate(const virDomainDef *def,
                      virCapsPtr caps ATTRIBUTE_UNUSED,
                      void *opaque ATTRIBUTE_UNUSED)
{
    if (def->mem.min_guarantee) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("Parameter 'min_guarantee' not supported by QEMU."));
        return -1;
    }

    return 0;
}


2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356
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;
        }
    }

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


2357
static const char *
2358 2359
qemuDomainDefaultNetModel(const virDomainDef *def,
                          virQEMUCapsPtr qemuCaps)
2360
{
2361
    if (ARCH_IS_S390(def->os.arch))
2362 2363
        return "virtio";

2364 2365
    if (def->os.arch == VIR_ARCH_ARMV7L ||
        def->os.arch == VIR_ARCH_AARCH64) {
2366 2367 2368
        if (STREQ(def->os.machine, "versatilepb"))
            return "smc91c111";

J
Ján Tomko 已提交
2369
        if (qemuDomainMachineIsVirt(def))
2370 2371
            return "virtio";

2372 2373 2374 2375 2376
        /* Incomplete. vexpress (and a few others) use this, but not all
         * arm boards */
        return "lan9118";
    }

2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388
    /* 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 */
2389 2390
    return "rtl8139";
}
2391

2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414

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

    virObjectUnref(cfg);
}


2415 2416
static int
qemuDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
2417
                             const virDomainDef *def,
2418
                             virCapsPtr caps ATTRIBUTE_UNUSED,
2419
                             unsigned int parseFlags,
2420
                             void *opaque)
2421
{
2422
    virQEMUDriverPtr driver = opaque;
2423
    virQEMUCapsPtr qemuCaps = NULL;
2424
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
2425
    int ret = -1;
2426

P
Pavel Fedin 已提交
2427
    qemuCaps = virQEMUCapsCacheLookup(driver->qemuCapsCache, def->emulator);
2428

2429
    if (dev->type == VIR_DOMAIN_DEVICE_NET &&
2430 2431
        dev->data.net->type != VIR_DOMAIN_NET_TYPE_HOSTDEV &&
        !dev->data.net->model) {
2432
        if (VIR_STRDUP(dev->data.net->model,
2433
                       qemuDomainDefaultNetModel(def, qemuCaps)) < 0)
2434
            goto cleanup;
2435
    }
2436

2437 2438 2439 2440
    /* set default disk types and drivers */
    if (dev->type == VIR_DOMAIN_DEVICE_DISK) {
        virDomainDiskDefPtr disk = dev->data.disk;

2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468
        /* 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;
2469 2470 2471
        }
    }

2472 2473 2474 2475
    /* 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 &&
2476
        ARCH_IS_S390(def->os.arch))
2477 2478
        dev->data.chr->targetType = VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO;

2479 2480 2481 2482 2483
    /* 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 &&
2484
        ARCH_IS_S390(def->os.arch))
2485 2486
        dev->data.controller->model = VIR_DOMAIN_CONTROLLER_MODEL_USB_NONE;

2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499
    /* 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;
    }


2500 2501 2502 2503 2504 2505 2506
    /* 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;

2507 2508
    /* clear auto generated unix socket path for inactive definitions */
    if ((parseFlags & VIR_DOMAIN_DEF_PARSE_INACTIVE) &&
2509 2510
        dev->type == VIR_DOMAIN_DEVICE_CHR)
        qemuDomainChrDefDropDefaultPath(dev->data.chr, driver);
2511

2512 2513 2514 2515 2516 2517 2518 2519 2520 2521
    /* 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;
    }

2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536
    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 {
2537
            dev->data.video->vgamem = QEMU_QXL_VGAMEM_DEFAULT;
2538 2539 2540
        }
    }

2541 2542
    if (dev->type == VIR_DOMAIN_DEVICE_PANIC &&
        dev->data.panic->model == VIR_DOMAIN_PANIC_MODEL_DEFAULT) {
2543
        if (qemuDomainMachineIsPSeries(def))
2544
            dev->data.panic->model = VIR_DOMAIN_PANIC_MODEL_PSERIES;
2545 2546
        else if (ARCH_IS_S390(def->os.arch))
            dev->data.panic->model = VIR_DOMAIN_PANIC_MODEL_S390;
2547 2548 2549 2550
        else
            dev->data.panic->model = VIR_DOMAIN_PANIC_MODEL_ISA;
    }

2551 2552 2553 2554

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

2555 2556 2557
        if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI) {
            if (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCI_EXPANDER_BUS &&
                !qemuDomainMachineIsI440FX(def)) {
2558 2559 2560 2561 2562
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("pci-expander-bus controllers are only supported "
                                 "on 440fx-based machinetypes"));
                goto cleanup;
            }
2563 2564 2565 2566 2567 2568 2569
            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;
            }
2570 2571 2572 2573 2574 2575

            /* 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.
             */
2576 2577 2578
            if ((cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCI_EXPANDER_BUS ||
                 cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCIE_EXPANDER_BUS) &&
                (int) virDomainNumaGetNodeCount(def->numa)
2579 2580
                <= cont->opts.pciopts.numaNode) {
                virReportError(VIR_ERR_XML_ERROR,
2581
                               _("%s with index %d is "
2582 2583 2584
                                 "configured for a NUMA node (%d) "
                                 "not present in the domain's "
                                 "<cpu><numa> array (%zu)"),
2585
                               virDomainControllerModelPCITypeToString(cont->model),
2586 2587 2588 2589 2590 2591 2592
                               cont->idx, cont->opts.pciopts.numaNode,
                               virDomainNumaGetNodeCount(def->numa));
                goto cleanup;
            }
        }
    }

2593 2594
    ret = 0;

2595
 cleanup:
2596
    virObjectUnref(qemuCaps);
2597 2598
    virObjectUnref(cfg);
    return ret;
2599 2600 2601
}


2602 2603 2604 2605 2606 2607 2608 2609 2610
static int
qemuDomainDefAssignAddresses(virDomainDef *def,
                             virCapsPtr caps ATTRIBUTE_UNUSED,
                             unsigned int parseFlags ATTRIBUTE_UNUSED,
                             void *opaque)
{
    virQEMUDriverPtr driver = opaque;
    virQEMUCapsPtr qemuCaps = NULL;
    int ret = -1;
2611
    bool newDomain = parseFlags & VIR_DOMAIN_DEF_PARSE_ABI_UPDATE;
2612 2613 2614 2615 2616

    if (!(qemuCaps = virQEMUCapsCacheLookup(driver->qemuCapsCache,
                                            def->emulator)))
        goto cleanup;

2617
    if (qemuDomainAssignAddresses(def, qemuCaps, NULL, newDomain) < 0)
2618 2619 2620 2621 2622 2623 2624 2625 2626
        goto cleanup;

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


2627 2628
virDomainDefParserConfig virQEMUDriverDomainDefParserConfig = {
    .devicesPostParseCallback = qemuDomainDeviceDefPostParse,
2629
    .domainPostParseCallback = qemuDomainDefPostParse,
2630
    .assignAddressesCallback = qemuDomainDefAssignAddresses,
2631
    .domainValidateCallback = qemuDomainDefValidate,
2632 2633
    .deviceValidateCallback = qemuDomainDeviceDefValidate,

2634 2635
    .features = VIR_DOMAIN_DEF_FEATURE_MEMORY_HOTPLUG |
                VIR_DOMAIN_DEF_FEATURE_OFFLINE_VCPUPIN
2636 2637 2638
};


2639
static void
2640
qemuDomainObjSaveJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
2641
{
2642 2643 2644
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);

    if (virDomainObjIsActive(obj)) {
2645
        if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, obj, driver->caps) < 0)
2646
            VIR_WARN("Failed to save status on vm %s", obj->def->name);
2647
    }
2648

2649
    virObjectUnref(cfg);
2650 2651
}

J
Jiri Denemark 已提交
2652
void
2653
qemuDomainObjSetJobPhase(virQEMUDriverPtr driver,
J
Jiri Denemark 已提交
2654 2655 2656 2657
                         virDomainObjPtr obj,
                         int phase)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
2658
    unsigned long long me = virThreadSelfID();
J
Jiri Denemark 已提交
2659 2660 2661 2662

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

2663 2664 2665 2666 2667
    VIR_DEBUG("Setting '%s' phase to '%s'",
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
              qemuDomainAsyncJobPhaseToString(priv->job.asyncJob, phase));

    if (priv->job.asyncOwner && me != priv->job.asyncOwner) {
2668
        VIR_WARN("'%s' async job is owned by thread %llu",
2669 2670 2671 2672
                 qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
                 priv->job.asyncOwner);
    }

J
Jiri Denemark 已提交
2673
    priv->job.phase = phase;
2674
    priv->job.asyncOwner = me;
J
Jiri Denemark 已提交
2675 2676 2677
    qemuDomainObjSaveJob(driver, obj);
}

2678
void
2679 2680
qemuDomainObjSetAsyncJobMask(virDomainObjPtr obj,
                             unsigned long long allowedJobs)
2681 2682 2683
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

2684 2685 2686 2687 2688 2689 2690
    if (!priv->job.asyncJob)
        return;

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

void
2691
qemuDomainObjDiscardAsyncJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
2692 2693 2694 2695 2696 2697
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

    if (priv->job.active == QEMU_JOB_ASYNC_NESTED)
        qemuDomainObjResetJob(priv);
    qemuDomainObjResetAsyncJob(priv);
2698
    qemuDomainObjSaveJob(driver, obj);
2699 2700
}

2701 2702 2703 2704 2705 2706 2707 2708 2709
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()) {
2710
        VIR_WARN("'%s' async job is owned by thread %llu",
2711 2712 2713 2714 2715 2716
                 qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
                 priv->job.asyncOwner);
    }
    priv->job.asyncOwner = 0;
}

2717
static bool
2718
qemuDomainNestedJobAllowed(qemuDomainObjPrivatePtr priv, qemuDomainJob job)
2719 2720
{
    return !priv->job.asyncJob || (priv->job.mask & JOB_MASK(job)) != 0;
2721 2722
}

2723
bool
2724
qemuDomainJobAllowed(qemuDomainObjPrivatePtr priv, qemuDomainJob job)
2725 2726 2727 2728
{
    return !priv->job.active && qemuDomainNestedJobAllowed(priv, job);
}

2729 2730 2731
/* Give up waiting for mutex after 30 seconds */
#define QEMU_JOB_WAIT_TIME (1000ull * 30)

2732
/*
2733
 * obj must be locked before calling
2734
 */
2735
static int ATTRIBUTE_NONNULL(1)
2736
qemuDomainObjBeginJobInternal(virQEMUDriverPtr driver,
2737
                              virDomainObjPtr obj,
2738 2739
                              qemuDomainJob job,
                              qemuDomainAsyncJob asyncJob)
2740 2741
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
J
Jiri Denemark 已提交
2742
    unsigned long long now;
2743
    unsigned long long then;
2744
    bool nested = job == QEMU_JOB_ASYNC_NESTED;
J
Jiri Denemark 已提交
2745
    bool async = job == QEMU_JOB_ASYNC;
2746
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
2747
    const char *blocker = NULL;
J
Jiri Denemark 已提交
2748
    int ret = -1;
J
Jiri Denemark 已提交
2749 2750
    unsigned long long duration = 0;
    unsigned long long asyncDuration = 0;
J
Jiri Denemark 已提交
2751
    const char *jobStr;
2752

J
Jiri Denemark 已提交
2753 2754 2755 2756 2757 2758 2759 2760 2761
    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));
2762

2763 2764
    if (virTimeMillisNow(&now) < 0) {
        virObjectUnref(cfg);
2765
        return -1;
2766 2767
    }

2768
    priv->jobs_queued++;
J
Jiri Denemark 已提交
2769
    then = now + QEMU_JOB_WAIT_TIME;
2770

2771
 retry:
2772 2773
    if (cfg->maxQueuedJobs &&
        priv->jobs_queued > cfg->maxQueuedJobs) {
2774 2775 2776
        goto error;
    }

2777
    while (!nested && !qemuDomainNestedJobAllowed(priv, job)) {
2778
        VIR_DEBUG("Waiting for async job (vm=%p name=%s)", obj, obj->def->name);
2779
        if (virCondWaitUntil(&priv->job.asyncCond, &obj->parent.lock, then) < 0)
2780 2781 2782
            goto error;
    }

2783
    while (priv->job.active) {
2784
        VIR_DEBUG("Waiting for job (vm=%p name=%s)", obj, obj->def->name);
2785
        if (virCondWaitUntil(&priv->job.cond, &obj->parent.lock, then) < 0)
2786
            goto error;
2787
    }
2788 2789 2790

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

2794
    qemuDomainObjResetJob(priv);
2795

J
Jiri Denemark 已提交
2796 2797
    ignore_value(virTimeMillisNow(&now));

2798
    if (job != QEMU_JOB_ASYNC) {
2799
        VIR_DEBUG("Started job: %s (async=%s vm=%p name=%s)",
2800
                   qemuDomainJobTypeToString(job),
2801 2802
                  qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
                  obj, obj->def->name);
2803
        priv->job.active = job;
2804
        priv->job.owner = virThreadSelfID();
2805
        priv->job.ownerAPI = virThreadJobGet();
J
Jiri Denemark 已提交
2806
        priv->job.started = now;
2807
    } else {
2808 2809 2810
        VIR_DEBUG("Started async job: %s (vm=%p name=%s)",
                  qemuDomainAsyncJobTypeToString(asyncJob),
                  obj, obj->def->name);
2811
        qemuDomainObjResetAsyncJob(priv);
J
Jiri Denemark 已提交
2812 2813
        if (VIR_ALLOC(priv->job.current) < 0)
            goto cleanup;
2814
        priv->job.asyncJob = asyncJob;
2815
        priv->job.asyncOwner = virThreadSelfID();
2816
        priv->job.asyncOwnerAPI = virThreadJobGet();
J
Jiri Denemark 已提交
2817
        priv->job.asyncStarted = now;
J
Jiri Denemark 已提交
2818
        priv->job.current->started = now;
2819
    }
2820

2821 2822
    if (qemuDomainTrackJob(job))
        qemuDomainObjSaveJob(driver, obj);
2823

2824
    virObjectUnref(cfg);
2825
    return 0;
2826

2827
 error:
J
Jiri Denemark 已提交
2828 2829 2830 2831 2832 2833
    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;

2834
    VIR_WARN("Cannot start job (%s, %s) for domain %s; "
J
Jiri Denemark 已提交
2835 2836
             "current job is (%s, %s) owned by (%llu %s, %llu %s) "
             "for (%llus, %llus)",
2837 2838 2839 2840 2841
             qemuDomainJobTypeToString(job),
             qemuDomainAsyncJobTypeToString(asyncJob),
             obj->def->name,
             qemuDomainJobTypeToString(priv->job.active),
             qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
2842
             priv->job.owner, NULLSTR(priv->job.ownerAPI),
J
Jiri Denemark 已提交
2843 2844
             priv->job.asyncOwner, NULLSTR(priv->job.asyncOwnerAPI),
             duration / 1000, asyncDuration / 1000);
2845 2846 2847 2848 2849

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

2851 2852
    ret = -1;
    if (errno == ETIMEDOUT) {
2853 2854 2855 2856 2857 2858 2859 2860
        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"));
        }
2861 2862 2863
        ret = -2;
    } else if (cfg->maxQueuedJobs &&
               priv->jobs_queued > cfg->maxQueuedJobs) {
2864 2865 2866 2867 2868 2869 2870 2871 2872 2873
        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"));
        }
2874 2875
        ret = -2;
    } else {
2876
        virReportSystemError(errno, "%s", _("cannot acquire job mutex"));
2877
    }
J
Jiri Denemark 已提交
2878 2879

 cleanup:
2880
    priv->jobs_queued--;
2881
    virObjectUnref(cfg);
2882
    return ret;
2883 2884 2885
}

/*
2886
 * obj must be locked before calling
2887 2888 2889 2890
 *
 * This must be called by anything that will change the VM state
 * in any way, or anything that will use the QEMU monitor.
 *
2891
 * Successful calls must be followed by EndJob eventually
2892
 */
2893
int qemuDomainObjBeginJob(virQEMUDriverPtr driver,
2894
                          virDomainObjPtr obj,
2895
                          qemuDomainJob job)
2896
{
2897 2898 2899 2900 2901
    if (qemuDomainObjBeginJobInternal(driver, obj, job,
                                      QEMU_ASYNC_JOB_NONE) < 0)
        return -1;
    else
        return 0;
2902 2903
}

2904
int qemuDomainObjBeginAsyncJob(virQEMUDriverPtr driver,
2905
                               virDomainObjPtr obj,
2906
                               qemuDomainAsyncJob asyncJob)
2907
{
2908 2909 2910 2911 2912
    if (qemuDomainObjBeginJobInternal(driver, obj, QEMU_JOB_ASYNC,
                                      asyncJob) < 0)
        return -1;
    else
        return 0;
2913 2914
}

2915
int
2916 2917
qemuDomainObjBeginNestedJob(virQEMUDriverPtr driver,
                            virDomainObjPtr obj,
2918
                            qemuDomainAsyncJob asyncJob)
2919 2920 2921 2922 2923 2924 2925 2926 2927 2928
{
    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()) {
2929
        VIR_WARN("This thread doesn't seem to be the async job owner: %llu",
2930 2931 2932 2933 2934 2935 2936 2937
                 priv->job.asyncOwner);
    }

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

2938

2939
/*
2940
 * obj must be locked and have a reference before calling
2941 2942 2943 2944
 *
 * To be called after completing the work associated with the
 * earlier qemuDomainBeginJob() call
 */
2945 2946
void
qemuDomainObjEndJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
2947 2948
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
2949
    qemuDomainJob job = priv->job.active;
2950

2951 2952
    priv->jobs_queued--;

2953
    VIR_DEBUG("Stopping job: %s (async=%s vm=%p name=%s)",
2954
              qemuDomainJobTypeToString(job),
2955 2956
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
              obj, obj->def->name);
2957

2958
    qemuDomainObjResetJob(priv);
2959 2960
    if (qemuDomainTrackJob(job))
        qemuDomainObjSaveJob(driver, obj);
2961
    virCondSignal(&priv->job.cond);
2962 2963
}

2964
void
2965
qemuDomainObjEndAsyncJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
2966 2967
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
2968

2969 2970
    priv->jobs_queued--;

2971 2972 2973
    VIR_DEBUG("Stopping async job: %s (vm=%p name=%s)",
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
              obj, obj->def->name);
2974

2975
    qemuDomainObjResetAsyncJob(priv);
2976
    qemuDomainObjSaveJob(driver, obj);
2977 2978 2979
    virCondBroadcast(&priv->job.asyncCond);
}

2980 2981 2982 2983 2984
void
qemuDomainObjAbortAsyncJob(virDomainObjPtr obj)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

2985 2986 2987
    VIR_DEBUG("Requesting abort of async job: %s (vm=%p name=%s)",
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
              obj, obj->def->name);
2988

2989 2990
    priv->job.abortJob = true;
    virDomainObjBroadcast(obj);
2991 2992
}

2993 2994 2995 2996 2997 2998 2999 3000 3001
/*
 * 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
 */
3002
static int
3003
qemuDomainObjEnterMonitorInternal(virQEMUDriverPtr driver,
3004
                                  virDomainObjPtr obj,
3005
                                  qemuDomainAsyncJob asyncJob)
3006 3007 3008
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

3009
    if (asyncJob != QEMU_ASYNC_JOB_NONE) {
3010 3011 3012
        int ret;
        if ((ret = qemuDomainObjBeginNestedJob(driver, obj, asyncJob)) < 0)
            return ret;
3013
        if (!virDomainObjIsActive(obj)) {
3014 3015
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("domain is no longer running"));
3016
            qemuDomainObjEndJob(driver, obj);
3017 3018
            return -1;
        }
3019 3020 3021
    } 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");
3022 3023
    }

3024 3025
    VIR_DEBUG("Entering monitor (mon=%p vm=%p name=%s)",
              priv->mon, obj, obj->def->name);
3026
    virObjectLock(priv->mon);
3027
    virObjectRef(priv->mon);
3028
    ignore_value(virTimeMillisNow(&priv->monStart));
3029
    virObjectUnlock(obj);
3030 3031

    return 0;
3032 3033
}

3034
static void ATTRIBUTE_NONNULL(1)
3035
qemuDomainObjExitMonitorInternal(virQEMUDriverPtr driver,
3036
                                 virDomainObjPtr obj)
3037 3038
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
3039
    bool hasRefs;
3040

3041
    hasRefs = virObjectUnref(priv->mon);
3042

3043
    if (hasRefs)
3044
        virObjectUnlock(priv->mon);
3045

3046
    virObjectLock(obj);
3047 3048
    VIR_DEBUG("Exited monitor (mon=%p vm=%p name=%s)",
              priv->mon, obj, obj->def->name);
3049

3050
    priv->monStart = 0;
3051
    if (!hasRefs)
3052
        priv->mon = NULL;
3053

J
Jiri Denemark 已提交
3054 3055
    if (priv->job.active == QEMU_JOB_ASYNC_NESTED)
        qemuDomainObjEndJob(driver, obj);
3056 3057
}

3058
void qemuDomainObjEnterMonitor(virQEMUDriverPtr driver,
3059
                               virDomainObjPtr obj)
3060
{
3061
    ignore_value(qemuDomainObjEnterMonitorInternal(driver, obj,
3062
                                                   QEMU_ASYNC_JOB_NONE));
3063 3064
}

3065
/* obj must NOT be locked before calling
3066 3067
 *
 * Should be paired with an earlier qemuDomainObjEnterMonitor() call
3068 3069 3070 3071 3072 3073
 *
 * 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.
3074
 */
3075 3076
int qemuDomainObjExitMonitor(virQEMUDriverPtr driver,
                             virDomainObjPtr obj)
3077
{
3078
    qemuDomainObjExitMonitorInternal(driver, obj);
3079
    if (!virDomainObjIsActive(obj)) {
3080 3081 3082
        if (!virGetLastError())
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("domain is no longer running"));
3083 3084 3085
        return -1;
    }
    return 0;
3086
}
3087 3088

/*
3089
 * obj must be locked before calling
3090 3091
 *
 * To be called immediately before any QEMU monitor API call.
3092
 * Must have already either called qemuDomainObjBeginJob()
3093 3094 3095 3096 3097
 * 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
3098 3099 3100
 * 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).
3101 3102
 */
int
3103
qemuDomainObjEnterMonitorAsync(virQEMUDriverPtr driver,
3104
                               virDomainObjPtr obj,
3105
                               qemuDomainAsyncJob asyncJob)
3106
{
3107
    return qemuDomainObjEnterMonitorInternal(driver, obj, asyncJob);
3108 3109
}

D
Daniel P. Berrange 已提交
3110

3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122
/**
 * qemuDomainGetAgent:
 * @vm: domain object
 *
 * Returns the agent pointer of @vm;
 */
qemuAgentPtr
qemuDomainGetAgent(virDomainObjPtr vm)
{
    return (((qemuDomainObjPrivatePtr)(vm->privateData))->agent);
}

D
Daniel P. Berrange 已提交
3123

3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134
/*
 * 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
 */
void
qemuDomainObjEnterAgent(virDomainObjPtr obj)
D
Daniel P. Berrange 已提交
3135 3136 3137
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

3138 3139
    VIR_DEBUG("Entering agent (agent=%p vm=%p name=%s)",
              priv->agent, obj, obj->def->name);
3140
    virObjectLock(priv->agent);
3141
    virObjectRef(priv->agent);
D
Daniel P. Berrange 已提交
3142
    ignore_value(virTimeMillisNow(&priv->agentStart));
3143
    virObjectUnlock(obj);
D
Daniel P. Berrange 已提交
3144 3145
}

3146 3147 3148 3149 3150 3151 3152

/* obj must NOT be locked before calling
 *
 * Should be paired with an earlier qemuDomainObjEnterAgent() call
 */
void
qemuDomainObjExitAgent(virDomainObjPtr obj)
D
Daniel P. Berrange 已提交
3153 3154
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
3155
    bool hasRefs;
D
Daniel P. Berrange 已提交
3156

3157
    hasRefs = virObjectUnref(priv->agent);
D
Daniel P. Berrange 已提交
3158

3159
    if (hasRefs)
3160
        virObjectUnlock(priv->agent);
D
Daniel P. Berrange 已提交
3161

3162
    virObjectLock(obj);
3163 3164
    VIR_DEBUG("Exited agent (agent=%p vm=%p name=%s)",
              priv->agent, obj, obj->def->name);
D
Daniel P. Berrange 已提交
3165 3166

    priv->agentStart = 0;
3167
    if (!hasRefs)
D
Daniel P. Berrange 已提交
3168 3169 3170
        priv->agent = NULL;
}

3171
void qemuDomainObjEnterRemote(virDomainObjPtr obj)
3172
{
3173 3174
    VIR_DEBUG("Entering remote (vm=%p name=%s)",
              obj, obj->def->name);
3175
    virObjectUnlock(obj);
3176 3177
}

3178
void qemuDomainObjExitRemote(virDomainObjPtr obj)
3179
{
3180
    virObjectLock(obj);
3181 3182
    VIR_DEBUG("Exited remote (vm=%p name=%s)",
              obj, obj->def->name);
3183
}
3184 3185


3186 3187 3188 3189 3190 3191 3192 3193
virDomainDefPtr
qemuDomainDefCopy(virQEMUDriverPtr driver,
                  virDomainDefPtr src,
                  unsigned int flags)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    virDomainDefPtr ret = NULL;
    virCapsPtr caps = NULL;
3194
    char *xml = NULL;
3195 3196 3197 3198 3199 3200 3201 3202 3203 3204

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

    xml = virBufferContentAndReset(&buf);

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

    if (!(ret = virDomainDefParseString(xml, caps, driver->xmlopt,
3205 3206
                                        VIR_DOMAIN_DEF_PARSE_INACTIVE |
                                        VIR_DOMAIN_DEF_PARSE_SKIP_VALIDATE)))
3207 3208
        goto cleanup;

3209
 cleanup:
3210 3211 3212 3213 3214
    VIR_FREE(xml);
    virObjectUnref(caps);
    return ret;
}

3215
int
3216
qemuDomainDefFormatBuf(virQEMUDriverPtr driver,
3217 3218 3219
                       virDomainDefPtr def,
                       unsigned int flags,
                       virBuffer *buf)
3220
{
3221
    int ret = -1;
3222
    virDomainDefPtr copy = NULL;
3223 3224 3225 3226
    virCapsPtr caps = NULL;

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

3228 3229 3230 3231 3232 3233 3234 3235 3236
    if (!(flags & (VIR_DOMAIN_XML_UPDATE_CPU | VIR_DOMAIN_XML_MIGRATABLE)))
        goto format;

    if (!(copy = virDomainDefCopy(def, caps, driver->xmlopt,
                                  flags & VIR_DOMAIN_XML_MIGRATABLE)))
        goto cleanup;

    def = copy;

3237
    /* Update guest CPU requirements according to host CPU */
3238
    if ((flags & VIR_DOMAIN_XML_UPDATE_CPU) &&
3239 3240
        def->cpu &&
        (def->cpu->mode != VIR_CPU_MODE_CUSTOM || def->cpu->model)) {
3241 3242
        if (!caps->host.cpu ||
            !caps->host.cpu->model) {
3243 3244
            virReportError(VIR_ERR_OPERATION_FAILED,
                           "%s", _("cannot get host CPU capabilities"));
3245 3246 3247
            goto cleanup;
        }

3248
        if (cpuUpdate(def->cpu, caps->host.cpu) < 0)
3249 3250 3251
            goto cleanup;
    }

3252
    if ((flags & VIR_DOMAIN_XML_MIGRATABLE)) {
3253
        size_t i;
3254
        int toremove = 0;
3255
        virDomainControllerDefPtr usb = NULL, pci = NULL;
3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270

        /* 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];
            }
        }
3271 3272 3273 3274
        /*  The original purpose of the check was the migration compatibility
         *  with libvirt <= 0.9.4. Limitation doesn't apply to other archs
         *  and can cause problems on PPC64.
         */
3275 3276
        if (ARCH_IS_X86(def->os.arch) && qemuDomainMachineIsI440FX(def) &&
            usb && usb->idx == 0 && usb->model == -1) {
3277 3278
            VIR_DEBUG("Removing default USB controller from domain '%s'"
                      " for migration compatibility", def->name);
3279
            toremove++;
3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297
        } 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 已提交
3298
            VIR_DEBUG("Removing default pci-root from domain '%s'"
3299
                      " for migration compatibility", def->name);
3300
            toremove++;
3301 3302 3303 3304
        } else {
            pci = NULL;
        }

3305
        if (toremove) {
3306 3307 3308
            virDomainControllerDefPtr *controllers = def->controllers;
            int ncontrollers = def->ncontrollers;

3309
            if (VIR_ALLOC_N(def->controllers, ncontrollers - toremove) < 0) {
3310
                def->controllers = controllers;
3311 3312 3313 3314 3315
                goto cleanup;
            }

            def->ncontrollers = 0;
            for (i = 0; i < ncontrollers; i++) {
3316
                if (controllers[i] != usb && controllers[i] != pci)
3317 3318
                    def->controllers[def->ncontrollers++] = controllers[i];
            }
3319 3320 3321 3322

            VIR_FREE(controllers);
            virDomainControllerDefFree(pci);
            virDomainControllerDefFree(usb);
3323
        }
3324

3325 3326 3327 3328 3329 3330 3331 3332 3333
        /* 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;
            }
        }

3334 3335
        for (i = 0; i < def->nchannels; i++)
            qemuDomainChrDefDropDefaultPath(def->channels[i], driver);
3336 3337
    }

3338 3339
 format:
    ret = virDomainDefFormatInternal(def, caps,
3340 3341
                                     virDomainDefFormatConvertXMLFlags(flags),
                                     buf);
3342

3343
 cleanup:
3344
    virDomainDefFree(copy);
3345
    virObjectUnref(caps);
3346 3347
    return ret;
}
3348

3349
char *qemuDomainDefFormatXML(virQEMUDriverPtr driver,
3350
                             virDomainDefPtr def,
3351
                             unsigned int flags)
3352 3353 3354
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

3355
    if (qemuDomainDefFormatBuf(driver, def, flags, &buf) < 0) {
3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368
        virBufferFreeAndReset(&buf);
        return NULL;
    }

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

    return virBufferContentAndReset(&buf);
}

3369
char *qemuDomainFormatXML(virQEMUDriverPtr driver,
3370
                          virDomainObjPtr vm,
3371
                          unsigned int flags)
3372 3373 3374 3375 3376 3377 3378 3379
{
    virDomainDefPtr def;

    if ((flags & VIR_DOMAIN_XML_INACTIVE) && vm->newDef)
        def = vm->newDef;
    else
        def = vm->def;

3380
    return qemuDomainDefFormatXML(driver, def, flags);
3381 3382
}

3383
char *
3384
qemuDomainDefFormatLive(virQEMUDriverPtr driver,
3385
                        virDomainDefPtr def,
3386 3387
                        bool inactive,
                        bool compatible)
3388 3389 3390 3391 3392
{
    unsigned int flags = QEMU_DOMAIN_FORMAT_LIVE_FLAGS;

    if (inactive)
        flags |= VIR_DOMAIN_XML_INACTIVE;
3393 3394
    if (compatible)
        flags |= VIR_DOMAIN_XML_MIGRATABLE;
3395

3396
    return qemuDomainDefFormatXML(driver, def, flags);
3397 3398
}

3399

3400
void qemuDomainObjTaint(virQEMUDriverPtr driver,
3401
                        virDomainObjPtr obj,
3402
                        virDomainTaintFlags taint,
3403
                        qemuDomainLogContextPtr logCtxt)
3404
{
3405
    virErrorPtr orig_err = NULL;
3406
    bool closeLog = false;
3407

3408 3409 3410 3411 3412 3413 3414 3415 3416
    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));
3417 3418 3419 3420 3421

        /* We don't care about errors logging taint info, so
         * preserve original error, and clear any error that
         * is raised */
        orig_err = virSaveLastError();
3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439
        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)
3440
            virResetLastError();
3441 3442
        if (closeLog)
            qemuDomainLogContextFree(logCtxt);
3443 3444 3445 3446
        if (orig_err) {
            virSetError(orig_err);
            virFreeError(orig_err);
        }
3447 3448 3449 3450
    }
}


3451
void qemuDomainObjCheckTaint(virQEMUDriverPtr driver,
3452
                             virDomainObjPtr obj,
3453
                             qemuDomainLogContextPtr logCtxt)
3454
{
3455
    size_t i;
3456
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
3457
    qemuDomainObjPrivatePtr priv = obj->privateData;
3458

3459
    if (virQEMUDriverIsPrivileged(driver) &&
3460 3461 3462
        (!cfg->clearEmulatorCapabilities ||
         cfg->user == 0 ||
         cfg->group == 0))
3463
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HIGH_PRIVILEGES, logCtxt);
3464

3465
    if (priv->hookRun)
3466
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HOOK, logCtxt);
3467

3468 3469 3470
    if (obj->def->namespaceData) {
        qemuDomainCmdlineDefPtr qemucmd = obj->def->namespaceData;
        if (qemucmd->num_args || qemucmd->num_env)
3471
            qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_CUSTOM_ARGV, logCtxt);
3472 3473
    }

3474
    if (obj->def->cpu && obj->def->cpu->mode == VIR_CPU_MODE_HOST_PASSTHROUGH)
3475
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HOST_CPU, logCtxt);
3476

3477
    for (i = 0; i < obj->def->ndisks; i++)
3478
        qemuDomainObjCheckDiskTaint(driver, obj, obj->def->disks[i], logCtxt);
3479

3480 3481
    for (i = 0; i < obj->def->nhostdevs; i++)
        qemuDomainObjCheckHostdevTaint(driver, obj, obj->def->hostdevs[i],
3482
                                       logCtxt);
3483

3484
    for (i = 0; i < obj->def->nnets; i++)
3485
        qemuDomainObjCheckNetTaint(driver, obj, obj->def->nets[i], logCtxt);
3486

3487
    if (obj->def->os.dtb)
3488
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_CUSTOM_DTB, logCtxt);
3489

3490
    virObjectUnref(cfg);
3491 3492 3493
}


3494
void qemuDomainObjCheckDiskTaint(virQEMUDriverPtr driver,
3495
                                 virDomainObjPtr obj,
3496
                                 virDomainDiskDefPtr disk,
3497
                                 qemuDomainLogContextPtr logCtxt)
3498
{
3499
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
3500
    int format = virDomainDiskGetFormat(disk);
3501

3502
    if ((!format || format == VIR_STORAGE_FILE_AUTO) &&
3503
        cfg->allowDiskFormatProbing)
3504
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_DISK_PROBING, logCtxt);
3505

3506 3507
    if (disk->rawio == VIR_TRISTATE_BOOL_YES)
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HIGH_PRIVILEGES,
3508
                           logCtxt);
3509

3510 3511 3512 3513
    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,
3514
                           logCtxt);
3515

3516
    virObjectUnref(cfg);
3517 3518 3519
}


3520 3521 3522
void qemuDomainObjCheckHostdevTaint(virQEMUDriverPtr driver,
                                    virDomainObjPtr obj,
                                    virDomainHostdevDefPtr hostdev,
3523
                                    qemuDomainLogContextPtr logCtxt)
3524 3525 3526 3527 3528 3529
{
    virDomainHostdevSubsysSCSIPtr scsisrc = &hostdev->source.subsys.u.scsi;

    if (hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_SCSI &&
        scsisrc->rawio == VIR_TRISTATE_BOOL_YES)
            qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HIGH_PRIVILEGES,
3530
                               logCtxt);
3531 3532 3533
}


3534
void qemuDomainObjCheckNetTaint(virQEMUDriverPtr driver,
3535
                                virDomainObjPtr obj,
3536
                                virDomainNetDefPtr net,
3537
                                qemuDomainLogContextPtr logCtxt)
3538
{
3539 3540 3541 3542 3543 3544
    /* 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)
3545
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_SHELL_SCRIPTS, logCtxt);
3546
}
3547 3548


3549 3550 3551 3552 3553 3554 3555 3556 3557 3558
qemuDomainLogContextPtr qemuDomainLogContextNew(virQEMUDriverPtr driver,
                                                virDomainObjPtr vm,
                                                qemuDomainLogContextMode mode)
{
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    qemuDomainLogContextPtr ctxt = NULL;

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

3559
    VIR_DEBUG("Context new %p stdioLogD=%d", ctxt, cfg->stdioLogD);
3560 3561 3562 3563
    ctxt->writefd = -1;
    ctxt->readfd = -1;
    virAtomicIntSet(&ctxt->refs, 1);

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

3567 3568 3569 3570
    if (cfg->stdioLogD) {
        ctxt->manager = virLogManagerNew(virQEMUDriverIsPrivileged(driver));
        if (!ctxt->manager)
            goto error;
3571

3572 3573 3574 3575
        ctxt->writefd = virLogManagerDomainOpenLogFile(ctxt->manager,
                                                       "qemu",
                                                       vm->def->uuid,
                                                       vm->def->name,
3576
                                                       ctxt->path,
3577 3578 3579 3580 3581 3582
                                                       0,
                                                       &ctxt->inode,
                                                       &ctxt->pos);
        if (ctxt->writefd < 0)
            goto error;
    } else {
3583
        if ((ctxt->writefd = open(ctxt->path, O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR)) < 0) {
3584
            virReportSystemError(errno, _("failed to create logfile %s"),
3585
                                 ctxt->path);
3586 3587
            goto error;
        }
3588
        if (virSetCloseExec(ctxt->writefd) < 0) {
3589
            virReportSystemError(errno, _("failed to set close-on-exec flag on %s"),
3590
                                 ctxt->path);
3591 3592 3593
            goto error;
        }

3594 3595 3596 3597 3598 3599 3600
        /* 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"),
3601
                                 ctxt->path);
3602 3603 3604 3605
            goto error;
        }

        if (mode == QEMU_DOMAIN_LOG_CONTEXT_MODE_START) {
3606
            if ((ctxt->readfd = open(ctxt->path, O_RDONLY, S_IRUSR | S_IWUSR)) < 0) {
3607
                virReportSystemError(errno, _("failed to open logfile %s"),
3608
                                     ctxt->path);
3609 3610 3611 3612
                goto error;
            }
            if (virSetCloseExec(ctxt->readfd) < 0) {
                virReportSystemError(errno, _("failed to set close-on-exec flag on %s"),
3613
                                     ctxt->path);
3614 3615 3616 3617
                goto error;
            }
        }

3618 3619
        if ((ctxt->pos = lseek(ctxt->writefd, 0, SEEK_END)) < 0) {
            virReportSystemError(errno, _("failed to seek in log file %s"),
3620
                                 ctxt->path);
3621 3622 3623 3624
            goto error;
        }
    }

3625
 cleanup:
3626 3627 3628 3629 3630
    virObjectUnref(cfg);
    return ctxt;

 error:
    qemuDomainLogContextFree(ctxt);
3631 3632
    ctxt = NULL;
    goto cleanup;
3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646
}


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;
3647 3648
    if (!ctxt->manager &&
        lseek(ctxt->writefd, 0, SEEK_END) < 0) {
3649
        virReportSystemError(errno, "%s",
3650
                             _("Unable to seek to end of domain logfile"));
3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670
        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)
{
3671 3672 3673 3674
    VIR_DEBUG("Context read %p manager=%p inode=%llu pos=%llu",
              ctxt, ctxt->manager,
              (unsigned long long)ctxt->inode,
              (unsigned long long)ctxt->pos);
3675
    char *buf;
3676 3677 3678
    size_t buflen;
    if (ctxt->manager) {
        buf = virLogManagerDomainReadLogFile(ctxt->manager,
3679
                                             ctxt->path,
3680 3681 3682 3683 3684 3685 3686 3687 3688
                                             ctxt->inode,
                                             ctxt->pos,
                                             1024 * 128,
                                             0);
        if (!buf)
            return -1;
        buflen = strlen(buf);
    } else {
        ssize_t got;
3689

3690
        buflen = 1024 * 128;
3691

3692 3693
        /* Best effort jump to start of messages */
        ignore_value(lseek(ctxt->readfd, ctxt->pos, SEEK_SET));
3694

3695 3696
        if (VIR_ALLOC_N(buf, buflen) < 0)
            return -1;
3697

3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710
        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;
    }
3711 3712 3713

    *msg = buf;

3714
    return buflen;
3715 3716 3717
}


3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779
/**
 * 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;
}


3780 3781 3782 3783 3784 3785 3786 3787
int qemuDomainLogContextGetWriteFD(qemuDomainLogContextPtr ctxt)
{
    return ctxt->writefd;
}


void qemuDomainLogContextMarkPosition(qemuDomainLogContextPtr ctxt)
{
3788 3789
    if (ctxt->manager)
        virLogManagerDomainGetLogFilePosition(ctxt->manager,
3790
                                              ctxt->path,
3791 3792 3793 3794 3795
                                              0,
                                              &ctxt->inode,
                                              &ctxt->pos);
    else
        ctxt->pos = lseek(ctxt->writefd, 0, SEEK_END);
3796 3797 3798 3799 3800
}


void qemuDomainLogContextRef(qemuDomainLogContextPtr ctxt)
{
3801
    VIR_DEBUG("Context ref %p", ctxt);
3802 3803 3804 3805
    virAtomicIntInc(&ctxt->refs);
}


3806 3807 3808 3809 3810 3811
virLogManagerPtr qemuDomainLogContextGetManager(qemuDomainLogContextPtr ctxt)
{
    return ctxt->manager;
}


3812 3813 3814 3815 3816 3817 3818 3819
void qemuDomainLogContextFree(qemuDomainLogContextPtr ctxt)
{
    bool lastRef;

    if (!ctxt)
        return;

    lastRef = virAtomicIntDecAndTest(&ctxt->refs);
3820
    VIR_DEBUG("Context free %p lastref=%d", ctxt, lastRef);
3821 3822 3823
    if (!lastRef)
        return;

3824
    virLogManagerFree(ctxt->manager);
3825
    VIR_FREE(ctxt->path);
3826 3827 3828 3829 3830 3831
    VIR_FORCE_CLOSE(ctxt->writefd);
    VIR_FORCE_CLOSE(ctxt->readfd);
    VIR_FREE(ctxt);
}


3832 3833
/* Locate an appropriate 'qemu-img' binary.  */
const char *
3834
qemuFindQemuImgBinary(virQEMUDriverPtr driver)
3835
{
3836 3837
    if (!driver->qemuImgBinary)
        virReportError(VIR_ERR_INTERNAL_ERROR,
3838
                       "%s", _("unable to find qemu-img"));
3839 3840 3841 3842 3843 3844 3845

    return driver->qemuImgBinary;
}

int
qemuDomainSnapshotWriteMetadata(virDomainObjPtr vm,
                                virDomainSnapshotObjPtr snapshot,
3846
                                virCapsPtr caps,
3847 3848 3849 3850 3851 3852 3853 3854 3855
                                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);
3856
    newxml = virDomainSnapshotDefFormat(
3857
        uuidstr, snapshot->def, caps,
3858 3859
        virDomainDefFormatConvertXMLFlags(QEMU_DOMAIN_FORMAT_LIVE_FLAGS),
        1);
3860
    if (newxml == NULL)
3861 3862
        return -1;

3863
    if (virAsprintf(&snapDir, "%s/%s", snapshotDir, vm->def->name) < 0)
3864 3865 3866 3867 3868 3869 3870
        goto cleanup;
    if (virFileMakePath(snapDir) < 0) {
        virReportSystemError(errno, _("cannot create snapshot directory '%s'"),
                             snapDir);
        goto cleanup;
    }

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

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

3876
 cleanup:
3877 3878 3879 3880 3881 3882 3883 3884
    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.  */
3885
static int
3886
qemuDomainSnapshotForEachQcow2Raw(virQEMUDriverPtr driver,
3887 3888 3889 3890 3891
                                  virDomainDefPtr def,
                                  const char *name,
                                  const char *op,
                                  bool try_all,
                                  int ndisks)
3892 3893
{
    const char *qemuimgarg[] = { NULL, "snapshot", NULL, NULL, NULL, NULL };
3894
    size_t i;
3895 3896 3897 3898 3899 3900 3901 3902 3903
    bool skipped = false;

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

    qemuimgarg[2] = op;
3904
    qemuimgarg[3] = name;
3905

3906
    for (i = 0; i < ndisks; i++) {
3907
        /* FIXME: we also need to handle LVM here */
3908
        if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
3909 3910 3911
            int format = virDomainDiskGetFormat(def->disks[i]);

            if (format > 0 && format != VIR_STORAGE_FILE_QCOW2) {
3912 3913 3914 3915 3916
                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",
3917
                             def->disks[i]->dst);
3918 3919
                    skipped = true;
                    continue;
3920 3921 3922 3923 3924
                } else if (STREQ(op, "-c") && i) {
                    /* We must roll back partial creation by deleting
                     * all earlier snapshots.  */
                    qemuDomainSnapshotForEachQcow2Raw(driver, def, name,
                                                      "-d", false, i);
3925
                }
3926 3927 3928 3929
                virReportError(VIR_ERR_OPERATION_INVALID,
                               _("Disk device '%s' does not support"
                                 " snapshotting"),
                               def->disks[i]->dst);
3930 3931 3932
                return -1;
            }

3933
            qemuimgarg[4] = virDomainDiskGetSource(def->disks[i]);
3934 3935 3936 3937

            if (virRun(qemuimgarg, NULL) < 0) {
                if (try_all) {
                    VIR_WARN("skipping snapshot action on %s",
3938
                             def->disks[i]->dst);
3939 3940
                    skipped = true;
                    continue;
3941 3942 3943 3944 3945
                } else if (STREQ(op, "-c") && i) {
                    /* We must roll back partial creation by deleting
                     * all earlier snapshots.  */
                    qemuDomainSnapshotForEachQcow2Raw(driver, def, name,
                                                      "-d", false, i);
3946 3947 3948 3949 3950 3951 3952 3953 3954
                }
                return -1;
            }
        }
    }

    return skipped ? 1 : 0;
}

3955 3956 3957
/* 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
3958
qemuDomainSnapshotForEachQcow2(virQEMUDriverPtr driver,
3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974
                               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);
}

3975 3976
/* Discard one snapshot (or its metadata), without reparenting any children.  */
int
3977
qemuDomainSnapshotDiscard(virQEMUDriverPtr driver,
3978 3979 3980 3981 3982 3983 3984 3985 3986
                          virDomainObjPtr vm,
                          virDomainSnapshotObjPtr snap,
                          bool update_current,
                          bool metadata_only)
{
    char *snapFile = NULL;
    int ret = -1;
    qemuDomainObjPrivatePtr priv;
    virDomainSnapshotObjPtr parentsnap = NULL;
3987
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
3988 3989 3990 3991 3992 3993 3994 3995 3996

    if (!metadata_only) {
        if (!virDomainObjIsActive(vm)) {
            /* Ignore any skipped disks */
            if (qemuDomainSnapshotForEachQcow2(driver, vm, snap, "-d",
                                               true) < 0)
                goto cleanup;
        } else {
            priv = vm->privateData;
3997
            qemuDomainObjEnterMonitor(driver, vm);
3998 3999
            /* we continue on even in the face of error */
            qemuMonitorDeleteSnapshot(priv->mon, snap->def->name);
4000
            ignore_value(qemuDomainObjExitMonitor(driver, vm));
4001 4002 4003
        }
    }

4004
    if (virAsprintf(&snapFile, "%s/%s/%s.xml", cfg->snapshotDir,
4005
                    vm->def->name, snap->def->name) < 0)
4006 4007 4008 4009
        goto cleanup;

    if (snap == vm->current_snapshot) {
        if (update_current && snap->def->parent) {
4010
            parentsnap = virDomainSnapshotFindByName(vm->snapshots,
4011 4012 4013 4014 4015 4016
                                                     snap->def->parent);
            if (!parentsnap) {
                VIR_WARN("missing parent snapshot matching name '%s'",
                         snap->def->parent);
            } else {
                parentsnap->def->current = true;
4017
                if (qemuDomainSnapshotWriteMetadata(vm, parentsnap, driver->caps,
4018
                                                    cfg->snapshotDir) < 0) {
4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030
                    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);
4031
    virDomainSnapshotObjListRemove(vm->snapshots, snap);
4032 4033 4034

    ret = 0;

4035
 cleanup:
4036
    VIR_FREE(snapFile);
4037
    virObjectUnref(cfg);
4038 4039 4040 4041
    return ret;
}

/* Hash iterator callback to discard multiple snapshots.  */
4042 4043 4044
int qemuDomainSnapshotDiscardAll(void *payload,
                                 const void *name ATTRIBUTE_UNUSED,
                                 void *data)
4045 4046
{
    virDomainSnapshotObjPtr snap = payload;
4047
    virQEMUSnapRemovePtr curr = data;
4048 4049 4050 4051 4052 4053 4054 4055
    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;
4056
    return 0;
4057 4058 4059
}

int
4060
qemuDomainSnapshotDiscardAllMetadata(virQEMUDriverPtr driver,
4061 4062
                                     virDomainObjPtr vm)
{
4063
    virQEMUSnapRemove rem;
4064 4065 4066 4067 4068

    rem.driver = driver;
    rem.vm = vm;
    rem.metadata_only = true;
    rem.err = 0;
4069 4070
    virDomainSnapshotForEach(vm->snapshots, qemuDomainSnapshotDiscardAll,
                             &rem);
4071 4072 4073 4074 4075

    return rem.err;
}

/*
4076
 * The caller must hold a lock the vm.
4077 4078
 */
void
4079
qemuDomainRemoveInactive(virQEMUDriverPtr driver,
4080 4081
                         virDomainObjPtr vm)
{
4082
    bool haveJob = true;
4083
    char *snapDir;
4084 4085 4086 4087 4088 4089 4090 4091
    virQEMUDriverConfigPtr cfg;

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

    cfg = virQEMUDriverGetConfig(driver);
4092

4093 4094 4095
    if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
        haveJob = false;

4096 4097 4098 4099 4100
    /* 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);
    }
4101
    else if (virAsprintf(&snapDir, "%s/%s", cfg->snapshotDir,
4102 4103
                         vm->def->name) < 0) {
        VIR_WARN("unable to remove snapshot directory %s/%s",
4104
                 cfg->snapshotDir, vm->def->name);
4105 4106 4107 4108 4109
    } else {
        if (rmdir(snapDir) < 0 && errno != ENOENT)
            VIR_WARN("unable to remove snapshot directory %s", snapDir);
        VIR_FREE(snapDir);
    }
4110 4111 4112

    virObjectRef(vm);

4113
    virDomainObjListRemove(driver->domains, vm);
4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126
    /*
     * 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);
4127
    virObjectUnref(cfg);
4128 4129

    if (haveJob)
4130
        qemuDomainObjEndJob(driver, vm);
4131 4132

    virObjectUnref(vm);
4133
}
4134 4135

void
4136
qemuDomainSetFakeReboot(virQEMUDriverPtr driver,
4137 4138 4139 4140
                        virDomainObjPtr vm,
                        bool value)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
4141
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
4142 4143

    if (priv->fakeReboot == value)
4144
        goto cleanup;
4145 4146 4147

    priv->fakeReboot = value;

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

4151
 cleanup:
4152
    virObjectUnref(cfg);
4153
}
M
Michal Privoznik 已提交
4154

4155
static void
4156 4157
qemuDomainCheckRemoveOptionalDisk(virQEMUDriverPtr driver,
                                  virDomainObjPtr vm,
4158
                                  size_t diskIndex)
4159 4160
{
    char uuid[VIR_UUID_STRING_BUFLEN];
4161
    virObjectEventPtr event = NULL;
4162
    virDomainDiskDefPtr disk = vm->def->disks[diskIndex];
4163
    const char *src = virDomainDiskGetSource(disk);
4164 4165 4166 4167 4168

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

    VIR_DEBUG("Dropping disk '%s' on domain '%s' (UUID '%s') "
              "due to inaccessible source '%s'",
4169
              disk->dst, vm->def->name, uuid, src);
4170 4171 4172 4173

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

4174
        event = virDomainEventDiskChangeNewFromObj(vm, src, NULL,
4175 4176
                                                   disk->info.alias,
                                                   VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START);
4177
        ignore_value(virDomainDiskSetSource(disk, NULL));
4178
    } else {
4179
        event = virDomainEventDiskChangeNewFromObj(vm, src, NULL,
4180 4181
                                                   disk->info.alias,
                                                   VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START);
4182 4183
        virDomainDiskRemove(vm->def, diskIndex);
        virDomainDiskDefFree(disk);
4184 4185
    }

4186
    qemuDomainEventQueue(driver, event);
4187 4188
}

4189 4190 4191
static int
qemuDomainCheckDiskStartupPolicy(virQEMUDriverPtr driver,
                                 virDomainObjPtr vm,
4192
                                 size_t diskIndex,
4193 4194
                                 bool cold_boot)
{
4195
    int startupPolicy = vm->def->disks[diskIndex]->startupPolicy;
4196
    int device = vm->def->disks[diskIndex]->device;
4197

4198
    switch ((virDomainStartupPolicy) startupPolicy) {
4199
        case VIR_DOMAIN_STARTUP_POLICY_OPTIONAL:
4200 4201 4202 4203 4204 4205
            /* 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)
4206
                return -1;
4207 4208
            break;

4209
        case VIR_DOMAIN_STARTUP_POLICY_DEFAULT:
4210
        case VIR_DOMAIN_STARTUP_POLICY_MANDATORY:
4211
            return -1;
4212 4213

        case VIR_DOMAIN_STARTUP_POLICY_REQUISITE:
4214
            if (cold_boot)
4215
                return -1;
4216 4217 4218 4219 4220 4221 4222
            break;

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

4223
    qemuDomainCheckRemoveOptionalDisk(driver, vm, diskIndex);
4224
    virResetLastError();
4225 4226 4227
    return 0;
}

4228

M
Michal Privoznik 已提交
4229
int
4230 4231
qemuDomainCheckDiskPresence(virConnectPtr conn,
                            virQEMUDriverPtr driver,
M
Michal Privoznik 已提交
4232
                            virDomainObjPtr vm,
4233
                            unsigned int flags)
M
Michal Privoznik 已提交
4234
{
4235
    size_t i;
4236 4237
    bool pretend = flags & VIR_QEMU_PROCESS_START_PRETEND;
    bool cold_boot = flags & VIR_QEMU_PROCESS_START_COLD;
M
Michal Privoznik 已提交
4238

4239
    VIR_DEBUG("Checking for disk presence");
4240
    for (i = vm->def->ndisks; i > 0; i--) {
4241 4242
        size_t idx = i - 1;
        virDomainDiskDefPtr disk = vm->def->disks[idx];
4243
        virStorageFileFormat format = virDomainDiskGetFormat(disk);
M
Michal Privoznik 已提交
4244

4245 4246 4247 4248 4249 4250 4251 4252 4253 4254
        if (virStorageTranslateDiskSourcePool(conn, vm->def->disks[idx]) < 0) {
            if (pretend ||
                qemuDomainCheckDiskStartupPolicy(driver, vm, idx, cold_boot) < 0)
                return -1;
            continue;
        }

        if (pretend)
            continue;

4255
        if (virStorageSourceIsEmpty(disk->src))
4256 4257 4258 4259 4260
            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 */
4261
        if (virStorageSourceIsLocalStorage(disk->src) &&
4262
            format > VIR_STORAGE_FILE_NONE &&
4263
            format < VIR_STORAGE_FILE_BACKING &&
4264
            virFileExists(virDomainDiskGetSource(disk)))
M
Michal Privoznik 已提交
4265 4266
            continue;

4267
        if (qemuDomainDetermineDiskChain(driver, vm, disk, true, true) >= 0)
M
Michal Privoznik 已提交
4268
            continue;
4269

4270
        if (qemuDomainCheckDiskStartupPolicy(driver, vm, idx, cold_boot) >= 0)
4271
            continue;
M
Michal Privoznik 已提交
4272

4273
        return -1;
M
Michal Privoznik 已提交
4274 4275
    }

4276
    return 0;
M
Michal Privoznik 已提交
4277
}
4278 4279 4280 4281 4282 4283 4284 4285 4286 4287

/*
 * The vm must be locked when any of the following cleanup functions is
 * called.
 */
int
qemuDomainCleanupAdd(virDomainObjPtr vm,
                     qemuDomainCleanupCallback cb)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
4288
    size_t i;
4289 4290 4291 4292 4293 4294 4295 4296 4297 4298

    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,
4299
                     priv->ncleanupCallbacks, 1) < 0)
4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310
        return -1;

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

void
qemuDomainCleanupRemove(virDomainObjPtr vm,
                        qemuDomainCleanupCallback cb)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
4311
    size_t i;
4312 4313 4314 4315

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

    for (i = 0; i < priv->ncleanupCallbacks; i++) {
4316 4317 4318
        if (priv->cleanupCallbacks[i] == cb)
            VIR_DELETE_ELEMENT_INPLACE(priv->cleanupCallbacks,
                                       i, priv->ncleanupCallbacks);
4319 4320 4321 4322 4323 4324 4325 4326
    }

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

void
4327
qemuDomainCleanupRun(virQEMUDriverPtr driver,
4328 4329 4330
                     virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
4331
    size_t i;
4332 4333 4334 4335

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

    /* run cleanup callbacks in reverse order */
4336 4337
    for (i = 0; i < priv->ncleanupCallbacks; i++) {
        if (priv->cleanupCallbacks[priv->ncleanupCallbacks - (i + 1)])
4338 4339 4340 4341 4342 4343 4344
            priv->cleanupCallbacks[i](driver, vm);
    }

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

4346 4347 4348
static void
qemuDomainGetImageIds(virQEMUDriverConfigPtr cfg,
                      virDomainObjPtr vm,
4349
                      virStorageSourcePtr src,
4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367
                      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;
    }

4368 4369
    if (vm && (vmlabel = virDomainDefGetSecurityLabelDef(vm->def, "dac")) &&
        vmlabel->label)
4370 4371
        virParseOwnershipIds(vmlabel->label, uid, gid);

4372
    if ((disklabel = virStorageSourceGetSecurityLabelDef(src, "dac")) &&
4373
        disklabel->label)
4374 4375 4376 4377
        virParseOwnershipIds(disklabel->label, uid, gid);
}


4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400
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;
}


4401 4402 4403 4404 4405
char *
qemuDomainStorageAlias(const char *device, int depth)
{
    char *alias;

4406
    device = qemuAliasDiskDriveSkipPrefix(device);
4407 4408 4409 4410 4411 4412 4413 4414 4415

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


4416
int
4417
qemuDomainDetermineDiskChain(virQEMUDriverPtr driver,
4418
                             virDomainObjPtr vm,
4419
                             virDomainDiskDefPtr disk,
4420 4421
                             bool force_probe,
                             bool report_broken)
4422
{
4423 4424
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    int ret = 0;
4425 4426
    uid_t uid;
    gid_t gid;
4427

4428
    if (virStorageSourceIsEmpty(disk->src))
4429
        goto cleanup;
4430

4431
    if (disk->src->backingStore) {
4432
        if (force_probe)
4433
            virStorageSourceBackingStoreClear(disk->src);
4434
        else
4435
            goto cleanup;
4436
    }
4437

4438
    qemuDomainGetImageIds(cfg, vm, disk->src, &uid, &gid);
4439

4440
    if (virStorageFileGetMetadata(disk->src,
4441
                                  uid, gid,
4442
                                  cfg->allowDiskFormatProbing,
4443
                                  report_broken) < 0)
4444 4445
        ret = -1;

4446
 cleanup:
4447 4448
    virObjectUnref(cfg);
    return ret;
4449
}
4450

4451

4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514
/**
 * 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;
}


4515
bool
4516
qemuDomainDiskSourceDiffers(virDomainDiskDefPtr disk,
4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531
                            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;

4532 4533 4534 4535
    /* 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)
4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548
        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;
}


4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571
/*
 * 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);
4572 4573 4574 4575
    CHECK_EQ(bus, "bus", false);
    if (STRNEQ(disk->dst, orig_disk->dst)) {
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("cannot modify field '%s' of the disk"),
4576
                       "target");
4577 4578 4579 4580
        return false;
    }
    CHECK_EQ(tray_status, "tray", true);
    CHECK_EQ(removable, "removable", true);
4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663

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

4664 4665 4666 4667 4668 4669 4670
    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);
4671
    /* "snapshot" is a libvirt internal field and thus can be changed */
4672
    /* startupPolicy is allowed to be updated. Therefore not checked here. */
4673
    CHECK_EQ(transient, "transient", true);
4674
    CHECK_EQ(info.bootIndex, "boot order", true);
4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686
    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;
    }
4687

4688 4689 4690 4691 4692 4693
    /* 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);

4694 4695 4696 4697 4698
#undef CHECK_EQ

    return true;
}

4699 4700 4701
bool
qemuDomainDiskBlockJobIsActive(virDomainDiskDefPtr disk)
{
4702 4703
    qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);

4704 4705 4706 4707 4708 4709 4710 4711
    if (disk->mirror) {
        virReportError(VIR_ERR_BLOCK_COPY_ACTIVE,
                       _("disk '%s' already in active block job"),
                       disk->dst);

        return true;
    }

4712
    if (diskPriv->blockjob) {
4713 4714 4715 4716 4717 4718 4719 4720 4721 4722
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("disk '%s' already in active block job"),
                       disk->dst);
        return true;
    }

    return false;
}


4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737
/**
 * 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++) {
4738 4739 4740 4741
        virDomainDiskDefPtr disk = vm->def->disks[i];
        qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);

        if (!copy_only && diskPriv->blockjob)
4742 4743
            return true;

4744
        if (disk->mirror && disk->mirrorJob == VIR_DOMAIN_BLOCK_JOB_TYPE_COPY)
4745 4746 4747 4748 4749 4750 4751
            return true;
    }

    return false;
}


4752 4753
int
qemuDomainUpdateDeviceList(virQEMUDriverPtr driver,
4754 4755
                           virDomainObjPtr vm,
                           int asyncJob)
4756 4757 4758
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    char **aliases;
4759
    int rc;
4760 4761 4762 4763

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

4764 4765
    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
        return -1;
4766 4767 4768 4769
    rc = qemuMonitorGetDeviceAliases(priv->mon, &aliases);
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        return -1;
    if (rc < 0)
4770 4771 4772 4773 4774 4775
        return -1;

    virStringFreeList(priv->qemuDevices);
    priv->qemuDevices = aliases;
    return 0;
}
4776

4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825

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


4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841
bool
qemuDomainDefCheckABIStability(virQEMUDriverPtr driver,
                               virDomainDefPtr src,
                               virDomainDefPtr dst)
{
    virDomainDefPtr migratableDefSrc = NULL;
    virDomainDefPtr migratableDefDst = NULL;
    const int flags = VIR_DOMAIN_XML_SECURE | VIR_DOMAIN_XML_UPDATE_CPU | VIR_DOMAIN_XML_MIGRATABLE;
    bool ret = false;

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

    ret = virDomainDefCheckABIStability(migratableDefSrc, migratableDefDst);

4842
 cleanup:
4843 4844 4845 4846
    virDomainDefFree(migratableDefSrc);
    virDomainDefFree(migratableDefDst);
    return ret;
}
4847 4848

bool
4849
qemuDomainAgentAvailable(virDomainObjPtr vm,
4850 4851
                         bool reportError)
{
4852 4853
    qemuDomainObjPrivatePtr priv = vm->privateData;

4854 4855 4856 4857 4858 4859 4860
    if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING) {
        if (reportError) {
            virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                           _("domain is not running"));
        }
        return false;
    }
4861 4862 4863 4864 4865 4866 4867 4868 4869
    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) {
4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881
        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;
4882 4883 4884 4885
        }
    }
    return true;
}
4886

4887

4888
static unsigned long long
4889
qemuDomainGetMemorySizeAlignment(virDomainDefPtr def)
4890
{
4891 4892 4893 4894 4895
    /* 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;

4896 4897 4898 4899 4900 4901 4902
    /* Align memory size. QEMU requires rounding to next 4KiB block.
     * We'll take the "traditional" path and round it to 1MiB*/

    return 1024;
}


4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917
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;
}


4918 4919 4920
int
qemuDomainAlignMemorySizes(virDomainDefPtr def)
{
4921 4922
    unsigned long long maxmemkb = virMemoryMaxValue(false) >> 10;
    unsigned long long maxmemcapped = virMemoryMaxValue(true) >> 10;
4923
    unsigned long long initialmem = 0;
4924
    unsigned long long hotplugmem = 0;
4925
    unsigned long long mem;
4926
    unsigned long long align = qemuDomainGetMemorySizeAlignment(def);
4927 4928 4929 4930 4931
    size_t ncells = virDomainNumaGetNodeCount(def->numa);
    size_t i;

    /* align NUMA cell sizes if relevant */
    for (i = 0; i < ncells; i++) {
4932 4933
        mem = VIR_ROUND_UP(virDomainNumaGetNodeMemorySize(def->numa, i), align);
        initialmem += mem;
4934 4935 4936 4937 4938 4939 4940

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

4944 4945 4946 4947 4948
    /* 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);

4949 4950 4951 4952 4953 4954
    if (initialmem > maxmemcapped) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("initial memory size overflowed after alignment"));
        return -1;
    }

4955
    def->mem.max_memory = VIR_ROUND_UP(def->mem.max_memory, align);
4956 4957 4958 4959 4960
    if (def->mem.max_memory > maxmemkb) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("maximum memory size overflowed after alignment"));
        return -1;
    }
4961

4962
    /* Align memory module sizes */
4963 4964
    for (i = 0; i < def->nmems; i++) {
        align = qemuDomainGetMemoryModuleSizeAlignment(def, def->mems[i]);
4965
        def->mems[i]->size = VIR_ROUND_UP(def->mems[i]->size, align);
4966
        hotplugmem += def->mems[i]->size;
4967 4968 4969 4970 4971 4972 4973

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

4976 4977
    virDomainDefSetMemoryTotal(def, initialmem + hotplugmem);

4978 4979
    return 0;
}
4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990


/**
 * 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
4991 4992
qemuDomainMemoryDeviceAlignSize(virDomainDefPtr def,
                                virDomainMemoryDefPtr mem)
4993
{
4994
    mem->size = VIR_ROUND_UP(mem->size, qemuDomainGetMemorySizeAlignment(def));
4995
}
4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008


/**
 * qemuDomainGetMonitor:
 * @vm: domain object
 *
 * Returns the monitor pointer corresponding to the domain object @vm.
 */
qemuMonitorPtr
qemuDomainGetMonitor(virDomainObjPtr vm)
{
    return ((qemuDomainObjPrivatePtr) vm->privateData)->mon;
}
5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024


/**
 * 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;
5025 5026
    bool asynchronous = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_ASYNC);
    bool synchronous = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_SYNC);
5027

5028
    if (!synchronous && !asynchronous) {
5029 5030 5031 5032 5033 5034
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("block jobs not supported with this QEMU binary"));
        return -1;
    }

    if (modern)
5035
        *modern = asynchronous;
5036 5037 5038

    return 0;
}
5039 5040 5041 5042 5043 5044 5045 5046 5047


/**
 * 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.
 */
5048
virDomainChrDefPtr
5049 5050 5051 5052 5053 5054 5055 5056 5057 5058
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;

5059 5060
        if (STREQ_NULLABLE(channel->target.name, "org.qemu.guest_agent.0"))
            return channel;
5061 5062
    }

5063
    return NULL;
5064
}
5065 5066 5067 5068 5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083


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"));
}
5084 5085


5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103
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;
}


5104 5105 5106 5107 5108 5109
bool
qemuDomainMachineIsS390CCW(const virDomainDef *def)
{
    return STRPREFIX(def->os.machine, "s390-ccw");
}

5110

J
Ján Tomko 已提交
5111 5112 5113
bool
qemuDomainMachineIsVirt(const virDomainDef *def)
{
5114 5115 5116 5117 5118 5119 5120 5121 5122
    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 已提交
5123 5124 5125
}


5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138 5139
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;
}


5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186
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;
        }

5187 5188 5189
        if (virDomainNumaGetNodeCount(def->numa) != 0) {
            if (mem->targetNode == -1) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
Y
Yuri Chornoivan 已提交
5190
                               _("target NUMA node needs to be specified for "
5191 5192 5193
                                 "memory device"));
                return -1;
            }
5194 5195
        }

5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219
        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;
}


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
/**
 * 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;
5248 5249 5250

        if (qemuDomainDefValidateMemoryHotplugDevice(mem, def) < 0)
            return -1;
5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269
    }

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

5270 5271 5272 5273 5274 5275 5276 5277 5278 5279 5280
    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;
        }
5281 5282 5283 5284 5285 5286 5287 5288 5289
    }

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

5290
    for (i = 0; i < def->nmems; i++) {
5291 5292
        hotplugMemory += def->mems[i]->size;

5293 5294 5295 5296 5297 5298
        /* already existing devices don't need to be checked on hotplug */
        if (!mem &&
            qemuDomainDefValidateMemoryHotplugDevice(def->mems[i], def) < 0)
            return -1;
    }

5299 5300 5301 5302 5303 5304 5305 5306 5307 5308
    if (hotplugMemory > hotplugSpace) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("memory device total size exceeds hotplug space"));
        return -1;
    }

    return 0;
}


5309 5310 5311 5312 5313 5314 5315 5316 5317 5318
bool
qemuDomainMachineHasBuiltinIDE(const virDomainDef *def)
{
    return qemuDomainMachineIsI440FX(def) ||
        STREQ(def->os.machine, "malta") ||
        STREQ(def->os.machine, "sun4u") ||
        STREQ(def->os.machine, "g3beige");
}


5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342
/**
 * 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 */
5343
    if (!virDomainDefHasMemballoon(vm->def)) {
5344
        vm->def->mem.cur_balloon = virDomainDefGetMemoryTotal(vm->def);
5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376
        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;

5377 5378
        vm->def->mem.cur_balloon = balloon;
    }
5379 5380 5381

    return 0;
}
5382 5383 5384


/**
5385
 * qemuDomainGetMemLockLimitBytes:
5386 5387 5388 5389
 *
 * @def: domain definition
 *
 * Returns the size of the memory in bytes that needs to be set as
5390
 * RLIMIT_MEMLOCK for the QEMU process.
5391 5392 5393 5394
 * 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
5395
qemuDomainGetMemLockLimitBytes(virDomainDefPtr def)
5396 5397 5398
{
    unsigned long long memKB;

5399 5400 5401 5402 5403 5404
    /* prefer the hard limit */
    if (virMemoryLimitIsSet(def->mem.hard_limit)) {
        memKB = def->mem.hard_limit;
        goto done;
    }

5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428
    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;
            }
        }

5429
        memory = virDomainDefGetMemoryTotal(def);
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 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482

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

5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500
    /* 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.
     */
5501
    memKB = virDomainDefGetMemoryTotal(def) + 1024 * 1024;
5502

5503
 done:
5504 5505
    return memKB << 10;
}
5506 5507 5508 5509 5510


/**
 * @def: domain definition
 *
5511 5512 5513
 * Returns true if the locked memory limit needs to be set or updated because
 * of domain configuration, VFIO passthrough devices or architecture-specific
 * requirements.
5514 5515
 * */
bool
5516
qemuDomainRequiresMemLock(virDomainDefPtr def)
5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531
{
    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;
    }

5532 5533 5534 5535
    /* 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;

5536 5537
    return false;
}
5538

5539 5540 5541 5542 5543 5544 5545
/**
 * qemuDomainAdjustMaxMemLock:
 * @vm: domain
 *
 * Adjust the memory locking limit for the QEMU process associated to @vm, in
 * order to comply with VFIO or architecture requirements.
 *
5546 5547 5548 5549
 * 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.
5550 5551 5552 5553 5554 5555 5556 5557 5558
 *
 * Returns: 0 on success, <0 on failure
 */
int
qemuDomainAdjustMaxMemLock(virDomainObjPtr vm)
{
    unsigned long long bytes = 0;
    int ret = -1;

5559
    if (qemuDomainRequiresMemLock(vm->def)) {
5560 5561 5562 5563 5564 5565 5566 5567
        /* 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;
        }
5568
        bytes = qemuDomainGetMemLockLimitBytes(vm->def);
5569 5570 5571 5572 5573 5574
    } 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;
    }
5575 5576 5577 5578 5579 5580 5581 5582 5583 5584

    /* 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;
}
5585 5586 5587 5588 5589 5590 5591 5592 5593 5594

/**
 * qemuDomainHasVcpuPids:
 * @vm: Domain object
 *
 * Returns true if we were able to successfully detect vCPU pids for the VM.
 */
bool
qemuDomainHasVcpuPids(virDomainObjPtr vm)
{
5595 5596 5597 5598 5599 5600
    size_t i;
    size_t maxvcpus = virDomainDefGetVcpusMax(vm->def);
    virDomainVcpuDefPtr vcpu;

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

5602 5603 5604 5605 5606
        if (QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->tid > 0)
            return true;
    }

    return false;
5607
}
5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618


/**
 * 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,
5619
                     unsigned int vcpuid)
5620
{
5621 5622
    virDomainVcpuDefPtr vcpu = virDomainDefGetVcpu(vm->def, vcpuid);
    return QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->tid;
5623
}
5624 5625 5626 5627 5628 5629 5630 5631 5632 5633


/**
 * qemuDomainDetectVcpuPids:
 * @driver: qemu driver data
 * @vm: domain object
 * @asyncJob: current asynchronous job type
 *
 * Updates vCPU thread ids in the private data of @vm.
 *
5634
 * Returns number of detected vCPU threads on success, -1 on error and reports
5635
 * an appropriate error, -2 if the domain doesn't exist any more.
5636 5637 5638 5639 5640 5641
 */
int
qemuDomainDetectVcpuPids(virQEMUDriverPtr driver,
                         virDomainObjPtr vm,
                         int asyncJob)
{
5642 5643
    virDomainVcpuDefPtr vcpu;
    size_t maxvcpus = virDomainDefGetVcpusMax(vm->def);
5644
    pid_t *cpupids = NULL;
5645 5646 5647
    int ncpupids;
    size_t i;
    int ret = -1;
5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676

    /*
     * 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.
     */
5677
    if (vm->def->virtType == VIR_DOMAIN_VIRT_QEMU)
5678
        return 0;
5679 5680 5681

    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
        return -1;
5682
    ncpupids = qemuMonitorGetCPUInfo(qemuDomainGetMonitor(vm), &cpupids);
5683
    if (qemuDomainObjExitMonitor(driver, vm) < 0) {
5684 5685
        ret = -2;
        goto cleanup;
5686
    }
5687

5688
    /* failure to get the VCPU <-> PID mapping or to execute the query
5689 5690 5691 5692
     * command will not be treated fatal as some versions of qemu don't
     * support this command */
    if (ncpupids <= 0) {
        virResetLastError();
5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703
        ret = 0;
        goto cleanup;
    }

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

        if (i < ncpupids)
            QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->tid = cpupids[i];
        else
            QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->tid = 0;
5704 5705 5706 5707 5708 5709 5710
    }

    if (ncpupids != virDomainDefGetVcpus(vm->def)) {
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("got wrong number of vCPU pids from QEMU monitor. "
                         "got %d, wanted %d"),
                       ncpupids, virDomainDefGetVcpus(vm->def));
5711
        goto cleanup;
5712 5713
    }

5714 5715 5716 5717 5718
    ret = ncpupids;

 cleanup:
    VIR_FREE(cpupids);
    return ret;
5719
}
5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740


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)
{
5741
    if (!qemuDomainSupportsNicdev(def, net))
5742 5743 5744
        return false;
    return virQEMUCapsGet(qemuCaps, QEMU_CAPS_NETDEV);
}
J
John Ferlan 已提交
5745 5746 5747 5748 5749 5750 5751


int
qemuDomainNetVLAN(virDomainNetDefPtr def)
{
    return qemuDomainDeviceAliasIndex(&def->info, "net");
}
P
Peter Krempa 已提交
5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767


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;
}
5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798


/**
 * 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;
}
5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818


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

        channel->source.data.nix.listen = true;
    }

    return 0;
}