[PATCH 6/7] fspool: default implementation of filesystem pools

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Implementation is backend base as in case of storage pools.
This patch adds directory backend which is nothing more
than managing directories inside another one as starting
point.

Signed-off-by: Nikolay Shirokovskiy <nshirokovskiy@xxxxxxxxxxxxx>
---
 configure.ac             |   33 +
 daemon/Makefile.am       |    4 +
 po/POTFILES.in           |    2 +
 src/Makefile.am          |   38 +
 src/driver.h             |    1 +
 src/fs/fs_backend.h      |   85 ++
 src/fs/fs_backend_dir.c  |  334 +++++++
 src/fs/fs_backend_dir.h  |    8 +
 src/fs/fs_driver.c       | 2164 ++++++++++++++++++++++++++++++++++++++++++++++
 src/fs/fs_driver.h       |   10 +
 src/libvirt.c            |   28 +
 src/libvirt_private.syms |    1 +
 12 files changed, 2708 insertions(+)
 create mode 100644 src/fs/fs_backend.h
 create mode 100644 src/fs/fs_backend_dir.c
 create mode 100644 src/fs/fs_backend_dir.h
 create mode 100644 src/fs/fs_driver.c
 create mode 100644 src/fs/fs_driver.h

diff --git a/configure.ac b/configure.ac
index 8d7d63e..435b1ec 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1647,6 +1647,35 @@ fi
 AM_CONDITIONAL([WITH_SECRETS], [test "$with_secrets" = "yes"])
 
 
+AC_ARG_WITH([fs-dir],
+  [AS_HELP_STRING([--with-fs-dir],
+    [with fs backend for fs driver @<:@default=yes@:>])],
+  [],[with_fs_dir=yes])
+
+if test "$with_libvirtd" = "no"; then
+  with_fs_dir=no
+fi
+
+if test "$with_fs_dir" = "yes" ; then
+  AC_DEFINE_UNQUOTED([WITH_FS_DIR], 1, [whether directory backend for fs driver is enabled])
+fi
+AM_CONDITIONAL([WITH_FS_DIR], [test "$with_fs_dir" = "yes"])
+
+with_fs=no
+for backend in dir; do
+    if eval test \$with_fs_$backend = yes; then
+        with_fs=yes
+        break
+    fi
+done
+if test $with_fs = yes; then
+    AC_DEFINE([WITH_FS], [1],
+      [Define to 1 if at least one fs backend is in use])
+fi
+AM_CONDITIONAL([WITH_FS], [test "$with_fs" = "yes"])
+
+
+
 AC_ARG_WITH([storage-dir],
   [AS_HELP_STRING([--with-storage-dir],
     [with directory backend for the storage driver @<:@default=yes@:>@])],
@@ -2760,6 +2789,10 @@ AC_MSG_NOTICE([Sheepdog: $with_storage_sheepdog])
 AC_MSG_NOTICE([ Gluster: $with_storage_gluster])
 AC_MSG_NOTICE([     ZFS: $with_storage_zfs])
 AC_MSG_NOTICE([])
+AC_MSG_NOTICE([Fs Drivers])
+AC_MSG_NOTICE([])
+AC_MSG_NOTICE([     Dir: $with_fs_dir])
+AC_MSG_NOTICE([])
 AC_MSG_NOTICE([Security Drivers])
 AC_MSG_NOTICE([])
 AC_MSG_NOTICE([ SELinux: $with_secdriver_selinux ($SELINUX_MOUNT)])
diff --git a/daemon/Makefile.am b/daemon/Makefile.am
index 927d16f..63444cf 100644
--- a/daemon/Makefile.am
+++ b/daemon/Makefile.am
@@ -241,6 +241,10 @@ if WITH_STORAGE
     libvirtd_LDADD += ../src/libvirt_driver_storage.la
 endif WITH_STORAGE
 
+if WITH_FS
+    libvirtd_LDADD += ../src/libvirt_driver_fs.la
+endif WITH_FS
+
 if WITH_NETWORK
     libvirtd_LDADD += ../src/libvirt_driver_network.la
 endif WITH_NETWORK
diff --git a/po/POTFILES.in b/po/POTFILES.in
index f4d2f25..0fc3b79 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -59,6 +59,8 @@ src/esx/esx_vi.c
 src/esx/esx_vi_methods.c
 src/esx/esx_vi_types.c
 src/fdstream.c
+src/fs/fs_backend_dir.c
+src/fs/fs_driver.c
 src/hyperv/hyperv_driver.c
 src/hyperv/hyperv_util.c
 src/hyperv/hyperv_wmi.c
diff --git a/src/Makefile.am b/src/Makefile.am
index db69fbb..6275f9e 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -642,6 +642,7 @@ DRIVER_SOURCE_FILES = \
 	$(REMOTE_DRIVER_SOURCES) \
 	$(SECRET_DRIVER_SOURCES) \
 	$(STORAGE_DRIVER_SOURCES) \
+	$(FS_DRIVER_SOURCES) \
 	$(TEST_DRIVER_SOURCES) \
 	$(UML_DRIVER_SOURCES) \
 	$(VBOX_DRIVER_SOURCES) \
@@ -662,6 +663,7 @@ STATEFUL_DRIVER_SOURCE_FILES = \
 	$(QEMU_DRIVER_SOURCES) \
 	$(SECRET_DRIVER_SOURCES) \
 	$(STORAGE_DRIVER_SOURCES) \
+	$(FS_DRIVER_SOURCES) \
 	$(UML_DRIVER_SOURCES) \
 	$(XEN_DRIVER_SOURCES) \
 	$(NULL)
@@ -968,6 +970,14 @@ SECRET_UTIL_SOURCES =						\
 SECRET_DRIVER_SOURCES =						\
 		secret/secret_driver.h secret/secret_driver.c
 
+# FS pool backend specific impls
+FS_DRIVER_SOURCES =							\
+		fs/fs_driver.h fs/fs_driver.c		\
+		fs/fs_backend.h
+
+FS_DRIVER_DIR_SOURCES =							\
+		fs/fs_backend_dir.h fs/fs_backend_dir.c
+
 # Storage backend specific impls
 STORAGE_DRIVER_SOURCES =						\
 		storage/storage_driver.h storage/storage_driver.c	\
@@ -1631,6 +1641,32 @@ endif WITH_DRIVER_MODULES
 libvirt_driver_secret_la_SOURCES = $(SECRET_DRIVER_SOURCES)
 endif WITH_SECRETS
 
+libvirt_driver_fs_impl_la_SOURCES =
+libvirt_driver_fs_impl_la_CFLAGS = \
+		-I$(srcdir)/access \
+		-I$(srcdir)/conf \
+		$(AM_CFLAGS)
+libvirt_driver_fs_impl_la_LDFLAGS = $(AM_LDFLAGS)
+libvirt_driver_fs_impl_la_LIBADD =
+libvirt_driver_fs_impl_la_LIBADD += $(SECDRIVER_LIBS) $(LIBXML_LIBS)
+if WITH_FS
+noinst_LTLIBRARIES += libvirt_driver_fs_impl.la
+libvirt_driver_fs_la_SOURCES =
+libvirt_driver_fs_la_LIBADD = libvirt_driver_fs_impl.la
+if WITH_DRIVER_MODULES
+mod_LTLIBRARIES += libvirt_driver_fs.la
+libvirt_driver_fs_la_LIBADD += ../gnulib/lib/libgnu.la
+libvirt_driver_fs_la_LDFLAGS = -module -avoid-version $(AM_LDFLAGS)
+else ! WITH_DRIVER_MODULES
+noinst_LTLIBRARIES += libvirt_driver_fs.la
+# Stateful, so linked to daemon instead
+#libvirt_la_BUILT_LIBADD += libvirt_driver_fs.la
+endif ! WITH_DRIVER_MODULES
+libvirt_driver_fs_impl_la_SOURCES += $(FS_DRIVER_SOURCES)
+libvirt_driver_fs_impl_la_SOURCES += $(FS_DRIVER_DIR_SOURCES)
+endif WITH_FS
+
+
 # Needed to keep automake quiet about conditionals
 libvirt_driver_storage_impl_la_SOURCES =
 libvirt_driver_storage_impl_la_CFLAGS = \
@@ -1902,6 +1938,8 @@ EXTRA_DIST +=							\
 		$(BHYVE_DRIVER_SOURCES)				\
 		$(NETWORK_DRIVER_SOURCES)			\
 		$(INTERFACE_DRIVER_SOURCES)			\
+		$(FS_DRIVER_SOURCES)				\
+		$(FS_DRIVER_DIR_SOURCES)			\
 		$(STORAGE_DRIVER_SOURCES)			\
 		$(STORAGE_DRIVER_FS_SOURCES)			\
 		$(STORAGE_DRIVER_LVM_SOURCES)			\
diff --git a/src/driver.h b/src/driver.h
index 57ad1f7..6d475f9 100644
--- a/src/driver.h
+++ b/src/driver.h
@@ -100,6 +100,7 @@ int virSetSharedNodeDeviceDriver(virNodeDeviceDriverPtr driver) ATTRIBUTE_RETURN
 int virSetSharedNWFilterDriver(virNWFilterDriverPtr driver) ATTRIBUTE_RETURN_CHECK;
 int virSetSharedSecretDriver(virSecretDriverPtr driver) ATTRIBUTE_RETURN_CHECK;
 int virSetSharedStorageDriver(virStorageDriverPtr driver) ATTRIBUTE_RETURN_CHECK;
+int virSetSharedFsDriver(virFsDriverPtr driver) ATTRIBUTE_RETURN_CHECK;
 
 void *virDriverLoadModule(const char *name);
 
diff --git a/src/fs/fs_backend.h b/src/fs/fs_backend.h
new file mode 100644
index 0000000..f714b29
--- /dev/null
+++ b/src/fs/fs_backend.h
@@ -0,0 +1,85 @@
+#ifndef __VIR_FS_BACKEND_H__
+# define __VIR_FS_BACKEND_H__
+
+# include <sys/stat.h>
+
+# include "internal.h"
+# include "fs_conf.h"
+# include "fs_driver.h"
+
+typedef char * (*virFsBackendFindFspoolSources)(virConnectPtr conn,
+                                                const char *srcSpec,
+                                                unsigned int flags);
+typedef int (*virFsBackendCheckFspool)(virFsPoolObjPtr fspool,
+                                       bool *active);
+typedef int (*virFsBackendStartFspool)(virConnectPtr conn,
+                                      virFsPoolObjPtr fspool);
+typedef int (*virFsBackendBuildFspool)(virConnectPtr conn,
+                                       virFsPoolObjPtr fspool,
+                                       unsigned int flags);
+typedef int (*virFsBackendRefreshFspool)(virConnectPtr conn,
+                                         virFsPoolObjPtr fspool);
+typedef int (*virFsBackendStopFspool)(virConnectPtr conn,
+                                       virFsPoolObjPtr fspool);
+typedef int (*virFsBackendDeleteFspool)(virConnectPtr conn,
+                                        virFsPoolObjPtr fspool,
+                                        unsigned int flags);
+
+/* FIXME */
+
+/* A 'buildItem' backend must remove any volume created on error since
+ * the storage driver does not distinguish whether the failure is due
+ * to failure to create the volume, to reserve any space necessary for
+ * the volume, to get data about the volume, to change it's accessibility,
+ * etc. This avoids issues arising from a creation failure due to some
+ * external action which created a volume of the same name that libvirt
+ * was not aware of between checking the fspool and the create attempt. It
+ * also avoids extra round trips to just delete a file.
+ */
+typedef int (*virFsBackendBuildItem)(virConnectPtr conn,
+                                     virFsPoolObjPtr fspool,
+                                     virFsItemDefPtr item,
+                                     unsigned int flags);
+typedef int (*virFsBackendCreateItem)(virConnectPtr conn,
+                                      virFsPoolObjPtr fspool,
+                                      virFsItemDefPtr item);
+typedef int (*virFsBackendRefreshItem)(virConnectPtr conn,
+                                       virFsPoolObjPtr fspool,
+                                       virFsItemDefPtr item);
+typedef int (*virFsBackendDeleteItem)(virConnectPtr conn,
+                                      virFsPoolObjPtr fspool,
+                                      virFsItemDefPtr item,
+                                      unsigned int flags);
+typedef int (*virFsBackendBuildItemFrom)(virConnectPtr conn,
+                                         virFsPoolObjPtr fspool,
+                                         virFsItemDefPtr origitem,
+                                         virFsItemDefPtr newitem,
+                                         unsigned int flags);
+
+typedef struct _virFsBackend virFsBackend;
+typedef virFsBackend *virFsBackendPtr;
+
+/* Callbacks are optional unless documented otherwise; but adding more
+ * callbacks provides better fspool support.  */
+struct _virFsBackend {
+    int type;
+
+    virFsBackendFindFspoolSources findFspoolSources;
+    virFsBackendCheckFspool checkFspool;
+    virFsBackendStartFspool startFspool;
+    virFsBackendBuildFspool buildFspool;
+    virFsBackendRefreshFspool refreshFspool; /* Must be non-NULL */
+    virFsBackendStopFspool stopFspool;
+    virFsBackendDeleteFspool deleteFspool;
+
+    virFsBackendBuildItem buildItem;
+    virFsBackendBuildItemFrom buildItemFrom;
+    virFsBackendCreateItem createItem;
+    virFsBackendRefreshItem refreshItem;
+    virFsBackendDeleteItem deleteItem;
+};
+
+# define VIR_FS_DEFAULT_POOL_PERM_MODE 0755
+# define VIR_FS_DEFAULT_ITEM_PERM_MODE  0600
+
+#endif /* __VIR_FS_BACKEND_H__ */
diff --git a/src/fs/fs_backend_dir.c b/src/fs/fs_backend_dir.c
new file mode 100644
index 0000000..fc08b85
--- /dev/null
+++ b/src/fs/fs_backend_dir.c
@@ -0,0 +1,334 @@
+#include <config.h>
+
+#include <sys/statvfs.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdio.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+#include <libxml/xpath.h>
+
+#include "virerror.h"
+#include "fs_backend_dir.h"
+#include "fs_conf.h"
+#include "vircommand.h"
+#include "viralloc.h"
+#include "virxml.h"
+#include "virfile.h"
+#include "virlog.h"
+#include "virstring.h"
+#include "fdstream.h"
+#include "stat-time.h"
+
+#define VIR_FROM_THIS VIR_FROM_FSPOOL
+
+VIR_LOG_INIT("fs.fs_backend_dir");
+
+static int
+virFsDirBuild(virConnectPtr conn ATTRIBUTE_UNUSED,
+              virFsPoolObjPtr fspool,
+              unsigned int flags)
+{
+    int ret = -1;
+    char *parent = NULL;
+    char *p = NULL;
+    mode_t mode;
+    unsigned int dir_create_flags;
+
+    virCheckFlags(0, -1);
+
+    if (VIR_STRDUP(parent, fspool->def->target.path) < 0)
+        goto error;
+    if (!(p = strrchr(parent, '/'))) {
+        virReportError(VIR_ERR_INVALID_ARG,
+                       _("path '%s' is not absolute"),
+                       fspool->def->target.path);
+        goto error;
+    }
+
+    if (p != parent) {
+        /* assure all directories in the path prior to the final dir
+         * exist, with default uid/gid/mode. */
+        *p = '\0';
+        if (virFileMakePath(parent) < 0) {
+            virReportSystemError(errno, _("cannot create path '%s'"),
+                                 parent);
+            goto error;
+        }
+    }
+
+    dir_create_flags = VIR_DIR_CREATE_ALLOW_EXIST;
+    mode = fspool->def->target.perms.mode;
+
+    if (mode == (mode_t) -1 &&
+        (!virFileExists(fspool->def->target.path)))
+        mode = VIR_FS_DEFAULT_POOL_PERM_MODE;
+
+    /* Now create the final dir in the path with the uid/gid/mode
+     * requested in the config. If the dir already exists, just set
+     * the perms. */
+    if (virDirCreate(fspool->def->target.path,
+                     mode,
+                     fspool->def->target.perms.uid,
+                     fspool->def->target.perms.gid,
+                     dir_create_flags) < 0)
+        goto error;
+
+    ret = 0;
+
+ error:
+    VIR_FREE(parent);
+    return ret;
+}
+
+static int
+virFsDirRefresh(virConnectPtr conn ATTRIBUTE_UNUSED,
+                virFsPoolObjPtr fspool)
+{
+    DIR *dir;
+    struct dirent *entry;
+    virFsItemDefPtr item = NULL;
+    struct statvfs sb;
+    struct stat statbuf;
+    int fd = 0;
+    int ret = -1;
+
+    if (virDirOpen(&dir, fspool->def->target.path) < 0)
+        goto cleanup;
+
+    while (virDirRead(dir, &entry, fspool->def->target.path) > 0) {
+        if (virStringHasControlChars(entry->d_name)) {
+            VIR_WARN("Ignoring control characters under '%s'",
+                     fspool->def->target.path);
+            continue;
+        }
+
+        if (VIR_ALLOC(item) < 0)
+            goto cleanup;
+
+        if (VIR_STRDUP(item->name, entry->d_name) < 0)
+            goto cleanup;
+        item->type  = VIR_FS_ITEM_DIR;
+        if (virAsprintf(&item->target.path, "%s/%s",
+                        fspool->def->target.path,
+                        item->name) == -1)
+            goto cleanup;
+
+        if (VIR_STRDUP(item->key, item->target.path) < 0)
+            goto cleanup;
+
+
+        if (VIR_APPEND_ELEMENT(fspool->items.objs, fspool->items.count, item) < 0)
+            goto cleanup;
+    }
+
+
+    if ((fd = open(fspool->def->target.path, O_RDONLY)) < 0) {
+        virReportSystemError(errno,
+                             _("cannot open path '%s'"),
+                             fspool->def->target.path);
+        goto cleanup;
+    }
+
+    if (fstat(fd, &statbuf) < 0) {
+        virReportSystemError(errno,
+                             _("cannot stat path '%s'"),
+                             fspool->def->target.path);
+        goto cleanup;
+    }
+
+    fspool->def->target.perms.mode = statbuf.st_mode & S_IRWXUGO;
+    fspool->def->target.perms.uid = statbuf.st_uid;
+    fspool->def->target.perms.gid = statbuf.st_gid;
+
+    if (statvfs(fspool->def->target.path, &sb) < 0) {
+        virReportSystemError(errno,
+                             _("cannot statvfs path '%s'"),
+                             fspool->def->target.path);
+        goto cleanup;
+    }
+
+    fspool->def->capacity = ((unsigned long long)sb.f_blocks *
+                           (unsigned long long)sb.f_frsize);
+    fspool->def->available = ((unsigned long long)sb.f_bfree *
+                            (unsigned long long)sb.f_frsize);
+    fspool->def->allocation = fspool->def->capacity - fspool->def->available;
+
+    ret = 0;
+
+ cleanup:
+    VIR_DIR_CLOSE(dir);
+    VIR_FORCE_CLOSE(fd);
+    virFsItemDefFree(item);
+    if (ret < 0)
+        virFsPoolObjClearItems(fspool);
+    return ret;
+}
+
+static int
+virFsDirDelete(virConnectPtr conn ATTRIBUTE_UNUSED,
+               virFsPoolObjPtr fspool,
+               unsigned int flags)
+{
+    virCheckFlags(0, -1);
+
+    if (rmdir(fspool->def->target.path) < 0) {
+        virReportSystemError(errno, _("failed to remove fspool '%s'"),
+                             fspool->def->target.path);
+        return -1;
+    }
+
+    return 0;
+
+}
+static int
+virFsDirItemBuild(virConnectPtr conn ATTRIBUTE_UNUSED,
+                  virFsPoolObjPtr fspool ATTRIBUTE_UNUSED,
+                  virFsItemDefPtr item,
+                  unsigned int flags)
+{
+    virCheckFlags(0, -1);
+
+    if (item->type == VIR_FS_ITEM_DIR) {
+        if ((virDirCreate(item->target.path,
+                          (item->target.perms->mode == (mode_t) -1 ?
+                           VIR_FS_DEFAULT_ITEM_PERM_MODE:
+                           item->target.perms->mode),
+                          item->target.perms->uid,
+                          item->target.perms->gid,
+                          0)) < 0) {
+            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                           _("error creating item"));
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+static int
+virFsDirItemBuildFrom(virConnectPtr conn ATTRIBUTE_UNUSED,
+                      virFsPoolObjPtr fspool ATTRIBUTE_UNUSED,
+                      virFsItemDefPtr item,
+                      virFsItemDefPtr inputitem,
+                      unsigned int flags)
+{
+    virCommandPtr cmd = NULL;
+    int ret = -1;
+
+    virCheckFlags(0, -1);
+
+    item->target.capacity = inputitem->target.capacity;
+    cmd = virCommandNewArgList("cp", "-r", inputitem->target.path,
+                               item->target.path, NULL);
+    ret = virCommandRun(cmd, NULL);
+
+    virCommandFree(cmd);
+    return ret;
+}
+
+static int
+virFsDirItemCreate(virConnectPtr conn ATTRIBUTE_UNUSED,
+                   virFsPoolObjPtr fspool,
+                   virFsItemDefPtr item)
+{
+    if (strchr(item->name, '/')) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("volume name '%s' cannot contain '/'"), item->name);
+        return -1;
+    }
+
+    VIR_FREE(item->target.path);
+    if (virAsprintf(&item->target.path, "%s/%s",
+                    fspool->def->target.path,
+                    item->name) == -1)
+        return -1;
+
+    if (virFileExists(item->target.path)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("item target path '%s' already exists"),
+                       item->target.path);
+        return -1;
+    }
+
+    VIR_FREE(item->key);
+    return VIR_STRDUP(item->key, item->target.path);
+}
+
+
+static int
+virFsDirItemRefresh(virConnectPtr conn ATTRIBUTE_UNUSED,
+                    virFsPoolObjPtr fspool ATTRIBUTE_UNUSED,
+                    virFsItemDefPtr item)
+{
+    int fd;
+    int ret = -1;
+    struct stat statbuf;
+    virCommandPtr cmd = NULL;
+    char *output = NULL, *end;
+
+    if ((fd = open(item->target.path, O_RDONLY)) < 0) {
+        virReportSystemError(errno, _("cannot open directory '%s'"),
+                             item->target.path);
+        return -1;
+    }
+    if (fstat(fd, &statbuf) < 0) {
+         virReportSystemError(errno, _("cannot stat path '%s'"),
+                             item->target.path);
+        goto cleanup;
+    }
+
+    cmd = virCommandNewArgList("du", "-sB1", item->target.path, NULL);
+    virCommandSetOutputBuffer(cmd, &output);
+    if ((ret = virCommandRun(cmd, NULL)) < 0)
+        goto cleanup;
+
+    if (virStrToLong_ull(output, &end, 10, &item->target.allocation) < 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Malformed du output: %s"), output);
+        goto cleanup;
+    }
+
+    if (&(item->target.perms) && VIR_ALLOC(*(&item->target.perms)) < 0)
+            goto cleanup;
+    item->target.perms->mode = statbuf.st_mode & S_IRWXUGO;
+    item->target.perms->uid = statbuf.st_uid;
+    item->target.perms->gid = statbuf.st_gid;
+
+    ret = 0;
+ cleanup:
+    VIR_FORCE_CLOSE(fd);
+    VIR_FREE(output);
+    virCommandFree(cmd);
+    return ret;
+}
+
+static int
+virFsDirItemDelete(virConnectPtr conn ATTRIBUTE_UNUSED,
+                   virFsPoolObjPtr fspool ATTRIBUTE_UNUSED,
+                   virFsItemDefPtr item,
+                   unsigned int flags)
+{
+    virCheckFlags(0, -1);
+
+    return virFileDeleteTree(item->target.path);
+}
+
+virFsBackend virFsBackendDir = {
+    .type = VIR_FS_POOL_DIR,
+
+    .buildFspool = virFsDirBuild,
+    .refreshFspool = virFsDirRefresh,
+    .deleteFspool = virFsDirDelete,
+    .buildItem = virFsDirItemBuild,
+    .buildItemFrom = virFsDirItemBuildFrom,
+    .createItem = virFsDirItemCreate,
+    .deleteItem = virFsDirItemDelete,
+    .refreshItem = virFsDirItemRefresh,
+};
diff --git a/src/fs/fs_backend_dir.h b/src/fs/fs_backend_dir.h
new file mode 100644
index 0000000..d8ff68f
--- /dev/null
+++ b/src/fs/fs_backend_dir.h
@@ -0,0 +1,8 @@
+#ifndef __VIR_FS_BACKEND_DIR_H__
+# define __VIR_FS_BACKEND_DIR_H__
+
+# include "fs_backend.h"
+
+extern virFsBackend virFsBackendDir;
+
+#endif /* __VIR_FS_BACKEND_DIR_H__ */
diff --git a/src/fs/fs_driver.c b/src/fs/fs_driver.c
new file mode 100644
index 0000000..76aba7a
--- /dev/null
+++ b/src/fs/fs_driver.c
@@ -0,0 +1,2164 @@
+#include <config.h>
+
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/param.h>
+#include <fcntl.h>
+
+#include <errno.h>
+#include <string.h>
+
+#include "virerror.h"
+#include "datatypes.h"
+#include "driver.h"
+#include "fs_driver.h"
+#include "fs_conf.h"
+#include "fs_backend.h"
+#include "viralloc.h"
+#include "virlog.h"
+#include "virfile.h"
+#include "fdstream.h"
+#include "configmake.h"
+#include "virstring.h"
+#include "viraccessapicheck.h"
+#include "dirname.h"
+
+#if WITH_FS_DIR
+# include "fs_backend_dir.h"
+#endif
+
+#define VIR_FROM_THIS VIR_FROM_FSPOOL
+
+VIR_LOG_INIT("fs.fs_driver");
+
+static virFsDriverStatePtr driver;
+
+typedef struct _virFsItemStreamInfo virFsItemStreamInfo;
+typedef virFsItemStreamInfo *virFsItemStreamInfoPtr;
+struct _virFsItemStreamInfo {
+    char *fspool_name;
+    char *item_path;
+};
+
+static int fsStateCleanup(void);
+
+static void fsDriverLock(void)
+{
+    virMutexLock(&driver->lock);
+}
+
+static void fsDriverUnlock(void)
+{
+    virMutexUnlock(&driver->lock);
+}
+
+static virFsBackendPtr backends[] = {
+#if WITH_FS_DIR
+    &virFsBackendDir,
+#endif
+};
+
+static virFsBackendPtr
+virFsBackendForType(int type)
+{
+    size_t i;
+    for (i = 0; backends[i]; i++)
+        if (backends[i]->type == type)
+            return backends[i];
+
+    virReportError(VIR_ERR_INTERNAL_ERROR,
+                   _("missing backend for fspool type %d (%s)"),
+                   type, NULLSTR(virFsPoolTypeToString(type)));
+    return NULL;
+}
+
+static void
+fsItemRemoveFromFsPool(virFsPoolObjPtr fspool,
+                       virFsItemDefPtr item)
+{
+    size_t i;
+
+    for (i = 0; i < fspool->items.count; i++) {
+        if (fspool->items.objs[i] == item) {
+            VIR_INFO("Deleting item '%s' from fspool '%s'",
+                     item->name, fspool->def->name);
+            virFsItemDefFree(item);
+
+            VIR_DELETE_ELEMENT(fspool->items.objs, i, fspool->items.count);
+            break;
+        }
+    }
+}
+
+static int
+fsItemDeleteInternal(virFsItemPtr obj,
+                     virFsBackendPtr backend,
+                     virFsPoolObjPtr fspool,
+                     virFsItemDefPtr item,
+                     unsigned int flags)
+{
+    int ret = -1;
+
+    virCheckFlags(0, -1);
+
+    if (!backend->deleteItem) {
+        virReportError(VIR_ERR_NO_SUPPORT,
+                  "%s", _("fspool does not support item deletion"));
+        goto cleanup;
+    }
+    if (backend->deleteItem(obj->conn, fspool, item, flags) < 0)
+        goto cleanup;
+
+    fsItemRemoveFromFsPool(fspool, item);
+
+    ret = 0;
+
+ cleanup:
+    return ret;
+}
+
+static virFsItemDefPtr
+virFsItemDefFromItem(virFsItemPtr obj,
+                     virFsPoolObjPtr *fspool,
+                     virFsBackendPtr *backend)
+{
+    virFsItemDefPtr item = NULL;
+
+    *fspool = NULL;
+
+    fsDriverLock();
+    *fspool = virFsPoolObjFindByName(&driver->fspools, obj->fspool);
+    fsDriverUnlock();
+
+    if (!*fspool) {
+        virReportError(VIR_ERR_NO_FS_POOL,
+                       _("no fspool with matching name '%s'"),
+                       obj->fspool);
+        return NULL;
+    }
+
+    if (!virFsPoolObjIsActive(*fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"),
+                       (*fspool)->def->name);
+        goto error;
+    }
+
+    if (!(item = virFsItemDefFindByName(*fspool, obj->name))) {
+        virReportError(VIR_ERR_NO_FS_ITEM,
+                       _("no fs item with matching name '%s'"),
+                       obj->name);
+        goto error;
+    }
+
+    if (backend) {
+        if (!(*backend = virFsBackendForType((*fspool)->def->type)))
+            goto error;
+    }
+
+    return item;
+
+ error:
+    virFsPoolObjUnlock(*fspool);
+    *fspool = NULL;
+
+    return NULL;
+}
+
+static void
+fsPoolUpdateState(virFsPoolObjPtr fspool)
+{
+    bool active;
+    virFsBackendPtr backend;
+    int ret = -1;
+    char *stateFile;
+
+    if (!(stateFile = virFileBuildPath(driver->stateDir,
+                                       fspool->def->name, ".xml")))
+        goto error;
+
+    if ((backend = virFsBackendForType(fspool->def->type)) == NULL) {
+        VIR_ERROR(_("Missing backend %d"), fspool->def->type);
+        goto error;
+    }
+
+    /* Backends which do not support 'checkFspool' are considered
+     * inactive by default.
+     */
+    active = false;
+    if (backend->checkFspool &&
+        backend->checkFspool(fspool, &active) < 0) {
+        virErrorPtr err = virGetLastError();
+        VIR_ERROR(_("Failed to initialize fspool '%s': %s"),
+                  fspool->def->name, err ? err->message :
+                  _("no error message found"));
+        goto error;
+    }
+
+    /* We can pass NULL as connection, most backends do not use
+     * it anyway, but if they do and fail, we want to log error and
+     * continue with other fspools.
+     */
+    if (active) {
+        virFsPoolObjClearItems(fspool);
+        if (backend->refreshFspool(NULL, fspool) < 0) {
+            virErrorPtr err = virGetLastError();
+            if (backend->stopFspool)
+                backend->stopFspool(NULL, fspool);
+            VIR_ERROR(_("Failed to restart fspool '%s': %s"),
+                      fspool->def->name, err ? err->message :
+                      _("no error message found"));
+            goto error;
+        }
+    }
+
+    fspool->active = active;
+    ret = 0;
+ error:
+    if (ret < 0) {
+        if (stateFile)
+            unlink(stateFile);
+    }
+    VIR_FREE(stateFile);
+
+    return;
+}
+
+static void
+fsPoolUpdateAllState(void)
+{
+    size_t i;
+
+    for (i = 0; i < driver->fspools.count; i++) {
+        virFsPoolObjPtr fspool = driver->fspools.objs[i];
+
+        virFsPoolObjLock(fspool);
+        fsPoolUpdateState(fspool);
+        virFsPoolObjUnlock(fspool);
+    }
+}
+
+static void
+fsDriverAutostart(void)
+{
+    size_t i;
+    virConnectPtr conn = NULL;
+
+    /* XXX Remove hardcoding of QEMU URI */
+    if (driver->privileged)
+        conn = virConnectOpen("qemu:///system");
+    else
+        conn = virConnectOpen("qemu:///session");
+    /* Ignoring NULL conn - let backends decide */
+
+   for (i = 0; i < driver->fspools.count; i++) {
+        virFsPoolObjPtr fspool = driver->fspools.objs[i];
+        virFsBackendPtr backend;
+        bool started = false;
+
+        virFsPoolObjLock(fspool);
+        if ((backend = virFsBackendForType(fspool->def->type)) == NULL) {
+            virFsPoolObjUnlock(fspool);
+            continue;
+        }
+
+        if (fspool->autostart &&
+            !virFsPoolObjIsActive(fspool)) {
+            if (backend->startFspool &&
+                backend->startFspool(conn, fspool) < 0) {
+                virErrorPtr err = virGetLastError();
+                VIR_ERROR(_("Failed to autostart fspool '%s': %s"),
+                          fspool->def->name, err ? err->message :
+                          _("no error message found"));
+                virFsPoolObjUnlock(fspool);
+                continue;
+            }
+            started = true;
+        }
+
+        if (started) {
+            char *stateFile;
+
+            virFsPoolObjClearItems(fspool);
+            stateFile = virFileBuildPath(driver->stateDir,
+                                         fspool->def->name, ".xml");
+            if (!stateFile ||
+                virFsPoolSaveState(stateFile, fspool->def) < 0 ||
+                backend->refreshFspool(conn, fspool) < 0) {
+                virErrorPtr err = virGetLastError();
+                if (stateFile)
+                    unlink(stateFile);
+                if (backend->stopFspool)
+                    backend->stopFspool(conn, fspool);
+                VIR_ERROR(_("Failed to autostart fspool '%s': %s"),
+                          fspool->def->name, err ? err->message :
+                          _("no error message found"));
+            } else {
+                fspool->active = true;
+            }
+            VIR_FREE(stateFile);
+        }
+        virFsPoolObjUnlock(fspool);
+    }
+
+    virObjectUnref(conn);
+}
+
+/**
+ * virFsStartup:
+ *
+ * Initialization function for the Fs Driver
+ */
+static int
+fsStateInitialize(bool privileged,
+                  virStateInhibitCallback callback ATTRIBUTE_UNUSED,
+                  void *opaque ATTRIBUTE_UNUSED)
+{
+    int ret = -1;
+    char *configdir = NULL;
+    char *rundir = NULL;
+
+    if (VIR_ALLOC(driver) < 0)
+        return ret;
+
+    if (virMutexInit(&driver->lock) < 0) {
+        VIR_FREE(driver);
+        return ret;
+    }
+    fsDriverLock();
+
+    if (privileged) {
+        if (VIR_STRDUP(driver->configDir,
+                       SYSCONFDIR "/libvirt/fs") < 0 ||
+            VIR_STRDUP(driver->autostartDir,
+                       SYSCONFDIR "/libvirt/fs/autostart") < 0 ||
+            VIR_STRDUP(driver->stateDir,
+                       LOCALSTATEDIR "/run/libvirt/fs") < 0)
+            goto error;
+    } else {
+        configdir = virGetUserConfigDirectory();
+        rundir = virGetUserRuntimeDirectory();
+        if (!(configdir && rundir))
+            goto error;
+
+        if ((virAsprintf(&driver->configDir,
+                        "%s/fs", configdir) < 0) ||
+            (virAsprintf(&driver->autostartDir,
+                        "%s/fs/autostart", configdir) < 0) ||
+            (virAsprintf(&driver->stateDir,
+                         "%s/fs/run", rundir) < 0))
+            goto error;
+    }
+    driver->privileged = privileged;
+
+    if (virFileMakePath(driver->stateDir) < 0) {
+        virReportError(errno,
+                       _("cannot create directory %s"),
+                       driver->stateDir);
+        goto error;
+    }
+
+    if (virFsPoolLoadAllState(&driver->fspools,
+                                   driver->stateDir) < 0)
+        goto error;
+
+    if (virFsPoolLoadAllConfigs(&driver->fspools,
+                                     driver->configDir,
+                                     driver->autostartDir) < 0)
+        goto error;
+
+    fsPoolUpdateAllState();
+
+    fsDriverUnlock();
+
+    ret = 0;
+ cleanup:
+    VIR_FREE(configdir);
+    VIR_FREE(rundir);
+    return ret;
+
+ error:
+    fsDriverUnlock();
+    fsStateCleanup();
+    goto cleanup;
+}
+
+/**
+ * fsStateAutoStart:
+ *
+ * Function to auto start the fs_driver
+ */
+static void
+fsStateAutoStart(void)
+{
+    if (!driver)
+        return;
+
+    fsDriverLock();
+    fsDriverAutostart();
+    fsDriverUnlock();
+}
+
+/**
+ * fsStateReload:
+ *
+ * Function to restart the fs_driver, it will recheck the configuration
+ * files and update its state
+ */
+static int
+fsStateReload(void)
+{
+    if (!driver)
+        return -1;
+
+    fsDriverLock();
+    virFsPoolLoadAllState(&driver->fspools,
+                          driver->stateDir);
+    virFsPoolLoadAllConfigs(&driver->fspools,
+                            driver->configDir,
+                            driver->autostartDir);
+    fsDriverAutostart();
+    fsDriverUnlock();
+
+    return 0;
+}
+
+
+/**
+ * fsStateCleanup
+ *
+ * Shutdown the fs driver, it will stop all active fspools
+ */
+static int
+fsStateCleanup(void)
+{
+    if (!driver)
+        return -1;
+
+    fsDriverLock();
+
+    /* free inactive fspools */
+    virFsPoolObjListFree(&driver->fspools);
+
+    VIR_FREE(driver->configDir);
+    VIR_FREE(driver->autostartDir);
+    VIR_FREE(driver->stateDir);
+    fsDriverUnlock();
+    virMutexDestroy(&driver->lock);
+    VIR_FREE(driver);
+
+    return 0;
+}
+
+
+static virFsPoolObjPtr
+virFsPoolObjFromFsPool(virFsPoolPtr fspool)
+{
+    char uuidstr[VIR_UUID_STRING_BUFLEN];
+    virFsPoolObjPtr ret;
+
+    fsDriverLock();
+    if (!(ret = virFsPoolObjFindByUUID(&driver->fspools, fspool->uuid))) {
+        virUUIDFormat(fspool->uuid, uuidstr);
+        virReportError(VIR_ERR_NO_FS_POOL,
+                       _("no fspool with matching uuid '%s' (%s)"),
+                       uuidstr, fspool->name);
+    }
+    fsDriverUnlock();
+
+    return ret;
+}
+
+static int
+fsConnectNumOfFsPools(virConnectPtr conn)
+{
+    size_t i;
+    int nactive = 0;
+
+    if (virConnectNumOfFsPoolsEnsureACL(conn) < 0)
+        return -1;
+
+    fsDriverLock();
+    for (i = 0; i < driver->fspools.count; i++) {
+        virFsPoolObjPtr obj = driver->fspools.objs[i];
+        virFsPoolObjLock(obj);
+        if (virConnectNumOfFsPoolsCheckACL(conn, obj->def) &&
+            virFsPoolObjIsActive(obj))
+            nactive++;
+        virFsPoolObjUnlock(obj);
+    }
+    fsDriverUnlock();
+
+    return nactive;
+}
+
+static int
+fsConnectListAllFsPools(virConnectPtr conn,
+                        virFsPoolPtr **fspools,
+                        unsigned int flags)
+{
+    int ret = -1;
+
+    virCheckFlags(VIR_CONNECT_LIST_FS_POOLS_FILTERS_ALL, -1);
+
+    if (virConnectListAllFsPoolsEnsureACL(conn) < 0)
+        goto cleanup;
+
+    fsDriverLock();
+    ret = virFsPoolObjListExport(conn, driver->fspools, fspools,
+                                 virConnectListAllFsPoolsCheckACL,
+                                 flags);
+    fsDriverUnlock();
+
+ cleanup:
+    return ret;
+}
+
+static int
+fsConnectListFsPools(virConnectPtr conn,
+                     char **const names,
+                     int nnames)
+{
+    int got = 0;
+    size_t i;
+
+    if (virConnectListFsPoolsEnsureACL(conn) < 0)
+        return -1;
+
+    fsDriverLock();
+    for (i = 0; i < driver->fspools.count && got < nnames; i++) {
+        virFsPoolObjPtr obj = driver->fspools.objs[i];
+        virFsPoolObjLock(obj);
+        if (virConnectListFsPoolsCheckACL(conn, obj->def) &&
+            virFsPoolObjIsActive(obj)) {
+            if (VIR_STRDUP(names[got], obj->def->name) < 0) {
+                virFsPoolObjUnlock(obj);
+                goto cleanup;
+            }
+            got++;
+        }
+        virFsPoolObjUnlock(obj);
+    }
+    fsDriverUnlock();
+    return got;
+
+ cleanup:
+    fsDriverUnlock();
+    for (i = 0; i < got; i++)
+        VIR_FREE(names[i]);
+    memset(names, 0, nnames * sizeof(*names));
+    return -1;
+}
+
+static int
+fsConnectNumOfDefinedFsPools(virConnectPtr conn)
+{
+    size_t i;
+    int nactive = 0;
+
+    if (virConnectNumOfDefinedFsPoolsEnsureACL(conn) < 0)
+        return -1;
+
+    fsDriverLock();
+    for (i = 0; i < driver->fspools.count; i++) {
+        virFsPoolObjPtr obj = driver->fspools.objs[i];
+        virFsPoolObjLock(obj);
+        if (virConnectNumOfDefinedFsPoolsCheckACL(conn, obj->def) &&
+            !virFsPoolObjIsActive(obj))
+            nactive++;
+        virFsPoolObjUnlock(obj);
+    }
+    fsDriverUnlock();
+
+    return nactive;
+}
+
+static int
+fsConnectListDefinedFsPools(virConnectPtr conn,
+                            char **const names,
+                            int nnames)
+{
+    int got = 0;
+    size_t i;
+
+    if (virConnectListDefinedFsPoolsEnsureACL(conn) < 0)
+        return -1;
+
+    fsDriverLock();
+    for (i = 0; i < driver->fspools.count && got < nnames; i++) {
+        virFsPoolObjPtr obj = driver->fspools.objs[i];
+        virFsPoolObjLock(obj);
+        if (virConnectListDefinedFsPoolsCheckACL(conn, obj->def) &&
+            !virFsPoolObjIsActive(obj)) {
+            if (VIR_STRDUP(names[got], obj->def->name) < 0) {
+                virFsPoolObjUnlock(obj);
+                goto cleanup;
+            }
+            got++;
+        }
+        virFsPoolObjUnlock(obj);
+    }
+    fsDriverUnlock();
+    return got;
+
+ cleanup:
+    fsDriverUnlock();
+    for (i = 0; i < got; i++)
+        VIR_FREE(names[i]);
+    memset(names, 0, nnames * sizeof(*names));
+    return -1;
+}
+
+static virFsPoolPtr
+fsPoolLookupByUUID(virConnectPtr conn,
+                   const unsigned char *uuid)
+{
+    virFsPoolObjPtr fspool;
+    virFsPoolPtr ret = NULL;
+
+    fsDriverLock();
+    fspool = virFsPoolObjFindByUUID(&driver->fspools, uuid);
+    fsDriverUnlock();
+
+    if (!fspool) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+        virUUIDFormat(uuid, uuidstr);
+        virReportError(VIR_ERR_NO_FS_POOL,
+                       _("no fspool with matching uuid '%s'"), uuidstr);
+        return NULL;
+    }
+
+    if (virFsPoolLookupByUUIDEnsureACL(conn, fspool->def) < 0)
+        goto cleanup;
+
+    ret = virGetFsPool(conn, fspool->def->name, fspool->def->uuid,
+                       NULL, NULL);
+
+ cleanup:
+    virFsPoolObjUnlock(fspool);
+    return ret;
+}
+
+static virFsPoolPtr
+fsPoolLookupByName(virConnectPtr conn,
+                   const char *name)
+{
+    virFsPoolObjPtr fspool;
+    virFsPoolPtr ret = NULL;
+
+    fsDriverLock();
+    fspool = virFsPoolObjFindByName(&driver->fspools, name);
+    fsDriverUnlock();
+
+    if (!fspool) {
+        virReportError(VIR_ERR_NO_FS_POOL,
+                       _("no fspool with matching name '%s'"), name);
+        return NULL;
+    }
+
+    if (virFsPoolLookupByNameEnsureACL(conn, fspool->def) < 0)
+        goto cleanup;
+
+    ret = virGetFsPool(conn, fspool->def->name, fspool->def->uuid,
+                       NULL, NULL);
+
+ cleanup:
+    virFsPoolObjUnlock(fspool);
+    return ret;
+}
+
+static virFsPoolPtr
+fsPoolLookupByItem(virFsItemPtr item)
+{
+    virFsPoolObjPtr fspool;
+    virFsPoolPtr ret = NULL;
+
+    fsDriverLock();
+    fspool = virFsPoolObjFindByName(&driver->fspools, item->fspool);
+    fsDriverUnlock();
+
+    if (!fspool) {
+        virReportError(VIR_ERR_NO_FS_POOL,
+                       _("no fspool with matching name '%s'"),
+                       item->fspool);
+        return NULL;
+    }
+
+    if (virFsPoolLookupByItemEnsureACL(item->conn, fspool->def) < 0)
+        goto cleanup;
+
+    ret = virGetFsPool(item->conn, fspool->def->name, fspool->def->uuid,
+                            NULL, NULL);
+
+ cleanup:
+    virFsPoolObjUnlock(fspool);
+    return ret;
+}
+
+
+static virFsPoolPtr
+fsPoolCreateXML(virConnectPtr conn,
+                const char *xml,
+                unsigned int flags)
+{
+    virFsPoolDefPtr def;
+    virFsPoolObjPtr fspool = NULL;
+    virFsPoolPtr ret = NULL;
+    virFsBackendPtr backend;
+    char *stateFile = NULL;
+    unsigned int build_flags = 0;
+
+    virCheckFlags(VIR_FS_POOL_CREATE_WITH_BUILD |
+                  VIR_FS_POOL_CREATE_WITH_BUILD_OVERWRITE |
+                  VIR_FS_POOL_CREATE_WITH_BUILD_NO_OVERWRITE, NULL);
+
+    VIR_EXCLUSIVE_FLAGS_RET(VIR_FS_POOL_BUILD_OVERWRITE,
+                            VIR_FS_POOL_BUILD_NO_OVERWRITE, NULL);
+
+    fsDriverLock();
+    if (!(def = virFsPoolDefParseString(xml)))
+        goto cleanup;
+
+    if (virFsPoolCreateXMLEnsureACL(conn, def) < 0)
+        goto cleanup;
+
+    if (virFsPoolObjIsDuplicate(&driver->fspools, def, 1) < 0)
+        goto cleanup;
+
+    if (virFsPoolSourceFindDuplicate(conn, &driver->fspools, def) < 0)
+        goto cleanup;
+
+    if ((backend = virFsBackendForType(def->type)) == NULL)
+        goto cleanup;
+
+    if (!(fspool = virFsPoolObjAssignDef(&driver->fspools, def)))
+        goto cleanup;
+    def = NULL;
+
+    if (backend->buildFspool) {
+        if (flags & VIR_FS_POOL_CREATE_WITH_BUILD_OVERWRITE)
+            build_flags |= VIR_FS_POOL_BUILD_OVERWRITE;
+        else if (flags & VIR_FS_POOL_CREATE_WITH_BUILD_NO_OVERWRITE)
+            build_flags |= VIR_FS_POOL_BUILD_NO_OVERWRITE;
+
+        if (build_flags ||
+            (flags & VIR_FS_POOL_CREATE_WITH_BUILD)) {
+            if (backend->buildFspool(conn, fspool, build_flags) < 0) {
+                virFsPoolObjRemove(&driver->fspools, fspool);
+                fspool = NULL;
+                goto cleanup;
+            }
+        }
+    }
+
+    if (backend->startFspool &&
+        backend->startFspool(conn, fspool) < 0) {
+        virFsPoolObjRemove(&driver->fspools, fspool);
+        fspool = NULL;
+        goto cleanup;
+    }
+
+    stateFile = virFileBuildPath(driver->stateDir,
+                                 fspool->def->name, ".xml");
+
+    if (!stateFile || virFsPoolSaveState(stateFile, fspool->def) < 0 ||
+        backend->refreshFspool(conn, fspool) < 0) {
+        if (stateFile)
+            unlink(stateFile);
+        if (backend->stopFspool)
+            backend->stopFspool(conn, fspool);
+        virFsPoolObjRemove(&driver->fspools, fspool);
+        fspool = NULL;
+        goto cleanup;
+    }
+    VIR_INFO("Creating fspool '%s'", fspool->def->name);
+    fspool->active = true;
+
+    ret = virGetFsPool(conn, fspool->def->name, fspool->def->uuid,
+                       NULL, NULL);
+
+ cleanup:
+    VIR_FREE(stateFile);
+    virFsPoolDefFree(def);
+    if (fspool)
+        virFsPoolObjUnlock(fspool);
+    fsDriverUnlock();
+    return ret;
+}
+
+static virFsPoolPtr
+fsPoolDefineXML(virConnectPtr conn,
+                const char *xml,
+                unsigned int flags)
+{
+    virFsPoolDefPtr def;
+    virFsPoolObjPtr fspool = NULL;
+    virFsPoolPtr ret = NULL;
+
+    virCheckFlags(0, NULL);
+
+    fsDriverLock();
+    if (!(def = virFsPoolDefParseString(xml)))
+        goto cleanup;
+
+    if (virFsPoolDefineXMLEnsureACL(conn, def) < 0)
+        goto cleanup;
+
+    if (virFsPoolObjIsDuplicate(&driver->fspools, def, 0) < 0)
+        goto cleanup;
+
+    if (virFsPoolSourceFindDuplicate(conn, &driver->fspools, def) < 0)
+        goto cleanup;
+
+    if (virFsBackendForType(def->type) == NULL)
+        goto cleanup;
+
+    if (!(fspool = virFsPoolObjAssignDef(&driver->fspools, def)))
+        goto cleanup;
+
+    if (virFsPoolObjSaveDef(driver, fspool, def) < 0) {
+        virFsPoolObjRemove(&driver->fspools, fspool);
+        def = NULL;
+        fspool = NULL;
+        goto cleanup;
+    }
+    def = NULL;
+
+    VIR_INFO("Defining fspool '%s'", fspool->def->name);
+    ret = virGetFsPool(conn, fspool->def->name, fspool->def->uuid,
+                            NULL, NULL);
+
+ cleanup:
+    virFsPoolDefFree(def);
+    if (fspool)
+        virFsPoolObjUnlock(fspool);
+    fsDriverUnlock();
+    return ret;
+}
+
+static int
+fsPoolCreate(virFsPoolPtr obj,
+             unsigned int flags)
+{
+    virFsPoolObjPtr fspool;
+    virFsBackendPtr backend;
+    int ret = -1;
+    char *stateFile = NULL;
+    unsigned int build_flags = 0;
+
+    virCheckFlags(VIR_FS_POOL_CREATE_WITH_BUILD |
+                  VIR_FS_POOL_CREATE_WITH_BUILD_OVERWRITE |
+                  VIR_FS_POOL_CREATE_WITH_BUILD_NO_OVERWRITE, -1);
+
+    VIR_EXCLUSIVE_FLAGS_RET(VIR_FS_POOL_BUILD_OVERWRITE,
+                            VIR_FS_POOL_BUILD_NO_OVERWRITE, -1);
+
+    if (!(fspool = virFsPoolObjFromFsPool(obj)))
+        return -1;
+
+    if (virFsPoolCreateEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if ((backend = virFsBackendForType(fspool->def->type)) == NULL)
+        goto cleanup;
+
+    if (virFsPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is already active"),
+                       fspool->def->name);
+        goto cleanup;
+    }
+
+    if (backend->buildFspool) {
+        if (flags & VIR_FS_POOL_CREATE_WITH_BUILD_OVERWRITE)
+            build_flags |= VIR_FS_POOL_BUILD_OVERWRITE;
+        else if (flags & VIR_FS_POOL_CREATE_WITH_BUILD_NO_OVERWRITE)
+            build_flags |= VIR_FS_POOL_BUILD_NO_OVERWRITE;
+
+        if (build_flags ||
+            (flags & VIR_FS_POOL_CREATE_WITH_BUILD)) {
+            if (backend->buildFspool(obj->conn, fspool, build_flags) < 0) {
+                virFsPoolObjRemove(&driver->fspools, fspool);
+                fspool = NULL;
+                goto cleanup;
+            }
+        }
+    }
+
+    VIR_INFO("Starting up fspool '%s'", fspool->def->name);
+    if (backend->startFspool &&
+        backend->startFspool(obj->conn, fspool) < 0)
+        goto cleanup;
+
+    stateFile = virFileBuildPath(driver->stateDir,
+                                 fspool->def->name, ".xml");
+
+    virFsPoolObjClearItems(fspool);
+    if (!stateFile || virFsPoolSaveState(stateFile, fspool->def) < 0 ||
+        backend->refreshFspool(obj->conn, fspool) < 0) {
+        if (stateFile)
+            unlink(stateFile);
+        goto cleanup;
+    }
+
+    fspool->active = true;
+    ret = 0;
+
+ cleanup:
+    VIR_FREE(stateFile);
+    if (fspool)
+        virFsPoolObjUnlock(fspool);
+    return ret;
+}
+
+static int
+fsPoolBuild(virFsPoolPtr obj,
+            unsigned int flags)
+{
+    virFsPoolObjPtr fspool;
+    virFsBackendPtr backend;
+    int ret = -1;
+
+    virCheckFlags(0, -1);
+
+    if (!(fspool = virFsPoolObjFromFsPool(obj)))
+        return -1;
+
+    if (virFsPoolBuildEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if ((backend = virFsBackendForType(fspool->def->type)) == NULL)
+        goto cleanup;
+
+    if (virFsPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is already active"),
+                       fspool->def->name);
+        goto cleanup;
+    }
+
+    if (backend->buildFspool &&
+        backend->buildFspool(obj->conn, fspool, flags) < 0)
+        goto cleanup;
+
+    ret = 0;
+
+ cleanup:
+    virFsPoolObjUnlock(fspool);
+    return ret;
+}
+
+static int
+fsPoolUndefine(virFsPoolPtr obj)
+{
+    virFsPoolObjPtr fspool;
+    int ret = -1;
+
+    fsDriverLock();
+    if (!(fspool = virFsPoolObjFindByUUID(&driver->fspools, obj->uuid))) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+        virUUIDFormat(obj->uuid, uuidstr);
+        virReportError(VIR_ERR_NO_FS_POOL,
+                       _("no fspool with matching uuid '%s' (%s)"),
+                       uuidstr, obj->name);
+        goto cleanup;
+    }
+
+    if (virFsPoolUndefineEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if (virFsPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is still active"),
+                       fspool->def->name);
+        goto cleanup;
+    }
+
+    if (fspool->asyncjobs > 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("fspool '%s' has asynchronous jobs running."),
+                       fspool->def->name);
+        goto cleanup;
+    }
+
+    if (virFsPoolObjDeleteDef(fspool) < 0)
+        goto cleanup;
+
+    if (unlink(fspool->autostartLink) < 0 &&
+        errno != ENOENT &&
+        errno != ENOTDIR) {
+        char ebuf[1024];
+        VIR_ERROR(_("Failed to delete autostart link '%s': %s"),
+                  fspool->autostartLink, virStrerror(errno, ebuf, sizeof(ebuf)));
+    }
+
+    VIR_FREE(fspool->configFile);
+    VIR_FREE(fspool->autostartLink);
+
+    VIR_INFO("Undefining fspool '%s'", fspool->def->name);
+    virFsPoolObjRemove(&driver->fspools, fspool);
+    fspool = NULL;
+    ret = 0;
+
+ cleanup:
+    if (fspool)
+        virFsPoolObjUnlock(fspool);
+    fsDriverUnlock();
+    return ret;
+}
+
+static int
+fsPoolDestroy(virFsPoolPtr obj)
+{
+    virFsPoolObjPtr fspool;
+    virFsBackendPtr backend;
+    char *stateFile = NULL;
+    int ret = -1;
+
+    fsDriverLock();
+    if (!(fspool = virFsPoolObjFindByUUID(&driver->fspools, obj->uuid))) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+        virUUIDFormat(obj->uuid, uuidstr);
+        virReportError(VIR_ERR_NO_FS_POOL,
+                       _("no fspool with matching uuid '%s' (%s)"),
+                       uuidstr, obj->name);
+        goto cleanup;
+    }
+
+    if (virFsPoolDestroyEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if ((backend = virFsBackendForType(fspool->def->type)) == NULL)
+        goto cleanup;
+
+    VIR_INFO("Destroying fspool '%s'", fspool->def->name);
+
+    if (!virFsPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"), fspool->def->name);
+        goto cleanup;
+    }
+
+    if (fspool->asyncjobs > 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("fspool '%s' has asynchronous jobs running."),
+                       fspool->def->name);
+        goto cleanup;
+    }
+
+    if (!(stateFile = virFileBuildPath(driver->stateDir,
+                                       fspool->def->name,
+                                       ".xml")))
+        goto cleanup;
+
+    unlink(stateFile);
+    VIR_FREE(stateFile);
+
+    if (backend->stopFspool &&
+        backend->stopFspool(obj->conn, fspool) < 0)
+        goto cleanup;
+
+    virFsPoolObjClearItems(fspool);
+
+    fspool->active = false;
+
+    if (fspool->configFile == NULL) {
+        virFsPoolObjRemove(&driver->fspools, fspool);
+        fspool = NULL;
+    } else if (fspool->newDef) {
+        virFsPoolDefFree(fspool->def);
+        fspool->def = fspool->newDef;
+        fspool->newDef = NULL;
+    }
+
+    ret = 0;
+
+ cleanup:
+    if (fspool)
+        virFsPoolObjUnlock(fspool);
+    fsDriverUnlock();
+    return ret;
+}
+
+static int
+fsPoolDelete(virFsPoolPtr obj,
+             unsigned int flags)
+{
+    virFsPoolObjPtr fspool;
+    virFsBackendPtr backend;
+    char *stateFile = NULL;
+    int ret = -1;
+
+    virCheckFlags(0, -1);
+
+    if (!(fspool = virFsPoolObjFromFsPool(obj)))
+        return -1;
+
+    if (virFsPoolDeleteEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if ((backend = virFsBackendForType(fspool->def->type)) == NULL)
+        goto cleanup;
+
+    VIR_INFO("Deleting fspool '%s'", fspool->def->name);
+
+    if (virFsPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is still active"),
+                       fspool->def->name);
+        goto cleanup;
+    }
+
+    if (fspool->asyncjobs > 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("fspool '%s' has asynchronous jobs running."),
+                       fspool->def->name);
+        goto cleanup;
+    }
+
+    if (!(stateFile = virFileBuildPath(driver->stateDir,
+                                       fspool->def->name,
+                                       ".xml")))
+        goto cleanup;
+
+    unlink(stateFile);
+    VIR_FREE(stateFile);
+
+    if (!backend->deleteFspool) {
+        virReportError(VIR_ERR_NO_SUPPORT,
+                       "%s", _("fspool does not support fspool deletion"));
+        goto cleanup;
+    }
+    if (backend->deleteFspool(obj->conn, fspool, flags) < 0)
+        goto cleanup;
+
+    ret = 0;
+
+ cleanup:
+    virFsPoolObjUnlock(fspool);
+    return ret;
+}
+
+static int
+fsPoolRefresh(virFsPoolPtr obj,
+              unsigned int flags)
+{
+    virFsPoolObjPtr fspool;
+    virFsBackendPtr backend;
+    int ret = -1;
+
+    virCheckFlags(0, -1);
+
+    fsDriverLock();
+    if (!(fspool = virFsPoolObjFindByUUID(&driver->fspools, obj->uuid))) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+        virUUIDFormat(obj->uuid, uuidstr);
+        virReportError(VIR_ERR_NO_FS_POOL,
+                       _("no fspool with matching uuid '%s' (%s)"),
+                       uuidstr, obj->name);
+        goto cleanup;
+    }
+
+    if (virFsPoolRefreshEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if ((backend = virFsBackendForType(fspool->def->type)) == NULL)
+        goto cleanup;
+
+    if (!virFsPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"), fspool->def->name);
+        goto cleanup;
+    }
+
+    if (fspool->asyncjobs > 0) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("fspool '%s' has asynchronous jobs running."),
+                       fspool->def->name);
+        goto cleanup;
+    }
+
+    virFsPoolObjClearItems(fspool);
+    if (backend->refreshFspool(obj->conn, fspool) < 0) {
+        if (backend->stopFspool)
+            backend->stopFspool(obj->conn, fspool);
+
+        fspool->active = false;
+
+        if (fspool->configFile == NULL) {
+            virFsPoolObjRemove(&driver->fspools, fspool);
+            fspool = NULL;
+        }
+        goto cleanup;
+    }
+    ret = 0;
+
+ cleanup:
+    if (fspool)
+        virFsPoolObjUnlock(fspool);
+    fsDriverUnlock();
+    return ret;
+
+    return 0;
+}
+
+
+static int
+fsPoolGetInfo(virFsPoolPtr obj,
+              virFsPoolInfoPtr info)
+{
+    virFsPoolObjPtr fspool;
+    int ret = -1;
+
+    if (!(fspool = virFsPoolObjFromFsPool(obj)))
+        return -1;
+
+    if (virFsPoolGetInfoEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if (virFsBackendForType(fspool->def->type) == NULL)
+        goto cleanup;
+
+    memset(info, 0, sizeof(virFsPoolInfo));
+    if (fspool->active)
+        info->state = VIR_FS_POOL_RUNNING;
+    else
+        info->state = VIR_FS_POOL_INACTIVE;
+    info->capacity = fspool->def->capacity;
+    info->allocation = fspool->def->allocation;
+    info->available = fspool->def->available;
+    ret = 0;
+
+ cleanup:
+    virFsPoolObjUnlock(fspool);
+    return ret;
+}
+
+static char *
+fsPoolGetXMLDesc(virFsPoolPtr obj,
+                 unsigned int flags)
+{
+    virFsPoolObjPtr fspool;
+    virFsPoolDefPtr def;
+    char *ret = NULL;
+
+    virCheckFlags(VIR_FS_XML_INACTIVE, NULL);
+
+    if (!(fspool = virFsPoolObjFromFsPool(obj)))
+        return NULL;
+
+    if (virFsPoolGetXMLDescEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if ((flags & VIR_FS_XML_INACTIVE) && fspool->newDef)
+        def = fspool->newDef;
+    else
+        def = fspool->def;
+
+    ret = virFsPoolDefFormat(def);
+
+ cleanup:
+    virFsPoolObjUnlock(fspool);
+    return ret;
+}
+
+static int
+fsPoolGetAutostart(virFsPoolPtr obj, int *autostart)
+{
+    virFsPoolObjPtr fspool;
+    int ret = -1;
+
+    if (!(fspool = virFsPoolObjFromFsPool(obj)))
+        return -1;
+
+    if (virFsPoolGetAutostartEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if (!fspool->configFile) {
+        *autostart = 0;
+    } else {
+        *autostart = fspool->autostart;
+    }
+    ret = 0;
+
+ cleanup:
+    virFsPoolObjUnlock(fspool);
+    return ret;
+}
+
+static int
+fsPoolSetAutostart(virFsPoolPtr obj, int autostart)
+{
+    virFsPoolObjPtr fspool;
+    int ret = -1;
+
+    fsDriverLock();
+    fspool = virFsPoolObjFindByUUID(&driver->fspools, obj->uuid);
+
+    if (!fspool) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+        virUUIDFormat(obj->uuid, uuidstr);
+        virReportError(VIR_ERR_NO_FS_POOL,
+                       _("no fspool with matching uuid '%s' (%s)"),
+                       uuidstr, obj->name);
+        goto cleanup;
+    }
+
+    if (virFsPoolSetAutostartEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if (!fspool->configFile) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       "%s", _("fspool has no config file"));
+        goto cleanup;
+    }
+
+    autostart = (autostart != 0);
+
+    if (fspool->autostart != autostart) {
+        if (autostart) {
+            if (virFileMakePath(driver->autostartDir) < 0) {
+                virReportSystemError(errno,
+                                     _("cannot create autostart directory %s"),
+                                     driver->autostartDir);
+                goto cleanup;
+            }
+
+            if (symlink(fspool->configFile, fspool->autostartLink) < 0) {
+                virReportSystemError(errno,
+                                     _("Failed to create symlink '%s' to '%s'"),
+                                     fspool->autostartLink, fspool->configFile);
+                goto cleanup;
+            }
+        } else {
+            if (unlink(fspool->autostartLink) < 0 &&
+                errno != ENOENT && errno != ENOTDIR) {
+                virReportSystemError(errno,
+                                     _("Failed to delete symlink '%s'"),
+                                     fspool->autostartLink);
+                goto cleanup;
+            }
+        }
+        fspool->autostart = autostart;
+    }
+    ret = 0;
+
+ cleanup:
+    if (fspool)
+        virFsPoolObjUnlock(fspool);
+    fsDriverUnlock();
+    return ret;
+}
+
+static int
+fsPoolNumOfItems(virFsPoolPtr obj)
+{
+    virFsPoolObjPtr fspool;
+    int ret = -1;
+    size_t i;
+
+    if (!(fspool = virFsPoolObjFromFsPool(obj)))
+        return -1;
+
+    if (virFsPoolNumOfItemsEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if (!virFsPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"), fspool->def->name);
+        goto cleanup;
+    }
+    ret = 0;
+    for (i = 0; i < fspool->items.count; i++) {
+        if (virFsPoolNumOfItemsCheckACL(obj->conn, fspool->def,
+                                               fspool->items.objs[i]))
+            ret++;
+    }
+
+ cleanup:
+    virFsPoolObjUnlock(fspool);
+    return ret;
+}
+
+static int
+fsPoolListItems(virFsPoolPtr obj,
+                char **const names,
+                int maxnames)
+{
+    virFsPoolObjPtr fspool;
+    size_t i;
+    int n = 0;
+
+    memset(names, 0, maxnames * sizeof(*names));
+
+    if (!(fspool = virFsPoolObjFromFsPool(obj)))
+        return -1;
+
+    if (virFsPoolListItemsEnsureACL(obj->conn, fspool->def) < 0)
+        goto cleanup;
+
+    if (!virFsPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"), fspool->def->name);
+        goto cleanup;
+    }
+
+    for (i = 0; i < fspool->items.count && n < maxnames; i++) {
+        if (!virFsPoolListItemsCheckACL(obj->conn, fspool->def,
+                                        fspool->items.objs[i]))
+            continue;
+        if (VIR_STRDUP(names[n++], fspool->items.objs[i]->name) < 0)
+            goto cleanup;
+    }
+
+    virFsPoolObjUnlock(fspool);
+    return n;
+
+ cleanup:
+    virFsPoolObjUnlock(fspool);
+    for (n = 0; n < maxnames; n++)
+        VIR_FREE(names[n]);
+
+    memset(names, 0, maxnames * sizeof(*names));
+    return -1;
+}
+
+static int
+fsPoolListAllItems(virFsPoolPtr fspool,
+                   virFsItemPtr **items,
+                   unsigned int flags)
+{
+    virFsPoolObjPtr obj;
+    size_t i;
+    virFsItemPtr *tmp_items = NULL;
+    virFsItemPtr item = NULL;
+    int nitems = 0;
+    int ret = -1;
+
+    virCheckFlags(0, -1);
+
+    if (!(obj = virFsPoolObjFromFsPool(fspool)))
+        return -1;
+
+    if (virFsPoolListAllItemsEnsureACL(fspool->conn, obj->def) < 0)
+        goto cleanup;
+
+    if (!virFsPoolObjIsActive(obj)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"), obj->def->name);
+        goto cleanup;
+    }
+
+     /* Just returns the items count */
+    if (!items) {
+        ret = obj->items.count;
+        goto cleanup;
+    }
+
+    if (VIR_ALLOC_N(tmp_items, obj->items.count + 1) < 0)
+        goto cleanup;
+
+    for (i = 0; i < obj->items.count; i++) {
+        if (!virFsPoolListAllItemsCheckACL(fspool->conn, obj->def,
+                                                  obj->items.objs[i]))
+            continue;
+        if (!(item = virGetFsItem(fspool->conn, obj->def->name,
+                                  obj->items.objs[i]->name,
+                                  obj->items.objs[i]->key,
+                                  NULL, NULL)))
+            goto cleanup;
+        tmp_items[nitems++] = item;
+    }
+
+    *items = tmp_items;
+    tmp_items = NULL;
+    ret = nitems;
+
+ cleanup:
+    if (tmp_items) {
+        for (i = 0; i < nitems; i++)
+            virObjectUnref(tmp_items[i]);
+        VIR_FREE(tmp_items);
+    }
+
+    virFsPoolObjUnlock(obj);
+
+    return ret;
+}
+
+static virFsItemPtr
+fsItemLookupByName(virFsPoolPtr obj, const char *name)
+{
+    virFsPoolObjPtr fspool;
+    virFsItemDefPtr item;
+    virFsItemPtr ret = NULL;
+
+    if (!(fspool = virFsPoolObjFromFsPool(obj)))
+        return NULL;
+
+    if (!virFsPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"), fspool->def->name);
+        goto cleanup;
+    }
+
+    item = virFsItemDefFindByName(fspool, name);
+
+    if (!item) {
+        virReportError(VIR_ERR_NO_FS_ITEM,
+                       _("no fspool item with matching name '%s'"),
+                       name);
+        goto cleanup;
+    }
+
+    if (virFsItemLookupByNameEnsureACL(obj->conn, fspool->def, item) < 0)
+        goto cleanup;
+
+    ret = virGetFsItem(obj->conn, fspool->def->name, item->name, item->key,
+                       NULL, NULL);
+
+ cleanup:
+    virFsPoolObjUnlock(fspool);
+    return ret;
+}
+
+
+static virFsItemPtr
+fsItemLookupByKey(virConnectPtr conn, const char *key)
+{
+    size_t i;
+    virFsItemPtr ret = NULL;
+
+    fsDriverLock();
+    for (i = 0; i < driver->fspools.count && !ret; i++) {
+        virFsPoolObjLock(driver->fspools.objs[i]);
+        if (virFsPoolObjIsActive(driver->fspools.objs[i])) {
+            virFsItemDefPtr item =
+                virFsItemDefFindByKey(driver->fspools.objs[i], key);
+
+            if (item) {
+                virFsPoolDefPtr def = driver->fspools.objs[i]->def;
+                if (virFsItemLookupByKeyEnsureACL(conn, def, item) < 0) {
+                    virFsPoolObjUnlock(driver->fspools.objs[i]);
+                    goto cleanup;
+                }
+
+                ret = virGetFsItem(conn,
+                                   def->name,
+                                   item->name,
+                                   item->key,
+                                   NULL, NULL);
+            }
+        }
+        virFsPoolObjUnlock(driver->fspools.objs[i]);
+    }
+
+    if (!ret)
+        virReportError(VIR_ERR_NO_FS_ITEM,
+                       _("no fspool item with matching key %s"), key);
+
+ cleanup:
+    fsDriverUnlock();
+    return ret;
+}
+
+static virFsItemPtr
+fsItemLookupByPath(virConnectPtr conn,
+                   const char *path)
+{
+    size_t i;
+    virFsItemPtr ret = NULL;
+    char *cleanpath;
+
+    cleanpath = virFileSanitizePath(path);
+    if (!cleanpath)
+        return NULL;
+
+    fsDriverLock();
+    for (i = 0; i < driver->fspools.count && !ret; i++) {
+        virFsPoolObjPtr fspool = driver->fspools.objs[i];
+        virFsItemDefPtr item;
+
+        virFsPoolObjLock(fspool);
+
+        if (!virFsPoolObjIsActive(fspool)) {
+           virFsPoolObjUnlock(fspool);
+           continue;
+        }
+
+        item = virFsItemDefFindByPath(fspool, cleanpath);
+
+        if (item) {
+            if (virFsItemLookupByPathEnsureACL(conn, fspool->def, item) < 0) {
+                virFsPoolObjUnlock(fspool);
+                goto cleanup;
+            }
+
+            ret = virGetFsItem(conn, fspool->def->name,
+                               item->name, item->key,
+                               NULL, NULL);
+        }
+
+        virFsPoolObjUnlock(fspool);
+    }
+
+    if (!ret) {
+        if (STREQ(path, cleanpath)) {
+            virReportError(VIR_ERR_NO_FS_ITEM,
+                           _("no fspool item with matching path '%s'"), path);
+        } else {
+            virReportError(VIR_ERR_NO_FS_ITEM,
+                           _("no fspool item with matching path '%s' (%s)"),
+                           path, cleanpath);
+        }
+    }
+
+ cleanup:
+    VIR_FREE(cleanpath);
+    fsDriverUnlock();
+    return ret;
+}
+
+static virFsItemPtr
+fsItemCreateXML(virFsPoolPtr obj,
+                const char *xmldesc,
+                unsigned int flags)
+{
+    virFsPoolObjPtr fspool;
+    virFsBackendPtr backend;
+    virFsItemDefPtr itemdef = NULL;
+    virFsItemPtr ret = NULL, itemobj = NULL;
+
+    virCheckFlags(0, NULL);
+
+    if (!(fspool = virFsPoolObjFromFsPool(obj)))
+        return NULL;
+
+    if (!virFsPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fspool '%s' is not active"), fspool->def->name);
+        goto cleanup;
+    }
+
+    if ((backend = virFsBackendForType(fspool->def->type)) == NULL)
+        goto cleanup;
+
+    itemdef = virFsItemDefParseString(fspool->def, xmldesc,
+                                      VIR_ITEM_XML_PARSE_OPT_CAPACITY);
+    if (itemdef == NULL)
+        goto cleanup;
+
+    if (!itemdef->target.capacity && !backend->buildItem) {
+        virReportError(VIR_ERR_NO_SUPPORT,
+                       "%s", _("item capacity required for this "
+                               "fspool"));
+        goto cleanup;
+    }
+
+    if (virFsItemCreateXMLEnsureACL(obj->conn, fspool->def, itemdef) < 0)
+        goto cleanup;
+
+    if (virFsItemDefFindByName(fspool, itemdef->name)) {
+        virReportError(VIR_ERR_FS_ITEM_EXIST,
+                       _("'%s'"), itemdef->name);
+        goto cleanup;
+    }
+
+    if (!backend->createItem) {
+        virReportError(VIR_ERR_NO_SUPPORT,
+                       "%s", _("fspool does not support item "
+                               "creation"));
+        goto cleanup;
+    }
+
+    if (VIR_REALLOC_N(fspool->items.objs,
+                      fspool->items.count+1) < 0)
+        goto cleanup;
+
+    /* Wipe any key the user may have suggested, as item creation
+     * will generate the canonical key.  */
+    VIR_FREE(itemdef->key);
+    if (backend->createItem(obj->conn, fspool, itemdef) < 0)
+        goto cleanup;
+
+    fspool->items.objs[fspool->items.count++] = itemdef;
+    itemobj = virGetFsItem(obj->conn, fspool->def->name, itemdef->name,
+                           itemdef->key, NULL, NULL);
+    if (!itemobj) {
+        fspool->items.count--;
+        goto cleanup;
+    }
+
+
+    if (backend->buildItem) {
+        int buildret;
+        virFsItemDefPtr builditemdef = NULL;
+
+        if (VIR_ALLOC(builditemdef) < 0) {
+            itemdef = NULL;
+            goto cleanup;
+        }
+
+        /* Make a shallow copy of the 'defined' item definition, since the
+         * original allocation value will change as the user polls 'info',
+         * but we only need the initial requested values
+         */
+        memcpy(builditemdef, itemdef, sizeof(*itemdef));
+
+        /* Drop the fspool lock during item allocation */
+        fspool->asyncjobs++;
+        itemdef->building = true;
+        virFsPoolObjUnlock(fspool);
+
+        buildret = backend->buildItem(obj->conn, fspool, builditemdef, flags);
+
+        VIR_FREE(builditemdef);
+
+        fsDriverLock();
+        virFsPoolObjLock(fspool);
+        fsDriverUnlock();
+
+        itemdef->building = false;
+        fspool->asyncjobs--;
+
+        if (buildret < 0) {
+            /* buildItem handles deleting item on failure */
+            fsItemRemoveFromFsPool(fspool, itemdef);
+            itemdef = NULL;
+            goto cleanup;
+        }
+
+    }
+
+    if (backend->refreshItem &&
+        backend->refreshItem(obj->conn, fspool, itemdef) < 0) {
+        fsItemDeleteInternal(itemobj, backend, fspool, itemdef, 0);
+        itemdef = NULL;
+        goto cleanup;
+    }
+
+    /* Update fspool metadata ignoring the disk backend since
+     * it updates the fspool values.
+     */
+
+    VIR_INFO("Creating item '%s' in fs fspool '%s'",
+             itemobj->name, fspool->def->name);
+    ret = itemobj;
+    itemobj = NULL;
+    itemdef = NULL;
+
+ cleanup:
+    virObjectUnref(itemobj);
+    virFsItemDefFree(itemdef);
+    if (fspool)
+        virFsPoolObjUnlock(fspool);
+    return ret;
+}
+
+static virFsItemPtr
+fsItemCreateXMLFrom(virFsPoolPtr obj,
+                    const char *xmldesc,
+                    virFsItemPtr vobj,
+                    unsigned int flags)
+{
+    virFsPoolObjPtr fspool, origpool = NULL;
+    virFsBackendPtr backend;
+    virFsItemDefPtr origitem = NULL, newitem = NULL, shadowitem = NULL;
+    virFsItemPtr ret = NULL, itemobj = NULL;
+    int buildret;
+
+    virCheckFlags(0, NULL);
+
+    fsDriverLock();
+    fspool = virFsPoolObjFindByUUID(&driver->fspools, obj->uuid);
+    if (fspool && STRNEQ(obj->name, vobj->fspool)) {
+        virFsPoolObjUnlock(fspool);
+        origpool = virFsPoolObjFindByName(&driver->fspools, vobj->fspool);
+        virFsPoolObjLock(fspool);
+    }
+    fsDriverUnlock();
+    if (!fspool) {
+        char uuidstr[VIR_UUID_STRING_BUFLEN];
+        virUUIDFormat(obj->uuid, uuidstr);
+        virReportError(VIR_ERR_NO_FS_POOL,
+                       _("no fs fspool with matching uuid '%s' (%s)"),
+                       uuidstr, obj->name);
+        goto cleanup;
+    }
+
+    if (STRNEQ(obj->name, vobj->fspool) && !origpool) {
+        virReportError(VIR_ERR_NO_FS_POOL,
+                       _("no fs fspool with matching name '%s'"),
+                       vobj->fspool);
+        goto cleanup;
+    }
+
+    if (!virFsPoolObjIsActive(fspool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fs fspool '%s' is not active"), fspool->def->name);
+        goto cleanup;
+    }
+
+    if (origpool && !virFsPoolObjIsActive(origpool)) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("fs fspool '%s' is not active"),
+                       origpool->def->name);
+        goto cleanup;
+    }
+
+    if ((backend = virFsBackendForType(fspool->def->type)) == NULL)
+        goto cleanup;
+
+    origitem = virFsItemDefFindByName(origpool ?
+                                         origpool : fspool, vobj->name);
+    if (!origitem) {
+        virReportError(VIR_ERR_NO_FS_ITEM,
+                       _("no fs item with matching name '%s'"),
+                       vobj->name);
+        goto cleanup;
+    }
+
+    newitem = virFsItemDefParseString(fspool->def, xmldesc,
+                                         VIR_VOL_XML_PARSE_NO_CAPACITY);
+    if (newitem == NULL)
+        goto cleanup;
+
+    if (virFsItemCreateXMLFromEnsureACL(obj->conn, fspool->def, newitem) < 0)
+        goto cleanup;
+
+    if (virFsItemDefFindByName(fspool, newitem->name)) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("fs item name '%s' already in use."),
+                       newitem->name);
+        goto cleanup;
+    }
+
+    /* Use the original item's capacity in case the new capacity
+     * is less than that, or it was omitted */
+    if (newitem->target.capacity < origitem->target.capacity)
+        newitem->target.capacity = origitem->target.capacity;
+
+    if (!backend->buildItemFrom) {
+        virReportError(VIR_ERR_NO_SUPPORT,
+                       "%s", _("fs fspool does not support"
+                               " item creation from an existing item"));
+        goto cleanup;
+    }
+
+    if (origitem->building) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("item '%s' is still being allocated."),
+                       origitem->name);
+        goto cleanup;
+    }
+
+    if (backend->refreshItem &&
+        backend->refreshItem(obj->conn, fspool, origitem) < 0)
+        goto cleanup;
+
+    if (VIR_REALLOC_N(fspool->items.objs,
+                      fspool->items.count+1) < 0)
+        goto cleanup;
+
+    /* 'Define' the new item so we get async progress reporting.
+     * Wipe any key the user may have suggested, as item creation
+     * will generate the canonical key.  */
+    VIR_FREE(newitem->key);
+    if (backend->createItem(obj->conn, fspool, newitem) < 0)
+        goto cleanup;
+
+    /* Make a shallow copy of the 'defined' item definition, since the
+     * original allocation value will change as the user polls 'info',
+     * but we only need the initial requested values
+     */
+    if (VIR_ALLOC(shadowitem) < 0)
+        goto cleanup;
+
+    memcpy(shadowitem, newitem, sizeof(*newitem));
+
+    fspool->items.objs[fspool->items.count++] = newitem;
+    itemobj = virGetFsItem(obj->conn, fspool->def->name, newitem->name,
+                              newitem->key, NULL, NULL);
+    if (!itemobj) {
+        fspool->items.count--;
+        goto cleanup;
+    }
+
+    /* Drop the fspool lock during item allocation */
+    fspool->asyncjobs++;
+    newitem->building = true;
+    origitem->in_use++;
+    virFsPoolObjUnlock(fspool);
+
+    if (origpool) {
+        origpool->asyncjobs++;
+        virFsPoolObjUnlock(origpool);
+    }
+
+    buildret = backend->buildItemFrom(obj->conn, fspool, shadowitem, origitem, flags);
+
+    fsDriverLock();
+    virFsPoolObjLock(fspool);
+    if (origpool)
+        virFsPoolObjLock(origpool);
+    fsDriverUnlock();
+
+    origitem->in_use--;
+    newitem->building = false;
+    fspool->asyncjobs--;
+
+    if (origpool) {
+        origpool->asyncjobs--;
+        virFsPoolObjUnlock(origpool);
+        origpool = NULL;
+    }
+
+    if (buildret < 0 ||
+        (backend->refreshItem &&
+         backend->refreshItem(obj->conn, fspool, newitem) < 0)) {
+        fsItemDeleteInternal(itemobj, backend, fspool, newitem, 0);
+        newitem = NULL;
+        goto cleanup;
+    }
+
+    fspool->def->allocation += newitem->target.allocation;
+    fspool->def->available -= newitem->target.allocation;
+
+    VIR_INFO("Creating item '%s' in fs fspool '%s'",
+             itemobj->name, fspool->def->name);
+    ret = itemobj;
+    itemobj = NULL;
+    newitem = NULL;
+
+ cleanup:
+    virObjectUnref(itemobj);
+    virFsItemDefFree(newitem);
+    VIR_FREE(shadowitem);
+    if (fspool)
+        virFsPoolObjUnlock(fspool);
+    if (origpool)
+        virFsPoolObjUnlock(origpool);
+    return ret;
+}
+
+
+static int
+fsItemGetInfo(virFsItemPtr obj,
+              virFsItemInfoPtr info)
+{
+    virFsPoolObjPtr fspool;
+    virFsBackendPtr backend;
+    virFsItemDefPtr item;
+    int ret = -1;
+
+    if (!(item = virFsItemDefFromItem(obj, &fspool, &backend)))
+        return -1;
+
+    if (virFsItemGetInfoEnsureACL(obj->conn, fspool->def, item) < 0)
+        goto cleanup;
+
+    if (backend->refreshItem &&
+        backend->refreshItem(obj->conn, fspool, item) < 0)
+        goto cleanup;
+
+    memset(info, 0, sizeof(*info));
+    info->type = item->type;
+    info->capacity = item->target.capacity;
+    info->allocation = item->target.allocation;
+    ret = 0;
+
+ cleanup:
+    virFsPoolObjUnlock(fspool);
+    return ret;
+}
+
+static char *
+fsItemGetXMLDesc(virFsItemPtr obj, unsigned int flags)
+{
+    virFsPoolObjPtr fspool;
+    virFsBackendPtr backend;
+    virFsItemDefPtr item;
+    char *ret = NULL;
+
+    virCheckFlags(0, NULL);
+
+    if (!(item = virFsItemDefFromItem(obj, &fspool, &backend)))
+        return NULL;
+
+    if (virFsItemGetXMLDescEnsureACL(obj->conn, fspool->def, item) < 0)
+        goto cleanup;
+
+    if (backend->refreshItem &&
+        backend->refreshItem(obj->conn, fspool, item) < 0)
+        goto cleanup;
+
+    ret = virFsItemDefFormat(fspool->def, item);
+
+ cleanup:
+    virFsPoolObjUnlock(fspool);
+
+    return ret;
+}
+
+static char *
+fsItemGetPath(virFsItemPtr obj)
+{
+    virFsPoolObjPtr fspool;
+    virFsItemDefPtr item;
+    char *ret = NULL;
+
+    if (!(item = virFsItemDefFromItem(obj, &fspool, NULL)))
+        return NULL;
+
+    if (virFsItemGetPathEnsureACL(obj->conn, fspool->def, item) < 0)
+        goto cleanup;
+
+    ignore_value(VIR_STRDUP(ret, item->target.path));
+
+ cleanup:
+    virFsPoolObjUnlock(fspool);
+    return ret;
+}
+
+
+static int fsPoolIsActive(virFsPoolPtr fspool)
+{
+    virFsPoolObjPtr obj;
+    int ret = -1;
+
+    if (!(obj = virFsPoolObjFromFsPool(fspool)))
+        return -1;
+
+    if (virFsPoolIsActiveEnsureACL(fspool->conn, obj->def) < 0)
+        goto cleanup;
+
+    ret = virFsPoolObjIsActive(obj);
+
+ cleanup:
+    virFsPoolObjUnlock(obj);
+    return ret;
+}
+
+static int fsPoolIsPersistent(virFsPoolPtr fspool)
+{
+    virFsPoolObjPtr obj;
+    int ret = -1;
+
+    if (!(obj = virFsPoolObjFromFsPool(fspool)))
+        return -1;
+
+    if (virFsPoolIsPersistentEnsureACL(fspool->conn, obj->def) < 0)
+        goto cleanup;
+
+    ret = obj->configFile ? 1 : 0;
+
+ cleanup:
+    virFsPoolObjUnlock(obj);
+    return ret;
+}
+
+
+static int
+fsItemDelete(virFsItemPtr obj,
+             unsigned int flags)
+{
+    virFsPoolObjPtr fspool;
+    virFsBackendPtr backend;
+    virFsItemDefPtr item = NULL;
+    int ret = -1;
+
+    virCheckFlags(0, -1);
+
+    if (!(item = virFsItemDefFromItem(obj, &fspool, &backend)))
+        return -1;
+
+    if (virFsItemDeleteEnsureACL(obj->conn, fspool->def, item) < 0)
+        goto cleanup;
+
+    if (item->in_use) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("item '%s' is still in use."),
+                       item->name);
+        goto cleanup;
+    }
+
+    if (item->building) {
+        virReportError(VIR_ERR_OPERATION_INVALID,
+                       _("item '%s' is still being allocated."),
+                       item->name);
+        goto cleanup;
+    }
+
+    if (fsItemDeleteInternal(obj, backend, fspool, item, flags) < 0)
+        goto cleanup;
+
+    ret = 0;
+
+ cleanup:
+    virFsPoolObjUnlock(fspool);
+    return ret;
+}
+
+static virFsDriver fsDriver = {
+    .name = "fs",
+    .connectNumOfFsPools = fsConnectNumOfFsPools, /* 2.1.0 */
+    .connectListFsPools = fsConnectListFsPools, /* 2.1.0 */
+    .connectNumOfDefinedFsPools = fsConnectNumOfDefinedFsPools, /* 2.1.0 */
+    .connectListDefinedFsPools = fsConnectListDefinedFsPools, /* 2.1.0 */
+    .connectListAllFsPools = fsConnectListAllFsPools, /* 2.1.0 */
+    .fsPoolLookupByName = fsPoolLookupByName, /* 2.1.0 */
+    .fsPoolLookupByUUID = fsPoolLookupByUUID, /* 2.1.0 */
+    .fsPoolLookupByItem = fsPoolLookupByItem, /* 2.1.0 */
+    .fsPoolCreateXML = fsPoolCreateXML, /* 2.1.0 */
+    .fsPoolDefineXML = fsPoolDefineXML, /* 2.1.0 */
+    .fsPoolBuild = fsPoolBuild, /* 2.1.0 */
+    .fsPoolCreate = fsPoolCreate, /* 2.1.0 */
+    .fsPoolUndefine = fsPoolUndefine, /* 2.1.0 */
+    .fsPoolDestroy = fsPoolDestroy, /* 2.1.0 */
+    .fsPoolDelete = fsPoolDelete, /* 2.1.0 */
+    .fsPoolRefresh = fsPoolRefresh, /* 2.1.0 */
+    .fsPoolGetInfo = fsPoolGetInfo, /* 2.1.0 */
+    .fsPoolGetXMLDesc = fsPoolGetXMLDesc, /* 2.1.0 */
+    .fsPoolGetAutostart = fsPoolGetAutostart, /* 2.1.0 */
+    .fsPoolSetAutostart = fsPoolSetAutostart, /* 2.1.0 */
+    .fsPoolNumOfItems = fsPoolNumOfItems, /* 2.1.0 */
+    .fsPoolListItems = fsPoolListItems, /* 2.1.0 */
+    .fsPoolListAllItems = fsPoolListAllItems, /* 2.1.0 */
+    .fsItemLookupByName = fsItemLookupByName, /* 2.1.0 */
+    .fsItemLookupByKey = fsItemLookupByKey, /* 2.1.0 */
+    .fsItemLookupByPath = fsItemLookupByPath, /* 2.1.0 */
+    .fsItemCreateXML = fsItemCreateXML, /* 2.1.0 */
+    .fsItemCreateXMLFrom = fsItemCreateXMLFrom, /* 2.1.0 */
+    .fsItemDelete = fsItemDelete, /* 2.1.0 */
+    .fsItemGetInfo = fsItemGetInfo, /* 2.1.0 */
+    .fsItemGetXMLDesc = fsItemGetXMLDesc, /* 2.1.0 */
+    .fsItemGetPath = fsItemGetPath, /* 2.1.0 */
+    .fsPoolIsActive = fsPoolIsActive, /* 2.1.0 */
+    .fsPoolIsPersistent = fsPoolIsPersistent, /* 2.1.0 */
+};
+
+
+static virStateDriver stateDriver = {
+    .name = "fs",
+    .stateInitialize = fsStateInitialize,
+    .stateAutoStart = fsStateAutoStart,
+    .stateCleanup = fsStateCleanup,
+    .stateReload = fsStateReload,
+};
+
+int fsRegister(void)
+{
+    VIR_DEBUG("fsDriver = %p", &fsDriver);
+
+    if (virSetSharedFsDriver(&fsDriver) < 0)
+        return -1;
+
+    if (virRegisterStateDriver(&stateDriver) < 0)
+        return -1;
+
+    VIR_DEBUG("fsDriver = %p", &fsDriver);
+
+    return 0;
+}
diff --git a/src/fs/fs_driver.h b/src/fs/fs_driver.h
new file mode 100644
index 0000000..aaf0258
--- /dev/null
+++ b/src/fs/fs_driver.h
@@ -0,0 +1,10 @@
+#ifndef __VIR_FS_DRIVER_H__
+# define __VIR_FS_DRIVER_H__
+
+# include <sys/stat.h>
+
+# include "domain_conf.h"
+# include "fs_conf.h"
+
+int fsRegister(void);
+#endif /* __VIR_FS_DRIVER_H__ */
diff --git a/src/libvirt.c b/src/libvirt.c
index 52462e3..cccebdd 100644
--- a/src/libvirt.c
+++ b/src/libvirt.c
@@ -116,6 +116,7 @@ static int virStateDriverTabCount;
 static virNetworkDriverPtr virSharedNetworkDriver;
 static virInterfaceDriverPtr virSharedInterfaceDriver;
 static virStorageDriverPtr virSharedStorageDriver;
+static virFsDriverPtr virSharedFsDriver;
 static virNodeDeviceDriverPtr virSharedNodeDeviceDriver;
 static virSecretDriverPtr virSharedSecretDriver;
 static virNWFilterDriverPtr virSharedNWFilterDriver;
@@ -587,7 +588,30 @@ virSetSharedStorageDriver(virStorageDriverPtr driver)
     return 0;
 }
 
+/**
+ * virSetSharedFsDriver:
+ * @driver: pointer to a fs driver block
+ *
+ * Register a fs virtualization driver
+ *
+ * Returns the driver priority or -1 in case of error.
+ */
+int
+virSetSharedFsDriver(virFsDriverPtr driver)
+{
+    virCheckNonNullArgReturn(driver, -1);
 
+    if (virSharedFsDriver) {
+        virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+                       _("A fs driver is already registered"));
+        return -1;
+    }
+
+    VIR_DEBUG("registering %s as fs driver", driver->name);
+
+    virSharedFsDriver = driver;
+    return 0;
+}
 /**
  * virSetSharedNodeDeviceDriver:
  * @driver: pointer to a device monitor block
@@ -707,6 +731,8 @@ virRegisterConnectDriver(virConnectDriverPtr driver,
             driver->secretDriver = virSharedSecretDriver;
         if (driver->storageDriver == NULL)
             driver->storageDriver = virSharedStorageDriver;
+        if (driver->fsDriver == NULL)
+            driver->fsDriver = virSharedFsDriver;
     }
 
     virConnectDriverTab[virConnectDriverTabCount] = driver;
@@ -1089,6 +1115,7 @@ virConnectOpenInternal(const char *name,
         ret->nwfilterDriver = virConnectDriverTab[i]->nwfilterDriver;
         ret->secretDriver = virConnectDriverTab[i]->secretDriver;
         ret->storageDriver = virConnectDriverTab[i]->storageDriver;
+        ret->fsDriver = virConnectDriverTab[i]->fsDriver;
 
         res = virConnectDriverTab[i]->hypervisorDriver->connectOpen(ret, auth, conf, flags);
         VIR_DEBUG("driver %zu %s returned %s",
@@ -1107,6 +1134,7 @@ virConnectOpenInternal(const char *name,
             ret->nwfilterDriver = NULL;
             ret->secretDriver = NULL;
             ret->storageDriver = NULL;
+            ret->fsDriver = NULL;
 
             if (res == VIR_DRV_OPEN_ERROR)
                 goto failed;
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index 68150d6..f504143 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -1085,6 +1085,7 @@ virDomainMigratePrepareTunnel3;
 virDomainMigratePrepareTunnel3Params;
 virRegisterConnectDriver;
 virRegisterStateDriver;
+virSetSharedFsDriver;
 virSetSharedInterfaceDriver;
 virSetSharedNetworkDriver;
 virSetSharedNodeDeviceDriver;
-- 
1.8.3.1

--
libvir-list mailing list
libvir-list@xxxxxxxxxx
https://www.redhat.com/mailman/listinfo/libvir-list




[Index of Archives]     [Virt Tools]     [Libvirt Users]     [Lib OS Info]     [Fedora Users]     [Fedora Desktop]     [Fedora SELinux]     [Big List of Linux Books]     [Yosemite News]     [KDE Users]     [Fedora Tools]