crypto/zstd.c

   1 /*
   2  * Cryptographic API.
   3  *
   4  * Copyright (c) 2017-present, Facebook, Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published by
   8  * the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  */
  15 #include <linux/crypto.h>
  16 #include <linux/init.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/mm.h>
  19 #include <linux/module.h>
  20 #include <linux/net.h>
  21 #include <linux/vmalloc.h>
  22 #include <linux/zstd.h>
  23 #include <crypto/internal/scompress.h>
  24
  25
  26 #define ZSTD_DEF_LEVEL  3
  27
  28 struct zstd_ctx {
  29         ZSTD_CCtx *cctx;
  30         ZSTD_DCtx *dctx;
  31         void *cwksp;
  32         void *dwksp;
  33 };
  34
  35 static ZSTD_parameters zstd_params(void)
  36 {
  37         return ZSTD_getParams(ZSTD_DEF_LEVEL, 0, 0);
  38 }
  39
  40 static int zstd_comp_init(struct zstd_ctx *ctx)
  41 {
  42         int ret = 0;
  43         const ZSTD_parameters params = zstd_params();
  44         const size_t wksp_size = ZSTD_CCtxWorkspaceBound(params.cParams);
  45
  46         ctx->cwksp = vzalloc(wksp_size);
  47         if (!ctx->cwksp) {
  48                 ret = -ENOMEM;
  49                 goto out;
  50         }
  51
  52         ctx->cctx = ZSTD_initCCtx(ctx->cwksp, wksp_size);
  53         if (!ctx->cctx) {
  54                 ret = -EINVAL;
  55                 goto out_free;
  56         }
  57 out:
  58         return ret;
  59 out_free:
  60         vfree(ctx->cwksp);
  61         goto out;
  62 }
  63
  64 static int zstd_decomp_init(struct zstd_ctx *ctx)
  65 {
  66         int ret = 0;
  67         const size_t wksp_size = ZSTD_DCtxWorkspaceBound();
  68
  69         ctx->dwksp = vzalloc(wksp_size);
  70         if (!ctx->dwksp) {
  71                 ret = -ENOMEM;
  72                 goto out;
  73         }
  74
  75         ctx->dctx = ZSTD_initDCtx(ctx->dwksp, wksp_size);
  76         if (!ctx->dctx) {
  77                 ret = -EINVAL;
  78                 goto out_free;
  79         }
  80 out:
  81         return ret;
  82 out_free:
  83         vfree(ctx->dwksp);
  84         goto out;
  85 }
  86
  87 static void zstd_comp_exit(struct zstd_ctx *ctx)
  88 {
  89         vfree(ctx->cwksp);
  90         ctx->cwksp = NULL;
  91         ctx->cctx = NULL;
  92 }
  93
  94 static void zstd_decomp_exit(struct zstd_ctx *ctx)
  95 {
  96         vfree(ctx->dwksp);
  97         ctx->dwksp = NULL;
  98         ctx->dctx = NULL;
  99 }
 100
 101 static int __zstd_init(void *ctx)
 102 {
 103         int ret;
 104
 105         ret = zstd_comp_init(ctx);
 106         if (ret)
 107                 return ret;
 108         ret = zstd_decomp_init(ctx);
 109         if (ret)
 110                 zstd_comp_exit(ctx);
 111         return ret;
 112 }
 113
 114 static void *zstd_alloc_ctx(struct crypto_scomp *tfm)
 115 {
 116         int ret;
 117         struct zstd_ctx *ctx;
 118
 119         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
 120         if (!ctx)
 121                 return ERR_PTR(-ENOMEM);
 122
 123         ret = __zstd_init(ctx);
 124         if (ret) {
 125                 kfree(ctx);
 126                 return ERR_PTR(ret);
 127         }
 128
 129         return ctx;
 130 }
 131
 132 static int zstd_init(struct crypto_tfm *tfm)
 133 {
 134         struct zstd_ctx *ctx = crypto_tfm_ctx(tfm);
 135
 136         return __zstd_init(ctx);
 137 }
 138
 139 static void __zstd_exit(void *ctx)
 140 {
 141         zstd_comp_exit(ctx);
 142         zstd_decomp_exit(ctx);
 143 }
 144
 145 static void zstd_free_ctx(struct crypto_scomp *tfm, void *ctx)
 146 {
 147         __zstd_exit(ctx);
 148         kzfree(ctx);
 149 }
 150
 151 static void zstd_exit(struct crypto_tfm *tfm)
 152 {
 153         struct zstd_ctx *ctx = crypto_tfm_ctx(tfm);
 154
 155         __zstd_exit(ctx);
 156 }
 157
 158 static int __zstd_compress(const u8 *src, unsigned int slen,
 159                            u8 *dst, unsigned int *dlen, void *ctx)
 160 {
 161         size_t out_len;
 162         struct zstd_ctx *zctx = ctx;
 163         const ZSTD_parameters params = zstd_params();
 164
 165         out_len = ZSTD_compressCCtx(zctx->cctx, dst, *dlen, src, slen, params);
 166         if (ZSTD_isError(out_len))
 167                 return -EINVAL;
 168         *dlen = out_len;
 169         return 0;
 170 }
 171
 172 static int zstd_compress(struct crypto_tfm *tfm, const u8 *src,
 173                          unsigned int slen, u8 *dst, unsigned int *dlen)
 174 {
 175         struct zstd_ctx *ctx = crypto_tfm_ctx(tfm);
 176
 177         return __zstd_compress(src, slen, dst, dlen, ctx);
 178 }
 179
 180 static int zstd_scompress(struct crypto_scomp *tfm, const u8 *src,
 181                           unsigned int slen, u8 *dst, unsigned int *dlen,
 182                           void *ctx)
 183 {
 184         return __zstd_compress(src, slen, dst, dlen, ctx);
 185 }
 186
 187 static int __zstd_decompress(const u8 *src, unsigned int slen,
 188                              u8 *dst, unsigned int *dlen, void *ctx)
 189 {
 190         size_t out_len;
 191         struct zstd_ctx *zctx = ctx;
 192
 193         out_len = ZSTD_decompressDCtx(zctx->dctx, dst, *dlen, src, slen);
 194         if (ZSTD_isError(out_len))
 195                 return -EINVAL;
 196         *dlen = out_len;
 197         return 0;
 198 }
 199
 200 static int zstd_decompress(struct crypto_tfm *tfm, const u8 *src,
 201                            unsigned int slen, u8 *dst, unsigned int *dlen)
 202 {
 203         struct zstd_ctx *ctx = crypto_tfm_ctx(tfm);
 204
 205         return __zstd_decompress(src, slen, dst, dlen, ctx);
 206 }
 207
 208 static int zstd_sdecompress(struct crypto_scomp *tfm, const u8 *src,
 209                             unsigned int slen, u8 *dst, unsigned int *dlen,
 210                             void *ctx)
 211 {
 212         return __zstd_decompress(src, slen, dst, dlen, ctx);
 213 }
 214
 215 static struct crypto_alg alg = {
 216         .cra_name               = "zstd",
 217         .cra_flags              = CRYPTO_ALG_TYPE_COMPRESS,
 218         .cra_ctxsize            = sizeof(struct zstd_ctx),
 219         .cra_module             = THIS_MODULE,
 220         .cra_init               = zstd_init,
 221         .cra_exit               = zstd_exit,
 222         .cra_u                  = { .compress = {
 223         .coa_compress           = zstd_compress,
 224         .coa_decompress         = zstd_decompress } }
 225 };
 226
 227 static struct scomp_alg scomp = {
 228         .alloc_ctx              = zstd_alloc_ctx,
 229         .free_ctx               = zstd_free_ctx,
 230         .compress               = zstd_scompress,
 231         .decompress             = zstd_sdecompress,
 232         .base                   = {
 233                 .cra_name       = "zstd",
 234                 .cra_driver_name = "zstd-scomp",
 235                 .cra_module      = THIS_MODULE,
 236         }
 237 };
 238
 239 static int __init zstd_mod_init(void)
 240 {
 241         int ret;
 242
 243         ret = crypto_register_alg(&alg);
 244         if (ret)
 245                 return ret;
 246
 247         ret = crypto_register_scomp(&scomp);
 248         if (ret)
 249                 crypto_unregister_alg(&alg);
 250
 251         return ret;
 252 }
 253
 254 static void __exit zstd_mod_fini(void)
 255 {
 256         crypto_unregister_alg(&alg);
 257         crypto_unregister_scomp(&scomp);
 258 }
 259
 260 module_init(zstd_mod_init);
 261 module_exit(zstd_mod_fini);
 262
 263 MODULE_LICENSE("GPL");
 264 MODULE_DESCRIPTION("Zstd Compression Algorithm");
 265 MODULE_ALIAS_CRYPTO("zstd");