1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Synchronous Compression operations
5 * Copyright 2015 LG Electronics Inc.
6 * Copyright (c) 2016, Intel Corporation
7 * Author: Giovanni Cabiddu <giovanni.cabiddu@intel.com>
10 #include <crypto/internal/acompress.h>
11 #include <crypto/internal/scompress.h>
12 #include <crypto/scatterwalk.h>
13 #include <linux/cryptouser.h>
14 #include <linux/err.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/scatterlist.h>
18 #include <linux/seq_file.h>
19 #include <linux/slab.h>
20 #include <linux/string.h>
21 #include <linux/vmalloc.h>
22 #include <net/netlink.h>
26 struct scomp_scratch
{
32 static DEFINE_PER_CPU(struct scomp_scratch
, scomp_scratch
) = {
33 .lock
= __SPIN_LOCK_UNLOCKED(scomp_scratch
.lock
),
36 static const struct crypto_type crypto_scomp_type
;
37 static int scomp_scratch_users
;
38 static DEFINE_MUTEX(scomp_lock
);
40 static int __maybe_unused
crypto_scomp_report(
41 struct sk_buff
*skb
, struct crypto_alg
*alg
)
43 struct crypto_report_comp rscomp
;
45 memset(&rscomp
, 0, sizeof(rscomp
));
47 strscpy(rscomp
.type
, "scomp", sizeof(rscomp
.type
));
49 return nla_put(skb
, CRYPTOCFGA_REPORT_COMPRESS
,
50 sizeof(rscomp
), &rscomp
);
53 static void crypto_scomp_show(struct seq_file
*m
, struct crypto_alg
*alg
)
56 static void crypto_scomp_show(struct seq_file
*m
, struct crypto_alg
*alg
)
58 seq_puts(m
, "type : scomp\n");
61 static void crypto_scomp_free_scratches(void)
63 struct scomp_scratch
*scratch
;
66 for_each_possible_cpu(i
) {
67 scratch
= per_cpu_ptr(&scomp_scratch
, i
);
76 static int crypto_scomp_alloc_scratches(void)
78 struct scomp_scratch
*scratch
;
81 for_each_possible_cpu(i
) {
84 scratch
= per_cpu_ptr(&scomp_scratch
, i
);
86 mem
= vmalloc_node(SCOMP_SCRATCH_SIZE
, cpu_to_node(i
));
90 mem
= vmalloc_node(SCOMP_SCRATCH_SIZE
, cpu_to_node(i
));
97 crypto_scomp_free_scratches();
101 static int crypto_scomp_init_tfm(struct crypto_tfm
*tfm
)
105 mutex_lock(&scomp_lock
);
106 if (!scomp_scratch_users
++)
107 ret
= crypto_scomp_alloc_scratches();
108 mutex_unlock(&scomp_lock
);
113 static int scomp_acomp_comp_decomp(struct acomp_req
*req
, int dir
)
115 struct crypto_acomp
*tfm
= crypto_acomp_reqtfm(req
);
116 void **tfm_ctx
= acomp_tfm_ctx(tfm
);
117 struct crypto_scomp
*scomp
= *tfm_ctx
;
118 void **ctx
= acomp_request_ctx(req
);
119 struct scomp_scratch
*scratch
;
122 if (!req
->src
|| !req
->slen
|| req
->slen
> SCOMP_SCRATCH_SIZE
)
125 if (req
->dst
&& !req
->dlen
)
128 if (!req
->dlen
|| req
->dlen
> SCOMP_SCRATCH_SIZE
)
129 req
->dlen
= SCOMP_SCRATCH_SIZE
;
131 scratch
= raw_cpu_ptr(&scomp_scratch
);
132 spin_lock(&scratch
->lock
);
134 scatterwalk_map_and_copy(scratch
->src
, req
->src
, 0, req
->slen
, 0);
136 ret
= crypto_scomp_compress(scomp
, scratch
->src
, req
->slen
,
137 scratch
->dst
, &req
->dlen
, *ctx
);
139 ret
= crypto_scomp_decompress(scomp
, scratch
->src
, req
->slen
,
140 scratch
->dst
, &req
->dlen
, *ctx
);
143 req
->dst
= sgl_alloc(req
->dlen
, GFP_ATOMIC
, NULL
);
149 scatterwalk_map_and_copy(scratch
->dst
, req
->dst
, 0, req
->dlen
,
153 spin_unlock(&scratch
->lock
);
157 static int scomp_acomp_compress(struct acomp_req
*req
)
159 return scomp_acomp_comp_decomp(req
, 1);
162 static int scomp_acomp_decompress(struct acomp_req
*req
)
164 return scomp_acomp_comp_decomp(req
, 0);
167 static void crypto_exit_scomp_ops_async(struct crypto_tfm
*tfm
)
169 struct crypto_scomp
**ctx
= crypto_tfm_ctx(tfm
);
171 crypto_free_scomp(*ctx
);
173 mutex_lock(&scomp_lock
);
174 if (!--scomp_scratch_users
)
175 crypto_scomp_free_scratches();
176 mutex_unlock(&scomp_lock
);
179 int crypto_init_scomp_ops_async(struct crypto_tfm
*tfm
)
181 struct crypto_alg
*calg
= tfm
->__crt_alg
;
182 struct crypto_acomp
*crt
= __crypto_acomp_tfm(tfm
);
183 struct crypto_scomp
**ctx
= crypto_tfm_ctx(tfm
);
184 struct crypto_scomp
*scomp
;
186 if (!crypto_mod_get(calg
))
189 scomp
= crypto_create_tfm(calg
, &crypto_scomp_type
);
191 crypto_mod_put(calg
);
192 return PTR_ERR(scomp
);
196 tfm
->exit
= crypto_exit_scomp_ops_async
;
198 crt
->compress
= scomp_acomp_compress
;
199 crt
->decompress
= scomp_acomp_decompress
;
200 crt
->dst_free
= sgl_free
;
201 crt
->reqsize
= sizeof(void *);
206 struct acomp_req
*crypto_acomp_scomp_alloc_ctx(struct acomp_req
*req
)
208 struct crypto_acomp
*acomp
= crypto_acomp_reqtfm(req
);
209 struct crypto_tfm
*tfm
= crypto_acomp_tfm(acomp
);
210 struct crypto_scomp
**tfm_ctx
= crypto_tfm_ctx(tfm
);
211 struct crypto_scomp
*scomp
= *tfm_ctx
;
214 ctx
= crypto_scomp_alloc_ctx(scomp
);
225 void crypto_acomp_scomp_free_ctx(struct acomp_req
*req
)
227 struct crypto_acomp
*acomp
= crypto_acomp_reqtfm(req
);
228 struct crypto_tfm
*tfm
= crypto_acomp_tfm(acomp
);
229 struct crypto_scomp
**tfm_ctx
= crypto_tfm_ctx(tfm
);
230 struct crypto_scomp
*scomp
= *tfm_ctx
;
231 void *ctx
= *req
->__ctx
;
234 crypto_scomp_free_ctx(scomp
, ctx
);
237 static const struct crypto_type crypto_scomp_type
= {
238 .extsize
= crypto_alg_extsize
,
239 .init_tfm
= crypto_scomp_init_tfm
,
240 #ifdef CONFIG_PROC_FS
241 .show
= crypto_scomp_show
,
243 #if IS_ENABLED(CONFIG_CRYPTO_USER)
244 .report
= crypto_scomp_report
,
246 #ifdef CONFIG_CRYPTO_STATS
247 .report_stat
= crypto_acomp_report_stat
,
249 .maskclear
= ~CRYPTO_ALG_TYPE_MASK
,
250 .maskset
= CRYPTO_ALG_TYPE_MASK
,
251 .type
= CRYPTO_ALG_TYPE_SCOMPRESS
,
252 .tfmsize
= offsetof(struct crypto_scomp
, base
),
255 int crypto_register_scomp(struct scomp_alg
*alg
)
257 struct crypto_alg
*base
= &alg
->calg
.base
;
259 comp_prepare_alg(&alg
->calg
);
261 base
->cra_type
= &crypto_scomp_type
;
262 base
->cra_flags
|= CRYPTO_ALG_TYPE_SCOMPRESS
;
264 return crypto_register_alg(base
);
266 EXPORT_SYMBOL_GPL(crypto_register_scomp
);
268 void crypto_unregister_scomp(struct scomp_alg
*alg
)
270 crypto_unregister_alg(&alg
->base
);
272 EXPORT_SYMBOL_GPL(crypto_unregister_scomp
);
274 int crypto_register_scomps(struct scomp_alg
*algs
, int count
)
278 for (i
= 0; i
< count
; i
++) {
279 ret
= crypto_register_scomp(&algs
[i
]);
287 for (--i
; i
>= 0; --i
)
288 crypto_unregister_scomp(&algs
[i
]);
292 EXPORT_SYMBOL_GPL(crypto_register_scomps
);
294 void crypto_unregister_scomps(struct scomp_alg
*algs
, int count
)
298 for (i
= count
- 1; i
>= 0; --i
)
299 crypto_unregister_scomp(&algs
[i
]);
301 EXPORT_SYMBOL_GPL(crypto_unregister_scomps
);
303 MODULE_LICENSE("GPL");
304 MODULE_DESCRIPTION("Synchronous compression type");