zram: unify and harden algo/priority params handling

We have two functions that accept algo= and priority= params -
algorithm_params_store() and recompress_store().  This patch unifies and
hardens handling of those parameters.

There are 4 possible cases:

- only priority= provided [recommended]
  We need to verify that provided priority value is
  within permitted range for each particular function.

- both algo= and priority= provided
  We cannot prioritize one over another.  All we should
  do is to verify that zram is configured in the way
  that user-space expects it to be.  Namely that zram
  indeed has compressor algo= setup at given priority=.

- only algo= provided [not recommended]
  We should lookup priority in compressors list.

- none provided [not recommended]
  Just use function's defaults.

Link: https://lkml.kernel.org/r/20260311084312.1766036-7-senozhatsky@chromium.org
Signed-off-by: Sergey Senozhatsky <senozhatsky@chromium.org>
Suggested-by: Minchan Kim <minchan@kernel.org>
Cc: Brian Geffon <bgeffon@google.com>
Cc: gao xu <gaoxu2@honor.com>
Cc: Jens Axboe <axboe@kernel.dk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c
index 48fb6e52de42fa69a43734b28e610e15f7d2bad0..bab21b44bdcb94d664dfe3a2a8e8fc0f6583ff1f 100644 (file)
--- a/drivers/block/zram/zram_drv.c
+++ b/drivers/block/zram/zram_drv.c
@@ -1619,6 +1619,37 @@ static void zram_debugfs_register(struct zram *zram) {};
 static void zram_debugfs_unregister(struct zram *zram) {};
 #endif
 
+/* Only algo parameter given, lookup by algo name */
+static int lookup_algo_priority(struct zram *zram, const char *algo,
+                               u32 min_prio)
+{
+       s32 prio;
+
+       for (prio = min_prio; prio < ZRAM_MAX_COMPS; prio++) {
+               if (!zram->comp_algs[prio])
+                       continue;
+
+               if (!strcmp(zram->comp_algs[prio], algo))
+                       return prio;
+       }
+
+       return -EINVAL;
+}
+
+/* Both algo and priority parameters given, validate them */
+static int validate_algo_priority(struct zram *zram, const char *algo, u32 prio)
+{
+       if (prio >= ZRAM_MAX_COMPS)
+               return -EINVAL;
+       /* No algo at given priority */
+       if (!zram->comp_algs[prio])
+               return -EINVAL;
+       /* A different algo at given priority */
+       if (strcmp(zram->comp_algs[prio], algo))
+               return -EINVAL;
+       return 0;
+}
+
 static void comp_algorithm_set(struct zram *zram, u32 prio, const char *alg)
 {
        zram->comp_algs[prio] = alg;
@@ -1691,6 +1722,7 @@ static ssize_t algorithm_params_store(struct device *dev,
        char *args, *param, *val, *algo = NULL, *dict_path = NULL;
        struct deflate_params deflate_params;
        struct zram *zram = dev_to_zram(dev);
+       bool prio_param = false;
        int ret;
 
        deflate_params.winbits = ZCOMP_PARAM_NOT_SET;
@@ -1703,6 +1735,7 @@ static ssize_t algorithm_params_store(struct device *dev,
                        return -EINVAL;
 
                if (!strcmp(param, "priority")) {
+                       prio_param = true;
                        ret = kstrtoint(val, 10, &prio);
                        if (ret)
                                return ret;
@@ -1738,24 +1771,22 @@ static ssize_t algorithm_params_store(struct device *dev,
        if (init_done(zram))
                return -EBUSY;
 
-       /* Lookup priority by algorithm name */
-       if (algo) {
-               s32 p;
-
-               prio = -EINVAL;
-               for (p = ZRAM_PRIMARY_COMP; p < ZRAM_MAX_COMPS; p++) {
-                       if (!zram->comp_algs[p])
-                               continue;
+       if (prio_param) {
+               if (prio < ZRAM_PRIMARY_COMP || prio >= ZRAM_MAX_COMPS)
+                       return -EINVAL;
+       }
 
-                       if (!strcmp(zram->comp_algs[p], algo)) {
-                               prio = p;
-                               break;
-                       }
-               }
+       if (algo && prio_param) {
+               ret = validate_algo_priority(zram, algo, prio);
+               if (ret)
+                       return ret;
        }
 
-       if (prio < ZRAM_PRIMARY_COMP || prio >= ZRAM_MAX_COMPS)
-               return -EINVAL;
+       if (algo && !prio_param) {
+               prio = lookup_algo_priority(zram, algo, ZRAM_PRIMARY_COMP);
+               if (prio < 0)
+                       return -EINVAL;
+       }
 
        ret = comp_params_store(zram, prio, level, dict_path, &deflate_params);
        return ret ? ret : len;
@@ -2396,9 +2427,6 @@ static int recompress_slot(struct zram *zram, u32 index, struct page *page,
        void *src;
        int ret = 0;
 
-       if (!zram->comps[prio])
-               return -EINVAL;
-
        handle_old = get_slot_handle(zram, index);
        if (!handle_old)
                return -EINVAL;
@@ -2500,10 +2528,11 @@ static ssize_t recompress_store(struct device *dev,
        char *args, *param, *val, *algo = NULL;
        u64 num_recomp_pages = ULLONG_MAX;
        struct zram_pp_ctl *ctl = NULL;
-       u32 prio = ZRAM_SECONDARY_COMP;
-       struct zram_pp_slot *pps;
+       s32 prio = ZRAM_SECONDARY_COMP;
        u32 mode = 0, threshold = 0;
+       struct zram_pp_slot *pps;
        struct page *page = NULL;
+       bool prio_param = false;
        ssize_t ret;
 
        args = skip_spaces(buf);
@@ -2551,7 +2580,8 @@ static ssize_t recompress_store(struct device *dev,
                }
 
                if (!strcmp(param, "priority")) {
-                       ret = kstrtouint(val, 10, &prio);
+                       prio_param = true;
+                       ret = kstrtoint(val, 10, &prio);
                        if (ret)
                                return ret;
                        continue;
@@ -2565,30 +2595,26 @@ static ssize_t recompress_store(struct device *dev,
        if (!init_done(zram))
                return -EINVAL;
 
-       if (algo) {
-               bool found = false;
-
-               for (; prio < ZRAM_MAX_COMPS; prio++) {
-                       if (!zram->comp_algs[prio])
-                               continue;
-
-                       if (!strcmp(zram->comp_algs[prio], algo)) {
-                               found = true;
-                               break;
-                       }
-               }
+       if (prio_param) {
+               if (prio < ZRAM_SECONDARY_COMP || prio >= ZRAM_MAX_COMPS)
+                       return -EINVAL;
+       }
 
-               if (!found) {
-                       ret = -EINVAL;
-                       goto out;
-               }
+       if (algo && prio_param) {
+               ret = validate_algo_priority(zram, algo, prio);
+               if (ret)
+                       return ret;
        }
 
-       if (prio < ZRAM_SECONDARY_COMP || prio >= ZRAM_MAX_COMPS) {
-               ret = -EINVAL;
-               goto out;
+       if (algo && !prio_param) {
+               prio = lookup_algo_priority(zram, algo, ZRAM_SECONDARY_COMP);
+               if (prio < 0)
+                       return -EINVAL;
        }
 
+       if (!zram->comps[prio])
+               return -EINVAL;
+
        page = alloc_page(GFP_KERNEL);
        if (!page) {
                ret = -ENOMEM;