{
virDomainDiskDefPtr ret;
- ignore_value(VIR_ALLOC(ret));
+ if (VIR_ALLOC(ret) < 0)
+ return NULL;
+ if (VIR_ALLOC(ret->src) < 0)
+ VIR_FREE(ret);
return ret;
}
if (!def)
return;
- virStorageSourceClear(&def->src);
+ virStorageSourceFree(def->src);
VIR_FREE(def->serial);
VIR_FREE(def->dst);
VIR_FREE(def->mirror);
int
virDomainDiskGetType(virDomainDiskDefPtr def)
{
- return def->src.type;
+ return def->src->type;
}
void
virDomainDiskSetType(virDomainDiskDefPtr def, int type)
{
- def->src.type = type;
+ def->src->type = type;
}
const char *
virDomainDiskGetSource(virDomainDiskDefPtr def)
{
- return def->src.path;
+ return def->src->path;
}
virDomainDiskSetSource(virDomainDiskDefPtr def, const char *src)
{
int ret;
- char *tmp = def->src.path;
+ char *tmp = def->src->path;
- ret = VIR_STRDUP(def->src.path, src);
+ ret = VIR_STRDUP(def->src->path, src);
if (ret < 0)
- def->src.path = tmp;
+ def->src->path = tmp;
else
VIR_FREE(tmp);
return ret;
const char *
virDomainDiskGetDriver(virDomainDiskDefPtr def)
{
- return def->src.driverName;
+ return def->src->driverName;
}
virDomainDiskSetDriver(virDomainDiskDefPtr def, const char *name)
{
int ret;
- char *tmp = def->src.driverName;
+ char *tmp = def->src->driverName;
- ret = VIR_STRDUP(def->src.driverName, name);
+ ret = VIR_STRDUP(def->src->driverName, name);
if (ret < 0)
- def->src.driverName = tmp;
+ def->src->driverName = tmp;
else
VIR_FREE(tmp);
return ret;
int
virDomainDiskGetFormat(virDomainDiskDefPtr def)
{
- return def->src.format;
+ return def->src->format;
}
void
virDomainDiskSetFormat(virDomainDiskDefPtr def, int format)
{
- def->src.format = format;
+ def->src->format = format;
}
type = virXMLPropString(node, "type");
if (type) {
- if ((def->src.type = virStorageTypeFromString(type)) <= 0) {
+ if ((def->src->type = virStorageTypeFromString(type)) <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unknown disk type '%s'"), type);
goto error;
}
} else {
- def->src.type = VIR_STORAGE_TYPE_FILE;
+ def->src->type = VIR_STORAGE_TYPE_FILE;
}
snapshot = virXMLPropString(node, "snapshot");
cur = node->children;
while (cur != NULL) {
if (cur->type == XML_ELEMENT_NODE) {
- if (!source && !def->src.hosts && !def->src.srcpool &&
+ if (!source && !def->src->hosts && !def->src->srcpool &&
xmlStrEqual(cur->name, BAD_CAST "source")) {
sourceNode = cur;
- if (virDomainDiskSourceParse(cur, &def->src) < 0)
+ if (virDomainDiskSourceParse(cur, def->src) < 0)
goto error;
- source = def->src.path;
+ source = def->src->path;
- if (def->src.type == VIR_STORAGE_TYPE_NETWORK) {
- if (def->src.protocol == VIR_STORAGE_NET_PROTOCOL_ISCSI)
+ if (def->src->type == VIR_STORAGE_TYPE_NETWORK) {
+ if (def->src->protocol == VIR_STORAGE_NET_PROTOCOL_ISCSI)
expected_secret_usage = VIR_SECRET_USAGE_TYPE_ISCSI;
- else if (def->src.protocol == VIR_STORAGE_NET_PROTOCOL_RBD)
+ else if (def->src->protocol == VIR_STORAGE_NET_PROTOCOL_RBD)
expected_secret_usage = VIR_SECRET_USAGE_TYPE_CEPH;
}
goto error;
}
- def->src.auth.secretType = VIR_STORAGE_SECRET_TYPE_NONE;
+ def->src->auth.secretType = VIR_STORAGE_SECRET_TYPE_NONE;
child = cur->children;
while (child != NULL) {
if (child->type == XML_ELEMENT_NODE &&
}
if (authUUID != NULL) {
- def->src.auth.secretType = VIR_STORAGE_SECRET_TYPE_UUID;
+ def->src->auth.secretType = VIR_STORAGE_SECRET_TYPE_UUID;
if (virUUIDParse(authUUID,
- def->src.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->src.auth.secretType = VIR_STORAGE_SECRET_TYPE_USAGE;
- def->src.auth.secret.usage = authUsage;
+ def->src->auth.secretType = VIR_STORAGE_SECRET_TYPE_USAGE;
+ def->src->auth.secret.usage = authUsage;
authUsage = NULL;
}
}
/* 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->src.hosts == NULL && !def->src.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) {
if (sourceNode) {
xmlNodePtr saved_node = ctxt->node;
ctxt->node = sourceNode;
- if (virSecurityDeviceLabelDefParseXML(&def->src.seclabels,
- &def->src.nseclabels,
+ if (virSecurityDeviceLabelDefParseXML(&def->src->seclabels,
+ &def->src->nseclabels,
vmSeclabels,
nvmSeclabels,
ctxt,
}
if (target == NULL) {
- if (def->src.srcpool) {
+ if (def->src->srcpool) {
char *tmp;
if (virAsprintf(&tmp, "pool = '%s', volume = '%s'",
- def->src.srcpool->pool, def->src.srcpool->volume) < 0)
+ def->src->srcpool->pool, def->src->srcpool->volume) < 0)
goto error;
virReportError(VIR_ERR_NO_TARGET, "%s", tmp);
goto error;
}
- if (def->src.type == VIR_STORAGE_TYPE_NETWORK) {
+ if (def->src->type == VIR_STORAGE_TYPE_NETWORK) {
virReportError(VIR_ERR_XML_ERROR,
_("Setting disk %s is not allowed for "
"disk of network type"),
def->dst = target;
target = NULL;
- def->src.auth.username = authUsername;
+ def->src->auth.username = authUsername;
authUsername = NULL;
- def->src.driverName = driverName;
+ def->src->driverName = driverName;
driverName = NULL;
def->mirror = mirror;
mirror = NULL;
def->mirroring = mirroring;
- def->src.encryption = encryption;
+ def->src->encryption = encryption;
encryption = NULL;
def->serial = serial;
serial = NULL;
product = NULL;
if (driverType) {
- def->src.format = virStorageFileFormatTypeFromString(driverType);
- if (def->src.format <= 0) {
+ def->src->format = virStorageFileFormatTypeFromString(driverType);
+ if (def->src->format <= 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unknown driver format value '%s'"),
driverType);
&& virDomainDiskDefAssignAddress(xmlopt, def) < 0)
goto error;
- if (virDomainDiskBackingStoreParse(ctxt, &def->src) < 0)
+ if (virDomainDiskBackingStoreParse(ctxt, def->src) < 0)
goto error;
cleanup:
virDomainDiskDefPtr def,
unsigned int flags)
{
- const char *type = virStorageTypeToString(def->src.type);
+ const char *type = virStorageTypeToString(def->src->type);
const char *device = virDomainDiskDeviceTypeToString(def->device);
const char *bus = virDomainDiskBusTypeToString(def->bus);
const char *cachemode = virDomainDiskCacheTypeToString(def->cachemode);
char uuidstr[VIR_UUID_STRING_BUFLEN];
- if (!type || !def->src.type) {
+ if (!type || !def->src->type) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("unexpected disk type %d"), def->src.type);
+ _("unexpected disk type %d"), def->src->type);
return -1;
}
if (!device) {
virBufferAddLit(buf, ">\n");
virBufferAdjustIndent(buf, 2);
- if (def->src.driverName || def->src.format > 0 || def->cachemode ||
+ if (def->src->driverName || def->src->format > 0 || def->cachemode ||
def->error_policy || def->rerror_policy || def->iomode ||
def->ioeventfd || def->event_idx || def->copy_on_read ||
def->discard) {
virBufferAddLit(buf, "<driver");
- if (def->src.driverName)
- virBufferAsprintf(buf, " name='%s'", def->src.driverName);
- if (def->src.format > 0)
+ if (def->src->driverName)
+ virBufferAsprintf(buf, " name='%s'", def->src->driverName);
+ if (def->src->format > 0)
virBufferAsprintf(buf, " type='%s'",
- virStorageFileFormatTypeToString(def->src.format));
+ virStorageFileFormatTypeToString(def->src->format));
if (def->cachemode)
virBufferAsprintf(buf, " cache='%s'", cachemode);
if (def->error_policy)
virBufferAddLit(buf, "/>\n");
}
- if (def->src.auth.username) {
+ if (def->src->auth.username) {
virBufferEscapeString(buf, "<auth username='%s'>\n",
- def->src.auth.username);
+ def->src->auth.username);
virBufferAdjustIndent(buf, 2);
- if (def->src.protocol == VIR_STORAGE_NET_PROTOCOL_ISCSI) {
+ if (def->src->protocol == VIR_STORAGE_NET_PROTOCOL_ISCSI) {
virBufferAddLit(buf, "<secret type='iscsi'");
- } else if (def->src.protocol == VIR_STORAGE_NET_PROTOCOL_RBD) {
+ } else if (def->src->protocol == VIR_STORAGE_NET_PROTOCOL_RBD) {
virBufferAddLit(buf, "<secret type='ceph'");
}
- if (def->src.auth.secretType == VIR_STORAGE_SECRET_TYPE_UUID) {
- virUUIDFormat(def->src.auth.secret.uuid, uuidstr);
+ if (def->src->auth.secretType == VIR_STORAGE_SECRET_TYPE_UUID) {
+ virUUIDFormat(def->src->auth.secret.uuid, uuidstr);
virBufferAsprintf(buf, " uuid='%s'/>\n", uuidstr);
}
- if (def->src.auth.secretType == VIR_STORAGE_SECRET_TYPE_USAGE) {
+ if (def->src->auth.secretType == VIR_STORAGE_SECRET_TYPE_USAGE) {
virBufferEscapeString(buf, " usage='%s'/>\n",
- def->src.auth.secret.usage);
+ def->src->auth.secret.usage);
}
virBufferAdjustIndent(buf, -2);
virBufferAddLit(buf, "</auth>\n");
}
- if (virDomainDiskSourceFormat(buf, &def->src, def->startupPolicy,
+ if (virDomainDiskSourceFormat(buf, def->src, def->startupPolicy,
flags) < 0)
return -1;
/* Don't format backingStore to inactive XMLs until the code for
* persistent storage of backing chains is ready. */
if (!(flags & VIR_DOMAIN_XML_INACTIVE) &&
- virDomainDiskBackingStoreFormat(buf, def->src.backingStore,
- def->src.backingStoreRaw, 1) < 0)
+ virDomainDiskBackingStoreFormat(buf, def->src->backingStore,
+ def->src->backingStoreRaw, 1) < 0)
return -1;
virDomainDiskGeometryDefFormat(buf, def);
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->src.encryption &&
- virStorageEncryptionFormat(buf, def->src.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)
char *brokenRaw = NULL;
if (!ignoreOpenFailure) {
- if (virStorageFileChainGetBroken(&disk->src, &brokenRaw) < 0)
+ if (virStorageFileChainGetBroken(disk->src, &brokenRaw) < 0)
goto cleanup;
if (brokenRaw) {
}
}
- for (tmp = &disk->src; tmp; tmp = tmp->backingStore) {
+ for (tmp = disk->src; tmp; tmp = tmp->backingStore) {
int actualType = virStorageSourceGetActualType(tmp);
/* execute the callback only for local storage */
if (actualType != VIR_STORAGE_TYPE_NETWORK &&
if (def == NULL)
return NULL;
- for (i = 0; i < def->src.nseclabels; i++) {
- if (STREQ_NULLABLE(def->src.seclabels[i]->model, model))
- return def->src.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;
}
* If it's a block type source pool, then it's possible
*/
if (virDomainDiskGetType(def) == VIR_STORAGE_TYPE_VOLUME &&
- def->src.srcpool &&
- def->src.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->src.srcpool->pooltype == VIR_STORAGE_POOL_ISCSI &&
- def->src.srcpool->mode == VIR_STORAGE_SOURCE_POOL_MODE_DIRECT)
+ if (def->src->srcpool->pooltype == VIR_STORAGE_POOL_ISCSI &&
+ def->src->srcpool->mode == VIR_STORAGE_SOURCE_POOL_MODE_DIRECT)
return false;
return true;
/* Stores the virtual disk configuration */
struct _virDomainDiskDef {
- virStorageSource src;
+ virStorageSourcePtr src; /* non-NULL. XXX Allow NULL for empty cdrom? */
int device; /* enum virDomainDiskDevice */
int bus; /* enum virDomainDiskBus */
int ret = -1;
struct stat sb;
mode_t mode;
- char *tmpsrc = def->src.path;
+ char *tmpsrc = def->src->path;
if (virDomainDiskGetType(def) != VIR_STORAGE_TYPE_BLOCK) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
LXC_STATE_DIR, ctrl->def->name, def->dst) < 0)
goto cleanup;
- if (stat(def->src.path, &sb) < 0) {
+ if (stat(def->src->path, &sb) < 0) {
virReportSystemError(errno,
_("Unable to access %s"), tmpsrc);
goto cleanup;
/* Labelling normally operates on src, but we need
* to actually label the dst here, so hack the config */
- def->src.path = dst;
+ def->src->path = dst;
if (virSecurityManagerSetImageLabel(securityDriver, ctrl->def, def) < 0)
goto cleanup;
ret = 0;
cleanup:
- def->src.path = tmpsrc;
+ def->src->path = tmpsrc;
VIR_FREE(dst);
return ret;
}
switch (data->def->type) {
case VIR_DOMAIN_DEVICE_DISK: {
virDomainDiskDefPtr def = data->def->data.disk;
- char *tmpsrc = def->src.path;
- def->src.path = data->file;
+ char *tmpsrc = def->src->path;
+ def->src->path = data->file;
if (virSecurityManagerSetImageLabel(data->driver->securityManager,
data->vm->def, def) < 0) {
- def->src.path = tmpsrc;
+ def->src->path = tmpsrc;
goto cleanup;
}
- def->src.path = tmpsrc;
+ def->src->path = tmpsrc;
} break;
case VIR_DOMAIN_DEVICE_HOSTDEV: {
size_t skip;
char **parts;
- if (VIR_EXPAND_N(disk->src.hosts, disk->src.nhosts, 1) < 0)
+ if (VIR_EXPAND_N(disk->src->hosts, disk->src->nhosts, 1) < 0)
return -1;
if ((port = strchr(hostport, ']'))) {
if (port) {
*port = '\0';
port += skip;
- if (VIR_STRDUP(disk->src.hosts[disk->src.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->src.hosts[disk->src.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->src.hosts[disk->src.nhosts-1].name = virStringJoin((const char **)parts, ":");
+ disk->src->hosts[disk->src->nhosts-1].name = virStringJoin((const char **)parts, ":");
virStringFreeList(parts);
- if (!disk->src.hosts[disk->src.nhosts-1].name)
+ if (!disk->src->hosts[disk->src->nhosts-1].name)
goto error;
- disk->src.hosts[disk->src.nhosts-1].transport = VIR_STORAGE_NET_HOST_TRANS_TCP;
- disk->src.hosts[disk->src.nhosts-1].socket = NULL;
+ disk->src->hosts[disk->src->nhosts-1].transport = VIR_STORAGE_NET_HOST_TRANS_TCP;
+ disk->src->hosts[disk->src->nhosts-1].socket = NULL;
return 0;
error:
- VIR_FREE(disk->src.hosts[disk->src.nhosts-1].port);
- VIR_FREE(disk->src.hosts[disk->src.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;
}
char *options = NULL;
char *p, *e, *next;
- p = strchr(disk->src.path, ':');
+ p = strchr(disk->src->path, ':');
if (p) {
if (VIR_STRDUP(options, p + 1) < 0)
goto error;
}
if (STRPREFIX(p, "id=") &&
- VIR_STRDUP(disk->src.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;
char *volimg = NULL;
char *secret = NULL;
- if (VIR_ALLOC(def->src.hosts) < 0)
+ if (VIR_ALLOC(def->src->hosts) < 0)
goto error;
transp = strchr(uri->scheme, '+');
}
if (!transp) {
- def->src.hosts->transport = VIR_STORAGE_NET_HOST_TRANS_TCP;
+ def->src->hosts->transport = VIR_STORAGE_NET_HOST_TRANS_TCP;
} else {
- def->src.hosts->transport = virStorageNetHostTransportTypeFromString(transp);
- if (def->src.hosts->transport < 0) {
+ def->src->hosts->transport = virStorageNetHostTransportTypeFromString(transp);
+ if (def->src->hosts->transport < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Invalid %s transport type '%s'"), scheme, transp);
goto error;
}
}
- def->src.nhosts = 0; /* set to 1 once everything succeeds */
+ def->src->nhosts = 0; /* set to 1 once everything succeeds */
- if (def->src.hosts->transport != VIR_STORAGE_NET_HOST_TRANS_UNIX) {
- if (VIR_STRDUP(def->src.hosts->name, uri->server) < 0)
+ if (def->src->hosts->transport != VIR_STORAGE_NET_HOST_TRANS_UNIX) {
+ if (VIR_STRDUP(def->src->hosts->name, uri->server) < 0)
goto error;
- if (virAsprintf(&def->src.hosts->port, "%d", uri->port) < 0)
+ if (virAsprintf(&def->src->hosts->port, "%d", uri->port) < 0)
goto error;
} else {
- def->src.hosts->name = NULL;
- def->src.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->src.hosts->socket, sock) < 0)
+ if (VIR_STRDUP(def->src->hosts->socket, sock) < 0)
goto error;
} else {
virReportError(VIR_ERR_INTERNAL_ERROR,
}
if (uri->path) {
volimg = uri->path + 1; /* skip the prefix slash */
- VIR_FREE(def->src.path);
- if (VIR_STRDUP(def->src.path, volimg) < 0)
+ VIR_FREE(def->src->path);
+ if (VIR_STRDUP(def->src->path, volimg) < 0)
goto error;
} else {
- VIR_FREE(def->src.path);
+ VIR_FREE(def->src->path);
}
if (uri->user) {
if (secret)
*secret = '\0';
- if (VIR_STRDUP(def->src.auth.username, uri->user) < 0)
+ if (VIR_STRDUP(def->src->auth.username, uri->user) < 0)
goto error;
}
- def->src.nhosts = 1;
+ def->src->nhosts = 1;
ret = 0;
cleanup:
return ret;
error:
- virStorageNetHostDefClear(def->src.hosts);
- VIR_FREE(def->src.hosts);
+ virStorageNetHostDefClear(def->src->hosts);
+ VIR_FREE(def->src->hosts);
goto cleanup;
}
{
virURIPtr uri = NULL;
- if (!(uri = virURIParse(def->src.path)))
+ if (!(uri = virURIParse(def->src->path)))
return -1;
return qemuParseDriveURIString(def, uri, "gluster");
char *slash;
unsigned lun;
- if (!(uri = virURIParse(def->src.path)))
+ if (!(uri = virURIParse(def->src->path)))
return -1;
if (uri->path &&
else if (virStrToLong_ui(slash + 1, NULL, 10, &lun) == -1) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("invalid name '%s' for iSCSI disk"),
- def->src.path);
+ def->src->path);
return -1;
}
}
virURIPtr uri = NULL;
- if (strstr(disk->src.path, "://")) {
- if (!(uri = virURIParse(disk->src.path)))
+ if (strstr(disk->src->path, "://")) {
+ if (!(uri = virURIParse(disk->src->path)))
return -1;
return qemuParseDriveURIString(disk, uri, "nbd");
}
if (VIR_ALLOC(h) < 0)
goto error;
- host = disk->src.path + strlen("nbd:");
+ host = disk->src->path + strlen("nbd:");
if (STRPREFIX(host, "unix:/")) {
src = strchr(host + strlen("unix:"), ':');
if (src)
port = strchr(host, ':');
if (!port) {
virReportError(VIR_ERR_INTERNAL_ERROR,
- _("cannot parse nbd filename '%s'"), disk->src.path);
+ _("cannot parse nbd filename '%s'"), disk->src->path);
goto error;
}
src = NULL;
}
- VIR_FREE(disk->src.path);
- disk->src.path = src;
- disk->src.nhosts = 1;
- disk->src.hosts = h;
+ VIR_FREE(disk->src->path);
+ disk->src->path = src;
+ disk->src->nhosts = 1;
+ disk->src->hosts = h;
return 0;
error:
int idx = virDiskNameToIndex(disk->dst);
int busid = -1, unitid = -1;
char *source = NULL;
- int actualType = virStorageSourceGetActualType(&disk->src);
+ int actualType = virStorageSourceGetActualType(disk->src);
if (idx < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
break;
}
- if (qemuGetDriveSourceString(&disk->src, conn, &source) < 0)
+ if (qemuGetDriveSourceString(disk->src, conn, &source) < 0)
goto error;
if (source &&
switch (actualType) {
case VIR_STORAGE_TYPE_DIR:
/* QEMU only supports magic FAT format for now */
- if (disk->src.format > 0 &&
- disk->src.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->src.format));
+ virStorageFileFormatTypeToString(disk->src->format));
goto error;
}
case VIR_STORAGE_TYPE_BLOCK:
if (disk->tray_status == VIR_DOMAIN_DISK_TRAY_OPEN) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
- disk->src.type == VIR_STORAGE_TYPE_VOLUME ?
+ disk->src->type == VIR_STORAGE_TYPE_VOLUME ?
_("tray status 'open' is invalid for block type volume") :
_("tray status 'open' is invalid for block type disk"));
goto error;
_("transient disks not supported yet"));
goto error;
}
- if (disk->src.format > 0 &&
- disk->src.type != VIR_STORAGE_TYPE_DIR &&
+ if (disk->src->format > 0 &&
+ disk->src->type != VIR_STORAGE_TYPE_DIR &&
virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_FORMAT))
virBufferAsprintf(&opt, ",format=%s",
- virStorageFileFormatTypeToString(disk->src.format));
+ virStorageFileFormatTypeToString(disk->src->format));
/* generate geometry command string */
if (disk->geometry.cylinders > 0 &&
bus);
goto error;
}
- if (disk->src.type == VIR_STORAGE_TYPE_NETWORK) {
- if (disk->src.protocol != VIR_STORAGE_NET_PROTOCOL_ISCSI) {
+ if (disk->src->type == VIR_STORAGE_TYPE_NETWORK) {
+ if (disk->src->protocol != VIR_STORAGE_NET_PROTOCOL_ISCSI) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("disk device='lun' is not supported for protocol='%s'"),
- virStorageNetProtocolTypeToString(disk->src.protocol));
+ virStorageNetProtocolTypeToString(disk->src->protocol));
goto error;
}
} else if (!virDomainDiskSourceIsBlockType(disk)) {
for (i = 0; i < def->ndisks; i++) {
virDomainDiskDefPtr disk = def->disks[i];
- if (disk->src.driverName != NULL &&
- !STREQ(disk->src.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->src.driverName, disk->src.path);
+ disk->src->driverName, disk->src->path);
goto error;
}
}
!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
virCommandAddArg(cmd, "-usbdevice");
- virCommandAddArgFormat(cmd, "disk:%s", disk->src.path);
+ virCommandAddArgFormat(cmd, "disk:%s", disk->src->path);
} else {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unsupported usb disk type for '%s'"),
- disk->src.path);
+ disk->src->path);
goto error;
}
continue;
const char *fmt;
virDomainDiskDefPtr disk = def->disks[i];
- if ((disk->src.type == VIR_STORAGE_TYPE_BLOCK) &&
+ if ((disk->src->type == VIR_STORAGE_TYPE_BLOCK) &&
(disk->tray_status == VIR_DOMAIN_DISK_TRAY_OPEN)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("tray status 'open' is invalid for "
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.path);
+ virCommandAddArgFormat(cmd, "disk:%s", disk->src->path);
} else {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unsupported usb disk type for '%s'"),
- disk->src.path);
+ disk->src->path);
goto error;
}
continue;
if (STREQ(disk->dst, "hdc") &&
disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
- if (disk->src.path) {
+ if (disk->src->path) {
snprintf(dev, NAME_MAX, "-%s", "cdrom");
} else {
continue;
}
}
- if (disk->src.type == VIR_STORAGE_TYPE_DIR) {
+ if (disk->src->type == VIR_STORAGE_TYPE_DIR) {
/* QEMU only supports magic FAT format for now */
- if (disk->src.format > 0 &&
- disk->src.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->src.format));
+ virStorageFileFormatTypeToString(disk->src->format));
goto error;
}
if (!disk->readonly) {
if (virAsprintf(&file, fmt, disk->src) < 0)
goto error;
- } else if (disk->src.type == VIR_STORAGE_TYPE_NETWORK) {
+ } else if (disk->src->type == VIR_STORAGE_TYPE_NETWORK) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("network disks are only supported with -drive"));
goto error;
} else {
- if (VIR_STRDUP(file, disk->src.path) < 0) {
+ if (VIR_STRDUP(file, disk->src->path) < 0) {
goto error;
}
}
if (VIR_ALLOC(def) < 0)
goto cleanup;
+ if (VIR_ALLOC(def->src) < 0)
+ goto error;
if (((dom->os.arch == VIR_ARCH_PPC64) &&
dom->os.machine && STREQ(dom->os.machine, "pseries")))
else
def->bus = VIR_DOMAIN_DISK_BUS_IDE;
def->device = VIR_DOMAIN_DISK_DEVICE_DISK;
- def->src.type = VIR_STORAGE_TYPE_FILE;
+ def->src->type = VIR_STORAGE_TYPE_FILE;
for (i = 0; i < nkeywords; i++) {
if (STREQ(keywords[i], "file")) {
if (values[i] && STRNEQ(values[i], "")) {
- def->src.path = values[i];
+ def->src->path = values[i];
values[i] = NULL;
- if (STRPREFIX(def->src.path, "/dev/"))
- def->src.type = VIR_STORAGE_TYPE_BLOCK;
- else if (STRPREFIX(def->src.path, "nbd:") ||
- STRPREFIX(def->src.path, "nbd+")) {
- def->src.type = VIR_STORAGE_TYPE_NETWORK;
- def->src.protocol = VIR_STORAGE_NET_PROTOCOL_NBD;
+ if (STRPREFIX(def->src->path, "/dev/"))
+ def->src->type = VIR_STORAGE_TYPE_BLOCK;
+ else if (STRPREFIX(def->src->path, "nbd:") ||
+ STRPREFIX(def->src->path, "nbd+")) {
+ def->src->type = VIR_STORAGE_TYPE_NETWORK;
+ def->src->protocol = VIR_STORAGE_NET_PROTOCOL_NBD;
if (qemuParseNBDString(def) < 0)
goto error;
- } else if (STRPREFIX(def->src.path, "rbd:")) {
- char *p = def->src.path;
+ } else if (STRPREFIX(def->src->path, "rbd:")) {
+ char *p = def->src->path;
- def->src.type = VIR_STORAGE_TYPE_NETWORK;
- def->src.protocol = VIR_STORAGE_NET_PROTOCOL_RBD;
- if (VIR_STRDUP(def->src.path, p + strlen("rbd:")) < 0)
+ def->src->type = VIR_STORAGE_TYPE_NETWORK;
+ def->src->protocol = VIR_STORAGE_NET_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) {
}
VIR_FREE(p);
- } else if (STRPREFIX(def->src.path, "gluster:") ||
- STRPREFIX(def->src.path, "gluster+")) {
- def->src.type = VIR_STORAGE_TYPE_NETWORK;
- def->src.protocol = VIR_STORAGE_NET_PROTOCOL_GLUSTER;
+ } else if (STRPREFIX(def->src->path, "gluster:") ||
+ STRPREFIX(def->src->path, "gluster+")) {
+ def->src->type = VIR_STORAGE_TYPE_NETWORK;
+ def->src->protocol = VIR_STORAGE_NET_PROTOCOL_GLUSTER;
if (qemuParseGlusterString(def) < 0)
goto error;
- } else if (STRPREFIX(def->src.path, "iscsi:")) {
- def->src.type = VIR_STORAGE_TYPE_NETWORK;
- def->src.protocol = VIR_STORAGE_NET_PROTOCOL_ISCSI;
+ } else if (STRPREFIX(def->src->path, "iscsi:")) {
+ def->src->type = VIR_STORAGE_TYPE_NETWORK;
+ def->src->protocol = VIR_STORAGE_NET_PROTOCOL_ISCSI;
if (qemuParseISCSIString(def) < 0)
goto error;
- } else if (STRPREFIX(def->src.path, "sheepdog:")) {
- char *p = def->src.path;
+ } else if (STRPREFIX(def->src->path, "sheepdog:")) {
+ char *p = def->src->path;
char *port, *vdi;
- def->src.type = VIR_STORAGE_TYPE_NETWORK;
- def->src.protocol = VIR_STORAGE_NET_PROTOCOL_SHEEPDOG;
- if (VIR_STRDUP(def->src.path, p + strlen("sheepdog:")) < 0)
+ def->src->type = VIR_STORAGE_TYPE_NETWORK;
+ def->src->protocol = VIR_STORAGE_NET_PROTOCOL_SHEEPDOG;
+ if (VIR_STRDUP(def->src->path, p + strlen("sheepdog:")) < 0)
goto error;
VIR_FREE(p);
- /* def->src.path must be [vdiname] or [host]:[port]:[vdiname] */
- port = strchr(def->src.path, ':');
+ /* def->src->path must be [vdiname] or [host]:[port]:[vdiname] */
+ port = strchr(def->src->path, ':');
if (port) {
*port = '\0';
vdi = strchr(port + 1, ':');
*port = ':';
virReportError(VIR_ERR_INTERNAL_ERROR,
_("cannot parse sheepdog filename '%s'"),
- def->src.path);
+ def->src->path);
goto error;
}
port++;
*vdi++ = '\0';
- if (VIR_ALLOC(def->src.hosts) < 0)
+ if (VIR_ALLOC(def->src->hosts) < 0)
goto error;
- def->src.nhosts = 1;
- def->src.hosts->name = def->src.path;
- if (VIR_STRDUP(def->src.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->src.hosts->transport = VIR_STORAGE_NET_HOST_TRANS_TCP;
- def->src.hosts->socket = NULL;
- if (VIR_STRDUP(def->src.path, vdi) < 0)
+ def->src->hosts->transport = VIR_STORAGE_NET_HOST_TRANS_TCP;
+ def->src->hosts->socket = NULL;
+ if (VIR_STRDUP(def->src->path, vdi) < 0)
goto error;
}
} else
- def->src.type = VIR_STORAGE_TYPE_FILE;
+ def->src->type = VIR_STORAGE_TYPE_FILE;
} else {
- def->src.type = VIR_STORAGE_TYPE_FILE;
+ def->src->type = VIR_STORAGE_TYPE_FILE;
}
} else if (STREQ(keywords[i], "if")) {
if (STREQ(values[i], "ide")) {
} else if (STREQ(values[i], "floppy"))
def->device = VIR_DOMAIN_DISK_DEVICE_FLOPPY;
} else if (STREQ(keywords[i], "format")) {
- if (VIR_STRDUP(def->src.driverName, "qemu") < 0)
+ if (VIR_STRDUP(def->src->driverName, "qemu") < 0)
goto error;
- def->src.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"))
if (def->rerror_policy == def->error_policy)
def->rerror_policy = 0;
- if (!def->src.path &&
+ if (!def->src->path &&
def->device == VIR_DOMAIN_DISK_DEVICE_DISK &&
- def->src.type != VIR_STORAGE_TYPE_NETWORK) {
+ def->src->type != VIR_STORAGE_TYPE_NETWORK) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("missing file parameter in drive '%s'"), val);
goto error;
goto error;
if (STRPREFIX(val, "/dev/"))
- disk->src.type = VIR_STORAGE_TYPE_BLOCK;
+ disk->src->type = VIR_STORAGE_TYPE_BLOCK;
else if (STRPREFIX(val, "nbd:")) {
- disk->src.type = VIR_STORAGE_TYPE_NETWORK;
- disk->src.protocol = VIR_STORAGE_NET_PROTOCOL_NBD;
+ disk->src->type = VIR_STORAGE_TYPE_NETWORK;
+ disk->src->protocol = VIR_STORAGE_NET_PROTOCOL_NBD;
} else if (STRPREFIX(val, "rbd:")) {
- disk->src.type = VIR_STORAGE_TYPE_NETWORK;
- disk->src.protocol = VIR_STORAGE_NET_PROTOCOL_RBD;
+ disk->src->type = VIR_STORAGE_TYPE_NETWORK;
+ disk->src->protocol = VIR_STORAGE_NET_PROTOCOL_RBD;
val += strlen("rbd:");
} else if (STRPREFIX(val, "gluster")) {
- disk->src.type = VIR_STORAGE_TYPE_NETWORK;
- disk->src.protocol = VIR_STORAGE_NET_PROTOCOL_GLUSTER;
+ disk->src->type = VIR_STORAGE_TYPE_NETWORK;
+ disk->src->protocol = VIR_STORAGE_NET_PROTOCOL_GLUSTER;
} else if (STRPREFIX(val, "sheepdog:")) {
- disk->src.type = VIR_STORAGE_TYPE_NETWORK;
- disk->src.protocol = VIR_STORAGE_NET_PROTOCOL_SHEEPDOG;
+ disk->src->type = VIR_STORAGE_TYPE_NETWORK;
+ disk->src->protocol = VIR_STORAGE_NET_PROTOCOL_SHEEPDOG;
val += strlen("sheepdog:");
} else
- disk->src.type = VIR_STORAGE_TYPE_FILE;
+ disk->src->type = VIR_STORAGE_TYPE_FILE;
if (STREQ(arg, "-cdrom")) {
disk->device = VIR_DOMAIN_DISK_DEVICE_CDROM;
if (((def->os.arch == VIR_ARCH_PPC64) &&
if (VIR_STRDUP(disk->dst, arg + 1) < 0)
goto error;
}
- if (VIR_STRDUP(disk->src.path, val) < 0)
+ if (VIR_STRDUP(disk->src->path, val) < 0)
goto error;
- if (disk->src.type == VIR_STORAGE_TYPE_NETWORK) {
+ if (disk->src->type == VIR_STORAGE_TYPE_NETWORK) {
char *port;
- switch ((virStorageNetProtocol) disk->src.protocol) {
+ switch ((virStorageNetProtocol) disk->src->protocol) {
case VIR_STORAGE_NET_PROTOCOL_NBD:
if (qemuParseNBDString(disk) < 0)
goto error;
break;
case VIR_STORAGE_NET_PROTOCOL_SHEEPDOG:
/* disk->src must be [vdiname] or [host]:[port]:[vdiname] */
- port = strchr(disk->src.path, ':');
+ port = strchr(disk->src->path, ':');
if (port) {
char *vdi;
goto error;
}
*vdi++ = '\0';
- if (VIR_ALLOC(disk->src.hosts) < 0)
+ if (VIR_ALLOC(disk->src->hosts) < 0)
goto error;
- disk->src.nhosts = 1;
- disk->src.hosts->name = disk->src.path;
- if (VIR_STRDUP(disk->src.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.path, vdi) < 0)
+ if (VIR_STRDUP(disk->src->path, vdi) < 0)
goto error;
}
break;
} else if (STRPREFIX(val, "disk:")) {
if (!(disk = virDomainDiskDefNew()))
goto error;
- if (VIR_STRDUP(disk->src.path, val + strlen("disk:")) < 0)
+ if (VIR_STRDUP(disk->src->path, val + strlen("disk:")) < 0)
goto error;
- if (STRPREFIX(disk->src.path, "/dev/"))
- disk->src.type = VIR_STORAGE_TYPE_BLOCK;
+ if (STRPREFIX(disk->src->path, "/dev/"))
+ disk->src->type = VIR_STORAGE_TYPE_BLOCK;
else
- disk->src.type = VIR_STORAGE_TYPE_FILE;
+ disk->src->type = VIR_STORAGE_TYPE_FILE;
disk->device = VIR_DOMAIN_DISK_DEVICE_DISK;
disk->bus = VIR_DOMAIN_DISK_BUS_USB;
disk->removable = VIR_DOMAIN_FEATURE_STATE_DEFAULT;
char *hosts, *port, *saveptr = NULL, *token;
virDomainDiskDefPtr first_rbd_disk = NULL;
for (i = 0; i < def->ndisks; i++) {
- if (def->disks[i]->src.type == VIR_STORAGE_TYPE_NETWORK &&
- def->disks[i]->src.protocol == VIR_STORAGE_NET_PROTOCOL_RBD) {
+ if (def->disks[i]->src->type == VIR_STORAGE_TYPE_NETWORK &&
+ def->disks[i]->src->protocol == VIR_STORAGE_NET_PROTOCOL_RBD) {
first_rbd_disk = def->disks[i];
break;
}
}
if (VIR_STRDUP(hosts, strchr(ceph_args, ' ') + 1) < 0)
goto error;
- first_rbd_disk->src.nhosts = 0;
+ first_rbd_disk->src->nhosts = 0;
token = strtok_r(hosts, ",", &saveptr);
while (token != NULL) {
- if (VIR_REALLOC_N(first_rbd_disk->src.hosts,
- first_rbd_disk->src.nhosts + 1) < 0) {
+ if (VIR_REALLOC_N(first_rbd_disk->src->hosts,
+ first_rbd_disk->src->nhosts + 1) < 0) {
VIR_FREE(hosts);
goto error;
}
goto error;
}
}
- 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,
+ 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->src.hosts[first_rbd_disk->src.nhosts].transport = VIR_STORAGE_NET_HOST_TRANS_TCP;
- first_rbd_disk->src.hosts[first_rbd_disk->src.nhosts].socket = NULL;
+ first_rbd_disk->src->hosts[first_rbd_disk->src->nhosts].transport = VIR_STORAGE_NET_HOST_TRANS_TCP;
+ first_rbd_disk->src->hosts[first_rbd_disk->src->nhosts].socket = NULL;
- first_rbd_disk->src.nhosts++;
+ first_rbd_disk->src->nhosts++;
token = strtok_r(NULL, ",", &saveptr);
}
VIR_FREE(hosts);
- if (first_rbd_disk->src.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;
virReportError(VIR_ERR_OPERATION_INVALID,
_("sgio of shared disk 'pool=%s' 'volume=%s' conflicts "
"with other active domains"),
- disk->src.srcpool->pool,
- disk->src.srcpool->volume);
+ disk->src->srcpool->pool,
+ disk->src->srcpool->volume);
} else {
virReportError(VIR_ERR_OPERATION_INVALID,
_("sgio of shared disk '%s' conflicts with other "
}
/* iscsi pool only supports one host */
- def->src.nhosts = 1;
+ def->src->nhosts = 1;
- if (VIR_ALLOC_N(def->src.hosts, def->src.nhosts) < 0)
+ if (VIR_ALLOC_N(def->src->hosts, def->src->nhosts) < 0)
goto cleanup;
- if (VIR_STRDUP(def->src.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->src.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->src.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->src.srcpool->volume);
+ def->src->srcpool->volume);
goto cleanup;
}
/* iscsi pool has only one source device path */
- if (virAsprintf(&def->src.path, "%s/%s",
+ if (virAsprintf(&def->src->path, "%s/%s",
pooldef->source.devices[0].path,
tokens[3]) < 0)
goto cleanup;
/* Storage pool have not supported these 2 attributes yet,
* use the defaults.
*/
- def->src.hosts[0].transport = VIR_STORAGE_NET_HOST_TRANS_TCP;
- def->src.hosts[0].socket = NULL;
+ def->src->hosts[0].transport = VIR_STORAGE_NET_HOST_TRANS_TCP;
+ def->src->hosts[0].socket = NULL;
- def->src.protocol = VIR_STORAGE_NET_PROTOCOL_ISCSI;
+ def->src->protocol = VIR_STORAGE_NET_PROTOCOL_ISCSI;
ret = 0;
* into the virDomainDiskDef
*/
if (pooldef->source.authType == VIR_STORAGE_POOL_AUTH_CHAP) {
- if (VIR_STRDUP(def->src.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->src.auth.secretType = VIR_STORAGE_SECRET_TYPE_UUID;
- memcpy(def->src.auth.secret.uuid,
+ def->src->auth.secretType = VIR_STORAGE_SECRET_TYPE_UUID;
+ memcpy(def->src->auth.secret.uuid,
pooldef->source.auth.chap.secret.uuid,
VIR_UUID_BUFLEN);
} else {
- if (VIR_STRDUP(def->src.auth.secret.usage,
+ if (VIR_STRDUP(def->src->auth.secret.usage,
pooldef->source.auth.chap.secret.usage) < 0)
goto cleanup;
- def->src.auth.secretType = VIR_STORAGE_SECRET_TYPE_USAGE;
+ def->src->auth.secretType = VIR_STORAGE_SECRET_TYPE_USAGE;
}
} else if (pooldef->source.authType == VIR_STORAGE_POOL_AUTH_CEPHX) {
- if (VIR_STRDUP(def->src.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->src.auth.secretType = VIR_STORAGE_SECRET_TYPE_UUID;
- memcpy(def->src.auth.secret.uuid,
+ def->src->auth.secretType = VIR_STORAGE_SECRET_TYPE_UUID;
+ memcpy(def->src->auth.secret.uuid,
pooldef->source.auth.cephx.secret.uuid,
VIR_UUID_BUFLEN);
} else {
- if (VIR_STRDUP(def->src.auth.secret.usage,
+ if (VIR_STRDUP(def->src->auth.secret.usage,
pooldef->source.auth.cephx.secret.usage) < 0)
goto cleanup;
- def->src.auth.secretType = VIR_STORAGE_SECRET_TYPE_USAGE;
+ def->src->auth.secretType = VIR_STORAGE_SECRET_TYPE_USAGE;
}
}
ret = 0;
int ret = -1;
virErrorPtr savedError = NULL;
- if (def->src.type != VIR_STORAGE_TYPE_VOLUME)
+ if (def->src->type != VIR_STORAGE_TYPE_VOLUME)
return 0;
- if (!def->src.srcpool)
+ if (!def->src->srcpool)
return 0;
- if (!(pool = virStoragePoolLookupByName(conn, def->src.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->src.srcpool->pool, def->src.srcpool->volume);
+ def->src->srcpool->pool, def->src->srcpool->volume);
goto cleanup;
}
- if (!(vol = virStorageVolLookupByName(pool, def->src.srcpool->volume)))
+ if (!(vol = virStorageVolLookupByName(pool, def->src->srcpool->volume)))
goto cleanup;
if (virStorageVolGetInfo(vol, &info) < 0)
if (!(pooldef = virStoragePoolDefParseString(poolxml)))
goto cleanup;
- def->src.srcpool->pooltype = pooldef->type;
- def->src.srcpool->voltype = info.type;
+ def->src->srcpool->pooltype = pooldef->type;
+ def->src->srcpool->voltype = info.type;
- if (def->src.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.path);
- virStorageNetHostDefFree(def->src.nhosts, def->src.hosts);
- virStorageSourceAuthClear(&def->src);
+ VIR_FREE(def->src->path);
+ virStorageNetHostDefFree(def->src->nhosts, def->src->hosts);
+ virStorageSourceAuthClear(def->src);
switch ((virStoragePoolType) pooldef->type) {
case VIR_STORAGE_POOL_DIR:
case VIR_STORAGE_POOL_LOGICAL:
case VIR_STORAGE_POOL_DISK:
case VIR_STORAGE_POOL_SCSI:
- if (!(def->src.path = virStorageVolGetPath(vol)))
+ if (!(def->src->path = virStorageVolGetPath(vol)))
goto cleanup;
if (def->startupPolicy && info.type != VIR_STORAGE_VOL_FILE) {
switch (info.type) {
case VIR_STORAGE_VOL_FILE:
- def->src.srcpool->actualtype = VIR_STORAGE_TYPE_FILE;
+ def->src->srcpool->actualtype = VIR_STORAGE_TYPE_FILE;
break;
case VIR_STORAGE_VOL_DIR:
- def->src.srcpool->actualtype = VIR_STORAGE_TYPE_DIR;
+ def->src->srcpool->actualtype = VIR_STORAGE_TYPE_DIR;
break;
case VIR_STORAGE_VOL_BLOCK:
- def->src.srcpool->actualtype = VIR_STORAGE_TYPE_BLOCK;
+ def->src->srcpool->actualtype = VIR_STORAGE_TYPE_BLOCK;
break;
case VIR_STORAGE_VOL_NETWORK:
goto cleanup;
}
- switch (def->src.srcpool->mode) {
+ switch (def->src->srcpool->mode) {
case VIR_STORAGE_SOURCE_POOL_MODE_DEFAULT:
case VIR_STORAGE_SOURCE_POOL_MODE_LAST:
- def->src.srcpool->mode = VIR_STORAGE_SOURCE_POOL_MODE_HOST;
+ def->src->srcpool->mode = VIR_STORAGE_SOURCE_POOL_MODE_HOST;
/* fallthrough */
case VIR_STORAGE_SOURCE_POOL_MODE_HOST:
- def->src.srcpool->actualtype = VIR_STORAGE_TYPE_BLOCK;
- if (!(def->src.path = virStorageVolGetPath(vol)))
+ def->src->srcpool->actualtype = VIR_STORAGE_TYPE_BLOCK;
+ if (!(def->src->path = virStorageVolGetPath(vol)))
goto cleanup;
break;
case VIR_STORAGE_SOURCE_POOL_MODE_DIRECT:
- def->src.srcpool->actualtype = VIR_STORAGE_TYPE_NETWORK;
- def->src.protocol = VIR_STORAGE_NET_PROTOCOL_ISCSI;
+ def->src->srcpool->actualtype = VIR_STORAGE_TYPE_NETWORK;
+ def->src->protocol = VIR_STORAGE_NET_PROTOCOL_ISCSI;
if (qemuTranslateDiskSourcePoolAuth(def, pooldef) < 0)
goto cleanup;
if (!virDomainDiskGetSource(disk))
return 0;
- if (virStorageFileChainGetBroken(&disk->src, &brokenFile) < 0)
+ if (virStorageFileChainGetBroken(disk->src, &brokenFile) < 0)
return -1;
if (brokenFile) {
virDomainDiskDefPtr disk = vm->def->disks[idx];
const char *path = virDomainDiskGetSource(disk);
virStorageFileFormat format = virDomainDiskGetFormat(disk);
- virStorageType type = virStorageSourceGetActualType(&disk->src);
+ virStorageType type = virStorageSourceGetActualType(disk->src);
if (!path)
continue;
int ret = 0;
uid_t uid;
gid_t gid;
- int type = virStorageSourceGetActualType(&disk->src);
+ int type = virStorageSourceGetActualType(disk->src);
if (type != VIR_STORAGE_TYPE_NETWORK &&
- !disk->src.path)
+ !disk->src->path)
goto cleanup;
- if (disk->src.backingStore) {
+ if (disk->src->backingStore) {
if (force)
- virStorageSourceClearBackingStore(&disk->src);
+ virStorageSourceClearBackingStore(disk->src);
else
goto cleanup;
}
qemuDomainGetImageIds(cfg, vm, disk, &uid, &gid);
- if (virStorageFileGetMetadata(&disk->src,
+ if (virStorageFileGetMetadata(disk->src,
uid, gid,
cfg->allowDiskFormatProbing) < 0)
ret = -1;
* Update 'orig'
* We allow updating src/type//driverType/cachemode/
*/
- VIR_FREE(orig->src.path);
- orig->src.path = disk->src.path;
- orig->src.type = disk->src.type;
+ VIR_FREE(orig->src->path);
+ orig->src->path = disk->src->path;
+ orig->src->type = disk->src->type;
orig->cachemode = disk->cachemode;
- if (disk->src.driverName) {
- VIR_FREE(orig->src.driverName);
- orig->src.driverName = disk->src.driverName;
- disk->src.driverName = NULL;
+ if (disk->src->driverName) {
+ VIR_FREE(orig->src->driverName);
+ orig->src->driverName = disk->src->driverName;
+ disk->src->driverName = NULL;
}
- if (disk->src.format)
- orig->src.format = disk->src.format;
- disk->src.path = NULL;
+ if (disk->src->format)
+ orig->src->format = disk->src->format;
+ disk->src->path = NULL;
break;
case VIR_DOMAIN_DEVICE_NET:
/* qcow2 and qed must be sized on 512 byte blocks/sectors,
* so adjust size if necessary to round up.
*/
- if (disk->src.format == VIR_STORAGE_FILE_QCOW2 ||
- disk->src.format == VIR_STORAGE_FILE_QED)
+ if (disk->src->format == VIR_STORAGE_FILE_QCOW2 ||
+ disk->src->format == VIR_STORAGE_FILE_QED)
size = VIR_ROUND_UP(size, 512);
if (virAsprintf(&device, "%s%s", QEMU_DRIVE_HOST_PREFIX,
int ret = -1;
/* XXX Labelling of non-local files isn't currently supported */
- if (virStorageSourceGetActualType(&disk->src) == VIR_STORAGE_TYPE_NETWORK)
+ if (virStorageSourceGetActualType(disk->src) == VIR_STORAGE_TYPE_NETWORK)
return 0;
cfg = virQEMUDriverGetConfig(driver);
- /* XXX This would be easier when disk->src will be a pointer */
- memcpy(&origdisk, &disk->src, sizeof(origdisk));
- memcpy(&disk->src, elem, sizeof(*elem));
+ /* XXX Need to refactor the security manager and lock daemon to
+ * operate directly on a virStorageSourcePtr plus tidbits rather
+ * than a full virDomainDiskDef. */
+ memcpy(&origdisk, disk->src, sizeof(origdisk));
+ memcpy(disk->src, elem, sizeof(*elem));
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.path);
+ 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.path);
+ disk->src->path);
if (virDomainLockDiskDetach(driver->lockManager, vm, disk) < 0)
- VIR_WARN("Unable to release lock on %s", disk->src.path);
+ 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 ||
ret = 0;
cleanup:
- memcpy(&disk->src, &origdisk, sizeof(origdisk));
+ memcpy(disk->src, &origdisk, sizeof(origdisk));
disk->readonly = origreadonly;
virObjectUnref(cfg);
return ret;
NULL)))
goto cleanup;
- if (defdisk->src.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.path,
- virStorageFileFormatTypeToString(defdisk->src.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.path);
+ defdisk->src->path);
goto cleanup;
}
/* adds cmd line arg: backing_file=/path/to/backing/file */
- virCommandAddArgFormat(cmd, "backing_file=%s", defdisk->src.path);
+ virCommandAddArgFormat(cmd, "backing_file=%s", defdisk->src->path);
}
/* adds cmd line args: /path/to/target/file */
defdisk = vm->def->disks[snapdisk->index];
if (snapdisk->snapshot == VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL) {
- VIR_FREE(defdisk->src.path);
- if (VIR_STRDUP(defdisk->src.path, snapdisk->src->path) < 0) {
+ VIR_FREE(defdisk->src->path);
+ if (VIR_STRDUP(defdisk->src->path, snapdisk->src->path) < 0) {
/* we cannot rollback here in a sane way */
goto cleanup;
}
- defdisk->src.format = snapdisk->src->format;
+ defdisk->src->format = snapdisk->src->format;
}
}
static int
qemuDomainSnapshotPrepareDiskExternalBackingInactive(virDomainDiskDefPtr disk)
{
- int actualType = virStorageSourceGetActualType(&disk->src);
+ int actualType = virStorageSourceGetActualType(disk->src);
switch ((virStorageType) actualType) {
case VIR_STORAGE_TYPE_BLOCK:
return 0;
case VIR_STORAGE_TYPE_NETWORK:
- switch ((virStorageNetProtocol) disk->src.protocol) {
+ switch ((virStorageNetProtocol) disk->src->protocol) {
case VIR_STORAGE_NET_PROTOCOL_NONE:
case VIR_STORAGE_NET_PROTOCOL_NBD:
case VIR_STORAGE_NET_PROTOCOL_RBD:
virReportError(VIR_ERR_INTERNAL_ERROR,
_("external inactive snapshots are not supported on "
"'network' disks using '%s' protocol"),
- virStorageNetProtocolTypeToString(disk->src.protocol));
+ virStorageNetProtocolTypeToString(disk->src->protocol));
return -1;
}
break;
static int
qemuDomainSnapshotPrepareDiskExternalBackingActive(virDomainDiskDefPtr disk)
{
- int actualType = virStorageSourceGetActualType(&disk->src);
+ int actualType = virStorageSourceGetActualType(disk->src);
if (actualType == VIR_STORAGE_TYPE_BLOCK &&
disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
if (qemuTranslateDiskSourcePool(conn, disk) < 0)
return -1;
- actualType = virStorageSourceGetActualType(&disk->src);
+ actualType = virStorageSourceGetActualType(disk->src);
switch ((virStorageType) actualType) {
case VIR_STORAGE_TYPE_BLOCK:
return 0;
case VIR_STORAGE_TYPE_NETWORK:
- switch ((virStorageNetProtocol) disk->src.protocol) {
+ switch ((virStorageNetProtocol) disk->src->protocol) {
case VIR_STORAGE_NET_PROTOCOL_NONE:
case VIR_STORAGE_NET_PROTOCOL_NBD:
case VIR_STORAGE_NET_PROTOCOL_RBD:
virReportError(VIR_ERR_INTERNAL_ERROR,
_("internal inactive snapshots are not supported on "
"'network' disks using '%s' protocol"),
- virStorageNetProtocolTypeToString(disk->src.protocol));
+ virStorageNetProtocolTypeToString(disk->src->protocol));
return -1;
}
break;
active) < 0)
goto cleanup;
- if (dom_disk->src.type == VIR_STORAGE_TYPE_NETWORK &&
- (dom_disk->src.protocol == VIR_STORAGE_NET_PROTOCOL_SHEEPDOG ||
- dom_disk->src.protocol == VIR_STORAGE_NET_PROTOCOL_RBD)) {
+ if (dom_disk->src->type == VIR_STORAGE_TYPE_NETWORK &&
+ (dom_disk->src->protocol == VIR_STORAGE_NET_PROTOCOL_SHEEPDOG ||
+ dom_disk->src->protocol == VIR_STORAGE_NET_PROTOCOL_RBD)) {
break;
}
- if (vm->def->disks[i]->src.format > 0 &&
- vm->def->disks[i]->src.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]->src.format));
+ vm->def->disks[i]->src->format));
goto cleanup;
}
break;
* recompute it. Better would be storing the chain ourselves rather than
* reprobing, but this requires modifying domain_conf and our XML to fully
* track the chain across libvirtd restarts. */
- virStorageSourceClearBackingStore(&disk->src);
+ virStorageSourceClearBackingStore(disk->src);
if (virStorageFileInit(snap->src) < 0)
goto cleanup;
}
}
- virDomainAuditDisk(vm, disk->src.path, 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.path);
- virStorageNetHostDefFree(disk->src.nhosts, disk->src.hosts);
+ VIR_FREE(disk->src->path);
+ virStorageNetHostDefFree(disk->src->nhosts, disk->src->hosts);
- disk->src.path = newsource;
- disk->src.format = format;
- disk->src.type = snap->src->type;
- disk->src.protocol = snap->src->protocol;
- disk->src.nhosts = snap->src->nhosts;
- disk->src.hosts = newhosts;
+ disk->src->path = newsource;
+ disk->src->format = format;
+ disk->src->type = snap->src->type;
+ disk->src->protocol = snap->src->protocol;
+ disk->src->nhosts = snap->src->nhosts;
+ disk->src->hosts = newhosts;
newsource = NULL;
newhosts = NULL;
if (persistDisk) {
- VIR_FREE(persistDisk->src.path);
- virStorageNetHostDefFree(persistDisk->src.nhosts,
- persistDisk->src.hosts);
+ VIR_FREE(persistDisk->src->path);
+ virStorageNetHostDefFree(persistDisk->src->nhosts,
+ persistDisk->src->hosts);
- persistDisk->src.path = persistSource;
- persistDisk->src.format = format;
- persistDisk->src.type = snap->src->type;
- persistDisk->src.protocol = snap->src->protocol;
- persistDisk->src.nhosts = snap->src->nhosts;
- persistDisk->src.hosts = persistHosts;
+ persistDisk->src->path = persistSource;
+ persistDisk->src->format = format;
+ persistDisk->src->type = snap->src->type;
+ persistDisk->src->protocol = snap->src->protocol;
+ persistDisk->src->nhosts = snap->src->nhosts;
+ persistDisk->src->hosts = persistHosts;
persistSource = NULL;
persistHosts = NULL;
char *persistSource = NULL;
struct stat st;
- ignore_value(virStorageFileInit(&disk->src));
+ ignore_value(virStorageFileInit(disk->src));
- if (VIR_STRDUP(source, origdisk->src.path) < 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,
VIR_DISK_CHAIN_NO_ACCESS);
if (need_unlink &&
- virStorageFileStat(&disk->src, &st) == 0 && S_ISREG(st.st_mode) &&
- virStorageFileUnlink(&disk->src) < 0)
- VIR_WARN("Unable to remove just-created %s", disk->src.path);
+ virStorageFileStat(disk->src, &st) == 0 && S_ISREG(st.st_mode) &&
+ virStorageFileUnlink(disk->src) < 0)
+ VIR_WARN("Unable to remove just-created %s", disk->src->path);
/* Update vm in place to match changes. */
- VIR_FREE(disk->src.path);
- disk->src.path = source;
+ VIR_FREE(disk->src->path);
+ disk->src->path = source;
source = NULL;
- disk->src.format = origdisk->src.format;
- disk->src.type = origdisk->src.type;
- disk->src.protocol = origdisk->src.protocol;
- virStorageNetHostDefFree(disk->src.nhosts, disk->src.hosts);
- disk->src.nhosts = origdisk->src.nhosts;
- disk->src.hosts = virStorageNetHostDefCopy(origdisk->src.nhosts,
- origdisk->src.hosts);
+ disk->src->format = origdisk->src->format;
+ disk->src->type = origdisk->src->type;
+ disk->src->protocol = origdisk->src->protocol;
+ virStorageNetHostDefFree(disk->src->nhosts, disk->src->hosts);
+ disk->src->nhosts = origdisk->src->nhosts;
+ disk->src->hosts = virStorageNetHostDefCopy(origdisk->src->nhosts,
+ origdisk->src->hosts);
if (persistDisk) {
- VIR_FREE(persistDisk->src.path);
- persistDisk->src.path = persistSource;
+ VIR_FREE(persistDisk->src->path);
+ persistDisk->src->path = persistSource;
persistSource = NULL;
- persistDisk->src.format = origdisk->src.format;
- persistDisk->src.type = origdisk->src.type;
- persistDisk->src.protocol = origdisk->src.protocol;
- virStorageNetHostDefFree(persistDisk->src.nhosts,
- persistDisk->src.hosts);
- persistDisk->src.nhosts = origdisk->src.nhosts;
- persistDisk->src.hosts = virStorageNetHostDefCopy(origdisk->src.nhosts,
- origdisk->src.hosts);
+ persistDisk->src->format = origdisk->src->format;
+ persistDisk->src->type = origdisk->src->type;
+ persistDisk->src->protocol = origdisk->src->protocol;
+ virStorageNetHostDefFree(persistDisk->src->nhosts,
+ persistDisk->src->hosts);
+ persistDisk->src->nhosts = origdisk->src->nhosts;
+ persistDisk->src->hosts = virStorageNetHostDefCopy(origdisk->src->nhosts,
+ origdisk->src->hosts);
}
cleanup:
- virStorageFileDeinit(&disk->src);
+ virStorageFileDeinit(disk->src);
VIR_FREE(source);
VIR_FREE(persistSource);
}
* 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.path;
- oldformat = disk->src.format;
- oldchain = disk->src.backingStore;
- disk->src.path = disk->mirror;
- disk->src.format = disk->mirrorFormat;
- disk->src.backingStore = NULL;
+ oldsrc = disk->src->path;
+ oldformat = disk->src->format;
+ oldchain = disk->src->backingStore;
+ disk->src->path = disk->mirror;
+ disk->src->format = disk->mirrorFormat;
+ disk->src->backingStore = NULL;
if (qemuDomainDetermineDiskChain(driver, vm, disk, false) < 0) {
- disk->src.path = oldsrc;
- disk->src.format = oldformat;
- disk->src.backingStore = oldchain;
+ disk->src->path = oldsrc;
+ disk->src->format = oldformat;
+ disk->src->backingStore = oldchain;
goto cleanup;
}
if (disk->mirrorFormat && disk->mirrorFormat != VIR_STORAGE_FILE_RAW &&
qemuSetupDiskCgroup(vm, disk) < 0 ||
virSecurityManagerSetImageLabel(driver->securityManager, vm->def,
disk) < 0)) {
- disk->src.path = oldsrc;
- disk->src.format = oldformat;
- disk->src.backingStore = oldchain;
+ disk->src->path = oldsrc;
+ disk->src->format = oldformat;
+ disk->src->backingStore = oldchain;
goto cleanup;
}
* '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.path = oldsrc;
- disk->src.format = oldformat;
- virStorageSourceFree(disk->src.backingStore);
- disk->src.backingStore = oldchain;
+ disk->src->path = oldsrc;
+ disk->src->format = oldformat;
+ virStorageSourceFree(disk->src->backingStore);
+ disk->src->backingStore = oldchain;
VIR_FREE(disk->mirror);
}
disk->mirrorFormat = VIR_STORAGE_FILE_NONE;
if (base &&
(virStorageFileParseChainIndex(disk->dst, base, &baseIndex) < 0 ||
- !(baseSource = virStorageFileChainLookup(&disk->src,
- disk->src.backingStore,
+ !(baseSource = virStorageFileChainLookup(disk->src,
+ disk->src->backingStore,
base, baseIndex, NULL))))
goto endjob;
if (!async) {
int type = VIR_DOMAIN_BLOCK_JOB_TYPE_PULL;
int status = VIR_DOMAIN_BLOCK_JOB_CANCELED;
- event = virDomainEventBlockJobNewFromObj(vm, disk->src.path, type,
+ event = virDomainEventBlockJobNewFromObj(vm, disk->src->path, type,
status);
} else if (!(flags & VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC)) {
while (1) {
if ((flags & VIR_DOMAIN_BLOCK_REBASE_SHALLOW) &&
STREQ_NULLABLE(format, "raw") &&
- disk->src.backingStore->path) {
+ disk->src->backingStore->path) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("disk '%s' has backing file, so raw shallow copy "
"is not possible"),
goto endjob;
VIR_FORCE_CLOSE(fd);
if (!format)
- disk->mirrorFormat = disk->src.format;
+ disk->mirrorFormat = disk->src->format;
} else if (format) {
disk->mirrorFormat = virStorageFileFormatTypeFromString(format);
if (disk->mirrorFormat <= 0) {
goto endjob;
disk = vm->def->disks[idx];
- if (!disk->src.path) {
+ if (!disk->src->path) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("disk %s has no source file to be committed"),
disk->dst);
goto endjob;
if (!top)
- topSource = &disk->src;
+ topSource = disk->src;
else if (virStorageFileParseChainIndex(disk->dst, top, &topIndex) < 0 ||
- !(topSource = virStorageFileChainLookup(&disk->src,
- disk->src.backingStore,
+ !(topSource = virStorageFileChainLookup(disk->src,
+ disk->src->backingStore,
top, topIndex,
&top_parent)))
goto endjob;
/* FIXME: qemu 2.0 supports active commit, but as a two-stage
* process; qemu 2.1 is further improving active commit. We need
* to start supporting it in libvirt. */
- if (topSource == &disk->src) {
+ if (topSource == disk->src) {
virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
_("committing the active layer not supported yet"));
goto endjob;
if (!base && (flags & VIR_DOMAIN_BLOCK_COMMIT_SHALLOW))
baseSource = topSource->backingStore;
else if (virStorageFileParseChainIndex(disk->dst, base, &baseIndex) < 0 ||
- !(baseSource = virStorageFileChainLookup(&disk->src, topSource,
+ !(baseSource = virStorageFileChainLookup(disk->src, topSource,
base, baseIndex, NULL)))
goto endjob;
clean_access = true;
if (qemuDomainPrepareDiskChainElement(driver, vm, disk, baseSource,
VIR_DISK_CHAIN_READ_WRITE) < 0 ||
- (top_parent && top_parent != disk->src.path &&
+ (top_parent && top_parent != disk->src->path &&
qemuDomainPrepareDiskChainElementPath(driver, vm, disk,
top_parent,
VIR_DISK_CHAIN_READ_WRITE) < 0))
/* Revert access to read-only, if possible. */
qemuDomainPrepareDiskChainElement(driver, vm, disk, baseSource,
VIR_DISK_CHAIN_READ_ONLY);
- if (top_parent && top_parent != disk->src.path)
+ if (top_parent && top_parent != disk->src->path)
qemuDomainPrepareDiskChainElementPath(driver, vm, disk,
top_parent,
VIR_DISK_CHAIN_READ_ONLY);
return false;
else if (rc == 1)
continue;
- } else if (disk->src.type == VIR_STORAGE_TYPE_NETWORK &&
- disk->src.protocol == VIR_STORAGE_NET_PROTOCOL_RBD) {
+ } else if (disk->src->type == VIR_STORAGE_TYPE_NETWORK &&
+ disk->src->protocol == VIR_STORAGE_NET_PROTOCOL_RBD) {
continue;
}
int ret = -1;
virStorageEncryptionPtr enc;
- if (!disk->src.encryption) {
+ if (!disk->src->encryption) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("disk %s does not have any encryption information"),
- disk->src.path);
+ disk->src->path);
return -1;
}
- enc = disk->src.encryption;
+ enc = disk->src->encryption;
if (!conn) {
virReportError(VIR_ERR_INTERNAL_ERROR,
size_t secretLen;
const char *alias;
- if (!vm->def->disks[i]->src.encryption ||
+ if (!vm->def->disks[i]->src->encryption ||
!virDomainDiskGetSource(vm->def->disks[i]))
continue;
* be tracked in domain XML, at which point labelskip should be a
* per-file attribute instead of a disk attribute. */
if (disk_seclabel && disk_seclabel->labelskip &&
- !disk->src.backingStore)
+ !disk->src->backingStore)
return 0;
/* Don't restore labels on readoly/shared disks, because
if (!disk_seclabel)
return -1;
disk_seclabel->labelskip = true;
- if (VIR_APPEND_ELEMENT(disk->src.seclabels, disk->src.nseclabels,
+ if (VIR_APPEND_ELEMENT(disk->src->seclabels, disk->src->nseclabels,
disk_seclabel) < 0) {
virSecurityDeviceLabelDefFree(disk_seclabel);
return -1;
/* XXX - if we knew the qemu user:group here we could send it in
* so that the open could be re-tried as that user:group.
*/
- if (!disk->src.backingStore) {
+ if (!disk->src->backingStore) {
bool probe = ctl->allowDiskFormatProbing;
- virStorageFileGetMetadata(&disk->src, -1, -1, probe);
+ virStorageFileGetMetadata(disk->src, -1, -1, probe);
}
/* XXX passing ignoreOpenFailure = true to get back to the behavior
goto cleanup;
for (i = 0; i < def->ndisks; i++) {
- if (def->disks[i]->src.type != VIR_STORAGE_TYPE_FILE &&
- def->disks[i]->src.type != VIR_STORAGE_TYPE_BLOCK)
+ if (def->disks[i]->src->type != VIR_STORAGE_TYPE_FILE &&
+ def->disks[i]->src->type != VIR_STORAGE_TYPE_BLOCK)
continue;
- if (testSELinuxMungePath(&def->disks[i]->src.path) < 0)
+ if (testSELinuxMungePath(&def->disks[i]->src->path) < 0)
goto cleanup;
}
projects / libvirt.git / commitdiff