qemu_domain.c 187.4 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
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
857
qemuDomainVcpuPrivateDispose(void *obj)
858
{
859 860 861 862
    qemuDomainVcpuPrivatePtr priv = obj;

    VIR_FREE(priv->type);
    VIR_FREE(priv->alias);
863 864 865 866
    return;
}


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

889
    return virSecretGetSecretString(conn, seclookupdef, secretUsageType,
890 891
                                    &secinfo->s.plain.secret,
                                    &secinfo->s.plain.secretlen);
892 893 894
}


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

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


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


1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
/* 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);

1026
    if (!diskPriv || !diskPriv->secinfo)
1027 1028 1029 1030 1031 1032
        return;

    qemuDomainSecretInfoFree(&diskPriv->secinfo);
}


1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046
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;
}


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

1065 1066 1067 1068
    if (!conn)
        return 0;

    if (qemuDomainSecretDiskCapable(src)) {
1069
        virSecretUsageType secretUsageType = VIR_SECRET_USAGE_TYPE_ISCSI;
1070 1071 1072 1073

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

1074 1075 1076
        if (src->protocol == VIR_STORAGE_NET_PROTOCOL_RBD)
            secretUsageType = VIR_SECRET_USAGE_TYPE_CEPH;

1077
        if (qemuDomainSecretSetup(conn, priv, secinfo, disk->info.alias,
1078
                                  secretUsageType, src->auth->username,
1079
                                  &src->auth->seclookupdef, false) < 0)
1080 1081 1082 1083 1084
            goto error;

        diskPriv->secinfo = secinfo;
    }

1085
    if (!virStorageSourceIsEmpty(src) && src->encryption &&
1086
        src->encryption->format == VIR_STORAGE_ENCRYPTION_FORMAT_LUKS) {
1087 1088 1089 1090 1091 1092 1093 1094 1095 1096

        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;

1097 1098 1099 1100 1101 1102 1103
        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;
        }

1104 1105 1106
        diskPriv->encinfo = secinfo;
    }

1107 1108 1109 1110 1111 1112 1113 1114
    return 0;

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


1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125
/* 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);

1126
    if (!hostdevPriv || !hostdevPriv->secinfo)
1127 1128 1129 1130 1131 1132 1133 1134
        return;

    qemuDomainSecretInfoFree(&hostdevPriv->secinfo);
}


/* qemuDomainSecretHostdevPrepare:
 * @conn: Pointer to connection
J
John Ferlan 已提交
1135
 * @priv: pointer to domain private object
1136 1137 1138 1139 1140 1141 1142 1143
 * @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,
1144
                               qemuDomainObjPrivatePtr priv,
1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164
                               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;

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

            hostdevPriv->secinfo = secinfo;
        }
    }

    return 0;

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


1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195
/* 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]);
1196 1197 1198

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


/* 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 已提交
1218
    qemuDomainObjPrivatePtr priv = vm->privateData;
1219 1220 1221
    size_t i;

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

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

1232 1233 1234 1235
    return 0;
}


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

M
Martin Kletzander 已提交
1271 1272 1273
    if (!domname)
        goto cleanup;

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

1278
    if (!priv->channelTargetDir &&
M
Martin Kletzander 已提交
1279 1280
        virAsprintf(&priv->channelTargetDir, "%s/domain-%s",
                    cfg->channelTargetDir, domname) < 0)
1281
        goto cleanup;
1282

1283 1284 1285
    ret = 0;
 cleanup:
    virObjectUnref(cfg);
M
Martin Kletzander 已提交
1286
    VIR_FREE(domname);
1287
    return ret;
1288 1289 1290
}


1291 1292 1293 1294 1295 1296 1297 1298 1299 1300
void
qemuDomainClearPrivatePaths(virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;

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


1301 1302
static void *
qemuDomainObjPrivateAlloc(void)
1303 1304 1305 1306 1307 1308
{
    qemuDomainObjPrivatePtr priv;

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

1309 1310 1311
    if (qemuDomainObjInitJob(priv) < 0) {
        virReportSystemError(errno, "%s",
                             _("Unable to init qemu driver mutexes"));
1312
        goto error;
1313
    }
1314

1315
    if (!(priv->devs = virChrdevAlloc()))
1316 1317
        goto error;

1318
    priv->migMaxBandwidth = QEMU_DOMAIN_MIG_BANDWIDTH_MAX;
1319

1320
    return priv;
1321

1322
 error:
1323 1324
    VIR_FREE(priv);
    return NULL;
1325 1326
}

1327 1328
static void
qemuDomainObjPrivateFree(void *data)
1329 1330 1331
{
    qemuDomainObjPrivatePtr priv = data;

1332
    virObjectUnref(priv->qemuCaps);
1333

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

1342
    virStringFreeList(priv->qemuDevices);
1343
    virChrdevFree(priv->devs);
1344

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

    VIR_FREE(priv->libDir);
    VIR_FREE(priv->channelTargetDir);
1360
    qemuDomainMasterKeyFree(priv);
1361

1362 1363 1364 1365
    VIR_FREE(priv);
}


1366 1367
static void
qemuDomainObjPrivateXMLFormatVcpus(virBufferPtr buf,
1368
                                   virDomainDefPtr def)
1369 1370
{
    size_t i;
1371 1372 1373
    size_t maxvcpus = virDomainDefGetVcpusMax(def);
    virDomainVcpuDefPtr vcpu;
    pid_t tid;
1374 1375 1376 1377

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

1378 1379 1380 1381 1382 1383 1384 1385 1386
    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);
    }
1387 1388 1389 1390 1391 1392

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


1393
static int
1394 1395
qemuDomainObjPrivateXMLFormat(virBufferPtr buf,
                              virDomainObjPtr vm)
1396
{
1397
    qemuDomainObjPrivatePtr priv = vm->privateData;
1398
    const char *monitorpath;
1399
    qemuDomainJob job;
1400 1401 1402

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

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

1420
    qemuDomainObjPrivateXMLFormatVcpus(buf, vm->def);
1421

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

1436
    if (priv->lockState)
1437
        virBufferAsprintf(buf, "<lockstate>%s</lockstate>\n", priv->lockState);
1438

1439 1440 1441 1442
    job = priv->job.active;
    if (!qemuDomainTrackJob(job))
        priv->job.active = QEMU_JOB_NONE;

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

1476
    if (priv->fakeReboot)
1477
        virBufferAddLit(buf, "<fakereboot/>\n");
1478

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

1491 1492 1493 1494 1495 1496 1497 1498 1499 1500
    if (priv->autoNodeset) {
        char *nodeset = virBitmapFormat(priv->autoNodeset);

        if (!nodeset)
            return -1;

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

1501 1502 1503 1504 1505
    /* Various per-domain paths */
    virBufferEscapeString(buf, "<libDir path='%s'/>\n", priv->libDir);
    virBufferEscapeString(buf, "<channelTargetDir path='%s'/>\n",
                          priv->channelTargetDir);

1506 1507 1508
    return 0;
}

1509 1510 1511 1512

static int
qemuDomainObjPrivateXMLParseVcpu(xmlNodePtr node,
                                 unsigned int idx,
1513
                                 virDomainDefPtr def)
1514
{
1515
    virDomainVcpuDefPtr vcpu;
1516
    char *idstr;
1517
    char *pidstr;
1518
    unsigned int tmp;
1519 1520
    int ret = -1;

1521 1522
    idstr = virXMLPropString(node, "id");

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

1535 1536 1537
    if (!(pidstr = virXMLPropString(node, "pid")))
        goto cleanup;

1538
    if (virStrToLong_uip(pidstr, NULL, 10, &tmp) < 0)
1539 1540
        goto cleanup;

1541 1542
    QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->tid = tmp;

1543 1544 1545
    ret = 0;

 cleanup:
1546
    VIR_FREE(idstr);
1547 1548 1549 1550 1551
    VIR_FREE(pidstr);
    return ret;
}


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

1567
    if (VIR_ALLOC(priv->monConfig) < 0)
1568 1569 1570 1571
        goto error;

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

    tmp = virXPathString("string(./monitor[1]/@type)", ctxt);
    if (tmp)
1579
        priv->monConfig->type = virDomainChrTypeFromString(tmp);
1580
    else
1581
        priv->monConfig->type = VIR_DOMAIN_CHR_TYPE_PTY;
1582 1583
    VIR_FREE(tmp);

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

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

1602
    if ((n = virXPathNodeSet("./vcpus/vcpu", ctxt, &nodes)) < 0)
1603 1604
        goto error;

1605
    for (i = 0; i < n; i++) {
1606
        if (qemuDomainObjPrivateXMLParseVcpu(nodes[i], i, vm->def) < 0)
1607
            goto error;
1608
    }
1609
    VIR_FREE(nodes);
1610

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

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

1635
        priv->qemuCaps = qemuCaps;
1636
        qemuCaps = NULL;
1637 1638 1639
    }
    VIR_FREE(nodes);

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

1642 1643 1644 1645
    if ((tmp = virXPathString("string(./job[1]/@type)", ctxt))) {
        int type;

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

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

1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701
    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);

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

1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724
    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);

1725 1726 1727 1728
    if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
        goto error;

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

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

1740 1741 1742 1743 1744 1745 1746 1747 1748
    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;

1749 1750
    return 0;

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


1764 1765 1766
virDomainXMLPrivateDataCallbacks virQEMUDriverPrivateDataCallbacks = {
    .alloc = qemuDomainObjPrivateAlloc,
    .free = qemuDomainObjPrivateFree,
1767
    .diskNew = qemuDomainDiskPrivateNew,
1768
    .vcpuNew = qemuDomainVcpuPrivateNew,
1769
    .hostdevNew = qemuDomainHostdevPrivateNew,
1770 1771 1772 1773 1774
    .parse = qemuDomainObjPrivateXMLParse,
    .format = qemuDomainObjPrivateXMLFormat,
};


1775 1776 1777 1778 1779
static void
qemuDomainDefNamespaceFree(void *nsdata)
{
    qemuDomainCmdlineDefPtr cmd = nsdata;

1780
    qemuDomainCmdlineDefFree(cmd);
1781 1782 1783
}

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

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

1802
    if (VIR_ALLOC(cmd) < 0)
1803 1804 1805 1806 1807 1808
        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 已提交
1809
    uses_qemu_ns |= n > 0;
1810 1811

    if (n && VIR_ALLOC_N(cmd->args, n) < 0)
1812
        goto error;
1813 1814 1815 1816

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

    if (n && VIR_ALLOC_N(cmd->env_name, n) < 0)
1833
        goto error;
1834 1835

    if (n && VIR_ALLOC_N(cmd->env_value, n) < 0)
1836
        goto error;
1837 1838 1839 1840 1841 1842

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

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

    return 0;

1879
 error:
1880 1881 1882 1883 1884 1885 1886 1887 1888 1889
    VIR_FREE(nodes);
    qemuDomainDefNamespaceFree(cmd);
    return -1;
}

static int
qemuDomainDefNamespaceFormatXML(virBufferPtr buf,
                                void *nsdata)
{
    qemuDomainCmdlineDefPtr cmd = nsdata;
1890
    size_t i;
1891 1892 1893 1894

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

1895 1896 1897
    virBufferAddLit(buf, "<qemu:commandline>\n");
    virBufferAdjustIndent(buf, 2);

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

1908 1909
    virBufferAdjustIndent(buf, -2);
    virBufferAddLit(buf, "</qemu:commandline>\n");
1910 1911 1912 1913 1914 1915 1916 1917 1918 1919
    return 0;
}

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


1920 1921 1922 1923 1924 1925
virDomainXMLNamespace virQEMUDriverDomainXMLNamespace = {
    .parse = qemuDomainDefNamespaceParse,
    .free = qemuDomainDefNamespaceFree,
    .format = qemuDomainDefNamespaceFormatXML,
    .href = qemuDomainDefNamespaceHref,
};
1926

1927

P
Pavel Hrdina 已提交
1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946
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;
}


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

P
Pavel Hrdina 已提交
1963 1964 1965 1966
    /* add implicit input devices */
    if (qemuDomainDefAddImplicitInputDevice(def) < 0)
        goto cleanup;

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

            /* 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;
1986
            break;
L
Laine Stump 已提交
1987
        }
1988 1989
        if (qemuDomainMachineIsI440FX(def))
            addPCIRoot = true;
1990 1991
        break;

1992
    case VIR_ARCH_ARMV7L:
1993
    case VIR_ARCH_AARCH64:
1994 1995
        addDefaultUSB = false;
        addDefaultMemballoon = false;
J
Ján Tomko 已提交
1996
        if (qemuDomainMachineIsVirt(def))
1997 1998
            addPCIeRoot = virQEMUCapsGet(qemuCaps, QEMU_CAPS_OBJECT_GPEX);
        break;
1999

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

2012 2013 2014 2015 2016 2017 2018
    case VIR_ARCH_ALPHA:
    case VIR_ARCH_PPC:
    case VIR_ARCH_PPCEMB:
    case VIR_ARCH_SH4:
    case VIR_ARCH_SH4EB:
        addPCIRoot = true;
        break;
2019

2020 2021 2022
    case VIR_ARCH_S390:
    case VIR_ARCH_S390X:
        addDefaultUSB = false;
2023
        addPanicDevice = true;
2024
        break;
2025 2026 2027 2028 2029 2030

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

2031 2032 2033 2034
    default:
        break;
    }

2035
    if (addDefaultUSB &&
2036 2037
        virDomainControllerFind(def, VIR_DOMAIN_CONTROLLER_TYPE_USB, 0) < 0 &&
        virDomainDefAddUSBController(def, 0, usbModel) < 0)
2038
        goto cleanup;
2039

2040 2041 2042
    if (addImplicitSATA &&
        virDomainDefMaybeAddController(
            def, VIR_DOMAIN_CONTROLLER_TYPE_SATA, 0, -1) < 0)
2043
        goto cleanup;
2044

2045 2046
    pciRoot = virDomainControllerFind(def, VIR_DOMAIN_CONTROLLER_TYPE_PCI, 0);

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

2066 2067 2068
    /* 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
2069 2070 2071
     *
     * NB: any machine that sets addPCIeRoot to true must also return
     * true from the function qemuDomainSupportsPCI().
2072 2073
     */
    if (addPCIeRoot) {
2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086
        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;
        }
2087
        /* Add a dmi-to-pci-bridge bridge if there are no PCI controllers
2088
         * other than the pcie-root. This is so that there will be hot-pluggable
2089 2090 2091 2092
         * 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
2093 2094
         */
        if (virDomainControllerFind(def, VIR_DOMAIN_CONTROLLER_TYPE_PCI, 1) < 0 &&
2095
            !qemuDomainMachineIsVirt(def) &&
2096
            !virDomainDefAddController(def, VIR_DOMAIN_CONTROLLER_TYPE_PCI, 1,
2097
                                       VIR_DOMAIN_CONTROLLER_MODEL_DMI_TO_PCI_BRIDGE))
2098
            goto cleanup;
2099
    }
2100

2101
    if (addDefaultMemballoon && !def->memballoon) {
2102 2103
        virDomainMemballoonDefPtr memballoon;
        if (VIR_ALLOC(memballoon) < 0)
2104
            goto cleanup;
2105 2106 2107 2108 2109

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

2110 2111 2112 2113 2114
    if (addDefaultUSBKBD &&
        def->ngraphics > 0 &&
        virDomainDefMaybeAddInput(def,
                                  VIR_DOMAIN_INPUT_TYPE_KBD,
                                  VIR_DOMAIN_INPUT_BUS_USB) < 0)
2115
        goto cleanup;
2116 2117 2118 2119 2120 2121

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

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

D
Dmitry Andreev 已提交
2135 2136 2137 2138 2139 2140 2141 2142 2143
        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;
            }
        }
2144 2145
    }

2146 2147 2148 2149 2150 2151
    ret = 0;
 cleanup:
    return ret;
}


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

2186 2187 2188
        /* 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;
2189 2190
    }

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


2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217
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;
}


2218
static int
2219 2220 2221 2222 2223
qemuDomainRecheckInternalPaths(virDomainDefPtr def,
                               virQEMUDriverConfigPtr cfg,
                               unsigned int flags)
{
    size_t i = 0;
2224
    size_t j = 0;
2225 2226 2227 2228

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

2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246
        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;
                }
2247
            }
2248 2249
        }
    }
2250 2251

    return 0;
2252 2253 2254
}


2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324
static int
qemuDomainDefVcpusPostParse(virDomainDefPtr def)
{
    unsigned int maxvcpus = virDomainDefGetVcpusMax(def);
    virDomainVcpuDefPtr vcpu;
    virDomainVcpuDefPtr prevvcpu;
    size_t i;
    bool has_order = false;

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

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

    prevvcpu = vcpu;

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

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

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

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

        prevvcpu = vcpu;
    }

    return 0;
}


2325 2326 2327
static int
qemuDomainDefPostParse(virDomainDefPtr def,
                       virCapsPtr caps,
2328
                       unsigned int parseFlags,
2329 2330 2331
                       void *opaque)
{
    virQEMUDriverPtr driver = opaque;
2332
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
2333 2334 2335 2336 2337 2338
    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"));
2339
        goto cleanup;
2340 2341
    }

2342 2343 2344
    if (!def->os.machine) {
        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                       _("missing machine type"));
2345
        goto cleanup;
2346 2347
    }

2348 2349 2350 2351 2352 2353 2354 2355 2356
    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;
    }

2357 2358 2359
    /* check for emulator and create a default one if needed */
    if (!def->emulator &&
        !(def->emulator = virDomainDefGetDefaultEmulator(def, caps)))
2360
        goto cleanup;
2361

2362 2363 2364
    if (!(qemuCaps = virQEMUCapsCacheLookup(driver->qemuCapsCache,
                                            def->emulator)))
        goto cleanup;
2365 2366 2367 2368

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

2369 2370 2371
    if (qemuCanonicalizeMachine(def, qemuCaps) < 0)
        goto cleanup;

2372
    qemuDomainDefEnableDefaultFeatures(def, qemuCaps);
A
Andrea Bolognani 已提交
2373

2374 2375
    if (qemuDomainRecheckInternalPaths(def, cfg, parseFlags) < 0)
        goto cleanup;
2376

2377 2378 2379
    if (virSecurityManagerVerify(driver->securityManager, def) < 0)
        goto cleanup;

2380 2381 2382
    if (qemuDomainDefVcpusPostParse(def) < 0)
        goto cleanup;

2383 2384 2385
    ret = 0;
 cleanup:
    virObjectUnref(qemuCaps);
2386
    virObjectUnref(cfg);
2387
    return ret;
2388 2389
}

2390 2391 2392 2393

static int
qemuDomainDefValidate(const virDomainDef *def,
                      virCapsPtr caps ATTRIBUTE_UNUSED,
2394
                      void *opaque)
2395
{
2396 2397 2398 2399 2400 2401 2402 2403 2404
    virQEMUDriverPtr driver = opaque;
    virQEMUCapsPtr qemuCaps = NULL;
    size_t topologycpus;
    int ret = -1;

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

2405 2406 2407
    if (def->mem.min_guarantee) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("Parameter 'min_guarantee' not supported by QEMU."));
2408
        goto cleanup;
2409 2410
    }

M
Michal Privoznik 已提交
2411 2412 2413 2414 2415 2416 2417 2418
    if (def->os.loader &&
        def->os.loader->secure == VIR_TRISTATE_BOOL_YES) {
        /* These are the QEMU implementation limitations. But we
         * have to live with them for now. */

        if (!qemuDomainMachineIsQ35(def)) {
            virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                           _("Secure boot is supported with q35 machine types only"));
2419
            goto cleanup;
M
Michal Privoznik 已提交
2420 2421 2422 2423 2424 2425 2426 2427
        }

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

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

2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455
    /* qemu as of 2.5.0 rejects SMP topologies that don't match the cpu count */
    if (def->cpu && def->cpu->sockets) {
        topologycpus = def->cpu->sockets * def->cpu->cores * def->cpu->threads;
        if (topologycpus != virDomainDefGetVcpusMax(def)) {
            /* presence of query-hotpluggable-cpus should be a good enough witness */
            if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS)) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("CPU topology doesn't match maximum vcpu count"));
                goto cleanup;
            }
        }
    }

    ret = 0;

 cleanup:
    virObjectUnref(qemuCaps);
    return ret;
2456 2457 2458
}


2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486
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;
}


2487
static const char *
2488 2489
qemuDomainDefaultNetModel(const virDomainDef *def,
                          virQEMUCapsPtr qemuCaps)
2490
{
2491
    if (ARCH_IS_S390(def->os.arch))
2492 2493
        return "virtio";

2494 2495
    if (def->os.arch == VIR_ARCH_ARMV7L ||
        def->os.arch == VIR_ARCH_AARCH64) {
2496 2497 2498
        if (STREQ(def->os.machine, "versatilepb"))
            return "smc91c111";

J
Ján Tomko 已提交
2499
        if (qemuDomainMachineIsVirt(def))
2500 2501
            return "virtio";

2502 2503 2504 2505 2506
        /* Incomplete. vexpress (and a few others) use this, but not all
         * arm boards */
        return "lan9118";
    }

2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518
    /* 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 */
2519 2520
    return "rtl8139";
}
2521

2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544

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


2545 2546
static int
qemuDomainDeviceDefPostParse(virDomainDeviceDefPtr dev,
2547
                             const virDomainDef *def,
2548
                             virCapsPtr caps ATTRIBUTE_UNUSED,
2549
                             unsigned int parseFlags,
2550
                             void *opaque)
2551
{
2552
    virQEMUDriverPtr driver = opaque;
2553
    virQEMUCapsPtr qemuCaps = NULL;
2554
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
2555
    int ret = -1;
2556

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

2559
    if (dev->type == VIR_DOMAIN_DEVICE_NET &&
2560 2561
        dev->data.net->type != VIR_DOMAIN_NET_TYPE_HOSTDEV &&
        !dev->data.net->model) {
2562
        if (VIR_STRDUP(dev->data.net->model,
2563
                       qemuDomainDefaultNetModel(def, qemuCaps)) < 0)
2564
            goto cleanup;
2565
    }
2566

2567 2568 2569 2570
    /* set default disk types and drivers */
    if (dev->type == VIR_DOMAIN_DEVICE_DISK) {
        virDomainDiskDefPtr disk = dev->data.disk;

2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598
        /* 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;
2599 2600 2601
        }
    }

2602 2603 2604 2605
    /* 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 &&
2606
        ARCH_IS_S390(def->os.arch))
2607 2608
        dev->data.chr->targetType = VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO;

2609 2610 2611 2612 2613
    /* 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 &&
2614
        ARCH_IS_S390(def->os.arch))
2615 2616
        dev->data.controller->model = VIR_DOMAIN_CONTROLLER_MODEL_USB_NONE;

2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629
    /* 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;
    }


2630 2631 2632 2633 2634 2635 2636
    /* 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;

2637 2638
    /* clear auto generated unix socket path for inactive definitions */
    if ((parseFlags & VIR_DOMAIN_DEF_PARSE_INACTIVE) &&
2639 2640
        dev->type == VIR_DOMAIN_DEVICE_CHR)
        qemuDomainChrDefDropDefaultPath(dev->data.chr, driver);
2641

2642 2643 2644 2645 2646 2647 2648 2649 2650 2651
    /* 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;
    }

2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666
    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 {
2667
            dev->data.video->vgamem = QEMU_QXL_VGAMEM_DEFAULT;
2668 2669 2670
        }
    }

2671 2672
    if (dev->type == VIR_DOMAIN_DEVICE_PANIC &&
        dev->data.panic->model == VIR_DOMAIN_PANIC_MODEL_DEFAULT) {
2673
        if (qemuDomainMachineIsPSeries(def))
2674
            dev->data.panic->model = VIR_DOMAIN_PANIC_MODEL_PSERIES;
2675 2676
        else if (ARCH_IS_S390(def->os.arch))
            dev->data.panic->model = VIR_DOMAIN_PANIC_MODEL_S390;
2677 2678 2679 2680
        else
            dev->data.panic->model = VIR_DOMAIN_PANIC_MODEL_ISA;
    }

2681 2682 2683 2684

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

2685 2686 2687
        if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_PCI) {
            if (cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCI_EXPANDER_BUS &&
                !qemuDomainMachineIsI440FX(def)) {
2688 2689 2690 2691 2692
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("pci-expander-bus controllers are only supported "
                                 "on 440fx-based machinetypes"));
                goto cleanup;
            }
2693 2694 2695 2696 2697 2698 2699
            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;
            }
2700 2701 2702 2703 2704 2705

            /* 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.
             */
2706 2707 2708
            if ((cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCI_EXPANDER_BUS ||
                 cont->model == VIR_DOMAIN_CONTROLLER_MODEL_PCIE_EXPANDER_BUS) &&
                (int) virDomainNumaGetNodeCount(def->numa)
2709 2710
                <= cont->opts.pciopts.numaNode) {
                virReportError(VIR_ERR_XML_ERROR,
2711
                               _("%s with index %d is "
2712 2713 2714
                                 "configured for a NUMA node (%d) "
                                 "not present in the domain's "
                                 "<cpu><numa> array (%zu)"),
2715
                               virDomainControllerModelPCITypeToString(cont->model),
2716 2717 2718 2719
                               cont->idx, cont->opts.pciopts.numaNode,
                               virDomainNumaGetNodeCount(def->numa));
                goto cleanup;
            }
2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739
        } else if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
                   cont->model == -1) {
            /* Pick a suitable default model for the USB controller if none
             * has been selected by the user.
             *
             * We rely on device availability instead of setting the model
             * unconditionally because, for some machine types, there's a
             * chance we will get away with using the legacy USB controller
             * when the relevant device is not available.
             *
             * See qemuBuildControllerDevCommandLine() */
            if (ARCH_IS_PPC64(def->os.arch)) {
                /* Default USB controller for ppc64 is pci-ohci */
                if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_PCI_OHCI))
                    cont->model = VIR_DOMAIN_CONTROLLER_MODEL_USB_PCI_OHCI;
            } else {
                /* Default USB controller for anything else is piix3-uhci */
                if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_PIIX3_USB_UHCI))
                    cont->model = VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX3_UHCI;
            }
2740 2741 2742
        }
    }

2743 2744
    ret = 0;

2745
 cleanup:
2746
    virObjectUnref(qemuCaps);
2747 2748
    virObjectUnref(cfg);
    return ret;
2749 2750 2751
}


2752 2753 2754 2755 2756 2757 2758 2759 2760
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;
2761
    bool newDomain = parseFlags & VIR_DOMAIN_DEF_PARSE_ABI_UPDATE;
2762 2763 2764 2765 2766

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

2767
    if (qemuDomainAssignAddresses(def, qemuCaps, NULL, newDomain) < 0)
2768 2769 2770 2771 2772 2773 2774 2775 2776
        goto cleanup;

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


2777 2778
virDomainDefParserConfig virQEMUDriverDomainDefParserConfig = {
    .devicesPostParseCallback = qemuDomainDeviceDefPostParse,
2779
    .domainPostParseCallback = qemuDomainDefPostParse,
2780
    .assignAddressesCallback = qemuDomainDefAssignAddresses,
2781
    .domainValidateCallback = qemuDomainDefValidate,
2782 2783
    .deviceValidateCallback = qemuDomainDeviceDefValidate,

2784
    .features = VIR_DOMAIN_DEF_FEATURE_MEMORY_HOTPLUG |
2785 2786
                VIR_DOMAIN_DEF_FEATURE_OFFLINE_VCPUPIN |
                VIR_DOMAIN_DEF_FEATURE_INDIVIDUAL_VCPUS,
2787 2788 2789
};


2790
static void
2791
qemuDomainObjSaveJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
2792
{
2793 2794 2795
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);

    if (virDomainObjIsActive(obj)) {
2796
        if (virDomainSaveStatus(driver->xmlopt, cfg->stateDir, obj, driver->caps) < 0)
2797
            VIR_WARN("Failed to save status on vm %s", obj->def->name);
2798
    }
2799

2800
    virObjectUnref(cfg);
2801 2802
}

J
Jiri Denemark 已提交
2803
void
2804
qemuDomainObjSetJobPhase(virQEMUDriverPtr driver,
J
Jiri Denemark 已提交
2805 2806 2807 2808
                         virDomainObjPtr obj,
                         int phase)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
2809
    unsigned long long me = virThreadSelfID();
J
Jiri Denemark 已提交
2810 2811 2812 2813

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

2814 2815 2816 2817 2818
    VIR_DEBUG("Setting '%s' phase to '%s'",
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
              qemuDomainAsyncJobPhaseToString(priv->job.asyncJob, phase));

    if (priv->job.asyncOwner && me != priv->job.asyncOwner) {
2819
        VIR_WARN("'%s' async job is owned by thread %llu",
2820 2821 2822 2823
                 qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
                 priv->job.asyncOwner);
    }

J
Jiri Denemark 已提交
2824
    priv->job.phase = phase;
2825
    priv->job.asyncOwner = me;
J
Jiri Denemark 已提交
2826 2827 2828
    qemuDomainObjSaveJob(driver, obj);
}

2829
void
2830 2831
qemuDomainObjSetAsyncJobMask(virDomainObjPtr obj,
                             unsigned long long allowedJobs)
2832 2833 2834
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

2835 2836 2837 2838 2839 2840 2841
    if (!priv->job.asyncJob)
        return;

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

void
2842
qemuDomainObjDiscardAsyncJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
2843 2844 2845 2846 2847 2848
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

    if (priv->job.active == QEMU_JOB_ASYNC_NESTED)
        qemuDomainObjResetJob(priv);
    qemuDomainObjResetAsyncJob(priv);
2849
    qemuDomainObjSaveJob(driver, obj);
2850 2851
}

2852 2853 2854 2855 2856 2857 2858 2859 2860
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()) {
2861
        VIR_WARN("'%s' async job is owned by thread %llu",
2862 2863 2864 2865 2866 2867
                 qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
                 priv->job.asyncOwner);
    }
    priv->job.asyncOwner = 0;
}

2868
static bool
2869
qemuDomainNestedJobAllowed(qemuDomainObjPrivatePtr priv, qemuDomainJob job)
2870 2871
{
    return !priv->job.asyncJob || (priv->job.mask & JOB_MASK(job)) != 0;
2872 2873
}

2874
bool
2875
qemuDomainJobAllowed(qemuDomainObjPrivatePtr priv, qemuDomainJob job)
2876 2877 2878 2879
{
    return !priv->job.active && qemuDomainNestedJobAllowed(priv, job);
}

2880 2881 2882
/* Give up waiting for mutex after 30 seconds */
#define QEMU_JOB_WAIT_TIME (1000ull * 30)

2883
/*
2884
 * obj must be locked before calling
2885
 */
2886
static int ATTRIBUTE_NONNULL(1)
2887
qemuDomainObjBeginJobInternal(virQEMUDriverPtr driver,
2888
                              virDomainObjPtr obj,
2889 2890
                              qemuDomainJob job,
                              qemuDomainAsyncJob asyncJob)
2891 2892
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
J
Jiri Denemark 已提交
2893
    unsigned long long now;
2894
    unsigned long long then;
2895
    bool nested = job == QEMU_JOB_ASYNC_NESTED;
J
Jiri Denemark 已提交
2896
    bool async = job == QEMU_JOB_ASYNC;
2897
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
2898
    const char *blocker = NULL;
J
Jiri Denemark 已提交
2899
    int ret = -1;
J
Jiri Denemark 已提交
2900 2901
    unsigned long long duration = 0;
    unsigned long long asyncDuration = 0;
J
Jiri Denemark 已提交
2902
    const char *jobStr;
2903

J
Jiri Denemark 已提交
2904 2905 2906 2907 2908 2909 2910 2911 2912
    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));
2913

2914 2915
    if (virTimeMillisNow(&now) < 0) {
        virObjectUnref(cfg);
2916
        return -1;
2917 2918
    }

2919
    priv->jobs_queued++;
J
Jiri Denemark 已提交
2920
    then = now + QEMU_JOB_WAIT_TIME;
2921

2922
 retry:
2923 2924
    if (cfg->maxQueuedJobs &&
        priv->jobs_queued > cfg->maxQueuedJobs) {
2925 2926 2927
        goto error;
    }

2928
    while (!nested && !qemuDomainNestedJobAllowed(priv, job)) {
2929
        VIR_DEBUG("Waiting for async job (vm=%p name=%s)", obj, obj->def->name);
2930
        if (virCondWaitUntil(&priv->job.asyncCond, &obj->parent.lock, then) < 0)
2931 2932 2933
            goto error;
    }

2934
    while (priv->job.active) {
2935
        VIR_DEBUG("Waiting for job (vm=%p name=%s)", obj, obj->def->name);
2936
        if (virCondWaitUntil(&priv->job.cond, &obj->parent.lock, then) < 0)
2937
            goto error;
2938
    }
2939 2940 2941

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

2945
    qemuDomainObjResetJob(priv);
2946

J
Jiri Denemark 已提交
2947 2948
    ignore_value(virTimeMillisNow(&now));

2949
    if (job != QEMU_JOB_ASYNC) {
2950
        VIR_DEBUG("Started job: %s (async=%s vm=%p name=%s)",
2951
                   qemuDomainJobTypeToString(job),
2952 2953
                  qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
                  obj, obj->def->name);
2954
        priv->job.active = job;
2955
        priv->job.owner = virThreadSelfID();
2956
        priv->job.ownerAPI = virThreadJobGet();
J
Jiri Denemark 已提交
2957
        priv->job.started = now;
2958
    } else {
2959 2960 2961
        VIR_DEBUG("Started async job: %s (vm=%p name=%s)",
                  qemuDomainAsyncJobTypeToString(asyncJob),
                  obj, obj->def->name);
2962
        qemuDomainObjResetAsyncJob(priv);
J
Jiri Denemark 已提交
2963 2964
        if (VIR_ALLOC(priv->job.current) < 0)
            goto cleanup;
2965
        priv->job.asyncJob = asyncJob;
2966
        priv->job.asyncOwner = virThreadSelfID();
2967
        priv->job.asyncOwnerAPI = virThreadJobGet();
J
Jiri Denemark 已提交
2968
        priv->job.asyncStarted = now;
J
Jiri Denemark 已提交
2969
        priv->job.current->started = now;
2970
    }
2971

2972 2973
    if (qemuDomainTrackJob(job))
        qemuDomainObjSaveJob(driver, obj);
2974

2975
    virObjectUnref(cfg);
2976
    return 0;
2977

2978
 error:
J
Jiri Denemark 已提交
2979 2980 2981 2982 2983 2984
    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;

2985
    VIR_WARN("Cannot start job (%s, %s) for domain %s; "
J
Jiri Denemark 已提交
2986 2987
             "current job is (%s, %s) owned by (%llu %s, %llu %s) "
             "for (%llus, %llus)",
2988 2989 2990 2991 2992
             qemuDomainJobTypeToString(job),
             qemuDomainAsyncJobTypeToString(asyncJob),
             obj->def->name,
             qemuDomainJobTypeToString(priv->job.active),
             qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
2993
             priv->job.owner, NULLSTR(priv->job.ownerAPI),
J
Jiri Denemark 已提交
2994 2995
             priv->job.asyncOwner, NULLSTR(priv->job.asyncOwnerAPI),
             duration / 1000, asyncDuration / 1000);
2996 2997 2998 2999 3000

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

3002 3003
    ret = -1;
    if (errno == ETIMEDOUT) {
3004 3005 3006 3007 3008 3009 3010 3011
        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"));
        }
3012 3013 3014
        ret = -2;
    } else if (cfg->maxQueuedJobs &&
               priv->jobs_queued > cfg->maxQueuedJobs) {
3015 3016 3017 3018 3019 3020 3021 3022 3023 3024
        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"));
        }
3025 3026
        ret = -2;
    } else {
3027
        virReportSystemError(errno, "%s", _("cannot acquire job mutex"));
3028
    }
J
Jiri Denemark 已提交
3029 3030

 cleanup:
3031
    priv->jobs_queued--;
3032
    virObjectUnref(cfg);
3033
    return ret;
3034 3035 3036
}

/*
3037
 * obj must be locked before calling
3038 3039 3040 3041
 *
 * This must be called by anything that will change the VM state
 * in any way, or anything that will use the QEMU monitor.
 *
3042
 * Successful calls must be followed by EndJob eventually
3043
 */
3044
int qemuDomainObjBeginJob(virQEMUDriverPtr driver,
3045
                          virDomainObjPtr obj,
3046
                          qemuDomainJob job)
3047
{
3048 3049 3050 3051 3052
    if (qemuDomainObjBeginJobInternal(driver, obj, job,
                                      QEMU_ASYNC_JOB_NONE) < 0)
        return -1;
    else
        return 0;
3053 3054
}

3055
int qemuDomainObjBeginAsyncJob(virQEMUDriverPtr driver,
3056
                               virDomainObjPtr obj,
3057
                               qemuDomainAsyncJob asyncJob)
3058
{
3059 3060 3061 3062 3063
    if (qemuDomainObjBeginJobInternal(driver, obj, QEMU_JOB_ASYNC,
                                      asyncJob) < 0)
        return -1;
    else
        return 0;
3064 3065
}

3066
int
3067 3068
qemuDomainObjBeginNestedJob(virQEMUDriverPtr driver,
                            virDomainObjPtr obj,
3069
                            qemuDomainAsyncJob asyncJob)
3070 3071 3072 3073 3074 3075 3076 3077 3078 3079
{
    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()) {
3080
        VIR_WARN("This thread doesn't seem to be the async job owner: %llu",
3081 3082 3083 3084 3085 3086 3087 3088
                 priv->job.asyncOwner);
    }

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

3089

3090
/*
3091
 * obj must be locked and have a reference before calling
3092 3093 3094 3095
 *
 * To be called after completing the work associated with the
 * earlier qemuDomainBeginJob() call
 */
3096 3097
void
qemuDomainObjEndJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
3098 3099
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
3100
    qemuDomainJob job = priv->job.active;
3101

3102 3103
    priv->jobs_queued--;

3104
    VIR_DEBUG("Stopping job: %s (async=%s vm=%p name=%s)",
3105
              qemuDomainJobTypeToString(job),
3106 3107
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
              obj, obj->def->name);
3108

3109
    qemuDomainObjResetJob(priv);
3110 3111
    if (qemuDomainTrackJob(job))
        qemuDomainObjSaveJob(driver, obj);
3112
    virCondSignal(&priv->job.cond);
3113 3114
}

3115
void
3116
qemuDomainObjEndAsyncJob(virQEMUDriverPtr driver, virDomainObjPtr obj)
3117 3118
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
3119

3120 3121
    priv->jobs_queued--;

3122 3123 3124
    VIR_DEBUG("Stopping async job: %s (vm=%p name=%s)",
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
              obj, obj->def->name);
3125

3126
    qemuDomainObjResetAsyncJob(priv);
3127
    qemuDomainObjSaveJob(driver, obj);
3128 3129 3130
    virCondBroadcast(&priv->job.asyncCond);
}

3131 3132 3133 3134 3135
void
qemuDomainObjAbortAsyncJob(virDomainObjPtr obj)
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

3136 3137 3138
    VIR_DEBUG("Requesting abort of async job: %s (vm=%p name=%s)",
              qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
              obj, obj->def->name);
3139

3140 3141
    priv->job.abortJob = true;
    virDomainObjBroadcast(obj);
3142 3143
}

3144 3145 3146 3147 3148 3149 3150 3151 3152
/*
 * 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
 */
3153
static int
3154
qemuDomainObjEnterMonitorInternal(virQEMUDriverPtr driver,
3155
                                  virDomainObjPtr obj,
3156
                                  qemuDomainAsyncJob asyncJob)
3157 3158 3159
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

3160
    if (asyncJob != QEMU_ASYNC_JOB_NONE) {
3161 3162 3163
        int ret;
        if ((ret = qemuDomainObjBeginNestedJob(driver, obj, asyncJob)) < 0)
            return ret;
3164
        if (!virDomainObjIsActive(obj)) {
3165 3166
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("domain is no longer running"));
3167
            qemuDomainObjEndJob(driver, obj);
3168 3169
            return -1;
        }
3170 3171 3172
    } 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");
3173 3174
    }

3175 3176
    VIR_DEBUG("Entering monitor (mon=%p vm=%p name=%s)",
              priv->mon, obj, obj->def->name);
3177
    virObjectLock(priv->mon);
3178
    virObjectRef(priv->mon);
3179
    ignore_value(virTimeMillisNow(&priv->monStart));
3180
    virObjectUnlock(obj);
3181 3182

    return 0;
3183 3184
}

3185
static void ATTRIBUTE_NONNULL(1)
3186
qemuDomainObjExitMonitorInternal(virQEMUDriverPtr driver,
3187
                                 virDomainObjPtr obj)
3188 3189
{
    qemuDomainObjPrivatePtr priv = obj->privateData;
3190
    bool hasRefs;
3191

3192
    hasRefs = virObjectUnref(priv->mon);
3193

3194
    if (hasRefs)
3195
        virObjectUnlock(priv->mon);
3196

3197
    virObjectLock(obj);
3198 3199
    VIR_DEBUG("Exited monitor (mon=%p vm=%p name=%s)",
              priv->mon, obj, obj->def->name);
3200

3201
    priv->monStart = 0;
3202
    if (!hasRefs)
3203
        priv->mon = NULL;
3204

J
Jiri Denemark 已提交
3205 3206
    if (priv->job.active == QEMU_JOB_ASYNC_NESTED)
        qemuDomainObjEndJob(driver, obj);
3207 3208
}

3209
void qemuDomainObjEnterMonitor(virQEMUDriverPtr driver,
3210
                               virDomainObjPtr obj)
3211
{
3212
    ignore_value(qemuDomainObjEnterMonitorInternal(driver, obj,
3213
                                                   QEMU_ASYNC_JOB_NONE));
3214 3215
}

3216
/* obj must NOT be locked before calling
3217 3218
 *
 * Should be paired with an earlier qemuDomainObjEnterMonitor() call
3219 3220 3221 3222 3223 3224
 *
 * 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.
3225
 */
3226 3227
int qemuDomainObjExitMonitor(virQEMUDriverPtr driver,
                             virDomainObjPtr obj)
3228
{
3229
    qemuDomainObjExitMonitorInternal(driver, obj);
3230
    if (!virDomainObjIsActive(obj)) {
3231 3232 3233
        if (!virGetLastError())
            virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                           _("domain is no longer running"));
3234 3235 3236
        return -1;
    }
    return 0;
3237
}
3238 3239

/*
3240
 * obj must be locked before calling
3241 3242
 *
 * To be called immediately before any QEMU monitor API call.
3243
 * Must have already either called qemuDomainObjBeginJob()
3244 3245 3246 3247 3248
 * 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
3249 3250 3251
 * 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).
3252 3253
 */
int
3254
qemuDomainObjEnterMonitorAsync(virQEMUDriverPtr driver,
3255
                               virDomainObjPtr obj,
3256
                               qemuDomainAsyncJob asyncJob)
3257
{
3258
    return qemuDomainObjEnterMonitorInternal(driver, obj, asyncJob);
3259 3260
}

D
Daniel P. Berrange 已提交
3261

3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273
/**
 * qemuDomainGetAgent:
 * @vm: domain object
 *
 * Returns the agent pointer of @vm;
 */
qemuAgentPtr
qemuDomainGetAgent(virDomainObjPtr vm)
{
    return (((qemuDomainObjPrivatePtr)(vm->privateData))->agent);
}

D
Daniel P. Berrange 已提交
3274

3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285
/*
 * 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 已提交
3286 3287 3288
{
    qemuDomainObjPrivatePtr priv = obj->privateData;

3289 3290
    VIR_DEBUG("Entering agent (agent=%p vm=%p name=%s)",
              priv->agent, obj, obj->def->name);
3291
    virObjectLock(priv->agent);
3292
    virObjectRef(priv->agent);
D
Daniel P. Berrange 已提交
3293
    ignore_value(virTimeMillisNow(&priv->agentStart));
3294
    virObjectUnlock(obj);
D
Daniel P. Berrange 已提交
3295 3296
}

3297 3298 3299 3300 3301 3302 3303

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

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

3310
    if (hasRefs)
3311
        virObjectUnlock(priv->agent);
D
Daniel P. Berrange 已提交
3312

3313
    virObjectLock(obj);
3314 3315
    VIR_DEBUG("Exited agent (agent=%p vm=%p name=%s)",
              priv->agent, obj, obj->def->name);
D
Daniel P. Berrange 已提交
3316 3317

    priv->agentStart = 0;
3318
    if (!hasRefs)
D
Daniel P. Berrange 已提交
3319 3320 3321
        priv->agent = NULL;
}

3322
void qemuDomainObjEnterRemote(virDomainObjPtr obj)
3323
{
3324 3325
    VIR_DEBUG("Entering remote (vm=%p name=%s)",
              obj, obj->def->name);
3326
    virObjectUnlock(obj);
3327 3328
}

3329
void qemuDomainObjExitRemote(virDomainObjPtr obj)
3330
{
3331
    virObjectLock(obj);
3332 3333
    VIR_DEBUG("Exited remote (vm=%p name=%s)",
              obj, obj->def->name);
3334
}
3335 3336


3337 3338 3339 3340 3341 3342 3343 3344
virDomainDefPtr
qemuDomainDefCopy(virQEMUDriverPtr driver,
                  virDomainDefPtr src,
                  unsigned int flags)
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    virDomainDefPtr ret = NULL;
    virCapsPtr caps = NULL;
3345
    char *xml = NULL;
3346 3347 3348 3349 3350 3351 3352 3353 3354 3355

    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,
3356 3357
                                        VIR_DOMAIN_DEF_PARSE_INACTIVE |
                                        VIR_DOMAIN_DEF_PARSE_SKIP_VALIDATE)))
3358 3359
        goto cleanup;

3360
 cleanup:
3361 3362 3363 3364 3365
    VIR_FREE(xml);
    virObjectUnref(caps);
    return ret;
}

3366
int
3367
qemuDomainDefFormatBuf(virQEMUDriverPtr driver,
3368 3369 3370
                       virDomainDefPtr def,
                       unsigned int flags,
                       virBuffer *buf)
3371
{
3372
    int ret = -1;
3373
    virDomainDefPtr copy = NULL;
3374 3375 3376 3377
    virCapsPtr caps = NULL;

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

3379 3380 3381 3382 3383 3384 3385 3386 3387
    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;

3388
    /* Update guest CPU requirements according to host CPU */
3389
    if ((flags & VIR_DOMAIN_XML_UPDATE_CPU) &&
3390 3391
        def->cpu &&
        (def->cpu->mode != VIR_CPU_MODE_CUSTOM || def->cpu->model)) {
3392 3393
        if (!caps->host.cpu ||
            !caps->host.cpu->model) {
3394 3395
            virReportError(VIR_ERR_OPERATION_FAILED,
                           "%s", _("cannot get host CPU capabilities"));
3396 3397 3398
            goto cleanup;
        }

3399
        if (cpuUpdate(def->cpu, caps->host.cpu) < 0)
3400 3401 3402
            goto cleanup;
    }

3403
    if ((flags & VIR_DOMAIN_XML_MIGRATABLE)) {
3404
        size_t i;
3405
        int toremove = 0;
3406
        virDomainControllerDefPtr usb = NULL, pci = NULL;
3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421

        /* 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];
            }
        }
3422 3423 3424 3425 3426 3427 3428 3429 3430

        /* In order to maintain compatibility with version of libvirt that
         * didn't support <controller type='usb'/> (<= 0.9.4), we need to
         * drop the default USB controller, ie. a USB controller at index
         * zero with no model or with the default piix3-ohci model.
         *
         * However, we only need to do so for x86 i440fx machine types,
         * because other architectures and machine types were introduced
         * when libvirt already supported <controller type='usb'/>.
3431
         */
3432
        if (ARCH_IS_X86(def->os.arch) && qemuDomainMachineIsI440FX(def) &&
3433 3434 3435
            usb && usb->idx == 0 &&
            (usb->model == -1 ||
             usb->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX3_UHCI)) {
3436 3437
            VIR_DEBUG("Removing default USB controller from domain '%s'"
                      " for migration compatibility", def->name);
3438
            toremove++;
3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456
        } 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 已提交
3457
            VIR_DEBUG("Removing default pci-root from domain '%s'"
3458
                      " for migration compatibility", def->name);
3459
            toremove++;
3460 3461 3462 3463
        } else {
            pci = NULL;
        }

3464
        if (toremove) {
3465 3466 3467
            virDomainControllerDefPtr *controllers = def->controllers;
            int ncontrollers = def->ncontrollers;

3468
            if (VIR_ALLOC_N(def->controllers, ncontrollers - toremove) < 0) {
3469
                def->controllers = controllers;
3470 3471 3472 3473 3474
                goto cleanup;
            }

            def->ncontrollers = 0;
            for (i = 0; i < ncontrollers; i++) {
3475
                if (controllers[i] != usb && controllers[i] != pci)
3476 3477
                    def->controllers[def->ncontrollers++] = controllers[i];
            }
3478 3479 3480 3481

            VIR_FREE(controllers);
            virDomainControllerDefFree(pci);
            virDomainControllerDefFree(usb);
3482
        }
3483

3484 3485 3486 3487 3488 3489 3490 3491 3492
        /* 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;
            }
        }

3493 3494
        for (i = 0; i < def->nchannels; i++)
            qemuDomainChrDefDropDefaultPath(def->channels[i], driver);
3495 3496
    }

3497 3498
 format:
    ret = virDomainDefFormatInternal(def, caps,
3499 3500
                                     virDomainDefFormatConvertXMLFlags(flags),
                                     buf);
3501

3502
 cleanup:
3503
    virDomainDefFree(copy);
3504
    virObjectUnref(caps);
3505 3506
    return ret;
}
3507

3508
char *qemuDomainDefFormatXML(virQEMUDriverPtr driver,
3509
                             virDomainDefPtr def,
3510
                             unsigned int flags)
3511 3512 3513
{
    virBuffer buf = VIR_BUFFER_INITIALIZER;

3514
    if (qemuDomainDefFormatBuf(driver, def, flags, &buf) < 0) {
3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527
        virBufferFreeAndReset(&buf);
        return NULL;
    }

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

    return virBufferContentAndReset(&buf);
}

3528
char *qemuDomainFormatXML(virQEMUDriverPtr driver,
3529
                          virDomainObjPtr vm,
3530
                          unsigned int flags)
3531 3532 3533 3534 3535 3536 3537 3538
{
    virDomainDefPtr def;

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

3539
    return qemuDomainDefFormatXML(driver, def, flags);
3540 3541
}

3542
char *
3543
qemuDomainDefFormatLive(virQEMUDriverPtr driver,
3544
                        virDomainDefPtr def,
3545 3546
                        bool inactive,
                        bool compatible)
3547 3548 3549 3550 3551
{
    unsigned int flags = QEMU_DOMAIN_FORMAT_LIVE_FLAGS;

    if (inactive)
        flags |= VIR_DOMAIN_XML_INACTIVE;
3552 3553
    if (compatible)
        flags |= VIR_DOMAIN_XML_MIGRATABLE;
3554

3555
    return qemuDomainDefFormatXML(driver, def, flags);
3556 3557
}

3558

3559
void qemuDomainObjTaint(virQEMUDriverPtr driver,
3560
                        virDomainObjPtr obj,
3561
                        virDomainTaintFlags taint,
3562
                        qemuDomainLogContextPtr logCtxt)
3563
{
3564
    virErrorPtr orig_err = NULL;
3565
    bool closeLog = false;
3566

3567 3568 3569 3570 3571 3572 3573 3574 3575
    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));
3576 3577 3578 3579 3580

        /* We don't care about errors logging taint info, so
         * preserve original error, and clear any error that
         * is raised */
        orig_err = virSaveLastError();
3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598
        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)
3599
            virResetLastError();
3600 3601
        if (closeLog)
            qemuDomainLogContextFree(logCtxt);
3602 3603 3604 3605
        if (orig_err) {
            virSetError(orig_err);
            virFreeError(orig_err);
        }
3606 3607 3608 3609
    }
}


3610
void qemuDomainObjCheckTaint(virQEMUDriverPtr driver,
3611
                             virDomainObjPtr obj,
3612
                             qemuDomainLogContextPtr logCtxt)
3613
{
3614
    size_t i;
3615
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
3616
    qemuDomainObjPrivatePtr priv = obj->privateData;
3617

3618
    if (virQEMUDriverIsPrivileged(driver) &&
3619 3620 3621
        (!cfg->clearEmulatorCapabilities ||
         cfg->user == 0 ||
         cfg->group == 0))
3622
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HIGH_PRIVILEGES, logCtxt);
3623

3624
    if (priv->hookRun)
3625
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HOOK, logCtxt);
3626

3627 3628 3629
    if (obj->def->namespaceData) {
        qemuDomainCmdlineDefPtr qemucmd = obj->def->namespaceData;
        if (qemucmd->num_args || qemucmd->num_env)
3630
            qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_CUSTOM_ARGV, logCtxt);
3631 3632
    }

3633
    if (obj->def->cpu && obj->def->cpu->mode == VIR_CPU_MODE_HOST_PASSTHROUGH)
3634
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HOST_CPU, logCtxt);
3635

3636
    for (i = 0; i < obj->def->ndisks; i++)
3637
        qemuDomainObjCheckDiskTaint(driver, obj, obj->def->disks[i], logCtxt);
3638

3639 3640
    for (i = 0; i < obj->def->nhostdevs; i++)
        qemuDomainObjCheckHostdevTaint(driver, obj, obj->def->hostdevs[i],
3641
                                       logCtxt);
3642

3643
    for (i = 0; i < obj->def->nnets; i++)
3644
        qemuDomainObjCheckNetTaint(driver, obj, obj->def->nets[i], logCtxt);
3645

3646
    if (obj->def->os.dtb)
3647
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_CUSTOM_DTB, logCtxt);
3648

3649
    virObjectUnref(cfg);
3650 3651 3652
}


3653
void qemuDomainObjCheckDiskTaint(virQEMUDriverPtr driver,
3654
                                 virDomainObjPtr obj,
3655
                                 virDomainDiskDefPtr disk,
3656
                                 qemuDomainLogContextPtr logCtxt)
3657
{
3658
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
3659
    int format = virDomainDiskGetFormat(disk);
3660

3661
    if ((!format || format == VIR_STORAGE_FILE_AUTO) &&
3662
        cfg->allowDiskFormatProbing)
3663
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_DISK_PROBING, logCtxt);
3664

3665 3666
    if (disk->rawio == VIR_TRISTATE_BOOL_YES)
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_HIGH_PRIVILEGES,
3667
                           logCtxt);
3668

3669 3670 3671 3672
    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,
3673
                           logCtxt);
3674

3675
    virObjectUnref(cfg);
3676 3677 3678
}


3679 3680 3681
void qemuDomainObjCheckHostdevTaint(virQEMUDriverPtr driver,
                                    virDomainObjPtr obj,
                                    virDomainHostdevDefPtr hostdev,
3682
                                    qemuDomainLogContextPtr logCtxt)
3683 3684 3685 3686 3687 3688
{
    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,
3689
                               logCtxt);
3690 3691 3692
}


3693
void qemuDomainObjCheckNetTaint(virQEMUDriverPtr driver,
3694
                                virDomainObjPtr obj,
3695
                                virDomainNetDefPtr net,
3696
                                qemuDomainLogContextPtr logCtxt)
3697
{
3698 3699 3700 3701 3702 3703
    /* 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)
3704
        qemuDomainObjTaint(driver, obj, VIR_DOMAIN_TAINT_SHELL_SCRIPTS, logCtxt);
3705
}
3706 3707


3708 3709 3710 3711 3712 3713 3714 3715 3716 3717
qemuDomainLogContextPtr qemuDomainLogContextNew(virQEMUDriverPtr driver,
                                                virDomainObjPtr vm,
                                                qemuDomainLogContextMode mode)
{
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    qemuDomainLogContextPtr ctxt = NULL;

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

3718
    VIR_DEBUG("Context new %p stdioLogD=%d", ctxt, cfg->stdioLogD);
3719 3720 3721 3722
    ctxt->writefd = -1;
    ctxt->readfd = -1;
    virAtomicIntSet(&ctxt->refs, 1);

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

3726 3727 3728 3729
    if (cfg->stdioLogD) {
        ctxt->manager = virLogManagerNew(virQEMUDriverIsPrivileged(driver));
        if (!ctxt->manager)
            goto error;
3730

3731 3732 3733 3734
        ctxt->writefd = virLogManagerDomainOpenLogFile(ctxt->manager,
                                                       "qemu",
                                                       vm->def->uuid,
                                                       vm->def->name,
3735
                                                       ctxt->path,
3736 3737 3738 3739 3740 3741
                                                       0,
                                                       &ctxt->inode,
                                                       &ctxt->pos);
        if (ctxt->writefd < 0)
            goto error;
    } else {
3742
        if ((ctxt->writefd = open(ctxt->path, O_WRONLY | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR)) < 0) {
3743
            virReportSystemError(errno, _("failed to create logfile %s"),
3744
                                 ctxt->path);
3745 3746
            goto error;
        }
3747
        if (virSetCloseExec(ctxt->writefd) < 0) {
3748
            virReportSystemError(errno, _("failed to set close-on-exec flag on %s"),
3749
                                 ctxt->path);
3750 3751 3752
            goto error;
        }

3753 3754 3755 3756 3757 3758 3759
        /* 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"),
3760
                                 ctxt->path);
3761 3762 3763 3764
            goto error;
        }

        if (mode == QEMU_DOMAIN_LOG_CONTEXT_MODE_START) {
3765
            if ((ctxt->readfd = open(ctxt->path, O_RDONLY, S_IRUSR | S_IWUSR)) < 0) {
3766
                virReportSystemError(errno, _("failed to open logfile %s"),
3767
                                     ctxt->path);
3768 3769 3770 3771
                goto error;
            }
            if (virSetCloseExec(ctxt->readfd) < 0) {
                virReportSystemError(errno, _("failed to set close-on-exec flag on %s"),
3772
                                     ctxt->path);
3773 3774 3775 3776
                goto error;
            }
        }

3777 3778
        if ((ctxt->pos = lseek(ctxt->writefd, 0, SEEK_END)) < 0) {
            virReportSystemError(errno, _("failed to seek in log file %s"),
3779
                                 ctxt->path);
3780 3781 3782 3783
            goto error;
        }
    }

3784
 cleanup:
3785 3786 3787 3788 3789
    virObjectUnref(cfg);
    return ctxt;

 error:
    qemuDomainLogContextFree(ctxt);
3790 3791
    ctxt = NULL;
    goto cleanup;
3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805
}


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;
3806 3807
    if (!ctxt->manager &&
        lseek(ctxt->writefd, 0, SEEK_END) < 0) {
3808
        virReportSystemError(errno, "%s",
3809
                             _("Unable to seek to end of domain logfile"));
3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829
        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)
{
3830 3831 3832 3833
    VIR_DEBUG("Context read %p manager=%p inode=%llu pos=%llu",
              ctxt, ctxt->manager,
              (unsigned long long)ctxt->inode,
              (unsigned long long)ctxt->pos);
3834
    char *buf;
3835 3836 3837
    size_t buflen;
    if (ctxt->manager) {
        buf = virLogManagerDomainReadLogFile(ctxt->manager,
3838
                                             ctxt->path,
3839 3840 3841 3842 3843 3844 3845 3846 3847
                                             ctxt->inode,
                                             ctxt->pos,
                                             1024 * 128,
                                             0);
        if (!buf)
            return -1;
        buflen = strlen(buf);
    } else {
        ssize_t got;
3848

3849
        buflen = 1024 * 128;
3850

3851 3852
        /* Best effort jump to start of messages */
        ignore_value(lseek(ctxt->readfd, ctxt->pos, SEEK_SET));
3853

3854 3855
        if (VIR_ALLOC_N(buf, buflen) < 0)
            return -1;
3856

3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869
        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;
    }
3870 3871 3872

    *msg = buf;

3873
    return buflen;
3874 3875 3876
}


3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938
/**
 * 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;
}


3939 3940 3941 3942 3943 3944 3945 3946
int qemuDomainLogContextGetWriteFD(qemuDomainLogContextPtr ctxt)
{
    return ctxt->writefd;
}


void qemuDomainLogContextMarkPosition(qemuDomainLogContextPtr ctxt)
{
3947 3948
    if (ctxt->manager)
        virLogManagerDomainGetLogFilePosition(ctxt->manager,
3949
                                              ctxt->path,
3950 3951 3952 3953 3954
                                              0,
                                              &ctxt->inode,
                                              &ctxt->pos);
    else
        ctxt->pos = lseek(ctxt->writefd, 0, SEEK_END);
3955 3956 3957 3958 3959
}


void qemuDomainLogContextRef(qemuDomainLogContextPtr ctxt)
{
3960
    VIR_DEBUG("Context ref %p", ctxt);
3961 3962 3963 3964
    virAtomicIntInc(&ctxt->refs);
}


3965 3966 3967 3968 3969 3970
virLogManagerPtr qemuDomainLogContextGetManager(qemuDomainLogContextPtr ctxt)
{
    return ctxt->manager;
}


3971 3972 3973 3974 3975 3976 3977 3978
void qemuDomainLogContextFree(qemuDomainLogContextPtr ctxt)
{
    bool lastRef;

    if (!ctxt)
        return;

    lastRef = virAtomicIntDecAndTest(&ctxt->refs);
3979
    VIR_DEBUG("Context free %p lastref=%d", ctxt, lastRef);
3980 3981 3982
    if (!lastRef)
        return;

3983
    virLogManagerFree(ctxt->manager);
3984
    VIR_FREE(ctxt->path);
3985 3986 3987 3988 3989 3990
    VIR_FORCE_CLOSE(ctxt->writefd);
    VIR_FORCE_CLOSE(ctxt->readfd);
    VIR_FREE(ctxt);
}


3991 3992
/* Locate an appropriate 'qemu-img' binary.  */
const char *
3993
qemuFindQemuImgBinary(virQEMUDriverPtr driver)
3994
{
3995 3996
    if (!driver->qemuImgBinary)
        virReportError(VIR_ERR_INTERNAL_ERROR,
3997
                       "%s", _("unable to find qemu-img"));
3998 3999 4000 4001 4002 4003 4004

    return driver->qemuImgBinary;
}

int
qemuDomainSnapshotWriteMetadata(virDomainObjPtr vm,
                                virDomainSnapshotObjPtr snapshot,
4005
                                virCapsPtr caps,
4006 4007 4008 4009 4010 4011 4012 4013 4014
                                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);
4015
    newxml = virDomainSnapshotDefFormat(
4016
        uuidstr, snapshot->def, caps,
4017 4018
        virDomainDefFormatConvertXMLFlags(QEMU_DOMAIN_FORMAT_LIVE_FLAGS),
        1);
4019
    if (newxml == NULL)
4020 4021
        return -1;

4022
    if (virAsprintf(&snapDir, "%s/%s", snapshotDir, vm->def->name) < 0)
4023 4024 4025 4026 4027 4028 4029
        goto cleanup;
    if (virFileMakePath(snapDir) < 0) {
        virReportSystemError(errno, _("cannot create snapshot directory '%s'"),
                             snapDir);
        goto cleanup;
    }

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

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

4035
 cleanup:
4036 4037 4038 4039 4040 4041 4042 4043
    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.  */
4044
static int
4045
qemuDomainSnapshotForEachQcow2Raw(virQEMUDriverPtr driver,
4046 4047 4048 4049 4050
                                  virDomainDefPtr def,
                                  const char *name,
                                  const char *op,
                                  bool try_all,
                                  int ndisks)
4051 4052
{
    const char *qemuimgarg[] = { NULL, "snapshot", NULL, NULL, NULL, NULL };
4053
    size_t i;
4054 4055 4056 4057 4058 4059 4060 4061 4062
    bool skipped = false;

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

    qemuimgarg[2] = op;
4063
    qemuimgarg[3] = name;
4064

4065
    for (i = 0; i < ndisks; i++) {
4066
        /* FIXME: we also need to handle LVM here */
4067
        if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
4068 4069 4070
            int format = virDomainDiskGetFormat(def->disks[i]);

            if (format > 0 && format != VIR_STORAGE_FILE_QCOW2) {
4071 4072 4073 4074 4075
                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",
4076
                             def->disks[i]->dst);
4077 4078
                    skipped = true;
                    continue;
4079 4080 4081 4082 4083
                } else if (STREQ(op, "-c") && i) {
                    /* We must roll back partial creation by deleting
                     * all earlier snapshots.  */
                    qemuDomainSnapshotForEachQcow2Raw(driver, def, name,
                                                      "-d", false, i);
4084
                }
4085 4086 4087 4088
                virReportError(VIR_ERR_OPERATION_INVALID,
                               _("Disk device '%s' does not support"
                                 " snapshotting"),
                               def->disks[i]->dst);
4089 4090 4091
                return -1;
            }

4092
            qemuimgarg[4] = virDomainDiskGetSource(def->disks[i]);
4093 4094 4095 4096

            if (virRun(qemuimgarg, NULL) < 0) {
                if (try_all) {
                    VIR_WARN("skipping snapshot action on %s",
4097
                             def->disks[i]->dst);
4098 4099
                    skipped = true;
                    continue;
4100 4101 4102 4103 4104
                } else if (STREQ(op, "-c") && i) {
                    /* We must roll back partial creation by deleting
                     * all earlier snapshots.  */
                    qemuDomainSnapshotForEachQcow2Raw(driver, def, name,
                                                      "-d", false, i);
4105 4106 4107 4108 4109 4110 4111 4112 4113
                }
                return -1;
            }
        }
    }

    return skipped ? 1 : 0;
}

4114 4115 4116
/* 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
4117
qemuDomainSnapshotForEachQcow2(virQEMUDriverPtr driver,
4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133
                               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);
}

4134 4135
/* Discard one snapshot (or its metadata), without reparenting any children.  */
int
4136
qemuDomainSnapshotDiscard(virQEMUDriverPtr driver,
4137 4138 4139 4140 4141 4142 4143 4144 4145
                          virDomainObjPtr vm,
                          virDomainSnapshotObjPtr snap,
                          bool update_current,
                          bool metadata_only)
{
    char *snapFile = NULL;
    int ret = -1;
    qemuDomainObjPrivatePtr priv;
    virDomainSnapshotObjPtr parentsnap = NULL;
4146
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
4147 4148 4149 4150 4151 4152 4153 4154 4155

    if (!metadata_only) {
        if (!virDomainObjIsActive(vm)) {
            /* Ignore any skipped disks */
            if (qemuDomainSnapshotForEachQcow2(driver, vm, snap, "-d",
                                               true) < 0)
                goto cleanup;
        } else {
            priv = vm->privateData;
4156
            qemuDomainObjEnterMonitor(driver, vm);
4157 4158
            /* we continue on even in the face of error */
            qemuMonitorDeleteSnapshot(priv->mon, snap->def->name);
4159
            ignore_value(qemuDomainObjExitMonitor(driver, vm));
4160 4161 4162
        }
    }

4163
    if (virAsprintf(&snapFile, "%s/%s/%s.xml", cfg->snapshotDir,
4164
                    vm->def->name, snap->def->name) < 0)
4165 4166 4167 4168
        goto cleanup;

    if (snap == vm->current_snapshot) {
        if (update_current && snap->def->parent) {
4169
            parentsnap = virDomainSnapshotFindByName(vm->snapshots,
4170 4171 4172 4173 4174 4175
                                                     snap->def->parent);
            if (!parentsnap) {
                VIR_WARN("missing parent snapshot matching name '%s'",
                         snap->def->parent);
            } else {
                parentsnap->def->current = true;
4176
                if (qemuDomainSnapshotWriteMetadata(vm, parentsnap, driver->caps,
4177
                                                    cfg->snapshotDir) < 0) {
4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189
                    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);
4190
    virDomainSnapshotObjListRemove(vm->snapshots, snap);
4191 4192 4193

    ret = 0;

4194
 cleanup:
4195
    VIR_FREE(snapFile);
4196
    virObjectUnref(cfg);
4197 4198 4199 4200
    return ret;
}

/* Hash iterator callback to discard multiple snapshots.  */
4201 4202 4203
int qemuDomainSnapshotDiscardAll(void *payload,
                                 const void *name ATTRIBUTE_UNUSED,
                                 void *data)
4204 4205
{
    virDomainSnapshotObjPtr snap = payload;
4206
    virQEMUSnapRemovePtr curr = data;
4207 4208 4209 4210 4211 4212 4213 4214
    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;
4215
    return 0;
4216 4217 4218
}

int
4219
qemuDomainSnapshotDiscardAllMetadata(virQEMUDriverPtr driver,
4220 4221
                                     virDomainObjPtr vm)
{
4222
    virQEMUSnapRemove rem;
4223 4224 4225 4226 4227

    rem.driver = driver;
    rem.vm = vm;
    rem.metadata_only = true;
    rem.err = 0;
4228 4229
    virDomainSnapshotForEach(vm->snapshots, qemuDomainSnapshotDiscardAll,
                             &rem);
4230 4231 4232 4233 4234

    return rem.err;
}

/*
4235
 * The caller must hold a lock the vm.
4236 4237
 */
void
4238
qemuDomainRemoveInactive(virQEMUDriverPtr driver,
4239 4240
                         virDomainObjPtr vm)
{
4241
    bool haveJob = true;
4242
    char *snapDir;
4243 4244 4245 4246 4247 4248 4249 4250
    virQEMUDriverConfigPtr cfg;

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

    cfg = virQEMUDriverGetConfig(driver);
4251

4252 4253 4254
    if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
        haveJob = false;

4255 4256 4257 4258 4259
    /* 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);
    }
4260
    else if (virAsprintf(&snapDir, "%s/%s", cfg->snapshotDir,
4261 4262
                         vm->def->name) < 0) {
        VIR_WARN("unable to remove snapshot directory %s/%s",
4263
                 cfg->snapshotDir, vm->def->name);
4264 4265 4266 4267 4268
    } else {
        if (rmdir(snapDir) < 0 && errno != ENOENT)
            VIR_WARN("unable to remove snapshot directory %s", snapDir);
        VIR_FREE(snapDir);
    }
4269 4270 4271

    virObjectRef(vm);

4272
    virDomainObjListRemove(driver->domains, vm);
4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285
    /*
     * 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);
4286
    virObjectUnref(cfg);
4287 4288

    if (haveJob)
4289
        qemuDomainObjEndJob(driver, vm);
4290 4291

    virObjectUnref(vm);
4292
}
4293 4294

void
4295
qemuDomainSetFakeReboot(virQEMUDriverPtr driver,
4296 4297 4298 4299
                        virDomainObjPtr vm,
                        bool value)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
4300
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
4301 4302

    if (priv->fakeReboot == value)
4303
        goto cleanup;
4304 4305 4306

    priv->fakeReboot = value;

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

4310
 cleanup:
4311
    virObjectUnref(cfg);
4312
}
M
Michal Privoznik 已提交
4313

4314
static void
4315 4316
qemuDomainCheckRemoveOptionalDisk(virQEMUDriverPtr driver,
                                  virDomainObjPtr vm,
4317
                                  size_t diskIndex)
4318 4319
{
    char uuid[VIR_UUID_STRING_BUFLEN];
4320
    virObjectEventPtr event = NULL;
4321
    virDomainDiskDefPtr disk = vm->def->disks[diskIndex];
4322
    const char *src = virDomainDiskGetSource(disk);
4323 4324 4325 4326 4327

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

    VIR_DEBUG("Dropping disk '%s' on domain '%s' (UUID '%s') "
              "due to inaccessible source '%s'",
4328
              disk->dst, vm->def->name, uuid, src);
4329 4330 4331 4332

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

4333
        event = virDomainEventDiskChangeNewFromObj(vm, src, NULL,
4334 4335
                                                   disk->info.alias,
                                                   VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START);
4336
        ignore_value(virDomainDiskSetSource(disk, NULL));
4337
    } else {
4338
        event = virDomainEventDiskChangeNewFromObj(vm, src, NULL,
4339 4340
                                                   disk->info.alias,
                                                   VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START);
4341 4342
        virDomainDiskRemove(vm->def, diskIndex);
        virDomainDiskDefFree(disk);
4343 4344
    }

4345
    qemuDomainEventQueue(driver, event);
4346 4347
}

4348 4349 4350
static int
qemuDomainCheckDiskStartupPolicy(virQEMUDriverPtr driver,
                                 virDomainObjPtr vm,
4351
                                 size_t diskIndex,
4352 4353
                                 bool cold_boot)
{
4354
    int startupPolicy = vm->def->disks[diskIndex]->startupPolicy;
4355
    int device = vm->def->disks[diskIndex]->device;
4356

4357
    switch ((virDomainStartupPolicy) startupPolicy) {
4358
        case VIR_DOMAIN_STARTUP_POLICY_OPTIONAL:
4359 4360 4361 4362 4363 4364
            /* 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)
4365
                return -1;
4366 4367
            break;

4368
        case VIR_DOMAIN_STARTUP_POLICY_DEFAULT:
4369
        case VIR_DOMAIN_STARTUP_POLICY_MANDATORY:
4370
            return -1;
4371 4372

        case VIR_DOMAIN_STARTUP_POLICY_REQUISITE:
4373
            if (cold_boot)
4374
                return -1;
4375 4376 4377 4378 4379 4380 4381
            break;

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

4382
    qemuDomainCheckRemoveOptionalDisk(driver, vm, diskIndex);
4383
    virResetLastError();
4384 4385 4386
    return 0;
}

4387

M
Michal Privoznik 已提交
4388
int
4389 4390
qemuDomainCheckDiskPresence(virConnectPtr conn,
                            virQEMUDriverPtr driver,
M
Michal Privoznik 已提交
4391
                            virDomainObjPtr vm,
4392
                            unsigned int flags)
M
Michal Privoznik 已提交
4393
{
4394
    size_t i;
4395 4396
    bool pretend = flags & VIR_QEMU_PROCESS_START_PRETEND;
    bool cold_boot = flags & VIR_QEMU_PROCESS_START_COLD;
M
Michal Privoznik 已提交
4397

4398
    VIR_DEBUG("Checking for disk presence");
4399
    for (i = vm->def->ndisks; i > 0; i--) {
4400 4401
        size_t idx = i - 1;
        virDomainDiskDefPtr disk = vm->def->disks[idx];
4402
        virStorageFileFormat format = virDomainDiskGetFormat(disk);
M
Michal Privoznik 已提交
4403

4404 4405 4406 4407 4408 4409 4410 4411 4412 4413
        if (virStorageTranslateDiskSourcePool(conn, vm->def->disks[idx]) < 0) {
            if (pretend ||
                qemuDomainCheckDiskStartupPolicy(driver, vm, idx, cold_boot) < 0)
                return -1;
            continue;
        }

        if (pretend)
            continue;

4414
        if (virStorageSourceIsEmpty(disk->src))
4415 4416 4417 4418 4419
            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 */
4420
        if (virStorageSourceIsLocalStorage(disk->src) &&
4421
            format > VIR_STORAGE_FILE_NONE &&
4422
            format < VIR_STORAGE_FILE_BACKING &&
4423
            virFileExists(virDomainDiskGetSource(disk)))
M
Michal Privoznik 已提交
4424 4425
            continue;

4426
        if (qemuDomainDetermineDiskChain(driver, vm, disk, true, true) >= 0)
M
Michal Privoznik 已提交
4427
            continue;
4428

4429
        if (qemuDomainCheckDiskStartupPolicy(driver, vm, idx, cold_boot) >= 0)
4430
            continue;
M
Michal Privoznik 已提交
4431

4432
        return -1;
M
Michal Privoznik 已提交
4433 4434
    }

4435
    return 0;
M
Michal Privoznik 已提交
4436
}
4437 4438 4439 4440 4441 4442 4443 4444 4445 4446

/*
 * The vm must be locked when any of the following cleanup functions is
 * called.
 */
int
qemuDomainCleanupAdd(virDomainObjPtr vm,
                     qemuDomainCleanupCallback cb)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
4447
    size_t i;
4448 4449 4450 4451 4452 4453 4454 4455 4456 4457

    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,
4458
                     priv->ncleanupCallbacks, 1) < 0)
4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469
        return -1;

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

void
qemuDomainCleanupRemove(virDomainObjPtr vm,
                        qemuDomainCleanupCallback cb)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
4470
    size_t i;
4471 4472 4473 4474

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

    for (i = 0; i < priv->ncleanupCallbacks; i++) {
4475 4476 4477
        if (priv->cleanupCallbacks[i] == cb)
            VIR_DELETE_ELEMENT_INPLACE(priv->cleanupCallbacks,
                                       i, priv->ncleanupCallbacks);
4478 4479 4480 4481 4482 4483 4484 4485
    }

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

void
4486
qemuDomainCleanupRun(virQEMUDriverPtr driver,
4487 4488 4489
                     virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
4490
    size_t i;
4491 4492 4493 4494

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

    /* run cleanup callbacks in reverse order */
4495 4496
    for (i = 0; i < priv->ncleanupCallbacks; i++) {
        if (priv->cleanupCallbacks[priv->ncleanupCallbacks - (i + 1)])
4497 4498 4499 4500 4501 4502 4503
            priv->cleanupCallbacks[i](driver, vm);
    }

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

4505 4506 4507
static void
qemuDomainGetImageIds(virQEMUDriverConfigPtr cfg,
                      virDomainObjPtr vm,
4508
                      virStorageSourcePtr src,
4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526
                      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;
    }

4527 4528
    if (vm && (vmlabel = virDomainDefGetSecurityLabelDef(vm->def, "dac")) &&
        vmlabel->label)
4529 4530
        virParseOwnershipIds(vmlabel->label, uid, gid);

4531
    if ((disklabel = virStorageSourceGetSecurityLabelDef(src, "dac")) &&
4532
        disklabel->label)
4533 4534 4535 4536
        virParseOwnershipIds(disklabel->label, uid, gid);
}


4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559
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;
}


4560 4561 4562 4563 4564
char *
qemuDomainStorageAlias(const char *device, int depth)
{
    char *alias;

4565
    device = qemuAliasDiskDriveSkipPrefix(device);
4566 4567 4568 4569 4570 4571 4572 4573 4574

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


4575
int
4576
qemuDomainDetermineDiskChain(virQEMUDriverPtr driver,
4577
                             virDomainObjPtr vm,
4578
                             virDomainDiskDefPtr disk,
4579 4580
                             bool force_probe,
                             bool report_broken)
4581
{
4582 4583
    virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
    int ret = 0;
4584 4585
    uid_t uid;
    gid_t gid;
4586

4587
    if (virStorageSourceIsEmpty(disk->src))
4588
        goto cleanup;
4589

4590
    if (disk->src->backingStore) {
4591
        if (force_probe)
4592
            virStorageSourceBackingStoreClear(disk->src);
4593
        else
4594
            goto cleanup;
4595
    }
4596

4597
    qemuDomainGetImageIds(cfg, vm, disk->src, &uid, &gid);
4598

4599
    if (virStorageFileGetMetadata(disk->src,
4600
                                  uid, gid,
4601
                                  cfg->allowDiskFormatProbing,
4602
                                  report_broken) < 0)
4603 4604
        ret = -1;

4605
 cleanup:
4606 4607
    virObjectUnref(cfg);
    return ret;
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 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673
/**
 * 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;
}


4674
bool
4675
qemuDomainDiskSourceDiffers(virDomainDiskDefPtr disk,
4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690
                            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;

4691 4692 4693 4694
    /* 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)
4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707
        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;
}


4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730
/*
 * 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);
4731 4732 4733 4734
    CHECK_EQ(bus, "bus", false);
    if (STRNEQ(disk->dst, orig_disk->dst)) {
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("cannot modify field '%s' of the disk"),
4735
                       "target");
4736 4737 4738 4739
        return false;
    }
    CHECK_EQ(tray_status, "tray", true);
    CHECK_EQ(removable, "removable", true);
4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 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

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

4823 4824 4825 4826 4827 4828 4829
    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);
4830
    /* "snapshot" is a libvirt internal field and thus can be changed */
4831
    /* startupPolicy is allowed to be updated. Therefore not checked here. */
4832
    CHECK_EQ(transient, "transient", true);
4833
    CHECK_EQ(info.bootIndex, "boot order", true);
4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845
    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;
    }
4846

4847 4848 4849 4850 4851 4852
    /* 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);

4853 4854 4855 4856 4857
#undef CHECK_EQ

    return true;
}

4858 4859 4860
bool
qemuDomainDiskBlockJobIsActive(virDomainDiskDefPtr disk)
{
4861 4862
    qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);

4863 4864 4865 4866 4867 4868 4869 4870
    if (disk->mirror) {
        virReportError(VIR_ERR_BLOCK_COPY_ACTIVE,
                       _("disk '%s' already in active block job"),
                       disk->dst);

        return true;
    }

4871
    if (diskPriv->blockjob) {
4872 4873 4874 4875 4876 4877 4878 4879 4880 4881
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
                       _("disk '%s' already in active block job"),
                       disk->dst);
        return true;
    }

    return false;
}


4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896
/**
 * 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++) {
4897 4898 4899 4900
        virDomainDiskDefPtr disk = vm->def->disks[i];
        qemuDomainDiskPrivatePtr diskPriv = QEMU_DOMAIN_DISK_PRIVATE(disk);

        if (!copy_only && diskPriv->blockjob)
4901 4902
            return true;

4903
        if (disk->mirror && disk->mirrorJob == VIR_DOMAIN_BLOCK_JOB_TYPE_COPY)
4904 4905 4906 4907 4908 4909 4910
            return true;
    }

    return false;
}


4911 4912
int
qemuDomainUpdateDeviceList(virQEMUDriverPtr driver,
4913 4914
                           virDomainObjPtr vm,
                           int asyncJob)
4915 4916 4917
{
    qemuDomainObjPrivatePtr priv = vm->privateData;
    char **aliases;
4918
    int rc;
4919 4920 4921 4922

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

4923 4924
    if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
        return -1;
4925 4926 4927 4928
    rc = qemuMonitorGetDeviceAliases(priv->mon, &aliases);
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
        return -1;
    if (rc < 0)
4929 4930 4931 4932 4933 4934
        return -1;

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

4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984

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


4985 4986 4987 4988 4989 4990 4991
bool
qemuDomainDefCheckABIStability(virQEMUDriverPtr driver,
                               virDomainDefPtr src,
                               virDomainDefPtr dst)
{
    virDomainDefPtr migratableDefSrc = NULL;
    virDomainDefPtr migratableDefDst = NULL;
4992 4993 4994 4995
    const unsigned int flags = VIR_DOMAIN_XML_SECURE |
                               VIR_DOMAIN_XML_UPDATE_CPU |
                               VIR_DOMAIN_XML_MIGRATABLE;
    const unsigned int check_flags = VIR_DOMAIN_DEF_ABI_CHECK_SKIP_VOLATILE;
4996 4997 4998 4999 5000 5001
    bool ret = false;

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

5002 5003 5004 5005 5006 5007 5008 5009 5010
    if (!virDomainDefCheckABIStabilityFlags(migratableDefSrc,
                                            migratableDefDst,
                                            check_flags))
        goto cleanup;

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

    ret = true;
5011

5012
 cleanup:
5013 5014 5015 5016
    virDomainDefFree(migratableDefSrc);
    virDomainDefFree(migratableDefDst);
    return ret;
}
5017 5018

bool
5019
qemuDomainAgentAvailable(virDomainObjPtr vm,
5020 5021
                         bool reportError)
{
5022 5023
    qemuDomainObjPrivatePtr priv = vm->privateData;

5024 5025 5026 5027 5028 5029 5030
    if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING) {
        if (reportError) {
            virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                           _("domain is not running"));
        }
        return false;
    }
5031 5032 5033 5034 5035 5036 5037 5038 5039
    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) {
5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051
        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;
5052 5053 5054 5055
        }
    }
    return true;
}
5056

5057

5058
static unsigned long long
5059
qemuDomainGetMemorySizeAlignment(virDomainDefPtr def)
5060
{
5061 5062 5063 5064 5065
    /* 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;

5066 5067 5068 5069 5070 5071 5072
    /* Align memory size. QEMU requires rounding to next 4KiB block.
     * We'll take the "traditional" path and round it to 1MiB*/

    return 1024;
}


5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087
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;
}


5088 5089 5090
int
qemuDomainAlignMemorySizes(virDomainDefPtr def)
{
5091 5092
    unsigned long long maxmemkb = virMemoryMaxValue(false) >> 10;
    unsigned long long maxmemcapped = virMemoryMaxValue(true) >> 10;
5093
    unsigned long long initialmem = 0;
5094
    unsigned long long hotplugmem = 0;
5095
    unsigned long long mem;
5096
    unsigned long long align = qemuDomainGetMemorySizeAlignment(def);
5097 5098 5099 5100 5101
    size_t ncells = virDomainNumaGetNodeCount(def->numa);
    size_t i;

    /* align NUMA cell sizes if relevant */
    for (i = 0; i < ncells; i++) {
5102 5103
        mem = VIR_ROUND_UP(virDomainNumaGetNodeMemorySize(def->numa, i), align);
        initialmem += mem;
5104 5105 5106 5107 5108 5109 5110

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

5114 5115 5116 5117 5118
    /* 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);

5119 5120 5121 5122 5123 5124
    if (initialmem > maxmemcapped) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("initial memory size overflowed after alignment"));
        return -1;
    }

5125
    def->mem.max_memory = VIR_ROUND_UP(def->mem.max_memory, align);
5126 5127 5128 5129 5130
    if (def->mem.max_memory > maxmemkb) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("maximum memory size overflowed after alignment"));
        return -1;
    }
5131

5132
    /* Align memory module sizes */
5133 5134
    for (i = 0; i < def->nmems; i++) {
        align = qemuDomainGetMemoryModuleSizeAlignment(def, def->mems[i]);
5135
        def->mems[i]->size = VIR_ROUND_UP(def->mems[i]->size, align);
5136
        hotplugmem += def->mems[i]->size;
5137 5138 5139 5140 5141 5142 5143

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

5146 5147
    virDomainDefSetMemoryTotal(def, initialmem + hotplugmem);

5148 5149
    return 0;
}
5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160


/**
 * 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
5161 5162
qemuDomainMemoryDeviceAlignSize(virDomainDefPtr def,
                                virDomainMemoryDefPtr mem)
5163
{
5164
    mem->size = VIR_ROUND_UP(mem->size, qemuDomainGetMemorySizeAlignment(def));
5165
}
5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178


/**
 * qemuDomainGetMonitor:
 * @vm: domain object
 *
 * Returns the monitor pointer corresponding to the domain object @vm.
 */
qemuMonitorPtr
qemuDomainGetMonitor(virDomainObjPtr vm)
{
    return ((qemuDomainObjPrivatePtr) vm->privateData)->mon;
}
5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194


/**
 * 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;
5195 5196
    bool asynchronous = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_ASYNC);
    bool synchronous = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_SYNC);
5197

5198
    if (!synchronous && !asynchronous) {
5199 5200 5201 5202 5203 5204
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("block jobs not supported with this QEMU binary"));
        return -1;
    }

    if (modern)
5205
        *modern = asynchronous;
5206 5207 5208

    return 0;
}
5209 5210 5211 5212 5213 5214 5215 5216 5217


/**
 * 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.
 */
5218
virDomainChrDefPtr
5219 5220 5221 5222 5223 5224 5225 5226 5227 5228
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;

5229 5230
        if (STREQ_NULLABLE(channel->target.name, "org.qemu.guest_agent.0"))
            return channel;
5231 5232
    }

5233
    return NULL;
5234
}
5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253


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"));
}
5254 5255


5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273
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;
}


5274 5275 5276 5277 5278 5279
bool
qemuDomainMachineIsS390CCW(const virDomainDef *def)
{
    return STRPREFIX(def->os.machine, "s390-ccw");
}

5280

J
Ján Tomko 已提交
5281 5282 5283
bool
qemuDomainMachineIsVirt(const virDomainDef *def)
{
5284 5285 5286 5287 5288 5289 5290 5291 5292
    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 已提交
5293 5294 5295
}


5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309
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;
}


5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356
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;
        }

5357 5358 5359
        if (virDomainNumaGetNodeCount(def->numa) != 0) {
            if (mem->targetNode == -1) {
                virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
Y
Yuri Chornoivan 已提交
5360
                               _("target NUMA node needs to be specified for "
5361 5362 5363
                                 "memory device"));
                return -1;
            }
5364 5365
        }

5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389
        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;
}


5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417
/**
 * 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;
5418 5419 5420

        if (qemuDomainDefValidateMemoryHotplugDevice(mem, def) < 0)
            return -1;
5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439
    }

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

5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450
    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;
        }
5451 5452 5453 5454 5455 5456 5457 5458 5459
    }

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

5460
    for (i = 0; i < def->nmems; i++) {
5461 5462
        hotplugMemory += def->mems[i]->size;

5463 5464 5465 5466 5467 5468
        /* already existing devices don't need to be checked on hotplug */
        if (!mem &&
            qemuDomainDefValidateMemoryHotplugDevice(def->mems[i], def) < 0)
            return -1;
    }

5469 5470 5471 5472 5473 5474 5475 5476 5477 5478
    if (hotplugMemory > hotplugSpace) {
        virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                       _("memory device total size exceeds hotplug space"));
        return -1;
    }

    return 0;
}


5479 5480 5481 5482 5483 5484 5485 5486 5487 5488
bool
qemuDomainMachineHasBuiltinIDE(const virDomainDef *def)
{
    return qemuDomainMachineIsI440FX(def) ||
        STREQ(def->os.machine, "malta") ||
        STREQ(def->os.machine, "sun4u") ||
        STREQ(def->os.machine, "g3beige");
}


5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512
/**
 * 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 */
5513
    if (!virDomainDefHasMemballoon(vm->def)) {
5514
        vm->def->mem.cur_balloon = virDomainDefGetMemoryTotal(vm->def);
5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546
        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;

5547 5548
        vm->def->mem.cur_balloon = balloon;
    }
5549 5550 5551

    return 0;
}
5552 5553 5554


/**
5555
 * qemuDomainGetMemLockLimitBytes:
5556 5557 5558 5559
 *
 * @def: domain definition
 *
 * Returns the size of the memory in bytes that needs to be set as
5560
 * RLIMIT_MEMLOCK for the QEMU process.
5561 5562 5563 5564
 * 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
5565
qemuDomainGetMemLockLimitBytes(virDomainDefPtr def)
5566 5567 5568
{
    unsigned long long memKB;

5569 5570 5571 5572 5573 5574
    /* prefer the hard limit */
    if (virMemoryLimitIsSet(def->mem.hard_limit)) {
        memKB = def->mem.hard_limit;
        goto done;
    }

5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598
    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;
            }
        }

5599
        memory = virDomainDefGetMemoryTotal(def);
5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652

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

5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670
    /* 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.
     */
5671
    memKB = virDomainDefGetMemoryTotal(def) + 1024 * 1024;
5672

5673
 done:
5674 5675
    return memKB << 10;
}
5676 5677 5678 5679 5680


/**
 * @def: domain definition
 *
5681 5682 5683
 * Returns true if the locked memory limit needs to be set or updated because
 * of domain configuration, VFIO passthrough devices or architecture-specific
 * requirements.
5684 5685
 * */
bool
5686
qemuDomainRequiresMemLock(virDomainDefPtr def)
5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701
{
    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;
    }

5702 5703 5704 5705
    /* 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;

5706 5707
    return false;
}
5708

5709 5710 5711 5712 5713 5714 5715
/**
 * qemuDomainAdjustMaxMemLock:
 * @vm: domain
 *
 * Adjust the memory locking limit for the QEMU process associated to @vm, in
 * order to comply with VFIO or architecture requirements.
 *
5716 5717 5718 5719
 * 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.
5720 5721 5722 5723 5724 5725 5726 5727 5728
 *
 * Returns: 0 on success, <0 on failure
 */
int
qemuDomainAdjustMaxMemLock(virDomainObjPtr vm)
{
    unsigned long long bytes = 0;
    int ret = -1;

5729
    if (qemuDomainRequiresMemLock(vm->def)) {
5730 5731 5732 5733 5734 5735 5736 5737
        /* 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;
        }
5738
        bytes = qemuDomainGetMemLockLimitBytes(vm->def);
5739 5740 5741 5742 5743 5744
    } 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;
    }
5745 5746 5747 5748 5749 5750 5751 5752 5753 5754

    /* 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;
}
5755 5756 5757 5758 5759 5760 5761 5762 5763 5764

/**
 * qemuDomainHasVcpuPids:
 * @vm: Domain object
 *
 * Returns true if we were able to successfully detect vCPU pids for the VM.
 */
bool
qemuDomainHasVcpuPids(virDomainObjPtr vm)
{
5765 5766 5767 5768 5769 5770
    size_t i;
    size_t maxvcpus = virDomainDefGetVcpusMax(vm->def);
    virDomainVcpuDefPtr vcpu;

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

5772 5773 5774 5775 5776
        if (QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->tid > 0)
            return true;
    }

    return false;
5777
}
5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788


/**
 * 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,
5789
                     unsigned int vcpuid)
5790
{
5791 5792
    virDomainVcpuDefPtr vcpu = virDomainDefGetVcpu(vm->def, vcpuid);
    return QEMU_DOMAIN_VCPU_PRIVATE(vcpu)->tid;
5793
}
5794 5795


5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837
/**
 * qemuDomainValidateVcpuInfo:
 *
 * Validates vcpu thread information. If vcpu thread IDs are reported by qemu,
 * this function validates that online vcpus have thread info present and
 * offline vcpus don't.
 *
 * Returns 0 on success -1 on error.
 */
int
qemuDomainValidateVcpuInfo(virDomainObjPtr vm)
{
    size_t maxvcpus = virDomainDefGetVcpusMax(vm->def);
    virDomainVcpuDefPtr vcpu;
    qemuDomainVcpuPrivatePtr vcpupriv;
    size_t i;

    if (!qemuDomainHasVcpuPids(vm))
        return 0;

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

        if (vcpu->online && vcpupriv->tid == 0) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("qemu didn't report thread id for vcpu '%zu'"), i);
            return -1;
        }

        if (!vcpu->online && vcpupriv->tid != 0) {
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("qemu reported thread id for inactive vcpu '%zu'"),
                           i);
            return -1;
        }
    }

    return 0;
}


5838 5839 5840 5841 5842 5843 5844 5845 5846
bool
qemuDomainSupportsNewVcpuHotplug(virDomainObjPtr vm)
{
    qemuDomainObjPrivatePtr priv = vm->privateData;

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


5847
/**
5848
 * qemuDomainRefreshVcpuInfo:
5849 5850 5851
 * @driver: qemu driver data
 * @vm: domain object
 * @asyncJob: current asynchronous job type
5852
 * @state: refresh vcpu state
5853
 *
5854 5855
 * Updates vCPU information private data of @vm. Due to historical reasons this
 * function returns success even if some data were not reported by qemu.
5856
 *
5857 5858
 * If @state is true, the vcpu state is refreshed as reported by the monitor.
 *
5859
 * Returns 0 on success and -1 on fatal error.
5860 5861
 */
int
5862 5863
qemuDomainRefreshVcpuInfo(virQEMUDriverPtr driver,
                          virDomainObjPtr vm,
5864 5865
                          int asyncJob,
                          bool state)
5866
{
5867
    virDomainVcpuDefPtr vcpu;
5868 5869
    qemuDomainVcpuPrivatePtr vcpupriv;
    qemuMonitorCPUInfoPtr info = NULL;
5870 5871
    size_t maxvcpus = virDomainDefGetVcpusMax(vm->def);
    size_t i;
5872
    bool hotplug;
5873
    int rc;
5874
    int ret = -1;
5875

5876
    hotplug = qemuDomainSupportsNewVcpuHotplug(vm);
5877 5878 5879

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

5881
    rc = qemuMonitorGetCPUInfo(qemuDomainGetMonitor(vm), &info, maxvcpus, hotplug);
5882

5883
    if (qemuDomainObjExitMonitor(driver, vm) < 0)
5884 5885
        goto cleanup;

5886
    if (rc < 0)
5887 5888 5889 5890
        goto cleanup;

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

5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932
        /*
         * Current QEMU *can* report info about host threads mapped
         * to vCPUs, but it is not in a manner we can correctly
         * deal with. The TCG CPU emulation does have a separate vCPU
         * thread, but it runs every vCPU in that same thread. So it
         * is impossible to setup different affinity per thread.
         *
         * What's more the 'query-cpus' command returns bizarre
         * data for the threads. It gives the TCG thread for the
         * vCPU 0, but for vCPUs 1-> N, it actually replies with
         * the main process thread ID.
         *
         * The result is that when we try to set affinity for
         * vCPU 1, it will actually change the affinity of the
         * emulator thread :-( When you try to set affinity for
         * vCPUs 2, 3.... it will fail if the affinity was
         * different from vCPU 1.
         *
         * We *could* allow vcpu pinning with TCG, if we made the
         * restriction that all vCPUs had the same mask. This would
         * at least let us separate emulator from vCPUs threads, as
         * we do for KVM. It would need some changes to our cgroups
         * CPU layout though, and error reporting for the config
         * restrictions.
         *
         * Just disable CPU pinning with TCG until someone wants
         * to try to do this hard work.
         */
        if (vm->def->virtType != VIR_DOMAIN_VIRT_QEMU)
            vcpupriv->tid = info[i].tid;

        vcpupriv->socket_id = info[i].socket_id;
        vcpupriv->core_id = info[i].core_id;
        vcpupriv->thread_id = info[i].thread_id;
        vcpupriv->vcpus = info[i].vcpus;
        VIR_FREE(vcpupriv->type);
        VIR_STEAL_PTR(vcpupriv->type, info[i].type);
        VIR_FREE(vcpupriv->alias);
        VIR_STEAL_PTR(vcpupriv->alias, info[i].alias);
        vcpupriv->enable_id = info[i].id;
5933

5934
        if (hotplug && state) {
5935
            vcpu->online = !!info[i].qom_path;
5936 5937 5938 5939 5940 5941 5942 5943 5944

            /* mark cpus that don't have an alias as non-hotpluggable */
            if (vcpu->online) {
                if (vcpupriv->alias)
                    vcpu->hotpluggable = VIR_TRISTATE_BOOL_YES;
                else
                    vcpu->hotpluggable = VIR_TRISTATE_BOOL_NO;
            }
        }
5945 5946
    }

5947
    ret = 0;
5948 5949

 cleanup:
5950
    qemuMonitorCPUInfoFree(info, maxvcpus);
5951
    return ret;
5952
}
5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973


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)
{
5974
    if (!qemuDomainSupportsNicdev(def, net))
5975 5976 5977
        return false;
    return virQEMUCapsGet(qemuCaps, QEMU_CAPS_NETDEV);
}
J
John Ferlan 已提交
5978 5979 5980 5981 5982 5983 5984


int
qemuDomainNetVLAN(virDomainNetDefPtr def)
{
    return qemuDomainDeviceAliasIndex(&def->info, "net");
}
P
Peter Krempa 已提交
5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000


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;
}
6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031


/**
 * 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;
}
6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051


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;
}
6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086


/**
 * qemuDomainVcpuHotplugIsInOrder:
 * @def: domain definition
 *
 * Returns true if online vcpus were added in order (clustered behind vcpu0
 * with increasing order).
 */
bool
qemuDomainVcpuHotplugIsInOrder(virDomainDefPtr def)
{
    size_t maxvcpus = virDomainDefGetVcpusMax(def);
    virDomainVcpuDefPtr vcpu;
    unsigned int prevorder = 0;
    size_t seenonlinevcpus = 0;
    size_t i;

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

        if (!vcpu->online)
            break;

        if (vcpu->order < prevorder)
            break;

        if (vcpu->order > prevorder)
            prevorder = vcpu->order;

        seenonlinevcpus++;
    }

    return seenonlinevcpus == virDomainDefGetVcpus(def);
}
6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115 6116 6117 6118 6119 6120


/**
 * qemuDomainVcpuPersistOrder:
 * @def: domain definition
 *
 * Saves the order of vcpus detected from qemu to the domain definition.
 * The private data note the order only for the entry describing the
 * hotpluggable entity. This function copies the order into the definition part
 * of all sub entities.
 */
void
qemuDomainVcpuPersistOrder(virDomainDefPtr def)
{
    size_t maxvcpus = virDomainDefGetVcpusMax(def);
    virDomainVcpuDefPtr vcpu;
    qemuDomainVcpuPrivatePtr vcpupriv;
    unsigned int prevorder = 0;
    size_t i;

    for (i = 0; i < maxvcpus; i++) {
        vcpu = virDomainDefGetVcpu(def, i);
        vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpu);

        if (!vcpu->online) {
            vcpu->order = 0;
        } else {
            if (vcpupriv->enable_id != 0)
                prevorder = vcpupriv->enable_id;

            vcpu->order = prevorder;
        }
    }
}