External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-03-20 07:59:00 +00:00
Code

conf: prepare to track multiple host source files per <disk>

Browse Source 
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@redhat.com>
This commit is contained in:
Eric Blake 2014-03-19 11:11:16 -06:00
parent 41a32b0a9b
commit 4f20226664
12 changed files with 441 additions and 408 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

187
src/conf/domain_conf.c
View File

@ -1248,25 +1248,19 @@ virDomainDiskSourcePoolDefFree(virDomainDiskSourcePoolDefPtr def)
VIR_FREE(def); VIR_FREE(def);
} }
void virDomainDiskDefFree(virDomainDiskDefPtr def)
static void
virDomainDiskSourceDefClear(virDomainDiskSourceDefPtr def)
{ {
size_t i; size_t i;
if (!def) if (!def)
return; return;
VIR_FREE(def->serial); VIR_FREE(def->path);
VIR_FREE(def->src);
virDomainDiskSourcePoolDefFree(def->srcpool); virDomainDiskSourcePoolDefFree(def->srcpool);
VIR_FREE(def->dst);
VIR_FREE(def->driverName); 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); virStorageEncryptionFree(def->encryption);
virDomainDeviceInfoClear(&def->info);
if (def->seclabels) { if (def->seclabels) {
for (i = 0; i < def->nseclabels; i++) for (i = 0; i < def->nseclabels; i++)
@ -1276,13 +1270,31 @@ void virDomainDiskDefFree(virDomainDiskDefPtr def)
virDomainDiskHostDefFree(def->nhosts, def->hosts); virDomainDiskHostDefFree(def->nhosts, def->hosts);
virDomainDiskAuthClear(def); 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); VIR_FREE(def);
} }
void void
virDomainDiskAuthClear(virDomainDiskDefPtr def) virDomainDiskAuthClear(virDomainDiskSourceDefPtr def)
{ {
VIR_FREE(def->auth.username); VIR_FREE(def->auth.username);
@ -1357,31 +1369,31 @@ error:
int int
virDomainDiskGetType(virDomainDiskDefPtr def) virDomainDiskGetType(virDomainDiskDefPtr def)
{ {
return def->type; return def->src.type;
} }
void void
virDomainDiskSetType(virDomainDiskDefPtr def, int type) virDomainDiskSetType(virDomainDiskDefPtr def, int type)
{ {
def->type = type; def->src.type = type;
} }
int int
virDomainDiskGetActualType(virDomainDiskDefPtr def) virDomainDiskGetActualType(virDomainDiskDefPtr def)
{ {
if (def->type == VIR_DOMAIN_DISK_TYPE_VOLUME && def->srcpool) if (def->src.type == VIR_DOMAIN_DISK_TYPE_VOLUME && def->src.srcpool)
return def->srcpool->actualtype; return def->src.srcpool->actualtype;
return def->type; return def->src.type;
} }
const char * const char *
virDomainDiskGetSource(virDomainDiskDefPtr def) virDomainDiskGetSource(virDomainDiskDefPtr def)
{ {
return def->src; return def->src.path;
} }
@ -1389,11 +1401,11 @@ int
virDomainDiskSetSource(virDomainDiskDefPtr def, const char *src) virDomainDiskSetSource(virDomainDiskDefPtr def, const char *src)
{ {
int ret; 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) if (ret < 0)
def->src = tmp; def->src.path = tmp;
else else
VIR_FREE(tmp); VIR_FREE(tmp);
return ret; return ret;
@ -1403,7 +1415,7 @@ virDomainDiskSetSource(virDomainDiskDefPtr def, const char *src)
const char * const char *
virDomainDiskGetDriver(virDomainDiskDefPtr def) virDomainDiskGetDriver(virDomainDiskDefPtr def)
{ {
return def->driverName; return def->src.driverName;
} }
@ -1411,11 +1423,11 @@ int
virDomainDiskSetDriver(virDomainDiskDefPtr def, const char *name) virDomainDiskSetDriver(virDomainDiskDefPtr def, const char *name)
{ {
int ret; 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) if (ret < 0)
def->driverName = tmp; def->src.driverName = tmp;
else else
VIR_FREE(tmp); VIR_FREE(tmp);
return ret; return ret;
@ -1425,14 +1437,14 @@ virDomainDiskSetDriver(virDomainDiskDefPtr def, const char *name)
int int
virDomainDiskGetFormat(virDomainDiskDefPtr def) virDomainDiskGetFormat(virDomainDiskDefPtr def)
{ {
return def->format; return def->src.format;
} }
void void
virDomainDiskSetFormat(virDomainDiskDefPtr def, int format) virDomainDiskSetFormat(virDomainDiskDefPtr def, int format)
{ {
def->format = format; def->src.format = format;
} }
@ -5309,13 +5321,13 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
type = virXMLPropString(node, "type"); type = virXMLPropString(node, "type");
if (type) { if (type) {
if ((def->type = virDomainDiskTypeFromString(type)) < 0) { if ((def->src.type = virDomainDiskTypeFromString(type)) < 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unknown disk type '%s'"), type); _("unknown disk type '%s'"), type);
goto error; goto error;
} }
} else { } else {
def->type = VIR_DOMAIN_DISK_TYPE_FILE; def->src.type = VIR_DOMAIN_DISK_TYPE_FILE;
} }
snapshot = virXMLPropString(node, "snapshot"); snapshot = virXMLPropString(node, "snapshot");
@ -5326,22 +5338,22 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
cur = node->children; cur = node->children;
while (cur != NULL) { while (cur != NULL) {
if (cur->type == XML_ELEMENT_NODE) { 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")) { xmlStrEqual(cur->name, BAD_CAST "source")) {
sourceNode = cur; sourceNode = cur;
if (virDomainDiskSourceDefParse(cur, def->type, if (virDomainDiskSourceDefParse(cur, def->src.type,
&source, &source,
&def->protocol, &def->src.protocol,
&def->nhosts, &def->src.nhosts,
&def->hosts, &def->src.hosts,
&def->srcpool) < 0) &def->src.srcpool) < 0)
goto error; goto error;
if (def->type == VIR_DOMAIN_DISK_TYPE_NETWORK) { if (def->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
if (def->protocol == VIR_DOMAIN_DISK_PROTOCOL_ISCSI) if (def->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_ISCSI)
expected_secret_usage = VIR_SECRET_USAGE_TYPE_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; expected_secret_usage = VIR_SECRET_USAGE_TYPE_CEPH;
} }
@ -5450,7 +5462,7 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
goto error; goto error;
} }
def->auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_NONE; def->src.auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_NONE;
child = cur->children; child = cur->children;
while (child != NULL) { while (child != NULL) {
if (child->type == XML_ELEMENT_NODE && if (child->type == XML_ELEMENT_NODE &&
@ -5487,17 +5499,17 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
} }
if (authUUID != NULL) { 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, if (virUUIDParse(authUUID,
def->auth.secret.uuid) < 0) { def->src.auth.secret.uuid) < 0) {
virReportError(VIR_ERR_XML_ERROR, virReportError(VIR_ERR_XML_ERROR,
_("malformed uuid %s"), _("malformed uuid %s"),
authUUID); authUUID);
goto error; goto error;
} }
} else if (authUsage != NULL) { } else if (authUsage != NULL) {
def->auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_USAGE; def->src.auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_USAGE;
def->auth.secret.usage = authUsage; def->src.auth.secret.usage = authUsage;
authUsage = NULL; authUsage = NULL;
} }
} }
@ -5642,7 +5654,7 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
/* Only CDROM and Floppy devices are allowed missing source path /* Only CDROM and Floppy devices are allowed missing source path
* to indicate no media present. LUN is for raw access CD-ROMs * to indicate no media present. LUN is for raw access CD-ROMs
* that are not attached to a physical device presently */ * 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_CDROM &&
def->device != VIR_DOMAIN_DISK_DEVICE_LUN && def->device != VIR_DOMAIN_DISK_DEVICE_LUN &&
def->device != VIR_DOMAIN_DISK_DEVICE_FLOPPY) { def->device != VIR_DOMAIN_DISK_DEVICE_FLOPPY) {
@ -5655,8 +5667,8 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
if (sourceNode) { if (sourceNode) {
xmlNodePtr saved_node = ctxt->node; xmlNodePtr saved_node = ctxt->node;
ctxt->node = sourceNode; ctxt->node = sourceNode;
if (virSecurityDeviceLabelDefParseXML(&def->seclabels, if (virSecurityDeviceLabelDefParseXML(&def->src.seclabels,
&def->nseclabels, &def->src.nseclabels,
vmSeclabels, vmSeclabels,
nvmSeclabels, nvmSeclabels,
ctxt, ctxt,
@ -5666,10 +5678,10 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
} }
if (target == NULL) { if (target == NULL) {
if (def->srcpool) { if (def->src.srcpool) {
char *tmp; char *tmp;
if (virAsprintf(&tmp, "pool = '%s', volume = '%s'", 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; goto error;
virReportError(VIR_ERR_NO_TARGET, "%s", tmp); virReportError(VIR_ERR_NO_TARGET, "%s", tmp);
@ -5934,7 +5946,7 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
goto error; goto error;
} }
if (def->type == VIR_DOMAIN_DISK_TYPE_NETWORK) { if (def->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
virReportError(VIR_ERR_XML_ERROR, virReportError(VIR_ERR_XML_ERROR,
_("Setting disk %s is not allowed for " _("Setting disk %s is not allowed for "
"disk of network type"), "disk of network type"),
@ -5953,18 +5965,18 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
def->startupPolicy = val; def->startupPolicy = val;
} }
def->src = source; def->src.path = source;
source = NULL; source = NULL;
def->dst = target; def->dst = target;
target = NULL; target = NULL;
def->auth.username = authUsername; def->src.auth.username = authUsername;
authUsername = NULL; authUsername = NULL;
def->driverName = driverName; def->src.driverName = driverName;
driverName = NULL; driverName = NULL;
def->mirror = mirror; def->mirror = mirror;
mirror = NULL; mirror = NULL;
def->mirroring = mirroring; def->mirroring = mirroring;
def->encryption = encryption; def->src.encryption = encryption;
encryption = NULL; encryption = NULL;
def->serial = serial; def->serial = serial;
serial = NULL; serial = NULL;
@ -5976,8 +5988,8 @@ virDomainDiskDefParseXML(virDomainXMLOptionPtr xmlopt,
product = NULL; product = NULL;
if (driverType) { if (driverType) {
def->format = virStorageFileFormatTypeFromString(driverType); def->src.format = virStorageFileFormatTypeFromString(driverType);
if (def->format <= 0) { if (def->src.format <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unknown driver format value '%s'"), _("unknown driver format value '%s'"),
driverType); driverType);
@ -14950,15 +14962,15 @@ virDomainDiskSourceDefFormat(virBufferPtr buf,
unsigned int flags) unsigned int flags)
{ {
return virDomainDiskSourceDefFormatInternal(buf, return virDomainDiskSourceDefFormatInternal(buf,
def->type, def->src.type,
def->src, def->src.path,
def->startupPolicy, def->startupPolicy,
def->protocol, def->src.protocol,
def->nhosts, def->src.nhosts,
def->hosts, def->src.hosts,
def->nseclabels, def->src.nseclabels,
def->seclabels, def->src.seclabels,
def->srcpool, def->src.srcpool,
flags); flags);
} }
@ -14968,7 +14980,7 @@ virDomainDiskDefFormat(virBufferPtr buf,
virDomainDiskDefPtr def, virDomainDiskDefPtr def,
unsigned int flags) unsigned int flags)
{ {
const char *type = virDomainDiskTypeToString(def->type); const char *type = virDomainDiskTypeToString(def->src.type);
const char *device = virDomainDiskDeviceTypeToString(def->device); const char *device = virDomainDiskDeviceTypeToString(def->device);
const char *bus = virDomainDiskBusTypeToString(def->bus); const char *bus = virDomainDiskBusTypeToString(def->bus);
const char *cachemode = virDomainDiskCacheTypeToString(def->cachemode); const char *cachemode = virDomainDiskCacheTypeToString(def->cachemode);
@ -14985,7 +14997,7 @@ virDomainDiskDefFormat(virBufferPtr buf,
if (!type) { if (!type) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("unexpected disk type %d"), def->type); _("unexpected disk type %d"), def->src.type);
return -1; return -1;
} }
if (!device) { if (!device) {
@ -15035,14 +15047,14 @@ virDomainDiskDefFormat(virBufferPtr buf,
virBufferAddLit(buf, ">\n"); virBufferAddLit(buf, ">\n");
virBufferAdjustIndent(buf, 2); 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) { def->ioeventfd || def->event_idx || def->copy_on_read) {
virBufferAddLit(buf, "<driver"); virBufferAddLit(buf, "<driver");
if (def->driverName) if (def->src.driverName)
virBufferAsprintf(buf, " name='%s'", def->driverName); virBufferAsprintf(buf, " name='%s'", def->src.driverName);
if (def->format > 0) if (def->src.format > 0)
virBufferAsprintf(buf, " type='%s'", virBufferAsprintf(buf, " type='%s'",
virStorageFileFormatTypeToString(def->format)); virStorageFileFormatTypeToString(def->src.format));
if (def->cachemode) if (def->cachemode)
virBufferAsprintf(buf, " cache='%s'", cachemode); virBufferAsprintf(buf, " cache='%s'", cachemode);
if (def->error_policy) if (def->error_policy)
@ -15062,23 +15074,23 @@ virDomainDiskDefFormat(virBufferPtr buf,
virBufferAddLit(buf, "/>\n"); virBufferAddLit(buf, "/>\n");
} }
if (def->auth.username) { if (def->src.auth.username) {
virBufferEscapeString(buf, "<auth username='%s'>\n", virBufferEscapeString(buf, "<auth username='%s'>\n",
def->auth.username); def->src.auth.username);
virBufferAdjustIndent(buf, 2); 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'"); 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'"); virBufferAddLit(buf, "<secret type='ceph'");
} }
if (def->auth.secretType == VIR_DOMAIN_DISK_SECRET_TYPE_UUID) { if (def->src.auth.secretType == VIR_DOMAIN_DISK_SECRET_TYPE_UUID) {
virUUIDFormat(def->auth.secret.uuid, uuidstr); virUUIDFormat(def->src.auth.secret.uuid, uuidstr);
virBufferAsprintf(buf, " uuid='%s'/>\n", 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", virBufferEscapeString(buf, " usage='%s'/>\n",
def->auth.secret.usage); def->src.auth.secret.usage);
} }
virBufferAdjustIndent(buf, -2); virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</auth>\n"); virBufferAddLit(buf, "</auth>\n");
@ -15169,7 +15181,8 @@ virDomainDiskDefFormat(virBufferPtr buf,
virBufferEscapeString(buf, "<wwn>%s</wwn>\n", def->wwn); virBufferEscapeString(buf, "<wwn>%s</wwn>\n", def->wwn);
virBufferEscapeString(buf, "<vendor>%s</vendor>\n", def->vendor); virBufferEscapeString(buf, "<vendor>%s</vendor>\n", def->vendor);
virBufferEscapeString(buf, "<product>%s</product>\n", def->product); 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; return -1;
if (virDomainDeviceInfoFormat(buf, &def->info, if (virDomainDeviceInfoFormat(buf, &def->info,
flags | VIR_DOMAIN_XML_INTERNAL_ALLOW_BOOT) < 0) flags | VIR_DOMAIN_XML_INTERNAL_ALLOW_BOOT) < 0)
@ -18622,8 +18635,8 @@ virDomainDiskDefForeachPath(virDomainDiskDefPtr disk,
if (!path || type == VIR_DOMAIN_DISK_TYPE_NETWORK || if (!path || type == VIR_DOMAIN_DISK_TYPE_NETWORK ||
(type == VIR_DOMAIN_DISK_TYPE_VOLUME && (type == VIR_DOMAIN_DISK_TYPE_VOLUME &&
disk->srcpool && disk->src.srcpool &&
disk->srcpool->mode == VIR_DOMAIN_DISK_SOURCE_POOL_MODE_DIRECT)) disk->src.srcpool->mode == VIR_DOMAIN_DISK_SOURCE_POOL_MODE_DIRECT))
return 0; return 0;
if (iter(disk, path, 0, opaque) < 0) if (iter(disk, path, 0, opaque) < 0)
@ -19385,9 +19398,9 @@ virDomainDiskDefGetSecurityLabelDef(virDomainDiskDefPtr def, const char *model)
if (def == NULL) if (def == NULL)
return NULL; return NULL;
for (i = 0; i < def->nseclabels; i++) { for (i = 0; i < def->src.nseclabels; i++) {
if (STREQ_NULLABLE(def->seclabels[i]->model, model)) if (STREQ_NULLABLE(def->src.seclabels[i]->model, model))
return def->seclabels[i]; return def->src.seclabels[i];
} }
return NULL; return NULL;
} }
@ -19506,14 +19519,14 @@ virDomainDiskSourceIsBlockType(virDomainDiskDefPtr def)
* If it's a block type source pool, then it's possible * If it's a block type source pool, then it's possible
*/ */
if (virDomainDiskGetType(def) == VIR_DOMAIN_DISK_TYPE_VOLUME && if (virDomainDiskGetType(def) == VIR_DOMAIN_DISK_TYPE_VOLUME &&
def->srcpool && def->src.srcpool &&
def->srcpool->voltype == VIR_STORAGE_VOL_BLOCK) { def->src.srcpool->voltype == VIR_STORAGE_VOL_BLOCK) {
/* We don't think the volume accessed by remote URI is /* We don't think the volume accessed by remote URI is
* block type source, since we can't/shouldn't manage it * block type source, since we can't/shouldn't manage it
* (e.g. set sgio=filtered|unfiltered for it) in libvirt. * (e.g. set sgio=filtered|unfiltered for it) in libvirt.
*/ */
if (def->srcpool->pooltype == VIR_STORAGE_POOL_ISCSI && if (def->src.srcpool->pooltype == VIR_STORAGE_POOL_ISCSI &&
def->srcpool->mode == VIR_DOMAIN_DISK_SOURCE_POOL_MODE_DIRECT) def->src.srcpool->mode == VIR_DOMAIN_DISK_SOURCE_POOL_MODE_DIRECT)
return false; return false;
return true; return true;

37
src/conf/domain_conf.h
View File

@ -705,15 +705,15 @@ struct _virDomainDiskSourcePoolDef {
}; };
typedef virDomainDiskSourcePoolDef *virDomainDiskSourcePoolDefPtr; typedef virDomainDiskSourcePoolDef *virDomainDiskSourcePoolDefPtr;
/* Stores the virtual disk configuration */ typedef struct _virDomainDiskSourceDef virDomainDiskSourceDef;
struct _virDomainDiskDef { 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 type; /* enum virDomainDiskType */
int device; /* enum virDomainDiskDevice */ char *path;
int bus; /* enum virDomainDiskBus */
char *src;
char *dst;
int tray_status; /* enum virDomainDiskTray */
int removable; /* enum virDomainFeatureState */
int protocol; /* enum virDomainDiskProtocol */ int protocol; /* enum virDomainDiskProtocol */
size_t nhosts; size_t nhosts;
virDomainDiskHostDefPtr hosts; virDomainDiskHostDefPtr hosts;
@ -726,8 +726,23 @@ struct _virDomainDiskDef {
char *usage; char *usage;
} secret; } secret;
} auth; } auth;
virStorageEncryptionPtr encryption;
char *driverName; char *driverName;
int format; /* enum virStorageFileFormat */ 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; virStorageFileMetadataPtr backingChain;
char *mirror; char *mirror;
@ -765,14 +780,10 @@ struct _virDomainDiskDef {
bool shared; bool shared;
bool transient; bool transient;
virDomainDeviceInfo info; virDomainDeviceInfo info;
virStorageEncryptionPtr encryption;
bool rawio_specified; bool rawio_specified;
int rawio; /* no = 0, yes = 1 */ int rawio; /* no = 0, yes = 1 */
int sgio; /* enum virDomainDeviceSGIO */ int sgio; /* enum virDomainDeviceSGIO */
int discard; /* enum virDomainDiskDiscard */ int discard; /* enum virDomainDiskDiscard */
size_t nseclabels;
virSecurityDeviceLabelDefPtr *seclabels;
}; };
@ -2251,7 +2262,7 @@ void virDomainGraphicsDefFree(virDomainGraphicsDefPtr def);
void virDomainInputDefFree(virDomainInputDefPtr def); void virDomainInputDefFree(virDomainInputDefPtr def);
void virDomainDiskDefFree(virDomainDiskDefPtr def); void virDomainDiskDefFree(virDomainDiskDefPtr def);
void virDomainLeaseDefFree(virDomainLeaseDefPtr def); void virDomainLeaseDefFree(virDomainLeaseDefPtr def);
void virDomainDiskAuthClear(virDomainDiskDefPtr def); void virDomainDiskAuthClear(virDomainDiskSourceDefPtr def);
void virDomainDiskHostDefClear(virDomainDiskHostDefPtr def); void virDomainDiskHostDefClear(virDomainDiskHostDefPtr def);
void virDomainDiskHostDefFree(size_t nhosts, virDomainDiskHostDefPtr hosts); void virDomainDiskHostDefFree(size_t nhosts, virDomainDiskHostDefPtr hosts);
virDomainDiskHostDefPtr virDomainDiskHostDefCopy(size_t nhosts, virDomainDiskHostDefPtr virDomainDiskHostDefCopy(size_t nhosts,

8
src/lxc/lxc_controller.c
View File

@ -1669,7 +1669,7 @@ static int virLXCControllerSetupDisk(virLXCControllerPtr ctrl,
int ret = -1; int ret = -1;
struct stat sb; struct stat sb;
mode_t mode; mode_t mode;
char *tmpsrc = def->src; char *tmpsrc = def->src.path;
if (virDomainDiskGetType(def) != VIR_DOMAIN_DISK_TYPE_BLOCK) { if (virDomainDiskGetType(def) != VIR_DOMAIN_DISK_TYPE_BLOCK) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
@ -1686,7 +1686,7 @@ static int virLXCControllerSetupDisk(virLXCControllerPtr ctrl,
LXC_STATE_DIR, ctrl->def->name, def->dst) < 0) LXC_STATE_DIR, ctrl->def->name, def->dst) < 0)
goto cleanup; goto cleanup;
if (stat(def->src, &sb) < 0) { if (stat(def->src.path, &sb) < 0) {
virReportSystemError(errno, virReportSystemError(errno,
_("Unable to access %s"), tmpsrc); _("Unable to access %s"), tmpsrc);
goto cleanup; goto cleanup;
@ -1726,14 +1726,14 @@ static int virLXCControllerSetupDisk(virLXCControllerPtr ctrl,
/* Labelling normally operates on src, but we need /* Labelling normally operates on src, but we need
* to actually label the dst here, so hack the config */ * to actually label the dst here, so hack the config */
def->src = dst; def->src.path = dst;
if (virSecurityManagerSetImageLabel(securityDriver, ctrl->def, def) < 0) if (virSecurityManagerSetImageLabel(securityDriver, ctrl->def, def) < 0)
goto cleanup; goto cleanup;
ret = 0; ret = 0;
cleanup: cleanup:
def->src = tmpsrc; def->src.path = tmpsrc;
VIR_FREE(dst); VIR_FREE(dst);
return ret; return ret;
} }

8
src/lxc/lxc_driver.c
View File

@ -3911,14 +3911,14 @@ lxcDomainAttachDeviceMknodHelper(pid_t pid ATTRIBUTE_UNUSED,
switch (data->def->type) { switch (data->def->type) {
case VIR_DOMAIN_DEVICE_DISK: { case VIR_DOMAIN_DEVICE_DISK: {
virDomainDiskDefPtr def = data->def->data.disk; virDomainDiskDefPtr def = data->def->data.disk;
char *tmpsrc = def->src; char *tmpsrc = def->src.path;
def->src = data->file; def->src.path = data->file;
if (virSecurityManagerSetImageLabel(data->driver->securityManager, if (virSecurityManagerSetImageLabel(data->driver->securityManager,
data->vm->def, def) < 0) { data->vm->def, def) < 0) {
def->src = tmpsrc; def->src.path = tmpsrc;
goto cleanup; goto cleanup;
} }
def->src = tmpsrc; def->src.path = tmpsrc;
} break; } break;
case VIR_DOMAIN_DEVICE_HOSTDEV: { case VIR_DOMAIN_DEVICE_HOSTDEV: {

308
src/qemu/qemu_command.c
View File

@ -3255,7 +3255,7 @@ static int qemuAddRBDHost(virDomainDiskDefPtr disk, char *hostport)
size_t skip; size_t skip;
char **parts; 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; return -1;
if ((port = strchr(hostport, ']'))) { if ((port = strchr(hostport, ']'))) {
@ -3270,29 +3270,29 @@ static int qemuAddRBDHost(virDomainDiskDefPtr disk, char *hostport)
if (port) { if (port) {
*port = '\0'; *port = '\0';
port += skip; 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; goto error;
} else { } 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; goto error;
} }
parts = virStringSplit(hostport, "\\:", 0); parts = virStringSplit(hostport, "\\:", 0);
if (!parts) if (!parts)
goto error; 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); virStringFreeList(parts);
if (!disk->hosts[disk->nhosts-1].name) if (!disk->src.hosts[disk->src.nhosts-1].name)
goto error; goto error;
disk->hosts[disk->nhosts-1].transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP; disk->src.hosts[disk->src.nhosts-1].transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
disk->hosts[disk->nhosts-1].socket = NULL; disk->src.hosts[disk->src.nhosts-1].socket = NULL;
return 0; return 0;
error: error:
VIR_FREE(disk->hosts[disk->nhosts-1].port); VIR_FREE(disk->src.hosts[disk->src.nhosts-1].port);
VIR_FREE(disk->hosts[disk->nhosts-1].name); VIR_FREE(disk->src.hosts[disk->src.nhosts-1].name);
return -1; return -1;
} }
@ -3302,7 +3302,7 @@ static int qemuParseRBDString(virDomainDiskDefPtr disk)
char *options = NULL; char *options = NULL;
char *p, *e, *next; char *p, *e, *next;
p = strchr(disk->src, ':'); p = strchr(disk->src.path, ':');
if (p) { if (p) {
if (VIR_STRDUP(options, p + 1) < 0) if (VIR_STRDUP(options, p + 1) < 0)
goto error; goto error;
@ -3331,7 +3331,7 @@ static int qemuParseRBDString(virDomainDiskDefPtr disk)
} }
if (STRPREFIX(p, "id=") && 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; goto error;
if (STRPREFIX(p, "mon_host=")) { if (STRPREFIX(p, "mon_host=")) {
char *h, *sep; char *h, *sep;
@ -3374,7 +3374,7 @@ qemuParseDriveURIString(virDomainDiskDefPtr def, virURIPtr uri,
char *volimg = NULL; char *volimg = NULL;
char *secret = NULL; char *secret = NULL;
if (VIR_ALLOC(def->hosts) < 0) if (VIR_ALLOC(def->src.hosts) < 0)
goto error; goto error;
transp = strchr(uri->scheme, '+'); transp = strchr(uri->scheme, '+');
@ -3388,30 +3388,30 @@ qemuParseDriveURIString(virDomainDiskDefPtr def, virURIPtr uri,
} }
if (!transp) { if (!transp) {
def->hosts->transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP; def->src.hosts->transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
} else { } else {
def->hosts->transport = virDomainDiskProtocolTransportTypeFromString(transp); def->src.hosts->transport = virDomainDiskProtocolTransportTypeFromString(transp);
if (def->hosts->transport < 0) { if (def->src.hosts->transport < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("Invalid %s transport type '%s'"), scheme, transp); _("Invalid %s transport type '%s'"), scheme, transp);
goto error; 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 (def->src.hosts->transport != VIR_DOMAIN_DISK_PROTO_TRANS_UNIX) {
if (VIR_STRDUP(def->hosts->name, uri->server) < 0) if (VIR_STRDUP(def->src.hosts->name, uri->server) < 0)
goto error; goto error;
if (virAsprintf(&def->hosts->port, "%d", uri->port) < 0) if (virAsprintf(&def->src.hosts->port, "%d", uri->port) < 0)
goto error; goto error;
} else { } else {
def->hosts->name = NULL; def->src.hosts->name = NULL;
def->hosts->port = 0; def->src.hosts->port = 0;
if (uri->query) { if (uri->query) {
if (STRPREFIX(uri->query, "socket=")) { if (STRPREFIX(uri->query, "socket=")) {
sock = strchr(uri->query, '=') + 1; sock = strchr(uri->query, '=') + 1;
if (VIR_STRDUP(def->hosts->socket, sock) < 0) if (VIR_STRDUP(def->src.hosts->socket, sock) < 0)
goto error; goto error;
} else { } else {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
@ -3422,12 +3422,11 @@ qemuParseDriveURIString(virDomainDiskDefPtr def, virURIPtr uri,
} }
if (uri->path) { if (uri->path) {
volimg = uri->path + 1; /* skip the prefix slash */ volimg = uri->path + 1; /* skip the prefix slash */
VIR_FREE(def->src); VIR_FREE(def->src.path);
if (VIR_STRDUP(def->src, volimg) < 0) if (VIR_STRDUP(def->src.path, volimg) < 0)
goto error; goto error;
} else { } else {
VIR_FREE(def->src); VIR_FREE(def->src.path);
def->src = NULL;
} }
if (uri->user) { if (uri->user) {
@ -3435,11 +3434,11 @@ qemuParseDriveURIString(virDomainDiskDefPtr def, virURIPtr uri,
if (secret) if (secret)
*secret = '\0'; *secret = '\0';
if (VIR_STRDUP(def->auth.username, uri->user) < 0) if (VIR_STRDUP(def->src.auth.username, uri->user) < 0)
goto error; goto error;
} }
def->nhosts = 1; def->src.nhosts = 1;
ret = 0; ret = 0;
cleanup: cleanup:
@ -3448,8 +3447,8 @@ cleanup:
return ret; return ret;
error: error:
virDomainDiskHostDefClear(def->hosts); virDomainDiskHostDefClear(def->src.hosts);
VIR_FREE(def->hosts); VIR_FREE(def->src.hosts);
goto cleanup; goto cleanup;
} }
@ -3458,7 +3457,7 @@ qemuParseGlusterString(virDomainDiskDefPtr def)
{ {
virURIPtr uri = NULL; virURIPtr uri = NULL;
if (!(uri = virURIParse(def->src))) if (!(uri = virURIParse(def->src.path)))
return -1; return -1;
return qemuParseDriveURIString(def, uri, "gluster"); return qemuParseDriveURIString(def, uri, "gluster");
@ -3471,7 +3470,7 @@ qemuParseISCSIString(virDomainDiskDefPtr def)
char *slash; char *slash;
unsigned lun; unsigned lun;
if (!(uri = virURIParse(def->src))) if (!(uri = virURIParse(def->src.path)))
return -1; return -1;
if (uri->path && if (uri->path &&
@ -3481,7 +3480,8 @@ qemuParseISCSIString(virDomainDiskDefPtr def)
*slash = '\0'; *slash = '\0';
else if (virStrToLong_ui(slash + 1, NULL, 10, &lun) == -1) { else if (virStrToLong_ui(slash + 1, NULL, 10, &lun) == -1) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("invalid name '%s' for iSCSI disk"), def->src); _("invalid name '%s' for iSCSI disk"),
def->src.path);
return -1; return -1;
} }
} }
@ -3498,8 +3498,8 @@ qemuParseNBDString(virDomainDiskDefPtr disk)
virURIPtr uri = NULL; virURIPtr uri = NULL;
if (strstr(disk->src, "://")) { if (strstr(disk->src.path, "://")) {
if (!(uri = virURIParse(disk->src))) if (!(uri = virURIParse(disk->src.path)))
return -1; return -1;
return qemuParseDriveURIString(disk, uri, "nbd"); return qemuParseDriveURIString(disk, uri, "nbd");
} }
@ -3507,7 +3507,7 @@ qemuParseNBDString(virDomainDiskDefPtr disk)
if (VIR_ALLOC(h) < 0) if (VIR_ALLOC(h) < 0)
goto error; goto error;
host = disk->src + strlen("nbd:"); host = disk->src.path + strlen("nbd:");
if (STRPREFIX(host, "unix:/")) { if (STRPREFIX(host, "unix:/")) {
src = strchr(host + strlen("unix:"), ':'); src = strchr(host + strlen("unix:"), ':');
if (src) if (src)
@ -3520,7 +3520,7 @@ qemuParseNBDString(virDomainDiskDefPtr disk)
port = strchr(host, ':'); port = strchr(host, ':');
if (!port) { if (!port) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("cannot parse nbd filename '%s'"), disk->src); _("cannot parse nbd filename '%s'"), disk->src.path);
goto error; goto error;
} }
@ -3543,10 +3543,10 @@ qemuParseNBDString(virDomainDiskDefPtr disk)
src = NULL; src = NULL;
} }
VIR_FREE(disk->src); VIR_FREE(disk->src.path);
disk->src = src; disk->src.path = src;
disk->nhosts = 1; disk->src.nhosts = 1;
disk->hosts = h; disk->src.hosts = h;
return 0; return 0;
error: error:
@ -3875,35 +3875,35 @@ qemuDomainDiskGetSourceString(virConnectPtr conn,
*source = NULL; *source = NULL;
if (actualType == VIR_DOMAIN_DISK_TYPE_NETWORK && if (actualType == VIR_DOMAIN_DISK_TYPE_NETWORK &&
disk->auth.username && disk->src.auth.username &&
(disk->protocol == VIR_DOMAIN_DISK_PROTOCOL_ISCSI || (disk->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_ISCSI ||
disk->protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD)) { disk->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD)) {
bool encode = false; bool encode = false;
int secretType = VIR_SECRET_USAGE_TYPE_ISCSI; 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 */ /* qemu requires the secret to be encoded for RBD */
encode = true; encode = true;
secretType = VIR_SECRET_USAGE_TYPE_CEPH; secretType = VIR_SECRET_USAGE_TYPE_CEPH;
} }
if (!(secret = qemuGetSecretString(conn, if (!(secret = qemuGetSecretString(conn,
virDomainDiskProtocolTypeToString(disk->protocol), virDomainDiskProtocolTypeToString(disk->src.protocol),
encode, encode,
disk->auth.secretType, disk->src.auth.secretType,
disk->auth.username, disk->src.auth.username,
disk->auth.secret.uuid, disk->src.auth.secret.uuid,
disk->auth.secret.usage, disk->src.auth.secret.usage,
secretType))) secretType)))
goto cleanup; goto cleanup;
} }
ret = qemuGetDriveSourceString(virDomainDiskGetActualType(disk), ret = qemuGetDriveSourceString(virDomainDiskGetActualType(disk),
disk->src, disk->src.path,
disk->protocol, disk->src.protocol,
disk->nhosts, disk->src.nhosts,
disk->hosts, disk->src.hosts,
disk->auth.username, disk->src.auth.username,
secret, secret,
source); source);
@ -4021,10 +4021,11 @@ qemuBuildDriveStr(virConnectPtr conn,
switch (actualType) { switch (actualType) {
case VIR_DOMAIN_DISK_TYPE_DIR: case VIR_DOMAIN_DISK_TYPE_DIR:
/* QEMU only supports magic FAT format for now */ /* 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, virReportError(VIR_ERR_INTERNAL_ERROR,
_("unsupported disk driver type for '%s'"), _("unsupported disk driver type for '%s'"),
virStorageFileFormatTypeToString(disk->format)); virStorageFileFormatTypeToString(disk->src.format));
goto error; goto error;
} }
@ -4044,7 +4045,7 @@ qemuBuildDriveStr(virConnectPtr conn,
case VIR_DOMAIN_DISK_TYPE_BLOCK: case VIR_DOMAIN_DISK_TYPE_BLOCK:
if (disk->tray_status == VIR_DOMAIN_DISK_TRAY_OPEN) { if (disk->tray_status == VIR_DOMAIN_DISK_TRAY_OPEN) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", 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 volume") :
_("tray status 'open' is invalid for block type disk")); _("tray status 'open' is invalid for block type disk"));
goto error; goto error;
@ -4104,11 +4105,11 @@ qemuBuildDriveStr(virConnectPtr conn,
_("transient disks not supported yet")); _("transient disks not supported yet"));
goto error; goto error;
} }
if (disk->format > 0 && if (disk->src.format > 0 &&
disk->type != VIR_DOMAIN_DISK_TYPE_DIR && disk->src.type != VIR_DOMAIN_DISK_TYPE_DIR &&
virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_FORMAT)) virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_FORMAT))
virBufferAsprintf(&opt, ",format=%s", virBufferAsprintf(&opt, ",format=%s",
virStorageFileFormatTypeToString(disk->format)); virStorageFileFormatTypeToString(disk->src.format));
/* generate geometry command string */ /* generate geometry command string */
if (disk->geometry.cylinders > 0 && if (disk->geometry.cylinders > 0 &&
@ -4319,11 +4320,11 @@ qemuBuildDriveDevStr(virDomainDefPtr def,
bus); bus);
goto error; goto error;
} }
if (disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK) { if (disk->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
if (disk->protocol != VIR_DOMAIN_DISK_PROTOCOL_ISCSI) { if (disk->src.protocol != VIR_DOMAIN_DISK_PROTOCOL_ISCSI) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("disk device='lun' is not supported for protocol='%s'"), _("disk device='lun' is not supported for protocol='%s'"),
virDomainDiskProtocolTypeToString(disk->protocol)); virDomainDiskProtocolTypeToString(disk->src.protocol));
goto error; goto error;
} }
} else if (!virDomainDiskSourceIsBlockType(disk)) { } else if (!virDomainDiskSourceIsBlockType(disk)) {
@ -8414,11 +8415,11 @@ qemuBuildCommandLine(virConnectPtr conn,
for (i = 0; i < def->ndisks; i++) { for (i = 0; i < def->ndisks; i++) {
virDomainDiskDefPtr disk = def->disks[i]; virDomainDiskDefPtr disk = def->disks[i];
if (disk->driverName != NULL && if (disk->src.driverName != NULL &&
!STREQ(disk->driverName, "qemu")) { !STREQ(disk->src.driverName, "qemu")) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unsupported driver name '%s' for disk '%s'"), _("unsupported driver name '%s' for disk '%s'"),
disk->driverName, disk->src); disk->src.driverName, disk->src.path);
goto error; goto error;
} }
} }
@ -8542,11 +8543,11 @@ qemuBuildCommandLine(virConnectPtr conn,
!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) { !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) { if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
virCommandAddArg(cmd, "-usbdevice"); virCommandAddArg(cmd, "-usbdevice");
virCommandAddArgFormat(cmd, "disk:%s", disk->src); virCommandAddArgFormat(cmd, "disk:%s", disk->src.path);
} else { } else {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("unsupported usb disk type for '%s'"), _("unsupported usb disk type for '%s'"),
disk->src); disk->src.path);
goto error; goto error;
} }
continue; continue;
@ -8632,7 +8633,7 @@ qemuBuildCommandLine(virConnectPtr conn,
const char *fmt; const char *fmt;
virDomainDiskDefPtr disk = def->disks[i]; 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)) { (disk->tray_status == VIR_DOMAIN_DISK_TRAY_OPEN)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("tray status 'open' is invalid for " _("tray status 'open' is invalid for "
@ -8643,11 +8644,11 @@ qemuBuildCommandLine(virConnectPtr conn,
if (disk->bus == VIR_DOMAIN_DISK_BUS_USB) { if (disk->bus == VIR_DOMAIN_DISK_BUS_USB) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) { if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
virCommandAddArg(cmd, "-usbdevice"); virCommandAddArg(cmd, "-usbdevice");
virCommandAddArgFormat(cmd, "disk:%s", disk->src); virCommandAddArgFormat(cmd, "disk:%s", disk->src.path);
} else { } else {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("unsupported usb disk type for '%s'"), _("unsupported usb disk type for '%s'"),
disk->src); disk->src.path);
goto error; goto error;
} }
continue; continue;
@ -8655,7 +8656,7 @@ qemuBuildCommandLine(virConnectPtr conn,
if (STREQ(disk->dst, "hdc") && if (STREQ(disk->dst, "hdc") &&
disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) { disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
if (disk->src) { if (disk->src.path) {
snprintf(dev, NAME_MAX, "-%s", "cdrom"); snprintf(dev, NAME_MAX, "-%s", "cdrom");
} else { } else {
continue; continue;
@ -8671,12 +8672,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 */ /* 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, virReportError(VIR_ERR_INTERNAL_ERROR,
_("unsupported disk driver type for '%s'"), _("unsupported disk driver type for '%s'"),
virStorageFileFormatTypeToString(disk->format)); virStorageFileFormatTypeToString(disk->src.format));
goto error; goto error;
} }
if (!disk->readonly) { if (!disk->readonly) {
@ -8691,11 +8693,11 @@ qemuBuildCommandLine(virConnectPtr conn,
if (virAsprintf(&file, fmt, disk->src) < 0) if (virAsprintf(&file, fmt, disk->src) < 0)
goto error; 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", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("network disks are only supported with -drive")); _("network disks are only supported with -drive"));
} else { } else {
if (VIR_STRDUP(file, disk->src) < 0) { if (VIR_STRDUP(file, disk->src.path) < 0) {
goto error; goto error;
} }
} }
@ -10199,28 +10201,28 @@ qemuParseCommandLineDisk(virDomainXMLOptionPtr xmlopt,
else else
def->bus = VIR_DOMAIN_DISK_BUS_IDE; def->bus = VIR_DOMAIN_DISK_BUS_IDE;
def->device = VIR_DOMAIN_DISK_DEVICE_DISK; 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++) { for (i = 0; i < nkeywords; i++) {
if (STREQ(keywords[i], "file")) { if (STREQ(keywords[i], "file")) {
if (values[i] && STRNEQ(values[i], "")) { if (values[i] && STRNEQ(values[i], "")) {
def->src = values[i]; def->src.path = values[i];
values[i] = NULL; values[i] = NULL;
if (STRPREFIX(def->src, "/dev/")) if (STRPREFIX(def->src.path, "/dev/"))
def->type = VIR_DOMAIN_DISK_TYPE_BLOCK; def->src.type = VIR_DOMAIN_DISK_TYPE_BLOCK;
else if (STRPREFIX(def->src, "nbd:") || else if (STRPREFIX(def->src.path, "nbd:") ||
STRPREFIX(def->src, "nbd+")) { STRPREFIX(def->src.path, "nbd+")) {
def->type = VIR_DOMAIN_DISK_TYPE_NETWORK; def->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
def->protocol = VIR_DOMAIN_DISK_PROTOCOL_NBD; def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_NBD;
if (qemuParseNBDString(def) < 0) if (qemuParseNBDString(def) < 0)
goto error; goto error;
} else if (STRPREFIX(def->src, "rbd:")) { } else if (STRPREFIX(def->src.path, "rbd:")) {
char *p = def->src; char *p = def->src.path;
def->type = VIR_DOMAIN_DISK_TYPE_NETWORK; def->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
def->protocol = VIR_DOMAIN_DISK_PROTOCOL_RBD; def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_RBD;
if (VIR_STRDUP(def->src, p + strlen("rbd:")) < 0) if (VIR_STRDUP(def->src.path, p + strlen("rbd:")) < 0)
goto error; goto error;
/* old-style CEPH_ARGS env variable is parsed later */ /* old-style CEPH_ARGS env variable is parsed later */
if (!old_style_ceph_args && qemuParseRBDString(def) < 0) { if (!old_style_ceph_args && qemuParseRBDString(def) < 0) {
@ -10229,57 +10231,58 @@ qemuParseCommandLineDisk(virDomainXMLOptionPtr xmlopt,
} }
VIR_FREE(p); VIR_FREE(p);
} else if (STRPREFIX(def->src, "gluster:") || } else if (STRPREFIX(def->src.path, "gluster:") ||
STRPREFIX(def->src, "gluster+")) { STRPREFIX(def->src.path, "gluster+")) {
def->type = VIR_DOMAIN_DISK_TYPE_NETWORK; def->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
def->protocol = VIR_DOMAIN_DISK_PROTOCOL_GLUSTER; def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_GLUSTER;
if (qemuParseGlusterString(def) < 0) if (qemuParseGlusterString(def) < 0)
goto error; goto error;
} else if (STRPREFIX(def->src, "iscsi:")) { } else if (STRPREFIX(def->src.path, "iscsi:")) {
def->type = VIR_DOMAIN_DISK_TYPE_NETWORK; def->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
def->protocol = VIR_DOMAIN_DISK_PROTOCOL_ISCSI; def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_ISCSI;
if (qemuParseISCSIString(def) < 0) if (qemuParseISCSIString(def) < 0)
goto error; goto error;
} else if (STRPREFIX(def->src, "sheepdog:")) { } else if (STRPREFIX(def->src.path, "sheepdog:")) {
char *p = def->src; char *p = def->src.path;
char *port, *vdi; char *port, *vdi;
def->type = VIR_DOMAIN_DISK_TYPE_NETWORK; def->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
def->protocol = VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG; def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG;
if (VIR_STRDUP(def->src, p + strlen("sheepdog:")) < 0) if (VIR_STRDUP(def->src.path, p + strlen("sheepdog:")) < 0)
goto error; goto error;
VIR_FREE(p); VIR_FREE(p);
/* def->src must be [vdiname] or [host]:[port]:[vdiname] */ /* def->src.path must be [vdiname] or [host]:[port]:[vdiname] */
port = strchr(def->src, ':'); port = strchr(def->src.path, ':');
if (port) { if (port) {
*port = '\0'; *port = '\0';
vdi = strchr(port + 1, ':'); vdi = strchr(port + 1, ':');
if (!vdi) { if (!vdi) {
*port = ':'; *port = ':';
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("cannot parse sheepdog filename '%s'"), def->src); _("cannot parse sheepdog filename '%s'"),
def->src.path);
goto error; goto error;
} }
port++; port++;
*vdi++ = '\0'; *vdi++ = '\0';
if (VIR_ALLOC(def->hosts) < 0) if (VIR_ALLOC(def->src.hosts) < 0)
goto error; goto error;
def->nhosts = 1; def->src.nhosts = 1;
def->hosts->name = def->src; def->src.hosts->name = def->src.path;
if (VIR_STRDUP(def->hosts->port, port) < 0) if (VIR_STRDUP(def->src.hosts->port, port) < 0)
goto error; goto error;
def->hosts->transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP; def->src.hosts->transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
def->hosts->socket = NULL; def->src.hosts->socket = NULL;
if (VIR_STRDUP(def->src, vdi) < 0) if (VIR_STRDUP(def->src.path, vdi) < 0)
goto error; goto error;
} }
} else } else
def->type = VIR_DOMAIN_DISK_TYPE_FILE; def->src.type = VIR_DOMAIN_DISK_TYPE_FILE;
} else { } else {
def->type = VIR_DOMAIN_DISK_TYPE_FILE; def->src.type = VIR_DOMAIN_DISK_TYPE_FILE;
} }
} else if (STREQ(keywords[i], "if")) { } else if (STREQ(keywords[i], "if")) {
if (STREQ(values[i], "ide")) { if (STREQ(values[i], "ide")) {
@ -10305,9 +10308,9 @@ qemuParseCommandLineDisk(virDomainXMLOptionPtr xmlopt,
} else if (STREQ(values[i], "floppy")) } else if (STREQ(values[i], "floppy"))
def->device = VIR_DOMAIN_DISK_DEVICE_FLOPPY; def->device = VIR_DOMAIN_DISK_DEVICE_FLOPPY;
} else if (STREQ(keywords[i], "format")) { } else if (STREQ(keywords[i], "format")) {
if (VIR_STRDUP(def->driverName, "qemu") < 0) if (VIR_STRDUP(def->src.driverName, "qemu") < 0)
goto error; goto error;
def->format = virStorageFileFormatTypeFromString(values[i]); def->src.format = virStorageFileFormatTypeFromString(values[i]);
} else if (STREQ(keywords[i], "cache")) { } else if (STREQ(keywords[i], "cache")) {
if (STREQ(values[i], "off") || if (STREQ(values[i], "off") ||
STREQ(values[i], "none")) STREQ(values[i], "none"))
@ -10412,9 +10415,9 @@ qemuParseCommandLineDisk(virDomainXMLOptionPtr xmlopt,
if (def->rerror_policy == def->error_policy) if (def->rerror_policy == def->error_policy)
def->rerror_policy = 0; def->rerror_policy = 0;
if (!def->src && if (!def->src.path &&
def->device == VIR_DOMAIN_DISK_DEVICE_DISK && 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, virReportError(VIR_ERR_INTERNAL_ERROR,
_("missing file parameter in drive '%s'"), val); _("missing file parameter in drive '%s'"), val);
goto error; goto error;
@ -11499,23 +11502,23 @@ qemuParseCommandLine(virCapsPtr qemuCaps,
goto error; goto error;
if (STRPREFIX(val, "/dev/")) if (STRPREFIX(val, "/dev/"))
disk->type = VIR_DOMAIN_DISK_TYPE_BLOCK; disk->src.type = VIR_DOMAIN_DISK_TYPE_BLOCK;
else if (STRPREFIX(val, "nbd:")) { else if (STRPREFIX(val, "nbd:")) {
disk->type = VIR_DOMAIN_DISK_TYPE_NETWORK; disk->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
disk->protocol = VIR_DOMAIN_DISK_PROTOCOL_NBD; disk->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_NBD;
} else if (STRPREFIX(val, "rbd:")) { } else if (STRPREFIX(val, "rbd:")) {
disk->type = VIR_DOMAIN_DISK_TYPE_NETWORK; disk->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
disk->protocol = VIR_DOMAIN_DISK_PROTOCOL_RBD; disk->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_RBD;
val += strlen("rbd:"); val += strlen("rbd:");
} else if (STRPREFIX(val, "gluster")) { } else if (STRPREFIX(val, "gluster")) {
disk->type = VIR_DOMAIN_DISK_TYPE_NETWORK; disk->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
disk->protocol = VIR_DOMAIN_DISK_PROTOCOL_GLUSTER; disk->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_GLUSTER;
} else if (STRPREFIX(val, "sheepdog:")) { } else if (STRPREFIX(val, "sheepdog:")) {
disk->type = VIR_DOMAIN_DISK_TYPE_NETWORK; disk->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
disk->protocol = VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG; disk->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG;
val += strlen("sheepdog:"); val += strlen("sheepdog:");
} else } else
disk->type = VIR_DOMAIN_DISK_TYPE_FILE; disk->src.type = VIR_DOMAIN_DISK_TYPE_FILE;
if (STREQ(arg, "-cdrom")) { if (STREQ(arg, "-cdrom")) {
disk->device = VIR_DOMAIN_DISK_DEVICE_CDROM; disk->device = VIR_DOMAIN_DISK_DEVICE_CDROM;
if (((def->os.arch == VIR_ARCH_PPC64) && if (((def->os.arch == VIR_ARCH_PPC64) &&
@ -11541,13 +11544,13 @@ qemuParseCommandLine(virCapsPtr qemuCaps,
if (VIR_STRDUP(disk->dst, arg + 1) < 0) if (VIR_STRDUP(disk->dst, arg + 1) < 0)
goto error; goto error;
} }
if (VIR_STRDUP(disk->src, val) < 0) if (VIR_STRDUP(disk->src.path, val) < 0)
goto error; goto error;
if (disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK) { if (disk->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
char *port; char *port;
switch (disk->protocol) { switch (disk->src.protocol) {
case VIR_DOMAIN_DISK_PROTOCOL_NBD: case VIR_DOMAIN_DISK_PROTOCOL_NBD:
if (qemuParseNBDString(disk) < 0) if (qemuParseNBDString(disk) < 0)
goto error; goto error;
@ -11559,7 +11562,7 @@ qemuParseCommandLine(virCapsPtr qemuCaps,
break; break;
case VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG: case VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG:
/* disk->src must be [vdiname] or [host]:[port]:[vdiname] */ /* disk->src must be [vdiname] or [host]:[port]:[vdiname] */
port = strchr(disk->src, ':'); port = strchr(disk->src.path, ':');
if (port) { if (port) {
char *vdi; char *vdi;
@ -11571,13 +11574,13 @@ qemuParseCommandLine(virCapsPtr qemuCaps,
goto error; goto error;
} }
*vdi++ = '\0'; *vdi++ = '\0';
if (VIR_ALLOC(disk->hosts) < 0) if (VIR_ALLOC(disk->src.hosts) < 0)
goto error; goto error;
disk->nhosts = 1; disk->src.nhosts = 1;
disk->hosts->name = disk->src; disk->src.hosts->name = disk->src.path;
if (VIR_STRDUP(disk->hosts->port, port) < 0) if (VIR_STRDUP(disk->src.hosts->port, port) < 0)
goto error; goto error;
if (VIR_STRDUP(disk->src, vdi) < 0) if (VIR_STRDUP(disk->src.path, vdi) < 0)
goto error; goto error;
} }
break; break;
@ -11788,12 +11791,12 @@ qemuParseCommandLine(virCapsPtr qemuCaps,
} else if (STRPREFIX(val, "disk:")) { } else if (STRPREFIX(val, "disk:")) {
if (VIR_ALLOC(disk) < 0) if (VIR_ALLOC(disk) < 0)
goto error; goto error;
if (VIR_STRDUP(disk->src, val + strlen("disk:")) < 0) if (VIR_STRDUP(disk->src.path, val + strlen("disk:")) < 0)
goto error; goto error;
if (STRPREFIX(disk->src, "/dev/")) if (STRPREFIX(disk->src.path, "/dev/"))
disk->type = VIR_DOMAIN_DISK_TYPE_BLOCK; disk->src.type = VIR_DOMAIN_DISK_TYPE_BLOCK;
else else
disk->type = VIR_DOMAIN_DISK_TYPE_FILE; disk->src.type = VIR_DOMAIN_DISK_TYPE_FILE;
disk->device = VIR_DOMAIN_DISK_DEVICE_DISK; disk->device = VIR_DOMAIN_DISK_DEVICE_DISK;
disk->bus = VIR_DOMAIN_DISK_BUS_USB; disk->bus = VIR_DOMAIN_DISK_BUS_USB;
disk->removable = VIR_DOMAIN_FEATURE_STATE_DEFAULT; disk->removable = VIR_DOMAIN_FEATURE_STATE_DEFAULT;
@ -12024,8 +12027,8 @@ qemuParseCommandLine(virCapsPtr qemuCaps,
char *hosts, *port, *saveptr = NULL, *token; char *hosts, *port, *saveptr = NULL, *token;
virDomainDiskDefPtr first_rbd_disk = NULL; virDomainDiskDefPtr first_rbd_disk = NULL;
for (i = 0; i < def->ndisks; i++) { for (i = 0; i < def->ndisks; i++) {
if (def->disks[i]->type == VIR_DOMAIN_DISK_TYPE_NETWORK && if (def->disks[i]->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK &&
def->disks[i]->protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD) { def->disks[i]->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD) {
first_rbd_disk = def->disks[i]; first_rbd_disk = def->disks[i];
break; break;
} }
@ -12045,10 +12048,11 @@ qemuParseCommandLine(virCapsPtr qemuCaps,
} }
if (VIR_STRDUP(hosts, strchr(ceph_args, ' ') + 1) < 0) if (VIR_STRDUP(hosts, strchr(ceph_args, ' ') + 1) < 0)
goto error; goto error;
first_rbd_disk->nhosts = 0; first_rbd_disk->src.nhosts = 0;
token = strtok_r(hosts, ",", &saveptr); token = strtok_r(hosts, ",", &saveptr);
while (token != NULL) { 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); VIR_FREE(hosts);
goto error; goto error;
} }
@ -12060,21 +12064,21 @@ qemuParseCommandLine(virCapsPtr qemuCaps,
goto error; goto error;
} }
} }
first_rbd_disk->hosts[first_rbd_disk->nhosts].port = port; first_rbd_disk->src.hosts[first_rbd_disk->src.nhosts].port = port;
if (VIR_STRDUP(first_rbd_disk->hosts[first_rbd_disk->nhosts].name, if (VIR_STRDUP(first_rbd_disk->src.hosts[first_rbd_disk->src.nhosts].name,
token) < 0) { token) < 0) {
VIR_FREE(hosts); VIR_FREE(hosts);
goto error; goto error;
} }
first_rbd_disk->hosts[first_rbd_disk->nhosts].transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP; first_rbd_disk->src.hosts[first_rbd_disk->src.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].socket = NULL;
first_rbd_disk->nhosts++; first_rbd_disk->src.nhosts++;
token = strtok_r(NULL, ",", &saveptr); token = strtok_r(NULL, ",", &saveptr);
} }
VIR_FREE(hosts); VIR_FREE(hosts);
if (first_rbd_disk->nhosts == 0) { if (first_rbd_disk->src.nhosts == 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("found no rbd hosts in CEPH_ARGS '%s'"), ceph_args); _("found no rbd hosts in CEPH_ARGS '%s'"), ceph_args);
goto error; goto error;

86
src/qemu/qemu_conf.c
View File

@ -797,8 +797,8 @@ qemuCheckSharedDevice(virHashTablePtr sharedDevices,
virReportError(VIR_ERR_OPERATION_INVALID, virReportError(VIR_ERR_OPERATION_INVALID,
_("sgio of shared disk 'pool=%s' 'volume=%s' conflicts " _("sgio of shared disk 'pool=%s' 'volume=%s' conflicts "
"with other active domains"), "with other active domains"),
disk->srcpool->pool, disk->src.srcpool->pool,
disk->srcpool->volume); disk->src.srcpool->volume);
} else { } else {
virReportError(VIR_ERR_OPERATION_INVALID, virReportError(VIR_ERR_OPERATION_INVALID,
_("sgio of shared disk '%s' conflicts with other " _("sgio of shared disk '%s' conflicts with other "
@ -1158,33 +1158,33 @@ qemuAddISCSIPoolSourceHost(virDomainDiskDefPtr def,
} }
/* iscsi pool only supports one host */ /* 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; 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; 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 ?
pooldef->source.hosts[0].port : pooldef->source.hosts[0].port :
3260) < 0) 3260) < 0)
goto cleanup; goto cleanup;
/* iscsi volume has name like "unit:0:0:1" */ /* 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; goto cleanup;
if (virStringListLength(tokens) != 4) { if (virStringListLength(tokens) != 4) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("unexpected iscsi volume name '%s'"), _("unexpected iscsi volume name '%s'"),
def->srcpool->volume); def->src.srcpool->volume);
goto cleanup; goto cleanup;
} }
/* iscsi pool has only one source device path */ /* 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, pooldef->source.devices[0].path,
tokens[3]) < 0) tokens[3]) < 0)
goto cleanup; goto cleanup;
@ -1192,10 +1192,10 @@ qemuAddISCSIPoolSourceHost(virDomainDiskDefPtr def,
/* Storage pool have not supported these 2 attributes yet, /* Storage pool have not supported these 2 attributes yet,
* use the defaults. * use the defaults.
*/ */
def->hosts[0].transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP; def->src.hosts[0].transport = VIR_DOMAIN_DISK_PROTO_TRANS_TCP;
def->hosts[0].socket = NULL; def->src.hosts[0].socket = NULL;
def->protocol = VIR_DOMAIN_DISK_PROTOCOL_ISCSI; def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_ISCSI;
ret = 0; ret = 0;
@ -1220,34 +1220,34 @@ qemuTranslateDiskSourcePoolAuth(virDomainDiskDefPtr def,
* into the virDomainDiskDef * into the virDomainDiskDef
*/ */
if (pooldef->source.authType == VIR_STORAGE_POOL_AUTH_CHAP) { 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) pooldef->source.auth.chap.username) < 0)
goto cleanup; goto cleanup;
if (pooldef->source.auth.chap.secret.uuidUsable) { if (pooldef->source.auth.chap.secret.uuidUsable) {
def->auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_UUID; def->src.auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_UUID;
memcpy(def->auth.secret.uuid, memcpy(def->src.auth.secret.uuid,
pooldef->source.auth.chap.secret.uuid, pooldef->source.auth.chap.secret.uuid,
VIR_UUID_BUFLEN); VIR_UUID_BUFLEN);
} else { } else {
if (VIR_STRDUP(def->auth.secret.usage, if (VIR_STRDUP(def->src.auth.secret.usage,
pooldef->source.auth.chap.secret.usage) < 0) pooldef->source.auth.chap.secret.usage) < 0)
goto cleanup; 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) { } 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) pooldef->source.auth.cephx.username) < 0)
goto cleanup; goto cleanup;
if (pooldef->source.auth.cephx.secret.uuidUsable) { if (pooldef->source.auth.cephx.secret.uuidUsable) {
def->auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_UUID; def->src.auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_UUID;
memcpy(def->auth.secret.uuid, memcpy(def->src.auth.secret.uuid,
pooldef->source.auth.cephx.secret.uuid, pooldef->source.auth.cephx.secret.uuid,
VIR_UUID_BUFLEN); VIR_UUID_BUFLEN);
} else { } else {
if (VIR_STRDUP(def->auth.secret.usage, if (VIR_STRDUP(def->src.auth.secret.usage,
pooldef->source.auth.cephx.secret.usage) < 0) pooldef->source.auth.cephx.secret.usage) < 0)
goto cleanup; goto cleanup;
def->auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_USAGE; def->src.auth.secretType = VIR_DOMAIN_DISK_SECRET_TYPE_USAGE;
} }
} }
ret = 0; ret = 0;
@ -1269,24 +1269,24 @@ qemuTranslateDiskSourcePool(virConnectPtr conn,
int ret = -1; int ret = -1;
virErrorPtr savedError = NULL; virErrorPtr savedError = NULL;
if (def->type != VIR_DOMAIN_DISK_TYPE_VOLUME) if (def->src.type != VIR_DOMAIN_DISK_TYPE_VOLUME)
return 0; return 0;
if (!def->srcpool) if (!def->src.srcpool)
return 0; return 0;
if (!(pool = virStoragePoolLookupByName(conn, def->srcpool->pool))) if (!(pool = virStoragePoolLookupByName(conn, def->src.srcpool->pool)))
return -1; return -1;
if (virStoragePoolIsActive(pool) != 1) { if (virStoragePoolIsActive(pool) != 1) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("storage pool '%s' containing volume '%s' " _("storage pool '%s' containing volume '%s' "
"is not active"), "is not active"),
def->srcpool->pool, def->srcpool->volume); def->src.srcpool->pool, def->src.srcpool->volume);
goto cleanup; goto cleanup;
} }
if (!(vol = virStorageVolLookupByName(pool, def->srcpool->volume))) if (!(vol = virStorageVolLookupByName(pool, def->src.srcpool->volume)))
goto cleanup; goto cleanup;
if (virStorageVolGetInfo(vol, &info) < 0) if (virStorageVolGetInfo(vol, &info) < 0)
@ -1298,19 +1298,19 @@ qemuTranslateDiskSourcePool(virConnectPtr conn,
if (!(pooldef = virStoragePoolDefParseString(poolxml))) if (!(pooldef = virStoragePoolDefParseString(poolxml)))
goto cleanup; goto cleanup;
def->srcpool->pooltype = pooldef->type; def->src.srcpool->pooltype = pooldef->type;
def->srcpool->voltype = info.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", virReportError(VIR_ERR_XML_ERROR, "%s",
_("disk source mode is only valid when " _("disk source mode is only valid when "
"storage pool is of iscsi type")); "storage pool is of iscsi type"));
goto cleanup; goto cleanup;
} }
VIR_FREE(def->src); VIR_FREE(def->src.path);
virDomainDiskHostDefFree(def->nhosts, def->hosts); virDomainDiskHostDefFree(def->src.nhosts, def->src.hosts);
virDomainDiskAuthClear(def); virDomainDiskAuthClear(&def->src);
switch ((enum virStoragePoolType) pooldef->type) { switch ((enum virStoragePoolType) pooldef->type) {
case VIR_STORAGE_POOL_DIR: case VIR_STORAGE_POOL_DIR:
@ -1319,7 +1319,7 @@ qemuTranslateDiskSourcePool(virConnectPtr conn,
case VIR_STORAGE_POOL_LOGICAL: case VIR_STORAGE_POOL_LOGICAL:
case VIR_STORAGE_POOL_DISK: case VIR_STORAGE_POOL_DISK:
case VIR_STORAGE_POOL_SCSI: case VIR_STORAGE_POOL_SCSI:
if (!(def->src = virStorageVolGetPath(vol))) if (!(def->src.path = virStorageVolGetPath(vol)))
goto cleanup; goto cleanup;
if (def->startupPolicy && info.type != VIR_STORAGE_VOL_FILE) { if (def->startupPolicy && info.type != VIR_STORAGE_VOL_FILE) {
@ -1332,15 +1332,15 @@ qemuTranslateDiskSourcePool(virConnectPtr conn,
switch (info.type) { switch (info.type) {
case VIR_STORAGE_VOL_FILE: case VIR_STORAGE_VOL_FILE:
def->srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_FILE; def->src.srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_FILE;
break; break;
case VIR_STORAGE_VOL_DIR: case VIR_STORAGE_VOL_DIR:
def->srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_DIR; def->src.srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_DIR;
break; break;
case VIR_STORAGE_VOL_BLOCK: case VIR_STORAGE_VOL_BLOCK:
def->srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_BLOCK; def->src.srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_BLOCK;
break; break;
case VIR_STORAGE_VOL_NETWORK: case VIR_STORAGE_VOL_NETWORK:
@ -1363,20 +1363,20 @@ qemuTranslateDiskSourcePool(virConnectPtr conn,
goto cleanup; 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_DEFAULT:
case VIR_DOMAIN_DISK_SOURCE_POOL_MODE_LAST: 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 */ /* fallthrough */
case VIR_DOMAIN_DISK_SOURCE_POOL_MODE_HOST: case VIR_DOMAIN_DISK_SOURCE_POOL_MODE_HOST:
def->srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_BLOCK; def->src.srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_BLOCK;
if (!(def->src = virStorageVolGetPath(vol))) if (!(def->src.path = virStorageVolGetPath(vol)))
goto cleanup; goto cleanup;
break; break;
case VIR_DOMAIN_DISK_SOURCE_POOL_MODE_DIRECT: case VIR_DOMAIN_DISK_SOURCE_POOL_MODE_DIRECT:
def->srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_NETWORK; def->src.srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_NETWORK;
def->protocol = VIR_DOMAIN_DISK_PROTOCOL_ISCSI; def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_ISCSI;
if (qemuTranslateDiskSourcePoolAuth(def, pooldef) < 0) if (qemuTranslateDiskSourcePoolAuth(def, pooldef) < 0)
goto cleanup; goto cleanup;

185
src/qemu/qemu_driver.c
View File

@ -6839,18 +6839,18 @@ qemuDomainUpdateDeviceConfig(virQEMUCapsPtr qemuCaps,
* Update 'orig' * Update 'orig'
* We allow updating src/type//driverType/cachemode/ * We allow updating src/type//driverType/cachemode/
*/ */
VIR_FREE(orig->src); VIR_FREE(orig->src.path);
orig->src = disk->src; orig->src.path = disk->src.path;
orig->type = disk->type; orig->src.type = disk->src.type;
orig->cachemode = disk->cachemode; orig->cachemode = disk->cachemode;
if (disk->driverName) { if (disk->src.driverName) {
VIR_FREE(orig->driverName); VIR_FREE(orig->src.driverName);
orig->driverName = disk->driverName; orig->src.driverName = disk->src.driverName;
disk->driverName = NULL; disk->src.driverName = NULL;
} }
if (disk->format) if (disk->src.format)
orig->format = disk->format; orig->src.format = disk->src.format;
disk->src = NULL; disk->src.path = NULL;
break; break;
case VIR_DOMAIN_DEVICE_NET: case VIR_DOMAIN_DEVICE_NET:
@ -12003,26 +12003,27 @@ qemuDomainPrepareDiskChainElement(virQEMUDriverPtr driver,
/* The easiest way to label a single file with the same /* The easiest way to label a single file with the same
* permissions it would have as if part of the disk chain is to * permissions it would have as if part of the disk chain is to
* temporarily modify the disk in place. */ * temporarily modify the disk in place. */
char *origsrc = disk->src; char *origsrc = disk->src.path;
int origformat = disk->format; int origformat = disk->src.format;
virStorageFileMetadataPtr origchain = disk->backingChain; virStorageFileMetadataPtr origchain = disk->backingChain;
bool origreadonly = disk->readonly; bool origreadonly = disk->readonly;
int ret = -1; int ret = -1;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver); virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
disk->src = (char *) file; /* casting away const is safe here */ disk->src.path = (char *) file; /* casting away const is safe here */
disk->format = VIR_STORAGE_FILE_RAW; disk->src.format = VIR_STORAGE_FILE_RAW;
disk->backingChain = NULL; disk->backingChain = NULL;
disk->readonly = mode == VIR_DISK_CHAIN_READ_ONLY; disk->readonly = mode == VIR_DISK_CHAIN_READ_ONLY;
if (mode == VIR_DISK_CHAIN_NO_ACCESS) { if (mode == VIR_DISK_CHAIN_NO_ACCESS) {
if (virSecurityManagerRestoreImageLabel(driver->securityManager, if (virSecurityManagerRestoreImageLabel(driver->securityManager,
vm->def, disk) < 0) 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) 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) 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, } else if (virDomainLockDiskAttach(driver->lockManager, cfg->uri,
vm, disk) < 0 || vm, disk) < 0 ||
qemuSetupDiskCgroup(vm, disk) < 0 || qemuSetupDiskCgroup(vm, disk) < 0 ||
@ -12034,8 +12035,8 @@ qemuDomainPrepareDiskChainElement(virQEMUDriverPtr driver,
ret = 0; ret = 0;
cleanup: cleanup:
disk->src = origsrc; disk->src.path = origsrc;
disk->format = origformat; disk->src.format = origformat;
disk->backingChain = origchain; disk->backingChain = origchain;
disk->readonly = origreadonly; disk->readonly = origreadonly;
virObjectUnref(cfg); virObjectUnref(cfg);
@ -12133,22 +12134,22 @@ qemuDomainSnapshotCreateInactiveExternal(virQEMUDriverPtr driver,
NULL))) NULL)))
goto cleanup; goto cleanup;
if (defdisk->format > 0) { if (defdisk->src.format > 0) {
/* adds cmd line arg: backing_file=/path/to/backing/file,backing_fmd=format */ /* adds cmd line arg: backing_file=/path/to/backing/file,backing_fmd=format */
virCommandAddArgFormat(cmd, "backing_file=%s,backing_fmt=%s", virCommandAddArgFormat(cmd, "backing_file=%s,backing_fmt=%s",
defdisk->src, defdisk->src.path,
virStorageFileFormatTypeToString(defdisk->format)); virStorageFileFormatTypeToString(defdisk->src.format));
} else { } else {
if (!cfg->allowDiskFormatProbing) { if (!cfg->allowDiskFormatProbing) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unknown image format of '%s' and " _("unknown image format of '%s' and "
"format probing is disabled"), "format probing is disabled"),
defdisk->src); defdisk->src.path);
goto cleanup; goto cleanup;
} }
/* adds cmd line arg: backing_file=/path/to/backing/file */ /* 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 */ /* adds cmd line args: /path/to/target/file */
@ -12171,12 +12172,12 @@ qemuDomainSnapshotCreateInactiveExternal(virQEMUDriverPtr driver,
defdisk = vm->def->disks[snapdisk->index]; defdisk = vm->def->disks[snapdisk->index];
if (snapdisk->snapshot == VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL) { if (snapdisk->snapshot == VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL) {
VIR_FREE(defdisk->src); VIR_FREE(defdisk->src.path);
if (VIR_STRDUP(defdisk->src, snapdisk->file) < 0) { if (VIR_STRDUP(defdisk->src.path, snapdisk->file) < 0) {
/* we cannot rollback here in a sane way */ /* we cannot rollback here in a sane way */
goto cleanup; goto cleanup;
} }
defdisk->format = snapdisk->format; defdisk->src.format = snapdisk->format;
} }
} }
@ -12299,7 +12300,7 @@ qemuDomainSnapshotPrepareDiskExternalBackingInactive(virDomainDiskDefPtr disk)
return 0; return 0;
case VIR_DOMAIN_DISK_TYPE_NETWORK: 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_NBD:
case VIR_DOMAIN_DISK_PROTOCOL_RBD: case VIR_DOMAIN_DISK_PROTOCOL_RBD:
case VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG: case VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG:
@ -12314,7 +12315,7 @@ qemuDomainSnapshotPrepareDiskExternalBackingInactive(virDomainDiskDefPtr disk)
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("external inactive snapshots are not supported on " _("external inactive snapshots are not supported on "
"'network' disks using '%s' protocol"), "'network' disks using '%s' protocol"),
virDomainDiskProtocolTypeToString(disk->protocol)); virDomainDiskProtocolTypeToString(disk->src.protocol));
return -1; return -1;
} }
break; break;
@ -12504,7 +12505,7 @@ qemuDomainSnapshotPrepareDiskInternal(virConnectPtr conn,
return 0; return 0;
case VIR_DOMAIN_DISK_TYPE_NETWORK: 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_NBD:
case VIR_DOMAIN_DISK_PROTOCOL_RBD: case VIR_DOMAIN_DISK_PROTOCOL_RBD:
case VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG: case VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG:
@ -12519,7 +12520,7 @@ qemuDomainSnapshotPrepareDiskInternal(virConnectPtr conn,
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("internal inactive snapshots are not supported on " _("internal inactive snapshots are not supported on "
"'network' disks using '%s' protocol"), "'network' disks using '%s' protocol"),
virDomainDiskProtocolTypeToString(disk->protocol)); virDomainDiskProtocolTypeToString(disk->src.protocol));
return -1; return -1;
} }
break; break;
@ -12579,19 +12580,19 @@ qemuDomainSnapshotPrepare(virConnectPtr conn,
active) < 0) active) < 0)
goto cleanup; goto cleanup;
if (dom_disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK && if (dom_disk->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK &&
(dom_disk->protocol == VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG || (dom_disk->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG ||
dom_disk->protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD)) { dom_disk->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD)) {
break; break;
} }
if (vm->def->disks[i]->format > 0 && if (vm->def->disks[i]->src.format > 0 &&
vm->def->disks[i]->format != VIR_STORAGE_FILE_QCOW2) { vm->def->disks[i]->src.format != VIR_STORAGE_FILE_QCOW2) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("internal snapshot for disk %s unsupported " _("internal snapshot for disk %s unsupported "
"for storage type %s"), "for storage type %s"),
disk->name, disk->name,
virStorageFileFormatTypeToString( virStorageFileFormatTypeToString(
vm->def->disks[i]->format)); vm->def->disks[i]->src.format));
goto cleanup; goto cleanup;
} }
break; break;
@ -12805,36 +12806,37 @@ qemuDomainSnapshotCreateSingleDiskActive(virQEMUDriverPtr driver,
} }
} }
virDomainAuditDisk(vm, disk->src, source, "snapshot", ret >= 0); virDomainAuditDisk(vm, disk->src.path, source, "snapshot", ret >= 0);
if (ret < 0) if (ret < 0)
goto cleanup; goto cleanup;
/* Update vm in place to match changes. */ /* Update vm in place to match changes. */
need_unlink = false; need_unlink = false;
VIR_FREE(disk->src); VIR_FREE(disk->src.path);
virDomainDiskHostDefFree(disk->nhosts, disk->hosts); virDomainDiskHostDefFree(disk->src.nhosts, disk->src.hosts);
disk->src = newsource; disk->src.path = newsource;
disk->format = format; disk->src.format = format;
disk->type = snap->type; disk->src.type = snap->type;
disk->protocol = snap->protocol; disk->src.protocol = snap->protocol;
disk->nhosts = snap->nhosts; disk->src.nhosts = snap->nhosts;
disk->hosts = newhosts; disk->src.hosts = newhosts;
newsource = NULL; newsource = NULL;
newhosts = NULL; newhosts = NULL;
if (persistDisk) { if (persistDisk) {
VIR_FREE(persistDisk->src); VIR_FREE(persistDisk->src.path);
virDomainDiskHostDefFree(persistDisk->nhosts, persistDisk->hosts); virDomainDiskHostDefFree(persistDisk->src.nhosts,
persistDisk->src.hosts);
persistDisk->src = persistSource; persistDisk->src.path = persistSource;
persistDisk->format = format; persistDisk->src.format = format;
persistDisk->type = snap->type; persistDisk->src.type = snap->type;
persistDisk->protocol = snap->protocol; persistDisk->src.protocol = snap->protocol;
persistDisk->nhosts = snap->nhosts; persistDisk->src.nhosts = snap->nhosts;
persistDisk->hosts = persistHosts; persistDisk->src.hosts = persistHosts;
persistSource = NULL; persistSource = NULL;
persistHosts = NULL; persistHosts = NULL;
@ -12871,37 +12873,40 @@ qemuDomainSnapshotUndoSingleDiskActive(virQEMUDriverPtr driver,
diskfile = virStorageFileInitFromDiskDef(disk); diskfile = virStorageFileInitFromDiskDef(disk);
if (VIR_STRDUP(source, origdisk->src) < 0 || if (VIR_STRDUP(source, origdisk->src.path) < 0 ||
(persistDisk && VIR_STRDUP(persistSource, source) < 0)) (persistDisk && VIR_STRDUP(persistSource, source) < 0))
goto cleanup; goto cleanup;
qemuDomainPrepareDiskChainElement(driver, vm, disk, disk->src, qemuDomainPrepareDiskChainElement(driver, vm, disk, disk->src.path,
VIR_DISK_CHAIN_NO_ACCESS); VIR_DISK_CHAIN_NO_ACCESS);
if (need_unlink && diskfile && if (need_unlink && diskfile &&
virStorageFileStat(diskfile, &st) == 0 && S_ISREG(st.st_mode) && virStorageFileStat(diskfile, &st) == 0 && S_ISREG(st.st_mode) &&
virStorageFileUnlink(diskfile) < 0) 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. */ /* Update vm in place to match changes. */
VIR_FREE(disk->src); VIR_FREE(disk->src.path);
disk->src = source; disk->src.path = source;
source = NULL; source = NULL;
disk->format = origdisk->format; disk->src.format = origdisk->src.format;
disk->type = origdisk->type; disk->src.type = origdisk->src.type;
disk->protocol = origdisk->protocol; disk->src.protocol = origdisk->src.protocol;
virDomainDiskHostDefFree(disk->nhosts, disk->hosts); virDomainDiskHostDefFree(disk->src.nhosts, disk->src.hosts);
disk->nhosts = origdisk->nhosts; disk->src.nhosts = origdisk->src.nhosts;
disk->hosts = virDomainDiskHostDefCopy(origdisk->nhosts, origdisk->hosts); disk->src.hosts = virDomainDiskHostDefCopy(origdisk->src.nhosts,
origdisk->src.hosts);
if (persistDisk) { if (persistDisk) {
VIR_FREE(persistDisk->src); VIR_FREE(persistDisk->src.path);
persistDisk->src = persistSource; persistDisk->src.path = persistSource;
persistSource = NULL; persistSource = NULL;
persistDisk->format = origdisk->format; persistDisk->src.format = origdisk->src.format;
persistDisk->type = origdisk->type; persistDisk->src.type = origdisk->src.type;
persistDisk->protocol = origdisk->protocol; persistDisk->src.protocol = origdisk->src.protocol;
virDomainDiskHostDefFree(persistDisk->nhosts, persistDisk->hosts); virDomainDiskHostDefFree(persistDisk->src.nhosts,
persistDisk->nhosts = origdisk->nhosts; persistDisk->src.hosts);
persistDisk->hosts = virDomainDiskHostDefCopy(origdisk->nhosts, origdisk->hosts); persistDisk->src.nhosts = origdisk->src.nhosts;
persistDisk->src.hosts = virDomainDiskHostDefCopy(origdisk->src.nhosts,
origdisk->src.hosts);
} }
cleanup: cleanup:
@ -14744,15 +14749,15 @@ qemuDomainBlockPivot(virConnectPtr conn,
* label the entire chain. This action is safe even if the * label the entire chain. This action is safe even if the
* backing chain has already been labeled; but only necessary when * backing chain has already been labeled; but only necessary when
* we know for sure that there is a backing chain. */ * we know for sure that there is a backing chain. */
oldsrc = disk->src; oldsrc = disk->src.path;
oldformat = disk->format; oldformat = disk->src.format;
oldchain = disk->backingChain; oldchain = disk->backingChain;
disk->src = disk->mirror; disk->src.path = disk->mirror;
disk->format = disk->mirrorFormat; disk->src.format = disk->mirrorFormat;
disk->backingChain = NULL; disk->backingChain = NULL;
if (qemuDomainDetermineDiskChain(driver, vm, disk, false) < 0) { if (qemuDomainDetermineDiskChain(driver, vm, disk, false) < 0) {
disk->src = oldsrc; disk->src.path = oldsrc;
disk->format = oldformat; disk->src.format = oldformat;
disk->backingChain = oldchain; disk->backingChain = oldchain;
goto cleanup; goto cleanup;
} }
@ -14762,8 +14767,8 @@ qemuDomainBlockPivot(virConnectPtr conn,
qemuSetupDiskCgroup(vm, disk) < 0 || qemuSetupDiskCgroup(vm, disk) < 0 ||
virSecurityManagerSetImageLabel(driver->securityManager, vm->def, virSecurityManagerSetImageLabel(driver->securityManager, vm->def,
disk) < 0)) { disk) < 0)) {
disk->src = oldsrc; disk->src.path = oldsrc;
disk->format = oldformat; disk->src.format = oldformat;
disk->backingChain = oldchain; disk->backingChain = oldchain;
goto cleanup; goto cleanup;
} }
@ -14793,8 +14798,8 @@ qemuDomainBlockPivot(virConnectPtr conn,
* 'query-block', to see what state we really got left in * 'query-block', to see what state we really got left in
* before killing the mirroring job? And just as on the * before killing the mirroring job? And just as on the
* success case, there's security labeling to worry about. */ * success case, there's security labeling to worry about. */
disk->src = oldsrc; disk->src.path = oldsrc;
disk->format = oldformat; disk->src.format = oldformat;
virStorageFileFreeMetadata(disk->backingChain); virStorageFileFreeMetadata(disk->backingChain);
disk->backingChain = oldchain; disk->backingChain = oldchain;
VIR_FREE(disk->mirror); VIR_FREE(disk->mirror);
@ -14933,7 +14938,7 @@ qemuDomainBlockJobImpl(virDomainObjPtr vm,
if (!async) { if (!async) {
int type = VIR_DOMAIN_BLOCK_JOB_TYPE_PULL; int type = VIR_DOMAIN_BLOCK_JOB_TYPE_PULL;
int status = VIR_DOMAIN_BLOCK_JOB_CANCELED; int status = VIR_DOMAIN_BLOCK_JOB_CANCELED;
event = virDomainEventBlockJobNewFromObj(vm, disk->src, type, event = virDomainEventBlockJobNewFromObj(vm, disk->src.path, type,
status); status);
} else if (!(flags & VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC)) { } else if (!(flags & VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC)) {
while (1) { while (1) {
@ -15142,7 +15147,7 @@ qemuDomainBlockCopy(virDomainObjPtr vm,
goto endjob; goto endjob;
VIR_FORCE_CLOSE(fd); VIR_FORCE_CLOSE(fd);
if (!format) if (!format)
disk->mirrorFormat = disk->format; disk->mirrorFormat = disk->src.format;
} else if (format) { } else if (format) {
disk->mirrorFormat = virStorageFileFormatTypeFromString(format); disk->mirrorFormat = virStorageFileFormatTypeFromString(format);
if (disk->mirrorFormat <= 0) { if (disk->mirrorFormat <= 0) {
@ -15302,7 +15307,7 @@ qemuDomainBlockCommit(virDomainPtr dom, const char *path, const char *base,
goto endjob; goto endjob;
disk = vm->def->disks[idx]; disk = vm->def->disks[idx];
if (!disk->src) { if (!disk->src.path) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("disk %s has no source file to be committed"), _("disk %s has no source file to be committed"),
disk->dst); disk->dst);
@ -15312,10 +15317,10 @@ qemuDomainBlockCommit(virDomainPtr dom, const char *path, const char *base,
goto endjob; goto endjob;
if (!top) { if (!top) {
top_canon = disk->src; top_canon = disk->src.path;
top_meta = disk->backingChain; top_meta = disk->backingChain;
} else if (!(top_canon = virStorageFileChainLookup(disk->backingChain, } else if (!(top_canon = virStorageFileChainLookup(disk->backingChain,
disk->src, disk->src.path,
top, &top_meta, top, &top_meta,
&top_parent))) { &top_parent))) {
virReportError(VIR_ERR_INVALID_ARG, virReportError(VIR_ERR_INVALID_ARG,
@ -15361,7 +15366,7 @@ qemuDomainBlockCommit(virDomainPtr dom, const char *path, const char *base,
clean_access = true; clean_access = true;
if (qemuDomainPrepareDiskChainElement(driver, vm, disk, base_canon, if (qemuDomainPrepareDiskChainElement(driver, vm, disk, base_canon,
VIR_DISK_CHAIN_READ_WRITE) < 0 || VIR_DISK_CHAIN_READ_WRITE) < 0 ||
(top_parent && top_parent != disk->src && (top_parent && top_parent != disk->src.path &&
qemuDomainPrepareDiskChainElement(driver, vm, disk, qemuDomainPrepareDiskChainElement(driver, vm, disk,
top_parent, top_parent,
VIR_DISK_CHAIN_READ_WRITE) < 0)) VIR_DISK_CHAIN_READ_WRITE) < 0))
@ -15383,7 +15388,7 @@ endjob:
/* Revert access to read-only, if possible. */ /* Revert access to read-only, if possible. */
qemuDomainPrepareDiskChainElement(driver, vm, disk, base_canon, qemuDomainPrepareDiskChainElement(driver, vm, disk, base_canon,
VIR_DISK_CHAIN_READ_ONLY); VIR_DISK_CHAIN_READ_ONLY);
if (top_parent && top_parent != disk->src) if (top_parent && top_parent != disk->src.path)
qemuDomainPrepareDiskChainElement(driver, vm, disk, qemuDomainPrepareDiskChainElement(driver, vm, disk,
top_parent, top_parent,
VIR_DISK_CHAIN_READ_ONLY); VIR_DISK_CHAIN_READ_ONLY);

4
src/qemu/qemu_migration.c
View File

@ -1542,8 +1542,8 @@ qemuMigrationIsSafe(virDomainDefPtr def)
return false; return false;
else if (rc == 1) else if (rc == 1)
continue; continue;
} else if (disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK && } else if (disk->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK &&
disk->protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD) { disk->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD) {
continue; continue;
} }

8
src/qemu/qemu_process.c
View File

@ -421,13 +421,13 @@ qemuProcessGetVolumeQcowPassphrase(virConnectPtr conn,
int ret = -1; int ret = -1;
virStorageEncryptionPtr enc; virStorageEncryptionPtr enc;
if (!disk->encryption) { if (!disk->src.encryption) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("disk %s does not have any encryption information"), _("disk %s does not have any encryption information"),
disk->src); disk->src.path);
return -1; return -1;
} }
enc = disk->encryption; enc = disk->src.encryption;
if (!conn) { if (!conn) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
@ -2222,7 +2222,7 @@ qemuProcessInitPasswords(virConnectPtr conn,
size_t secretLen; size_t secretLen;
const char *alias; const char *alias;
if (!vm->def->disks[i]->encryption || if (!vm->def->disks[i]->src.encryption ||
!virDomainDiskGetSource(vm->def->disks[i])) !virDomainDiskGetSource(vm->def->disks[i]))
continue; continue;

2
src/security/security_selinux.c
View File

@ -1237,7 +1237,7 @@ virSecuritySELinuxSetSecurityFileLabel(virDomainDiskDefPtr disk,
if (!disk_seclabel) if (!disk_seclabel)
return -1; return -1;
disk_seclabel->labelskip = true; 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) { disk_seclabel) < 0) {
virSecurityDeviceLabelDefFree(disk_seclabel); virSecurityDeviceLabelDefFree(disk_seclabel);
return -1; return -1;

8
src/storage/storage_driver.c
View File

@ -2791,10 +2791,10 @@ virStorageFilePtr
virStorageFileInitFromDiskDef(virDomainDiskDefPtr disk) virStorageFileInitFromDiskDef(virDomainDiskDefPtr disk)
{ {
return virStorageFileInitInternal(virDomainDiskGetActualType(disk), return virStorageFileInitInternal(virDomainDiskGetActualType(disk),
disk->src, disk->src.path,
disk->protocol, disk->src.protocol,
disk->nhosts, disk->src.nhosts,
disk->hosts); disk->src.hosts);
} }

8
tests/securityselinuxlabeltest.c
View File

@ -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 * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
@ -169,11 +169,11 @@ testSELinuxLoadDef(const char *testname)
goto cleanup; goto cleanup;
for (i = 0; i < def->ndisks; i++) { for (i = 0; i < def->ndisks; i++) {
if (def->disks[i]->type != VIR_DOMAIN_DISK_TYPE_FILE && if (def->disks[i]->src.type != VIR_DOMAIN_DISK_TYPE_FILE &&
def->disks[i]->type != VIR_DOMAIN_DISK_TYPE_BLOCK) def->disks[i]->src.type != VIR_DOMAIN_DISK_TYPE_BLOCK)
continue; continue;
if (testSELinuxMungePath(&def->disks[i]->src) < 0) if (testSELinuxMungePath(&def->disks[i]->src.path) < 0)
goto cleanup; goto cleanup;
} }