A continuation of the migration of disk details to virstoragefile.
This patch moves a single enum, but converting the name has quite
a bit of fallout.
* src/conf/domain_conf.h (virDomainDiskType): Move...
* src/util/virstoragefile.h (virStorageType): ...and rename.
* src/bhyve/bhyve_command.c (bhyveBuildDiskArgStr)
(virBhyveProcessBuildLoadCmd): Update clients.
* src/conf/domain_conf.c (virDomainDiskSourceDefParse)
(virDomainDiskDefParseXML, virDomainDiskSourceDefFormatInternal)
(virDomainDiskDefFormat, virDomainDiskGetActualType)
(virDomainDiskDefForeachPath, virDomainDiskSourceIsBlockType):
Likewise.
* src/conf/snapshot_conf.h (_virDomainSnapshotDiskDef): Likewise.
* src/conf/snapshot_conf.c (virDomainSnapshotDiskDefParseXML)
(virDomainSnapshotAlignDisks, virDomainSnapshotDiskDefFormat):
Likewise.
* src/esx/esx_driver.c (esxAutodetectSCSIControllerModel)
(esxDomainDefineXML): Likewise.
* src/locking/domain_lock.c (virDomainLockManagerAddDisk):
Likewise.
* src/lxc/lxc_controller.c
(virLXCControllerSetupLoopDeviceDisk)
(virLXCControllerSetupNBDDeviceDisk)
(virLXCControllerSetupLoopDevices, virLXCControllerSetupDisk):
Likewise.
* src/parallels/parallels_driver.c (parallelsGetHddInfo):
Likewise.
* src/phyp/phyp_driver.c (phypDiskType): Likewise.
* src/qemu/qemu_command.c (qemuGetDriveSourceString)
(qemuDomainDiskGetSourceString, qemuBuildDriveStr)
(qemuBuildCommandLine, qemuParseCommandLineDisk)
(qemuParseCommandLine): Likewise.
* src/qemu/qemu_conf.c (qemuCheckSharedDevice)
(qemuTranslateDiskSourcePool)
(qemuTranslateSnapshotDiskSourcePool): Likewise.
* src/qemu/qemu_domain.c (qemuDomainDeviceDefPostParse)
(qemuDomainDetermineDiskChain): Likewise.
* src/qemu/qemu_driver.c (qemuDomainGetBlockInfo)
(qemuDomainSnapshotPrepareDiskExternalBackingInactive)
(qemuDomainSnapshotPrepareDiskExternalBackingActive)
(qemuDomainSnapshotPrepareDiskExternalOverlayActive)
(qemuDomainSnapshotPrepareDiskExternalOverlayInactive)
(qemuDomainSnapshotPrepareDiskInternal)
(qemuDomainSnapshotPrepare)
(qemuDomainSnapshotCreateSingleDiskActive): Likewise.
* src/qemu/qemu_hotplug.c (qemuDomainChangeEjectableMedia):
Likewise.
* src/qemu/qemu_migration.c (qemuMigrationIsSafe): Likewise.
* src/security/security_apparmor.c
(AppArmorRestoreSecurityImageLabel)
(AppArmorSetSecurityImageLabel): Likewise.
* src/security/security_dac.c (virSecurityDACSetSecurityImageLabel)
(virSecurityDACRestoreSecurityImageLabelInt)
(virSecurityDACSetSecurityAllLabel): Likewise.
* src/security/security_selinux.c
(virSecuritySELinuxRestoreSecurityImageLabelInt)
(virSecuritySELinuxSetSecurityImageLabel)
(virSecuritySELinuxSetSecurityAllLabel): Likewise.
* src/storage/storage_backend.c (virStorageFileBackendForType):
Likewise.
* src/storage/storage_backend_fs.c (virStorageFileBackendFile)
(virStorageFileBackendBlock): Likewise.
* src/storage/storage_backend_gluster.c
(virStorageFileBackendGluster): Likewise.
* src/vbox/vbox_tmpl.c (vboxDomainGetXMLDesc, vboxAttachDrives)
(vboxDomainAttachDeviceImpl, vboxDomainDetachDevice): Likewise.
* src/vmware/vmware_conf.c (vmwareVmxPath): Likewise.
* src/vmx/vmx.c (virVMXParseDisk, virVMXFormatDisk)
(virVMXFormatFloppy): Likewise.
* src/xenxs/xen_sxpr.c (xenParseSxprDisks, xenParseSxpr)
(xenFormatSxprDisk): Likewise.
* src/xenxs/xen_xm.c (xenParseXM, xenFormatXMDisk): Likewise.
* tests/securityselinuxlabeltest.c (testSELinuxLoadDef):
Likewise.
* src/libvirt_private.syms (domain_conf.h): Move symbols...
(virstoragefile.h): ...as appropriate.
Signed-off-by: Eric Blake <eblake@redhat.com>
return -1;
}
- if (virDomainDiskGetType(disk) != VIR_DOMAIN_DISK_TYPE_FILE) {
+ if (virDomainDiskGetType(disk) != VIR_STORAGE_TYPE_FILE) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("unsupported disk type"));
return -1;
return NULL;
}
- if (virDomainDiskGetType(disk) != VIR_DOMAIN_DISK_TYPE_FILE) {
+ if (virDomainDiskGetType(disk) != VIR_STORAGE_TYPE_FILE) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("unsupported disk type"));
return NULL;
"virtio-mmio",
"isa")
-VIR_ENUM_IMPL(virDomainDisk, VIR_DOMAIN_DISK_TYPE_LAST,
- "block",
- "file",
- "dir",
- "network",
- "volume")
-
VIR_ENUM_IMPL(virDomainDiskDevice, VIR_DOMAIN_DISK_DEVICE_LAST,
"disk",
"cdrom",
int
virDomainDiskGetActualType(virDomainDiskDefPtr def)
{
- if (def->src.type == VIR_DOMAIN_DISK_TYPE_VOLUME && def->src.srcpool)
+ if (def->src.type == VIR_STORAGE_TYPE_VOLUME && def->src.srcpool)
return def->src.srcpool->actualtype;
return def->src.type;
memset(&host, 0, sizeof(host));
switch (type) {
- case VIR_DOMAIN_DISK_TYPE_FILE:
+ case VIR_STORAGE_TYPE_FILE:
*source = virXMLPropString(node, "file");
break;
- case VIR_DOMAIN_DISK_TYPE_BLOCK:
+ case VIR_STORAGE_TYPE_BLOCK:
*source = virXMLPropString(node, "dev");
break;
- case VIR_DOMAIN_DISK_TYPE_DIR:
+ case VIR_STORAGE_TYPE_DIR:
*source = virXMLPropString(node, "dir");
break;
- case VIR_DOMAIN_DISK_TYPE_NETWORK:
+ case VIR_STORAGE_TYPE_NETWORK:
if (!(protocol = virXMLPropString(node, "protocol"))) {
virReportError(VIR_ERR_XML_ERROR, "%s",
_("missing network source protocol type"));
child = child->next;
}
break;
- case VIR_DOMAIN_DISK_TYPE_VOLUME:
+ case VIR_STORAGE_TYPE_VOLUME:
if (virDomainDiskSourcePoolDefParse(node, srcpool) < 0)
goto cleanup;
break;
default:
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unexpected disk type %s"),
- virDomainDiskTypeToString(type));
+ virStorageTypeToString(type));
goto cleanup;
}
type = virXMLPropString(node, "type");
if (type) {
- if ((def->src.type = virDomainDiskTypeFromString(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_DOMAIN_DISK_TYPE_FILE;
+ def->src.type = VIR_STORAGE_TYPE_FILE;
}
snapshot = virXMLPropString(node, "snapshot");
&def->src.srcpool) < 0)
goto error;
- if (def->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
+ if (def->src.type == VIR_STORAGE_TYPE_NETWORK) {
if (def->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_ISCSI)
expected_secret_usage = VIR_SECRET_USAGE_TYPE_ISCSI;
else if (def->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD)
goto error;
}
- if (def->src.type == VIR_DOMAIN_DISK_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"),
if (src || nhosts > 0 || srcpool || startupPolicy) {
switch (type) {
- case VIR_DOMAIN_DISK_TYPE_FILE:
+ case VIR_STORAGE_TYPE_FILE:
virBufferAddLit(buf, "<source");
virBufferEscapeString(buf, " file='%s'", src);
virBufferEscapeString(buf, " startupPolicy='%s'", startupPolicy);
virDomainDiskSourceDefFormatSeclabel(buf, nseclabels, seclabels, flags);
break;
- case VIR_DOMAIN_DISK_TYPE_BLOCK:
+ case VIR_STORAGE_TYPE_BLOCK:
virBufferAddLit(buf, "<source");
virBufferEscapeString(buf, " dev='%s'", src);
virBufferEscapeString(buf, " startupPolicy='%s'", startupPolicy);
virDomainDiskSourceDefFormatSeclabel(buf, nseclabels, seclabels, flags);
break;
- case VIR_DOMAIN_DISK_TYPE_DIR:
+ case VIR_STORAGE_TYPE_DIR:
virBufferAddLit(buf, "<source");
virBufferEscapeString(buf, " dir='%s'", src);
virBufferEscapeString(buf, " startupPolicy='%s'", startupPolicy);
virBufferAddLit(buf, "/>\n");
break;
- case VIR_DOMAIN_DISK_TYPE_NETWORK:
+ case VIR_STORAGE_TYPE_NETWORK:
virBufferAsprintf(buf, "<source protocol='%s'",
virDomainDiskProtocolTypeToString(protocol));
virBufferEscapeString(buf, " name='%s'", src);
}
break;
- case VIR_DOMAIN_DISK_TYPE_VOLUME:
+ case VIR_STORAGE_TYPE_VOLUME:
virBufferAddLit(buf, "<source");
if (srcpool) {
default:
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unexpected disk type %s"),
- virDomainDiskTypeToString(type));
+ virStorageTypeToString(type));
return -1;
}
}
virDomainDiskDefPtr def,
unsigned int flags)
{
- const char *type = virDomainDiskTypeToString(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);
const char *path = virDomainDiskGetSource(disk);
int type = virDomainDiskGetType(disk);
- if (!path || type == VIR_DOMAIN_DISK_TYPE_NETWORK ||
- (type == VIR_DOMAIN_DISK_TYPE_VOLUME &&
+ if (!path || type == VIR_STORAGE_TYPE_NETWORK ||
+ (type == VIR_STORAGE_TYPE_VOLUME &&
disk->src.srcpool &&
disk->src.srcpool->mode == VIR_DOMAIN_DISK_SOURCE_POOL_MODE_DIRECT))
return 0;
if (!virDomainDiskGetSource(def))
return false;
- if (virDomainDiskGetType(def) == VIR_DOMAIN_DISK_TYPE_BLOCK)
+ if (virDomainDiskGetType(def) == VIR_STORAGE_TYPE_BLOCK)
return true;
/* For volume types, check the srcpool.
* If it's a block type source pool, then it's possible
*/
- if (virDomainDiskGetType(def) == VIR_DOMAIN_DISK_TYPE_VOLUME &&
+ if (virDomainDiskGetType(def) == VIR_STORAGE_TYPE_VOLUME &&
def->src.srcpool &&
def->src.srcpool->voltype == VIR_STORAGE_VOL_BLOCK) {
/* We don't think the volume accessed by remote URI is
virDomainDeviceInfoPtr info; /* Guest address */
};
-/* Types of disk backends (host resource) */
-enum virDomainDiskType {
- VIR_DOMAIN_DISK_TYPE_BLOCK,
- VIR_DOMAIN_DISK_TYPE_FILE,
- VIR_DOMAIN_DISK_TYPE_DIR,
- VIR_DOMAIN_DISK_TYPE_NETWORK,
- VIR_DOMAIN_DISK_TYPE_VOLUME,
- VIR_DOMAIN_DISK_TYPE_LAST
-};
-
-/* Types of disk frontend (guest view) */
+/* Types of disk frontend (guest view). For backends (host view), see
+ * virStorageType in util/virstoragefile.h */
enum virDomainDiskDevice {
VIR_DOMAIN_DISK_DEVICE_DISK,
VIR_DOMAIN_DISK_DEVICE_CDROM,
char *volume; /* volume name */
int voltype; /* enum virStorageVolType, internal only */
int pooltype; /* enum virStoragePoolType, internal only */
- int actualtype; /* enum virDomainDiskType, internal only */
+ int actualtype; /* enum virStorageType, internal only */
int mode; /* enum virDomainDiskSourcePoolMode */
};
typedef virDomainDiskSourcePoolDef *virDomainDiskSourcePoolDefPtr;
* 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 virStorageType */
char *path;
int protocol; /* enum virDomainDiskProtocol */
size_t nhosts;
VIR_ENUM_DECL(virDomainPMState)
VIR_ENUM_DECL(virDomainDevice)
VIR_ENUM_DECL(virDomainDeviceAddress)
-VIR_ENUM_DECL(virDomainDisk)
VIR_ENUM_DECL(virDomainDiskDevice)
VIR_ENUM_DECL(virDomainDiskGeometryTrans)
VIR_ENUM_DECL(virDomainDiskBus)
}
if ((type = virXMLPropString(node, "type"))) {
- if ((def->type = virDomainDiskTypeFromString(type)) < 0 ||
- def->type == VIR_DOMAIN_DISK_TYPE_VOLUME ||
- def->type == VIR_DOMAIN_DISK_TYPE_DIR) {
+ if ((def->type = virStorageTypeFromString(type)) < 0 ||
+ def->type == VIR_STORAGE_TYPE_VOLUME ||
+ def->type == VIR_STORAGE_TYPE_DIR) {
virReportError(VIR_ERR_XML_ERROR,
_("unknown disk snapshot type '%s'"), type);
goto cleanup;
}
} else {
- def->type = VIR_DOMAIN_DISK_TYPE_FILE;
+ def->type = VIR_STORAGE_TYPE_FILE;
}
for (cur = node->children; cur; cur = cur->next) {
goto cleanup;
disk->index = i;
disk->snapshot = def->dom->disks[i]->snapshot;
- disk->type = VIR_DOMAIN_DISK_TYPE_FILE;
+ disk->type = VIR_STORAGE_TYPE_FILE;
if (!disk->snapshot)
disk->snapshot = default_snapshot;
}
const char *tmp;
struct stat sb;
- if (disk->type != VIR_DOMAIN_DISK_TYPE_FILE) {
+ if (disk->type != VIR_STORAGE_TYPE_FILE) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("cannot generate external snapshot name "
"for disk '%s' on a '%s' device"),
- disk->name, virDomainDiskTypeToString(disk->type));
+ disk->name, virStorageTypeToString(disk->type));
goto cleanup;
}
return;
}
- virBufferAsprintf(buf, " type='%s'>\n", virDomainDiskTypeToString(type));
+ virBufferAsprintf(buf, " type='%s'>\n", virStorageTypeToString(type));
virBufferAdjustIndent(buf, 2);
if (disk->format > 0)
char *name; /* name matching the <target dev='...' of the domain */
int index; /* index within snapshot->dom->disks that matches name */
int snapshot; /* enum virDomainSnapshotLocation */
- int type; /* enum virDomainDiskType */
+ int type; /* enum virStorageType */
char *file; /* new source file when snapshot is external */
int format; /* enum virStorageFileFormat */
int protocol; /* network source protocol */
if (def->device != VIR_DOMAIN_DISK_DEVICE_DISK ||
def->bus != VIR_DOMAIN_DISK_BUS_SCSI ||
- virDomainDiskGetType(def) != VIR_DOMAIN_DISK_TYPE_FILE ||
+ virDomainDiskGetType(def) != VIR_STORAGE_TYPE_FILE ||
!src || !STRPREFIX(src, "[")) {
/*
* This isn't a file-based SCSI disk device with a datastore related
for (i = 0; i < def->ndisks; ++i) {
if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_DISK &&
- virDomainDiskGetType(def->disks[i]) == VIR_DOMAIN_DISK_TYPE_FILE) {
+ virDomainDiskGetType(def->disks[i]) == VIR_STORAGE_TYPE_FILE) {
disk = def->disks[i];
break;
}
virDomainDiskSetSource;
virDomainDiskSetType;
virDomainDiskSourceIsBlockType;
-virDomainDiskTypeFromString;
-virDomainDiskTypeToString;
virDomainEmulatorPinAdd;
virDomainEmulatorPinDel;
virDomainFeatureStateTypeFromString;
virStorageNetHostDefFree;
virStorageNetHostTransportTypeFromString;
virStorageNetHostTransportTypeToString;
+virStorageTypeFromString;
+virStorageTypeToString;
# util/virstring.h
if (!src)
return 0;
- if (!(type == VIR_DOMAIN_DISK_TYPE_BLOCK ||
- type == VIR_DOMAIN_DISK_TYPE_FILE ||
- type == VIR_DOMAIN_DISK_TYPE_DIR))
+ if (!(type == VIR_STORAGE_TYPE_BLOCK ||
+ type == VIR_STORAGE_TYPE_FILE ||
+ type == VIR_STORAGE_TYPE_DIR))
return 0;
if (disk->readonly)
* We now change it into a block device type, so that
* the rest of container setup 'just works'
*/
- virDomainDiskSetType(disk, VIR_DOMAIN_DISK_TYPE_BLOCK);
+ virDomainDiskSetType(disk, VIR_STORAGE_TYPE_BLOCK);
if (virDomainDiskSetSource(disk, loname) < 0)
goto cleanup;
* We now change it into a block device type, so that
* the rest of container setup 'just works'
*/
- virDomainDiskSetType(disk, VIR_DOMAIN_DISK_TYPE_BLOCK);
+ virDomainDiskSetType(disk, VIR_STORAGE_TYPE_BLOCK);
if (virDomainDiskSetSource(disk, dev) < 0) {
VIR_FREE(dev);
return -1;
const char *driver = virDomainDiskGetDriver(disk);
int format = virDomainDiskGetFormat(disk);
- if (virDomainDiskGetType(disk) != VIR_DOMAIN_DISK_TYPE_FILE)
+ if (virDomainDiskGetType(disk) != VIR_STORAGE_TYPE_FILE)
continue;
/* If no driverName is set, we prefer 'loop' for
mode_t mode;
char *tmpsrc = def->src.path;
- if (virDomainDiskGetType(def) != VIR_DOMAIN_DISK_TYPE_BLOCK) {
+ if (virDomainDiskGetType(def) != VIR_STORAGE_TYPE_BLOCK) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("Can't setup disk for non-block device"));
goto cleanup;
disk->device = VIR_DOMAIN_DISK_DEVICE_DISK;
if (virJSONValueObjectHasKey(value, "real") == 1) {
- virDomainDiskSetType(disk, VIR_DOMAIN_DISK_TYPE_BLOCK);
+ virDomainDiskSetType(disk, VIR_STORAGE_TYPE_BLOCK);
if (!(tmp = virJSONValueObjectGetString(value, "real"))) {
parallelsParseError();
if (virDomainDiskSetSource(disk, tmp) < 0)
return -1;
} else {
- virDomainDiskSetType(disk, VIR_DOMAIN_DISK_TYPE_FILE);
+ virDomainDiskSetType(disk, VIR_STORAGE_TYPE_FILE);
if (!(tmp = virJSONValueObjectGetString(value, "image"))) {
parallelsParseError();
goto cleanup;
if (STREQ(ret, "LVPOOL"))
- disk_type = VIR_DOMAIN_DISK_TYPE_BLOCK;
+ disk_type = VIR_STORAGE_TYPE_BLOCK;
else if (STREQ(ret, "FBPOOL"))
- disk_type = VIR_DOMAIN_DISK_TYPE_FILE;
+ disk_type = VIR_STORAGE_TYPE_FILE;
cleanup:
VIR_FREE(ret);
{
*path = NULL;
- switch ((enum virDomainDiskType) type) {
- case VIR_DOMAIN_DISK_TYPE_BLOCK:
- case VIR_DOMAIN_DISK_TYPE_FILE:
- case VIR_DOMAIN_DISK_TYPE_DIR:
+ switch ((enum virStorageType) type) {
+ case VIR_STORAGE_TYPE_BLOCK:
+ case VIR_STORAGE_TYPE_FILE:
+ case VIR_STORAGE_TYPE_DIR:
if (!src)
return 1;
break;
- case VIR_DOMAIN_DISK_TYPE_NETWORK:
+ case VIR_STORAGE_TYPE_NETWORK:
if (!(*path = qemuBuildNetworkDriveURI(protocol,
src,
nhosts,
return -1;
break;
- case VIR_DOMAIN_DISK_TYPE_VOLUME:
- case VIR_DOMAIN_DISK_TYPE_LAST:
+ case VIR_STORAGE_TYPE_VOLUME:
+ case VIR_STORAGE_TYPE_LAST:
break;
}
*source = NULL;
- if (actualType == VIR_DOMAIN_DISK_TYPE_NETWORK &&
+ if (actualType == VIR_STORAGE_TYPE_NETWORK &&
disk->src.auth.username &&
(disk->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_ISCSI ||
disk->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD)) {
virBufferAddLit(&opt, "file=");
switch (actualType) {
- case VIR_DOMAIN_DISK_TYPE_DIR:
+ 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) {
break;
- case VIR_DOMAIN_DISK_TYPE_BLOCK:
+ case VIR_STORAGE_TYPE_BLOCK:
if (disk->tray_status == VIR_DOMAIN_DISK_TRAY_OPEN) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
- disk->src.type == VIR_DOMAIN_DISK_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;
goto error;
}
if (disk->src.format > 0 &&
- disk->src.type != VIR_DOMAIN_DISK_TYPE_DIR &&
+ disk->src.type != VIR_STORAGE_TYPE_DIR &&
virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_FORMAT))
virBufferAsprintf(&opt, ",format=%s",
virStorageFileFormatTypeToString(disk->src.format));
bus);
goto error;
}
- if (disk->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
+ if (disk->src.type == VIR_STORAGE_TYPE_NETWORK) {
if (disk->src.protocol != VIR_DOMAIN_DISK_PROTOCOL_ISCSI) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("disk device='lun' is not supported for protocol='%s'"),
const char *fmt;
virDomainDiskDefPtr disk = def->disks[i];
- if ((disk->src.type == VIR_DOMAIN_DISK_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->src.type == VIR_DOMAIN_DISK_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 (virAsprintf(&file, fmt, disk->src) < 0)
goto error;
- } else if (disk->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
+ } else if (disk->src.type == VIR_STORAGE_TYPE_NETWORK) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("network disks are only supported with -drive"));
} else {
else
def->bus = VIR_DOMAIN_DISK_BUS_IDE;
def->device = VIR_DOMAIN_DISK_DEVICE_DISK;
- def->src.type = VIR_DOMAIN_DISK_TYPE_FILE;
+ def->src.type = VIR_STORAGE_TYPE_FILE;
for (i = 0; i < nkeywords; i++) {
if (STREQ(keywords[i], "file")) {
def->src.path = values[i];
values[i] = NULL;
if (STRPREFIX(def->src.path, "/dev/"))
- def->src.type = VIR_DOMAIN_DISK_TYPE_BLOCK;
+ def->src.type = VIR_STORAGE_TYPE_BLOCK;
else if (STRPREFIX(def->src.path, "nbd:") ||
STRPREFIX(def->src.path, "nbd+")) {
- def->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ def->src.type = VIR_STORAGE_TYPE_NETWORK;
def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_NBD;
if (qemuParseNBDString(def) < 0)
} else if (STRPREFIX(def->src.path, "rbd:")) {
char *p = def->src.path;
- def->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ def->src.type = VIR_STORAGE_TYPE_NETWORK;
def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_RBD;
if (VIR_STRDUP(def->src.path, p + strlen("rbd:")) < 0)
goto error;
VIR_FREE(p);
} else if (STRPREFIX(def->src.path, "gluster:") ||
STRPREFIX(def->src.path, "gluster+")) {
- def->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ def->src.type = VIR_STORAGE_TYPE_NETWORK;
def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_GLUSTER;
if (qemuParseGlusterString(def) < 0)
goto error;
} else if (STRPREFIX(def->src.path, "iscsi:")) {
- def->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ def->src.type = VIR_STORAGE_TYPE_NETWORK;
def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_ISCSI;
if (qemuParseISCSIString(def) < 0)
char *p = def->src.path;
char *port, *vdi;
- def->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ def->src.type = VIR_STORAGE_TYPE_NETWORK;
def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG;
if (VIR_STRDUP(def->src.path, p + strlen("sheepdog:")) < 0)
goto error;
goto error;
}
} else
- def->src.type = VIR_DOMAIN_DISK_TYPE_FILE;
+ def->src.type = VIR_STORAGE_TYPE_FILE;
} else {
- def->src.type = VIR_DOMAIN_DISK_TYPE_FILE;
+ def->src.type = VIR_STORAGE_TYPE_FILE;
}
} else if (STREQ(keywords[i], "if")) {
if (STREQ(values[i], "ide")) {
if (!def->src.path &&
def->device == VIR_DOMAIN_DISK_DEVICE_DISK &&
- def->src.type != VIR_DOMAIN_DISK_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_DOMAIN_DISK_TYPE_BLOCK;
+ disk->src.type = VIR_STORAGE_TYPE_BLOCK;
else if (STRPREFIX(val, "nbd:")) {
- disk->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ disk->src.type = VIR_STORAGE_TYPE_NETWORK;
disk->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_NBD;
} else if (STRPREFIX(val, "rbd:")) {
- disk->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ disk->src.type = VIR_STORAGE_TYPE_NETWORK;
disk->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_RBD;
val += strlen("rbd:");
} else if (STRPREFIX(val, "gluster")) {
- disk->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ disk->src.type = VIR_STORAGE_TYPE_NETWORK;
disk->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_GLUSTER;
} else if (STRPREFIX(val, "sheepdog:")) {
- disk->src.type = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ disk->src.type = VIR_STORAGE_TYPE_NETWORK;
disk->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG;
val += strlen("sheepdog:");
} else
- disk->src.type = VIR_DOMAIN_DISK_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->src.path, val) < 0)
goto error;
- if (disk->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
+ if (disk->src.type == VIR_STORAGE_TYPE_NETWORK) {
char *port;
switch (disk->src.protocol) {
if (VIR_STRDUP(disk->src.path, val + strlen("disk:")) < 0)
goto error;
if (STRPREFIX(disk->src.path, "/dev/"))
- disk->src.type = VIR_DOMAIN_DISK_TYPE_BLOCK;
+ disk->src.type = VIR_STORAGE_TYPE_BLOCK;
else
- disk->src.type = VIR_DOMAIN_DISK_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_DOMAIN_DISK_TYPE_NETWORK &&
+ if (def->disks[i]->src.type == VIR_STORAGE_TYPE_NETWORK &&
def->disks[i]->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD) {
first_rbd_disk = def->disks[i];
break;
disk->sgio == VIR_DOMAIN_DEVICE_SGIO_UNFILTERED))
goto cleanup;
- if (virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_VOLUME) {
+ if (virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_VOLUME) {
virReportError(VIR_ERR_OPERATION_INVALID,
_("sgio of shared disk 'pool=%s' 'volume=%s' conflicts "
"with other active domains"),
int ret = -1;
virErrorPtr savedError = NULL;
- if (def->src.type != VIR_DOMAIN_DISK_TYPE_VOLUME)
+ if (def->src.type != VIR_STORAGE_TYPE_VOLUME)
return 0;
if (!def->src.srcpool)
switch (info.type) {
case VIR_STORAGE_VOL_FILE:
- def->src.srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_FILE;
+ def->src.srcpool->actualtype = VIR_STORAGE_TYPE_FILE;
break;
case VIR_STORAGE_VOL_DIR:
- def->src.srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_DIR;
+ def->src.srcpool->actualtype = VIR_STORAGE_TYPE_DIR;
break;
case VIR_STORAGE_VOL_BLOCK:
- def->src.srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_BLOCK;
+ def->src.srcpool->actualtype = VIR_STORAGE_TYPE_BLOCK;
break;
case VIR_STORAGE_VOL_NETWORK:
def->src.srcpool->mode = VIR_DOMAIN_DISK_SOURCE_POOL_MODE_HOST;
/* fallthrough */
case VIR_DOMAIN_DISK_SOURCE_POOL_MODE_HOST:
- def->src.srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_BLOCK;
+ def->src.srcpool->actualtype = VIR_STORAGE_TYPE_BLOCK;
if (!(def->src.path = virStorageVolGetPath(vol)))
goto cleanup;
break;
case VIR_DOMAIN_DISK_SOURCE_POOL_MODE_DIRECT:
- def->src.srcpool->actualtype = VIR_DOMAIN_DISK_TYPE_NETWORK;
+ def->src.srcpool->actualtype = VIR_STORAGE_TYPE_NETWORK;
def->src.protocol = VIR_DOMAIN_DISK_PROTOCOL_ISCSI;
if (qemuTranslateDiskSourcePoolAuth(def, pooldef) < 0)
qemuTranslateSnapshotDiskSourcePool(virConnectPtr conn ATTRIBUTE_UNUSED,
virDomainSnapshotDiskDefPtr def)
{
- if (def->type != VIR_DOMAIN_DISK_TYPE_VOLUME)
+ if (def->type != VIR_STORAGE_TYPE_VOLUME)
return 0;
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
if (cfg->allowDiskFormatProbing) {
/* default disk format for drives */
if (virDomainDiskGetFormat(disk) == VIR_STORAGE_FILE_NONE &&
- (virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_FILE ||
- virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_BLOCK))
+ (virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_FILE ||
+ virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_BLOCK))
virDomainDiskSetFormat(disk, VIR_STORAGE_FILE_AUTO);
/* default disk format for mirrored drive */
/* default disk format for drives */
if (virDomainDiskGetFormat(disk) == VIR_STORAGE_FILE_NONE &&
- (virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_FILE ||
- virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_BLOCK))
+ (virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_FILE ||
+ virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_BLOCK))
virDomainDiskSetFormat(disk, VIR_STORAGE_FILE_RAW);
/* default disk format for mirrored drive */
int type = virDomainDiskGetType(disk);
if (!src ||
- type == VIR_DOMAIN_DISK_TYPE_NETWORK ||
- type == VIR_DOMAIN_DISK_TYPE_VOLUME)
+ type == VIR_STORAGE_TYPE_NETWORK ||
+ type == VIR_STORAGE_TYPE_VOLUME)
goto cleanup;
if (disk->backingChain) {
/* ..but if guest is not using raw disk format and on a block device,
* then query highest allocated extent from QEMU
*/
- if (virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_BLOCK &&
+ if (virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_BLOCK &&
format != VIR_STORAGE_FILE_RAW &&
S_ISBLK(sb.st_mode)) {
qemuDomainObjPrivatePtr priv = vm->privateData;
{
int actualType = virDomainDiskGetActualType(disk);
- switch ((enum virDomainDiskType) actualType) {
- case VIR_DOMAIN_DISK_TYPE_BLOCK:
- case VIR_DOMAIN_DISK_TYPE_FILE:
+ switch ((enum virStorageType) actualType) {
+ case VIR_STORAGE_TYPE_BLOCK:
+ case VIR_STORAGE_TYPE_FILE:
return 0;
- case VIR_DOMAIN_DISK_TYPE_NETWORK:
+ case VIR_STORAGE_TYPE_NETWORK:
switch ((enum virDomainDiskProtocol) disk->src.protocol) {
case VIR_DOMAIN_DISK_PROTOCOL_NBD:
case VIR_DOMAIN_DISK_PROTOCOL_RBD:
}
break;
- case VIR_DOMAIN_DISK_TYPE_DIR:
- case VIR_DOMAIN_DISK_TYPE_VOLUME:
- case VIR_DOMAIN_DISK_TYPE_LAST:
+ case VIR_STORAGE_TYPE_DIR:
+ case VIR_STORAGE_TYPE_VOLUME:
+ case VIR_STORAGE_TYPE_LAST:
virReportError(VIR_ERR_INTERNAL_ERROR,
_("external inactive snapshots are not supported on "
- "'%s' disks"), virDomainDiskTypeToString(actualType));
+ "'%s' disks"), virStorageTypeToString(actualType));
return -1;
}
{
int actualType = virDomainDiskGetActualType(disk);
- if (actualType == VIR_DOMAIN_DISK_TYPE_BLOCK &&
+ if (actualType == VIR_STORAGE_TYPE_BLOCK &&
disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("external active snapshots are not supported on scsi "
{
int actualType = virDomainSnapshotDiskGetActualType(disk);
- switch ((enum virDomainDiskType) actualType) {
- case VIR_DOMAIN_DISK_TYPE_BLOCK:
- case VIR_DOMAIN_DISK_TYPE_FILE:
+ switch ((enum virStorageType) actualType) {
+ case VIR_STORAGE_TYPE_BLOCK:
+ case VIR_STORAGE_TYPE_FILE:
return 0;
- case VIR_DOMAIN_DISK_TYPE_NETWORK:
+ case VIR_STORAGE_TYPE_NETWORK:
switch ((enum virDomainDiskProtocol) disk->protocol) {
case VIR_DOMAIN_DISK_PROTOCOL_GLUSTER:
return 0;
}
break;
- case VIR_DOMAIN_DISK_TYPE_DIR:
- case VIR_DOMAIN_DISK_TYPE_VOLUME:
- case VIR_DOMAIN_DISK_TYPE_LAST:
+ case VIR_STORAGE_TYPE_DIR:
+ case VIR_STORAGE_TYPE_VOLUME:
+ case VIR_STORAGE_TYPE_LAST:
virReportError(VIR_ERR_INTERNAL_ERROR,
_("external active snapshots are not supported on "
- "'%s' disks"), virDomainDiskTypeToString(actualType));
+ "'%s' disks"), virStorageTypeToString(actualType));
return -1;
}
{
int actualType = virDomainSnapshotDiskGetActualType(disk);
- switch ((enum virDomainDiskType) actualType) {
- case VIR_DOMAIN_DISK_TYPE_BLOCK:
- case VIR_DOMAIN_DISK_TYPE_FILE:
+ switch ((enum virStorageType) actualType) {
+ case VIR_STORAGE_TYPE_BLOCK:
+ case VIR_STORAGE_TYPE_FILE:
return 0;
- case VIR_DOMAIN_DISK_TYPE_NETWORK:
- case VIR_DOMAIN_DISK_TYPE_DIR:
- case VIR_DOMAIN_DISK_TYPE_VOLUME:
- case VIR_DOMAIN_DISK_TYPE_LAST:
+ case VIR_STORAGE_TYPE_NETWORK:
+ case VIR_STORAGE_TYPE_DIR:
+ case VIR_STORAGE_TYPE_VOLUME:
+ case VIR_STORAGE_TYPE_LAST:
virReportError(VIR_ERR_INTERNAL_ERROR,
_("external inactive snapshots are not supported on "
- "'%s' disks"), virDomainDiskTypeToString(actualType));
+ "'%s' disks"), virStorageTypeToString(actualType));
return -1;
}
actualType = virDomainDiskGetActualType(disk);
- switch ((enum virDomainDiskType) actualType) {
- case VIR_DOMAIN_DISK_TYPE_BLOCK:
- case VIR_DOMAIN_DISK_TYPE_FILE:
+ switch ((enum virStorageType) actualType) {
+ case VIR_STORAGE_TYPE_BLOCK:
+ case VIR_STORAGE_TYPE_FILE:
return 0;
- case VIR_DOMAIN_DISK_TYPE_NETWORK:
+ case VIR_STORAGE_TYPE_NETWORK:
switch ((enum virDomainDiskProtocol) disk->src.protocol) {
case VIR_DOMAIN_DISK_PROTOCOL_NBD:
case VIR_DOMAIN_DISK_PROTOCOL_RBD:
}
break;
- case VIR_DOMAIN_DISK_TYPE_DIR:
- case VIR_DOMAIN_DISK_TYPE_VOLUME:
- case VIR_DOMAIN_DISK_TYPE_LAST:
+ case VIR_STORAGE_TYPE_DIR:
+ case VIR_STORAGE_TYPE_VOLUME:
+ case VIR_STORAGE_TYPE_LAST:
virReportError(VIR_ERR_INTERNAL_ERROR,
_("internal inactive snapshots are not supported on "
- "'%s' disks"), virDomainDiskTypeToString(actualType));
+ "'%s' disks"), virStorageTypeToString(actualType));
return -1;
}
active) < 0)
goto cleanup;
- if (dom_disk->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK &&
+ if (dom_disk->src.type == VIR_STORAGE_TYPE_NETWORK &&
(dom_disk->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG ||
dom_disk->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD)) {
break;
goto cleanup;
switch (snap->type) {
- case VIR_DOMAIN_DISK_TYPE_BLOCK:
+ case VIR_STORAGE_TYPE_BLOCK:
reuse = true;
/* fallthrough */
- case VIR_DOMAIN_DISK_TYPE_FILE:
+ case VIR_STORAGE_TYPE_FILE:
/* create the stub file and set selinux labels; manipulate disk in
* place, in a way that can be reverted on failure. */
}
break;
- case VIR_DOMAIN_DISK_TYPE_NETWORK:
+ case VIR_STORAGE_TYPE_NETWORK:
switch (snap->protocol) {
case VIR_DOMAIN_DISK_PROTOCOL_GLUSTER:
if (!(newhosts = virStorageNetHostDefCopy(snap->nhosts, snap->hosts)))
default:
virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
_("snapshots are not supported on '%s' volumes"),
- virDomainDiskTypeToString(snap->type));
+ virStorageTypeToString(snap->type));
goto cleanup;
}
int type = virDomainDiskGetType(disk);
int diskFormat = virDomainDiskGetFormat(disk);
- if (type != VIR_DOMAIN_DISK_TYPE_DIR) {
+ if (type != VIR_STORAGE_TYPE_DIR) {
if (diskFormat > 0) {
format = virStorageFileFormatTypeToString(diskFormat);
} else {
disk->cachemode != VIR_DOMAIN_DISK_CACHE_DISABLE) {
int rc;
- if (virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_FILE) {
+ if (virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_FILE) {
if ((rc = virStorageFileIsSharedFS(src)) < 0)
return false;
else if (rc == 0)
return false;
else if (rc == 1)
continue;
- } else if (disk->src.type == VIR_DOMAIN_DISK_TYPE_NETWORK &&
+ } else if (disk->src.type == VIR_STORAGE_TYPE_NETWORK &&
disk->src.protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD) {
continue;
}
/*
* AppArmor security driver for libvirt
*
- * Copyright (C) 2011-2013 Red Hat, Inc.
+ * Copyright (C) 2011-2014 Red Hat, Inc.
* Copyright (C) 2009-2010 Canonical Ltd.
*
* This library is free software; you can redistribute it and/or
virDomainDefPtr def,
virDomainDiskDefPtr disk)
{
- if (virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_NETWORK)
+ if (virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_NETWORK)
return 0;
return reload_profile(mgr, def, NULL, false);
return 0;
if (!virDomainDiskGetSource(disk) ||
- virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_NETWORK)
+ virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_NETWORK)
return 0;
if (secdef->imagelabel) {
if (!priv->dynamicOwnership)
return 0;
- if (virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_NETWORK)
+ if (virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_NETWORK)
return 0;
params[0] = mgr;
if (!priv->dynamicOwnership)
return 0;
- if (virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_NETWORK)
+ if (virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_NETWORK)
return 0;
/* Don't restore labels on readoly/shared disks, because
for (i = 0; i < def->ndisks; i++) {
/* XXX fixme - we need to recursively label the entire tree :-( */
- if (virDomainDiskGetType(def->disks[i]) == VIR_DOMAIN_DISK_TYPE_DIR)
+ if (virDomainDiskGetType(def->disks[i]) == VIR_STORAGE_TYPE_DIR)
continue;
if (virSecurityDACSetSecurityImageLabel(mgr,
def,
if (disk->readonly || disk->shared)
return 0;
- if (!src || virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_NETWORK)
+ if (!src || virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_NETWORK)
return 0;
/* If we have a shared FS & doing migrated, we must not
if (cbdata.secdef->norelabel)
return 0;
- if (virDomainDiskGetType(disk) == VIR_DOMAIN_DISK_TYPE_NETWORK)
+ if (virDomainDiskGetType(disk) == VIR_STORAGE_TYPE_NETWORK)
return 0;
return virDomainDiskDefForeachPath(disk,
for (i = 0; i < def->ndisks; i++) {
/* XXX fixme - we need to recursively label the entire tree :-( */
- if (virDomainDiskGetType(def->disks[i]) == VIR_DOMAIN_DISK_TYPE_DIR) {
+ if (virDomainDiskGetType(def->disks[i]) == VIR_STORAGE_TYPE_DIR) {
VIR_WARN("Unable to relabel directory tree %s for disk %s",
virDomainDiskGetSource(def->disks[i]),
def->disks[i]->dst);
for (i = 0; fileBackends[i]; i++) {
if (fileBackends[i]->type == type) {
- if (type == VIR_DOMAIN_DISK_TYPE_NETWORK &&
+ if (type == VIR_STORAGE_TYPE_NETWORK &&
fileBackends[i]->protocol != protocol)
continue;
}
}
- if (type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
+ if (type == VIR_STORAGE_TYPE_NETWORK) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("missing storage backend for network files "
"using %s protocol"),
} else {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("missing storage backend for '%s' storage"),
- virDomainDiskTypeToString(type));
+ virStorageTypeToString(type));
}
return NULL;
virStorageFileBackend virStorageFileBackendFile = {
- .type = VIR_DOMAIN_DISK_TYPE_FILE,
+ .type = VIR_STORAGE_TYPE_FILE,
.storageFileUnlink = virStorageFileBackendFileUnlink,
.storageFileStat = virStorageFileBackendFileStat,
virStorageFileBackend virStorageFileBackendBlock = {
- .type = VIR_DOMAIN_DISK_TYPE_BLOCK,
+ .type = VIR_STORAGE_TYPE_BLOCK,
.storageFileStat = virStorageFileBackendFileStat,
};
virStorageFileBackend virStorageFileBackendGluster = {
- .type = VIR_DOMAIN_DISK_TYPE_NETWORK,
+ .type = VIR_STORAGE_TYPE_NETWORK,
.protocol = VIR_DOMAIN_DISK_PROTOCOL_GLUSTER,
.backendInit = virStorageFileBackendGlusterInit,
VIR_LOG_INIT("util.storagefile");
+VIR_ENUM_IMPL(virStorage, VIR_STORAGE_TYPE_LAST,
+ "block",
+ "file",
+ "dir",
+ "network",
+ "volume")
+
VIR_ENUM_IMPL(virStorageFileFormat,
VIR_STORAGE_FILE_LAST,
"none",
* beyond this size, in practice that doesn't matter. */
# define VIR_STORAGE_MAX_HEADER 0x8200
+
+/* Types of disk backends (host resource) */
+enum virStorageType {
+ VIR_STORAGE_TYPE_BLOCK,
+ VIR_STORAGE_TYPE_FILE,
+ VIR_STORAGE_TYPE_DIR,
+ VIR_STORAGE_TYPE_NETWORK,
+ VIR_STORAGE_TYPE_VOLUME,
+
+ VIR_STORAGE_TYPE_LAST
+};
+
+VIR_ENUM_DECL(virStorage)
+
+
enum virStorageFileFormat {
VIR_STORAGE_FILE_AUTO_SAFE = -2,
VIR_STORAGE_FILE_AUTO = -1,
def->disks[i]->device = VIR_DOMAIN_DISK_DEVICE_DISK;
def->disks[i]->bus = VIR_DOMAIN_DISK_BUS_IDE;
virDomainDiskSetType(def->disks[i],
- VIR_DOMAIN_DISK_TYPE_FILE);
+ VIR_STORAGE_TYPE_FILE);
}
}
}
def->disks[diskCount]->readonly = true;
virDomainDiskSetType(def->disks[diskCount],
- VIR_DOMAIN_DISK_TYPE_FILE);
+ VIR_STORAGE_TYPE_FILE);
VBOX_RELEASE(medium);
VBOX_RELEASE(storageController);
def->disks[def->ndisks - 1]->device = VIR_DOMAIN_DISK_DEVICE_CDROM;
def->disks[def->ndisks - 1]->bus = VIR_DOMAIN_DISK_BUS_IDE;
virDomainDiskSetType(def->disks[def->ndisks - 1],
- VIR_DOMAIN_DISK_TYPE_FILE);
+ VIR_STORAGE_TYPE_FILE);
def->disks[def->ndisks - 1]->readonly = true;
ignore_value(virDomainDiskSetSource(def->disks[def->ndisks - 1], location));
ignore_value(VIR_STRDUP(def->disks[def->ndisks - 1]->dst, "hdc"));
def->disks[def->ndisks - 1]->device = VIR_DOMAIN_DISK_DEVICE_FLOPPY;
def->disks[def->ndisks - 1]->bus = VIR_DOMAIN_DISK_BUS_FDC;
virDomainDiskSetType(def->disks[def->ndisks - 1],
- VIR_DOMAIN_DISK_TYPE_FILE);
+ VIR_STORAGE_TYPE_FILE);
def->disks[def->ndisks - 1]->readonly = false;
ignore_value(virDomainDiskSetSource(def->disks[def->ndisks - 1], location));
ignore_value(VIR_STRDUP(def->disks[def->ndisks - 1]->dst, "fda"));
? "True" : "False"));
if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
- if (type == VIR_DOMAIN_DISK_TYPE_FILE && src) {
+ if (type == VIR_STORAGE_TYPE_FILE && src) {
IDVDDrive *dvdDrive = NULL;
/* Currently CDROM/DVD Drive is always IDE
* Secondary Master so neglecting the following
VBOX_UTF16_FREE(dvdfileUtf16);
VBOX_RELEASE(dvdDrive);
}
- } else if (type == VIR_DOMAIN_DISK_TYPE_BLOCK) {
+ } else if (type == VIR_STORAGE_TYPE_BLOCK) {
}
} else if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
- if (type == VIR_DOMAIN_DISK_TYPE_FILE && src) {
+ if (type == VIR_STORAGE_TYPE_FILE && src) {
IHardDisk *hardDisk = NULL;
PRUnichar *hddfileUtf16 = NULL;
vboxIID hdduuid = VBOX_IID_INITIALIZER;
vboxIIDUnalloc(&hdduuid);
VBOX_UTF16_FREE(hddEmpty);
VBOX_UTF16_FREE(hddfileUtf16);
- } else if (type == VIR_DOMAIN_DISK_TYPE_BLOCK) {
+ } else if (type == VIR_STORAGE_TYPE_BLOCK) {
}
} else if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY) {
- if (type == VIR_DOMAIN_DISK_TYPE_FILE && src) {
+ if (type == VIR_STORAGE_TYPE_FILE && src) {
IFloppyDrive *floppyDrive;
machine->vtbl->GetFloppyDrive(machine, &floppyDrive);
if (floppyDrive) {
}
VBOX_RELEASE(floppyDrive);
}
- } else if (type == VIR_DOMAIN_DISK_TYPE_BLOCK) {
+ } else if (type == VIR_STORAGE_TYPE_BLOCK) {
}
}
}
VIR_DEBUG("disk(%zu) shared: %s", i, (def->disks[i]->shared
? "True" : "False"));
- if (type == VIR_DOMAIN_DISK_TYPE_FILE && src) {
+ if (type == VIR_STORAGE_TYPE_FILE && src) {
IMedium *medium = NULL;
PRUnichar *mediumUUID = NULL;
PRUnichar *mediumFileUtf16 = NULL;
int type = virDomainDiskGetType(dev->data.disk);
if (dev->data.disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
- if (type == VIR_DOMAIN_DISK_TYPE_FILE && src) {
+ if (type == VIR_STORAGE_TYPE_FILE && src) {
IDVDDrive *dvdDrive = NULL;
/* Currently CDROM/DVD Drive is always IDE
* Secondary Master so neglecting the following
VBOX_UTF16_FREE(dvdfileUtf16);
VBOX_RELEASE(dvdDrive);
}
- } else if (type == VIR_DOMAIN_DISK_TYPE_BLOCK) {
+ } else if (type == VIR_STORAGE_TYPE_BLOCK) {
}
} else if (dev->data.disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY) {
- if (type == VIR_DOMAIN_DISK_TYPE_FILE && src) {
+ if (type == VIR_STORAGE_TYPE_FILE && src) {
IFloppyDrive *floppyDrive;
machine->vtbl->GetFloppyDrive(machine, &floppyDrive);
if (floppyDrive) {
}
VBOX_RELEASE(floppyDrive);
}
- } else if (type == VIR_DOMAIN_DISK_TYPE_BLOCK) {
+ } else if (type == VIR_STORAGE_TYPE_BLOCK) {
}
}
#else /* VBOX_API_VERSION >= 3001000 */
int type = virDomainDiskGetType(dev->data.disk);
if (dev->data.disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
- if (type == VIR_DOMAIN_DISK_TYPE_FILE) {
+ if (type == VIR_STORAGE_TYPE_FILE) {
IDVDDrive *dvdDrive = NULL;
/* Currently CDROM/DVD Drive is always IDE
* Secondary Master so neglecting the following
}
VBOX_RELEASE(dvdDrive);
}
- } else if (type == VIR_DOMAIN_DISK_TYPE_BLOCK) {
+ } else if (type == VIR_STORAGE_TYPE_BLOCK) {
}
} else if (dev->data.disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY) {
- if (type == VIR_DOMAIN_DISK_TYPE_FILE) {
+ if (type == VIR_STORAGE_TYPE_FILE) {
IFloppyDrive *floppyDrive;
machine->vtbl->GetFloppyDrive(machine, &floppyDrive);
if (floppyDrive) {
}
VBOX_RELEASE(floppyDrive);
}
- } else if (type == VIR_DOMAIN_DISK_TYPE_BLOCK) {
+ } else if (type == VIR_STORAGE_TYPE_BLOCK) {
}
}
#else /* VBOX_API_VERSION >= 3001000 */
for (i = 0; i < vmdef->ndisks; ++i) {
if (vmdef->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_DISK &&
- virDomainDiskGetType(vmdef->disks[i]) == VIR_DOMAIN_DISK_TYPE_FILE) {
+ virDomainDiskGetType(vmdef->disks[i]) == VIR_STORAGE_TYPE_FILE) {
disk = vmdef->disks[i];
break;
}
}
}
- virDomainDiskSetType(*def, VIR_DOMAIN_DISK_TYPE_FILE);
+ virDomainDiskSetType(*def, VIR_STORAGE_TYPE_FILE);
if (!(tmp = ctx->parseFileName(fileName, ctx->opaque)))
goto cleanup;
if (virDomainDiskSetSource(*def, tmp) < 0) {
}
}
- virDomainDiskSetType(*def, VIR_DOMAIN_DISK_TYPE_FILE);
+ virDomainDiskSetType(*def, VIR_STORAGE_TYPE_FILE);
if (!(tmp = ctx->parseFileName(fileName, ctx->opaque)))
goto cleanup;
if (virDomainDiskSetSource(*def, tmp) < 0) {
*/
goto ignore;
} else if (STRCASEEQ(deviceType, "atapi-cdrom")) {
- virDomainDiskSetType(*def, VIR_DOMAIN_DISK_TYPE_BLOCK);
+ virDomainDiskSetType(*def, VIR_STORAGE_TYPE_BLOCK);
if (STRCASEEQ(fileName, "auto detect")) {
ignore_value(virDomainDiskSetSource(*def, NULL));
} else if (STRCASEEQ(deviceType, "cdrom-raw")) {
/* Raw access CD-ROMs actually are device='lun' */
(*def)->device = VIR_DOMAIN_DISK_DEVICE_LUN;
- virDomainDiskSetType(*def, VIR_DOMAIN_DISK_TYPE_BLOCK);
+ virDomainDiskSetType(*def, VIR_STORAGE_TYPE_BLOCK);
if (STRCASEEQ(fileName, "auto detect")) {
ignore_value(virDomainDiskSetSource(*def, NULL));
}
} else if (device == VIR_DOMAIN_DISK_DEVICE_FLOPPY) {
if (fileType != NULL && STRCASEEQ(fileType, "device")) {
- virDomainDiskSetType(*def, VIR_DOMAIN_DISK_TYPE_BLOCK);
+ virDomainDiskSetType(*def, VIR_STORAGE_TYPE_BLOCK);
if (virDomainDiskSetSource(*def, fileName) < 0)
goto cleanup;
} else if (fileType != NULL && STRCASEEQ(fileType, "file")) {
char *tmp;
- virDomainDiskSetType(*def, VIR_DOMAIN_DISK_TYPE_FILE);
+ virDomainDiskSetType(*def, VIR_STORAGE_TYPE_FILE);
if (!(tmp = ctx->parseFileName(fileName, ctx->opaque)))
goto cleanup;
if (virDomainDiskSetSource(*def, tmp) < 0) {
}
/* We only support type='file' and type='block' */
- if (type != VIR_DOMAIN_DISK_TYPE_FILE &&
- type != VIR_DOMAIN_DISK_TYPE_BLOCK) {
+ if (type != VIR_STORAGE_TYPE_FILE &&
+ type != VIR_STORAGE_TYPE_BLOCK) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("%s %s '%s' has unsupported type '%s', expecting "
"'%s' or '%s'"), busType, deviceType, def->dst,
diskType,
- virDomainDiskTypeToString(VIR_DOMAIN_DISK_TYPE_FILE),
- virDomainDiskTypeToString(VIR_DOMAIN_DISK_TYPE_BLOCK));
+ virStorageTypeToString(VIR_STORAGE_TYPE_FILE),
+ virStorageTypeToString(VIR_STORAGE_TYPE_BLOCK));
return -1;
}
}
if (def->device == VIR_DOMAIN_DISK_DEVICE_DISK &&
- type == VIR_DOMAIN_DISK_TYPE_FILE) {
+ type == VIR_STORAGE_TYPE_FILE) {
vmxDeviceType = (def->bus == VIR_DOMAIN_DISK_BUS_SCSI) ?
"scsi-hardDisk" : "ata-hardDisk";
} else if (def->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
- if (type == VIR_DOMAIN_DISK_TYPE_FILE)
+ if (type == VIR_STORAGE_TYPE_FILE)
vmxDeviceType = "cdrom-image";
else
vmxDeviceType = "atapi-cdrom";
virBufferAsprintf(buffer, "%s%d:%d.deviceType = \"%s\"\n",
busType, controllerOrBus, unit, vmxDeviceType);
- if (type == VIR_DOMAIN_DISK_TYPE_FILE) {
+ if (type == VIR_STORAGE_TYPE_FILE) {
const char *src = virDomainDiskGetSource(def);
if (src && ! virFileHasSuffix(src, fileExt)) {
busType, controllerOrBus, unit, fileName);
VIR_FREE(fileName);
- } else if (type == VIR_DOMAIN_DISK_TYPE_BLOCK) {
+ } else if (type == VIR_STORAGE_TYPE_BLOCK) {
const char *src = virDomainDiskGetSource(def);
if (!src &&
virBufferAsprintf(buffer, "floppy%d.present = \"true\"\n", unit);
- if (type == VIR_DOMAIN_DISK_TYPE_FILE) {
+ if (type == VIR_STORAGE_TYPE_FILE) {
virBufferAsprintf(buffer, "floppy%d.fileType = \"file\"\n", unit);
if (src) {
VIR_FREE(fileName);
}
- } else if (type == VIR_DOMAIN_DISK_TYPE_BLOCK) {
+ } else if (type == VIR_STORAGE_TYPE_BLOCK) {
virBufferAsprintf(buffer, "floppy%d.fileType = \"device\"\n", unit);
if (src) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("Floppy '%s' has unsupported type '%s', expecting '%s' "
"or '%s'"), def->dst,
- virDomainDiskTypeToString(type),
- virDomainDiskTypeToString(VIR_DOMAIN_DISK_TYPE_FILE),
- virDomainDiskTypeToString(VIR_DOMAIN_DISK_TYPE_BLOCK));
+ virStorageTypeToString(type),
+ virStorageTypeToString(VIR_STORAGE_TYPE_FILE),
+ virStorageTypeToString(VIR_STORAGE_TYPE_BLOCK));
return -1;
}
so we assume common case here. If blktap becomes
omnipotent, we can revisit this, perhaps stat()'ing
the src file in question */
- virDomainDiskSetType(disk, VIR_DOMAIN_DISK_TYPE_FILE);
+ virDomainDiskSetType(disk, VIR_STORAGE_TYPE_FILE);
} else if (STREQ(virDomainDiskGetDriver(disk), "phy")) {
- virDomainDiskSetType(disk, VIR_DOMAIN_DISK_TYPE_BLOCK);
+ virDomainDiskSetType(disk, VIR_STORAGE_TYPE_BLOCK);
} else if (STREQ(virDomainDiskGetDriver(disk), "file")) {
- virDomainDiskSetType(disk, VIR_DOMAIN_DISK_TYPE_FILE);
+ virDomainDiskSetType(disk, VIR_STORAGE_TYPE_FILE);
}
} else {
/* No CDROM media so can't really tell. We'll just
call if a FILE for now and update when media
is inserted later */
- virDomainDiskSetType(disk, VIR_DOMAIN_DISK_TYPE_FILE);
+ virDomainDiskSetType(disk, VIR_STORAGE_TYPE_FILE);
}
if (STREQLEN(dst, "ioemu:", 6))
virDomainDiskDefFree(disk);
goto error;
}
- virDomainDiskSetType(disk, VIR_DOMAIN_DISK_TYPE_FILE);
+ virDomainDiskSetType(disk, VIR_STORAGE_TYPE_FILE);
disk->device = VIR_DOMAIN_DISK_DEVICE_CDROM;
if (VIR_STRDUP(disk->dst, "hdc") < 0) {
virDomainDiskDefFree(disk);
VIR_FREE(disk);
goto error;
}
- virDomainDiskSetType(disk, VIR_DOMAIN_DISK_TYPE_FILE);
+ virDomainDiskSetType(disk, VIR_STORAGE_TYPE_FILE);
disk->device = VIR_DOMAIN_DISK_DEVICE_FLOPPY;
if (VIR_STRDUP(disk->dst, fds[i]) < 0) {
virDomainDiskDefFree(disk);
} else {
int type = virDomainDiskGetType(def);
- if (type == VIR_DOMAIN_DISK_TYPE_FILE) {
+ if (type == VIR_STORAGE_TYPE_FILE) {
virBufferEscapeSexpr(buf, "(uname 'file:%s')", src);
- } else if (type == VIR_DOMAIN_DISK_TYPE_BLOCK) {
+ } else if (type == VIR_STORAGE_TYPE_BLOCK) {
if (src[0] == '/')
virBufferEscapeSexpr(buf, "(uname 'phy:%s')", src);
else
} else {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("unsupported disk type %s"),
- virDomainDiskTypeToString(type));
+ virStorageTypeToString(type));
return -1;
}
}
/* phy: type indicates a block device */
virDomainDiskSetType(disk,
STREQ(virDomainDiskGetDriver(disk), "phy") ?
- VIR_DOMAIN_DISK_TYPE_BLOCK :
- VIR_DOMAIN_DISK_TYPE_FILE);
+ VIR_STORAGE_TYPE_BLOCK :
+ VIR_STORAGE_TYPE_FILE);
/* Check for a :cdrom/:disk postfix */
disk->device = VIR_DOMAIN_DISK_DEVICE_DISK;
if (VIR_ALLOC(disk) < 0)
goto cleanup;
- virDomainDiskSetType(disk, VIR_DOMAIN_DISK_TYPE_FILE);
+ virDomainDiskSetType(disk, VIR_STORAGE_TYPE_FILE);
disk->device = VIR_DOMAIN_DISK_DEVICE_CDROM;
if (virDomainDiskSetDriver(disk, "file") < 0)
goto cleanup;
virBufferAsprintf(&buf, "%s:", type);
} else {
switch (virDomainDiskGetType(disk)) {
- case VIR_DOMAIN_DISK_TYPE_FILE:
+ case VIR_STORAGE_TYPE_FILE:
virBufferAddLit(&buf, "file:");
break;
- case VIR_DOMAIN_DISK_TYPE_BLOCK:
+ case VIR_STORAGE_TYPE_BLOCK:
virBufferAddLit(&buf, "phy:");
break;
default:
virReportError(VIR_ERR_INTERNAL_ERROR,
_("unsupported disk type %s"),
- virDomainDiskTypeToString(virDomainDiskGetType(disk)));
+ virStorageTypeToString(virDomainDiskGetType(disk)));
goto cleanup;
}
}
goto cleanup;
for (i = 0; i < def->ndisks; i++) {
- if (def->disks[i]->src.type != VIR_DOMAIN_DISK_TYPE_FILE &&
- def->disks[i]->src.type != VIR_DOMAIN_DISK_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)
projects / thirdparty / libvirt.git / commitdiff
