1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * AMD Cryptographic Coprocessor (CCP) crypto API support
4 *
5 * Copyright (C) 2013,2017 Advanced Micro Devices, Inc.
6 *
7 * Author: Tom Lendacky <thomas.lendacky@amd.com>
8 */
9
10 #include <linux/module.h>
11 #include <linux/moduleparam.h>
12 #include <linux/kernel.h>
13 #include <linux/list.h>
14 #include <linux/ccp.h>
15 #include <linux/scatterlist.h>
16 #include <crypto/internal/hash.h>
17 #include <crypto/internal/akcipher.h>
18
19 #include "ccp-crypto.h"
20
21 MODULE_AUTHOR("Tom Lendacky <thomas.lendacky@amd.com>");
22 MODULE_LICENSE("GPL");
23 MODULE_VERSION("1.0.0");
24 MODULE_DESCRIPTION("AMD Cryptographic Coprocessor crypto API support");
25
26 static unsigned int aes_disable;
27 module_param(aes_disable, uint, 0444);
28 MODULE_PARM_DESC(aes_disable, "Disable use of AES - any non-zero value");
29
30 static unsigned int sha_disable;
31 module_param(sha_disable, uint, 0444);
32 MODULE_PARM_DESC(sha_disable, "Disable use of SHA - any non-zero value");
33
34 static unsigned int des3_disable;
35 module_param(des3_disable, uint, 0444);
36 MODULE_PARM_DESC(des3_disable, "Disable use of 3DES - any non-zero value");
37
38 static unsigned int rsa_disable;
39 module_param(rsa_disable, uint, 0444);
40 MODULE_PARM_DESC(rsa_disable, "Disable use of RSA - any non-zero value");
41
42 /* List heads for the supported algorithms */
43 static LIST_HEAD(hash_algs);
44 static LIST_HEAD(cipher_algs);
45 static LIST_HEAD(aead_algs);
46 static LIST_HEAD(akcipher_algs);
47
48 /* For any tfm, requests for that tfm must be returned on the order
49 * received. With multiple queues available, the CCP can process more
50 * than one cmd at a time. Therefore we must maintain a cmd list to insure
51 * the proper ordering of requests on a given tfm.
52 */
53 struct ccp_crypto_queue {
54 struct list_head cmds;
55 struct list_head *backlog;
56 unsigned int cmd_count;
57 };
58
59 #define CCP_CRYPTO_MAX_QLEN 100
60
61 static struct ccp_crypto_queue req_queue;
62 static spinlock_t req_queue_lock;
63
64 struct ccp_crypto_cmd {
65 struct list_head entry;
66
67 struct ccp_cmd *cmd;
68
69 /* Save the crypto_tfm and crypto_async_request addresses
70 * separately to avoid any reference to a possibly invalid
71 * crypto_async_request structure after invoking the request
72 * callback
73 */
74 struct crypto_async_request *req;
75 struct crypto_tfm *tfm;
76
77 /* Used for held command processing to determine state */
78 int ret;
79 };
80
81 struct ccp_crypto_cpu {
82 struct work_struct work;
83 struct completion completion;
84 struct ccp_crypto_cmd *crypto_cmd;
85 int err;
86 };
87
ccp_crypto_success(int err)88 static inline bool ccp_crypto_success(int err)
89 {
90 if (err && (err != -EINPROGRESS) && (err != -EBUSY))
91 return false;
92
93 return true;
94 }
95
ccp_crypto_cmd_complete(struct ccp_crypto_cmd * crypto_cmd,struct ccp_crypto_cmd ** backlog)96 static struct ccp_crypto_cmd *ccp_crypto_cmd_complete(
97 struct ccp_crypto_cmd *crypto_cmd, struct ccp_crypto_cmd **backlog)
98 {
99 struct ccp_crypto_cmd *held = NULL, *tmp;
100 unsigned long flags;
101
102 *backlog = NULL;
103
104 spin_lock_irqsave(&req_queue_lock, flags);
105
106 /* Held cmds will be after the current cmd in the queue so start
107 * searching for a cmd with a matching tfm for submission.
108 */
109 tmp = crypto_cmd;
110 list_for_each_entry_continue(tmp, &req_queue.cmds, entry) {
111 if (crypto_cmd->tfm != tmp->tfm)
112 continue;
113 held = tmp;
114 break;
115 }
116
117 /* Process the backlog:
118 * Because cmds can be executed from any point in the cmd list
119 * special precautions have to be taken when handling the backlog.
120 */
121 if (req_queue.backlog != &req_queue.cmds) {
122 /* Skip over this cmd if it is the next backlog cmd */
123 if (req_queue.backlog == &crypto_cmd->entry)
124 req_queue.backlog = crypto_cmd->entry.next;
125
126 *backlog = container_of(req_queue.backlog,
127 struct ccp_crypto_cmd, entry);
128 req_queue.backlog = req_queue.backlog->next;
129
130 /* Skip over this cmd if it is now the next backlog cmd */
131 if (req_queue.backlog == &crypto_cmd->entry)
132 req_queue.backlog = crypto_cmd->entry.next;
133 }
134
135 /* Remove the cmd entry from the list of cmds */
136 req_queue.cmd_count--;
137 list_del(&crypto_cmd->entry);
138
139 spin_unlock_irqrestore(&req_queue_lock, flags);
140
141 return held;
142 }
143
ccp_crypto_complete(void * data,int err)144 static void ccp_crypto_complete(void *data, int err)
145 {
146 struct ccp_crypto_cmd *crypto_cmd = data;
147 struct ccp_crypto_cmd *held, *next, *backlog;
148 struct crypto_async_request *req = crypto_cmd->req;
149 struct ccp_ctx *ctx = crypto_tfm_ctx(req->tfm);
150 int ret;
151
152 if (err == -EINPROGRESS) {
153 /* Only propagate the -EINPROGRESS if necessary */
154 if (crypto_cmd->ret == -EBUSY) {
155 crypto_cmd->ret = -EINPROGRESS;
156 req->complete(req, -EINPROGRESS);
157 }
158
159 return;
160 }
161
162 /* Operation has completed - update the queue before invoking
163 * the completion callbacks and retrieve the next cmd (cmd with
164 * a matching tfm) that can be submitted to the CCP.
165 */
166 held = ccp_crypto_cmd_complete(crypto_cmd, &backlog);
167 if (backlog) {
168 backlog->ret = -EINPROGRESS;
169 backlog->req->complete(backlog->req, -EINPROGRESS);
170 }
171
172 /* Transition the state from -EBUSY to -EINPROGRESS first */
173 if (crypto_cmd->ret == -EBUSY)
174 req->complete(req, -EINPROGRESS);
175
176 /* Completion callbacks */
177 ret = err;
178 if (ctx->complete)
179 ret = ctx->complete(req, ret);
180 req->complete(req, ret);
181
182 /* Submit the next cmd */
183 while (held) {
184 /* Since we have already queued the cmd, we must indicate that
185 * we can backlog so as not to "lose" this request.
186 */
187 held->cmd->flags |= CCP_CMD_MAY_BACKLOG;
188 ret = ccp_enqueue_cmd(held->cmd);
189 if (ccp_crypto_success(ret))
190 break;
191
192 /* Error occurred, report it and get the next entry */
193 ctx = crypto_tfm_ctx(held->req->tfm);
194 if (ctx->complete)
195 ret = ctx->complete(held->req, ret);
196 held->req->complete(held->req, ret);
197
198 next = ccp_crypto_cmd_complete(held, &backlog);
199 if (backlog) {
200 backlog->ret = -EINPROGRESS;
201 backlog->req->complete(backlog->req, -EINPROGRESS);
202 }
203
204 kfree(held);
205 held = next;
206 }
207
208 kfree(crypto_cmd);
209 }
210
ccp_crypto_enqueue_cmd(struct ccp_crypto_cmd * crypto_cmd)211 static int ccp_crypto_enqueue_cmd(struct ccp_crypto_cmd *crypto_cmd)
212 {
213 struct ccp_crypto_cmd *active = NULL, *tmp;
214 unsigned long flags;
215 bool free_cmd = true;
216 int ret;
217
218 spin_lock_irqsave(&req_queue_lock, flags);
219
220 /* Check if the cmd can/should be queued */
221 if (req_queue.cmd_count >= CCP_CRYPTO_MAX_QLEN) {
222 if (!(crypto_cmd->cmd->flags & CCP_CMD_MAY_BACKLOG)) {
223 ret = -ENOSPC;
224 goto e_lock;
225 }
226 }
227
228 /* Look for an entry with the same tfm. If there is a cmd
229 * with the same tfm in the list then the current cmd cannot
230 * be submitted to the CCP yet.
231 */
232 list_for_each_entry(tmp, &req_queue.cmds, entry) {
233 if (crypto_cmd->tfm != tmp->tfm)
234 continue;
235 active = tmp;
236 break;
237 }
238
239 ret = -EINPROGRESS;
240 if (!active) {
241 ret = ccp_enqueue_cmd(crypto_cmd->cmd);
242 if (!ccp_crypto_success(ret))
243 goto e_lock; /* Error, don't queue it */
244 }
245
246 if (req_queue.cmd_count >= CCP_CRYPTO_MAX_QLEN) {
247 ret = -EBUSY;
248 if (req_queue.backlog == &req_queue.cmds)
249 req_queue.backlog = &crypto_cmd->entry;
250 }
251 crypto_cmd->ret = ret;
252
253 req_queue.cmd_count++;
254 list_add_tail(&crypto_cmd->entry, &req_queue.cmds);
255
256 free_cmd = false;
257
258 e_lock:
259 spin_unlock_irqrestore(&req_queue_lock, flags);
260
261 if (free_cmd)
262 kfree(crypto_cmd);
263
264 return ret;
265 }
266
267 /**
268 * ccp_crypto_enqueue_request - queue an crypto async request for processing
269 * by the CCP
270 *
271 * @req: crypto_async_request struct to be processed
272 * @cmd: ccp_cmd struct to be sent to the CCP
273 */
ccp_crypto_enqueue_request(struct crypto_async_request * req,struct ccp_cmd * cmd)274 int ccp_crypto_enqueue_request(struct crypto_async_request *req,
275 struct ccp_cmd *cmd)
276 {
277 struct ccp_crypto_cmd *crypto_cmd;
278 gfp_t gfp;
279
280 gfp = req->flags & CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL : GFP_ATOMIC;
281
282 crypto_cmd = kzalloc(sizeof(*crypto_cmd), gfp);
283 if (!crypto_cmd)
284 return -ENOMEM;
285
286 /* The tfm pointer must be saved and not referenced from the
287 * crypto_async_request (req) pointer because it is used after
288 * completion callback for the request and the req pointer
289 * might not be valid anymore.
290 */
291 crypto_cmd->cmd = cmd;
292 crypto_cmd->req = req;
293 crypto_cmd->tfm = req->tfm;
294
295 cmd->callback = ccp_crypto_complete;
296 cmd->data = crypto_cmd;
297
298 if (req->flags & CRYPTO_TFM_REQ_MAY_BACKLOG)
299 cmd->flags |= CCP_CMD_MAY_BACKLOG;
300 else
301 cmd->flags &= ~CCP_CMD_MAY_BACKLOG;
302
303 return ccp_crypto_enqueue_cmd(crypto_cmd);
304 }
305
ccp_crypto_sg_table_add(struct sg_table * table,struct scatterlist * sg_add)306 struct scatterlist *ccp_crypto_sg_table_add(struct sg_table *table,
307 struct scatterlist *sg_add)
308 {
309 struct scatterlist *sg, *sg_last = NULL;
310
311 for (sg = table->sgl; sg; sg = sg_next(sg))
312 if (!sg_page(sg))
313 break;
314 if (WARN_ON(!sg))
315 return NULL;
316
317 for (; sg && sg_add; sg = sg_next(sg), sg_add = sg_next(sg_add)) {
318 sg_set_page(sg, sg_page(sg_add), sg_add->length,
319 sg_add->offset);
320 sg_last = sg;
321 }
322 if (WARN_ON(sg_add))
323 return NULL;
324
325 return sg_last;
326 }
327
ccp_register_algs(void)328 static int ccp_register_algs(void)
329 {
330 int ret;
331
332 if (!aes_disable) {
333 ret = ccp_register_aes_algs(&cipher_algs);
334 if (ret)
335 return ret;
336
337 ret = ccp_register_aes_cmac_algs(&hash_algs);
338 if (ret)
339 return ret;
340
341 ret = ccp_register_aes_xts_algs(&cipher_algs);
342 if (ret)
343 return ret;
344
345 ret = ccp_register_aes_aeads(&aead_algs);
346 if (ret)
347 return ret;
348 }
349
350 if (!des3_disable) {
351 ret = ccp_register_des3_algs(&cipher_algs);
352 if (ret)
353 return ret;
354 }
355
356 if (!sha_disable) {
357 ret = ccp_register_sha_algs(&hash_algs);
358 if (ret)
359 return ret;
360 }
361
362 if (!rsa_disable) {
363 ret = ccp_register_rsa_algs(&akcipher_algs);
364 if (ret)
365 return ret;
366 }
367
368 return 0;
369 }
370
ccp_unregister_algs(void)371 static void ccp_unregister_algs(void)
372 {
373 struct ccp_crypto_ahash_alg *ahash_alg, *ahash_tmp;
374 struct ccp_crypto_ablkcipher_alg *ablk_alg, *ablk_tmp;
375 struct ccp_crypto_aead *aead_alg, *aead_tmp;
376 struct ccp_crypto_akcipher_alg *akc_alg, *akc_tmp;
377
378 list_for_each_entry_safe(ahash_alg, ahash_tmp, &hash_algs, entry) {
379 crypto_unregister_ahash(&ahash_alg->alg);
380 list_del(&ahash_alg->entry);
381 kfree(ahash_alg);
382 }
383
384 list_for_each_entry_safe(ablk_alg, ablk_tmp, &cipher_algs, entry) {
385 crypto_unregister_alg(&ablk_alg->alg);
386 list_del(&ablk_alg->entry);
387 kfree(ablk_alg);
388 }
389
390 list_for_each_entry_safe(aead_alg, aead_tmp, &aead_algs, entry) {
391 crypto_unregister_aead(&aead_alg->alg);
392 list_del(&aead_alg->entry);
393 kfree(aead_alg);
394 }
395
396 list_for_each_entry_safe(akc_alg, akc_tmp, &akcipher_algs, entry) {
397 crypto_unregister_akcipher(&akc_alg->alg);
398 list_del(&akc_alg->entry);
399 kfree(akc_alg);
400 }
401 }
402
ccp_crypto_init(void)403 static int ccp_crypto_init(void)
404 {
405 int ret;
406
407 ret = ccp_present();
408 if (ret) {
409 pr_err("Cannot load: there are no available CCPs\n");
410 return ret;
411 }
412
413 spin_lock_init(&req_queue_lock);
414 INIT_LIST_HEAD(&req_queue.cmds);
415 req_queue.backlog = &req_queue.cmds;
416 req_queue.cmd_count = 0;
417
418 ret = ccp_register_algs();
419 if (ret)
420 ccp_unregister_algs();
421
422 return ret;
423 }
424
ccp_crypto_exit(void)425 static void ccp_crypto_exit(void)
426 {
427 ccp_unregister_algs();
428 }
429
430 module_init(ccp_crypto_init);
431 module_exit(ccp_crypto_exit);
432
