]>
Commit | Line | Data |
---|---|---|
2ebda74f GC |
1 | /* |
2 | * Asynchronous Compression operations | |
3 | * | |
4 | * Copyright (c) 2016, Intel Corporation | |
5 | * Authors: Weigang Li <weigang.li@intel.com> | |
6 | * Giovanni Cabiddu <giovanni.cabiddu@intel.com> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify it | |
9 | * under the terms of the GNU General Public License as published by the Free | |
10 | * Software Foundation; either version 2 of the License, or (at your option) | |
11 | * any later version. | |
12 | * | |
13 | */ | |
14 | #include <linux/errno.h> | |
15 | #include <linux/kernel.h> | |
16 | #include <linux/module.h> | |
17 | #include <linux/seq_file.h> | |
18 | #include <linux/slab.h> | |
19 | #include <linux/string.h> | |
20 | #include <linux/crypto.h> | |
21 | #include <crypto/algapi.h> | |
22 | #include <linux/cryptouser.h> | |
23 | #include <net/netlink.h> | |
24 | #include <crypto/internal/acompress.h> | |
1ab53a77 | 25 | #include <crypto/internal/scompress.h> |
2ebda74f GC |
26 | #include "internal.h" |
27 | ||
1ab53a77 GC |
28 | static const struct crypto_type crypto_acomp_type; |
29 | ||
2ebda74f GC |
30 | #ifdef CONFIG_NET |
31 | static int crypto_acomp_report(struct sk_buff *skb, struct crypto_alg *alg) | |
32 | { | |
33 | struct crypto_report_acomp racomp; | |
34 | ||
35 | strncpy(racomp.type, "acomp", sizeof(racomp.type)); | |
36 | ||
37 | if (nla_put(skb, CRYPTOCFGA_REPORT_ACOMP, | |
38 | sizeof(struct crypto_report_acomp), &racomp)) | |
39 | goto nla_put_failure; | |
40 | return 0; | |
41 | ||
42 | nla_put_failure: | |
43 | return -EMSGSIZE; | |
44 | } | |
45 | #else | |
46 | static int crypto_acomp_report(struct sk_buff *skb, struct crypto_alg *alg) | |
47 | { | |
48 | return -ENOSYS; | |
49 | } | |
50 | #endif | |
51 | ||
52 | static void crypto_acomp_show(struct seq_file *m, struct crypto_alg *alg) | |
53 | __attribute__ ((unused)); | |
54 | ||
55 | static void crypto_acomp_show(struct seq_file *m, struct crypto_alg *alg) | |
56 | { | |
57 | seq_puts(m, "type : acomp\n"); | |
58 | } | |
59 | ||
60 | static void crypto_acomp_exit_tfm(struct crypto_tfm *tfm) | |
61 | { | |
62 | struct crypto_acomp *acomp = __crypto_acomp_tfm(tfm); | |
63 | struct acomp_alg *alg = crypto_acomp_alg(acomp); | |
64 | ||
65 | alg->exit(acomp); | |
66 | } | |
67 | ||
68 | static int crypto_acomp_init_tfm(struct crypto_tfm *tfm) | |
69 | { | |
70 | struct crypto_acomp *acomp = __crypto_acomp_tfm(tfm); | |
71 | struct acomp_alg *alg = crypto_acomp_alg(acomp); | |
72 | ||
1ab53a77 GC |
73 | if (tfm->__crt_alg->cra_type != &crypto_acomp_type) |
74 | return crypto_init_scomp_ops_async(tfm); | |
75 | ||
76 | acomp->compress = alg->compress; | |
77 | acomp->decompress = alg->decompress; | |
78 | acomp->dst_free = alg->dst_free; | |
79 | acomp->reqsize = alg->reqsize; | |
80 | ||
2ebda74f GC |
81 | if (alg->exit) |
82 | acomp->base.exit = crypto_acomp_exit_tfm; | |
83 | ||
84 | if (alg->init) | |
85 | return alg->init(acomp); | |
86 | ||
87 | return 0; | |
88 | } | |
89 | ||
1ab53a77 GC |
90 | static unsigned int crypto_acomp_extsize(struct crypto_alg *alg) |
91 | { | |
92 | int extsize = crypto_alg_extsize(alg); | |
93 | ||
94 | if (alg->cra_type != &crypto_acomp_type) | |
95 | extsize += sizeof(struct crypto_scomp *); | |
96 | ||
97 | return extsize; | |
98 | } | |
99 | ||
2ebda74f | 100 | static const struct crypto_type crypto_acomp_type = { |
1ab53a77 | 101 | .extsize = crypto_acomp_extsize, |
2ebda74f GC |
102 | .init_tfm = crypto_acomp_init_tfm, |
103 | #ifdef CONFIG_PROC_FS | |
104 | .show = crypto_acomp_show, | |
105 | #endif | |
106 | .report = crypto_acomp_report, | |
107 | .maskclear = ~CRYPTO_ALG_TYPE_MASK, | |
1ab53a77 | 108 | .maskset = CRYPTO_ALG_TYPE_ACOMPRESS_MASK, |
2ebda74f GC |
109 | .type = CRYPTO_ALG_TYPE_ACOMPRESS, |
110 | .tfmsize = offsetof(struct crypto_acomp, base), | |
111 | }; | |
112 | ||
113 | struct crypto_acomp *crypto_alloc_acomp(const char *alg_name, u32 type, | |
114 | u32 mask) | |
115 | { | |
116 | return crypto_alloc_tfm(alg_name, &crypto_acomp_type, type, mask); | |
117 | } | |
118 | EXPORT_SYMBOL_GPL(crypto_alloc_acomp); | |
119 | ||
1ab53a77 GC |
120 | struct acomp_req *acomp_request_alloc(struct crypto_acomp *acomp) |
121 | { | |
122 | struct crypto_tfm *tfm = crypto_acomp_tfm(acomp); | |
123 | struct acomp_req *req; | |
124 | ||
125 | req = __acomp_request_alloc(acomp); | |
126 | if (req && (tfm->__crt_alg->cra_type != &crypto_acomp_type)) | |
127 | return crypto_acomp_scomp_alloc_ctx(req); | |
128 | ||
129 | return req; | |
130 | } | |
131 | EXPORT_SYMBOL_GPL(acomp_request_alloc); | |
132 | ||
133 | void acomp_request_free(struct acomp_req *req) | |
134 | { | |
135 | struct crypto_acomp *acomp = crypto_acomp_reqtfm(req); | |
136 | struct crypto_tfm *tfm = crypto_acomp_tfm(acomp); | |
137 | ||
138 | if (tfm->__crt_alg->cra_type != &crypto_acomp_type) | |
139 | crypto_acomp_scomp_free_ctx(req); | |
140 | ||
141 | if (req->flags & CRYPTO_ACOMP_ALLOC_OUTPUT) { | |
142 | acomp->dst_free(req->dst); | |
143 | req->dst = NULL; | |
144 | } | |
145 | ||
146 | __acomp_request_free(req); | |
147 | } | |
148 | EXPORT_SYMBOL_GPL(acomp_request_free); | |
149 | ||
2ebda74f GC |
150 | int crypto_register_acomp(struct acomp_alg *alg) |
151 | { | |
152 | struct crypto_alg *base = &alg->base; | |
153 | ||
154 | base->cra_type = &crypto_acomp_type; | |
155 | base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK; | |
156 | base->cra_flags |= CRYPTO_ALG_TYPE_ACOMPRESS; | |
157 | ||
158 | return crypto_register_alg(base); | |
159 | } | |
160 | EXPORT_SYMBOL_GPL(crypto_register_acomp); | |
161 | ||
162 | int crypto_unregister_acomp(struct acomp_alg *alg) | |
163 | { | |
164 | return crypto_unregister_alg(&alg->base); | |
165 | } | |
166 | EXPORT_SYMBOL_GPL(crypto_unregister_acomp); | |
167 | ||
168 | MODULE_LICENSE("GPL"); | |
169 | MODULE_DESCRIPTION("Asynchronous compression type"); |