12:20 p.m.
It's finally time to start tracking disk backing chains in
<domain> XML. The first step is to start refactoring code
so that we have an object more convenient for representing
each host source resource in the context of a single guest
<disk>. Ultimately, I plan to move the new type into src/util
where it can be reused by virStorageFile, but to make the
transition easier to review, this patch just creates the
new type then fixes everything until it compiles again.
* src/conf/domain_conf.h (_virDomainDiskDef): Split...
(_virDomainDiskSourceDef): ...to new struct.
(virDomainDiskAuthClear): Use new type.
* src/conf/domain_conf.c (virDomainDiskDefFree): Split...
(virDomainDiskSourceDefClear): ...to new function.
(virDomainDiskGetType, virDomainDiskSetType)
(virDomainDiskGetSource, virDomainDiskSetSource)
(virDomainDiskGetDriver, virDomainDiskSetDriver)
(virDomainDiskGetFormat, virDomainDiskSetFormat)
(virDomainDiskAuthClear, virDomainDiskGetActualType)
(virDomainDiskDefParseXML, virDomainDiskSourceDefFormat)
(virDomainDiskDefFormat, virDomainDiskDefForeachPath)
(virDomainDiskDefGetSecurityLabelDef)
(virDomainDiskSourceIsBlockType): Adjust all users.
* src/lxc/lxc_controller.c (virLXCControllerSetupDisk):
Likewise.
* src/lxc/lxc_driver.c (lxcDomainAttachDeviceMknodHelper):
Likewise.
* src/qemu/qemu_command.c (qemuAddRBDHost, qemuParseRBDString)
(qemuParseDriveURIString, qemuParseGlusterString)
(qemuParseISCSIString, qemuParseNBDString)
(qemuDomainDiskGetSourceString, qemuBuildDriveStr)
(qemuBuildCommandLine, qemuParseCommandLineDisk)
(qemuParseCommandLine): Likewise.
* src/qemu/qemu_conf.c (qemuCheckSharedDevice)
(qemuAddISCSIPoolSourceHost, qemuTranslateDiskSourcePool):
Likewise.
* src/qemu/qemu_driver.c (qemuDomainUpdateDeviceConfig)
(qemuDomainPrepareDiskChainElement)
(qemuDomainSnapshotCreateInactiveExternal)
(qemuDomainSnapshotPrepareDiskExternalBackingInactive)
(qemuDomainSnapshotPrepareDiskInternal)
(qemuDomainSnapshotPrepare)
(qemuDomainSnapshotCreateSingleDiskActive)
(qemuDomainSnapshotUndoSingleDiskActive)
(qemuDomainBlockPivot, qemuDomainBlockJobImpl)
(qemuDomainBlockCopy, qemuDomainBlockCommit): Likewise.
* src/qemu/qemu_migration.c (qemuMigrationIsSafe): Likewise.
* src/qemu/qemu_process.c (qemuProcessGetVolumeQcowPassphrase)
(qemuProcessInitPasswords): Likewise.
* src/security/security_selinux.c
(virSecuritySELinuxSetSecurityFileLabel): Likewise.
* src/storage/storage_driver.c (virStorageFileInitFromDiskDef):
Likewise.
* tests/securityselinuxlabeltest.c (testSELinuxLoadDef):
Likewise.
Signed-off-by: Eric Blake <eblake(a)redhat.com>
---
The accessor functions made a huge difference. I wrote this
patch first, and it was over 200k in size; then after redoing
the code to inject accessors, this shrunk under 100k and
touches fewer files. Best of all, most of the hypervisor
drivers that aren't quite as actively developed are NOT part
of this patch, which means my refactoring into accessors
properly isolated the most common usage of fields that got
relocated into the new struct.
src/conf/domain_conf.c | 187 +++++++++++++-----------
src/conf/domain_conf.h | 37 +++--
src/lxc/lxc_controller.c | 8 +-
src/lxc/lxc_driver.c | 8 +-
src/qemu/qemu_command.c | 308 ++++++++++++++++++++-------------------
src/qemu/qemu_conf.c | 86 +++++------
src/qemu/qemu_driver.c | 185 +++++++++++------------
src/qemu/qemu_migration.c | 4 +-
src/qemu/qemu_process.c | 8 +-
src/security/security_selinux.c | 2 +-
src/storage/storage_driver.c | 8 +-
tests/securityselinuxlabeltest.c | 8 +-
12 files changed, 441 insertions(+), 408 deletions(-)
diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c
index a0e07c7..c664624 100644
--- a/src/conf/domain_conf.c
+++ b/src/conf/domain_conf.c
@@ -1248,25 +1248,19 @@ virDomainDiskSourcePoolDefFree(virDomainDiskSourcePoolDefPtr def)
VIR_FREE(def);
}
-void virDomainDiskDefFree(virDomainDiskDefPtr def)
+
+static void
+virDomainDiskSourceDefClear(virDomainDiskSourceDefPtr def)
{
size_t i;
if (!def)
return;
- VIR_FREE(def->serial);
- VIR_FREE(def->src);
+ VIR_FREE(def->path);
virDomainDiskSourcePoolDefFree(def->srcpool);
- VIR_FREE(def->dst);
VIR_FREE(def->driverName);
- virStorageFileFreeMetadata(def->backingChain);
- VIR_FREE(def->mirror);
- VIR_FREE(def->wwn);
- VIR_FREE(def->vendor);
- VIR_FREE(def->product);
virStorageEncryptionFree(def->encryption);
- virDomainDeviceInfoClear(&def->info);
if (def->seclabels) {
for (i = 0; i < def->nseclabels; i++)
@@ -1276,13 +1270,31 @@ void virDomainDiskDefFree(virDomainDiskDefPtr def)
virDomainDiskHostDefFree(def->nhosts, def->hosts);
virDomainDiskAuthClear(def);
+}
+
+
+void
+virDomainDiskDefFree(virDomainDiskDefPtr def)
+{
+ if (!def)
+ return;
+
+ virDomainDiskSourceDefClear(&def->src);
+ VIR_FREE(def->serial);
+ VIR_FREE(def->dst);
+ virStorageFileFreeMetadata(def->backingChain);
+ VIR_FREE(def->mirror);
+ VIR_FREE(def->wwn);
+ VIR_FREE(def->vendor);
+ VIR_FREE(def->product);
+ virDomainDeviceInfoClear(&def->info);
VIR_FREE(def);
}
void
-virDomainDiskAuthClear(virDomainDiskDefPtr def)
+virDomainDiskAuthClear(virDomainDiskSourceDefPtr def)
{
VIR_FREE(def->auth.username);
@@ -1357,31 +1369,31 @@ error:
int
virDomainDiskGetType(virDomainDiskDefPtr def)
{
- return def->type;
+ return def->src.type;
}
void
virDomainDiskSetType(virDomainDiskDefPtr def, int type)
{
- def->type = type;
+ def->src.type = type;
}
int
virDomainDiskGetActualType(virDomainDiskDefPtr def)
{
- if (def->type == VIR_DOMAIN_DISK_TYPE_VOLUME && def->srcpool)
- return def->srcpool->actualtype;
+ if (def->src.type == VIR_DOMAIN_DISK_TYPE_VOLUME && def->src.srcpool)
+ return def->src.srcpool->actualtype;
- return def->type;
+ return def->src.type;
}
const char *
virDomainDiskGetSource(virDomainDiskDefPtr def)
{
- return def->src;
+ return def->src.path;
}
@@ -1389,11 +1401,11 @@ int
virDomainDiskSetSource(virDomainDiskDefPtr def, const char *src)
{
int ret;
- char *tmp = def->src;
+ char *tmp = def->src.path;
- ret = VIR_STRDUP(def->src, src);
+ ret = VIR_STRDUP(def->src.path, src);
if (ret < 0)
- def->src = tmp;
+ def->src.path = tmp;
else
VIR_FREE(tmp);
return ret;
@@ -1403,7 +1415,7 @@ virDomainDiskSetSource(virDomainDiskDefPtr def, const char *src)
const char *
virDomainDiskGetDriver(virDomainDiskDefPtr def)
{
- return def->driverName;
+ return def->src.driverName;
}
@@ -1411,11 +1423,11 @@ int
virDomainDiskSetDriver(virDomainDiskDefPtr def, const char *name)
{
int ret;
- char *tmp = def->driverName;
+ char *tmp = def->src.driverName;
- ret = VIR_STRDUP(def->driverName, name);
+ ret = VIR_STRDUP(def->src.driverName, name);
if (ret < 0)
- def->driverName = tmp;
+ def->src.driverName = tmp;
else
VIR_FREE(tmp);
return ret;
@@ -1425,14 +1437,14 @@ virDomainDiskSetDriver(virDomainDiskDefPtr def, const char *name)
int
virDomainDiskGetFormat(virDomainDiskDefPtr def)
{
- return def->format;
+ return def->src.format;
}
void
virDomainDiskSetFormat(virDomainDiskDefPtr def, int format)
{
- def->format = format;
+ def->src.format = format;
}
@@ -5262,13 +5274,13 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
type = virXMLPropString(node, "type");
if (type) {
- if ((def->type = virDomainDiskTypeFromString(type)) < 0) {
+ if ((def->src.type = virDomainDiskTypeFromString(type)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unknown disk type '%s'"), type);
goto error;
}
} else {
- def->type = VIR_DOMAIN_DISK_TYPE_FILE;
+ def->src.type = VIR_DOMAIN_DISK_TYPE_FILE;
}
snapshot = virXMLPropString(node, "snapshot");
@@ -5279,22 +5291,22 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
cur = node->children;
while (cur != NULL) {
if (cur->type == XML_ELEMENT_NODE) {
- if (!source && !def->hosts && !def->srcpool &&
+ if (!source && !def->src.hosts && !def->src.srcpool
&&
xmlStrEqual(cur->name, BAD_CAST "source")) {
sourceNode = cur;
- if (virDomainDiskSourceDefParse(cur, def->type,
+ if (virDomainDiskSourceDefParse(cur, def->src.type,
&source,
- &def->protocol,
- &def->nhosts,
- &def->hosts,
- &def->srcpool) < 0)
+ &def->src.protocol,
+ &def->src.nhosts,
+ &def->src.hosts,
+ &def->src.srcpool) < 0)
goto error;
- if (def->type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
- if (def->protocol == VIR_DOMAIN_DISK_PROTOCOL_ISCSI)
+ if (def->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
+ if (def->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_ISCSI)
expected_secret_usage = VIR_SECRET_USAGE_TYPE_ISCSI;
- else if (def->protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD)
+ else if (def->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD)
expected_secret_usage = VIR_SECRET_USAGE_TYPE_CEPH;
}
@@ -5403,7 +5415,7 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
goto error;
}
- def->auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_NONE;
+ def->src.auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_NONE;
child = cur->children;
while (child != NULL) {
if (child->type == XML_ELEMENT_NODE &&
@@ -5440,17 +5452,17 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
}
if (authUUID != NULL) {
- def->auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_UUID;
+ def->src.auth.secretType =
VIR_DOMAIN_DISK_SECRET_TYPE_UUID;
if (virUUIDParse(authUUID,
- def->auth.secret.uuid) < 0) {
+ def->src.auth.secret.uuid) < 0) {
virReportError(VIR_ERR_XML_ERROR,
_("malformed uuid %s"),
authUUID);
goto error;
}
} else if (authUsage != NULL) {
- def->auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_USAGE;
- def->auth.secret.usage = authUsage;
+ def->src.auth.secretType =
VIR_DOMAIN_DISK_SECRET_TYPE_USAGE;
+ def->src.auth.secret.usage = authUsage;
authUsage = NULL;
}
}
@@ -5595,7 +5607,7 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
/* Only CDROM and Floppy devices are allowed missing source path
* to indicate no media present. LUN is for raw access CD-ROMs
* that are not attached to a physical device presently */
- if (source == NULL && def->hosts == NULL && !def->srcpool
&&
+ if (source == NULL && def->src.hosts == NULL &&
!def->src.srcpool &&
def->device != VIR_DOMAIN_DISK_DEVICE_CDROM &&
def->device != VIR_DOMAIN_DISK_DEVICE_LUN &&
def->device != VIR_DOMAIN_DISK_DEVICE_FLOPPY) {
@@ -5608,8 +5620,8 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
if (sourceNode) {
xmlNodePtr saved_node = ctxt->node;
ctxt->node = sourceNode;
- if (virSecurityDeviceLabelDefParseXML(&def->seclabels,
- &def->nseclabels,
+ if (virSecurityDeviceLabelDefParseXML(&def->src.seclabels,
+ &def->src.nseclabels,
vmSeclabels,
nvmSeclabels,
ctxt,
@@ -5619,10 +5631,10 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
}
if (target == NULL) {
- if (def->srcpool) {
+ if (def->src.srcpool) {
char *tmp;
if (virAsprintf(&tmp, "pool = '%s', volume =
'%s'",
- def->srcpool->pool, def->srcpool->volume) < 0)
+ def->src.srcpool->pool, def->src.srcpool->volume) < 0)
goto error;
virReportError(VIR_ERR_NO_TARGET, "%s", tmp);
@@ -5887,7 +5899,7 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
goto error;
}
- if (def->type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
+ if (def->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
virReportError(VIR_ERR_XML_ERROR,
_("Setting disk %s is not allowed for "
"disk of network type"),
@@ -5906,18 +5918,18 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
def->startupPolicy = val;
}
- def->src = source;
+ def->src.path = source;
source = NULL;
def->dst = target;
target = NULL;
- def->auth.username = authUsername;
+ def->src.auth.username = authUsername;
authUsername = NULL;
- def->driverName = driverName;
+ def->src.driverName = driverName;
driverName = NULL;
def->mirror = mirror;
mirror = NULL;
def->mirroring = mirroring;
- def->encryption = encryption;
+ def->src.encryption = encryption;
encryption = NULL;
def->serial = serial;
serial = NULL;
@@ -5929,8 +5941,8 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
product = NULL;
if (driverType) {
- def->format = virStorageFileFormatTypeFromString(driverType);
- if (def->format <= 0) {
+ def->src.format = virStorageFileFormatTypeFromString(driverType);
+ if (def->src.format <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unknown driver format value '%s'"),
driverType);
@@ -14900,15 +14912,15 @@ virDomainDiskSourceDefFormat(virBufferPtr buf,
unsigned int flags)
{
return virDomainDiskSourceDefFormatInternal(buf,
- def->type,
- def->src,
+ def->src.type,
+ def->src.path,
def->startupPolicy,
- def->protocol,
- def->nhosts,
- def->hosts,
- def->nseclabels,
- def->seclabels,
- def->srcpool,
+ def->src.protocol,
+ def->src.nhosts,
+ def->src.hosts,
+ def->src.nseclabels,
+ def->src.seclabels,
+ def->src.srcpool,
flags);
}
@@ -14918,7 +14930,7 @@ virDomainDiskDefFormat(virBufferPtr buf,
virDomainDiskDefPtr def,
unsigned int flags)
{
- const char *type = virDomainDiskTypeToString(def->type);
+ const char *type = virDomainDiskTypeToString(def->src.type);
const char *device = virDomainDiskDeviceTypeToString(def->device);
const char *bus = virDomainDiskBusTypeToString(def->bus);
const char *cachemode = virDomainDiskCacheTypeToString(def->cachemode);
@@ -14935,7 +14947,7 @@ virDomainDiskDefFormat(virBufferPtr buf,
if (!type) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected disk type %d"), def->type);
+ _("unexpected disk type %d"), def->src.type);
return -1;
}
if (!device) {
@@ -14985,14 +14997,14 @@ virDomainDiskDefFormat(virBufferPtr buf,
virBufferAddLit(buf, ">\n");
virBufferAdjustIndent(buf, 2);
- if (def->driverName || def->format > 0 || def->cachemode ||
+ if (def->src.driverName || def->src.format > 0 || def->cachemode ||
def->ioeventfd || def->event_idx || def->copy_on_read) {
virBufferAddLit(buf, "<driver");
- if (def->driverName)
- virBufferAsprintf(buf, " name='%s'", def->driverName);
- if (def->format > 0)
+ if (def->src.driverName)
+ virBufferAsprintf(buf, " name='%s'",
def->src.driverName);
+ if (def->src.format > 0)
virBufferAsprintf(buf, " type='%s'",
- virStorageFileFormatTypeToString(def->format));
+ virStorageFileFormatTypeToString(def->src.format));
if (def->cachemode)
virBufferAsprintf(buf, " cache='%s'", cachemode);
if (def->error_policy)
@@ -15012,23 +15024,23 @@ virDomainDiskDefFormat(virBufferPtr buf,
virBufferAddLit(buf, "/>\n");
}
- if (def->auth.username) {
+ if (def->src.auth.username) {
virBufferEscapeString(buf, "<auth username='%s'>\n",
- def->auth.username);
+ def->src.auth.username);
virBufferAdjustIndent(buf, 2);
- if (def->protocol == VIR_DOMAIN_DISK_PROTOCOL_ISCSI) {
+ if (def->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_ISCSI) {
virBufferAddLit(buf, "<secret type='iscsi'");
- } else if (def->protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD) {
+ } else if (def->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD) {
virBufferAddLit(buf, "<secret type='ceph'");
}
- if (def->auth.secretType == VIR_DOMAIN_DISK_SECRET_TYPE_UUID) {
- virUUIDFormat(def->auth.secret.uuid, uuidstr);
+ if (def->src.auth.secretType == VIR_DOMAIN_DISK_SECRET_TYPE_UUID) {
+ virUUIDFormat(def->src.auth.secret.uuid, uuidstr);
virBufferAsprintf(buf, " uuid='%s'/>\n", uuidstr);
}
- if (def->auth.secretType == VIR_DOMAIN_DISK_SECRET_TYPE_USAGE) {
+ if (def->src.auth.secretType == VIR_DOMAIN_DISK_SECRET_TYPE_USAGE) {
virBufferEscapeString(buf, " usage='%s'/>\n",
- def->auth.secret.usage);
+ def->src.auth.secret.usage);
}
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</auth>\n");
@@ -15119,7 +15131,8 @@ virDomainDiskDefFormat(virBufferPtr buf,
virBufferEscapeString(buf, "<wwn>%s</wwn>\n", def->wwn);
virBufferEscapeString(buf, "<vendor>%s</vendor>\n",
def->vendor);
virBufferEscapeString(buf, "<product>%s</product>\n",
def->product);
- if (def->encryption && virStorageEncryptionFormat(buf, def->encryption)
< 0)
+ if (def->src.encryption &&
+ virStorageEncryptionFormat(buf, def->src.encryption) < 0)
return -1;
if (virDomainDeviceInfoFormat(buf, &def->info,
flags | VIR_DOMAIN_XML_INTERNAL_ALLOW_BOOT) < 0)
@@ -18536,8 +18549,8 @@ virDomainDiskDefForeachPath(virDomainDiskDefPtr disk,
if (!path || type == VIR_DOMAIN_DISK_TYPE_NETWORK ||
(type == VIR_DOMAIN_DISK_TYPE_VOLUME &&
- disk->srcpool &&
- disk->srcpool->mode == VIR_DOMAIN_DISK_SOURCE_POOL_MODE_DIRECT))
+ disk->src.srcpool &&
+ disk->src.srcpool->mode == VIR_DOMAIN_DISK_SOURCE_POOL_MODE_DIRECT))
return 0;
if (iter(disk, path, 0, opaque) < 0)
@@ -19299,9 +19312,9 @@ virDomainDiskDefGetSecurityLabelDef(virDomainDiskDefPtr def, const
char *model)
if (def == NULL)
return NULL;
- for (i = 0; i < def->nseclabels; i++) {
- if (STREQ_NULLABLE(def->seclabels[i]->model, model))
- return def->seclabels[i];
+ for (i = 0; i < def->src.nseclabels; i++) {
+ if (STREQ_NULLABLE(def->src.seclabels[i]->model, model))
+ return def->src.seclabels[i];
}
return NULL;
}
@@ -19420,14 +19433,14 @@ virDomainDiskSourceIsBlockType(virDomainDiskDefPtr def)
* If it's a block type source pool, then it's possible
*/
if (virDomainDiskGetType(def) == VIR_DOMAIN_DISK_TYPE_VOLUME &&
- def->srcpool &&
- def->srcpool->voltype == VIR_STORAGE_VOL_BLOCK) {
+ def->src.srcpool &&
+ def->src.srcpool->voltype == VIR_STORAGE_VOL_BLOCK) {
/* We don't think the volume accessed by remote URI is
* block type source, since we can't/shouldn't manage it
* (e.g. set sgio=filtered|unfiltered for it) in libvirt.
*/
- if (def->srcpool->pooltype == VIR_STORAGE_POOL_ISCSI &&
- def->srcpool->mode == VIR_DOMAIN_DISK_SOURCE_POOL_MODE_DIRECT)
+ if (def->src.srcpool->pooltype == VIR_STORAGE_POOL_ISCSI &&
+ def->src.srcpool->mode == VIR_DOMAIN_DISK_SOURCE_POOL_MODE_DIRECT)
return false;
return true;
diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h
index cc447b0..ef3dd38 100644
--- a/src/conf/domain_conf.h
+++ b/src/conf/domain_conf.h
@@ -705,15 +705,15 @@ struct _virDomainDiskSourcePoolDef {
};
typedef virDomainDiskSourcePoolDef *virDomainDiskSourcePoolDefPtr;
-/* Stores the virtual disk configuration */
-struct _virDomainDiskDef {
+typedef struct _virDomainDiskSourceDef virDomainDiskSourceDef;
+typedef virDomainDiskSourceDef *virDomainDiskSourceDefPtr;
+
+/* Stores information related to a host resource. In the case of
+ * backing chains, multiple source disks join to form a single guest
+ * view. TODO Move this to util/ */
+struct _virDomainDiskSourceDef {
int type; /* enum virDomainDiskType */
- int device; /* enum virDomainDiskDevice */
- int bus; /* enum virDomainDiskBus */
- char *src;
- char *dst;
- int tray_status; /* enum virDomainDiskTray */
- int removable; /* enum virDomainFeatureState */
+ char *path;
int protocol; /* enum virDomainDiskProtocol */
size_t nhosts;
virDomainDiskHostDefPtr hosts;
@@ -726,8 +726,23 @@ struct _virDomainDiskDef {
char *usage;
} secret;
} auth;
+ virStorageEncryptionPtr encryption;
char *driverName;
int format; /* enum virStorageFileFormat */
+
+ size_t nseclabels;
+ virSecurityDeviceLabelDefPtr *seclabels;
+};
+
+/* Stores the virtual disk configuration */
+struct _virDomainDiskDef {
+ virDomainDiskSourceDef src;
+
+ int device; /* enum virDomainDiskDevice */
+ int bus; /* enum virDomainDiskBus */
+ char *dst;
+ int tray_status; /* enum virDomainDiskTray */
+ int removable; /* enum virDomainFeatureState */
virStorageFileMetadataPtr backingChain;
char *mirror;
@@ -765,14 +780,10 @@ struct _virDomainDiskDef {
bool shared;
bool transient;
virDomainDeviceInfo info;
- virStorageEncryptionPtr encryption;
bool rawio_specified;
int rawio; /* no = 0, yes = 1 */
int sgio; /* enum virDomainDeviceSGIO */
int discard; /* enum virDomainDiskDiscard */
-
- size_t nseclabels;
- virSecurityDeviceLabelDefPtr *seclabels;
};
@@ -2251,7 +2262,7 @@ void virDomainGraphicsDefFree(virDomainGraphicsDefPtr def);
void virDomainInputDefFree(virDomainInputDefPtr def);
void virDomainDiskDefFree(virDomainDiskDefPtr def);
void virDomainLeaseDefFree(virDomainLeaseDefPtr def);
-void virDomainDiskAuthClear(virDomainDiskDefPtr def);
+void virDomainDiskAuthClear(virDomainDiskSourceDefPtr def);
void virDomainDiskHostDefClear(virDomainDiskHostDefPtr def);
void virDomainDiskHostDefFree(size_t nhosts, virDomainDiskHostDefPtr hosts);
virDomainDiskHostDefPtr virDomainDiskHostDefCopy(size_t nhosts,
diff --git a/src/lxc/lxc_controller.c b/src/lxc/lxc_controller.c
index 6ed13fb..3425110 100644
--- a/src/lxc/lxc_controller.c
+++ b/src/lxc/lxc_controller.c
@@ -1669,7 +1669,7 @@ static int virLXCControllerSetupDisk(virLXCControllerPtr ctrl,
int ret = -1;
struct stat sb;
mode_t mode;
- char *tmpsrc = def->src;
+ char *tmpsrc = def->src.path;
if (virDomainDiskGetType(def) != VIR_DOMAIN_DISK_TYPE_BLOCK) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
@@ -1686,7 +1686,7 @@ static int virLXCControllerSetupDisk(virLXCControllerPtr ctrl,
LXC_STATE_DIR, ctrl->def->name, def->dst) < 0)
goto cleanup;
- if (stat(def->src, &sb) < 0) {
+ if (stat(def->src.path, &sb) < 0) {
virReportSystemError(errno,
_("Unable to access %s"), tmpsrc);
goto cleanup;
@@ -1726,14 +1726,14 @@ static int virLXCControllerSetupDisk(virLXCControllerPtr ctrl,
/* Labelling normally operates on src, but we need
* to actually label the dst here, so hack the config */
- def->src = dst;
+ def->src.path = dst;
if (virSecurityManagerSetImageLabel(securityDriver, ctrl->def, def) < 0)
goto cleanup;
ret = 0;
cleanup:
- def->src = tmpsrc;
+ def->src.path = tmpsrc;
VIR_FREE(dst);
return ret;
}
diff --git a/src/lxc/lxc_driver.c b/src/lxc/lxc_driver.c
index 5546861..7fd95cc 100644
--- a/src/lxc/lxc_driver.c
+++ b/src/lxc/lxc_driver.c
@@ -3901,14 +3901,14 @@ lxcDomainAttachDeviceMknodHelper(pid_t pid ATTRIBUTE_UNUSED,
switch (data->def->type) {
case VIR_DOMAIN_DEVICE_DISK: {
virDomainDiskDefPtr def = data->def->data.disk;
- char *tmpsrc = def->src;
- def->src = data->file;
+ char *tmpsrc = def->src.path;
+ def->src.path = data->file;
if (virSecurityManagerSetImageLabel(data->driver->securityManager,
data->vm->def, def) < 0) {
- def->src = tmpsrc;
+ def->src.path = tmpsrc;
goto cleanup;
}
- def->src = tmpsrc;
+ def->src.path = tmpsrc;
} break;
case VIR_DOMAIN_DEVICE_HOSTDEV: {
diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c
index 5ca3f74..e4783c6 100644
--- a/src/qemu/qemu_command.c
+++ b/src/qemu/qemu_command.c
@@ -3254,7 +3254,7 @@ static int qemuAddRBDHost(virDomainDiskDefPtr disk, char *hostport)
size_t skip;
char **parts;
- if (VIR_EXPAND_N(disk->hosts, disk->nhosts, 1) < 0)
+ if (VIR_EXPAND_N(disk->src.hosts, disk->src.nhosts, 1) < 0)
return -1;
if ((port = strchr(hostport, ']'))) {
@@ -3269,29 +3269,29 @@ static int qemuAddRBDHost(virDomainDiskDefPtr disk, char
*hostport)
if (port) {
*port = '\0';
port += skip;
- if (VIR_STRDUP(disk->hosts[disk->nhosts - 1].port, port) < 0)
+ if (VIR_STRDUP(disk->src.hosts[disk->src.nhosts - 1].port, port) < 0)
goto error;
} else {
- if (VIR_STRDUP(disk->hosts[disk->nhosts - 1].port, "6789") <
0)
+ if (VIR_STRDUP(disk->src.hosts[disk->src.nhosts - 1].port,
"6789") < 0)
goto error;
}
parts = virStringSplit(hostport, "\\:", 0);
if (!parts)
goto error;
- disk->hosts[disk->nhosts-1].name = virStringJoin((const char **)parts,
":");
+ disk->src.hosts[disk->src.nhosts-1].name = virStringJoin((const char **)parts,
":");
virStringFreeList(parts);
- if (!disk->hosts[disk->nhosts-1].name)
+ if (!disk->src.hosts[disk->src.nhosts-1].name)
goto error;
- disk->hosts[disk->nhosts-1].transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
- disk->hosts[disk->nhosts-1].socket = NULL;
+ disk->src.hosts[disk->src.nhosts-1].transport =
VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
+ disk->src.hosts[disk->src.nhosts-1].socket = NULL;
return 0;
error:
- VIR_FREE(disk->hosts[disk->nhosts-1].port);
- VIR_FREE(disk->hosts[disk->nhosts-1].name);
+ VIR_FREE(disk->src.hosts[disk->src.nhosts-1].port);
+ VIR_FREE(disk->src.hosts[disk->src.nhosts-1].name);
return -1;
}
@@ -3301,7 +3301,7 @@ static int qemuParseRBDString(virDomainDiskDefPtr disk)
char *options = NULL;
char *p, *e, *next;
- p = strchr(disk->src, ':');
+ p = strchr(disk->src.path, ':');
if (p) {
if (VIR_STRDUP(options, p + 1) < 0)
goto error;
@@ -3330,7 +3330,7 @@ static int qemuParseRBDString(virDomainDiskDefPtr disk)
}
if (STRPREFIX(p, "id=") &&
- VIR_STRDUP(disk->auth.username, p + strlen("id=")) < 0)
+ VIR_STRDUP(disk->src.auth.username, p + strlen("id=")) < 0)
goto error;
if (STRPREFIX(p, "mon_host=")) {
char *h, *sep;
@@ -3373,7 +3373,7 @@ qemuParseDriveURIString(virDomainDiskDefPtr def, virURIPtr uri,
char *volimg = NULL;
char *secret = NULL;
- if (VIR_ALLOC(def->hosts) < 0)
+ if (VIR_ALLOC(def->src.hosts) < 0)
goto error;
transp = strchr(uri->scheme, '+');
@@ -3387,30 +3387,30 @@ qemuParseDriveURIString(virDomainDiskDefPtr def, virURIPtr uri,
}
if (!transp) {
- def->hosts->transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
+ def->src.hosts->transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
} else {
- def->hosts->transport =
virDomainDiskProtocolTransportTypeFromString(transp);
- if (def->hosts->transport < 0) {
+ def->src.hosts->transport =
virDomainDiskProtocolTransportTypeFromString(transp);
+ if (def->src.hosts->transport < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Invalid %s transport type '%s'"), scheme,
transp);
goto error;
}
}
- def->nhosts = 0; /* set to 1 once everything succeeds */
+ def->src.nhosts = 0; /* set to 1 once everything succeeds */
- if (def->hosts->transport != VIR_DOMAIN_DISK_PROTO_TRANS_UNIX) {
- if (VIR_STRDUP(def->hosts->name, uri->server) < 0)
+ if (def->src.hosts->transport != VIR_DOMAIN_DISK_PROTO_TRANS_UNIX) {
+ if (VIR_STRDUP(def->src.hosts->name, uri->server) < 0)
goto error;
- if (virAsprintf(&def->hosts->port, "%d", uri->port) <
0)
+ if (virAsprintf(&def->src.hosts->port, "%d", uri->port)
< 0)
goto error;
} else {
- def->hosts->name = NULL;
- def->hosts->port = 0;
+ def->src.hosts->name = NULL;
+ def->src.hosts->port = 0;
if (uri->query) {
if (STRPREFIX(uri->query, "socket=")) {
sock = strchr(uri->query, '=') + 1;
- if (VIR_STRDUP(def->hosts->socket, sock) < 0)
+ if (VIR_STRDUP(def->src.hosts->socket, sock) < 0)
goto error;
} else {
virReportError(VIR_ERR_INTERNAL_ERROR,
@@ -3421,12 +3421,11 @@ qemuParseDriveURIString(virDomainDiskDefPtr def, virURIPtr uri,
}
if (uri->path) {
volimg = uri->path + 1; /* skip the prefix slash */
- VIR_FREE(def->src);
- if (VIR_STRDUP(def->src, volimg) < 0)
+ VIR_FREE(def->src.path);
+ if (VIR_STRDUP(def->src.path, volimg) < 0)
goto error;
} else {
- VIR_FREE(def->src);
- def->src = NULL;
+ VIR_FREE(def->src.path);
}
if (uri->user) {
@@ -3434,11 +3433,11 @@ qemuParseDriveURIString(virDomainDiskDefPtr def, virURIPtr uri,
if (secret)
*secret = '\0';
- if (VIR_STRDUP(def->auth.username, uri->user) < 0)
+ if (VIR_STRDUP(def->src.auth.username, uri->user) < 0)
goto error;
}
- def->nhosts = 1;
+ def->src.nhosts = 1;
ret = 0;
cleanup:
@@ -3447,8 +3446,8 @@ cleanup:
return ret;
error:
- virDomainDiskHostDefClear(def->hosts);
- VIR_FREE(def->hosts);
+ virDomainDiskHostDefClear(def->src.hosts);
+ VIR_FREE(def->src.hosts);
goto cleanup;
}
@@ -3457,7 +3456,7 @@ qemuParseGlusterString(virDomainDiskDefPtr def)
{
virURIPtr uri = NULL;
- if (!(uri = virURIParse(def->src)))
+ if (!(uri = virURIParse(def->src.path)))
return -1;
return qemuParseDriveURIString(def, uri, "gluster");
@@ -3470,7 +3469,7 @@ qemuParseISCSIString(virDomainDiskDefPtr def)
char *slash;
unsigned lun;
- if (!(uri = virURIParse(def->src)))
+ if (!(uri = virURIParse(def->src.path)))
return -1;
if (uri->path &&
@@ -3480,7 +3479,8 @@ qemuParseISCSIString(virDomainDiskDefPtr def)
*slash = '\0';
else if (virStrToLong_ui(slash + 1, NULL, 10, &lun) == -1) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("invalid name '%s' for iSCSI disk"),
def->src);
+ _("invalid name '%s' for iSCSI disk"),
+ def->src.path);
return -1;
}
}
@@ -3497,8 +3497,8 @@ qemuParseNBDString(virDomainDiskDefPtr disk)
virURIPtr uri = NULL;
- if (strstr(disk->src, "://")) {
- if (!(uri = virURIParse(disk->src)))
+ if (strstr(disk->src.path, "://")) {
+ if (!(uri = virURIParse(disk->src.path)))
return -1;
return qemuParseDriveURIString(disk, uri, "nbd");
}
@@ -3506,7 +3506,7 @@ qemuParseNBDString(virDomainDiskDefPtr disk)
if (VIR_ALLOC(h) < 0)
goto error;
- host = disk->src + strlen("nbd:");
+ host = disk->src.path + strlen("nbd:");
if (STRPREFIX(host, "unix:/")) {
src = strchr(host + strlen("unix:"), ':');
if (src)
@@ -3519,7 +3519,7 @@ qemuParseNBDString(virDomainDiskDefPtr disk)
port = strchr(host, ':');
if (!port) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("cannot parse nbd filename '%s'"),
disk->src);
+ _("cannot parse nbd filename '%s'"),
disk->src.path);
goto error;
}
@@ -3542,10 +3542,10 @@ qemuParseNBDString(virDomainDiskDefPtr disk)
src = NULL;
}
- VIR_FREE(disk->src);
- disk->src = src;
- disk->nhosts = 1;
- disk->hosts = h;
+ VIR_FREE(disk->src.path);
+ disk->src.path = src;
+ disk->src.nhosts = 1;
+ disk->src.hosts = h;
return 0;
error:
@@ -3874,35 +3874,35 @@ qemuDomainDiskGetSourceString(virConnectPtr conn,
*source = NULL;
if (actualType == VIR_DOMAIN_DISK_TYPE_NETWORK &&
- disk->auth.username &&
- (disk->protocol == VIR_DOMAIN_DISK_PROTOCOL_ISCSI ||
- disk->protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD)) {
+ disk->src.auth.username &&
+ (disk->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_ISCSI ||
+ disk->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD)) {
bool encode = false;
int secretType = VIR_SECRET_USAGE_TYPE_ISCSI;
- if (disk->protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD) {
+ if (disk->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD) {
/* qemu requires the secret to be encoded for RBD */
encode = true;
secretType = VIR_SECRET_USAGE_TYPE_CEPH;
}
if (!(secret = qemuGetSecretString(conn,
-
virDomainDiskProtocolTypeToString(disk->protocol),
+
virDomainDiskProtocolTypeToString(disk->src.protocol),
encode,
- disk->auth.secretType,
- disk->auth.username,
- disk->auth.secret.uuid,
- disk->auth.secret.usage,
+ disk->src.auth.secretType,
+ disk->src.auth.username,
+ disk->src.auth.secret.uuid,
+ disk->src.auth.secret.usage,
secretType)))
goto cleanup;
}
ret = qemuGetDriveSourceString(virDomainDiskGetActualType(disk),
- disk->src,
- disk->protocol,
- disk->nhosts,
- disk->hosts,
- disk->auth.username,
+ disk->src.path,
+ disk->src.protocol,
+ disk->src.nhosts,
+ disk->src.hosts,
+ disk->src.auth.username,
secret,
source);
@@ -4020,10 +4020,11 @@ qemuBuildDriveStr(virConnectPtr conn,
switch (actualType) {
case VIR_DOMAIN_DISK_TYPE_DIR:
/* QEMU only supports magic FAT format for now */
- if (disk->format > 0 && disk->format !=
VIR_STORAGE_FILE_FAT) {
+ if (disk->src.format > 0 &&
+ disk->src.format != VIR_STORAGE_FILE_FAT) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unsupported disk driver type for
'%s'"),
- virStorageFileFormatTypeToString(disk->format));
+ virStorageFileFormatTypeToString(disk->src.format));
goto error;
}
@@ -4043,7 +4044,7 @@ qemuBuildDriveStr(virConnectPtr conn,
case VIR_DOMAIN_DISK_TYPE_BLOCK:
if (disk->tray_status == VIR_DOMAIN_DISK_TRAY_OPEN) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
- disk->type == VIR_DOMAIN_DISK_TYPE_VOLUME ?
+ disk->src.type == VIR_DOMAIN_DISK_TYPE_VOLUME ?
_("tray status 'open' is invalid for block
type volume") :
_("tray status 'open' is invalid for block
type disk"));
goto error;
@@ -4103,11 +4104,11 @@ qemuBuildDriveStr(virConnectPtr conn,
_("transient disks not supported yet"));
goto error;
}
- if (disk->format > 0 &&
- disk->type != VIR_DOMAIN_DISK_TYPE_DIR &&
+ if (disk->src.format > 0 &&
+ disk->src.type != VIR_DOMAIN_DISK_TYPE_DIR &&
virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_FORMAT))
virBufferAsprintf(&opt, ",format=%s",
- virStorageFileFormatTypeToString(disk->format));
+ virStorageFileFormatTypeToString(disk->src.format));
/* generate geometry command string */
if (disk->geometry.cylinders > 0 &&
@@ -4318,11 +4319,11 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
bus);
goto error;
}
- if (disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
- if (disk->protocol != VIR_DOMAIN_DISK_PROTOCOL_ISCSI) {
+ if (disk->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
+ if (disk->src.protocol != VIR_DOMAIN_DISK_PROTOCOL_ISCSI) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("disk device='lun' is not supported for
protocol='%s'"),
- virDomainDiskProtocolTypeToString(disk->protocol));
+
virDomainDiskProtocolTypeToString(disk->src.protocol));
goto error;
}
} else if (!virDomainDiskSourceIsBlockType(disk)) {
@@ -8413,11 +8414,11 @@ qemuBuildCommandLine(virConnectPtr conn,
for (i = 0; i < def->ndisks; i++) {
virDomainDiskDefPtr disk = def->disks[i];
- if (disk->driverName != NULL &&
- !STREQ(disk->driverName, "qemu")) {
+ if (disk->src.driverName != NULL &&
+ !STREQ(disk->src.driverName, "qemu")) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unsupported driver name '%s' for disk
'%s'"),
- disk->driverName, disk->src);
+ disk->src.driverName, disk->src.path);
goto error;
}
}
@@ -8541,11 +8542,11 @@ qemuBuildCommandLine(virConnectPtr conn,
!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
virCommandAddArg(cmd, "-usbdevice");
- virCommandAddArgFormat(cmd, "disk:%s", disk->src);
+ virCommandAddArgFormat(cmd, "disk:%s", disk->src.path);
} else {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unsupported usb disk type for
'%s'"),
- disk->src);
+ disk->src.path);
goto error;
}
continue;
@@ -8631,7 +8632,7 @@ qemuBuildCommandLine(virConnectPtr conn,
const char *fmt;
virDomainDiskDefPtr disk = def->disks[i];
- if ((disk->type == VIR_DOMAIN_DISK_TYPE_BLOCK) &&
+ if ((disk->src.type == VIR_DOMAIN_DISK_TYPE_BLOCK) &&
(disk->tray_status == VIR_DOMAIN_DISK_TRAY_OPEN)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("tray status 'open' is invalid for "
@@ -8642,11 +8643,11 @@ qemuBuildCommandLine(virConnectPtr conn,
if (disk->bus == VIR_DOMAIN_DISK_BUS_USB) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
virCommandAddArg(cmd, "-usbdevice");
- virCommandAddArgFormat(cmd, "disk:%s", disk->src);
+ virCommandAddArgFormat(cmd, "disk:%s", disk->src.path);
} else {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unsupported usb disk type for
'%s'"),
- disk->src);
+ disk->src.path);
goto error;
}
continue;
@@ -8654,7 +8655,7 @@ qemuBuildCommandLine(virConnectPtr conn,
if (STREQ(disk->dst, "hdc") &&
disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
- if (disk->src) {
+ if (disk->src.path) {
snprintf(dev, NAME_MAX, "-%s", "cdrom");
} else {
continue;
@@ -8670,12 +8671,13 @@ qemuBuildCommandLine(virConnectPtr conn,
}
}
- if (disk->type == VIR_DOMAIN_DISK_TYPE_DIR) {
+ if (disk->src.type == VIR_DOMAIN_DISK_TYPE_DIR) {
/* QEMU only supports magic FAT format for now */
- if (disk->format > 0 && disk->format !=
VIR_STORAGE_FILE_FAT) {
+ if (disk->src.format > 0 &&
+ disk->src.format != VIR_STORAGE_FILE_FAT) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unsupported disk driver type for
'%s'"),
- virStorageFileFormatTypeToString(disk->format));
+
virStorageFileFormatTypeToString(disk->src.format));
goto error;
}
if (!disk->readonly) {
@@ -8690,11 +8692,11 @@ qemuBuildCommandLine(virConnectPtr conn,
if (virAsprintf(&file, fmt, disk->src) < 0)
goto error;
- } else if (disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
+ } else if (disk->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("network disks are only supported with
-drive"));
} else {
- if (VIR_STRDUP(file, disk->src) < 0) {
+ if (VIR_STRDUP(file, disk->src.path) < 0) {
goto error;
}
}
@@ -10198,28 +10200,28 @@ qemuParseCommandLineDisk(virDomainXMLOptionPtr xmlopt,
else
def->bus = VIR_DOMAIN_DISK_BUS_IDE;
def->device = VIR_DOMAIN_DISK_DEVICE_DISK;
- def->type = VIR_DOMAIN_DISK_TYPE_FILE;
+ def->src.type = VIR_DOMAIN_DISK_TYPE_FILE;
for (i = 0; i < nkeywords; i++) {
if (STREQ(keywords[i], "file")) {
if (values[i] && STRNEQ(values[i], "")) {
- def->src = values[i];
+ def->src.path = values[i];
values[i] = NULL;
- if (STRPREFIX(def->src, "/dev/"))
- def->type = VIR_DOMAIN_DISK_TYPE_BLOCK;
- else if (STRPREFIX(def->src, "nbd:") ||
- STRPREFIX(def->src, "nbd+")) {
- def->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
- def->protocol = VIR_DOMAIN_DISK_PROTOCOL_NBD;
+ if (STRPREFIX(def->src.path, "/dev/"))
+ def->src.type = VIR_DOMAIN_DISK_TYPE_BLOCK;
+ else if (STRPREFIX(def->src.path, "nbd:") ||
+ STRPREFIX(def->src.path, "nbd+")) {
+ def->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_NBD;
if (qemuParseNBDString(def) < 0)
goto error;
- } else if (STRPREFIX(def->src, "rbd:")) {
- char *p = def->src;
+ } else if (STRPREFIX(def->src.path, "rbd:")) {
+ char *p = def->src.path;
- def->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
- def->protocol = VIR_DOMAIN_DISK_PROTOCOL_RBD;
- if (VIR_STRDUP(def->src, p + strlen("rbd:")) < 0)
+ def->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_RBD;
+ if (VIR_STRDUP(def->src.path, p + strlen("rbd:")) <
0)
goto error;
/* old-style CEPH_ARGS env variable is parsed later */
if (!old_style_ceph_args && qemuParseRBDString(def) < 0)
{
@@ -10228,57 +10230,58 @@ qemuParseCommandLineDisk(virDomainXMLOptionPtr xmlopt,
}
VIR_FREE(p);
- } else if (STRPREFIX(def->src, "gluster:") ||
- STRPREFIX(def->src, "gluster+")) {
- def->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
- def->protocol = VIR_DOMAIN_DISK_PROTOCOL_GLUSTER;
+ } else if (STRPREFIX(def->src.path, "gluster:") ||
+ STRPREFIX(def->src.path, "gluster+")) {
+ def->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_GLUSTER;
if (qemuParseGlusterString(def) < 0)
goto error;
- } else if (STRPREFIX(def->src, "iscsi:")) {
- def->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
- def->protocol = VIR_DOMAIN_DISK_PROTOCOL_ISCSI;
+ } else if (STRPREFIX(def->src.path, "iscsi:")) {
+ def->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_ISCSI;
if (qemuParseISCSIString(def) < 0)
goto error;
- } else if (STRPREFIX(def->src, "sheepdog:")) {
- char *p = def->src;
+ } else if (STRPREFIX(def->src.path, "sheepdog:")) {
+ char *p = def->src.path;
char *port, *vdi;
- def->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
- def->protocol = VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG;
- if (VIR_STRDUP(def->src, p + strlen("sheepdog:")) <
0)
+ def->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG;
+ if (VIR_STRDUP(def->src.path, p + strlen("sheepdog:"))
< 0)
goto error;
VIR_FREE(p);
- /* def->src must be [vdiname] or [host]:[port]:[vdiname] */
- port = strchr(def->src, ':');
+ /* def->src.path must be [vdiname] or [host]:[port]:[vdiname] */
+ port = strchr(def->src.path, ':');
if (port) {
*port = '\0';
vdi = strchr(port + 1, ':');
if (!vdi) {
*port = ':';
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("cannot parse sheepdog filename
'%s'"), def->src);
+ _("cannot parse sheepdog filename
'%s'"),
+ def->src.path);
goto error;
}
port++;
*vdi++ = '\0';
- if (VIR_ALLOC(def->hosts) < 0)
+ if (VIR_ALLOC(def->src.hosts) < 0)
goto error;
- def->nhosts = 1;
- def->hosts->name = def->src;
- if (VIR_STRDUP(def->hosts->port, port) < 0)
+ def->src.nhosts = 1;
+ def->src.hosts->name = def->src.path;
+ if (VIR_STRDUP(def->src.hosts->port, port) < 0)
goto error;
- def->hosts->transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
- def->hosts->socket = NULL;
- if (VIR_STRDUP(def->src, vdi) < 0)
+ def->src.hosts->transport =
VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
+ def->src.hosts->socket = NULL;
+ if (VIR_STRDUP(def->src.path, vdi) < 0)
goto error;
}
} else
- def->type = VIR_DOMAIN_DISK_TYPE_FILE;
+ def->src.type = VIR_DOMAIN_DISK_TYPE_FILE;
} else {
- def->type = VIR_DOMAIN_DISK_TYPE_FILE;
+ def->src.type = VIR_DOMAIN_DISK_TYPE_FILE;
}
} else if (STREQ(keywords[i], "if")) {
if (STREQ(values[i], "ide")) {
@@ -10304,9 +10307,9 @@ qemuParseCommandLineDisk(virDomainXMLOptionPtr xmlopt,
} else if (STREQ(values[i], "floppy"))
def->device = VIR_DOMAIN_DISK_DEVICE_FLOPPY;
} else if (STREQ(keywords[i], "format")) {
- if (VIR_STRDUP(def->driverName, "qemu") < 0)
+ if (VIR_STRDUP(def->src.driverName, "qemu") < 0)
goto error;
- def->format = virStorageFileFormatTypeFromString(values[i]);
+ def->src.format = virStorageFileFormatTypeFromString(values[i]);
} else if (STREQ(keywords[i], "cache")) {
if (STREQ(values[i], "off") ||
STREQ(values[i], "none"))
@@ -10411,9 +10414,9 @@ qemuParseCommandLineDisk(virDomainXMLOptionPtr xmlopt,
if (def->rerror_policy == def->error_policy)
def->rerror_policy = 0;
- if (!def->src &&
+ if (!def->src.path &&
def->device == VIR_DOMAIN_DISK_DEVICE_DISK &&
- def->type != VIR_DOMAIN_DISK_TYPE_NETWORK) {
+ def->src.type != VIR_DOMAIN_DISK_TYPE_NETWORK) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("missing file parameter in drive '%s'"),
val);
goto error;
@@ -11497,23 +11500,23 @@ qemuParseCommandLine(virCapsPtr qemuCaps,
goto error;
if (STRPREFIX(val, "/dev/"))
- disk->type = VIR_DOMAIN_DISK_TYPE_BLOCK;
+ disk->src.type = VIR_DOMAIN_DISK_TYPE_BLOCK;
else if (STRPREFIX(val, "nbd:")) {
- disk->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
- disk->protocol = VIR_DOMAIN_DISK_PROTOCOL_NBD;
+ disk->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ disk->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_NBD;
} else if (STRPREFIX(val, "rbd:")) {
- disk->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
- disk->protocol = VIR_DOMAIN_DISK_PROTOCOL_RBD;
+ disk->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ disk->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_RBD;
val += strlen("rbd:");
} else if (STRPREFIX(val, "gluster")) {
- disk->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
- disk->protocol = VIR_DOMAIN_DISK_PROTOCOL_GLUSTER;
+ disk->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ disk->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_GLUSTER;
} else if (STRPREFIX(val, "sheepdog:")) {
- disk->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
- disk->protocol = VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG;
+ disk->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ disk->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG;
val += strlen("sheepdog:");
} else
- disk->type = VIR_DOMAIN_DISK_TYPE_FILE;
+ disk->src.type = VIR_DOMAIN_DISK_TYPE_FILE;
if (STREQ(arg, "-cdrom")) {
disk->device = VIR_DOMAIN_DISK_DEVICE_CDROM;
if (((def->os.arch == VIR_ARCH_PPC64) &&
@@ -11539,13 +11542,13 @@ qemuParseCommandLine(virCapsPtr qemuCaps,
if (VIR_STRDUP(disk->dst, arg + 1) < 0)
goto error;
}
- if (VIR_STRDUP(disk->src, val) < 0)
+ if (VIR_STRDUP(disk->src.path, val) < 0)
goto error;
- if (disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
+ if (disk->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
char *port;
- switch (disk->protocol) {
+ switch (disk->src.protocol) {
case VIR_DOMAIN_DISK_PROTOCOL_NBD:
if (qemuParseNBDString(disk) < 0)
goto error;
@@ -11557,7 +11560,7 @@ qemuParseCommandLine(virCapsPtr qemuCaps,
break;
case VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG:
/* disk->src must be [vdiname] or [host]:[port]:[vdiname] */
- port = strchr(disk->src, ':');
+ port = strchr(disk->src.path, ':');
if (port) {
char *vdi;
@@ -11569,13 +11572,13 @@ qemuParseCommandLine(virCapsPtr qemuCaps,
goto error;
}
*vdi++ = '\0';
- if (VIR_ALLOC(disk->hosts) < 0)
+ if (VIR_ALLOC(disk->src.hosts) < 0)
goto error;
- disk->nhosts = 1;
- disk->hosts->name = disk->src;
- if (VIR_STRDUP(disk->hosts->port, port) < 0)
+ disk->src.nhosts = 1;
+ disk->src.hosts->name = disk->src.path;
+ if (VIR_STRDUP(disk->src.hosts->port, port) < 0)
goto error;
- if (VIR_STRDUP(disk->src, vdi) < 0)
+ if (VIR_STRDUP(disk->src.path, vdi) < 0)
goto error;
}
break;
@@ -11786,12 +11789,12 @@ qemuParseCommandLine(virCapsPtr qemuCaps,
} else if (STRPREFIX(val, "disk:")) {
if (VIR_ALLOC(disk) < 0)
goto error;
- if (VIR_STRDUP(disk->src, val + strlen("disk:")) < 0)
+ if (VIR_STRDUP(disk->src.path, val + strlen("disk:")) <
0)
goto error;
- if (STRPREFIX(disk->src, "/dev/"))
- disk->type = VIR_DOMAIN_DISK_TYPE_BLOCK;
+ if (STRPREFIX(disk->src.path, "/dev/"))
+ disk->src.type = VIR_DOMAIN_DISK_TYPE_BLOCK;
else
- disk->type = VIR_DOMAIN_DISK_TYPE_FILE;
+ disk->src.type = VIR_DOMAIN_DISK_TYPE_FILE;
disk->device = VIR_DOMAIN_DISK_DEVICE_DISK;
disk->bus = VIR_DOMAIN_DISK_BUS_USB;
disk->removable = VIR_DOMAIN_FEATURE_STATE_DEFAULT;
@@ -12022,8 +12025,8 @@ qemuParseCommandLine(virCapsPtr qemuCaps,
char *hosts, *port, *saveptr = NULL, *token;
virDomainDiskDefPtr first_rbd_disk = NULL;
for (i = 0; i < def->ndisks; i++) {
- if (def->disks[i]->type == VIR_DOMAIN_DISK_TYPE_NETWORK &&
- def->disks[i]->protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD) {
+ if (def->disks[i]->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK &&
+ def->disks[i]->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD) {
first_rbd_disk = def->disks[i];
break;
}
@@ -12043,10 +12046,11 @@ qemuParseCommandLine(virCapsPtr qemuCaps,
}
if (VIR_STRDUP(hosts, strchr(ceph_args, ' ') + 1) < 0)
goto error;
- first_rbd_disk->nhosts = 0;
+ first_rbd_disk->src.nhosts = 0;
token = strtok_r(hosts, ",", &saveptr);
while (token != NULL) {
- if (VIR_REALLOC_N(first_rbd_disk->hosts, first_rbd_disk->nhosts + 1)
< 0) {
+ if (VIR_REALLOC_N(first_rbd_disk->src.hosts,
+ first_rbd_disk->src.nhosts + 1) < 0) {
VIR_FREE(hosts);
goto error;
}
@@ -12058,21 +12062,21 @@ qemuParseCommandLine(virCapsPtr qemuCaps,
goto error;
}
}
- first_rbd_disk->hosts[first_rbd_disk->nhosts].port = port;
- if (VIR_STRDUP(first_rbd_disk->hosts[first_rbd_disk->nhosts].name,
+ first_rbd_disk->src.hosts[first_rbd_disk->src.nhosts].port = port;
+ if
(VIR_STRDUP(first_rbd_disk->src.hosts[first_rbd_disk->src.nhosts].name,
token) < 0) {
VIR_FREE(hosts);
goto error;
}
- first_rbd_disk->hosts[first_rbd_disk->nhosts].transport =
VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
- first_rbd_disk->hosts[first_rbd_disk->nhosts].socket = NULL;
+ first_rbd_disk->src.hosts[first_rbd_disk->src.nhosts].transport =
VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
+ first_rbd_disk->src.hosts[first_rbd_disk->src.nhosts].socket = NULL;
- first_rbd_disk->nhosts++;
+ first_rbd_disk->src.nhosts++;
token = strtok_r(NULL, ",", &saveptr);
}
VIR_FREE(hosts);
- if (first_rbd_disk->nhosts == 0) {
+ if (first_rbd_disk->src.nhosts == 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("found no rbd hosts in CEPH_ARGS '%s'"),
ceph_args);
goto error;
diff --git a/src/qemu/qemu_conf.c b/src/qemu/qemu_conf.c
index d280c2c..0d6bcfe 100644
--- a/src/qemu/qemu_conf.c
+++ b/src/qemu/qemu_conf.c
@@ -797,8 +797,8 @@ qemuCheckSharedDevice(virHashTablePtr sharedDevices,
virReportError(VIR_ERR_OPERATION_INVALID,
_("sgio of shared disk 'pool=%s' 'volume=%s'
conflicts "
"with other active domains"),
- disk->srcpool->pool,
- disk->srcpool->volume);
+ disk->src.srcpool->pool,
+ disk->src.srcpool->volume);
} else {
virReportError(VIR_ERR_OPERATION_INVALID,
_("sgio of shared disk '%s' conflicts with other
"
@@ -1158,33 +1158,33 @@ qemuAddISCSIPoolSourceHost(virDomainDiskDefPtr def,
}
/* iscsi pool only supports one host */
- def->nhosts = 1;
+ def->src.nhosts = 1;
- if (VIR_ALLOC_N(def->hosts, def->nhosts) < 0)
+ if (VIR_ALLOC_N(def->src.hosts, def->src.nhosts) < 0)
goto cleanup;
- if (VIR_STRDUP(def->hosts[0].name, pooldef->source.hosts[0].name) < 0)
+ if (VIR_STRDUP(def->src.hosts[0].name, pooldef->source.hosts[0].name) < 0)
goto cleanup;
- if (virAsprintf(&def->hosts[0].port, "%d",
+ if (virAsprintf(&def->src.hosts[0].port, "%d",
pooldef->source.hosts[0].port ?
pooldef->source.hosts[0].port :
3260) < 0)
goto cleanup;
/* iscsi volume has name like "unit:0:0:1" */
- if (!(tokens = virStringSplit(def->srcpool->volume, ":", 0)))
+ if (!(tokens = virStringSplit(def->src.srcpool->volume, ":", 0)))
goto cleanup;
if (virStringListLength(tokens) != 4) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unexpected iscsi volume name '%s'"),
- def->srcpool->volume);
+ def->src.srcpool->volume);
goto cleanup;
}
/* iscsi pool has only one source device path */
- if (virAsprintf(&def->src, "%s/%s",
+ if (virAsprintf(&def->src.path, "%s/%s",
pooldef->source.devices[0].path,
tokens[3]) < 0)
goto cleanup;
@@ -1192,10 +1192,10 @@ qemuAddISCSIPoolSourceHost(virDomainDiskDefPtr def,
/* Storage pool have not supported these 2 attributes yet,
* use the defaults.
*/
- def->hosts[0].transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
- def->hosts[0].socket = NULL;
+ def->src.hosts[0].transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
+ def->src.hosts[0].socket = NULL;
- def->protocol = VIR_DOMAIN_DISK_PROTOCOL_ISCSI;
+ def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_ISCSI;
ret = 0;
@@ -1220,34 +1220,34 @@ qemuTranslateDiskSourcePoolAuth(virDomainDiskDefPtr def,
* into the virDomainDiskDef
*/
if (pooldef->source.authType == VIR_STORAGE_POOL_AUTH_CHAP) {
- if (VIR_STRDUP(def->auth.username,
+ if (VIR_STRDUP(def->src.auth.username,
pooldef->source.auth.chap.username) < 0)
goto cleanup;
if (pooldef->source.auth.chap.secret.uuidUsable) {
- def->auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_UUID;
- memcpy(def->auth.secret.uuid,
+ def->src.auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_UUID;
+ memcpy(def->src.auth.secret.uuid,
pooldef->source.auth.chap.secret.uuid,
VIR_UUID_BUFLEN);
} else {
- if (VIR_STRDUP(def->auth.secret.usage,
+ if (VIR_STRDUP(def->src.auth.secret.usage,
pooldef->source.auth.chap.secret.usage) < 0)
goto cleanup;
- def->auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_USAGE;
+ def->src.auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_USAGE;
}
} else if (pooldef->source.authType == VIR_STORAGE_POOL_AUTH_CEPHX) {
- if (VIR_STRDUP(def->auth.username,
+ if (VIR_STRDUP(def->src.auth.username,
pooldef->source.auth.cephx.username) < 0)
goto cleanup;
if (pooldef->source.auth.cephx.secret.uuidUsable) {
- def->auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_UUID;
- memcpy(def->auth.secret.uuid,
+ def->src.auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_UUID;
+ memcpy(def->src.auth.secret.uuid,
pooldef->source.auth.cephx.secret.uuid,
VIR_UUID_BUFLEN);
} else {
- if (VIR_STRDUP(def->auth.secret.usage,
+ if (VIR_STRDUP(def->src.auth.secret.usage,
pooldef->source.auth.cephx.secret.usage) < 0)
goto cleanup;
- def->auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_USAGE;
+ def->src.auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_USAGE;
}
}
ret = 0;
@@ -1269,24 +1269,24 @@ qemuTranslateDiskSourcePool(virConnectPtr conn,
int ret = -1;
virErrorPtr savedError = NULL;
- if (def->type != VIR_DOMAIN_DISK_TYPE_VOLUME)
+ if (def->src.type != VIR_DOMAIN_DISK_TYPE_VOLUME)
return 0;
- if (!def->srcpool)
+ if (!def->src.srcpool)
return 0;
- if (!(pool = virStoragePoolLookupByName(conn, def->srcpool->pool)))
+ if (!(pool = virStoragePoolLookupByName(conn, def->src.srcpool->pool)))
return -1;
if (virStoragePoolIsActive(pool) != 1) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("storage pool '%s' containing volume '%s'
"
"is not active"),
- def->srcpool->pool, def->srcpool->volume);
+ def->src.srcpool->pool, def->src.srcpool->volume);
goto cleanup;
}
- if (!(vol = virStorageVolLookupByName(pool, def->srcpool->volume)))
+ if (!(vol = virStorageVolLookupByName(pool, def->src.srcpool->volume)))
goto cleanup;
if (virStorageVolGetInfo(vol, &info) < 0)
@@ -1298,19 +1298,19 @@ qemuTranslateDiskSourcePool(virConnectPtr conn,
if (!(pooldef = virStoragePoolDefParseString(poolxml)))
goto cleanup;
- def->srcpool->pooltype = pooldef->type;
- def->srcpool->voltype = info.type;
+ def->src.srcpool->pooltype = pooldef->type;
+ def->src.srcpool->voltype = info.type;
- if (def->srcpool->mode && pooldef->type != VIR_STORAGE_POOL_ISCSI)
{
+ if (def->src.srcpool->mode && pooldef->type !=
VIR_STORAGE_POOL_ISCSI) {
virReportError(VIR_ERR_XML_ERROR, "%s",
_("disk source mode is only valid when "
"storage pool is of iscsi type"));
goto cleanup;
}
- VIR_FREE(def->src);
- virDomainDiskHostDefFree(def->nhosts, def->hosts);
- virDomainDiskAuthClear(def);
+ VIR_FREE(def->src.path);
+ virDomainDiskHostDefFree(def->src.nhosts, def->src.hosts);
+ virDomainDiskAuthClear(&def->src);
switch ((enum virStoragePoolType) pooldef->type) {
case VIR_STORAGE_POOL_DIR:
@@ -1319,7 +1319,7 @@ qemuTranslateDiskSourcePool(virConnectPtr conn,
case VIR_STORAGE_POOL_LOGICAL:
case VIR_STORAGE_POOL_DISK:
case VIR_STORAGE_POOL_SCSI:
- if (!(def->src = virStorageVolGetPath(vol)))
+ if (!(def->src.path = virStorageVolGetPath(vol)))
goto cleanup;
if (def->startupPolicy && info.type != VIR_STORAGE_VOL_FILE) {
@@ -1332,15 +1332,15 @@ qemuTranslateDiskSourcePool(virConnectPtr conn,
switch (info.type) {
case VIR_STORAGE_VOL_FILE:
- def->srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_FILE;
+ def->src.srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_FILE;
break;
case VIR_STORAGE_VOL_DIR:
- def->srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_DIR;
+ def->src.srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_DIR;
break;
case VIR_STORAGE_VOL_BLOCK:
- def->srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_BLOCK;
+ def->src.srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_BLOCK;
break;
case VIR_STORAGE_VOL_NETWORK:
@@ -1363,20 +1363,20 @@ qemuTranslateDiskSourcePool(virConnectPtr conn,
goto cleanup;
}
- switch (def->srcpool->mode) {
+ switch (def->src.srcpool->mode) {
case VIR_DOMAIN_DISK_SOURCE_POOL_MODE_DEFAULT:
case VIR_DOMAIN_DISK_SOURCE_POOL_MODE_LAST:
- def->srcpool->mode = VIR_DOMAIN_DISK_SOURCE_POOL_MODE_HOST;
+ def->src.srcpool->mode = VIR_DOMAIN_DISK_SOURCE_POOL_MODE_HOST;
/* fallthrough */
case VIR_DOMAIN_DISK_SOURCE_POOL_MODE_HOST:
- def->srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_BLOCK;
- if (!(def->src = virStorageVolGetPath(vol)))
+ def->src.srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_BLOCK;
+ if (!(def->src.path = virStorageVolGetPath(vol)))
goto cleanup;
break;
case VIR_DOMAIN_DISK_SOURCE_POOL_MODE_DIRECT:
- def->srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_NETWORK;
- def->protocol = VIR_DOMAIN_DISK_PROTOCOL_ISCSI;
+ def->src.srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_ISCSI;
if (qemuTranslateDiskSourcePoolAuth(def, pooldef) < 0)
goto cleanup;
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 3b82c5a..49b60fa 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -6813,18 +6813,18 @@ qemuDomainUpdateDeviceConfig(virQEMUCapsPtr qemuCaps,
* Update 'orig'
* We allow updating src/type//driverType/cachemode/
*/
- VIR_FREE(orig->src);
- orig->src = disk->src;
- orig->type = disk->type;
+ VIR_FREE(orig->src.path);
+ orig->src.path = disk->src.path;
+ orig->src.type = disk->src.type;
orig->cachemode = disk->cachemode;
- if (disk->driverName) {
- VIR_FREE(orig->driverName);
- orig->driverName = disk->driverName;
- disk->driverName = NULL;
+ if (disk->src.driverName) {
+ VIR_FREE(orig->src.driverName);
+ orig->src.driverName = disk->src.driverName;
+ disk->src.driverName = NULL;
}
- if (disk->format)
- orig->format = disk->format;
- disk->src = NULL;
+ if (disk->src.format)
+ orig->src.format = disk->src.format;
+ disk->src.path = NULL;
break;
case VIR_DOMAIN_DEVICE_NET:
@@ -11965,26 +11965,27 @@ qemuDomainPrepareDiskChainElement(virQEMUDriverPtr driver,
/* The easiest way to label a single file with the same
* permissions it would have as if part of the disk chain is to
* temporarily modify the disk in place. */
- char *origsrc = disk->src;
- int origformat = disk->format;
+ char *origsrc = disk->src.path;
+ int origformat = disk->src.format;
virStorageFileMetadataPtr origchain = disk->backingChain;
bool origreadonly = disk->readonly;
int ret = -1;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- disk->src = (char *) file; /* casting away const is safe here */
- disk->format = VIR_STORAGE_FILE_RAW;
+ disk->src.path = (char *) file; /* casting away const is safe here */
+ disk->src.format = VIR_STORAGE_FILE_RAW;
disk->backingChain = NULL;
disk->readonly = mode == VIR_DISK_CHAIN_READ_ONLY;
if (mode == VIR_DISK_CHAIN_NO_ACCESS) {
if (virSecurityManagerRestoreImageLabel(driver->securityManager,
vm->def, disk) < 0)
- VIR_WARN("Unable to restore security label on %s", disk->src);
+ VIR_WARN("Unable to restore security label on %s",
disk->src.path);
if (qemuTeardownDiskCgroup(vm, disk) < 0)
- VIR_WARN("Failed to teardown cgroup for disk path %s",
disk->src);
+ VIR_WARN("Failed to teardown cgroup for disk path %s",
+ disk->src.path);
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
- VIR_WARN("Unable to release lock on %s", disk->src);
+ VIR_WARN("Unable to release lock on %s", disk->src.path);
} else if (virDomainLockDiskAttach(driver->lockManager, cfg->uri,
vm, disk) < 0 ||
qemuSetupDiskCgroup(vm, disk) < 0 ||
@@ -11996,8 +11997,8 @@ qemuDomainPrepareDiskChainElement(virQEMUDriverPtr driver,
ret = 0;
cleanup:
- disk->src = origsrc;
- disk->format = origformat;
+ disk->src.path = origsrc;
+ disk->src.format = origformat;
disk->backingChain = origchain;
disk->readonly = origreadonly;
virObjectUnref(cfg);
@@ -12094,22 +12095,22 @@ qemuDomainSnapshotCreateInactiveExternal(virQEMUDriverPtr
driver,
NULL)))
goto cleanup;
- if (defdisk->format > 0) {
+ if (defdisk->src.format > 0) {
/* adds cmd line arg: backing_file=/path/to/backing/file,backing_fmd=format
*/
virCommandAddArgFormat(cmd, "backing_file=%s,backing_fmt=%s",
- defdisk->src,
-
virStorageFileFormatTypeToString(defdisk->format));
+ defdisk->src.path,
+
virStorageFileFormatTypeToString(defdisk->src.format));
} else {
if (!cfg->allowDiskFormatProbing) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unknown image format of '%s' and "
"format probing is disabled"),
- defdisk->src);
+ defdisk->src.path);
goto cleanup;
}
/* adds cmd line arg: backing_file=/path/to/backing/file */
- virCommandAddArgFormat(cmd, "backing_file=%s", defdisk->src);
+ virCommandAddArgFormat(cmd, "backing_file=%s",
defdisk->src.path);
}
/* adds cmd line args: /path/to/target/file */
@@ -12132,12 +12133,12 @@ qemuDomainSnapshotCreateInactiveExternal(virQEMUDriverPtr
driver,
defdisk = vm->def->disks[snapdisk->index];
if (snapdisk->snapshot == VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL) {
- VIR_FREE(defdisk->src);
- if (VIR_STRDUP(defdisk->src, snapdisk->file) < 0) {
+ VIR_FREE(defdisk->src.path);
+ if (VIR_STRDUP(defdisk->src.path, snapdisk->file) < 0) {
/* we cannot rollback here in a sane way */
goto cleanup;
}
- defdisk->format = snapdisk->format;
+ defdisk->src.format = snapdisk->format;
}
}
@@ -12260,7 +12261,7 @@
qemuDomainSnapshotPrepareDiskExternalBackingInactive(virDomainDiskDefPtr disk)
return 0;
case VIR_DOMAIN_DISK_TYPE_NETWORK:
- switch ((enum virDomainDiskProtocol) disk->protocol) {
+ switch ((enum virDomainDiskProtocol) disk->src.protocol) {
case VIR_DOMAIN_DISK_PROTOCOL_NBD:
case VIR_DOMAIN_DISK_PROTOCOL_RBD:
case VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG:
@@ -12275,7 +12276,7 @@
qemuDomainSnapshotPrepareDiskExternalBackingInactive(virDomainDiskDefPtr disk)
virReportError(VIR_ERR_INTERNAL_ERROR,
_("external inactive snapshots are not supported on
"
"'network' disks using '%s'
protocol"),
- virDomainDiskProtocolTypeToString(disk->protocol));
+ virDomainDiskProtocolTypeToString(disk->src.protocol));
return -1;
}
break;
@@ -12465,7 +12466,7 @@ qemuDomainSnapshotPrepareDiskInternal(virConnectPtr conn,
return 0;
case VIR_DOMAIN_DISK_TYPE_NETWORK:
- switch ((enum virDomainDiskProtocol) disk->protocol) {
+ switch ((enum virDomainDiskProtocol) disk->src.protocol) {
case VIR_DOMAIN_DISK_PROTOCOL_NBD:
case VIR_DOMAIN_DISK_PROTOCOL_RBD:
case VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG:
@@ -12480,7 +12481,7 @@ qemuDomainSnapshotPrepareDiskInternal(virConnectPtr conn,
virReportError(VIR_ERR_INTERNAL_ERROR,
_("internal inactive snapshots are not supported on
"
"'network' disks using '%s'
protocol"),
- virDomainDiskProtocolTypeToString(disk->protocol));
+ virDomainDiskProtocolTypeToString(disk->src.protocol));
return -1;
}
break;
@@ -12540,19 +12541,19 @@ qemuDomainSnapshotPrepare(virConnectPtr conn,
active) < 0)
goto cleanup;
- if (dom_disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK &&
- (dom_disk->protocol == VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG ||
- dom_disk->protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD)) {
+ if (dom_disk->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK &&
+ (dom_disk->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG ||
+ dom_disk->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD)) {
break;
}
- if (vm->def->disks[i]->format > 0 &&
- vm->def->disks[i]->format != VIR_STORAGE_FILE_QCOW2) {
+ if (vm->def->disks[i]->src.format > 0 &&
+ vm->def->disks[i]->src.format != VIR_STORAGE_FILE_QCOW2) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("internal snapshot for disk %s unsupported "
"for storage type %s"),
disk->name,
virStorageFileFormatTypeToString(
- vm->def->disks[i]->format));
+ vm->def->disks[i]->src.format));
goto cleanup;
}
break;
@@ -12766,36 +12767,37 @@ qemuDomainSnapshotCreateSingleDiskActive(virQEMUDriverPtr
driver,
}
}
- virDomainAuditDisk(vm, disk->src, source, "snapshot", ret >= 0);
+ virDomainAuditDisk(vm, disk->src.path, source, "snapshot", ret >=
0);
if (ret < 0)
goto cleanup;
/* Update vm in place to match changes. */
need_unlink = false;
- VIR_FREE(disk->src);
- virDomainDiskHostDefFree(disk->nhosts, disk->hosts);
+ VIR_FREE(disk->src.path);
+ virDomainDiskHostDefFree(disk->src.nhosts, disk->src.hosts);
- disk->src = newsource;
- disk->format = format;
- disk->type = snap->type;
- disk->protocol = snap->protocol;
- disk->nhosts = snap->nhosts;
- disk->hosts = newhosts;
+ disk->src.path = newsource;
+ disk->src.format = format;
+ disk->src.type = snap->type;
+ disk->src.protocol = snap->protocol;
+ disk->src.nhosts = snap->nhosts;
+ disk->src.hosts = newhosts;
newsource = NULL;
newhosts = NULL;
if (persistDisk) {
- VIR_FREE(persistDisk->src);
- virDomainDiskHostDefFree(persistDisk->nhosts, persistDisk->hosts);
+ VIR_FREE(persistDisk->src.path);
+ virDomainDiskHostDefFree(persistDisk->src.nhosts,
+ persistDisk->src.hosts);
- persistDisk->src = persistSource;
- persistDisk->format = format;
- persistDisk->type = snap->type;
- persistDisk->protocol = snap->protocol;
- persistDisk->nhosts = snap->nhosts;
- persistDisk->hosts = persistHosts;
+ persistDisk->src.path = persistSource;
+ persistDisk->src.format = format;
+ persistDisk->src.type = snap->type;
+ persistDisk->src.protocol = snap->protocol;
+ persistDisk->src.nhosts = snap->nhosts;
+ persistDisk->src.hosts = persistHosts;
persistSource = NULL;
persistHosts = NULL;
@@ -12832,37 +12834,40 @@ qemuDomainSnapshotUndoSingleDiskActive(virQEMUDriverPtr driver,
diskfile = virStorageFileInitFromDiskDef(disk);
- if (VIR_STRDUP(source, origdisk->src) < 0 ||
+ if (VIR_STRDUP(source, origdisk->src.path) < 0 ||
(persistDisk && VIR_STRDUP(persistSource, source) < 0))
goto cleanup;
- qemuDomainPrepareDiskChainElement(driver, vm, disk, disk->src,
+ qemuDomainPrepareDiskChainElement(driver, vm, disk, disk->src.path,
VIR_DISK_CHAIN_NO_ACCESS);
if (need_unlink && diskfile &&
virStorageFileStat(diskfile, &st) == 0 && S_ISREG(st.st_mode)
&&
virStorageFileUnlink(diskfile) < 0)
- VIR_WARN("Unable to remove just-created %s", disk->src);
+ VIR_WARN("Unable to remove just-created %s", disk->src.path);
/* Update vm in place to match changes. */
- VIR_FREE(disk->src);
- disk->src = source;
+ VIR_FREE(disk->src.path);
+ disk->src.path = source;
source = NULL;
- disk->format = origdisk->format;
- disk->type = origdisk->type;
- disk->protocol = origdisk->protocol;
- virDomainDiskHostDefFree(disk->nhosts, disk->hosts);
- disk->nhosts = origdisk->nhosts;
- disk->hosts = virDomainDiskHostDefCopy(origdisk->nhosts, origdisk->hosts);
+ disk->src.format = origdisk->src.format;
+ disk->src.type = origdisk->src.type;
+ disk->src.protocol = origdisk->src.protocol;
+ virDomainDiskHostDefFree(disk->src.nhosts, disk->src.hosts);
+ disk->src.nhosts = origdisk->src.nhosts;
+ disk->src.hosts = virDomainDiskHostDefCopy(origdisk->src.nhosts,
+ origdisk->src.hosts);
if (persistDisk) {
- VIR_FREE(persistDisk->src);
- persistDisk->src = persistSource;
+ VIR_FREE(persistDisk->src.path);
+ persistDisk->src.path = persistSource;
persistSource = NULL;
- persistDisk->format = origdisk->format;
- persistDisk->type = origdisk->type;
- persistDisk->protocol = origdisk->protocol;
- virDomainDiskHostDefFree(persistDisk->nhosts, persistDisk->hosts);
- persistDisk->nhosts = origdisk->nhosts;
- persistDisk->hosts = virDomainDiskHostDefCopy(origdisk->nhosts,
origdisk->hosts);
+ persistDisk->src.format = origdisk->src.format;
+ persistDisk->src.type = origdisk->src.type;
+ persistDisk->src.protocol = origdisk->src.protocol;
+ virDomainDiskHostDefFree(persistDisk->src.nhosts,
+ persistDisk->src.hosts);
+ persistDisk->src.nhosts = origdisk->src.nhosts;
+ persistDisk->src.hosts = virDomainDiskHostDefCopy(origdisk->src.nhosts,
+ origdisk->src.hosts);
}
cleanup:
@@ -14705,15 +14710,15 @@ qemuDomainBlockPivot(virConnectPtr conn,
* label the entire chain. This action is safe even if the
* backing chain has already been labeled; but only necessary when
* we know for sure that there is a backing chain. */
- oldsrc = disk->src;
- oldformat = disk->format;
+ oldsrc = disk->src.path;
+ oldformat = disk->src.format;
oldchain = disk->backingChain;
- disk->src = disk->mirror;
- disk->format = disk->mirrorFormat;
+ disk->src.path = disk->mirror;
+ disk->src.format = disk->mirrorFormat;
disk->backingChain = NULL;
if (qemuDomainDetermineDiskChain(driver, vm, disk, false) < 0) {
- disk->src = oldsrc;
- disk->format = oldformat;
+ disk->src.path = oldsrc;
+ disk->src.format = oldformat;
disk->backingChain = oldchain;
goto cleanup;
}
@@ -14723,8 +14728,8 @@ qemuDomainBlockPivot(virConnectPtr conn,
qemuSetupDiskCgroup(vm, disk) < 0 ||
virSecurityManagerSetImageLabel(driver->securityManager, vm->def,
disk) < 0)) {
- disk->src = oldsrc;
- disk->format = oldformat;
+ disk->src.path = oldsrc;
+ disk->src.format = oldformat;
disk->backingChain = oldchain;
goto cleanup;
}
@@ -14754,8 +14759,8 @@ qemuDomainBlockPivot(virConnectPtr conn,
* 'query-block', to see what state we really got left in
* before killing the mirroring job? And just as on the
* success case, there's security labeling to worry about. */
- disk->src = oldsrc;
- disk->format = oldformat;
+ disk->src.path = oldsrc;
+ disk->src.format = oldformat;
virStorageFileFreeMetadata(disk->backingChain);
disk->backingChain = oldchain;
VIR_FREE(disk->mirror);
@@ -14894,7 +14899,7 @@ qemuDomainBlockJobImpl(virDomainObjPtr vm,
if (!async) {
int type = VIR_DOMAIN_BLOCK_JOB_TYPE_PULL;
int status = VIR_DOMAIN_BLOCK_JOB_CANCELED;
- event = virDomainEventBlockJobNewFromObj(vm, disk->src, type,
+ event = virDomainEventBlockJobNewFromObj(vm, disk->src.path, type,
status);
} else if (!(flags & VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC)) {
while (1) {
@@ -15103,7 +15108,7 @@ qemuDomainBlockCopy(virDomainObjPtr vm,
goto endjob;
VIR_FORCE_CLOSE(fd);
if (!format)
- disk->mirrorFormat = disk->format;
+ disk->mirrorFormat = disk->src.format;
} else if (format) {
disk->mirrorFormat = virStorageFileFormatTypeFromString(format);
if (disk->mirrorFormat <= 0) {
@@ -15263,7 +15268,7 @@ qemuDomainBlockCommit(virDomainPtr dom, const char *path, const
char *base,
goto endjob;
disk = vm->def->disks[idx];
- if (!disk->src) {
+ if (!disk->src.path) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("disk %s has no source file to be committed"),
disk->dst);
@@ -15273,10 +15278,10 @@ qemuDomainBlockCommit(virDomainPtr dom, const char *path, const
char *base,
goto endjob;
if (!top) {
- top_canon = disk->src;
+ top_canon = disk->src.path;
top_meta = disk->backingChain;
} else if (!(top_canon = virStorageFileChainLookup(disk->backingChain,
- disk->src,
+ disk->src.path,
top, &top_meta,
&top_parent))) {
virReportError(VIR_ERR_INVALID_ARG,
@@ -15322,7 +15327,7 @@ qemuDomainBlockCommit(virDomainPtr dom, const char *path, const
char *base,
clean_access = true;
if (qemuDomainPrepareDiskChainElement(driver, vm, disk, base_canon,
VIR_DISK_CHAIN_READ_WRITE) < 0 ||
- (top_parent && top_parent != disk->src &&
+ (top_parent && top_parent != disk->src.path &&
qemuDomainPrepareDiskChainElement(driver, vm, disk,
top_parent,
VIR_DISK_CHAIN_READ_WRITE) < 0))
@@ -15344,7 +15349,7 @@ endjob:
/* Revert access to read-only, if possible. */
qemuDomainPrepareDiskChainElement(driver, vm, disk, base_canon,
VIR_DISK_CHAIN_READ_ONLY);
- if (top_parent && top_parent != disk->src)
+ if (top_parent && top_parent != disk->src.path)
qemuDomainPrepareDiskChainElement(driver, vm, disk,
top_parent,
VIR_DISK_CHAIN_READ_ONLY);
diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c
index 0a243c8..2b06150 100644
--- a/src/qemu/qemu_migration.c
+++ b/src/qemu/qemu_migration.c
@@ -1542,8 +1542,8 @@ qemuMigrationIsSafe(virDomainDefPtr def)
return false;
else if (rc == 1)
continue;
- } else if (disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK &&
- disk->protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD) {
+ } else if (disk->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK &&
+ disk->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD) {
continue;
}
diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c
index 978e7b4..6e214b9 100644
--- a/src/qemu/qemu_process.c
+++ b/src/qemu/qemu_process.c
@@ -421,13 +421,13 @@ qemuProcessGetVolumeQcowPassphrase(virConnectPtr conn,
int ret = -1;
virStorageEncryptionPtr enc;
- if (!disk->encryption) {
+ if (!disk->src.encryption) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("disk %s does not have any encryption information"),
- disk->src);
+ disk->src.path);
return -1;
}
- enc = disk->encryption;
+ enc = disk->src.encryption;
if (!conn) {
virReportError(VIR_ERR_INTERNAL_ERROR,
@@ -2193,7 +2193,7 @@ qemuProcessInitPasswords(virConnectPtr conn,
size_t secretLen;
const char *alias;
- if (!vm->def->disks[i]->encryption ||
+ if (!vm->def->disks[i]->src.encryption ||
!virDomainDiskGetSource(vm->def->disks[i]))
continue;
diff --git a/src/security/security_selinux.c b/src/security/security_selinux.c
index 32f6c7d..434abfe 100644
--- a/src/security/security_selinux.c
+++ b/src/security/security_selinux.c
@@ -1237,7 +1237,7 @@ virSecuritySELinuxSetSecurityFileLabel(virDomainDiskDefPtr disk,
if (!disk_seclabel)
return -1;
disk_seclabel->labelskip = true;
- if (VIR_APPEND_ELEMENT(disk->seclabels, disk->nseclabels,
+ if (VIR_APPEND_ELEMENT(disk->src.seclabels, disk->src.nseclabels,
disk_seclabel) < 0) {
virSecurityDeviceLabelDefFree(disk_seclabel);
return -1;
diff --git a/src/storage/storage_driver.c b/src/storage/storage_driver.c
index 6a2840c..d6edf60 100644
--- a/src/storage/storage_driver.c
+++ b/src/storage/storage_driver.c
@@ -2765,10 +2765,10 @@ virStorageFilePtr
virStorageFileInitFromDiskDef(virDomainDiskDefPtr disk)
{
return virStorageFileInitInternal(virDomainDiskGetActualType(disk),
- disk->src,
- disk->protocol,
- disk->nhosts,
- disk->hosts);
+ disk->src.path,
+ disk->src.protocol,
+ disk->src.nhosts,
+ disk->src.hosts);
}
diff --git a/tests/securityselinuxlabeltest.c b/tests/securityselinuxlabeltest.c
index d52f9f9..e6a0c29 100644
--- a/tests/securityselinuxlabeltest.c
+++ b/tests/securityselinuxlabeltest.c
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2011-2013 Red Hat, Inc.
+ * Copyright (C) 2011-2014 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -169,11 +169,11 @@ testSELinuxLoadDef(const char *testname)
goto cleanup;
for (i = 0; i < def->ndisks; i++) {
- if (def->disks[i]->type != VIR_DOMAIN_DISK_TYPE_FILE &&
- def->disks[i]->type != VIR_DOMAIN_DISK_TYPE_BLOCK)
+ if (def->disks[i]->src.type != VIR_DOMAIN_DISK_TYPE_FILE &&
+ def->disks[i]->src.type != VIR_DOMAIN_DISK_TYPE_BLOCK)
continue;
- if (testSELinuxMungePath(&def->disks[i]->src) < 0)
+ if (testSELinuxMungePath(&def->disks[i]->src.path) < 0)
goto cleanup;
}
--
1.8.5.3