mirror of
https://gitlab.com/libvirt/libvirt.git
synced 2024-10-31 10:23:09 +00:00
677c90cc1d
In commit 88957116c9 I've adapted
libvirt to QEMU's deprecation of -mem-path and -mem-prealloc and
switched to memory-backend-* even for system memory. My claim was
that that's what QEMU does under the hood anyway. And indeed it
was: see QEMU commit 900c0ba373aada4c13d47d95330aa72ec4067ba5 and
look at function create_default_memdev().
However, then commit d96c4d5f193e0e45beec80a6277728b32875bddb was
merged into QEMU. While it was fixing a bug, it also changed the
create_default_memdev() function in which it started turning off
use of canonical path (by setting
"x-use-canonical-path-for-ramblock-id" attribute to false). This
wasn't documented until QEMU commit
8db0b20415c129cf5e577a593a4a0372d90b7cc9. The path affects
migration - the same path has to be used on the source and on the
destination. Therefore, if there is old guest started with '-m X'
it has "pc.ram" block which doesn't use canonical path and thus
when migrating to newer QEMU which uses memory-backend-* we have
to turn off the canonical path explicitly. Otherwise,
"/objects/pc.ram" path would be expected by QEMU which doesn't
match the source.
Ideally, we would need to set it only for some machine types
(4.0 and older) because newer machine types already do what we
are doing. However, we treat machine types as opaque strings and
therefore we don't want to parse nor inspect their versions. But
then again, newer machine types already do what we are doing in
this commit, so when old machine types are deprecated and removed
we can remove our hack and forget it ever happened.
Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1912201
Signed-off-by: Michal Privoznik <mprivozn@redhat.com>
Reviewed-by: Peter Krempa <pkrempa@redhat.com>
269 lines
10 KiB
C
269 lines
10 KiB
C
/*
|
|
* qemu_command.h: QEMU command generation
|
|
*
|
|
* Copyright (C) 2006-2016 Red Hat, Inc.
|
|
* Copyright (C) 2006 Daniel P. Berrange
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library. If not, see
|
|
* <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "domain_addr.h"
|
|
#include "domain_conf.h"
|
|
#include "vircommand.h"
|
|
#include "virenum.h"
|
|
#include "capabilities.h"
|
|
#include "qemu_block.h"
|
|
#include "qemu_conf.h"
|
|
#include "qemu_domain.h"
|
|
#include "qemu_domain_address.h"
|
|
#include "qemu_capabilities.h"
|
|
#include "logging/log_manager.h"
|
|
|
|
/* Config type for XML import/export conversions */
|
|
#define QEMU_CONFIG_FORMAT_ARGV "qemu-argv"
|
|
|
|
#define QEMU_FSDEV_HOST_PREFIX "fsdev-"
|
|
|
|
#define QEMU_BLOCK_IOTUNE_MAX 1000000000000000LL
|
|
|
|
VIR_ENUM_DECL(qemuVideo);
|
|
VIR_ENUM_DECL(qemuSoundCodec);
|
|
|
|
typedef enum {
|
|
QEMU_BUILD_COMMANDLINE_VALIDATE_KEEP_JSON = 1 << 0,
|
|
} qemuBuildCommandLineFlags;
|
|
|
|
virCommandPtr qemuBuildCommandLine(virQEMUDriverPtr driver,
|
|
virLogManagerPtr logManager,
|
|
virSecurityManagerPtr secManager,
|
|
virDomainObjPtr vm,
|
|
const char *migrateURI,
|
|
virDomainMomentObjPtr snapshot,
|
|
virNetDevVPortProfileOp vmop,
|
|
bool standalone,
|
|
bool enableFips,
|
|
size_t *nnicindexes,
|
|
int **nicindexes,
|
|
unsigned int flags);
|
|
|
|
/* Generate the object properties for pr-manager */
|
|
virJSONValuePtr qemuBuildPRManagerInfoProps(virStorageSourcePtr src);
|
|
virJSONValuePtr qemuBuildPRManagedManagerInfoProps(qemuDomainObjPrivatePtr priv);
|
|
|
|
virJSONValuePtr qemuBuildDBusVMStateInfoProps(virQEMUDriverPtr driver,
|
|
virDomainObjPtr vm);
|
|
|
|
/* Generate the object properties for a secret */
|
|
int qemuBuildSecretInfoProps(qemuDomainSecretInfoPtr secinfo,
|
|
virJSONValuePtr *propsret);
|
|
|
|
/* Generate the object properties for a tls-creds-x509 */
|
|
int qemuBuildTLSx509BackendProps(const char *tlspath,
|
|
bool isListen,
|
|
bool verifypeer,
|
|
const char *alias,
|
|
const char *secalias,
|
|
virQEMUCapsPtr qemuCaps,
|
|
virJSONValuePtr *propsret);
|
|
|
|
/* Open a UNIX socket for chardev FD passing */
|
|
int
|
|
qemuOpenChrChardevUNIXSocket(const virDomainChrSourceDef *dev) G_GNUC_NO_INLINE;
|
|
|
|
/* Generate '-device' string for chardev device */
|
|
int
|
|
qemuBuildChrDeviceStr(char **deviceStr,
|
|
const virDomainDef *vmdef,
|
|
virDomainChrDefPtr chr,
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
virJSONValuePtr
|
|
qemuBuildChannelGuestfwdNetdevProps(virDomainChrDefPtr chr);
|
|
|
|
virJSONValuePtr qemuBuildHostNetStr(virDomainNetDefPtr net,
|
|
char **tapfd,
|
|
size_t tapfdSize,
|
|
char **vhostfd,
|
|
size_t vhostfdSize,
|
|
const char *slirpfd,
|
|
const char *vdpadev);
|
|
|
|
/* Current, best practice */
|
|
char *qemuBuildNicDevStr(virDomainDefPtr def,
|
|
virDomainNetDefPtr net,
|
|
unsigned int bootindex,
|
|
size_t vhostfdSize,
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
char *qemuDeviceDriveHostAlias(virDomainDiskDefPtr disk);
|
|
bool qemuDiskBusIsSD(int bus);
|
|
|
|
qemuBlockStorageSourceAttachDataPtr
|
|
qemuBuildStorageSourceAttachPrepareDrive(virDomainDiskDefPtr disk,
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
qemuBlockStorageSourceAttachDataPtr
|
|
qemuBuildStorageSourceAttachPrepareChardev(virDomainDiskDefPtr disk);
|
|
|
|
int
|
|
qemuBuildStorageSourceAttachPrepareCommon(virStorageSourcePtr src,
|
|
qemuBlockStorageSourceAttachDataPtr data,
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
|
|
qemuBlockStorageSourceChainDataPtr
|
|
qemuBuildStorageSourceChainAttachPrepareDrive(virDomainDiskDefPtr disk,
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
|
|
qemuBlockStorageSourceChainDataPtr
|
|
qemuBuildStorageSourceChainAttachPrepareChardev(virDomainDiskDefPtr disk);
|
|
|
|
|
|
qemuBlockStorageSourceChainDataPtr
|
|
qemuBuildStorageSourceChainAttachPrepareBlockdev(virStorageSourcePtr top,
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
qemuBlockStorageSourceChainDataPtr
|
|
qemuBuildStorageSourceChainAttachPrepareBlockdevTop(virStorageSourcePtr top,
|
|
virStorageSourcePtr backingStore,
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
char
|
|
*qemuBuildDiskDeviceStr(const virDomainDef *def,
|
|
virDomainDiskDefPtr disk,
|
|
unsigned int bootindex,
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
/* Current, best practice */
|
|
int qemuBuildControllerDevStr(const virDomainDef *domainDef,
|
|
virDomainControllerDefPtr def,
|
|
virQEMUCapsPtr qemuCaps,
|
|
char **devstr);
|
|
|
|
int qemuBuildMemoryBackendProps(virJSONValuePtr *backendProps,
|
|
const char *alias,
|
|
virQEMUDriverConfigPtr cfg,
|
|
qemuDomainObjPrivatePtr priv,
|
|
const virDomainDef *def,
|
|
const virDomainMemoryDef *mem,
|
|
bool force,
|
|
bool systemMemory);
|
|
|
|
char *
|
|
qemuBuildMemoryDeviceStr(const virDomainDef *def,
|
|
virDomainMemoryDefPtr mem,
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
/* Current, best practice */
|
|
char *qemuBuildPCIHostdevDevStr(const virDomainDef *def,
|
|
virDomainHostdevDefPtr dev,
|
|
unsigned int bootIndex,
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
char *qemuBuildRNGDevStr(const virDomainDef *def,
|
|
virDomainRNGDefPtr dev,
|
|
virQEMUCapsPtr qemuCaps);
|
|
int qemuBuildRNGBackendProps(virDomainRNGDefPtr rng,
|
|
virJSONValuePtr *props);
|
|
|
|
/* Current, best practice */
|
|
char *qemuBuildUSBHostdevDevStr(const virDomainDef *def,
|
|
virDomainHostdevDefPtr dev,
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
char *qemuBuildSCSIHostdevDevStr(const virDomainDef *def,
|
|
virDomainHostdevDefPtr dev,
|
|
const char *backendAlias);
|
|
|
|
qemuBlockStorageSourceAttachData *
|
|
qemuBuildHostdevSCSIAttachPrepare(virDomainHostdevDefPtr hostdev,
|
|
const char **backendAlias,
|
|
virQEMUCapsPtr qemuCaps);
|
|
qemuBlockStorageSourceAttachData *
|
|
qemuBuildHostdevSCSIDetachPrepare(virDomainHostdevDefPtr hostdev,
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
char *
|
|
qemuBuildSCSIVHostHostdevDevStr(const virDomainDef *def,
|
|
virDomainHostdevDefPtr dev,
|
|
virQEMUCapsPtr qemuCaps,
|
|
char *vhostfdName);
|
|
|
|
char *
|
|
qemuBuildHostdevMediatedDevStr(const virDomainDef *def,
|
|
virDomainHostdevDefPtr dev,
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
char *qemuBuildRedirdevDevStr(const virDomainDef *def,
|
|
virDomainRedirdevDefPtr dev,
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
char *qemuBuildZPCIDevStr(virDomainDeviceInfoPtr dev);
|
|
|
|
int qemuNetworkPrepareDevices(virDomainDefPtr def);
|
|
|
|
int qemuGetDriveSourceString(virStorageSourcePtr src,
|
|
qemuDomainSecretInfoPtr secinfo,
|
|
char **source);
|
|
|
|
bool
|
|
qemuDiskConfigBlkdeviotuneEnabled(virDomainDiskDefPtr disk);
|
|
|
|
|
|
bool
|
|
qemuCheckFips(virDomainObjPtr vm);
|
|
|
|
virJSONValuePtr qemuBuildHotpluggableCPUProps(const virDomainVcpuDef *vcpu)
|
|
ATTRIBUTE_NONNULL(1);
|
|
|
|
virJSONValuePtr qemuBuildShmemBackendMemProps(virDomainShmemDefPtr shmem)
|
|
ATTRIBUTE_NONNULL(1);
|
|
|
|
char *qemuBuildShmemDevStr(virDomainDefPtr def,
|
|
virDomainShmemDefPtr shmem,
|
|
virQEMUCapsPtr qemuCaps)
|
|
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
|
|
|
|
char *qemuBuildWatchdogDevStr(const virDomainDef *def,
|
|
virDomainWatchdogDefPtr dev,
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
int qemuBuildInputDevStr(char **devstr,
|
|
const virDomainDef *def,
|
|
virDomainInputDefPtr input,
|
|
virQEMUCapsPtr qemuCaps)
|
|
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
|
|
ATTRIBUTE_NONNULL(4);
|
|
|
|
char *
|
|
qemuBuildVsockDevStr(virDomainDefPtr def,
|
|
virDomainVsockDefPtr vsock,
|
|
virQEMUCapsPtr qemuCaps,
|
|
const char *fdprefix)
|
|
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
|
|
ATTRIBUTE_NONNULL(4);
|
|
|
|
/* this function is exported so that tests can mock the FDs */
|
|
int
|
|
qemuBuildTPMOpenBackendFDs(const char *tpmdev,
|
|
const char *cancel_path,
|
|
int *tpmfd,
|
|
int *cancelfd)
|
|
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
|
|
ATTRIBUTE_NONNULL(4) G_GNUC_NO_INLINE;
|