drivers/block/zram/zcomp.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 #include <linux/kernel.h>
   4 #include <linux/string.h>
   5 #include <linux/err.h>
   6 #include <linux/slab.h>
   7 #include <linux/wait.h>
   8 #include <linux/sched.h>
   9 #include <linux/cpu.h>
  10 #include <linux/crypto.h>
  11 #include <linux/vmalloc.h>
  12
  13 #include "zcomp.h"
  14
  15 #include "backend_lzo.h"
  16 #include "backend_lzorle.h"
  17 #include "backend_lz4.h"
  18 #include "backend_lz4hc.h"
  19 #include "backend_zstd.h"
  20 #include "backend_deflate.h"
  21 #include "backend_842.h"
  22
  23 static const struct zcomp_ops *backends[] = {
  24 #if IS_ENABLED(CONFIG_ZRAM_BACKEND_LZO)
  25         &backend_lzorle,
  26         &backend_lzo,
  27 #endif
  28 #if IS_ENABLED(CONFIG_ZRAM_BACKEND_LZ4)
  29         &backend_lz4,
  30 #endif
  31 #if IS_ENABLED(CONFIG_ZRAM_BACKEND_LZ4HC)
  32         &backend_lz4hc,
  33 #endif
  34 #if IS_ENABLED(CONFIG_ZRAM_BACKEND_ZSTD)
  35         &backend_zstd,
  36 #endif
  37 #if IS_ENABLED(CONFIG_ZRAM_BACKEND_DEFLATE)
  38         &backend_deflate,
  39 #endif
  40 #if IS_ENABLED(CONFIG_ZRAM_BACKEND_842)
  41         &backend_842,
  42 #endif
  43         NULL
  44 };
  45
  46 static void zcomp_strm_free(struct zcomp *comp, struct zcomp_strm *zstrm)
  47 {
  48         comp->ops->destroy_ctx(&zstrm->ctx);
  49         vfree(zstrm->buffer);
  50         zstrm->buffer = NULL;
  51 }
  52
  53 static int zcomp_strm_init(struct zcomp *comp, struct zcomp_strm *zstrm)
  54 {
  55         int ret;
  56
  57         ret = comp->ops->create_ctx(comp->params, &zstrm->ctx);
  58         if (ret)
  59                 return ret;
  60
  61         /*
  62          * allocate 2 pages. 1 for compressed data, plus 1 extra for the
  63          * case when compressed size is larger than the original one
  64          */
  65         zstrm->buffer = vzalloc(2 * PAGE_SIZE);
  66         if (!zstrm->buffer) {
  67                 zcomp_strm_free(comp, zstrm);
  68                 return -ENOMEM;
  69         }
  70         return 0;
  71 }
  72
  73 static const struct zcomp_ops *lookup_backend_ops(const char *comp)
  74 {
  75         int i = 0;
  76
  77         while (backends[i]) {
  78                 if (sysfs_streq(comp, backends[i]->name))
  79                         break;
  80                 i++;
  81         }
  82         return backends[i];
  83 }
  84
  85 bool zcomp_available_algorithm(const char *comp)
  86 {
  87         return lookup_backend_ops(comp) != NULL;
  88 }
  89
  90 /* show available compressors */
  91 ssize_t zcomp_available_show(const char *comp, char *buf)
  92 {
  93         ssize_t sz = 0;
  94         int i;
  95
  96         for (i = 0; i < ARRAY_SIZE(backends) - 1; i++) {
  97                 if (!strcmp(comp, backends[i]->name)) {
  98                         sz += scnprintf(buf + sz, PAGE_SIZE - sz - 2,
  99                                         "[%s] ", backends[i]->name);
 100                 } else {
 101                         sz += scnprintf(buf + sz, PAGE_SIZE - sz - 2,
 102                                         "%s ", backends[i]->name);
 103                 }
 104         }
 105
 106         sz += scnprintf(buf + sz, PAGE_SIZE - sz, "\n");
 107         return sz;
 108 }
 109
 110 struct zcomp_strm *zcomp_stream_get(struct zcomp *comp)
 111 {
 112         local_lock(&comp->stream->lock);
 113         return this_cpu_ptr(comp->stream);
 114 }
 115
 116 void zcomp_stream_put(struct zcomp *comp)
 117 {
 118         local_unlock(&comp->stream->lock);
 119 }
 120
 121 int zcomp_compress(struct zcomp *comp, struct zcomp_strm *zstrm,
 122                    const void *src, unsigned int *dst_len)
 123 {
 124         struct zcomp_req req = {
 125                 .src = src,
 126                 .dst = zstrm->buffer,
 127                 .src_len = PAGE_SIZE,
 128                 .dst_len = 2 * PAGE_SIZE,
 129         };
 130         int ret;
 131
 132         ret = comp->ops->compress(comp->params, &zstrm->ctx, &req);
 133         if (!ret)
 134                 *dst_len = req.dst_len;
 135         return ret;
 136 }
 137
 138 int zcomp_decompress(struct zcomp *comp, struct zcomp_strm *zstrm,
 139                      const void *src, unsigned int src_len, void *dst)
 140 {
 141         struct zcomp_req req = {
 142                 .src = src,
 143                 .dst = dst,
 144                 .src_len = src_len,
 145                 .dst_len = PAGE_SIZE,
 146         };
 147
 148         return comp->ops->decompress(comp->params, &zstrm->ctx, &req);
 149 }
 150
 151 int zcomp_cpu_up_prepare(unsigned int cpu, struct hlist_node *node)
 152 {
 153         struct zcomp *comp = hlist_entry(node, struct zcomp, node);
 154         struct zcomp_strm *zstrm;
 155         int ret;
 156
 157         zstrm = per_cpu_ptr(comp->stream, cpu);
 158         local_lock_init(&zstrm->lock);
 159
 160         ret = zcomp_strm_init(comp, zstrm);
 161         if (ret)
 162                 pr_err("Can't allocate a compression stream\n");
 163         return ret;
 164 }
 165
 166 int zcomp_cpu_dead(unsigned int cpu, struct hlist_node *node)
 167 {
 168         struct zcomp *comp = hlist_entry(node, struct zcomp, node);
 169         struct zcomp_strm *zstrm;
 170
 171         zstrm = per_cpu_ptr(comp->stream, cpu);
 172         zcomp_strm_free(comp, zstrm);
 173         return 0;
 174 }
 175
 176 static int zcomp_init(struct zcomp *comp, struct zcomp_params *params)
 177 {
 178         int ret;
 179
 180         comp->stream = alloc_percpu(struct zcomp_strm);
 181         if (!comp->stream)
 182                 return -ENOMEM;
 183
 184         comp->params = params;
 185         ret = comp->ops->setup_params(comp->params);
 186         if (ret)
 187                 goto cleanup;
 188
 189         ret = cpuhp_state_add_instance(CPUHP_ZCOMP_PREPARE, &comp->node);
 190         if (ret < 0)
 191                 goto cleanup;
 192
 193         return 0;
 194
 195 cleanup:
 196         comp->ops->release_params(comp->params);
 197         free_percpu(comp->stream);
 198         return ret;
 199 }
 200
 201 void zcomp_destroy(struct zcomp *comp)
 202 {
 203         cpuhp_state_remove_instance(CPUHP_ZCOMP_PREPARE, &comp->node);
 204         comp->ops->release_params(comp->params);
 205         free_percpu(comp->stream);
 206         kfree(comp);
 207 }
 208
 209 struct zcomp *zcomp_create(const char *alg, struct zcomp_params *params)
 210 {
 211         struct zcomp *comp;
 212         int error;
 213
 214         /*
 215          * The backends array has a sentinel NULL value, so the minimum
 216          * size is 1. In order to be valid the array, apart from the
 217          * sentinel NULL element, should have at least one compression
 218          * backend selected.
 219          */
 220         BUILD_BUG_ON(ARRAY_SIZE(backends) <= 1);
 221
 222         comp = kzalloc(sizeof(struct zcomp), GFP_KERNEL);
 223         if (!comp)
 224                 return ERR_PTR(-ENOMEM);
 225
 226         comp->ops = lookup_backend_ops(alg);
 227         if (!comp->ops) {
 228                 kfree(comp);
 229                 return ERR_PTR(-EINVAL);
 230         }
 231
 232         error = zcomp_init(comp, params);
 233         if (error) {
 234                 kfree(comp);
 235                 return ERR_PTR(error);
 236         }
 237         return comp;
 238 }