storage: backend: Refactor registration of the backend drivers

Add APIs that allow to dynamically register driver backends so that the
list of available drivers does not need to be known during compile time.

This will allow us to modularize the storage driver on runtime.

src/storage/storage_backend.c

@@ -72,67 +72,106 @@
 
 VIR_LOG_INIT("storage.storage_backend");
 
-static virStorageBackendPtr backends[] = {
+#define VIR_STORAGE_BACKENDS_MAX 20
-#if WITH_STORAGE_DIR
+
-    &virStorageBackendDirectory,
+static virStorageBackendPtr virStorageBackends[VIR_STORAGE_BACKENDS_MAX];
-#endif
+static size_t virStorageBackendsCount;
-#if WITH_STORAGE_FS
+static virStorageFileBackendPtr virStorageFileBackends[VIR_STORAGE_BACKENDS_MAX];
-    &virStorageBackendFileSystem,
+static size_t virStorageFileBackendsCount;
-    &virStorageBackendNetFileSystem,
+
+#define VIR_STORAGE_BACKEND_REGISTER(name)                                     \
+    if (name() < 0)                                                            \
+        return -1
+
+int
+virStorageBackendDriversRegister(void)
+{
+#if WITH_STORAGE_DIR || WITH_STORAGE_FS
+    VIR_STORAGE_BACKEND_REGISTER(virStorageBackendFsRegister);
 #endif
 #if WITH_STORAGE_LVM
-    &virStorageBackendLogical,
+    VIR_STORAGE_BACKEND_REGISTER(virStorageBackendLogicalRegister);
 #endif
 #if WITH_STORAGE_ISCSI
-    &virStorageBackendISCSI,
+    VIR_STORAGE_BACKEND_REGISTER(virStorageBackendISCSIRegister);
 #endif
 #if WITH_STORAGE_SCSI
-    &virStorageBackendSCSI,
+    VIR_STORAGE_BACKEND_REGISTER(virStorageBackendSCSIRegister);
 #endif
 #if WITH_STORAGE_MPATH
-    &virStorageBackendMpath,
+    VIR_STORAGE_BACKEND_REGISTER(virStorageBackendMpathRegister);
 #endif
 #if WITH_STORAGE_DISK
-    &virStorageBackendDisk,
+    VIR_STORAGE_BACKEND_REGISTER(virStorageBackendDiskRegister);
 #endif
 #if WITH_STORAGE_RBD
-    &virStorageBackendRBD,
+    VIR_STORAGE_BACKEND_REGISTER(virStorageBackendRBDRegister);
 #endif
 #if WITH_STORAGE_SHEEPDOG
-    &virStorageBackendSheepdog,
+    VIR_STORAGE_BACKEND_REGISTER(virStorageBackendSheepdogRegister);
 #endif
 #if WITH_STORAGE_GLUSTER
-    &virStorageBackendGluster,
+    VIR_STORAGE_BACKEND_REGISTER(virStorageBackendGlusterRegister);
 #endif
 #if WITH_STORAGE_ZFS
-    &virStorageBackendZFS,
+    VIR_STORAGE_BACKEND_REGISTER(virStorageBackendZFSRegister);
 #endif
 #if WITH_STORAGE_VSTORAGE
-    &virStorageBackendVstorage,
+    VIR_STORAGE_BACKEND_REGISTER(virStorageBackendVstorageRegister);
 #endif
-    NULL
+
-};
+    return 0;
+}
+#undef VIR_STORAGE_BACKEND_REGISTER
 
 
-static virStorageFileBackendPtr fileBackends[] = {
+int
-#if WITH_STORAGE_FS
+virStorageBackendRegister(virStorageBackendPtr backend)
-    &virStorageFileBackendFile,
+{
-    &virStorageFileBackendBlock,
+    VIR_DEBUG("Registering storage backend '%s'",
-#endif
+              virStorageTypeToString(backend->type));
-#if WITH_STORAGE_GLUSTER
+
-    &virStorageFileBackendGluster,
+    if (virStorageBackendsCount >= VIR_STORAGE_BACKENDS_MAX) {
-#endif
+        virReportError(VIR_ERR_INTERNAL_ERROR,
-    NULL
+                       _("Too many drivers, cannot register storage backend '%s'"),
-};
+                       virStorageTypeToString(backend->type));
+        return -1;
+    }
+
+    virStorageBackends[virStorageBackendsCount] = backend;
+    virStorageBackendsCount++;
+    return 0;
+}
+
+
+int
+virStorageBackendFileRegister(virStorageFileBackendPtr backend)
+{
+    VIR_DEBUG("Registering storage file backend '%s' protocol '%s'",
+              virStorageTypeToString(backend->type),
+              virStorageNetProtocolTypeToString(backend->protocol));
+
+    if (virStorageFileBackendsCount >= VIR_STORAGE_BACKENDS_MAX) {
+        virReportError(VIR_ERR_INTERNAL_ERROR,
+                       _("Too many drivers, cannot register storage file "
+                         "backend '%s'"),
+                       virStorageTypeToString(backend->type));
+        return -1;
+    }
+
+    virStorageFileBackends[virStorageFileBackendsCount] = backend;
+    virStorageFileBackendsCount++;
+    return 0;
+}
 
 
 virStorageBackendPtr
 virStorageBackendForType(int type)
 {
     size_t i;
-    for (i = 0; backends[i]; i++)
+    for (i = 0; i < virStorageBackendsCount; i++)
-        if (backends[i]->type == type)
+        if (virStorageBackends[i]->type == type)
-            return backends[i];
+            return virStorageBackends[i];
 
     virReportError(VIR_ERR_INTERNAL_ERROR,
                    _("missing backend for pool type %d (%s)"),
@@ -148,13 +187,13 @@ virStorageFileBackendForTypeInternal(int type,
 {
     size_t i;
 
-    for (i = 0; fileBackends[i]; i++) {
+    for (i = 0; i < virStorageFileBackendsCount; i++) {
-        if (fileBackends[i]->type == type) {
+        if (virStorageFileBackends[i]->type == type) {
             if (type == VIR_STORAGE_TYPE_NETWORK &&
-                fileBackends[i]->protocol != protocol)
+                virStorageFileBackends[i]->protocol != protocol)
                 continue;
 
-            return fileBackends[i];
+            return virStorageFileBackends[i];
         }
     }
 

src/storage/storage_backend.h

@@ -198,4 +198,9 @@ struct _virStorageFileBackend {
     virStorageFileBackendChown  storageFileChown;
 };
 
+int virStorageBackendDriversRegister(void);
+
+int virStorageBackendRegister(virStorageBackendPtr backend);
+int virStorageBackendFileRegister(virStorageFileBackendPtr backend);
+
 #endif /* __VIR_STORAGE_BACKEND_H__ */

src/storage/storage_backend_disk.c

@@ -937,3 +937,10 @@ virStorageBackend virStorageBackendDisk = {
     .downloadVol = virStorageBackendVolDownloadLocal,
     .wipeVol = virStorageBackendDiskVolWipe,
 };
+
+
+int
+virStorageBackendDiskRegister(void)
+{
+    return virStorageBackendRegister(&virStorageBackendDisk);
+}

src/storage/storage_backend_disk.h

@@ -24,8 +24,6 @@
 #ifndef __VIR_STORAGE_BACKEND_DISK_H__
 # define __VIR_STORAGE_BACKEND_DISK_H__
 
-# include "storage_backend.h"
+int virStorageBackendDiskRegister(void);
-
-extern virStorageBackend virStorageBackendDisk;
 
 #endif /* __VIR_STORAGE_BACKEND_DISK_H__ */

src/storage/storage_backend_fs.c

@@ -884,3 +884,30 @@ virStorageFileBackend virStorageFileBackendDir = {
 
     .storageFileGetUniqueIdentifier = virStorageFileBackendFileGetUniqueIdentifier,
 };
+
+
+int
+virStorageBackendFsRegister(void)
+{
+    if (virStorageBackendRegister(&virStorageBackendDirectory) < 0)
+        return -1;
+
+#if WITH_STORAGE_FS
+    if (virStorageBackendRegister(&virStorageBackendFileSystem) < 0)
+        return -1;
+
+    if (virStorageBackendRegister(&virStorageBackendNetFileSystem) < 0)
+        return -1;
+#endif /* WITH_STORAGE_FS */
+
+    if (virStorageBackendFileRegister(&virStorageFileBackendFile) < 0)
+        return -1;
+
+    if (virStorageBackendFileRegister(&virStorageFileBackendBlock) < 0)
+        return -1;
+
+    if (virStorageBackendFileRegister(&virStorageFileBackendDir) < 0)
+        return -1;
+
+    return 0;
+}

src/storage/storage_backend_fs.h

@@ -24,15 +24,6 @@
 #ifndef __VIR_STORAGE_BACKEND_FS_H__
 # define __VIR_STORAGE_BACKEND_FS_H__
 
-# include "storage_backend.h"
+int virStorageBackendFsRegister(void);
 
-# if WITH_STORAGE_FS
-extern virStorageBackend virStorageBackendFileSystem;
-extern virStorageBackend virStorageBackendNetFileSystem;
-# endif
-
-extern virStorageBackend virStorageBackendDirectory;
-
-extern virStorageFileBackend virStorageFileBackendFile;
-extern virStorageFileBackend virStorageFileBackendBlock;
 #endif /* __VIR_STORAGE_BACKEND_FS_H__ */

src/storage/storage_backend_gluster.c

@@ -843,6 +843,17 @@ virStorageFileBackend virStorageFileBackendGluster = {
     .storageFileChown = virStorageFileBackendGlusterChown,
 
     .storageFileGetUniqueIdentifier = virStorageFileBackendGlusterGetUniqueIdentifier,
-
-
 };
+
+
+int
+virStorageBackendGlusterRegister(void)
+{
+    if (virStorageBackendRegister(&virStorageBackendGluster) < 0)
+        return -1;
+
+    if (virStorageBackendFileRegister(&virStorageFileBackendGluster) < 0)
+        return -1;
+
+    return 0;
+}

src/storage/storage_backend_gluster.h

@@ -22,9 +22,6 @@
 #ifndef __VIR_STORAGE_BACKEND_GLUSTER_H__
 # define __VIR_STORAGE_BACKEND_GLUSTER_H__
 
-# include "storage_backend.h"
+int virStorageBackendGlusterRegister(void);
-
-extern virStorageBackend virStorageBackendGluster;
-extern virStorageFileBackend virStorageFileBackendGluster;
 
 #endif /* __VIR_STORAGE_BACKEND_GLUSTER_H__ */

src/storage/storage_backend_iscsi.c

@@ -437,3 +437,10 @@ virStorageBackend virStorageBackendISCSI = {
     .downloadVol = virStorageBackendVolDownloadLocal,
     .wipeVol = virStorageBackendVolWipeLocal,
 };
+
+
+int
+virStorageBackendISCSIRegister(void)
+{
+    return virStorageBackendRegister(&virStorageBackendISCSI);
+}

src/storage/storage_backend_iscsi.h

@@ -24,8 +24,6 @@
 #ifndef __VIR_STORAGE_BACKEND_ISCSI_H__
 # define __VIR_STORAGE_BACKEND_ISCSI_H__
 
-# include "storage_backend.h"
+int virStorageBackendISCSIRegister(void);
-
-extern virStorageBackend virStorageBackendISCSI;
 
 #endif /* __VIR_STORAGE_BACKEND_ISCSI_H__ */

src/storage/storage_backend_logical.c

@@ -1112,3 +1112,10 @@ virStorageBackend virStorageBackendLogical = {
     .downloadVol = virStorageBackendVolDownloadLocal,
     .wipeVol = virStorageBackendLogicalVolWipe,
 };
+
+
+int
+virStorageBackendLogicalRegister(void)
+{
+    return virStorageBackendRegister(&virStorageBackendLogical);
+}

src/storage/storage_backend_logical.h

@@ -24,8 +24,6 @@
 #ifndef __VIR_STORAGE_BACKEND_LOGICAL_H__
 # define __VIR_STORAGE_BACKEND_LOGICAL_H__
 
-# include "storage_backend.h"
+int virStorageBackendLogicalRegister(void);
-
-extern virStorageBackend virStorageBackendLogical;
 
 #endif /* __VIR_STORAGE_BACKEND_LOGICAL_H__ */

src/storage/storage_backend_mpath.c

@@ -32,6 +32,7 @@
 #include "virerror.h"
 #include "storage_conf.h"
 #include "storage_backend.h"
+#include "storage_backend_mpath.h"
 #include "viralloc.h"
 #include "virlog.h"
 #include "virfile.h"
@@ -278,3 +279,10 @@ virStorageBackend virStorageBackendMpath = {
     .downloadVol = virStorageBackendVolDownloadLocal,
     .wipeVol = virStorageBackendVolWipeLocal,
 };
+
+
+int
+virStorageBackendMpathRegister(void)
+{
+    return virStorageBackendRegister(&virStorageBackendMpath);
+}

src/storage/storage_backend_mpath.h

@@ -24,8 +24,6 @@
 #ifndef __VIR_STORAGE_BACKEND_MPATH_H__
 # define __VIR_STORAGE_BACKEND_MPATH_H__
 
-# include "storage_backend.h"
+int virStorageBackendMpathRegister(void);
-
-extern virStorageBackend virStorageBackendMpath;
 
 #endif /* __VIR_STORAGE_BACKEND_MPATH_H__ */

src/storage/storage_backend_rbd.c

@@ -1294,3 +1294,10 @@ virStorageBackend virStorageBackendRBD = {
     .resizeVol = virStorageBackendRBDResizeVol,
     .wipeVol = virStorageBackendRBDVolWipe
 };
+
+
+int
+virStorageBackendRBDRegister(void)
+{
+    return virStorageBackendRegister(&virStorageBackendRBD);
+}

src/storage/storage_backend_rbd.h

@@ -23,8 +23,6 @@
 #ifndef __VIR_STORAGE_BACKEND_RBD_H__
 # define __VIR_STORAGE_BACKEND_RBD_H__
 
-# include "storage_backend.h"
+int virStorageBackendRBDRegister(void);
-
-extern virStorageBackend virStorageBackendRBD;
 
 #endif /* __VIR_STORAGE_BACKEND_RBD_H__ */

src/storage/storage_backend_scsi.c

@@ -544,3 +544,10 @@ virStorageBackend virStorageBackendSCSI = {
     .downloadVol = virStorageBackendVolDownloadLocal,
     .wipeVol = virStorageBackendVolWipeLocal,
 };
+
+
+int
+virStorageBackendSCSIRegister(void)
+{
+    return virStorageBackendRegister(&virStorageBackendSCSI);
+}

src/storage/storage_backend_scsi.h

@@ -24,8 +24,6 @@
 #ifndef __VIR_STORAGE_BACKEND_SCSI_H__
 # define __VIR_STORAGE_BACKEND_SCSI_H__
 
-# include "storage_backend.h"
+int virStorageBackendSCSIRegister(void);
-
-extern virStorageBackend virStorageBackendSCSI;
 
 #endif /* __VIR_STORAGE_BACKEND_SCSI_H__ */

src/storage/storage_backend_sheepdog.c

@@ -417,3 +417,10 @@ virStorageBackend virStorageBackendSheepdog = {
     .deleteVol = virStorageBackendSheepdogDeleteVol,
     .resizeVol = virStorageBackendSheepdogResizeVol,
 };
+
+
+int
+virStorageBackendSheepdogRegister(void)
+{
+    return virStorageBackendRegister(&virStorageBackendSheepdog);
+}

src/storage/storage_backend_sheepdog.h

@@ -27,8 +27,6 @@
 #ifndef __VIR_STORAGE_BACKEND_SHEEPDOG_H__
 # define __VIR_STORAGE_BACKEND_SHEEPDOG_H__
 
-# include "storage_backend.h"
+int virStorageBackendSheepdogRegister(void);
-
-extern virStorageBackend virStorageBackendSheepdog;
 
 #endif /* __VIR_STORAGE_BACKEND_SHEEPDOG_H__ */

src/storage/storage_backend_vstorage.c

@@ -183,3 +183,10 @@ virStorageBackend virStorageBackendVstorage = {
     .downloadVol = virStorageBackendVolDownloadLocal,
     .wipeVol = virStorageBackendVolWipeLocal,
 };
+
+
+int
+virStorageBackendVstorageRegister(void)
+{
+    return virStorageBackendRegister(&virStorageBackendVstorage);
+}

src/storage/storage_backend_vstorage.h

@@ -21,8 +21,6 @@
 #ifndef __VIR_STORAGE_BACKEND_VSTORAGE_H__
 # define __VIR_STORAGE_BACKEND_VSTORAGE_H__
 
-# include "storage_backend.h"
+int virStorageBackendVstorageRegister(void);
-
-extern virStorageBackend virStorageBackendVstorage;
 
 #endif /* __VIR_STORAGE_BACKEND_VSTORAGE_H__ */

src/storage/storage_backend_zfs.c

@@ -467,3 +467,10 @@ virStorageBackend virStorageBackendZFS = {
     .uploadVol = virStorageBackendVolUploadLocal,
     .downloadVol = virStorageBackendVolDownloadLocal,
 };
+
+
+int
+virStorageBackendZFSRegister(void)
+{
+    return virStorageBackendRegister(&virStorageBackendZFS);
+}

src/storage/storage_backend_zfs.h

@@ -22,8 +22,6 @@
 #ifndef __VIR_STORAGE_BACKEND_ZFS_H__
 # define __VIR_STORAGE_BACKEND_ZFS_H__
 
-# include "storage_backend.h"
+int virStorageBackendZFSRegister(void);
-
-extern virStorageBackend virStorageBackendZFS;
 
 #endif /* __VIR_STORAGE_BACKEND_ZFS_H__ */

src/storage/storage_driver.c

@@ -2840,6 +2840,8 @@ static virStateDriver stateDriver = {
 
 int storageRegister(void)
 {
+    if (virStorageBackendDriversRegister() < 0)
+        return -1;
     if (virSetSharedStorageDriver(&storageDriver) < 0)
         return -1;
     if (virRegisterStateDriver(&stateDriver) < 0)

tests/virstoragetest.c

@@ -32,6 +32,7 @@
 #include "dirname.h"
 
 #include "storage/storage_driver.h"
+#include "storage/storage_backend.h"
 
 #define VIR_FROM_THIS VIR_FROM_NONE
 
@@ -731,6 +732,9 @@ mymain(void)
     virStorageSourcePtr chain2; /* short for chain->backingStore */
     virStorageSourcePtr chain3; /* short for chain2->backingStore */
 
+    if (virStorageBackendDriversRegister() < 0)
+       return -1;
+
     /* Prep some files with qemu-img; if that is not found on PATH, or
      * if it lacks support for qcow2 and qed, skip this test.  */
     if ((ret = testPrepImages()) != 0)