zswap: use charp for zswap param strings

Instead of using a fixed-length string for the zswap params, use charp.
This simplifies the code and uses less memory, as most zswap param strings
will be less than the current maximum length.

Signed-off-by: Dan Streetman <ddstreet@ieee.org>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: Seth Jennings <sjennings@variantweb.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/mm/zswap.c b/mm/zswap.c
index 827568959d74ecf314cf8739c8406bddb5a73073..025f8dc723dedf60da7d2d9d580ac208e75cd8f6 100644 (file)
--- a/mm/zswap.c
+++ b/mm/zswap.c
@@ -82,33 +82,27 @@ module_param_named(enabled, zswap_enabled, bool, 0644);
 
 /* Crypto compressor to use */
 #define ZSWAP_COMPRESSOR_DEFAULT "lzo"
-static char zswap_compressor[CRYPTO_MAX_ALG_NAME] = ZSWAP_COMPRESSOR_DEFAULT;
-static struct kparam_string zswap_compressor_kparam = {
-       .string =       zswap_compressor,
-       .maxlen =       sizeof(zswap_compressor),
-};
+static char *zswap_compressor = ZSWAP_COMPRESSOR_DEFAULT;
 static int zswap_compressor_param_set(const char *,
                                      const struct kernel_param *);
 static struct kernel_param_ops zswap_compressor_param_ops = {
        .set =          zswap_compressor_param_set,
-       .get =          param_get_string,
+       .get =          param_get_charp,
+       .free =         param_free_charp,
 };
 module_param_cb(compressor, &zswap_compressor_param_ops,
-               &zswap_compressor_kparam, 0644);
+               &zswap_compressor, 0644);
 
 /* Compressed storage zpool to use */
 #define ZSWAP_ZPOOL_DEFAULT "zbud"
-static char zswap_zpool_type[32 /* arbitrary */] = ZSWAP_ZPOOL_DEFAULT;
-static struct kparam_string zswap_zpool_kparam = {
-       .string =       zswap_zpool_type,
-       .maxlen =       sizeof(zswap_zpool_type),
-};
+static char *zswap_zpool_type = ZSWAP_ZPOOL_DEFAULT;
 static int zswap_zpool_param_set(const char *, const struct kernel_param *);
 static struct kernel_param_ops zswap_zpool_param_ops = {
-       .set =  zswap_zpool_param_set,
-       .get =  param_get_string,
+       .set =          zswap_zpool_param_set,
+       .get =          param_get_charp,
+       .free =         param_free_charp,
 };
-module_param_cb(zpool, &zswap_zpool_param_ops, &zswap_zpool_kparam, 0644);
+module_param_cb(zpool, &zswap_zpool_param_ops, &zswap_zpool_type, 0644);
 
 /* The maximum percentage of memory that the compressed pool can occupy */
 static unsigned int zswap_max_pool_percent = 20;
@@ -615,19 +609,29 @@ error:
        return NULL;
 }
 
-static struct zswap_pool *__zswap_pool_create_fallback(void)
+static __init struct zswap_pool *__zswap_pool_create_fallback(void)
 {
        if (!crypto_has_comp(zswap_compressor, 0, 0)) {
+               if (!strcmp(zswap_compressor, ZSWAP_COMPRESSOR_DEFAULT)) {
+                       pr_err("default compressor %s not available\n",
+                              zswap_compressor);
+                       return NULL;
+               }
                pr_err("compressor %s not available, using default %s\n",
                       zswap_compressor, ZSWAP_COMPRESSOR_DEFAULT);
-               strncpy(zswap_compressor, ZSWAP_COMPRESSOR_DEFAULT,
-                       sizeof(zswap_compressor));
+               param_free_charp(&zswap_compressor);
+               zswap_compressor = ZSWAP_COMPRESSOR_DEFAULT;
        }
        if (!zpool_has_pool(zswap_zpool_type)) {
+               if (!strcmp(zswap_zpool_type, ZSWAP_ZPOOL_DEFAULT)) {
+                       pr_err("default zpool %s not available\n",
+                              zswap_zpool_type);
+                       return NULL;
+               }
                pr_err("zpool %s not available, using default %s\n",
                       zswap_zpool_type, ZSWAP_ZPOOL_DEFAULT);
-               strncpy(zswap_zpool_type, ZSWAP_ZPOOL_DEFAULT,
-                       sizeof(zswap_zpool_type));
+               param_free_charp(&zswap_zpool_type);
+               zswap_zpool_type = ZSWAP_ZPOOL_DEFAULT;
        }
 
        return zswap_pool_create(zswap_zpool_type, zswap_compressor);
@@ -684,43 +688,39 @@ static void zswap_pool_put(struct zswap_pool *pool)
 * param callbacks
 **********************************/
 
+/* val must be a null-terminated string */
 static int __zswap_param_set(const char *val, const struct kernel_param *kp,
                             char *type, char *compressor)
 {
        struct zswap_pool *pool, *put_pool = NULL;
-       char str[kp->str->maxlen], *s;
+       char *s = strstrip((char *)val);
        int ret;
 
-       /*
-        * kp is either zswap_zpool_kparam or zswap_compressor_kparam, defined
-        * at the top of this file, so maxlen is CRYPTO_MAX_ALG_NAME (64) or
-        * 32 (arbitrary).
-        */
-       strlcpy(str, val, kp->str->maxlen);
-       s = strim(str);
+       /* no change required */
+       if (!strcmp(s, *(char **)kp->arg))
+               return 0;
 
        /* if this is load-time (pre-init) param setting,
         * don't create a pool; that's done during init.
         */
        if (!zswap_init_started)
-               return param_set_copystring(s, kp);
-
-       /* no change required */
-       if (!strncmp(kp->str->string, s, kp->str->maxlen))
-               return 0;
+               return param_set_charp(s, kp);
 
        if (!type) {
-               type = s;
-               if (!zpool_has_pool(type)) {
-                       pr_err("zpool %s not available\n", type);
+               if (!zpool_has_pool(s)) {
+                       pr_err("zpool %s not available\n", s);
                        return -ENOENT;
                }
+               type = s;
        } else if (!compressor) {
-               compressor = s;
-               if (!crypto_has_comp(compressor, 0, 0)) {
-                       pr_err("compressor %s not available\n", compressor);
+               if (!crypto_has_comp(s, 0, 0)) {
+                       pr_err("compressor %s not available\n", s);
                        return -ENOENT;
                }
+               compressor = s;
+       } else {
+               WARN_ON(1);
+               return -EINVAL;
        }
 
        spin_lock(&zswap_pools_lock);
@@ -736,7 +736,7 @@ static int __zswap_param_set(const char *val, const struct kernel_param *kp,
        }
 
        if (pool)
-               ret = param_set_copystring(s, kp);
+               ret = param_set_charp(s, kp);
        else
                ret = -EINVAL;