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/lzo.c

  1 /*
  2  * Cryptographic API.
  3  *
  4  * This program is free software; you can redistribute it and/or modify it
  5  * under the terms of the GNU General Public License version 2 as published by
  6  * the Free Software Foundation.
  7  *
  8  * This program is distributed in the hope that it will be useful, but WITHOUT
  9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 11  * more details.
 12  *
 13  * You should have received a copy of the GNU General Public License along with
 14  * this program; if not, write to the Free Software Foundation, Inc., 51
 15  * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 16  *
 17  */
 18 
 19 #include <linux/init.h>
 20 #include <linux/module.h>
 21 #include <linux/crypto.h>
 22 #include <linux/vmalloc.h>
 23 #include <linux/mm.h>
 24 #include <linux/lzo.h>
 25 #include <crypto/internal/scompress.h>
 26 
 27 struct lzo_ctx {
 28         void *lzo_comp_mem;
 29 };
 30 
 31 static void *lzo_alloc_ctx(struct crypto_scomp *tfm)
 32 {
 33         void *ctx;
 34 
 35         ctx = kmalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL | __GFP_NOWARN);
 36         if (!ctx)
 37                 ctx = vmalloc(LZO1X_MEM_COMPRESS);
 38         if (!ctx)
 39                 return ERR_PTR(-ENOMEM);
 40 
 41         return ctx;
 42 }
 43 
 44 static int lzo_init(struct crypto_tfm *tfm)
 45 {
 46         struct lzo_ctx *ctx = crypto_tfm_ctx(tfm);
 47 
 48         ctx->lzo_comp_mem = lzo_alloc_ctx(NULL);
 49         if (IS_ERR(ctx->lzo_comp_mem))
 50                 return -ENOMEM;
 51 
 52         return 0;
 53 }
 54 
 55 static void lzo_free_ctx(struct crypto_scomp *tfm, void *ctx)
 56 {
 57         kvfree(ctx);
 58 }
 59 
 60 static void lzo_exit(struct crypto_tfm *tfm)
 61 {
 62         struct lzo_ctx *ctx = crypto_tfm_ctx(tfm);
 63 
 64         lzo_free_ctx(NULL, ctx->lzo_comp_mem);
 65 }
 66 
 67 static int __lzo_compress(const u8 *src, unsigned int slen,
 68                           u8 *dst, unsigned int *dlen, void *ctx)
 69 {
 70         size_t tmp_len = *dlen; /* size_t(ulong) <-> uint on 64 bit */
 71         int err;
 72 
 73         err = lzo1x_1_compress(src, slen, dst, &tmp_len, ctx);
 74 
 75         if (err != LZO_E_OK)
 76                 return -EINVAL;
 77 
 78         *dlen = tmp_len;
 79         return 0;
 80 }
 81 
 82 static int lzo_compress(struct crypto_tfm *tfm, const u8 *src,
 83                         unsigned int slen, u8 *dst, unsigned int *dlen)
 84 {
 85         struct lzo_ctx *ctx = crypto_tfm_ctx(tfm);
 86 
 87         return __lzo_compress(src, slen, dst, dlen, ctx->lzo_comp_mem);
 88 }
 89 
 90 static int lzo_scompress(struct crypto_scomp *tfm, const u8 *src,
 91                          unsigned int slen, u8 *dst, unsigned int *dlen,
 92                          void *ctx)
 93 {
 94         return __lzo_compress(src, slen, dst, dlen, ctx);
 95 }
 96 
 97 static int __lzo_decompress(const u8 *src, unsigned int slen,
 98                             u8 *dst, unsigned int *dlen)
 99 {
100         int err;
101         size_t tmp_len = *dlen; /* size_t(ulong) <-> uint on 64 bit */
102 
103         err = lzo1x_decompress_safe(src, slen, dst, &tmp_len);
104 
105         if (err != LZO_E_OK)
106                 return -EINVAL;
107 
108         *dlen = tmp_len;
109         return 0;
110 }
111 
112 static int lzo_decompress(struct crypto_tfm *tfm, const u8 *src,
113                           unsigned int slen, u8 *dst, unsigned int *dlen)
114 {
115         return __lzo_decompress(src, slen, dst, dlen);
116 }
117 
118 static int lzo_sdecompress(struct crypto_scomp *tfm, const u8 *src,
119                            unsigned int slen, u8 *dst, unsigned int *dlen,
120                            void *ctx)
121 {
122         return __lzo_decompress(src, slen, dst, dlen);
123 }
124 
125 static struct crypto_alg alg = {
126         .cra_name               = "lzo",
127         .cra_flags              = CRYPTO_ALG_TYPE_COMPRESS,
128         .cra_ctxsize            = sizeof(struct lzo_ctx),
129         .cra_module             = THIS_MODULE,
130         .cra_init               = lzo_init,
131         .cra_exit               = lzo_exit,
132         .cra_u                  = { .compress = {
133         .coa_compress           = lzo_compress,
134         .coa_decompress         = lzo_decompress } }
135 };
136 
137 static struct scomp_alg scomp = {
138         .alloc_ctx              = lzo_alloc_ctx,
139         .free_ctx               = lzo_free_ctx,
140         .compress               = lzo_scompress,
141         .decompress             = lzo_sdecompress,
142         .base                   = {
143                 .cra_name       = "lzo",
144                 .cra_driver_name = "lzo-scomp",
145                 .cra_module      = THIS_MODULE,
146         }
147 };
148 
149 static int __init lzo_mod_init(void)
150 {
151         int ret;
152 
153         ret = crypto_register_alg(&alg);
154         if (ret)
155                 return ret;
156 
157         ret = crypto_register_scomp(&scomp);
158         if (ret) {
159                 crypto_unregister_alg(&alg);
160                 return ret;
161         }
162 
163         return ret;
164 }
165 
166 static void __exit lzo_mod_fini(void)
167 {
168         crypto_unregister_alg(&alg);
169         crypto_unregister_scomp(&scomp);
170 }
171 
172 module_init(lzo_mod_init);
173 module_exit(lzo_mod_fini);
174 
175 MODULE_LICENSE("GPL");
176 MODULE_DESCRIPTION("LZO Compression Algorithm");
177 MODULE_ALIAS_CRYPTO("lzo");
178 

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