2010-12-16 15:07:07 +00:00
|
|
|
/*
|
|
|
|
* qemu_command.h: QEMU command generation
|
|
|
|
*
|
2016-02-10 12:33:47 +00:00
|
|
|
* Copyright (C) 2006-2016 Red Hat, Inc.
|
2010-12-16 15:07:07 +00:00
|
|
|
* 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
|
2012-09-20 22:30:55 +00:00
|
|
|
* License along with this library. If not, see
|
2012-07-21 10:06:23 +00:00
|
|
|
* <http://www.gnu.org/licenses/>.
|
2010-12-16 15:07:07 +00:00
|
|
|
*/
|
|
|
|
|
2019-06-18 16:12:37 +00:00
|
|
|
#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"
|
2010-12-16 15:07:07 +00:00
|
|
|
|
|
|
|
/* Config type for XML import/export conversions */
|
2019-06-18 16:12:37 +00:00
|
|
|
#define QEMU_CONFIG_FORMAT_ARGV "qemu-argv"
|
2010-12-16 15:07:07 +00:00
|
|
|
|
2019-06-18 16:12:37 +00:00
|
|
|
#define QEMU_FSDEV_HOST_PREFIX "fsdev-"
|
2010-12-16 15:07:07 +00:00
|
|
|
|
2019-06-18 16:12:37 +00:00
|
|
|
#define QEMU_BLOCK_IOTUNE_MAX 1000000000000000LL
|
2016-04-20 14:14:02 +00:00
|
|
|
|
2019-01-20 16:04:56 +00:00
|
|
|
VIR_ENUM_DECL(qemuVideo);
|
2019-12-09 23:15:15 +00:00
|
|
|
VIR_ENUM_DECL(qemuSoundCodec);
|
2015-01-12 12:18:46 +00:00
|
|
|
|
2020-05-15 12:24:21 +00:00
|
|
|
typedef enum {
|
|
|
|
QEMU_BUILD_COMMANDLINE_VALIDATE_KEEP_JSON = 1 << 0,
|
|
|
|
} qemuBuildCommandLineFlags;
|
|
|
|
|
2016-04-06 14:41:33 +00:00
|
|
|
virCommandPtr qemuBuildCommandLine(virQEMUDriverPtr driver,
|
2016-02-23 13:05:09 +00:00
|
|
|
virLogManagerPtr logManager,
|
2018-06-07 15:55:07 +00:00
|
|
|
virSecurityManagerPtr secManager,
|
2017-10-11 10:44:30 +00:00
|
|
|
virDomainObjPtr vm,
|
2015-10-20 11:51:01 +00:00
|
|
|
const char *migrateURI,
|
2019-03-22 04:45:25 +00:00
|
|
|
virDomainMomentObjPtr snapshot,
|
2014-04-27 00:15:22 +00:00
|
|
|
virNetDevVPortProfileOp vmop,
|
2016-02-26 08:15:55 +00:00
|
|
|
bool standalone,
|
2014-10-30 06:34:30 +00:00
|
|
|
bool enableFips,
|
2015-01-16 11:25:50 +00:00
|
|
|
size_t *nnicindexes,
|
2020-05-15 12:24:21 +00:00
|
|
|
int **nicindexes,
|
|
|
|
unsigned int flags);
|
2010-12-16 15:07:07 +00:00
|
|
|
|
2018-04-18 14:55:14 +00:00
|
|
|
/* Generate the object properties for pr-manager */
|
2018-05-31 11:29:45 +00:00
|
|
|
virJSONValuePtr qemuBuildPRManagerInfoProps(virStorageSourcePtr src);
|
2018-05-31 11:56:35 +00:00
|
|
|
virJSONValuePtr qemuBuildPRManagedManagerInfoProps(qemuDomainObjPrivatePtr priv);
|
2016-06-13 16:30:34 +00:00
|
|
|
|
2020-02-25 09:55:11 +00:00
|
|
|
virJSONValuePtr qemuBuildDBusVMStateInfoProps(virQEMUDriverPtr driver,
|
|
|
|
virDomainObjPtr vm);
|
|
|
|
|
2016-06-22 10:11:59 +00:00
|
|
|
/* Generate the object properties for a secret */
|
|
|
|
int qemuBuildSecretInfoProps(qemuDomainSecretInfoPtr secinfo,
|
|
|
|
virJSONValuePtr *propsret);
|
|
|
|
|
2016-06-13 16:30:34 +00:00
|
|
|
/* Generate the object properties for a tls-creds-x509 */
|
|
|
|
int qemuBuildTLSx509BackendProps(const char *tlspath,
|
2016-09-12 14:49:28 +00:00
|
|
|
bool isListen,
|
2016-06-13 16:30:34 +00:00
|
|
|
bool verifypeer,
|
2018-05-22 05:38:22 +00:00
|
|
|
const char *alias,
|
2016-10-21 23:02:35 +00:00
|
|
|
const char *secalias,
|
2016-06-13 16:30:34 +00:00
|
|
|
virQEMUCapsPtr qemuCaps,
|
|
|
|
virJSONValuePtr *propsret);
|
|
|
|
|
2018-03-14 12:16:11 +00:00
|
|
|
/* Open a UNIX socket for chardev FD passing */
|
|
|
|
int
|
2020-08-04 14:17:07 +00:00
|
|
|
qemuOpenChrChardevUNIXSocket(const virDomainChrSourceDef *dev) G_GNUC_NO_INLINE;
|
2018-03-14 12:16:11 +00:00
|
|
|
|
2013-03-13 15:20:34 +00:00
|
|
|
/* Generate '-device' string for chardev device */
|
|
|
|
int
|
|
|
|
qemuBuildChrDeviceStr(char **deviceStr,
|
2016-02-18 15:46:48 +00:00
|
|
|
const virDomainDef *vmdef,
|
2013-03-13 15:20:34 +00:00
|
|
|
virDomainChrDefPtr chr,
|
|
|
|
virQEMUCapsPtr qemuCaps);
|
2011-11-21 12:50:42 +00:00
|
|
|
|
2020-05-15 07:46:08 +00:00
|
|
|
virJSONValuePtr
|
2020-05-14 11:01:59 +00:00
|
|
|
qemuBuildChannelGuestfwdNetdevProps(virDomainChrDefPtr chr);
|
|
|
|
|
2020-05-14 20:50:59 +00:00
|
|
|
virJSONValuePtr qemuBuildHostNetStr(virDomainNetDefPtr net,
|
|
|
|
char **tapfd,
|
|
|
|
size_t tapfdSize,
|
|
|
|
char **vhostfd,
|
|
|
|
size_t vhostfdSize,
|
2020-10-14 17:08:27 +00:00
|
|
|
const char *slirpfd,
|
|
|
|
const char *vdpadev);
|
2010-12-16 15:07:07 +00:00
|
|
|
|
|
|
|
/* Current, best practice */
|
2018-02-12 14:52:04 +00:00
|
|
|
char *qemuBuildNicDevStr(virDomainDefPtr def,
|
2014-07-24 13:23:40 +00:00
|
|
|
virDomainNetDefPtr net,
|
2016-03-29 12:31:37 +00:00
|
|
|
unsigned int bootindex,
|
2014-11-12 15:42:02 +00:00
|
|
|
size_t vhostfdSize,
|
2017-05-18 18:16:27 +00:00
|
|
|
virQEMUCapsPtr qemuCaps);
|
2010-12-16 15:07:07 +00:00
|
|
|
|
2016-05-15 20:33:27 +00:00
|
|
|
char *qemuDeviceDriveHostAlias(virDomainDiskDefPtr disk);
|
2020-05-04 13:44:43 +00:00
|
|
|
bool qemuDiskBusIsSD(int bus);
|
2010-12-16 15:07:07 +00:00
|
|
|
|
2018-05-16 11:39:22 +00:00
|
|
|
qemuBlockStorageSourceAttachDataPtr
|
|
|
|
qemuBuildStorageSourceAttachPrepareDrive(virDomainDiskDefPtr disk,
|
2018-08-09 11:33:41 +00:00
|
|
|
virQEMUCapsPtr qemuCaps);
|
2021-02-01 11:00:35 +00:00
|
|
|
|
|
|
|
qemuBlockStorageSourceAttachDataPtr
|
|
|
|
qemuBuildStorageSourceAttachPrepareChardev(virDomainDiskDefPtr disk);
|
|
|
|
|
2018-06-01 13:56:47 +00:00
|
|
|
int
|
|
|
|
qemuBuildStorageSourceAttachPrepareCommon(virStorageSourcePtr src,
|
2018-06-01 10:11:06 +00:00
|
|
|
qemuBlockStorageSourceAttachDataPtr data,
|
|
|
|
virQEMUCapsPtr qemuCaps);
|
2010-12-16 15:07:07 +00:00
|
|
|
|
2019-04-04 14:50:49 +00:00
|
|
|
|
|
|
|
qemuBlockStorageSourceChainDataPtr
|
|
|
|
qemuBuildStorageSourceChainAttachPrepareDrive(virDomainDiskDefPtr disk,
|
|
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
|
|
|
|
|
2021-02-01 11:00:35 +00:00
|
|
|
qemuBlockStorageSourceChainDataPtr
|
|
|
|
qemuBuildStorageSourceChainAttachPrepareChardev(virDomainDiskDefPtr disk);
|
|
|
|
|
|
|
|
|
2019-04-04 14:50:49 +00:00
|
|
|
qemuBlockStorageSourceChainDataPtr
|
|
|
|
qemuBuildStorageSourceChainAttachPrepareBlockdev(virStorageSourcePtr top,
|
|
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
|
2019-07-22 08:35:09 +00:00
|
|
|
qemuBlockStorageSourceChainDataPtr
|
|
|
|
qemuBuildStorageSourceChainAttachPrepareBlockdevTop(virStorageSourcePtr top,
|
2019-09-03 12:22:41 +00:00
|
|
|
virStorageSourcePtr backingStore,
|
2019-07-22 08:35:09 +00:00
|
|
|
virQEMUCapsPtr qemuCaps);
|
2019-04-04 14:50:49 +00:00
|
|
|
|
2018-07-10 08:41:04 +00:00
|
|
|
char
|
|
|
|
*qemuBuildDiskDeviceStr(const virDomainDef *def,
|
|
|
|
virDomainDiskDefPtr disk,
|
|
|
|
unsigned int bootindex,
|
|
|
|
virQEMUCapsPtr qemuCaps);
|
2016-02-18 15:06:14 +00:00
|
|
|
|
2010-12-16 15:07:07 +00:00
|
|
|
/* Current, best practice */
|
2017-02-28 09:46:30 +00:00
|
|
|
int qemuBuildControllerDevStr(const virDomainDef *domainDef,
|
|
|
|
virDomainControllerDefPtr def,
|
|
|
|
virQEMUCapsPtr qemuCaps,
|
2019-01-15 15:31:54 +00:00
|
|
|
char **devstr);
|
2010-12-16 15:07:07 +00:00
|
|
|
|
2018-05-18 13:51:36 +00:00
|
|
|
int qemuBuildMemoryBackendProps(virJSONValuePtr *backendProps,
|
2018-05-18 12:48:22 +00:00
|
|
|
const char *alias,
|
2018-05-18 13:51:36 +00:00
|
|
|
virQEMUDriverConfigPtr cfg,
|
2018-11-07 10:14:14 +00:00
|
|
|
qemuDomainObjPrivatePtr priv,
|
2020-05-25 13:00:17 +00:00
|
|
|
const virDomainDef *def,
|
|
|
|
const virDomainMemoryDef *mem,
|
2021-01-08 15:35:26 +00:00
|
|
|
bool force,
|
|
|
|
bool systemMemory);
|
2014-10-12 22:28:58 +00:00
|
|
|
|
2020-11-03 16:31:27 +00:00
|
|
|
char *
|
|
|
|
qemuBuildMemoryDeviceStr(const virDomainDef *def,
|
|
|
|
virDomainMemoryDefPtr mem,
|
|
|
|
virQEMUCapsPtr qemuCaps);
|
2014-10-12 22:28:58 +00:00
|
|
|
|
2010-12-16 15:07:07 +00:00
|
|
|
/* Current, best practice */
|
2016-03-12 00:36:25 +00:00
|
|
|
char *qemuBuildPCIHostdevDevStr(const virDomainDef *def,
|
2014-07-24 13:23:40 +00:00
|
|
|
virDomainHostdevDefPtr dev,
|
2016-03-29 12:31:37 +00:00
|
|
|
unsigned int bootIndex,
|
2014-07-24 13:23:40 +00:00
|
|
|
virQEMUCapsPtr qemuCaps);
|
2010-12-16 15:07:07 +00:00
|
|
|
|
2016-03-12 00:36:27 +00:00
|
|
|
char *qemuBuildRNGDevStr(const virDomainDef *def,
|
2015-01-17 05:09:31 +00:00
|
|
|
virDomainRNGDefPtr dev,
|
|
|
|
virQEMUCapsPtr qemuCaps);
|
2015-01-17 05:09:37 +00:00
|
|
|
int qemuBuildRNGBackendProps(virDomainRNGDefPtr rng,
|
|
|
|
virJSONValuePtr *props);
|
2015-01-17 05:09:31 +00:00
|
|
|
|
2010-12-16 15:07:07 +00:00
|
|
|
/* Current, best practice */
|
2016-03-12 00:36:25 +00:00
|
|
|
char *qemuBuildUSBHostdevDevStr(const virDomainDef *def,
|
2014-07-24 13:23:40 +00:00
|
|
|
virDomainHostdevDefPtr dev,
|
|
|
|
virQEMUCapsPtr qemuCaps);
|
2016-04-13 06:10:24 +00:00
|
|
|
|
2016-03-12 00:36:25 +00:00
|
|
|
char *qemuBuildSCSIHostdevDevStr(const virDomainDef *def,
|
2020-06-19 14:56:36 +00:00
|
|
|
virDomainHostdevDefPtr dev,
|
|
|
|
const char *backendAlias);
|
|
|
|
|
2020-06-19 14:53:56 +00:00
|
|
|
qemuBlockStorageSourceAttachData *
|
|
|
|
qemuBuildHostdevSCSIAttachPrepare(virDomainHostdevDefPtr hostdev,
|
|
|
|
const char **backendAlias,
|
|
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
qemuBlockStorageSourceAttachData *
|
|
|
|
qemuBuildHostdevSCSIDetachPrepare(virDomainHostdevDefPtr hostdev,
|
|
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
|
2016-11-22 03:58:18 +00:00
|
|
|
char *
|
|
|
|
qemuBuildSCSIVHostHostdevDevStr(const virDomainDef *def,
|
|
|
|
virDomainHostdevDefPtr dev,
|
|
|
|
virQEMUCapsPtr qemuCaps,
|
|
|
|
char *vhostfdName);
|
2010-12-16 15:07:07 +00:00
|
|
|
|
2017-02-03 13:24:14 +00:00
|
|
|
char *
|
|
|
|
qemuBuildHostdevMediatedDevStr(const virDomainDef *def,
|
|
|
|
virDomainHostdevDefPtr dev,
|
|
|
|
virQEMUCapsPtr qemuCaps);
|
|
|
|
|
2016-03-12 00:36:24 +00:00
|
|
|
char *qemuBuildRedirdevDevStr(const virDomainDef *def,
|
2014-07-24 13:23:40 +00:00
|
|
|
virDomainRedirdevDefPtr dev,
|
|
|
|
virQEMUCapsPtr qemuCaps);
|
2010-12-16 15:07:07 +00:00
|
|
|
|
2018-11-08 11:00:29 +00:00
|
|
|
char *qemuBuildZPCIDevStr(virDomainDeviceInfoPtr dev);
|
|
|
|
|
qemu: allocate network connections sooner during domain startup
VFIO device assignment requires a cgroup ACL to be setup for access to
the /dev/vfio/nn "group" device for any devices that will be assigned
to a guest. In the case of a host device that is allocated from a
pool, it was being allocated during qemuBuildCommandLine(), which is
called by qemuProcessStart() *after* the all-encompassing
qemuSetupCgroup() was called, meaning that the standard Cgroup ACL
setup wasn't creating ACLs for these devices allocated from pools.
One possible solution was to manually add a single ACL down inside
qemuBuildCommandLine() when networkAllocateActualDevice() is called,
but that has two problems: 1) the function that adds the cgroup ACL
requires a virDomainObjPtr, which isn't available in
qemuBuildCommandLine(), and 2) we really shouldn't be doing network
device setup inside qemuBuildCommandLine() anyway.
Instead, I've created a new function called
qemuNetworkPrepareDevices() which is called just before
qemuPrepareHostDevices() during qemuProcessStart() (explanation of
ordering in the comments), i.e. well before the call to
qemuSetupCgroup(). To minimize code churn in a patch that will be
backported to 1.0.5-maint, qemuNetworkPrepareDevices only does
networkAllocateActualDevice() and the bare amount of setup required
for type='hostdev network devices, but it eventually should do *all*
device setup for guest network devices.
Note that some of the code that was previously needed in
qemuBuildCommandLine() is no longer required when
networkAllocateActualDevice() is called earlier:
* qemuAssignDeviceHostdevAlias() is already done further down in
qemuProcessStart().
* qemuPrepareHostdevPCIDevices() is called by
qemuPrepareHostDevices() which is called after
qemuNetworkPrepareDevices() in qemuProcessStart().
As hinted above, this new function should be moved into a separate
qemu_network.c (or similarly named) file along with
qemuPhysIfaceConnect(), qemuNetworkIfaceConnect(), and
qemuOpenVhostNet(), and expanded to call those functions as well, then
the nnets loop in qemuBuildCommandLine() should be reduced to only
build the commandline string (which itself can be in a separate
qemuInterfaceBuilldCommandLine() function as suggested by
Michal). However, this will require storing away an array of tapfd and
vhostfd that are needed for the commandline, so I would rather do that
in a separate patch and leave this patch at the minimum to fix the
bug.
2013-05-06 19:43:56 +00:00
|
|
|
int qemuNetworkPrepareDevices(virDomainDefPtr def);
|
|
|
|
|
2014-04-08 15:50:50 +00:00
|
|
|
int qemuGetDriveSourceString(virStorageSourcePtr src,
|
2016-04-06 19:00:59 +00:00
|
|
|
qemuDomainSecretInfoPtr secinfo,
|
2014-04-08 15:50:50 +00:00
|
|
|
char **source);
|
2014-07-29 13:21:05 +00:00
|
|
|
|
2018-07-10 14:29:59 +00:00
|
|
|
bool
|
|
|
|
qemuDiskConfigBlkdeviotuneEnabled(virDomainDiskDefPtr disk);
|
|
|
|
|
2014-09-18 15:38:32 +00:00
|
|
|
|
|
|
|
bool
|
2020-10-20 16:48:59 +00:00
|
|
|
qemuCheckFips(virDomainObjPtr vm);
|
2015-08-31 15:06:42 +00:00
|
|
|
|
2016-08-04 12:12:39 +00:00
|
|
|
virJSONValuePtr qemuBuildHotpluggableCPUProps(const virDomainVcpuDef *vcpu)
|
|
|
|
ATTRIBUTE_NONNULL(1);
|
|
|
|
|
2016-08-10 09:15:22 +00:00
|
|
|
virJSONValuePtr qemuBuildShmemBackendMemProps(virDomainShmemDefPtr shmem)
|
|
|
|
ATTRIBUTE_NONNULL(1);
|
|
|
|
|
|
|
|
char *qemuBuildShmemDevStr(virDomainDefPtr def,
|
|
|
|
virDomainShmemDefPtr shmem,
|
|
|
|
virQEMUCapsPtr qemuCaps)
|
|
|
|
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
|
|
|
|
|
2017-09-01 11:39:15 +00:00
|
|
|
char *qemuBuildWatchdogDevStr(const virDomainDef *def,
|
|
|
|
virDomainWatchdogDefPtr dev,
|
|
|
|
virQEMUCapsPtr qemuCaps);
|
2016-08-10 09:15:22 +00:00
|
|
|
|
2017-10-04 09:34:31 +00:00
|
|
|
int qemuBuildInputDevStr(char **devstr,
|
|
|
|
const virDomainDef *def,
|
|
|
|
virDomainInputDefPtr input,
|
|
|
|
virQEMUCapsPtr qemuCaps)
|
|
|
|
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
|
|
|
|
ATTRIBUTE_NONNULL(4);
|
|
|
|
|
2018-05-30 11:53:52 +00:00
|
|
|
char *
|
|
|
|
qemuBuildVsockDevStr(virDomainDefPtr def,
|
|
|
|
virDomainVsockDefPtr vsock,
|
|
|
|
virQEMUCapsPtr qemuCaps,
|
|
|
|
const char *fdprefix)
|
|
|
|
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
|
|
|
|
ATTRIBUTE_NONNULL(4);
|
|
|
|
|
2018-08-14 12:17:52 +00:00
|
|
|
/* 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)
|
2020-08-04 14:17:07 +00:00
|
|
|
ATTRIBUTE_NONNULL(4) G_GNUC_NO_INLINE;
|