1 | /* SPDX-License-Identifier: GPL-2.0-or-later */ |
2 | /* |
3 | * Asynchronous Compression operations |
4 | * |
5 | * Copyright (c) 2016, Intel Corporation |
6 | * Authors: Weigang Li <weigang.li@intel.com> |
7 | * Giovanni Cabiddu <giovanni.cabiddu@intel.com> |
8 | */ |
9 | #ifndef _CRYPTO_ACOMP_H |
10 | #define _CRYPTO_ACOMP_H |
11 | |
12 | #include <linux/atomic.h> |
13 | #include <linux/container_of.h> |
14 | #include <linux/crypto.h> |
15 | |
16 | #define CRYPTO_ACOMP_ALLOC_OUTPUT 0x00000001 |
17 | #define CRYPTO_ACOMP_DST_MAX 131072 |
18 | |
19 | /** |
20 | * struct acomp_req - asynchronous (de)compression request |
21 | * |
22 | * @base: Common attributes for asynchronous crypto requests |
23 | * @src: Source Data |
24 | * @dst: Destination data |
25 | * @slen: Size of the input buffer |
26 | * @dlen: Size of the output buffer and number of bytes produced |
27 | * @flags: Internal flags |
28 | * @__ctx: Start of private context data |
29 | */ |
30 | struct acomp_req { |
31 | struct crypto_async_request base; |
32 | struct scatterlist *src; |
33 | struct scatterlist *dst; |
34 | unsigned int slen; |
35 | unsigned int dlen; |
36 | u32 flags; |
37 | void *__ctx[] CRYPTO_MINALIGN_ATTR; |
38 | }; |
39 | |
40 | /** |
41 | * struct crypto_acomp - user-instantiated objects which encapsulate |
42 | * algorithms and core processing logic |
43 | * |
44 | * @compress: Function performs a compress operation |
45 | * @decompress: Function performs a de-compress operation |
46 | * @dst_free: Frees destination buffer if allocated inside the |
47 | * algorithm |
48 | * @reqsize: Context size for (de)compression requests |
49 | * @base: Common crypto API algorithm data structure |
50 | */ |
51 | struct crypto_acomp { |
52 | int (*compress)(struct acomp_req *req); |
53 | int (*decompress)(struct acomp_req *req); |
54 | void (*dst_free)(struct scatterlist *dst); |
55 | unsigned int reqsize; |
56 | struct crypto_tfm base; |
57 | }; |
58 | |
59 | /* |
60 | * struct crypto_istat_compress - statistics for compress algorithm |
61 | * @compress_cnt: number of compress requests |
62 | * @compress_tlen: total data size handled by compress requests |
63 | * @decompress_cnt: number of decompress requests |
64 | * @decompress_tlen: total data size handled by decompress requests |
65 | * @err_cnt: number of error for compress requests |
66 | */ |
67 | struct crypto_istat_compress { |
68 | atomic64_t compress_cnt; |
69 | atomic64_t compress_tlen; |
70 | atomic64_t decompress_cnt; |
71 | atomic64_t decompress_tlen; |
72 | atomic64_t err_cnt; |
73 | }; |
74 | |
75 | #ifdef CONFIG_CRYPTO_STATS |
76 | #define COMP_ALG_COMMON_STATS struct crypto_istat_compress stat; |
77 | #else |
78 | #define COMP_ALG_COMMON_STATS |
79 | #endif |
80 | |
81 | #define COMP_ALG_COMMON { \ |
82 | COMP_ALG_COMMON_STATS \ |
83 | \ |
84 | struct crypto_alg base; \ |
85 | } |
86 | struct comp_alg_common COMP_ALG_COMMON; |
87 | |
88 | /** |
89 | * DOC: Asynchronous Compression API |
90 | * |
91 | * The Asynchronous Compression API is used with the algorithms of type |
92 | * CRYPTO_ALG_TYPE_ACOMPRESS (listed as type "acomp" in /proc/crypto) |
93 | */ |
94 | |
95 | /** |
96 | * crypto_alloc_acomp() -- allocate ACOMPRESS tfm handle |
97 | * @alg_name: is the cra_name / name or cra_driver_name / driver name of the |
98 | * compression algorithm e.g. "deflate" |
99 | * @type: specifies the type of the algorithm |
100 | * @mask: specifies the mask for the algorithm |
101 | * |
102 | * Allocate a handle for a compression algorithm. The returned struct |
103 | * crypto_acomp is the handle that is required for any subsequent |
104 | * API invocation for the compression operations. |
105 | * |
106 | * Return: allocated handle in case of success; IS_ERR() is true in case |
107 | * of an error, PTR_ERR() returns the error code. |
108 | */ |
109 | struct crypto_acomp *crypto_alloc_acomp(const char *alg_name, u32 type, |
110 | u32 mask); |
111 | /** |
112 | * crypto_alloc_acomp_node() -- allocate ACOMPRESS tfm handle with desired NUMA node |
113 | * @alg_name: is the cra_name / name or cra_driver_name / driver name of the |
114 | * compression algorithm e.g. "deflate" |
115 | * @type: specifies the type of the algorithm |
116 | * @mask: specifies the mask for the algorithm |
117 | * @node: specifies the NUMA node the ZIP hardware belongs to |
118 | * |
119 | * Allocate a handle for a compression algorithm. Drivers should try to use |
120 | * (de)compressors on the specified NUMA node. |
121 | * The returned struct crypto_acomp is the handle that is required for any |
122 | * subsequent API invocation for the compression operations. |
123 | * |
124 | * Return: allocated handle in case of success; IS_ERR() is true in case |
125 | * of an error, PTR_ERR() returns the error code. |
126 | */ |
127 | struct crypto_acomp *crypto_alloc_acomp_node(const char *alg_name, u32 type, |
128 | u32 mask, int node); |
129 | |
130 | static inline struct crypto_tfm *crypto_acomp_tfm(struct crypto_acomp *tfm) |
131 | { |
132 | return &tfm->base; |
133 | } |
134 | |
135 | static inline struct comp_alg_common *__crypto_comp_alg_common( |
136 | struct crypto_alg *alg) |
137 | { |
138 | return container_of(alg, struct comp_alg_common, base); |
139 | } |
140 | |
141 | static inline struct crypto_acomp *__crypto_acomp_tfm(struct crypto_tfm *tfm) |
142 | { |
143 | return container_of(tfm, struct crypto_acomp, base); |
144 | } |
145 | |
146 | static inline struct comp_alg_common *crypto_comp_alg_common( |
147 | struct crypto_acomp *tfm) |
148 | { |
149 | return __crypto_comp_alg_common(alg: crypto_acomp_tfm(tfm)->__crt_alg); |
150 | } |
151 | |
152 | static inline unsigned int crypto_acomp_reqsize(struct crypto_acomp *tfm) |
153 | { |
154 | return tfm->reqsize; |
155 | } |
156 | |
157 | static inline void acomp_request_set_tfm(struct acomp_req *req, |
158 | struct crypto_acomp *tfm) |
159 | { |
160 | req->base.tfm = crypto_acomp_tfm(tfm); |
161 | } |
162 | |
163 | static inline struct crypto_acomp *crypto_acomp_reqtfm(struct acomp_req *req) |
164 | { |
165 | return __crypto_acomp_tfm(tfm: req->base.tfm); |
166 | } |
167 | |
168 | /** |
169 | * crypto_free_acomp() -- free ACOMPRESS tfm handle |
170 | * |
171 | * @tfm: ACOMPRESS tfm handle allocated with crypto_alloc_acomp() |
172 | * |
173 | * If @tfm is a NULL or error pointer, this function does nothing. |
174 | */ |
175 | static inline void crypto_free_acomp(struct crypto_acomp *tfm) |
176 | { |
177 | crypto_destroy_tfm(mem: tfm, tfm: crypto_acomp_tfm(tfm)); |
178 | } |
179 | |
180 | static inline int crypto_has_acomp(const char *alg_name, u32 type, u32 mask) |
181 | { |
182 | type &= ~CRYPTO_ALG_TYPE_MASK; |
183 | type |= CRYPTO_ALG_TYPE_ACOMPRESS; |
184 | mask |= CRYPTO_ALG_TYPE_ACOMPRESS_MASK; |
185 | |
186 | return crypto_has_alg(name: alg_name, type, mask); |
187 | } |
188 | |
189 | /** |
190 | * acomp_request_alloc() -- allocates asynchronous (de)compression request |
191 | * |
192 | * @tfm: ACOMPRESS tfm handle allocated with crypto_alloc_acomp() |
193 | * |
194 | * Return: allocated handle in case of success or NULL in case of an error |
195 | */ |
196 | struct acomp_req *acomp_request_alloc(struct crypto_acomp *tfm); |
197 | |
198 | /** |
199 | * acomp_request_free() -- zeroize and free asynchronous (de)compression |
200 | * request as well as the output buffer if allocated |
201 | * inside the algorithm |
202 | * |
203 | * @req: request to free |
204 | */ |
205 | void acomp_request_free(struct acomp_req *req); |
206 | |
207 | /** |
208 | * acomp_request_set_callback() -- Sets an asynchronous callback |
209 | * |
210 | * Callback will be called when an asynchronous operation on a given |
211 | * request is finished. |
212 | * |
213 | * @req: request that the callback will be set for |
214 | * @flgs: specify for instance if the operation may backlog |
215 | * @cmlp: callback which will be called |
216 | * @data: private data used by the caller |
217 | */ |
218 | static inline void acomp_request_set_callback(struct acomp_req *req, |
219 | u32 flgs, |
220 | crypto_completion_t cmpl, |
221 | void *data) |
222 | { |
223 | req->base.complete = cmpl; |
224 | req->base.data = data; |
225 | req->base.flags &= CRYPTO_ACOMP_ALLOC_OUTPUT; |
226 | req->base.flags |= flgs & ~CRYPTO_ACOMP_ALLOC_OUTPUT; |
227 | } |
228 | |
229 | /** |
230 | * acomp_request_set_params() -- Sets request parameters |
231 | * |
232 | * Sets parameters required by an acomp operation |
233 | * |
234 | * @req: asynchronous compress request |
235 | * @src: pointer to input buffer scatterlist |
236 | * @dst: pointer to output buffer scatterlist. If this is NULL, the |
237 | * acomp layer will allocate the output memory |
238 | * @slen: size of the input buffer |
239 | * @dlen: size of the output buffer. If dst is NULL, this can be used by |
240 | * the user to specify the maximum amount of memory to allocate |
241 | */ |
242 | static inline void acomp_request_set_params(struct acomp_req *req, |
243 | struct scatterlist *src, |
244 | struct scatterlist *dst, |
245 | unsigned int slen, |
246 | unsigned int dlen) |
247 | { |
248 | req->src = src; |
249 | req->dst = dst; |
250 | req->slen = slen; |
251 | req->dlen = dlen; |
252 | |
253 | req->flags &= ~CRYPTO_ACOMP_ALLOC_OUTPUT; |
254 | if (!req->dst) |
255 | req->flags |= CRYPTO_ACOMP_ALLOC_OUTPUT; |
256 | } |
257 | |
258 | static inline struct crypto_istat_compress *comp_get_stat( |
259 | struct comp_alg_common *alg) |
260 | { |
261 | #ifdef CONFIG_CRYPTO_STATS |
262 | return &alg->stat; |
263 | #else |
264 | return NULL; |
265 | #endif |
266 | } |
267 | |
268 | static inline int crypto_comp_errstat(struct comp_alg_common *alg, int err) |
269 | { |
270 | if (!IS_ENABLED(CONFIG_CRYPTO_STATS)) |
271 | return err; |
272 | |
273 | if (err && err != -EINPROGRESS && err != -EBUSY) |
274 | atomic64_inc(v: &comp_get_stat(alg)->err_cnt); |
275 | |
276 | return err; |
277 | } |
278 | |
279 | /** |
280 | * crypto_acomp_compress() -- Invoke asynchronous compress operation |
281 | * |
282 | * Function invokes the asynchronous compress operation |
283 | * |
284 | * @req: asynchronous compress request |
285 | * |
286 | * Return: zero on success; error code in case of error |
287 | */ |
288 | static inline int crypto_acomp_compress(struct acomp_req *req) |
289 | { |
290 | struct crypto_acomp *tfm = crypto_acomp_reqtfm(req); |
291 | struct comp_alg_common *alg; |
292 | |
293 | alg = crypto_comp_alg_common(tfm); |
294 | |
295 | if (IS_ENABLED(CONFIG_CRYPTO_STATS)) { |
296 | struct crypto_istat_compress *istat = comp_get_stat(alg); |
297 | |
298 | atomic64_inc(v: &istat->compress_cnt); |
299 | atomic64_add(i: req->slen, v: &istat->compress_tlen); |
300 | } |
301 | |
302 | return crypto_comp_errstat(alg, err: tfm->compress(req)); |
303 | } |
304 | |
305 | /** |
306 | * crypto_acomp_decompress() -- Invoke asynchronous decompress operation |
307 | * |
308 | * Function invokes the asynchronous decompress operation |
309 | * |
310 | * @req: asynchronous compress request |
311 | * |
312 | * Return: zero on success; error code in case of error |
313 | */ |
314 | static inline int crypto_acomp_decompress(struct acomp_req *req) |
315 | { |
316 | struct crypto_acomp *tfm = crypto_acomp_reqtfm(req); |
317 | struct comp_alg_common *alg; |
318 | |
319 | alg = crypto_comp_alg_common(tfm); |
320 | |
321 | if (IS_ENABLED(CONFIG_CRYPTO_STATS)) { |
322 | struct crypto_istat_compress *istat = comp_get_stat(alg); |
323 | |
324 | atomic64_inc(v: &istat->decompress_cnt); |
325 | atomic64_add(i: req->slen, v: &istat->decompress_tlen); |
326 | } |
327 | |
328 | return crypto_comp_errstat(alg, err: tfm->decompress(req)); |
329 | } |
330 | |
331 | #endif |
332 | |