Re: [Libvir] PATCH: 7/7 storage driver and local backend implementation

This patch introduces the main storage driver. This is quite a large driver and so is split across several modules - storage_driver.c/.h - implements the public API calls glueing together the storage object handling, to the storage backend impls - storage_conf.c/.h - routines for parsing & formating XML, and managing the in-memory structs representing the storage objects. - storage_backend.h - defines a contract for storage pool backends - storage_backend_XXX.c - one file each for disk, iscsi, lvm, dir storage pools The storage_driver & storage_conf files are both structured to follow the same style as the QEMU network driver. In fact the storage_conf file has many routines that are 100% cut+paste from the QEMU driver. To address this obvious flaw I will pull some of these routines out into separate modules which can be easily shared between drivers. These are mostly convenience routines for dealing with file I/O making directories & symlink comparisons. At this time all the storage backends are empty stubs, except for the local directory driver. Implementing new backends requires about 6-8 methods to be provided - significantly less than the number of methods in the public libvirt storage API, since most are handled higher up the stack. The directory pool impl is sufficient to manage '/var/lib/xen/images' using raw files only. As an example, lets create a pool to manage xen images... # cat > pool-xen.xml <<EOF <pool type="dir"> <name>xenimages</name> <target dir="/var/lib/xen/images"/> <permissions> <mode>0700</mode> <owner>0</owner> <group>0</group> </permissions> </pool> EOF # virsh pool-define pool-xen.xml # virsh pool-list --all Name State Autostart ----------------------------------------- xenimages inactive no Until a pool is started you can't do much with it. Starting a pool takes care of mounting a disk, logging into the iSCSI server, or activating the LVM volume. In the case of a local dir, activating it merely loads the volumes from disk # virsh pool-autostart xenimages # virsh pool-start xenimages # virsh pool-list Name State Autostart ----------------------------------------- xenimages active yes Now we can list volumes available in the pool... # virsh vol-list xenimages Name Type Path ----------------------------------------- None there yet, so lets create one. Notice how can we create sparse vs fully-allocate images by tweaking capacity vs allocation in the XML. The permissions should inherit from the pool, but currently they're compulsory. # cat > vol-demo.xml <<EOF <volume type="file"> <name>demo</name> <capacity>10000000000000</capacity> <allocation>100000</allocation> <permissions> <mode>0700</mode> <owner>0</owner> <group>0</group> </permissions> </volume> EOF # virsh vol-create xenimages vol-demo.xml # virsh vol-list xenimages Name Type Path ----------------------------------------- demo file /var/lib/xen/images/demo And lets check the file was actually created... # ls -lsh /var/lib/xen/images total 108K 108K -rwx------ 1 root root 1.3G Oct 28 22:32 demo There's a bunch more virsh commands, but that's the interesting ones all covered. b/src/storage_backend.h | 57 + b/src/storage_backend_disk.c | 73 ++ b/src/storage_backend_disk.h | 29 b/src/storage_backend_fs.c | 258 ++++++++ b/src/storage_backend_fs.h | 30 b/src/storage_backend_iscsi.c | 75 ++ b/src/storage_backend_iscsi.h | 29 b/src/storage_backend_lvm.c | 74 ++ b/src/storage_backend_lvm.h | 29 b/src/storage_conf.c | 1333 ++++++++++++++++++++++++++++++++++++++++++ b/src/storage_conf.h | 222 ++++++ b/src/storage_driver.c | 996 +++++++++++++++++++++++++++++++ b/src/storage_driver.h | 6 include/libvirt/virterror.h | 3 src/Makefile.am | 7 src/virterror.c | 33 + 16 files changed, 3254 insertions(+) diff -r f57805779ece include/libvirt/virterror.h --- a/include/libvirt/virterror.h Sun Oct 28 22:45:04 2007 -0400 +++ b/include/libvirt/virterror.h Sun Oct 28 22:45:04 2007 -0400 @@ -52,6 +52,7 @@ typedef enum { VIR_FROM_TEST, /* Error from test driver */ VIR_FROM_REMOTE, /* Error from remote driver */ VIR_FROM_OPENVZ, /* Error from OpenVZ driver */ + VIR_FROM_STORAGE, /* Error from Storage driver */ } virErrorDomain; @@ -132,6 +133,8 @@ typedef enum { VIR_ERR_INVALID_STORAGE_POOL, /* invalid storage pool object */ VIR_ERR_INVALID_STORAGE_VOL, /* invalid storage vol object */ VIR_WAR_NO_STORAGE, /* failed to start storage */ + VIR_ERR_NO_STORAGE_POOL, /* storage pool not found */ + VIR_ERR_NO_STORAGE_VOL, /* storage pool not found */ } virErrorNumber; /** diff -r f57805779ece src/Makefile.am --- a/src/Makefile.am Sun Oct 28 22:45:04 2007 -0400 +++ b/src/Makefile.am Sun Oct 28 22:45:04 2007 -0400 @@ -57,6 +57,13 @@ CLIENT_SOURCES = \ openvz_conf.c openvz_conf.h \ openvz_driver.c openvz_driver.h \ nodeinfo.h nodeinfo.c \ + storage_conf.h storage_conf.c \ + storage_driver.h storage_driver.c \ + storage_backend.h \ + storage_backend_iscsi.h storage_backend_iscsi.c \ + storage_backend_disk.h storage_backend_disk.c \ + storage_backend_fs.h storage_backend_fs.c \ + storage_backend_lvm.h storage_backend_lvm.c \ util.c util.h SERVER_SOURCES = \ diff -r f57805779ece src/storage_backend.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/storage_backend.h Sun Oct 28 22:45:04 2007 -0400 @@ -0,0 +1,57 @@ +#ifndef __VIR_STORAGE_BACKEND_H__ +#define __VIR_STORAGE_BACKEND_H__ + +#include <libvirt/libvirt.h> +#include "storage_conf.h" + +#ifdef __cplusplus +extern "C" { +#endif + + + typedef int (*virStoragePoolBackendCreate)(virStoragePoolObjPtr pool); + typedef int (*virStoragePoolBackendStart)(virStoragePoolObjPtr pool); + typedef int (*virStoragePoolBackendStop)(virStoragePoolObjPtr pool); + typedef int (*virStoragePoolBackendDestroy)(virStoragePoolObjPtr pool); + + typedef int (*virStoragePoolBackendGetInfo)(virStoragePoolObjPtr pool, virStoragePoolInfoPtr info); + typedef int (*virStoragePoolBackendVolCreate)(virStoragePoolObjPtr pool, virStorageVolDefPtr vol); + typedef int (*virStoragePoolBackendVolDelete)(virStoragePoolObjPtr pool, virStorageVolDefPtr vol); + typedef int (*virStoragePoolBackendVolGetInfo)(virStoragePoolObjPtr pool, virStorageVolDefPtr vol, virStorageVolInfoPtr info); + + + typedef struct _virStoragePoolBackend virStoragePoolBackend; + typedef virStoragePoolBackend *virStoragePoolBackendPtr; + + struct _virStoragePoolBackend { + int type; + + virStoragePoolBackendCreate create; + virStoragePoolBackendStart start; + virStoragePoolBackendStop stop; + virStoragePoolBackendDestroy destroy; + + virStoragePoolBackendGetInfo getInfo; + virStoragePoolBackendVolCreate volCreate; + virStoragePoolBackendVolDelete volDelete; + virStoragePoolBackendVolGetInfo volGetInfo; + }; + +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif /* __VIR_STORAGE_BACKEND_H__ */ + +/* + * vim: set tabstop=4: + * vim: set shiftwidth=4: + * vim: set expandtab: + */ +/* + * Local variables: + * indent-tabs-mode: nil + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */ diff -r f57805779ece src/storage_backend_disk.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/storage_backend_disk.c Sun Oct 28 22:45:04 2007 -0400 @@ -0,0 +1,73 @@ +#include "storage_backend_disk.h" + + +static int virStoragePoolBackendDiskCreate(virStoragePoolObjPtr pool) +{ + /* create partition table, if not initialized */ + return -1; +} +static int virStoragePoolBackendDiskStart(virStoragePoolObjPtr pool) +{ + /* partition names */ + return -1; +} +static int virStoragePoolBackendDiskStop(virStoragePoolObjPtr pool) +{ + return -1; +} +static int virStoragePoolBackendDiskDestroy(virStoragePoolObjPtr pool) +{ + return -1; +} + +static int virStoragePoolBackendDiskGetInfo(virStoragePoolObjPtr pool, virStoragePoolInfoPtr info) +{ + /* block size */ + return -1; +} + + +static int virStoragePoolBackendDiskVolCreate(virStoragePoolObjPtr pool, virStorageVolDefPtr vol) +{ + /* Add a partition */ + return -1; +} +static int virStoragePoolBackendDiskVolDelete(virStoragePoolObjPtr pool, virStorageVolDefPtr vol) +{ + /* delete a partition */ + return -1; +} +static int virStoragePoolBackendDiskVolGetInfo(virStoragePoolObjPtr pool, virStorageVolDefPtr vol, virStorageVolInfoPtr info) +{ + /* partition size */ + return -1; +} + + +virStoragePoolBackend virStoragePoolBackendDisk = { + .type = VIR_STORAGE_POOL_DISK, + + .create = virStoragePoolBackendDiskCreate, + .start = virStoragePoolBackendDiskStart, + .stop = virStoragePoolBackendDiskStop, + .destroy = virStoragePoolBackendDiskDestroy, + + .getInfo = virStoragePoolBackendDiskGetInfo, + .volCreate = virStoragePoolBackendDiskVolCreate, + .volDelete = virStoragePoolBackendDiskVolDelete, + .volGetInfo = virStoragePoolBackendDiskVolGetInfo, +}; + +/* + * vim: set tabstop=4: + * vim: set shiftwidth=4: + * vim: set expandtab: + */ +/* + * Local variables: + * indent-tabs-mode: nil + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */ diff -r f57805779ece src/storage_backend_disk.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/storage_backend_disk.h Sun Oct 28 22:45:04 2007 -0400 @@ -0,0 +1,29 @@ +#ifndef __VIR_STORAGE_BACKEND_DISK_H__ +#define __VIR_STORAGE_BACKEND_DISK_H__ + +#include "storage_backend.h" + +#ifdef __cplusplus +extern "C" { +#endif + + extern virStoragePoolBackend virStoragePoolBackendDisk; + +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif /* __VIR_STORAGE_BACKEND_DISK_H__ */ + +/* + * vim: set tabstop=4: + * vim: set shiftwidth=4: + * vim: set expandtab: + */ +/* + * Local variables: + * indent-tabs-mode: nil + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */ diff -r f57805779ece src/storage_backend_fs.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/storage_backend_fs.c Sun Oct 28 22:45:04 2007 -0400 @@ -0,0 +1,258 @@ +#include <sys/statvfs.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <dirent.h> +#include <errno.h> +#include <fcntl.h> +#include <unistd.h> + +#include "storage_backend_fs.h" + + +static int virStoragePoolBackendFileSystemCreate(virStoragePoolObjPtr pool) +{ + /* format the block device, if not already formatted */ + return -1; +} +static int virStoragePoolBackendFileSystemStart(virStoragePoolObjPtr pool) +{ + DIR *dir; + struct dirent *ent; + + if (virStorageEnsureDir(pool->def->target) < 0) { + virStorageReportError(NULL, VIR_ERR_INTERNAL_ERROR, "cannot statvfs path '%s': %d (%s)", + pool->def->target, errno, strerror(errno)); + return -1; + } + + /* XXX mount volume for FS */ + + if (!(dir = opendir(pool->def->target))) { + virStorageReportError(NULL, VIR_ERR_INTERNAL_ERROR, "cannot open path '%s': %d (%s)", + pool->def->target, errno, strerror(errno)); + return -1; + } + + while ((ent = readdir(dir)) != NULL) { + virStorageVolDefPtr vol; + struct stat sb; + + if (ent->d_name[0] == '.') + continue; + + vol = calloc(1, sizeof(virStorageVolDef)); + if (vol == NULL) + goto no_memory; + vol->name = strdup(ent->d_name); + if (vol->name == NULL) + goto no_memory; + /* XXX other format probes */ + vol->format = VIR_STORAGE_VOL_RAW; + vol->target = malloc(strlen(pool->def->target) + 1 + strlen(vol->name) + 1); + if (vol->target == NULL) + goto no_memory; + strcpy(vol->target, pool->def->target); + strcat(vol->target, "/"); + strcat(vol->target, vol->name); + + if (stat(vol->target, &sb) < 0) { + virStorageReportError(NULL, VIR_ERR_INTERNAL_ERROR, "cannot stat file '%s': %d (%s)", + vol->target, errno, strerror(errno)); + goto failed; + } + + vol->capacity = sb.st_size; + vol->allocation = (unsigned long long)sb.st_blocks * (unsigned long long)512; + vol->perms.mode = sb.st_mode; + vol->perms.uid = sb.st_uid; + vol->perms.gid = sb.st_gid; + + vol->next = pool->volumes; + pool->volumes = vol; + pool->nvolumes++; + continue; + + no_memory: + virStorageReportError(NULL, VIR_ERR_NO_MEMORY, "volume"); + failed: + if (vol->name) free(vol->name); + if (vol->target) free(vol->target); + free(vol); + goto cleanup; + } + closedir(dir); + return 0; + + cleanup: + closedir(dir); + return -1; +} + +static int virStoragePoolBackendFileSystemStop(virStoragePoolObjPtr pool) +{ + virStorageVolDefPtr vol; + + vol = pool->volumes; + while (vol) { + virStorageVolDefPtr next = vol->next; + virStorageVolDefFree(vol); + vol = next; + } + pool->volumes = NULL; + pool->nvolumes = 0; + + /* XXX Unmount the disk */ + return 0; +} +static int virStoragePoolBackendFileSystemDestroy(virStoragePoolObjPtr pool) +{ + /* nada */ + return -1; +} + + +static int virStoragePoolBackendFileSystemGetInfo(virStoragePoolObjPtr pool, virStoragePoolInfoPtr info) +{ + struct statvfs sb; + + if (statvfs(pool->def->target, &sb) < 0) { + virStorageReportError(NULL, VIR_ERR_INTERNAL_ERROR, "cannot statvfs path '%s': %d (%s)", + pool->def->target, errno, strerror(errno)); + return -1; + } + + if (virStoragePoolObjIsActive(pool)) + info->state = VIR_STORAGE_POOL_ACTIVE; + else + info->state = VIR_STORAGE_POOL_INACTIVE; + + info->capacity = (unsigned long long)sb.f_frsize * (unsigned long long)sb.f_blocks; + info->allocation = info->capacity - ((unsigned long long)sb.f_bfree * (unsigned long long)sb.f_bsize); + + return -1; +} + +static int virStoragePoolBackendFileSystemVolCreate(virStoragePoolObjPtr pool, virStorageVolDefPtr vol) +{ + int fd; + + vol->target = malloc(strlen(pool->def->target) + 1 + strlen(vol->name) + 1); + if (vol->target == NULL) { + virStorageReportError(NULL, VIR_ERR_NO_MEMORY, "target"); + return -1; + } + strcpy(vol->target, pool->def->target); + strcat(vol->target, "/"); + strcat(vol->target, vol->name); + + if ((fd = open(vol->target, O_WRONLY | O_CREAT, vol->perms.mode)) < 0) { + virStorageReportError(NULL, VIR_ERR_INTERNAL_ERROR, "cannot create path '%s': %d (%s)", + vol->target, errno, strerror(errno)); + return -1; + } + + /* Pre-allocate any data if requested */ + if (vol->allocation) { + unsigned long long remain = vol->allocation; + char zeros[4096]; + memset(zeros, 0, sizeof(zeros)); + while (remain) { + int bytes = sizeof(zeros); + if (bytes > remain) + bytes = remain; + if ((bytes = write(fd, zeros, bytes)) < 0) { + virStorageReportError(NULL, VIR_ERR_INTERNAL_ERROR, "cannot fill file '%s': %d (%s)", + vol->target, errno, strerror(errno)); + close(fd); + return -1; + } + remain -= bytes; + } + } + + /* Now seek to final size, possibly making the file sparse */ + if (ftruncate(fd, vol->capacity) < 0) { + virStorageReportError(NULL, VIR_ERR_INTERNAL_ERROR, "cannot extend file '%s': %d (%s)", + vol->target, errno, strerror(errno)); + close(fd); + return -1; + } + + if (close(fd) < 0) { + virStorageReportError(NULL, VIR_ERR_INTERNAL_ERROR, "cannot close file '%s': %d (%s)", + vol->target, errno, strerror(errno)); + return -1; + } + + return 0; +} + +static int virStoragePoolBackendFileSystemVolDelete(virStoragePoolObjPtr pool, virStorageVolDefPtr vol) +{ + if (unlink(vol->target) < 0) { + virStorageReportError(NULL, VIR_ERR_INTERNAL_ERROR, "cannot unlink file '%s': %d (%s)", + vol->target, errno, strerror(errno)); + return -1; + } + return 0; +} + +static int virStoragePoolBackendFileSystemVolGetInfo(virStoragePoolObjPtr pool, virStorageVolDefPtr vol, virStorageVolInfoPtr info) +{ + struct stat sb; + + if (stat(vol->target, &sb) < 0) { + virStorageReportError(NULL, VIR_ERR_INTERNAL_ERROR, "cannot stat file '%s': %d (%s)", + vol->target, errno, strerror(errno)); + return -1; + } + + info->type = VIR_STORAGE_POOL_FILE; + info->capacity = sb.st_size; + info->allocation = (unsigned long long)sb.st_blocks * (unsigned long long)512; + + return 0; +} + + +virStoragePoolBackend virStoragePoolBackendFileSystem = { + .type = VIR_STORAGE_POOL_FS, + + .create = virStoragePoolBackendFileSystemCreate, + .start = virStoragePoolBackendFileSystemStart, + .stop = virStoragePoolBackendFileSystemStop, + .destroy = virStoragePoolBackendFileSystemDestroy, + + .getInfo = virStoragePoolBackendFileSystemGetInfo, + .volCreate = virStoragePoolBackendFileSystemVolCreate, + .volDelete = virStoragePoolBackendFileSystemVolDelete, + .volGetInfo = virStoragePoolBackendFileSystemVolGetInfo, +}; + +virStoragePoolBackend virStoragePoolBackendDirectory = { + .type = VIR_STORAGE_POOL_DIR, + + .create = virStoragePoolBackendFileSystemCreate, + .start = virStoragePoolBackendFileSystemStart, + .stop = virStoragePoolBackendFileSystemStop, + .destroy = virStoragePoolBackendFileSystemDestroy, + + .getInfo = virStoragePoolBackendFileSystemGetInfo, + .volCreate = virStoragePoolBackendFileSystemVolCreate, + .volDelete = virStoragePoolBackendFileSystemVolDelete, + .volGetInfo = virStoragePoolBackendFileSystemVolGetInfo, +}; + +/* + * vim: set tabstop=4: + * vim: set shiftwidth=4: + * vim: set expandtab: + */ +/* + * Local variables: + * indent-tabs-mode: nil + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */ diff -r f57805779ece src/storage_backend_fs.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/storage_backend_fs.h Sun Oct 28 22:45:04 2007 -0400 @@ -0,0 +1,30 @@ +#ifndef __VIR_STORAGE_BACKEND_FS_H__ +#define __VIR_STORAGE_BACKEND_FS_H__ + +#include "storage_backend.h" + +#ifdef __cplusplus +extern "C" { +#endif + + extern virStoragePoolBackend virStoragePoolBackendFileSystem; + extern virStoragePoolBackend virStoragePoolBackendDirectory; + +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif /* __VIR_STORAGE_BACKEND_FS_H__ */ + +/* + * vim: set tabstop=4: + * vim: set shiftwidth=4: + * vim: set expandtab: + */ +/* + * Local variables: + * indent-tabs-mode: nil + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */ diff -r f57805779ece src/storage_backend_iscsi.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/storage_backend_iscsi.c Sun Oct 28 22:45:04 2007 -0400 @@ -0,0 +1,75 @@ +#include "storage_backend_iscsi.h" + + +static int virStoragePoolBackendISCSICreate(virStoragePoolObjPtr pool) +{ + /* nada */ + return -1; +} +static int virStoragePoolBackendISCSIStart(virStoragePoolObjPtr pool) +{ + /* login to iscsi server */ + /* list LUNs for target */ + return -1; +} +static int virStoragePoolBackendISCSIStop(virStoragePoolObjPtr pool) +{ + /* logout of iscsi server */ + return -1; +} +static int virStoragePoolBackendISCSIDestroy(virStoragePoolObjPtr pool) +{ + /* nada */ + return -1; +} + +static int virStoragePoolBackendISCSIGetInfo(virStoragePoolObjPtr pool, virStoragePoolInfoPtr info) +{ + /* target size - unavailable */ + return -1; +} + +static int virStoragePoolBackendISCSIVolCreate(virStoragePoolObjPtr pool, virStorageVolDefPtr vol) +{ + /* Nada */ + return -1; +} +static int virStoragePoolBackendISCSIVolDelete(virStoragePoolObjPtr pool, virStorageVolDefPtr vol) +{ + /* Nada */ + return -1; +} +static int virStoragePoolBackendISCSIVolGetInfo(virStoragePoolObjPtr pool, virStorageVolDefPtr vol, virStorageVolInfoPtr info) +{ + /* block device size */ + return -1; +} + + +virStoragePoolBackend virStoragePoolBackendISCSI = { + .type = VIR_STORAGE_POOL_ISCSI, + + .create = virStoragePoolBackendISCSICreate, + .start = virStoragePoolBackendISCSIStart, + .stop = virStoragePoolBackendISCSIStop, + .destroy = virStoragePoolBackendISCSIDestroy, + + .getInfo = virStoragePoolBackendISCSIGetInfo, + .volCreate = virStoragePoolBackendISCSIVolCreate, + .volDelete = virStoragePoolBackendISCSIVolDelete, + .volGetInfo = virStoragePoolBackendISCSIVolGetInfo, +}; + +/* + * vim: set tabstop=4: + * vim: set shiftwidth=4: + * vim: set expandtab: + */ +/* + * Local variables: + * indent-tabs-mode: nil + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */ diff -r f57805779ece src/storage_backend_iscsi.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/storage_backend_iscsi.h Sun Oct 28 22:45:04 2007 -0400 @@ -0,0 +1,29 @@ +#ifndef __VIR_STORAGE_BACKEND_ISCSI_H__ +#define __VIR_STORAGE_BACKEND_ISCSI_H__ + +#include "storage_backend.h" + +#ifdef __cplusplus +extern "C" { +#endif + + extern virStoragePoolBackend virStoragePoolBackendISCSI; + +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif /* __VIR_STORAGE_BACKEND_ISCSI_H__ */ + +/* + * vim: set tabstop=4: + * vim: set shiftwidth=4: + * vim: set expandtab: + */ +/* + * Local variables: + * indent-tabs-mode: nil + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */ diff -r f57805779ece src/storage_backend_lvm.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/storage_backend_lvm.c Sun Oct 28 22:45:04 2007 -0400 @@ -0,0 +1,74 @@ +#include "storage_backend_lvm.h" + + +static int virStoragePoolBackendLVMCreate(virStoragePoolObjPtr pool) +{ + /* vgcreate */ + return -1; +} +static int virStoragePoolBackendLVMStart(virStoragePoolObjPtr pool) +{ + /* vgchange -y */ + return -1; +} +static int virStoragePoolBackendLVMStop(virStoragePoolObjPtr pool) +{ + /* vgchange -n */ + return -1; +} +static int virStoragePoolBackendLVMDestroy(virStoragePoolObjPtr pool) +{ + /* vgdestroy */ + return -1; +} + +static int virStoragePoolBackendLVMGetInfo(virStoragePoolObjPtr pool, virStoragePoolInfoPtr info) +{ + /* target size - unavailable */ + return -1; +} + +static int virStoragePoolBackendLVMVolCreate(virStoragePoolObjPtr pool, virStorageVolDefPtr vol) +{ + /* lvcreate */ + return -1; +} +static int virStoragePoolBackendLVMVolDelete(virStoragePoolObjPtr pool, virStorageVolDefPtr vol) +{ + /* lvdestroy */ + return -1; +} +static int virStoragePoolBackendLVMVolGetInfo(virStoragePoolObjPtr pool, virStorageVolDefPtr vol, virStorageVolInfoPtr info) +{ + /* lvdisplay */ + return -1; +} + + +virStoragePoolBackend virStoragePoolBackendLVM = { + .type = VIR_STORAGE_POOL_LVM, + + .create = virStoragePoolBackendLVMCreate, + .start = virStoragePoolBackendLVMStart, + .stop = virStoragePoolBackendLVMStop, + .destroy = virStoragePoolBackendLVMDestroy, + + .getInfo = virStoragePoolBackendLVMGetInfo, + .volCreate = virStoragePoolBackendLVMVolCreate, + .volDelete = virStoragePoolBackendLVMVolDelete, + .volGetInfo = virStoragePoolBackendLVMVolGetInfo, +}; + +/* + * vim: set tabstop=4: + * vim: set shiftwidth=4: + * vim: set expandtab: + */ +/* + * Local variables: + * indent-tabs-mode: nil + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */ diff -r f57805779ece src/storage_backend_lvm.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/storage_backend_lvm.h Sun Oct 28 22:45:04 2007 -0400 @@ -0,0 +1,29 @@ +#ifndef __VIR_STORAGE_BACKEND_LVM_H__ +#define __VIR_STORAGE_BACKEND_LVM_H__ + +#include "storage_backend.h" + +#ifdef __cplusplus +extern "C" { +#endif + + extern virStoragePoolBackend virStoragePoolBackendLVM; + +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif /* __VIR_STORAGE_BACKEND_LVM_H__ */ + +/* + * vim: set tabstop=4: + * vim: set shiftwidth=4: + * vim: set expandtab: + */ +/* + * Local variables: + * indent-tabs-mode: nil + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */ diff -r f57805779ece src/storage_conf.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/storage_conf.c Sun Oct 28 22:45:04 2007 -0400 @@ -0,0 +1,1333 @@ + +#include <libvirt/libvirt.h> +#include <libvirt/virterror.h> + +#include <libxml/parser.h> +#include <libxml/tree.h> +#include <libxml/xpath.h> +#include <libxml/uri.h> + +#include <stdlib.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <dirent.h> +#include <unistd.h> +#include <errno.h> +#include <stdio.h> +#include <fcntl.h> + +#include "storage_conf.h" +#include "xml.h" +#include "uuid.h" +#include "buf.h" + +#define virStorageLog(msg...) fprintf(stderr, msg) + +void +virStorageReportError(virConnectPtr conn, int code, const char *fmt, ...) { + va_list args; + char errorMessage[1024]; + + if (fmt) { + va_start(args, fmt); + vsnprintf(errorMessage, sizeof(errorMessage)-1, fmt, args); + va_end(args); + } else { + errorMessage[0] = '\0'; + } + virStorageLog("%s", errorMessage); + __virRaiseError(conn, NULL, NULL, VIR_FROM_STORAGE, code, VIR_ERR_ERROR, + NULL, NULL, NULL, -1, -1, errorMessage); +} + +/* Build up a fully qualfiied path for a config file to be + * associated with a persistent guest or network */ +static int +virStorageMakeConfigPath(const char *configDir, + const char *name, + const char *ext, + char *buf, + unsigned int buflen) { + if ((strlen(configDir) + 1 + strlen(name) + (ext ? strlen(ext) : 0) + 1) > buflen) + return -1; + + strcpy(buf, configDir); + strcat(buf, "/"); + strcat(buf, name); + if (ext) + strcat(buf, ext); + return 0; +} + +int +virStorageEnsureDir(const char *path) +{ + struct stat st; + char parent[PATH_MAX]; + char *p; + int err; + + if (stat(path, &st) >= 0) + return 0; + + strncpy(parent, path, PATH_MAX); + parent[PATH_MAX - 1] = '\0'; + + if (!(p = strrchr(parent, '/'))) + return EINVAL; + + if (p == parent) + return EPERM; + + *p = '\0'; + + if ((err = virStorageEnsureDir(parent))) + return err; + + if (mkdir(path, 0777) < 0 && errno != EEXIST) + return errno; + + return 0; +} + + +static int +compareFileToNameSuffix(const char *file, + const char *name, + const char *suffix) { + int filelen = strlen(file); + int namelen = strlen(name); + int suffixlen = strlen(suffix); + + if (filelen == (namelen + suffixlen) && + !strncmp(file, name, namelen) && + !strncmp(file + namelen, suffix, suffixlen)) + return 1; + else + return 0; +} + +static int +hasSuffix(const char *str, + const char *suffix) +{ + int len = strlen(str); + int suffixlen = strlen(suffix); + + if (len < suffixlen) + return 0; + + return strcmp(str + len - suffixlen, suffix) == 0; +} + +static int +checkLinkPointsTo(const char *checkLink, + const char *checkDest) +{ + char dest[PATH_MAX]; + char real[PATH_MAX]; + char checkReal[PATH_MAX]; + int n; + int passed = 0; + + /* read the link destination */ + if ((n = readlink(checkLink, dest, PATH_MAX)) < 0) { + switch (errno) { + case ENOENT: + case ENOTDIR: + break; + + case EINVAL: + virStorageLog("Autostart file '%s' is not a symlink", + checkLink); + break; + + default: + virStorageLog("Failed to read autostart symlink '%s': %s", + checkLink, strerror(errno)); + break; + } + + goto failed; + } else if (n >= PATH_MAX) { + virStorageLog("Symlink '%s' contents too long to fit in buffer", + checkLink); + goto failed; + } + + dest[n] = '\0'; + + /* make absolute */ + if (dest[0] != '/') { + char dir[PATH_MAX]; + char tmp[PATH_MAX]; + char *p; + + strncpy(dir, checkLink, PATH_MAX); + dir[PATH_MAX] = '\0'; + + if (!(p = strrchr(dir, '/'))) { + virStorageLog("Symlink path '%s' is not absolute", checkLink); + goto failed; + } + + if (p == dir) /* handle unlikely root dir case */ + p++; + + *p = '\0'; + + if (virStorageMakeConfigPath(dir, dest, NULL, tmp, PATH_MAX) < 0) { + virStorageLog("Path '%s/%s' is too long", dir, dest); + goto failed; + } + + strncpy(dest, tmp, PATH_MAX); + dest[PATH_MAX] = '\0'; + } + + /* canonicalize both paths */ + if (!realpath(dest, real)) { + virStorageLog("Failed to expand path '%s' :%s", + dest, strerror(errno)); + strncpy(real, dest, PATH_MAX); + real[PATH_MAX] = '\0'; + } + + if (!realpath(checkDest, checkReal)) { + virStorageLog("Failed to expand path '%s' :%s", + checkDest, strerror(errno)); + strncpy(checkReal, checkDest, PATH_MAX); + checkReal[PATH_MAX] = '\0'; + } + + /* compare */ + if (strcmp(checkReal, real) != 0) { + virStorageLog("Autostart link '%s' is not a symlink to '%s', ignoring", + checkLink, checkReal); + goto failed; + } + + passed = 1; + + failed: + return passed; +} + +static int +virStorageReadFile(const char *path, + char *buf, + int maxlen) { + FILE *fh; + struct stat st; + int ret = 0; + + if (!(fh = fopen(path, "r"))) { + virStorageLog("Failed to open file '%s': %s", + path, strerror(errno)); + goto error; + } + + if (fstat(fileno(fh), &st) < 0) { + virStorageLog("Failed to stat file '%s': %s", + path, strerror(errno)); + goto error; + } + + if (S_ISDIR(st.st_mode)) { + virStorageLog("Ignoring directory '%s' - clearly not a config file", path); + goto error; + } + + if (st.st_size >= maxlen) { + virStorageLog("File '%s' is too large", path); + goto error; + } + + if ((ret = fread(buf, st.st_size, 1, fh)) != 1) { + virStorageLog("Failed to read config file '%s': %s", + path, strerror(errno)); + goto error; + } + + buf[st.st_size] = '\0'; + + ret = 1; + + error: + if (fh) + fclose(fh); + + return ret; +} + + +void virStorageVolDefFree(virStorageVolDefPtr def) { + if (def->name) + free(def->name); + + if (def->format == VIR_STORAGE_VOL_QCOW2 && + def->formatOpts.qcow2.passwd) { + free(def->formatOpts.qcow2.passwd); + } + + if (def->target) + free(def->target); + if (def->perms.label) + free(def->perms.label); + free(def); +} + +void virStoragePoolDefFree(virStoragePoolDefPtr def) { + if (def->name) + free(def->name); + + if (def->srcType == VIR_STORAGE_POOL_SRC_REMOTE) { + if (def->src.remote.hostname) + free(def->src.remote.hostname); + if (def->src.remote.export) + free(def->src.remote.export); + } else { + int i; + for (i = 0 ; i < def->src.local.ndev ; i++) { + if (def->src.local.devs[i]) + free(def->src.local.devs[i]); + } + free(def->src.local.devs); + } + + if (def->target) + free(def->target); + if (def->perms.label) + free(def->perms.label); + free(def); +} + + +void virStoragePoolObjFree(virStoragePoolObjPtr obj) { + if (obj->def) + virStoragePoolDefFree(obj->def); + if (obj->newDef) + virStoragePoolDefFree(obj->newDef); + + free(obj->configFile); + free(obj->autostartLink); + free(obj); +} + +void virStoragePoolObjRemove(virStorageDriverStatePtr driver, + virStoragePoolObjPtr pool) +{ + virStoragePoolObjPtr prev = NULL, curr; + + curr = driver->pools; + while (curr != pool) { + prev = curr; + curr = curr->next; + } + + if (curr) { + if (prev) + prev->next = curr->next; + else + driver->pools = curr->next; + + driver->ninactivePools--; + } + + virStoragePoolObjFree(pool); +} + + +static int virStoragePoolDefTypeFromString(const char *type) { + if (STREQ(type, "dir")) + return VIR_STORAGE_POOL_DIR; + else if (STREQ(type, "fs")) + return VIR_STORAGE_POOL_FS; + else if (STREQ(type, "lvm")) + return VIR_STORAGE_POOL_LVM; + else if (STREQ(type, "disk")) + return VIR_STORAGE_POOL_DISK; + else if (STREQ(type, "iscsi")) + return VIR_STORAGE_POOL_ISCSI; + return -1; +} + +static const char *virStoragePoolDefTypeToString(int type) { + switch (type) { + case VIR_STORAGE_POOL_DIR: + return "dir"; + case VIR_STORAGE_POOL_FS: + return "fs"; + case VIR_STORAGE_POOL_LVM: + return "lvm"; + case VIR_STORAGE_POOL_DISK: + return "disk"; + case VIR_STORAGE_POOL_ISCSI: + return "iscsi"; + } + return NULL; +} + +static int virStorageVolDefFormatFromString(const char *format) { + if (STREQ(format, "raw")) + return VIR_STORAGE_VOL_RAW; + else if (STREQ(format, "qcow")) + return VIR_STORAGE_VOL_QCOW; + else if (STREQ(format, "qcow2")) + return VIR_STORAGE_VOL_QCOW2; + else if (STREQ(format, "vvfat")) + return VIR_STORAGE_VOL_VVFAT; + else if (STREQ(format, "vpc")) + return VIR_STORAGE_VOL_VPC; + else if (STREQ(format, "bochs")) + return VIR_STORAGE_VOL_BOCHS; + else if (STREQ(format, "dmg")) + return VIR_STORAGE_VOL_DMG; + else if (STREQ(format, "cloop")) + return VIR_STORAGE_VOL_CLOOP; + else if (STREQ(format, "vmdk")) + return VIR_STORAGE_VOL_VMDK; + else if (STREQ(format, "cow")) + return VIR_STORAGE_VOL_COW; + + return -1; +} + +static const char *virStorageVolDefFormatToString(int format) { + switch (format) { + case VIR_STORAGE_VOL_RAW: + return "raw"; + case VIR_STORAGE_VOL_QCOW: + return "qcow"; + case VIR_STORAGE_VOL_QCOW2: + return "qcow2"; + case VIR_STORAGE_VOL_VVFAT: + return "vvfat"; + case VIR_STORAGE_VOL_VPC: + return "vpc"; + case VIR_STORAGE_VOL_BOCHS: + return "bochs"; + case VIR_STORAGE_VOL_DMG: + return "dmg"; + case VIR_STORAGE_VOL_CLOOP: + return "cloop"; + case VIR_STORAGE_VOL_VMDK: + return "vmdk"; + case VIR_STORAGE_VOL_COW: + return "cow"; + } + return NULL; +} + +static int virStoragePoolDefParseSrcLocal(virConnectPtr conn, xmlXPathContextPtr ctxt, virStoragePoolSrcLocalPtr src) { + double count; + xmlNodePtr *nodes; + int i; + + if (virXPathNumber("count(/pool/source[@type='local'])", ctxt, &count) < 0) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing source element"); + return -1; + } + + /* Arbitrary cap */ + if (count > 50) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "too many source elements"); + return -1; + } + + src->ndev = (int)count; + src->devs = calloc(src->ndev, sizeof(char*)); + + if (virXPathNodeSet("/pool/source[@type='local']", ctxt, &nodes) < 0) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "cannot extract source nodes"); + return -1; + } + + for (i = 0 ; i < src->ndev ; i++) { + src->devs[i] = (char *)xmlGetProp(nodes[i], BAD_CAST "dev"); + if (src->devs[i] == NULL) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing source dev attribute"); + return -1; + } + } + + return 0; +} + +static int virStoragePoolDefParseSrcRemote(virConnectPtr conn, xmlXPathContextPtr ctxt, virStoragePoolSrcRemotePtr src) { + src->hostname = virXPathString("string(/pool/source/@host)", ctxt); + if (src->hostname == NULL) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing source host attribute"); + return -1; + } + + src->export = virXPathString("string(/pool/source/@export)", ctxt); + if (src->export == NULL) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing source export attribute"); + return -1; + } + + return 0; +} + + +static int virStoragePoolDefParseAuthChap(virConnectPtr conn, xmlXPathContextPtr ctxt, virStoragePoolAuthChapPtr auth) { + auth->login = virXPathString("string(/pool/source/auth/@login)", ctxt); + if (auth->login == NULL) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing auth host attribute"); + return -1; + } + + auth->passwd = virXPathString("string(/pool/source/auth/@passwd)", ctxt); + if (auth->passwd == NULL) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing auth passwd attribute"); + return -1; + } + + return 0; +} + + +static int virStoragePoolDefParsePerms(virConnectPtr conn, xmlXPathContextPtr ctxt, virStoragePermsPtr perms) { + char *mode; + long v; + + mode = virXPathString("string(/pool/permissions/mode)", ctxt); + if (!mode) { + perms->mode = 0700; + } else { + char *end; + printf("[%s]\n", mode); + perms->mode = strtol(mode, &end, 8); + if (end && *end) { + printf("[%s]\n", end); + virStorageReportError(conn, VIR_ERR_XML_ERROR, "malformed octal mode"); + return -1; + } + } + + if (virXPathLong("number(/pool/permissions/owner)", ctxt, &v) < 0) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing owner element"); + return -1; + } + perms->uid = (int)v; + if (virXPathLong("number(/pool/permissions/group)", ctxt, &v) < 0) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing owner element"); + return -1; + } + perms->gid = (int)v; + + perms->label = virXPathString("string(/pool/permissions/label)", ctxt); + + return 0; +} + + +static virStoragePoolDefPtr virStoragePoolDefParseDoc(virConnectPtr conn, xmlXPathContextPtr ctxt, xmlNodePtr root) { + virStoragePoolDefPtr ret = calloc(1, sizeof(virStoragePoolDef)); + xmlChar *type = NULL; + char *uuid = NULL; + char *srcType = NULL; + char *authType = NULL; + + if (ret == NULL) + return NULL; + + if (STRNEQ((const char *)root->name, "pool")) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "unknown root element"); + goto cleanup; + } + + type = xmlGetProp(root, BAD_CAST "type"); + ret->type = virStoragePoolDefTypeFromString((const char *)type); + if (ret->type < 0) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "unsupported storage pool %s", (const char *)type); + goto cleanup; + } + xmlFree(type); + type = NULL; + + ret->name = virXPathString("string(/pool/name)", ctxt); + if (ret->name == NULL) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing name element"); + goto cleanup; + } + + uuid = virXPathString("string(/pool/uuid)", ctxt); + if (uuid == NULL) { + if (virUUIDGenerate(ret->uuid) < 0) { + virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "unable to generate uuid"); + goto cleanup; + } + } else { + if (virUUIDParse(uuid, ret->uuid) < 0) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "malformed uuid element"); + goto cleanup; + } + free(uuid); + uuid = NULL; + } + + + if (type == VIR_STORAGE_POOL_DIR) { + ret->srcType = VIR_STORAGE_POOL_SRC_NONE; + } else { + srcType = virXPathString("string(/pool/source/@type)", ctxt); + if (srcType == NULL) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing type attribute on source element"); + goto cleanup; + } + if (STREQ(srcType, "local")) { + ret->srcType = VIR_STORAGE_POOL_SRC_LOCAL; + } else { + ret->srcType = VIR_STORAGE_POOL_SRC_REMOTE; + } + free(srcType); + srcType = NULL; + + if (ret->srcType == VIR_STORAGE_POOL_SRC_LOCAL) { + if (virStoragePoolDefParseSrcLocal(conn, ctxt, &ret->src.local) < 0) + goto cleanup; + } else { + if (virStoragePoolDefParseSrcRemote(conn, ctxt, &ret->src.remote) < 0) + goto cleanup; + } + } + + + + + authType = virXPathString("string(/pool/auth/@type)", ctxt); + if (authType == NULL) { + ret->authType = VIR_STORAGE_POOL_AUTH_NONE; + } else { + if (STREQ(authType, "chap")) { + ret->authType = VIR_STORAGE_POOL_AUTH_CHAP; + } else { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "unknown auth type '%s'", (const char *)authType); + goto cleanup; + } + free(authType); + authType = NULL; + } + + if (ret->srcType == VIR_STORAGE_POOL_AUTH_CHAP) { + if (virStoragePoolDefParseAuthChap(conn, ctxt, &ret->auth.chap) < 0) + goto cleanup; + } + + + + if (ret->type == VIR_STORAGE_POOL_DIR || + ret->type == VIR_STORAGE_POOL_FS) { + ret->target = virXPathString("string(/pool/target/@dir)", ctxt); + if (ret->target == NULL) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing target dir attribute"); + goto cleanup; + } + } else if (ret->type == VIR_STORAGE_POOL_LVM) { + ret->target = virXPathString("string(/pool/target/@name)", ctxt); + if (ret->target == NULL) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing target name attribute"); + goto cleanup; + } + } + + if (virStoragePoolDefParsePerms(conn, ctxt, &ret->perms) < 0) + goto cleanup; + + return ret; + + cleanup: + if (uuid) + free(uuid); + if (type) + xmlFree(type); + if (srcType) + xmlFree(srcType); + if (authType) + xmlFree(authType); + virStoragePoolDefFree(ret); + return NULL; +} + +virStoragePoolDefPtr virStoragePoolDefParse(virConnectPtr conn, const char *xmlStr, const char *filename) { + virStoragePoolDefPtr ret = NULL; + xmlDocPtr xml = NULL; + xmlNodePtr node = NULL; + xmlXPathContextPtr ctxt = NULL; + + if (!(xml = xmlReadDoc(BAD_CAST xmlStr, filename ? filename : "storage.xml", NULL, + XML_PARSE_NOENT | XML_PARSE_NONET | + XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "malformed xml document"); + goto cleanup; + } + + ctxt = xmlXPathNewContext(xml); + if (ctxt == NULL) { + virStorageReportError(conn, VIR_ERR_NO_MEMORY, "xmlXPathContext"); + goto cleanup; + } + + node = xmlDocGetRootElement(xml); + if (node == NULL) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing root element"); + goto cleanup; + } + + ret = virStoragePoolDefParseDoc(conn, ctxt, node); + + xmlXPathFreeContext(ctxt); + xmlFreeDoc(xml); + + return ret; + + cleanup: + if (ctxt) + xmlXPathFreeContext(ctxt); + if (xml) + xmlFreeDoc(xml); + return NULL; +} + + +char *virStoragePoolDefFormat(virConnectPtr conn, virStoragePoolDefPtr def) { + virBufferPtr buf = virBufferNew(8192); + const char *type; + char uuid[VIR_UUID_STRING_BUFLEN]; + if (!buf) + goto no_memory; + + type = virStoragePoolDefTypeToString(def->type); + if (!type) { + virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "unexpected pool type"); + goto cleanup; + } + if (virBufferVSprintf(buf, "<pool type='%s'>\n", type) < 0) + goto no_memory; + + if (virBufferVSprintf(buf," <name>%s</name>\n", def->name) < 0) + goto no_memory; + + virUUIDFormat(def->uuid, uuid); + if (virBufferVSprintf(buf," <uuid>%s</uuid>\n", uuid) < 0) + goto no_memory; + + if (def->srcType == VIR_STORAGE_POOL_SRC_LOCAL) { + int i; + for (i = 0 ; i < def->src.local.ndev ; i++) { + if (virBufferVSprintf(buf," <source type='local' dev='%s'/>\n", + def->src.local.devs[i]) < 0) + goto no_memory; + } + } else if (def->srcType == VIR_STORAGE_POOL_SRC_REMOTE) { + if (virBufferVSprintf(buf," <source type='remote' host='%s' export='%s'>\n", + def->src.remote.hostname, def->src.remote.export) < 0) + goto no_memory; + if (def->authType == VIR_STORAGE_POOL_AUTH_CHAP) { + if (virBufferVSprintf(buf," <auth type='chap' login='%s' passwd='%s'>\n", + def->auth.chap.login, def->auth.chap.passwd) < 0) + goto no_memory; + } + if (virBufferAdd(buf," </source>\n", -1) < 0) + goto no_memory; + } + + + if (def->target) { + if (def->type == VIR_STORAGE_POOL_DIR || + def->type == VIR_STORAGE_POOL_FS) { + if (virBufferVSprintf(buf," <target dir='%s'/>\n", def->target) < 0) + goto no_memory; + } else if (def->type == VIR_STORAGE_POOL_LVM) { + if (virBufferVSprintf(buf," <target name='%s'/>\n", def->target) < 0) + goto no_memory; + } + } + + if (virBufferAdd(buf," <permissions>\n", -1) < 0) + goto no_memory; + if (virBufferVSprintf(buf," <mode>0%o</mode>\n", def->perms.mode) < 0) + goto no_memory; + if (virBufferVSprintf(buf," <owner>%d</owner>\n", def->perms.uid) < 0) + goto no_memory; + if (virBufferVSprintf(buf," <group>%d</group>\n", def->perms.gid) < 0) + goto no_memory; + + if (def->perms.label) { + if (virBufferVSprintf(buf," <label>%s</label>\n", def->perms.label) < 0) + goto no_memory; + } + if (virBufferAdd(buf," </permissions>\n", -1) < 0) + goto no_memory; + + if (virBufferAdd(buf,"</pool>\n", -1) < 0) + goto no_memory; + + return virBufferContentAndFree(buf); + + no_memory: + virStorageReportError(conn, VIR_ERR_NO_MEMORY, "xml"); + cleanup: + if (buf) virBufferFree(buf); + return NULL; +} + + +static int virStorageVolDefParsePerms(virConnectPtr conn, xmlXPathContextPtr ctxt, virStoragePermsPtr perms) { + char *mode; + long v; + + mode = virXPathString("string(/volume/permissions/mode)", ctxt); + if (!mode) { + perms->mode = 0700; + } else { + char *end; + printf("[%s]\n", mode); + perms->mode = strtol(mode, &end, 8); + if (end && *end) { + printf("[%s]\n", end); + virStorageReportError(conn, VIR_ERR_XML_ERROR, "malformed octal mode"); + return -1; + } + } + + if (virXPathLong("number(/volume/permissions/owner)", ctxt, &v) < 0) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing owner element"); + return -1; + } + perms->uid = (int)v; + if (virXPathLong("number(/volume/permissions/group)", ctxt, &v) < 0) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing owner element"); + return -1; + } + perms->gid = (int)v; + + perms->label = virXPathString("string(/volume/permissions/label)", ctxt); + + return 0; +} + + + +static virStorageVolDefPtr virStorageVolDefParseDoc(virConnectPtr conn, xmlXPathContextPtr ctxt, xmlNodePtr root) { + virStorageVolDefPtr ret = calloc(1, sizeof(virStorageVolDef)); + xmlChar *type = NULL; + char *allocation = NULL; + char *capacity = NULL; + char *uuid = NULL; + char *formatType = NULL; + char *end; + + if (ret == NULL) + return NULL; + + if (STRNEQ((const char *)root->name, "volume")) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "unknown root element"); + goto cleanup; + } + + type = xmlGetProp(root, BAD_CAST "type"); + if (STREQ((const char*)type, "file")) + ret->type = VIR_STORAGE_VOL_FILE; + else + ret->type = VIR_STORAGE_VOL_BLOCK; + xmlFree(type); + type = NULL; + + ret->name = virXPathString("string(/volume/name)", ctxt); + if (ret->name == NULL) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing name element"); + goto cleanup; + } + + uuid = virXPathString("string(/volume/uuid)", ctxt); + if (uuid == NULL) { + if (virUUIDGenerate(ret->uuid) < 0) { + virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "unable to generate uuid"); + goto cleanup; + } + } else { + if (virUUIDParse(uuid, ret->uuid) < 0) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "malformed uuid element"); + goto cleanup; + } + free(uuid); + uuid = NULL; + } + + capacity = virXPathString("string(/volume/capacity)", ctxt); + if (capacity == NULL) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing capacity element"); + goto cleanup; + } + ret->capacity = strtoull(capacity, &end, 10); + if (end && *end) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "malformed capacity element"); + goto cleanup; + } + free(capacity); + capacity = NULL; + + allocation = virXPathString("string(/volume/allocation)", ctxt); + if (allocation) { + ret->allocation = strtoull(allocation, &end, 10); + if (end && *end) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "malformed allocation element"); + goto cleanup; + } + free(allocation); + allocation = NULL; + } + + formatType = virXPathString("string(/volume/format/@type)", ctxt); + if (formatType == NULL) { + ret->format = VIR_STORAGE_VOL_RAW; + } else { + ret->format = virStorageVolDefFormatFromString((const char *)formatType); + if (ret->format < 0) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "unsupported storage volume format %s", (const char *)formatType); + goto cleanup; + } + xmlFree(formatType); + formatType = NULL; + } + + if (virStorageVolDefParsePerms(conn, ctxt, &ret->perms) < 0) + goto cleanup; + + return ret; + + cleanup: + if (allocation) + free(allocation); + if (capacity) + free(capacity); + if (uuid) + free(uuid); + if (type) + xmlFree(type); + if (formatType) + xmlFree(formatType); + virStorageVolDefFree(ret); + return NULL; +} + + +virStorageVolDefPtr virStorageVolDefParse(virConnectPtr conn, const char *xmlStr, const char *filename) { + virStorageVolDefPtr ret = NULL; + xmlDocPtr xml = NULL; + xmlNodePtr node = NULL; + xmlXPathContextPtr ctxt = NULL; + + if (!(xml = xmlReadDoc(BAD_CAST xmlStr, filename ? filename : "storage.xml", NULL, + XML_PARSE_NOENT | XML_PARSE_NONET | + XML_PARSE_NOERROR | XML_PARSE_NOWARNING))) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "malformed xml document"); + goto cleanup; + } + + ctxt = xmlXPathNewContext(xml); + if (ctxt == NULL) { + virStorageReportError(conn, VIR_ERR_NO_MEMORY, "xmlXPathContext"); + goto cleanup; + } + + node = xmlDocGetRootElement(xml); + if (node == NULL) { + virStorageReportError(conn, VIR_ERR_XML_ERROR, "missing root element"); + goto cleanup; + } + + ret = virStorageVolDefParseDoc(conn, ctxt, node); + + xmlXPathFreeContext(ctxt); + xmlFreeDoc(xml); + + return ret; + + cleanup: + if (ctxt) + xmlXPathFreeContext(ctxt); + if (xml) + xmlFreeDoc(xml); + return NULL; +} + + + +char *virStorageVolDefFormat(virConnectPtr conn, virStorageVolDefPtr def) { + virBufferPtr buf = virBufferNew(8192); + char uuid[VIR_UUID_STRING_BUFLEN]; + if (!buf) + goto no_memory; + + if (virBufferVSprintf(buf, "<volume type='%s'>\n", def->type == VIR_STORAGE_VOL_FILE ? "file" : "block") < 0) + goto no_memory; + + if (virBufferVSprintf(buf," <name>%s</name>\n", def->name) < 0) + goto no_memory; + + virUUIDFormat(def->uuid, uuid); + if (virBufferVSprintf(buf," <uuid>%s</uuid>\n", uuid) < 0) + goto no_memory; + + if (virBufferVSprintf(buf," <capacity>%llu</capacity>\n", def->capacity) < 0) + goto no_memory; + if (virBufferVSprintf(buf," <allocation>%llu</allocation>\n", def->allocation) < 0) + goto no_memory; + + + if (def->type == VIR_STORAGE_VOL_FILE) { + const char *format = virStorageVolDefFormatToString(def->format); + if (format == NULL) { + virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "unexpected volume format %s", def->format); + goto cleanup; + } + if (def->format == VIR_STORAGE_VOL_QCOW2) { + if (virBufferVSprintf(buf," <format type='%s'/>\n", format) < 0) + goto no_memory; + if (def->formatOpts.qcow2.compress) { + if (virBufferAdd(buf," <compressed/>\n", -1) < 0) + goto no_memory; + } + if (def->formatOpts.qcow2.encrypted) { + if (virBufferAdd(buf," <encrypted/>\n", -1) < 0) + goto no_memory; + } + if (virBufferAdd(buf," </format>\n", -1) < 0) + goto no_memory; + } else { + if (virBufferVSprintf(buf," <format type='%s'/>\n", format) < 0) + goto no_memory; + } + } + + if (def->target) { + if (def->type == VIR_STORAGE_POOL_FILE) { + if (virBufferVSprintf(buf," <target file='%s'/>\n", def->target) < 0) + goto no_memory; + } else { + if (virBufferVSprintf(buf," <target dev='%s'/>\n", def->target) < 0) + goto no_memory; + } + } + + if (virBufferAdd(buf," <permissions>\n", -1) < 0) + goto no_memory; + if (virBufferVSprintf(buf," <mode>0%o</mode>\n", def->perms.mode) < 0) + goto no_memory; + if (virBufferVSprintf(buf," <owner>%d</owner>\n", def->perms.uid) < 0) + goto no_memory; + if (virBufferVSprintf(buf," <group>%d</group>\n", def->perms.gid) < 0) + goto no_memory; + + if (def->perms.label) { + if (virBufferVSprintf(buf," <label>%s</label>\n", def->perms.label) < 0) + goto no_memory; + } + if (virBufferAdd(buf," </permissions>\n", -1) < 0) + goto no_memory; + + if (virBufferAdd(buf,"</volume>\n", -1) < 0) + goto no_memory; + + return virBufferContentAndFree(buf); + + no_memory: + virStorageReportError(conn, VIR_ERR_NO_MEMORY, "xml"); + cleanup: + if (buf) virBufferFree(buf); + return NULL; +} + + +virStoragePoolObjPtr virStoragePoolObjFindByUUID(virStorageDriverStatePtr driver, + const unsigned char *uuid) { + virStoragePoolObjPtr pool = driver->pools; + + while (pool) { + if (!memcmp(pool->def->uuid, uuid, VIR_UUID_BUFLEN)) + return pool; + pool = pool->next; + } + + return NULL; +} + +virStoragePoolObjPtr virStoragePoolObjFindByName(virStorageDriverStatePtr driver, + const char *name) { + virStoragePoolObjPtr pool = driver->pools; + + while (pool) { + if (STREQ(pool->def->name, name)) + return pool; + pool = pool->next; + } + + return NULL; +} + + +virStorageVolDefPtr virStorageVolDefFindByUUID(virStoragePoolObjPtr pool, + const unsigned char *uuid) { + virStorageVolDefPtr vol = pool->volumes; + + while (vol) { + if (!memcmp(vol->uuid, uuid, VIR_UUID_BUFLEN)) + return vol; + vol = vol->next; + } + + return NULL; +} + +virStorageVolDefPtr virStorageVolDefFindByName(virStoragePoolObjPtr pool, + const char *name) { + virStorageVolDefPtr vol = pool->volumes; + + while (vol) { + if (STREQ(vol->name, name)) + return vol; + vol = vol->next; + } + + return NULL; +} + +virStoragePoolObjPtr virStoragePoolObjAssignDef(virConnectPtr conn, + virStorageDriverStatePtr driver, + virStoragePoolDefPtr def) { + virStoragePoolObjPtr pool; + + if ((pool = virStoragePoolObjFindByName(driver, def->name))) { + if (!virStoragePoolObjIsActive(pool)) { + virStoragePoolDefFree(pool->def); + pool->def = def; + } else { + if (pool->newDef) + virStoragePoolDefFree(pool->newDef); + pool->newDef = def; + } + return pool; + } + + if (!(pool = calloc(1, sizeof(virStoragePoolObj)))) { + virStorageReportError(conn, VIR_ERR_NO_MEMORY, "pool"); + return NULL; + } + + pool->active = 0; + pool->def = def; + pool->next = driver->pools; + + driver->pools = pool; + driver->ninactivePools++; + printf("inactive %d\n", driver->ninactivePools); + return pool; +} + +static virStoragePoolObjPtr +virStoragePoolObjLoad(virStorageDriverStatePtr driver, + const char *file, + const char *path, + const char *xml, + const char *autostartLink) { + virStoragePoolDefPtr def; + virStoragePoolObjPtr pool; + + if (!(def = virStoragePoolDefParse(NULL, xml, file))) { + virErrorPtr err = virGetLastError(); + virStorageLog("Error parsing storage pool config '%s' : %s", + path, err->message); + return NULL; + } + + if (!compareFileToNameSuffix(file, def->name, ".xml")) { + virStorageLog("Storage Pool config filename '%s' does not match pool name '%s'", + path, def->name); + virStoragePoolDefFree(def); + return NULL; + } + + if (!(pool = virStoragePoolObjAssignDef(NULL, driver, def))) { + virStorageLog("Failed to load storage pool config '%s': out of memory", path); + virStoragePoolDefFree(def); + return NULL; + } + + pool->configFile = strdup(path); + if (pool->configFile == NULL) { + virStorageLog("Failed to load storage pool config '%s': out of memory", path); + virStoragePoolDefFree(def); + return NULL; + } + pool->autostartLink = strdup(autostartLink); + if (pool->autostartLink == NULL) { + virStorageLog("Failed to load storage pool config '%s': out of memory", path); + virStoragePoolDefFree(def); + return NULL; + } + + pool->autostart = checkLinkPointsTo(pool->autostartLink, pool->configFile); + + return pool; +} + + +int virStoragePoolObjScanConfigs(virStorageDriverStatePtr driver) { + DIR *dir; + struct dirent *entry; + + if (!(dir = opendir(driver->configDir))) { + if (errno == ENOENT) + return 0; + virStorageLog("Failed to open dir '%s': %s", + driver->configDir, strerror(errno)); + return -1; + } + + while ((entry = readdir(dir))) { + char xml[8192]; + char path[PATH_MAX]; + char autostartLink[PATH_MAX]; + + if (entry->d_name[0] == '.') + continue; + + if (!hasSuffix(entry->d_name, ".xml")) + continue; + + if (virStorageMakeConfigPath(driver->configDir, entry->d_name, NULL, path, PATH_MAX) < 0) { + virStorageLog("Config filename '%s/%s' is too long", + driver->configDir, entry->d_name); + continue; + } + + if (virStorageMakeConfigPath(driver->autostartDir, entry->d_name, NULL, autostartLink, PATH_MAX) < 0) { + virStorageLog("Autostart link path '%s/%s' is too long", + driver->autostartDir, entry->d_name); + continue; + } + + if (!virStorageReadFile(path, xml, sizeof(xml))) + continue; + + virStoragePoolObjLoad(driver, entry->d_name, path, xml, autostartLink); + } + + closedir(dir); + + return 0; +} + +int virStoragePoolObjSaveDef(virConnectPtr conn, + virStorageDriverStatePtr driver, + virStoragePoolObjPtr pool, + virStoragePoolDefPtr def) { + char *xml; + int fd = -1, ret = -1; + int towrite; + + if (!pool->configFile) { + int err; + char path[PATH_MAX]; + + if ((err = virStorageEnsureDir(driver->configDir))) { + virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, + "cannot create config directory %s: %s", + driver->configDir, strerror(err)); + return -1; + } + + if (virStorageMakeConfigPath(driver->configDir, def->name, ".xml", + path, sizeof(path)) < 0) { + virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, + "cannot construct config file path"); + return -1; + } + if (!(pool->configFile = strdup(path))) { + virStorageReportError(conn, VIR_ERR_NO_MEMORY, "configFile"); + return -1; + } + + if (virStorageMakeConfigPath(driver->autostartDir, def->name, ".xml", + path, sizeof(path)) < 0) { + virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, + "cannot construct autostart link path"); + free(pool->configFile); + pool->configFile = NULL; + return -1; + } + if (!(pool->autostartLink = strdup(path))) { + virStorageReportError(conn, VIR_ERR_NO_MEMORY, "configFile"); + free(pool->configFile); + pool->configFile = NULL; + return -1; + } + } + + if (!(xml = virStoragePoolDefFormat(conn, def))) { + virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, + "failed to generate XML"); + return -1; + } + + if ((fd = open(pool->configFile, + O_WRONLY | O_CREAT | O_TRUNC, + S_IRUSR | S_IWUSR )) < 0) { + virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, + "cannot create config file %s: %s", + pool->configFile, strerror(errno)); + goto cleanup; + } + + towrite = strlen(xml); + if (write(fd, xml, towrite) != towrite) { + virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, + "cannot write config file %s: %s", + pool->configFile, strerror(errno)); + goto cleanup; + } + + if (close(fd) < 0) { + virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, + "cannot save config file %s: %s", + pool->configFile, strerror(errno)); + goto cleanup; + } + + ret = 0; + + cleanup: + if (fd != -1) + close(fd); + + free(xml); + + return ret; +} + +int virStoragePoolObjDeleteDef(virConnectPtr conn, virStoragePoolObjPtr pool) { + if (!pool->configFile) { + virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "no config file for %s", pool->def->name); + return -1; + } + + if (unlink(pool->configFile) < 0) { + virStorageReportError(conn, VIR_ERR_INTERNAL_ERROR, "cannot remove config for %s", pool->def->name); + return -1; + } + + return 0; +} + +/* + * Local variables: + * indent-tabs-mode: nil + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */ diff -r f57805779ece src/storage_conf.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/storage_conf.h Sun Oct 28 22:45:04 2007 -0400 @@ -0,0 +1,222 @@ + +#ifndef __VIR_STORAGE_DRIVER_H__ +#define __VIR_STORAGE_DRIVER_H__ + +#ifdef __cplusplus +extern "C" { +#endif + + +#include <libvirt/libvirt.h> +#include "internal.h" + + typedef struct _virStoragePerms virStoragePerms; + typedef virStoragePerms *virStoragePermsPtr; + struct _virStoragePerms { + int mode; + int uid; + int gid; + char *label; + }; + + + + enum virStorageVolType { + VIR_STORAGE_VOL_FILE, + VIR_STORAGE_VOL_BLOCK, + }; + + enum virStorageVolFormat { + VIR_STORAGE_VOL_RAW, + VIR_STORAGE_VOL_QCOW, + VIR_STORAGE_VOL_QCOW2, + VIR_STORAGE_VOL_VVFAT, + VIR_STORAGE_VOL_VPC, + VIR_STORAGE_VOL_BOCHS, + VIR_STORAGE_VOL_DMG, + VIR_STORAGE_VOL_CLOOP, + VIR_STORAGE_VOL_VMDK, + VIR_STORAGE_VOL_COW, + }; + + typedef struct _virStorageVolDef virStorageVolDef; + typedef virStorageVolDef *virStorageVolDefPtr; + struct _virStorageVolDef { + char *name; + unsigned char uuid[VIR_UUID_BUFLEN]; + int type; + int format; + union { + struct { + int compress :1; + int encrypted :1; + char *passwd; + } qcow2; + } formatOpts; + virStoragePerms perms; + char *target; + unsigned long long allocation; + unsigned long long capacity; + + virStorageVolDefPtr next; + }; + + enum virStoragePoolType { + VIR_STORAGE_POOL_DIR, + VIR_STORAGE_POOL_FS, + VIR_STORAGE_POOL_LVM, + VIR_STORAGE_POOL_DISK, + VIR_STORAGE_POOL_ISCSI, + }; + + enum virStoragePoolSrcType { + VIR_STORAGE_POOL_SRC_NONE, + VIR_STORAGE_POOL_SRC_LOCAL, + VIR_STORAGE_POOL_SRC_REMOTE, + }; + + enum virStoragePoolAuthType { + VIR_STORAGE_POOL_AUTH_NONE, + VIR_STORAGE_POOL_AUTH_CHAP, + }; + + typedef struct _virStoragePoolAuthChap virStoragePoolAuthChap; + typedef virStoragePoolAuthChap *virStoragePoolAuthChapPtr; + struct _virStoragePoolAuthChap { + char *login; + char *passwd; + }; + + typedef struct _virStoragePoolSrcRemote virStoragePoolSrcRemote; + typedef virStoragePoolSrcRemote *virStoragePoolSrcRemotePtr; + struct _virStoragePoolSrcRemote { + char *hostname; + char *export; + }; + + typedef struct _virStoragePoolSrcLocal virStoragePoolSrcLocal; + typedef virStoragePoolSrcLocal *virStoragePoolSrcLocalPtr; + struct _virStoragePoolSrcLocal { + int ndev; + char **devs; + }; + + typedef struct _virStoragePoolDef virStoragePoolDef; + typedef virStoragePoolDef *virStoragePoolDefPtr; + + struct _virStoragePoolDef { + /* General metadata */ + char *name; + unsigned char uuid[VIR_UUID_BUFLEN]; + int type; /* virStoragePoolType */ + + + /* Source info */ + int srcType; /* virStoragePoolSrcType */ + union { + virStoragePoolSrcRemote remote; + virStoragePoolSrcLocal local; + } src; + + int authType; /* virStoragePoolAuthType */ + union { + virStoragePoolAuthChap chap; + } auth; + + + /* Local filesystem mapping */ + char *target; + virStoragePerms perms; + }; + + typedef struct _virStoragePoolObj virStoragePoolObj; + typedef virStoragePoolObj *virStoragePoolObjPtr; + + struct _virStoragePoolObj { + char *configFile; + char *autostartLink; + int active; + int autostart; + + virStoragePoolDefPtr def; + virStoragePoolDefPtr newDef; + + int nvolumes; + virStorageVolDefPtr volumes; + + virStoragePoolObjPtr next; + }; + + typedef struct _virStorageDriverState virStorageDriverState; + typedef virStorageDriverState *virStorageDriverStatePtr; + + struct _virStorageDriverState { + int nactivePools; + int ninactivePools; + virStoragePoolObjPtr pools; + char *configDir; + char *autostartDir; + }; + + + static inline int virStoragePoolObjIsActive(virStoragePoolObjPtr pool) { + return pool->active; + } + + int virStorageEnsureDir(const char *path); + + void virStorageReportError(virConnectPtr conn, int code, const char *fmt, ...); + + int virStoragePoolObjScanConfigs(virStorageDriverStatePtr driver); + + virStoragePoolObjPtr virStoragePoolObjFindByUUID(virStorageDriverStatePtr driver, + const unsigned char *uuid); + virStoragePoolObjPtr virStoragePoolObjFindByName(virStorageDriverStatePtr driver, + const char *name); + + virStorageVolDefPtr virStorageVolDefFindByUUID(virStoragePoolObjPtr pool, + const unsigned char *uuid); + virStorageVolDefPtr virStorageVolDefFindByName(virStoragePoolObjPtr pool, + const char *name); + + virStoragePoolDefPtr virStoragePoolDefParse(virConnectPtr conn, const char *xml, const char *filename); + char *virStoragePoolDefFormat(virConnectPtr conn, virStoragePoolDefPtr def); + + virStorageVolDefPtr virStorageVolDefParse(virConnectPtr conn, const char *xml, const char *filename); + char *virStorageVolDefFormat(virConnectPtr conn, virStorageVolDefPtr def); + + virStoragePoolObjPtr virStoragePoolObjAssignDef(virConnectPtr conn, + virStorageDriverStatePtr driver, + virStoragePoolDefPtr def); + + int virStoragePoolObjSaveDef(virConnectPtr conn, + virStorageDriverStatePtr driver, + virStoragePoolObjPtr pool, + virStoragePoolDefPtr def); + int virStoragePoolObjDeleteDef(virConnectPtr conn, virStoragePoolObjPtr pool); + + void virStorageVolDefFree(virStorageVolDefPtr def); + void virStoragePoolDefFree(virStoragePoolDefPtr def); + void virStoragePoolObjFree(virStoragePoolObjPtr pool); + void virStoragePoolObjRemove(virStorageDriverStatePtr driver, + virStoragePoolObjPtr pool); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif /* __VIR_STORAGE_DRIVER_H__ */ + + +/* + * vim: set tabstop=4: + * vim: set shiftwidth=4: + * vim: set expandtab: + */ +/* + * Local variables: + * indent-tabs-mode: nil + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */ diff -r f57805779ece src/storage_driver.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/storage_driver.c Sun Oct 28 22:45:04 2007 -0400 @@ -0,0 +1,996 @@ + +#define _GNU_SOURCE +#include <stdio.h> +#include <unistd.h> +#include <sys/types.h> +#include <pwd.h> +#include <errno.h> + +#include "driver.h" +#include "storage_driver.h" +#include "storage_conf.h" + +#include "storage_backend.h" +#include "storage_backend_iscsi.h" +#include "storage_backend_lvm.h" +#include "storage_backend_disk.h" +#include "storage_backend_fs.h" + +#define storageLog(msg...) fprintf(stderr, msg) + +static virStorageDriverStatePtr driverState; +static virStoragePoolBackendPtr backends[] = { + &virStoragePoolBackendDirectory, + &virStoragePoolBackendFileSystem, + &virStoragePoolBackendDisk, + &virStoragePoolBackendLVM, + &virStoragePoolBackendISCSI, +}; + +static int storageDriverShutdown(void); + +static virStoragePoolBackendPtr storageBackend(int type) { + int i; + for (i = 0 ; i < (sizeof(backends)/sizeof(backends[0])) ; i++) + if (backends[i]->type == type) + return backends[i]; + + virStorageReportError(NULL, VIR_ERR_INTERNAL_ERROR, "missing backend for pool type %d", type); + return NULL; +} + + +static void storageDriverAutostart(virStorageDriverStatePtr driver) { + virStoragePoolObjPtr pool; + + pool = driver->pools; + while (pool != NULL) { + virStoragePoolObjPtr next = pool->next; + + if (pool->autostart && + !virStoragePoolObjIsActive(pool)) { + virStoragePoolBackendPtr backend; + if ((backend = storageBackend(pool->def->type)) == NULL) { + storageLog("Missing backend %d", + pool->def->type); + pool = next; + continue; + } + + if (backend->start(pool) < 0) { + virErrorPtr err = virGetLastError(); + storageLog("Failed to autostart storage pool '%s': %s", + pool->def->name, err->message); + } + pool->active = 1; + driver->nactivePools++; + driver->ninactivePools--; + } + + pool = next; + } +} + +/** + * virStorageStartup: + * + * Initialization function for the QEmu daemon + */ +static int +storageDriverStartup(void) { + uid_t uid = geteuid(); + struct passwd *pw; + char *base = NULL; + char driverConf[PATH_MAX]; + + if (!(driverState = calloc(1, sizeof(virStorageDriverState)))) { + return -1; + } + + if (!uid) { + if ((base = strdup (SYSCONF_DIR "/libvirt")) == NULL) + goto out_of_memory; + } else { + if (!(pw = getpwuid(uid))) { + storageLog("Failed to find user record for uid '%d': %s", + uid, strerror(errno)); + goto out_of_memory; + } + + if (asprintf (&base, "%s/.libvirt", pw->pw_dir) == -1) { + storageLog("out of memory in asprintf"); + goto out_of_memory; + } + } + + /* Configuration paths are either ~/.libvirt/storage/... (session) or + * /etc/libvirt/storage/... (system). + */ + if (snprintf (driverConf, sizeof(driverConf), "%s/storage.conf", base) == -1) + goto out_of_memory; + driverConf[sizeof(driverConf)-1] = '\0'; + + if (asprintf (&driverState->configDir, "%s/storage", base) == -1) + goto out_of_memory; + + if (asprintf (&driverState->autostartDir, "%s/storage/autostart", base) == -1) + goto out_of_memory; + + free(base); + + /* + if (virStorageLoadDriverConfig(driver, driverConf) < 0) { + virStorageDriverShutdown(); + return -1; + } + */ + + if (virStoragePoolObjScanConfigs(driverState) < 0) { + storageDriverShutdown(); + return -1; + } + storageDriverAutostart(driverState); + + return 0; + + out_of_memory: + storageLog("virStorageStartup: out of memory"); + if (base) free (base); + free(driverState); + driverState = NULL; + return -1; +} + +/** + * virStorageReload: + * + * Function to restart the storage driver, it will recheck the configuration + * files and update its state + */ +static int +storageDriverReload(void) { + virStoragePoolObjScanConfigs(driverState); + storageDriverAutostart(driverState); + + return 0; +} + +/** + * virStorageActive: + * + * Checks if the storage driver is active, i.e. has an active pool + * + * Returns 1 if active, 0 otherwise + */ +static int +storageDriverActive(void) { + /* If we've any active networks or guests, then we + * mark this driver as active + */ + if (driverState->nactivePools) + return 1; + + /* Otherwise we're happy to deal with a shutdown */ + return 0; +} + +/** + * virStorageShutdown: + * + * Shutdown the storage driver, it will stop all active storage pools + */ +static int +storageDriverShutdown(void) { + virStoragePoolObjPtr pool; + + if (!driverState) + return -1; + + /* shutdown active networks */ + pool = driverState->pools; + while (pool) { + virStoragePoolObjPtr next = pool->next; + if (virStoragePoolObjIsActive(pool)) { + virStoragePoolBackendPtr backend; + if ((backend = storageBackend(pool->def->type)) == NULL) { + storageLog("Missing backend"); + continue; + } + + if (backend->stop(pool) < 0) { + virErrorPtr err = virGetLastError(); + storageLog("Failed to stop storage pool '%s': %s", + pool->def->name, err->message); + } + } + pool = next; + } + + /* free inactive networks */ + pool = driverState->pools; + while (pool) { + virStoragePoolObjPtr next = pool->next; + virStoragePoolObjFree(pool); + pool = next; + } + driverState->pools = NULL; + driverState->nactivePools = 0; + driverState->ninactivePools = 0; + + if (driverState->configDir) + free(driverState->configDir); + if (driverState->autostartDir) + free(driverState->autostartDir); + + free(driverState); + driverState = NULL; + + return 0; +} + + + +static virStoragePoolPtr storagePoolLookupByUUID(virConnectPtr conn, + const unsigned char *uuid) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, uuid); + virStoragePoolPtr ret; + + if (!pool) { + virStorageReportError(conn, VIR_ERR_NO_STORAGE_POOL, "no pool with matching uuid"); + return NULL; + } + + ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid); + return ret; +} + +static virStoragePoolPtr storagePoolLookupByName(virConnectPtr conn, + const char *name) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByName(driver, name); + virStoragePoolPtr ret; + + if (!pool) { + virStorageReportError(conn, VIR_ERR_NO_STORAGE_POOL, "no pool with matching name"); + return NULL; + } + + ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid); + return ret; +} + +static virDrvOpenStatus storageOpen(virConnectPtr conn, + const char *name ATTRIBUTE_UNUSED, + int flags ATTRIBUTE_UNUSED) { + if (!driverState) + return VIR_DRV_OPEN_DECLINED; + + conn->storagePrivateData = driverState; + return VIR_DRV_OPEN_SUCCESS; +} + +static int storageClose(virConnectPtr conn) { + conn->storagePrivateData = NULL; + return 0; +} + +static int storageNumPools(virConnectPtr conn) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)conn->storagePrivateData; + printf("<<< %d \n", driver->nactivePools); + return driver->nactivePools; +} + +static int storageListPools(virConnectPtr conn, char **const names, int nnames) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)conn->storagePrivateData; + virStoragePoolObjPtr pool = driver->pools; + int got = 0, i; + while (pool && got < nnames) { + if (virStoragePoolObjIsActive(pool)) { + if (!(names[got] = strdup(pool->def->name))) { + virStorageReportError(conn, VIR_ERR_NO_MEMORY, "names"); + goto cleanup; + } + got++; + } + pool = pool->next; + } + return got; + + cleanup: + for (i = 0 ; i < got ; i++) + free(names[i]); + return -1; +} + +static int storageNumDefinedPools(virConnectPtr conn) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)conn->storagePrivateData; + printf(">>> %d \n", driver->ninactivePools); + return driver->ninactivePools; +} + +static int storageListDefinedPools(virConnectPtr conn, char **const names, int nnames) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)conn->storagePrivateData; + virStoragePoolObjPtr pool = driver->pools; + int got = 0, i; + while (pool && got < nnames) { + if (!virStoragePoolObjIsActive(pool)) { + if (!(names[got] = strdup(pool->def->name))) { + virStorageReportError(conn, VIR_ERR_NO_MEMORY, "names"); + goto cleanup; + } + got++; + } + pool = pool->next; + } + return got; + + cleanup: + for (i = 0 ; i < got ; i++) + free(names[i]); + return -1; +} + +static virStoragePoolPtr storagePoolCreate(virConnectPtr conn, const char *xml) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr )conn->storagePrivateData; + virStoragePoolDefPtr def; + virStoragePoolObjPtr pool; + virStoragePoolPtr ret; + virStoragePoolBackendPtr backend; + + printf("Create %p %d %d\n", driver->pools, driver->nactivePools, driver->ninactivePools); + if (!(def = virStoragePoolDefParse(conn, xml, NULL))) + return NULL; + + if ((backend = storageBackend(def->type)) == NULL) { + virStoragePoolDefFree(def); + return NULL; + } + + if (!(pool = virStoragePoolObjAssignDef(conn, driver, def))) { + virStoragePoolDefFree(def); + return NULL; + } + + if (backend->start(pool) < 0) { + virStoragePoolObjRemove(driver, pool); + return NULL; + } + pool->active = 1; + driver->nactivePools++; + driver->ninactivePools--; + + ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid); + printf("Created %p %d %d\n", driver->pools, driver->nactivePools, driver->ninactivePools); + return ret; +} + +static virStoragePoolPtr storagePoolDefine(virConnectPtr conn, const char *xml) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr )conn->storagePrivateData; + virStoragePoolDefPtr def; + virStoragePoolObjPtr pool; + virStoragePoolPtr ret; + virStoragePoolBackendPtr backend; + + if (!(def = virStoragePoolDefParse(conn, xml, NULL))) + return NULL; + + if ((backend = storageBackend(def->type)) == NULL) { + virStoragePoolDefFree(def); + return NULL; + } + + if (!(pool = virStoragePoolObjAssignDef(conn, driver, def))) { + virStoragePoolDefFree(def); + return NULL; + } + + if (virStoragePoolObjSaveDef(conn, driver, pool, def) < 0) { + virStoragePoolObjRemove(driver, pool); + return NULL; + } + + ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid); + return ret; +} + +static int storagePoolUndefine(virStoragePoolPtr obj) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)obj->conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, obj->uuid); + + if (!pool) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage pool with matching uuid"); + return -1; + } + + if (virStoragePoolObjDeleteDef(obj->conn, pool) < 0) + return -1; + + if (unlink(pool->autostartLink) < 0 && errno != ENOENT && errno != ENOTDIR) + storageLog("Failed to delete autostart link '%s': %s", + pool->autostartLink, strerror(errno)); + + free(pool->configFile); + pool->configFile = NULL; + free(pool->autostartLink); + pool->autostartLink = NULL; + + virStoragePoolObjRemove(driver, pool); + + return 0; +} + +static int storagePoolStart(virStoragePoolPtr obj) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)obj->conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, obj->uuid); + virStoragePoolBackendPtr backend; + + if (!pool) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage pool with matching uuid"); + return -1; + } + + if ((backend = storageBackend(pool->def->type)) == NULL) { + return -1; + } + + if (virStoragePoolObjIsActive(pool)) { + virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR, "pool already active"); + return -1; + } + if (backend->start(pool) < 0) + return -1; + + pool->active = 1; + driver->nactivePools++; + driver->ninactivePools--; + + return 0; +} + +static int storagePoolShutdown(virStoragePoolPtr obj) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)obj->conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, obj->uuid); + virStoragePoolBackendPtr backend; + + if (!pool) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no stoage pool with matching uuid"); + return -1; + } + + if ((backend = storageBackend(pool->def->type)) == NULL) { + return -1; + } + + if (!virStoragePoolObjIsActive(pool)) { + virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR, + "storage pool is not active"); + return -1; + } + + if (backend->stop(pool) < 0) + return -1; + + pool->active = 0; + driver->nactivePools--; + driver->ninactivePools++; + + return 0; +} + +static int storagePoolDestroy(virStoragePoolPtr obj) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)obj->conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, obj->uuid); + virStoragePoolBackendPtr backend; + int ret = 0; + + if (!pool) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no stoage pool with matching uuid"); + return -1; + } + + if ((backend = storageBackend(pool->def->type)) == NULL) { + return -1; + } + + if (!virStoragePoolObjIsActive(pool)) { + virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR, + "storage pool is not active"); + return -1; + } + ret = backend->stop(pool); + + if (ret == 0) { + pool->active = 0; + driver->nactivePools--; + driver->ninactivePools++; + } + + virFreeStoragePool(obj->conn, obj); + + return ret; +} + +static int storagePoolGetInfo(virStoragePoolPtr obj, virStoragePoolInfoPtr info) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)obj->conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, obj->uuid); + virStoragePoolBackendPtr backend; + + if (!pool) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage pool with matching uuid"); + return -1; + } + + if ((backend = storageBackend(pool->def->type)) == NULL) { + return -1; + } + + memset(info, 0, sizeof(virStoragePoolInfo)); + if (pool->active) + info->state = VIR_STORAGE_POOL_ACTIVE; + else + info->state = VIR_STORAGE_POOL_INACTIVE; + + return 0; +} + +static char *storagePoolDumpXML(virStoragePoolPtr obj, int flags ATTRIBUTE_UNUSED) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)obj->conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, obj->uuid); + + if (!pool) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage pool with matching uuid"); + return NULL; + } + + return virStoragePoolDefFormat(obj->conn, pool->def); +} + +static int storagePoolGetAutostart(virStoragePoolPtr obj, + int *autostart) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)obj->conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, obj->uuid); + + if (!pool) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no pool with matching uuid"); + return -1; + } + + if (!pool->configFile) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_ARG, + "pool has no config file"); + return -1; + } + + *autostart = pool->autostart; + + return 0; +} + +static int storagePoolSetAutostart(virStoragePoolPtr obj, + int autostart) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)obj->conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, obj->uuid); + + if (!pool) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no pool with matching uuid"); + return -1; + } + + if (!pool->configFile) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_ARG, + "pool has no config file"); + return -1; + } + + autostart = (autostart != 0); + + if (pool->autostart == autostart) + return 0; + + if (autostart) { + int err; + + if ((err = virStorageEnsureDir(driver->autostartDir))) { + virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR, + "cannot create autostart directory %s: %s", + driver->autostartDir, strerror(err)); + return -1; + } + + if (symlink(pool->configFile, pool->autostartLink) < 0) { + virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR, + "Failed to create symlink '%s' to '%s': %s", + pool->autostartLink, pool->configFile, strerror(errno)); + return -1; + } + } else { + if (unlink(pool->autostartLink) < 0 && errno != ENOENT && errno != ENOTDIR) { + virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR, + "Failed to delete symlink '%s': %s", + pool->autostartLink, strerror(errno)); + return -1; + } + } + + pool->autostart = autostart; + + return 0; +} + + +static int storagePoolNumVolumes(virStoragePoolPtr obj) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)obj->conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, obj->uuid); + + if (!pool) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage pool with matching uuid"); + return -1; + } + + if (!virStoragePoolObjIsActive(pool)) { + virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR, + "storage pool is not active"); + return -1; + } + + return pool->nvolumes; +} + +static int storagePoolListVolumes(virStoragePoolPtr obj, char **const names, int maxnames) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)obj->conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, obj->uuid); + int i = 0; + virStorageVolDefPtr vol; + + if (!pool) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage pool with matching uuid"); + return -1; + } + + if (!virStoragePoolObjIsActive(pool)) { + virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR, + "storage pool is not active"); + return -1; + } + + memset(names, 0, maxnames); + vol = pool->volumes; + while (vol && i < maxnames) { + names[i] = strdup(vol->name); + if (names[i] == NULL) { + virStorageReportError(obj->conn, VIR_ERR_NO_MEMORY, "name"); + goto cleanup; + } + vol = vol->next; + i++; + } + + return i; + + cleanup: + for (i = 0 ; i < maxnames ; i++) { + if (names[i]) { + free(names[i]); + names[i] = NULL; + } + } + return -1; +} + +static virStorageVolPtr storageVolumeLookupByName(virStoragePoolPtr obj, const char *name) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)obj->conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, obj->uuid); + virStorageVolDefPtr vol; + + if (!pool) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage pool with matching uuid"); + return NULL; + } + + if (!virStoragePoolObjIsActive(pool)) { + virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR, + "storage pool is not active"); + return NULL; + } + + vol = virStorageVolDefFindByName(pool, name); + + if (!vol) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage vol with matching name"); + return NULL; + } + + return virGetStorageVol(obj, vol->name, vol->uuid); +} + +static virStorageVolPtr storageVolumeLookupByUUID(virStoragePoolPtr obj, const unsigned char *uuid) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)obj->conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, obj->uuid); + virStorageVolDefPtr vol; + + if (!pool) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage pool with matching uuid"); + return NULL; + } + + if (!virStoragePoolObjIsActive(pool)) { + virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR, + "storage pool is not active"); + return NULL; + } + + vol = virStorageVolDefFindByUUID(pool, uuid); + + if (!vol) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage vol with matching name"); + return NULL; + } + + return virGetStorageVol(obj, vol->name, vol->uuid); +} + +static virStorageVolPtr storageVolumeCreateXML(virStoragePoolPtr obj, const char *xmldesc, int flags ATTRIBUTE_UNUSED) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)obj->conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, obj->uuid); + virStoragePoolBackendPtr backend; + virStorageVolDefPtr vol; + + if (!pool) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage pool with matching uuid"); + return NULL; + } + + if (!virStoragePoolObjIsActive(pool)) { + virStorageReportError(obj->conn, VIR_ERR_INTERNAL_ERROR, + "storage pool is not active"); + return NULL; + } + + if ((backend = storageBackend(pool->def->type)) == NULL) + return NULL; + + vol = virStorageVolDefParse(obj->conn, xmldesc, NULL); + if (vol == NULL) + return NULL; + + if (virStorageVolDefFindByName(pool, vol->name)) { + virStorageReportError(obj->conn, VIR_ERR_INVALID_STORAGE_POOL, + "storage vol already exists"); + virStorageVolDefFree(vol); + return NULL; + } + + + if (backend->volCreate(pool, vol) < 0) { + virStorageVolDefFree(vol); + return NULL; + } + + vol->next = pool->volumes; + pool->volumes = vol; + pool->nvolumes++; + + return virGetStorageVol(obj, vol->name, vol->uuid); +} + +static int storageVolumeDestroy(virStorageVolPtr obj) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)obj->pool->conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, obj->pool->uuid); + virStoragePoolBackendPtr backend; + virStorageVolDefPtr vol, tmp, prev; + + if (!pool) { + virStorageReportError(obj->pool->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage pool with matching uuid"); + return -1; + } + + if (!virStoragePoolObjIsActive(pool)) { + virStorageReportError(obj->pool->conn, VIR_ERR_INTERNAL_ERROR, + "storage pool is not active"); + return -1; + } + + if ((backend = storageBackend(pool->def->type)) == NULL) + return -1; + + vol = virStorageVolDefFindByName(pool, obj->name); + + if (!vol) { + virStorageReportError(obj->pool->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage vol with matching name"); + return -1; + } + + if (backend->volDelete(pool, vol) < 0) { + return -1; + } + + prev = NULL; + tmp = pool->volumes; + while (tmp) { + if (tmp == vol) { + break; + } + prev = tmp; + tmp = tmp->next; + } + if (prev) { + prev->next = vol->next; + } else { + pool->volumes = vol->next; + } + pool->nvolumes--; + virStorageVolDefFree(vol); + + return 0; +} + +static int storageVolumeGetInfo(virStorageVolPtr obj, virStorageVolInfoPtr info) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)obj->pool->conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, obj->pool->uuid); + virStoragePoolBackendPtr backend; + virStorageVolDefPtr vol; + + if (!pool) { + virStorageReportError(obj->pool->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage pool with matching uuid"); + return -1; + } + + if (!virStoragePoolObjIsActive(pool)) { + virStorageReportError(obj->pool->conn, VIR_ERR_INTERNAL_ERROR, + "storage pool is not active"); + return -1; + } + + vol = virStorageVolDefFindByName(pool, obj->name); + + if (!vol) { + virStorageReportError(obj->pool->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage vol with matching name"); + return -1; + } + + if ((backend = storageBackend(pool->def->type)) == NULL) + return -1; + + return backend->volGetInfo(pool, vol, info); +} + +static char *storageVolumeGetXMLDesc(virStorageVolPtr obj, int flags ATTRIBUTE_UNUSED) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)obj->pool->conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, obj->pool->uuid); + virStorageVolDefPtr vol; + + if (!pool) { + virStorageReportError(obj->pool->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage pool with matching uuid"); + return NULL; + } + + if (!virStoragePoolObjIsActive(pool)) { + virStorageReportError(obj->pool->conn, VIR_ERR_INTERNAL_ERROR, + "storage pool is not active"); + return NULL; + } + + vol = virStorageVolDefFindByName(pool, obj->name); + + if (!vol) { + virStorageReportError(obj->pool->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage vol with matching name"); + return NULL; + } + + return virStorageVolDefFormat(obj->pool->conn, vol); +} + +static char *storageVolumeGetPath(virStorageVolPtr obj) { + virStorageDriverStatePtr driver = (virStorageDriverStatePtr)obj->pool->conn->storagePrivateData; + virStoragePoolObjPtr pool = virStoragePoolObjFindByUUID(driver, obj->pool->uuid); + virStorageVolDefPtr vol; + char *ret; + + if (!pool) { + virStorageReportError(obj->pool->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage pool with matching uuid"); + return NULL; + } + + if (!virStoragePoolObjIsActive(pool)) { + virStorageReportError(obj->pool->conn, VIR_ERR_INTERNAL_ERROR, + "storage pool is not active"); + return NULL; + } + + vol = virStorageVolDefFindByName(pool, obj->name); + + if (!vol) { + virStorageReportError(obj->pool->conn, VIR_ERR_INVALID_STORAGE_POOL, + "no storage vol with matching name"); + return NULL; + } + + ret = strdup(vol->target); + if (ret == NULL) { + virStorageReportError(obj->pool->conn, VIR_ERR_NO_MEMORY, "path"); + return NULL; + } + return ret; +} + + + + + +static virStorageDriver storageDriver = { + "storage", + storageOpen, + storageClose, + storageNumPools, + storageListPools, + storageNumDefinedPools, + storageListDefinedPools, + storagePoolLookupByName, + storagePoolLookupByUUID, + storagePoolCreate, + storagePoolDefine, + storagePoolUndefine, + storagePoolStart, + storagePoolShutdown, + storagePoolDestroy, + storagePoolGetInfo, + storagePoolDumpXML, + storagePoolGetAutostart, + storagePoolSetAutostart, + storagePoolNumVolumes, + storagePoolListVolumes, + storageVolumeLookupByName, + storageVolumeLookupByUUID, + storageVolumeCreateXML, + storageVolumeDestroy, + storageVolumeGetInfo, + storageVolumeGetXMLDesc, + storageVolumeGetPath +}; + + +static virStateDriver stateDriver = { + storageDriverStartup, + storageDriverShutdown, + storageDriverReload, + storageDriverActive, +}; + +int storageRegister(void) { + virRegisterStorageDriver(&storageDriver); + virRegisterStateDriver(&stateDriver); + return 0; +} + +/* + * Local variables: + * indent-tabs-mode: nil + * c-indent-level: 4 + * c-basic-offset: 4 + * tab-width: 4 + * End: + */ + diff -r f57805779ece src/storage_driver.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/storage_driver.h Sun Oct 28 22:45:04 2007 -0400 @@ -0,0 +1,6 @@ + + +#include "storage_conf.h" + + +int storageRegister(void); diff -r f57805779ece src/virterror.c --- a/src/virterror.c Sun Oct 28 22:45:04 2007 -0400 +++ b/src/virterror.c Sun Oct 28 22:45:04 2007 -0400 @@ -280,6 +280,9 @@ virDefaultErrorFunc(virErrorPtr err) case VIR_FROM_REMOTE: dom = "Remote "; break; + case VIR_FROM_STORAGE: + dom = "Storage "; + break; } if ((err->dom != NULL) && (err->code != VIR_ERR_INVALID_DOMAIN)) { domain = err->dom->name; @@ -652,6 +655,36 @@ __virErrorMsg(virErrorNumber error, cons else errmsg = _("invalid MAC adress: %s"); break; + case VIR_ERR_NO_STORAGE_POOL: + if (info == NULL) + errmsg = _("Storage pool not found"); + else + errmsg = _("Storage pool not found: %s"); + break; + case VIR_ERR_NO_STORAGE_VOL: + if (info == NULL) + errmsg = _("Storage volume not found"); + else + errmsg = _("Storage volume not found: %s"); + break; + case VIR_ERR_INVALID_STORAGE_POOL: + if (info == NULL) + errmsg = _("invalid storage pool pointer in"); + else + errmsg = _("invalid storage pool pointer in %s"); + break; + case VIR_ERR_INVALID_STORAGE_VOL: + if (info == NULL) + errmsg = _("invalid storage volume pointer in"); + else + errmsg = _("invalid storage volume pointer in %s"); + break; + case VIR_WAR_NO_STORAGE: + if (info == NULL) + errmsg = _("Failed to find a storage driver"); + else + errmsg = _("Failed to find a storage driver: %s"); + break; } return (errmsg); } -- |=- Red Hat, Engineering, Emerging Technologies, Boston. +1 978 392 2496 -=| |=- Perl modules: http://search.cpan.org/~danberr/ -=| |=- Projects: http://freshmeat.net/~danielpb/ -=| |=- GnuPG: 7D3B9505 F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 -=|