External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-07-16 22:57:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add support for detecting the partition table type when scanning

Browse Source 
iSCSI volumes.  This is implemented in the
virStorageBackendUpdateVolInfoFD function, so all future callers will
automatically benefit.  This is a somewhat large patch because the
conversion of the virStorageBackendPartTableTypeToString necessitated
a change to the formatToString and formatFromString function pointers,
which caused fallout in other places in the storage stuff.  The good
news is that most of these callers are now converted over to the
VIR_ENUM_IMPL, which means a lot of redundant code is now gone.

Signed-off-by: Chris Lalancette <clalance@redhat.com>
This commit is contained in:
Chris Lalancette 2008-10-16 15:06:03 +00:00
parent 164f786626
commit eeff3cdcbc
8 changed files with 169 additions and 364 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
ChangeLog
View File

@ -1,3 +1,14 @@
Thu Oct 16 17:02:00 CEST 2008 Chris Lalancette <clalance@redhat.com>
* Add support for detecting the partition table type when scanning
iSCSI volumes. This is implemented in the
virStorageBackendUpdateVolInfoFD function, so all future callers will
automatically benefit. This is a somewhat large patch because the
conversion of the virStorageBackendPartTableTypeToString necessitated
a change to the formatToString and formatFromString function pointers,
which caused fallout in other places in the storage stuff. The good
news is that most of these callers are now converted over to the
VIR_ENUM_IMPL, which means a lot of redundant code is now gone.
Thu Oct 16 15:41:00 CEST 2008 Chris Lalancette <clalance@redhat.com>
* Compiling with -Werror showed a possible use before initialization
in src/qemu_driver.c. Make sure to initialize the origdisk ptr to

64
src/storage_backend.c
View File

@ -60,6 +60,11 @@
#include "storage_backend_fs.h"
#endif
VIR_ENUM_IMPL(virStorageBackendPartTable,
VIR_STORAGE_POOL_DISK_LAST,
"unknown", "dos", "dvh", "gpt",
"mac", "bsd", "pc98", "sun", "lvm2");
static virStorageBackendPtr backends[] = {
#if WITH_STORAGE_DIR
&virStorageBackendDirectory,
@ -192,6 +197,30 @@ virStorageBackendUpdateVolInfo(virConnectPtr conn,
return ret;
}
static struct diskType const disk_types[] = {
{ VIR_STORAGE_POOL_DISK_LVM2, 0x218, 8, 0x31303020324D564CULL },
{ VIR_STORAGE_POOL_DISK_GPT, 0x200, 8, 0x5452415020494645ULL },
{ VIR_STORAGE_POOL_DISK_DVH, 0x0, 4, 0x41A9E50BULL },
{ VIR_STORAGE_POOL_DISK_MAC, 0x0, 2, 0x5245ULL },
{ VIR_STORAGE_POOL_DISK_BSD, 0x40, 4, 0x82564557ULL },
{ VIR_STORAGE_POOL_DISK_SUN, 0x1fc, 2, 0xBEDAULL },
/*
* NOTE: pc98 is funky; the actual signature is 0x55AA (just like dos), so
* we can't use that. At the moment I'm relying on the "dummy" IPL
* bootloader data that comes from parted. Luckily, the chances of running
* into a pc98 machine running libvirt are approximately nil.
*/
/*{ 0x1fe, 2, 0xAA55UL },*/
{ VIR_STORAGE_POOL_DISK_PC98, 0x0, 8, 0x314C5049000000CBULL },
/*
* NOTE: the order is important here; some other disk types (like GPT and
* and PC98) also have 0x55AA at this offset. For that reason, the DOS
* one must be the last one.
*/
{ VIR_STORAGE_POOL_DISK_DOS, 0x1fe, 2, 0xAA55ULL },
{ -1, 0x0, 0, 0x0ULL },
};
int
virStorageBackendUpdateVolInfoFD(virConnectPtr conn,
virStorageVolDefPtr vol,
@ -245,6 +274,41 @@ virStorageBackendUpdateVolInfoFD(virConnectPtr conn,
if (withCapacity) vol->capacity = end;
}
/* make sure to set the target format "unknown" to begin with */
vol->target.format = VIR_STORAGE_POOL_DISK_UNKNOWN;
if (S_ISBLK(sb.st_mode)) {
off_t start;
int i;
unsigned char buffer[1024];
ssize_t bytes;
start = lseek(fd, 0, SEEK_SET);
if (start < 0) {
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("cannot seek to beginning of file '%s':%s"),
vol->target.path, strerror(errno));
return -1;
}
bytes = saferead(fd, buffer, sizeof(buffer));
if (bytes < 0) {
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("cannot read beginning of file '%s':%s"),
vol->target.path, strerror(errno));
return -1;
}
for (i = 0; disk_types[i].part_table_type != -1; i++) {
if (disk_types[i].offset + disk_types[i].length > bytes)
continue;
if (memcmp(buffer+disk_types[i].offset, &disk_types[i].magic,
disk_types[i].length) == 0) {
vol->target.format = disk_types[i].part_table_type;
break;
}
}
}
vol->target.perms.mode = sb.st_mode;
vol->target.perms.uid = sb.st_uid;
vol->target.perms.gid = sb.st_gid;

35
src/storage_backend.h
View File

@ -26,18 +26,14 @@
#include <libvirt/libvirt.h>
#include "storage_conf.h"
#include "util.h"
typedef const char *(*virStorageVolFormatToString)(virConnectPtr conn,
int format);
typedef int (*virStorageVolFormatFromString)(virConnectPtr conn,
const char *format);
typedef const char *(*virStoragePoolFormatToString)(virConnectPtr conn,
int format);
typedef int (*virStoragePoolFormatFromString)(virConnectPtr conn,
const char *format);
typedef const char *(*virStorageVolFormatToString)(int format);
typedef int (*virStorageVolFormatFromString)(const char *format);
typedef const char *(*virStoragePoolFormatToString)(int format);
typedef int (*virStoragePoolFormatFromString)(const char *format);
typedef struct _virStorageBackendVolOptions virStorageBackendVolOptions;
typedef virStorageBackendVolOptions *virStorageBackendVolOptionsPtr;
@ -56,6 +52,27 @@ enum {
VIR_STORAGE_BACKEND_POOL_SOURCE_NAME = (1<<4),
};
enum partTableType {
VIR_STORAGE_POOL_DISK_UNKNOWN = 0,
VIR_STORAGE_POOL_DISK_DOS = 1,
VIR_STORAGE_POOL_DISK_DVH,
VIR_STORAGE_POOL_DISK_GPT,
VIR_STORAGE_POOL_DISK_MAC,
VIR_STORAGE_POOL_DISK_BSD,
VIR_STORAGE_POOL_DISK_PC98,
VIR_STORAGE_POOL_DISK_SUN,
VIR_STORAGE_POOL_DISK_LVM2,
VIR_STORAGE_POOL_DISK_LAST,
};
struct diskType {
enum partTableType part_table_type;
unsigned short offset;
unsigned short length;
unsigned long long magic;
};
VIR_ENUM_DECL(virStorageBackendPartTable);
typedef struct _virStorageBackendPoolOptions virStorageBackendPoolOptions;
typedef virStorageBackendPoolOptions *virStorageBackendPoolOptionsPtr;
struct _virStorageBackendPoolOptions {

135
src/storage_backend_disk.c
View File

@ -30,16 +30,6 @@
#include "util.h"
#include "memory.h"
enum {
VIR_STORAGE_POOL_DISK_DOS = 0,
VIR_STORAGE_POOL_DISK_DVH,
VIR_STORAGE_POOL_DISK_GPT,
VIR_STORAGE_POOL_DISK_MAC,
VIR_STORAGE_POOL_DISK_BSD,
VIR_STORAGE_POOL_DISK_PC98,
VIR_STORAGE_POOL_DISK_SUN,
};
/*
* XXX these are basically partition types.
*
@ -58,116 +48,18 @@ enum {
VIR_STORAGE_VOL_DISK_LINUX_LVM,
VIR_STORAGE_VOL_DISK_LINUX_RAID,
VIR_STORAGE_VOL_DISK_EXTENDED,
VIR_STORAGE_VOL_DISK_LAST,
};
VIR_ENUM_DECL(virStorageBackendDiskVol);
VIR_ENUM_IMPL(virStorageBackendDiskVol,
VIR_STORAGE_VOL_DISK_LAST,
"none", "linux", "fat16",
"fat32", "linux-swap",
"linux-lvm", "linux-raid",
"extended");
#define PARTHELPER BINDIR "/libvirt_parthelper"
static int
virStorageBackendDiskPoolFormatFromString(virConnectPtr conn,
const char *format) {
if (format == NULL)
return VIR_STORAGE_POOL_DISK_DOS;
if (STREQ(format, "dos"))
return VIR_STORAGE_POOL_DISK_DOS;
if (STREQ(format, "dvh"))
return VIR_STORAGE_POOL_DISK_DVH;
if (STREQ(format, "gpt"))
return VIR_STORAGE_POOL_DISK_GPT;
if (STREQ(format, "mac"))
return VIR_STORAGE_POOL_DISK_MAC;
if (STREQ(format, "bsd"))
return VIR_STORAGE_POOL_DISK_BSD;
if (STREQ(format, "pc98"))
return VIR_STORAGE_POOL_DISK_PC98;
if (STREQ(format, "sun"))
return VIR_STORAGE_POOL_DISK_SUN;
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("unsupported pool format %s"), format);
return -1;
}
static const char *
virStorageBackendDiskPoolFormatToString(virConnectPtr conn,
int format) {
switch (format) {
case VIR_STORAGE_POOL_DISK_DOS:
return "dos";
case VIR_STORAGE_POOL_DISK_DVH:
return "dvh";
case VIR_STORAGE_POOL_DISK_GPT:
return "gpt";
case VIR_STORAGE_POOL_DISK_MAC:
return "mac";
case VIR_STORAGE_POOL_DISK_BSD:
return "bsd";
case VIR_STORAGE_POOL_DISK_PC98:
return "pc98";
case VIR_STORAGE_POOL_DISK_SUN:
return "sun";
}
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("unsupported pool format %d"), format);
return NULL;
}
static int
virStorageBackendDiskVolFormatFromString(virConnectPtr conn,
const char *format) {
if (format == NULL)
return VIR_STORAGE_VOL_DISK_NONE;
if (STREQ(format, "none"))
return VIR_STORAGE_VOL_DISK_NONE;
if (STREQ(format, "linux"))
return VIR_STORAGE_VOL_DISK_LINUX;
if (STREQ(format, "fat16"))
return VIR_STORAGE_VOL_DISK_FAT16;
if (STREQ(format, "fat32"))
return VIR_STORAGE_VOL_DISK_FAT32;
if (STREQ(format, "linux-swap"))
return VIR_STORAGE_VOL_DISK_LINUX_SWAP;
if (STREQ(format, "linux-lvm"))
return VIR_STORAGE_VOL_DISK_LINUX_LVM;
if (STREQ(format, "linux-raid"))
return VIR_STORAGE_VOL_DISK_LINUX_RAID;
if (STREQ(format, "extended"))
return VIR_STORAGE_VOL_DISK_EXTENDED;
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("unsupported volume format %s"), format);
return -1;
}
static const char *
virStorageBackendDiskVolFormatToString(virConnectPtr conn,
int format) {
switch (format) {
case VIR_STORAGE_VOL_DISK_NONE:
return "none";
case VIR_STORAGE_VOL_DISK_LINUX:
return "linux";
case VIR_STORAGE_VOL_DISK_FAT16:
return "fat16";
case VIR_STORAGE_VOL_DISK_FAT32:
return "fat32";
case VIR_STORAGE_VOL_DISK_LINUX_SWAP:
return "linux-swap";
case VIR_STORAGE_VOL_DISK_LINUX_LVM:
return "linux-lvm";
case VIR_STORAGE_VOL_DISK_LINUX_RAID:
return "linux-raid";
case VIR_STORAGE_VOL_DISK_EXTENDED:
return "extended";
}
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("unsupported volume format %d"), format);
return NULL;
}
static int
virStorageBackendDiskMakeDataVol(virConnectPtr conn,
virStoragePoolObjPtr pool,
@ -414,8 +306,7 @@ virStorageBackendDiskBuildPool(virConnectPtr conn,
"mklabel",
"--script",
((pool->def->source.format == VIR_STORAGE_POOL_DISK_DOS) ? "msdos" :
virStorageBackendDiskPoolFormatToString(conn,
pool->def->source.format)),
virStorageBackendPartTableTypeToString(pool->def->source.format)),
NULL,
};
@ -557,12 +448,12 @@ virStorageBackend virStorageBackendDisk = {
.poolOptions = {
.flags = (VIR_STORAGE_BACKEND_POOL_SOURCE_DEVICE),
.formatFromString = virStorageBackendDiskPoolFormatFromString,
.formatToString = virStorageBackendDiskPoolFormatToString,
.formatFromString = virStorageBackendPartTableTypeFromString,
.formatToString = virStorageBackendPartTableTypeToString,
},
.volOptions = {
.formatFromString = virStorageBackendDiskVolFormatFromString,
.formatToString = virStorageBackendDiskVolFormatToString,
.formatFromString = virStorageBackendDiskVolTypeFromString,
.formatToString = virStorageBackendDiskVolTypeToString,
},
.volType = VIR_STORAGE_VOL_BLOCK,

223
src/storage_backend_fs.c
View File

@ -60,17 +60,28 @@ enum {
VIR_STORAGE_POOL_FS_VFAT,
VIR_STORAGE_POOL_FS_HFSPLUS,
VIR_STORAGE_POOL_FS_XFS,
VIR_STORAGE_POOL_FS_LAST,
};
VIR_ENUM_DECL(virStorageBackendFileSystemPool);
VIR_ENUM_IMPL(virStorageBackendFileSystemPool,
VIR_STORAGE_POOL_FS_LAST,
"auto", "ext2", "ext3",
"ext4", "ufs", "iso9660", "udf",
"gfs", "gfs2", "vfat", "hfs+", "xfs");
enum {
VIR_STORAGE_POOL_NETFS_AUTO = 0,
VIR_STORAGE_POOL_NETFS_NFS,
VIR_STORAGE_POOL_NETFS_LAST,
};
VIR_ENUM_DECL(virStorageBackendFileSystemNetPool);
VIR_ENUM_IMPL(virStorageBackendFileSystemNetPool,
VIR_STORAGE_POOL_NETFS_LAST,
"auto", "nfs");
enum {
VIR_STORAGE_VOL_RAW,
VIR_STORAGE_VOL_RAW = 0,
VIR_STORAGE_VOL_DIR,
VIR_STORAGE_VOL_BOCHS,
VIR_STORAGE_VOL_CLOOP,
@ -81,7 +92,14 @@ enum {
VIR_STORAGE_VOL_QCOW2,
VIR_STORAGE_VOL_VMDK,
VIR_STORAGE_VOL_VPC,
VIR_STORAGE_VOL_LAST,
};
VIR_ENUM_DECL(virStorageBackendFileSystemVol);
VIR_ENUM_IMPL(virStorageBackendFileSystemVol,
VIR_STORAGE_VOL_LAST,
"raw", "dir", "bochs",
"cloop", "cow", "dmg", "iso",
"qcow", "qcow2", "vmdk", "vpc");
/* Either 'magic' or 'extension' *must* be provided */
struct FileTypeInfo {
@ -159,178 +177,6 @@ const struct FileTypeInfo const fileTypeInfo[] = {
static int
virStorageBackendFileSystemVolFormatFromString(virConnectPtr conn,
const char *format) {
if (format == NULL)
return VIR_STORAGE_VOL_RAW;
if (STREQ(format, "raw"))
return VIR_STORAGE_VOL_RAW;
if (STREQ(format, "dir"))
return VIR_STORAGE_VOL_DIR;
if (STREQ(format, "bochs"))
return VIR_STORAGE_VOL_BOCHS;
if (STREQ(format, "cow"))
return VIR_STORAGE_VOL_COW;
if (STREQ(format, "cloop"))
return VIR_STORAGE_VOL_CLOOP;
if (STREQ(format, "dmg"))
return VIR_STORAGE_VOL_DMG;
if (STREQ(format, "iso"))
return VIR_STORAGE_VOL_ISO;
if (STREQ(format, "qcow"))
return VIR_STORAGE_VOL_QCOW;
if (STREQ(format, "qcow2"))
return VIR_STORAGE_VOL_QCOW2;
if (STREQ(format, "vmdk"))
return VIR_STORAGE_VOL_VMDK;
if (STREQ(format, "vpc"))
return VIR_STORAGE_VOL_VPC;
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("unsupported volume format %s"), format);
return -1;
}
static const char *
virStorageBackendFileSystemVolFormatToString(virConnectPtr conn,
int format) {
switch (format) {
case VIR_STORAGE_VOL_RAW:
return "raw";
case VIR_STORAGE_VOL_DIR:
return "dir";
case VIR_STORAGE_VOL_BOCHS:
return "bochs";
case VIR_STORAGE_VOL_CLOOP:
return "cloop";
case VIR_STORAGE_VOL_COW:
return "cow";
case VIR_STORAGE_VOL_DMG:
return "dmg";
case VIR_STORAGE_VOL_ISO:
return "iso";
case VIR_STORAGE_VOL_QCOW:
return "qcow";
case VIR_STORAGE_VOL_QCOW2:
return "qcow2";
case VIR_STORAGE_VOL_VMDK:
return "vmdk";
case VIR_STORAGE_VOL_VPC:
return "vpc";
}
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("unsupported volume format %d"), format);
return NULL;
}
static int
virStorageBackendFileSystemPoolFormatFromString(virConnectPtr conn,
const char *format) {
if (format == NULL)
return VIR_STORAGE_POOL_FS_AUTO;
if (STREQ(format, "auto"))
return VIR_STORAGE_POOL_FS_AUTO;
if (STREQ(format, "ext2"))
return VIR_STORAGE_POOL_FS_EXT2;
if (STREQ(format, "ext3"))
return VIR_STORAGE_POOL_FS_EXT3;
if (STREQ(format, "ext4"))
return VIR_STORAGE_POOL_FS_EXT4;
if (STREQ(format, "ufs"))
return VIR_STORAGE_POOL_FS_UFS;
if (STREQ(format, "iso9660"))
return VIR_STORAGE_POOL_FS_ISO;
if (STREQ(format, "udf"))
return VIR_STORAGE_POOL_FS_UDF;
if (STREQ(format, "gfs"))
return VIR_STORAGE_POOL_FS_GFS;
if (STREQ(format, "gfs2"))
return VIR_STORAGE_POOL_FS_GFS2;
if (STREQ(format, "vfat"))
return VIR_STORAGE_POOL_FS_VFAT;
if (STREQ(format, "hfs+"))
return VIR_STORAGE_POOL_FS_HFSPLUS;
if (STREQ(format, "xfs"))
return VIR_STORAGE_POOL_FS_XFS;
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("unsupported volume format %s"), format);
return -1;
}
static const char *
virStorageBackendFileSystemPoolFormatToString(virConnectPtr conn,
int format) {
switch (format) {
case VIR_STORAGE_POOL_FS_AUTO:
return "auto";
case VIR_STORAGE_POOL_FS_EXT2:
return "ext2";
case VIR_STORAGE_POOL_FS_EXT3:
return "ext3";
case VIR_STORAGE_POOL_FS_EXT4:
return "ext4";
case VIR_STORAGE_POOL_FS_UFS:
return "ufs";
case VIR_STORAGE_POOL_FS_ISO:
return "iso";
case VIR_STORAGE_POOL_FS_UDF:
return "udf";
case VIR_STORAGE_POOL_FS_GFS:
return "gfs";
case VIR_STORAGE_POOL_FS_GFS2:
return "gfs2";
case VIR_STORAGE_POOL_FS_VFAT:
return "vfat";
case VIR_STORAGE_POOL_FS_HFSPLUS:
return "hfs+";
case VIR_STORAGE_POOL_FS_XFS:
return "xfs";
}
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("unsupported volume format %d"), format);
return NULL;
}
static int
virStorageBackendFileSystemNetPoolFormatFromString(virConnectPtr conn,
const char *format) {
if (format == NULL)
return VIR_STORAGE_POOL_NETFS_AUTO;
if (STREQ(format, "auto"))
return VIR_STORAGE_POOL_NETFS_AUTO;
if (STREQ(format, "nfs"))
return VIR_STORAGE_POOL_NETFS_NFS;
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("unsupported volume format %s"), format);
return -1;
}
static const char *
virStorageBackendFileSystemNetPoolFormatToString(virConnectPtr conn,
int format) {
switch (format) {
case VIR_STORAGE_POOL_NETFS_AUTO:
return "auto";
case VIR_STORAGE_POOL_NETFS_NFS:
return "nfs";
}
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("unsupported volume format %d"), format);
return NULL;
}
/**
* Probe the header of a file to determine what type of disk image
* it is, and info about its capacity if available.
@ -635,10 +481,8 @@ virStorageBackendFileSystemMount(virConnectPtr conn,
MOUNT,
"-t",
pool->def->type == VIR_STORAGE_POOL_FS ?
virStorageBackendFileSystemPoolFormatToString(conn,
pool->def->source.format) :
virStorageBackendFileSystemNetPoolFormatToString(conn,
pool->def->source.format),
virStorageBackendFileSystemPoolTypeToString(pool->def->source.format) :
virStorageBackendFileSystemNetPoolTypeToString(pool->def->source.format),
NULL, /* Fill in shortly - careful not to add extra fields
before this */
pool->def->target.path,
@ -1036,8 +880,7 @@ virStorageBackendFileSystemVolCreate(virConnectPtr conn,
char size[100];
const char *imgargv[7];
if ((type = virStorageBackendFileSystemVolFormatToString(conn,
vol->target.format)) == NULL) {
if ((type = virStorageBackendFileSystemVolTypeToString(vol->target.format)) == NULL) {
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("unknown storage vol type %d"),
vol->target.format);
@ -1194,8 +1037,8 @@ virStorageBackend virStorageBackendDirectory = {
.deleteVol = virStorageBackendFileSystemVolDelete,
.volOptions = {
.formatFromString = virStorageBackendFileSystemVolFormatFromString,
.formatToString = virStorageBackendFileSystemVolFormatToString,
.formatFromString = virStorageBackendFileSystemVolTypeFromString,
.formatToString = virStorageBackendFileSystemVolTypeToString,
},
.volType = VIR_STORAGE_VOL_FILE,
};
@ -1215,12 +1058,12 @@ virStorageBackend virStorageBackendFileSystem = {
.poolOptions = {
.flags = (VIR_STORAGE_BACKEND_POOL_SOURCE_DEVICE),
.formatFromString = virStorageBackendFileSystemPoolFormatFromString,
.formatToString = virStorageBackendFileSystemPoolFormatToString,
.formatFromString = virStorageBackendFileSystemPoolTypeFromString,
.formatToString = virStorageBackendFileSystemPoolTypeToString,
},
.volOptions = {
.formatFromString = virStorageBackendFileSystemVolFormatFromString,
.formatToString = virStorageBackendFileSystemVolFormatToString,
.formatFromString = virStorageBackendFileSystemVolTypeFromString,
.formatToString = virStorageBackendFileSystemVolTypeToString,
},
.volType = VIR_STORAGE_VOL_FILE,
};
@ -1240,12 +1083,12 @@ virStorageBackend virStorageBackendNetFileSystem = {
.poolOptions = {
.flags = (VIR_STORAGE_BACKEND_POOL_SOURCE_HOST |
VIR_STORAGE_BACKEND_POOL_SOURCE_DIR),
.formatFromString = virStorageBackendFileSystemNetPoolFormatFromString,
.formatToString = virStorageBackendFileSystemNetPoolFormatToString,
.formatFromString = virStorageBackendFileSystemNetPoolTypeFromString,
.formatToString = virStorageBackendFileSystemNetPoolTypeToString,
},
.volOptions = {
.formatFromString = virStorageBackendFileSystemVolFormatFromString,
.formatToString = virStorageBackendFileSystemVolFormatToString,
.formatFromString = virStorageBackendFileSystemVolTypeFromString,
.formatToString = virStorageBackendFileSystemVolTypeToString,
},
.volType = VIR_STORAGE_VOL_FILE,
};

16
src/storage_backend_iscsi.c
View File

@ -636,18 +636,20 @@ virStorageBackendISCSIStopPool(virConnectPtr conn,
return 0;
}
virStorageBackend virStorageBackendISCSI = {
.type = VIR_STORAGE_POOL_ISCSI,
.type = VIR_STORAGE_POOL_ISCSI,
.startPool = virStorageBackendISCSIStartPool,
.refreshPool = virStorageBackendISCSIRefreshPool,
.stopPool = virStorageBackendISCSIStopPool,
.startPool = virStorageBackendISCSIStartPool,
.refreshPool = virStorageBackendISCSIRefreshPool,
.stopPool = virStorageBackendISCSIStopPool,
.poolOptions = {
.poolOptions = {
.flags = (VIR_STORAGE_BACKEND_POOL_SOURCE_HOST |
VIR_STORAGE_BACKEND_POOL_SOURCE_DEVICE)
},
.volType = VIR_STORAGE_VOL_BLOCK,
.volType = VIR_STORAGE_VOL_BLOCK,
.volOptions = {
.formatToString = virStorageBackendPartTableTypeToString,
}
};

40
src/storage_backend_logical.c
View File

@ -40,36 +40,14 @@
#define PV_BLANK_SECTOR_SIZE 512
enum {
VIR_STORAGE_POOL_LOGICAL_LVM2 = 0,
VIR_STORAGE_POOL_LOGICAL_UNKNOWN = 0,
VIR_STORAGE_POOL_LOGICAL_LVM2 = 1,
VIR_STORAGE_POOL_LOGICAL_LAST,
};
static int
virStorageBackendLogicalPoolFormatFromString(virConnectPtr conn,
const char *format) {
if (format == NULL)
return VIR_STORAGE_POOL_LOGICAL_LVM2;
if (STREQ(format, "lvm2"))
return VIR_STORAGE_POOL_LOGICAL_LVM2;
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("unsupported pool format %s"), format);
return -1;
}
static const char *
virStorageBackendLogicalPoolFormatToString(virConnectPtr conn,
int format) {
switch (format) {
case VIR_STORAGE_POOL_LOGICAL_LVM2:
return "lvm2";
}
virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR,
_("unsupported pool format %d"), format);
return NULL;
}
VIR_ENUM_DECL(virStorageBackendLogicalPool);
VIR_ENUM_IMPL(virStorageBackendLogicalPool,
VIR_STORAGE_POOL_LOGICAL_LAST,
"unknown", "lvm2");
static int
virStorageBackendLogicalSetActive(virConnectPtr conn,
@ -638,8 +616,8 @@ virStorageBackend virStorageBackendLogical = {
.poolOptions = {
.flags = (VIR_STORAGE_BACKEND_POOL_SOURCE_NAME |
VIR_STORAGE_BACKEND_POOL_SOURCE_DEVICE),
.formatFromString = virStorageBackendLogicalPoolFormatFromString,
.formatToString = virStorageBackendLogicalPoolFormatToString,
.formatFromString = virStorageBackendLogicalPoolTypeFromString,
.formatToString = virStorageBackendLogicalPoolTypeToString,
},
.volType = VIR_STORAGE_VOL_BLOCK,

9
src/storage_conf.c
View File

@ -275,7 +275,7 @@ virStoragePoolDefParseDoc(virConnectPtr conn,
if (options->formatFromString) {
char *format = virXPathString(conn, "string(/pool/source/format/@type)", ctxt);
if ((ret->source.format = (options->formatFromString)(conn, format)) < 0) {
if ((ret->source.format = (options->formatFromString)(format)) < 0) {
VIR_FREE(format);
goto cleanup;
}
@ -520,7 +520,7 @@ virStoragePoolDefFormat(virConnectPtr conn,
virBufferVSprintf(&buf," <name>%s</name>\n", def->source.name);
if (options->formatToString) {
const char *format = (options->formatToString)(conn, def->source.format);
const char *format = (options->formatToString)(def->source.format);
if (!format)
goto cleanup;
virBufferVSprintf(&buf," <format type='%s'/>\n", format);
@ -750,7 +750,7 @@ virStorageVolDefParseDoc(virConnectPtr conn,
ret->target.path = virXPathString(conn, "string(/volume/target/path)", ctxt);
if (options->formatFromString) {
char *format = virXPathString(conn, "string(/volume/target/format/@type)", ctxt);
if ((ret->target.format = (options->formatFromString)(conn, format)) < 0) {
if ((ret->target.format = (options->formatFromString)(format)) < 0) {
VIR_FREE(format);
goto cleanup;
}
@ -884,8 +884,7 @@ virStorageVolDefFormat(virConnectPtr conn,
virBufferVSprintf(&buf," <path>%s</path>\n", def->target.path);
if (options->formatToString) {
const char *format = (options->formatToString)(conn,
def->target.format);
const char *format = (options->formatToString)(def->target.format);
if (!format)
goto cleanup;
virBufferVSprintf(&buf," <format type='%s'/>\n", format);