These changes are the raw update to linux-4.4.6-rt14. Kernel sources

[kvmfornfv.git] / kernel / mm / zpool.c

diff --git a/kernel/mm/zpool.c b/kernel/mm/zpool.c
index bacdab6..fd3ff71 100644 (file)
--- a/kernel/mm/zpool.c
+++ b/kernel/mm/zpool.c
@@ -18,11 +18,9 @@
 #include <linux/zpool.h>
 
 struct zpool {
-       char *type;
-
        struct zpool_driver *driver;
        void *pool;
-       struct zpool_ops *ops;
+       const struct zpool_ops *ops;
 
        struct list_head list;
 };
@@ -73,34 +71,8 @@ int zpool_unregister_driver(struct zpool_driver *driver)
 }
 EXPORT_SYMBOL(zpool_unregister_driver);
 
-/**
- * zpool_evict() - evict callback from a zpool implementation.
- * @pool:      pool to evict from.
- * @handle:    handle to evict.
- *
- * This can be used by zpool implementations to call the
- * user's evict zpool_ops struct evict callback.
- */
-int zpool_evict(void *pool, unsigned long handle)
-{
-       struct zpool *zpool;
-
-       spin_lock(&pools_lock);
-       list_for_each_entry(zpool, &pools_head, list) {
-               if (zpool->pool == pool) {
-                       spin_unlock(&pools_lock);
-                       if (!zpool->ops || !zpool->ops->evict)
-                               return -EINVAL;
-                       return zpool->ops->evict(zpool, handle);
-               }
-       }
-       spin_unlock(&pools_lock);
-
-       return -ENOENT;
-}
-EXPORT_SYMBOL(zpool_evict);
-
-static struct zpool_driver *zpool_get_driver(char *type)
+/* this assumes @type is null-terminated. */
+static struct zpool_driver *zpool_get_driver(const char *type)
 {
        struct zpool_driver *driver;
 
@@ -126,6 +98,41 @@ static void zpool_put_driver(struct zpool_driver *driver)
        module_put(driver->owner);
 }
 
+/**
+ * zpool_has_pool() - Check if the pool driver is available
+ * @type       The type of the zpool to check (e.g. zbud, zsmalloc)
+ *
+ * This checks if the @type pool driver is available.  This will try to load
+ * the requested module, if needed, but there is no guarantee the module will
+ * still be loaded and available immediately after calling.  If this returns
+ * true, the caller should assume the pool is available, but must be prepared
+ * to handle the @zpool_create_pool() returning failure.  However if this
+ * returns false, the caller should assume the requested pool type is not
+ * available; either the requested pool type module does not exist, or could
+ * not be loaded, and calling @zpool_create_pool() with the pool type will
+ * fail.
+ *
+ * The @type string must be null-terminated.
+ *
+ * Returns: true if @type pool is available, false if not
+ */
+bool zpool_has_pool(char *type)
+{
+       struct zpool_driver *driver = zpool_get_driver(type);
+
+       if (!driver) {
+               request_module("zpool-%s", type);
+               driver = zpool_get_driver(type);
+       }
+
+       if (!driver)
+               return false;
+
+       zpool_put_driver(driver);
+       return true;
+}
+EXPORT_SYMBOL(zpool_has_pool);
+
 /**
  * zpool_create_pool() - Create a new zpool
  * @type       The type of the zpool to create (e.g. zbud, zsmalloc)
@@ -139,15 +146,17 @@ static void zpool_put_driver(struct zpool_driver *driver)
  *
  * Implementations must guarantee this to be thread-safe.
  *
+ * The @type and @name strings must be null-terminated.
+ *
  * Returns: New zpool on success, NULL on failure.
  */
-struct zpool *zpool_create_pool(char *type, char *name, gfp_t gfp,
-               struct zpool_ops *ops)
+struct zpool *zpool_create_pool(const char *type, const char *name, gfp_t gfp,
+               const struct zpool_ops *ops)
 {
        struct zpool_driver *driver;
        struct zpool *zpool;
 
-       pr_info("creating pool type %s\n", type);
+       pr_debug("creating pool type %s\n", type);
 
        driver = zpool_get_driver(type);
 
@@ -168,9 +177,8 @@ struct zpool *zpool_create_pool(char *type, char *name, gfp_t gfp,
                return NULL;
        }
 
-       zpool->type = driver->type;
        zpool->driver = driver;
-       zpool->pool = driver->create(name, gfp, ops);
+       zpool->pool = driver->create(name, gfp, ops, zpool);
        zpool->ops = ops;
 
        if (!zpool->pool) {
@@ -180,7 +188,7 @@ struct zpool *zpool_create_pool(char *type, char *name, gfp_t gfp,
                return NULL;
        }
 
-       pr_info("created %s pool\n", type);
+       pr_debug("created pool type %s\n", type);
 
        spin_lock(&pools_lock);
        list_add(&zpool->list, &pools_head);
@@ -202,7 +210,7 @@ struct zpool *zpool_create_pool(char *type, char *name, gfp_t gfp,
  */
 void zpool_destroy_pool(struct zpool *zpool)
 {
-       pr_info("destroying pool type %s\n", zpool->type);
+       pr_debug("destroying pool type %s\n", zpool->driver->type);
 
        spin_lock(&pools_lock);
        list_del(&zpool->list);
@@ -222,9 +230,9 @@ void zpool_destroy_pool(struct zpool *zpool)
  *
  * Returns: The type of zpool.
  */
-char *zpool_get_type(struct zpool *zpool)
+const char *zpool_get_type(struct zpool *zpool)
 {
-       return zpool->type;
+       return zpool->driver->type;
 }
 
 /**
@@ -347,20 +355,6 @@ u64 zpool_get_total_size(struct zpool *zpool)
        return zpool->driver->total_size(zpool->pool);
 }
 
-static int __init init_zpool(void)
-{
-       pr_info("loaded\n");
-       return 0;
-}
-
-static void __exit exit_zpool(void)
-{
-       pr_info("unloaded\n");
-}
-
-module_init(init_zpool);
-module_exit(exit_zpool);
-
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Dan Streetman <ddstreet@ieee.org>");
 MODULE_DESCRIPTION("Common API for compressed memory storage");