Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/crypto/lz4.c

  1 /*
  2  * Cryptographic API.
  3  *
  4  * Copyright (c) 2013 Chanho Min <chanho.min@lge.com>
  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  * You should have received a copy of the GNU General Public License along with
 16  * this program; if not, write to the Free Software Foundation, Inc., 51
 17  * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 18  *
 19  */
 20 
 21 #include <linux/init.h>
 22 #include <linux/module.h>
 23 #include <linux/crypto.h>
 24 #include <linux/vmalloc.h>
 25 #include <linux/lz4.h>
 26 #include <crypto/internal/scompress.h>
 27 
 28 struct lz4_ctx {
 29         void *lz4_comp_mem;
 30 };
 31 
 32 static void *lz4_alloc_ctx(struct crypto_scomp *tfm)
 33 {
 34         void *ctx;
 35 
 36         ctx = vmalloc(LZ4_MEM_COMPRESS);
 37         if (!ctx)
 38                 return ERR_PTR(-ENOMEM);
 39 
 40         return ctx;
 41 }
 42 
 43 static int lz4_init(struct crypto_tfm *tfm)
 44 {
 45         struct lz4_ctx *ctx = crypto_tfm_ctx(tfm);
 46 
 47         ctx->lz4_comp_mem = lz4_alloc_ctx(NULL);
 48         if (IS_ERR(ctx->lz4_comp_mem))
 49                 return -ENOMEM;
 50 
 51         return 0;
 52 }
 53 
 54 static void lz4_free_ctx(struct crypto_scomp *tfm, void *ctx)
 55 {
 56         vfree(ctx);
 57 }
 58 
 59 static void lz4_exit(struct crypto_tfm *tfm)
 60 {
 61         struct lz4_ctx *ctx = crypto_tfm_ctx(tfm);
 62 
 63         lz4_free_ctx(NULL, ctx->lz4_comp_mem);
 64 }
 65 
 66 static int __lz4_compress_crypto(const u8 *src, unsigned int slen,
 67                                  u8 *dst, unsigned int *dlen, void *ctx)
 68 {
 69         size_t tmp_len = *dlen;
 70         int err;
 71 
 72         err = lz4_compress(src, slen, dst, &tmp_len, ctx);
 73 
 74         if (err < 0)
 75                 return -EINVAL;
 76 
 77         *dlen = tmp_len;
 78         return 0;
 79 }
 80 
 81 static int lz4_scompress(struct crypto_scomp *tfm, const u8 *src,
 82                          unsigned int slen, u8 *dst, unsigned int *dlen,
 83                          void *ctx)
 84 {
 85         return __lz4_compress_crypto(src, slen, dst, dlen, ctx);
 86 }
 87 
 88 static int lz4_compress_crypto(struct crypto_tfm *tfm, const u8 *src,
 89                                unsigned int slen, u8 *dst, unsigned int *dlen)
 90 {
 91         struct lz4_ctx *ctx = crypto_tfm_ctx(tfm);
 92 
 93         return __lz4_compress_crypto(src, slen, dst, dlen, ctx->lz4_comp_mem);
 94 }
 95 
 96 static int __lz4_decompress_crypto(const u8 *src, unsigned int slen,
 97                                    u8 *dst, unsigned int *dlen, void *ctx)
 98 {
 99         int err;
100         size_t tmp_len = *dlen;
101         size_t __slen = slen;
102 
103         err = lz4_decompress_unknownoutputsize(src, __slen, dst, &tmp_len);
104         if (err < 0)
105                 return -EINVAL;
106 
107         *dlen = tmp_len;
108         return err;
109 }
110 
111 static int lz4_sdecompress(struct crypto_scomp *tfm, const u8 *src,
112                            unsigned int slen, u8 *dst, unsigned int *dlen,
113                            void *ctx)
114 {
115         return __lz4_decompress_crypto(src, slen, dst, dlen, NULL);
116 }
117 
118 static int lz4_decompress_crypto(struct crypto_tfm *tfm, const u8 *src,
119                                  unsigned int slen, u8 *dst,
120                                  unsigned int *dlen)
121 {
122         return __lz4_decompress_crypto(src, slen, dst, dlen, NULL);
123 }
124 
125 static struct crypto_alg alg_lz4 = {
126         .cra_name               = "lz4",
127         .cra_flags              = CRYPTO_ALG_TYPE_COMPRESS,
128         .cra_ctxsize            = sizeof(struct lz4_ctx),
129         .cra_module             = THIS_MODULE,
130         .cra_list               = LIST_HEAD_INIT(alg_lz4.cra_list),
131         .cra_init               = lz4_init,
132         .cra_exit               = lz4_exit,
133         .cra_u                  = { .compress = {
134         .coa_compress           = lz4_compress_crypto,
135         .coa_decompress         = lz4_decompress_crypto } }
136 };
137 
138 static struct scomp_alg scomp = {
139         .alloc_ctx              = lz4_alloc_ctx,
140         .free_ctx               = lz4_free_ctx,
141         .compress               = lz4_scompress,
142         .decompress             = lz4_sdecompress,
143         .base                   = {
144                 .cra_name       = "lz4",
145                 .cra_driver_name = "lz4-scomp",
146                 .cra_module      = THIS_MODULE,
147         }
148 };
149 
150 static int __init lz4_mod_init(void)
151 {
152         int ret;
153 
154         ret = crypto_register_alg(&alg_lz4);
155         if (ret)
156                 return ret;
157 
158         ret = crypto_register_scomp(&scomp);
159         if (ret) {
160                 crypto_unregister_alg(&alg_lz4);
161                 return ret;
162         }
163 
164         return ret;
165 }
166 
167 static void __exit lz4_mod_fini(void)
168 {
169         crypto_unregister_alg(&alg_lz4);
170         crypto_unregister_scomp(&scomp);
171 }
172 
173 module_init(lz4_mod_init);
174 module_exit(lz4_mod_fini);
175 
176 MODULE_LICENSE("GPL");
177 MODULE_DESCRIPTION("LZ4 Compression Algorithm");
178 MODULE_ALIAS_CRYPTO("lz4");
179 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us