projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drivers: power: report battery voltage in AOSP compatible format
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / crypto / ablkcipher.c
CommitLineData
b5b7f088
HX		 1/*
2 * Asynchronous block chaining cipher operations.
c4ede64a 3 *
b5b7f088
HX		 4 * This is the asynchronous version of blkcipher.c indicating completion
5 * via a callback.
6 *
7 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the Free
c4ede64a 11 * Software Foundation; either version 2 of the License, or (at your option)
b5b7f088
HX		 12 * any later version.
13 *
14 */
15
378f4f51 16#include <crypto/internal/skcipher.h>
0b67fb65 17#include <linux/cpumask.h>
378f4f51 18#include <linux/err.h>
b5b7f088 19#include <linux/init.h>
791b4d5f 20#include <linux/kernel.h>
b5b7f088 21#include <linux/module.h>
b9c55aa4
HX		 22#include <linux/rtnetlink.h>
23#include <linux/sched.h>
791b4d5f 24#include <linux/slab.h>
b5b7f088 25#include <linux/seq_file.h>
29ffc876
SK		 26#include <linux/cryptouser.h>
27#include <net/netlink.h>
b5b7f088 28
bf06099d
DM		 29#include <crypto/scatterwalk.h>
30
378f4f51
HX		 31#include "internal.h"
32
0b67fb65
HX		 33static const char *skcipher_default_geniv __read_mostly;
34
bf06099d
DM		 35struct ablkcipher_buffer {
36 struct list_head entry;
37 struct scatter_walk dst;
38 unsigned int len;
39 void *data;
40};
41
42enum {
43 ABLKCIPHER_WALK_SLOW = 1 << 0,
44};
45
46static inline void ablkcipher_buffer_write(struct ablkcipher_buffer *p)
47{
48 scatterwalk_copychunks(p->data, &p->dst, p->len, 1);
49}
50
51void __ablkcipher_walk_complete(struct ablkcipher_walk *walk)
52{
53 struct ablkcipher_buffer *p, *tmp;
54
55 list_for_each_entry_safe(p, tmp, &walk->buffers, entry) {
56 ablkcipher_buffer_write(p);
57 list_del(&p->entry);
58 kfree(p);
59 }
60}
61EXPORT_SYMBOL_GPL(__ablkcipher_walk_complete);
62
63static inline void ablkcipher_queue_write(struct ablkcipher_walk *walk,
64 struct ablkcipher_buffer *p)
65{
66 p->dst = walk->out;
67 list_add_tail(&p->entry, &walk->buffers);
68}
69
70/* Get a spot of the specified length that does not straddle a page.
71 * The caller needs to ensure that there is enough space for this operation.
72 */
73static inline u8 *ablkcipher_get_spot(u8 *start, unsigned int len)
74{
75 u8 *end_page = (u8 *)(((unsigned long)(start + len - 1)) & PAGE_MASK);
76 return max(start, end_page);
77}
78
79static inline unsigned int ablkcipher_done_slow(struct ablkcipher_walk *walk,
80 unsigned int bsize)
81{
82 unsigned int n = bsize;
83
84 for (;;) {
85 unsigned int len_this_page = scatterwalk_pagelen(&walk->out);
86
87 if (len_this_page > n)
88 len_this_page = n;
89 scatterwalk_advance(&walk->out, n);
90 if (n == len_this_page)
91 break;
92 n -= len_this_page;
93 scatterwalk_start(&walk->out, scatterwalk_sg_next(walk->out.sg));
94 }
95
96 return bsize;
97}
98
99static inline unsigned int ablkcipher_done_fast(struct ablkcipher_walk *walk,
100 unsigned int n)
101{
102 scatterwalk_advance(&walk->in, n);
103 scatterwalk_advance(&walk->out, n);
104
105 return n;
106}
107
108static int ablkcipher_walk_next(struct ablkcipher_request *req,
109 struct ablkcipher_walk *walk);
110
111int ablkcipher_walk_done(struct ablkcipher_request *req,
112 struct ablkcipher_walk *walk, int err)
113{
114 struct crypto_tfm *tfm = req->base.tfm;
115 unsigned int nbytes = 0;
116
117 if (likely(err >= 0)) {
118 unsigned int n = walk->nbytes - err;
119
120 if (likely(!(walk->flags & ABLKCIPHER_WALK_SLOW)))
121 n = ablkcipher_done_fast(walk, n);
122 else if (WARN_ON(err)) {
123 err = -EINVAL;
124 goto err;
125 } else
126 n = ablkcipher_done_slow(walk, n);
127
128 nbytes = walk->total - n;
129 err = 0;
130 }
131
132 scatterwalk_done(&walk->in, 0, nbytes);
133 scatterwalk_done(&walk->out, 1, nbytes);
134
135err:
136 walk->total = nbytes;
137 walk->nbytes = nbytes;
138
139 if (nbytes) {
140 crypto_yield(req->base.flags);
141 return ablkcipher_walk_next(req, walk);
142 }
143
144 if (walk->iv != req->info)
145 memcpy(req->info, walk->iv, tfm->crt_ablkcipher.ivsize);
33c7c0fb 146 kfree(walk->iv_buffer);
bf06099d
DM		 147
148 return err;
149}
150EXPORT_SYMBOL_GPL(ablkcipher_walk_done);
151
152static inline int ablkcipher_next_slow(struct ablkcipher_request *req,
153 struct ablkcipher_walk *walk,
154 unsigned int bsize,
155 unsigned int alignmask,
156 void **src_p, void **dst_p)
157{
158 unsigned aligned_bsize = ALIGN(bsize, alignmask + 1);
159 struct ablkcipher_buffer *p;
160 void *src, *dst, *base;
161 unsigned int n;
162
163 n = ALIGN(sizeof(struct ablkcipher_buffer), alignmask + 1);
164 n += (aligned_bsize * 3 - (alignmask + 1) +
165 (alignmask & ~(crypto_tfm_ctx_alignment() - 1)));
166
167 p = kmalloc(n, GFP_ATOMIC);
168 if (!p)
2716fbf6 169 return ablkcipher_walk_done(req, walk, -ENOMEM);
bf06099d
DM		 170
171 base = p + 1;
172
173 dst = (u8 *)ALIGN((unsigned long)base, alignmask + 1);
174 src = dst = ablkcipher_get_spot(dst, bsize);
175
176 p->len = bsize;
177 p->data = dst;
178
179 scatterwalk_copychunks(src, &walk->in, bsize, 0);
180
181 ablkcipher_queue_write(walk, p);
182
183 walk->nbytes = bsize;
184 walk->flags |= ABLKCIPHER_WALK_SLOW;
185
186 *src_p = src;
187 *dst_p = dst;
188
189 return 0;
190}
191
192static inline int ablkcipher_copy_iv(struct ablkcipher_walk *walk,
193 struct crypto_tfm *tfm,
194 unsigned int alignmask)
195{
196 unsigned bs = walk->blocksize;
197 unsigned int ivsize = tfm->crt_ablkcipher.ivsize;
198 unsigned aligned_bs = ALIGN(bs, alignmask + 1);
199 unsigned int size = aligned_bs * 2 + ivsize + max(aligned_bs, ivsize) -
200 (alignmask + 1);
201 u8 *iv;
202
203 size += alignmask & ~(crypto_tfm_ctx_alignment() - 1);
204 walk->iv_buffer = kmalloc(size, GFP_ATOMIC);
205 if (!walk->iv_buffer)
206 return -ENOMEM;
207
208 iv = (u8 *)ALIGN((unsigned long)walk->iv_buffer, alignmask + 1);
209 iv = ablkcipher_get_spot(iv, bs) + aligned_bs;
210 iv = ablkcipher_get_spot(iv, bs) + aligned_bs;
211 iv = ablkcipher_get_spot(iv, ivsize);
212
213 walk->iv = memcpy(iv, walk->iv, ivsize);
214 return 0;
215}
216
217static inline int ablkcipher_next_fast(struct ablkcipher_request *req,
218 struct ablkcipher_walk *walk)
219{
220 walk->src.page = scatterwalk_page(&walk->in);
221 walk->src.offset = offset_in_page(walk->in.offset);
222 walk->dst.page = scatterwalk_page(&walk->out);
223 walk->dst.offset = offset_in_page(walk->out.offset);
224
225 return 0;
226}
227
228static int ablkcipher_walk_next(struct ablkcipher_request *req,
229 struct ablkcipher_walk *walk)
230{
231 struct crypto_tfm *tfm = req->base.tfm;
232 unsigned int alignmask, bsize, n;
233 void *src, *dst;
234 int err;
235
236 alignmask = crypto_tfm_alg_alignmask(tfm);
237 n = walk->total;
238 if (unlikely(n < crypto_tfm_alg_blocksize(tfm))) {
239 req->base.flags |= CRYPTO_TFM_RES_BAD_BLOCK_LEN;
240 return ablkcipher_walk_done(req, walk, -EINVAL);
241 }
242
243 walk->flags &= ~ABLKCIPHER_WALK_SLOW;
244 src = dst = NULL;
245
246 bsize = min(walk->blocksize, n);
247 n = scatterwalk_clamp(&walk->in, n);
248 n = scatterwalk_clamp(&walk->out, n);
249
250 if (n < bsize ||
251 !scatterwalk_aligned(&walk->in, alignmask) ||
252 !scatterwalk_aligned(&walk->out, alignmask)) {
253 err = ablkcipher_next_slow(req, walk, bsize, alignmask,
254 &src, &dst);
255 goto set_phys_lowmem;
256 }
257
258 walk->nbytes = n;
259
260 return ablkcipher_next_fast(req, walk);
261
262set_phys_lowmem:
263 if (err >= 0) {
264 walk->src.page = virt_to_page(src);
265 walk->dst.page = virt_to_page(dst);
266 walk->src.offset = ((unsigned long)src & (PAGE_SIZE - 1));
267 walk->dst.offset = ((unsigned long)dst & (PAGE_SIZE - 1));
268 }
269
270 return err;
271}
272
273static int ablkcipher_walk_first(struct ablkcipher_request *req,
274 struct ablkcipher_walk *walk)
275{
276 struct crypto_tfm *tfm = req->base.tfm;
277 unsigned int alignmask;
278
279 alignmask = crypto_tfm_alg_alignmask(tfm);
280 if (WARN_ON_ONCE(in_irq()))
281 return -EDEADLK;
282
283 walk->nbytes = walk->total;
284 if (unlikely(!walk->total))
285 return 0;
286
287 walk->iv_buffer = NULL;
288 walk->iv = req->info;
289 if (unlikely(((unsigned long)walk->iv & alignmask))) {
290 int err = ablkcipher_copy_iv(walk, tfm, alignmask);
291 if (err)
292 return err;
293 }
294
295 scatterwalk_start(&walk->in, walk->in.sg);
296 scatterwalk_start(&walk->out, walk->out.sg);
297
298 return ablkcipher_walk_next(req, walk);
299}
300
301int ablkcipher_walk_phys(struct ablkcipher_request *req,
302 struct ablkcipher_walk *walk)
303{
304 walk->blocksize = crypto_tfm_alg_blocksize(req->base.tfm);
305 return ablkcipher_walk_first(req, walk);
306}
307EXPORT_SYMBOL_GPL(ablkcipher_walk_phys);
308
791b4d5f
HX		 309static int setkey_unaligned(struct crypto_ablkcipher *tfm, const u8 *key,
310 unsigned int keylen)
ca7c3938
SS		 311{
312 struct ablkcipher_alg *cipher = crypto_ablkcipher_alg(tfm);
313 unsigned long alignmask = crypto_ablkcipher_alignmask(tfm);
314 int ret;
315 u8 *buffer, *alignbuffer;
316 unsigned long absize;
317
318 absize = keylen + alignmask;
319 buffer = kmalloc(absize, GFP_ATOMIC);
320 if (!buffer)
321 return -ENOMEM;
322
323 alignbuffer = (u8 *)ALIGN((unsigned long)buffer, alignmask + 1);
324 memcpy(alignbuffer, key, keylen);
325 ret = cipher->setkey(tfm, alignbuffer, keylen);
06817176 326 memset(alignbuffer, 0, keylen);
ca7c3938
SS		 327 kfree(buffer);
328 return ret;
329}
330
b5b7f088
HX		 331static int setkey(struct crypto_ablkcipher *tfm, const u8 *key,
332 unsigned int keylen)
333{
334 struct ablkcipher_alg *cipher = crypto_ablkcipher_alg(tfm);
ca7c3938 335 unsigned long alignmask = crypto_ablkcipher_alignmask(tfm);
b5b7f088
HX		 336
337 if (keylen < cipher->min_keysize || keylen > cipher->max_keysize) {
338 crypto_ablkcipher_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
339 return -EINVAL;
340 }
341
ca7c3938
SS		 342 if ((unsigned long)key & alignmask)
343 return setkey_unaligned(tfm, key, keylen);
344
b5b7f088
HX		 345 return cipher->setkey(tfm, key, keylen);
346}
347
348static unsigned int crypto_ablkcipher_ctxsize(struct crypto_alg *alg, u32 type,
349 u32 mask)
350{
351 return alg->cra_ctxsize;
352}
353
b9c55aa4
HX		 354int skcipher_null_givencrypt(struct skcipher_givcrypt_request *req)
355{
356 return crypto_ablkcipher_encrypt(&req->creq);
357}
358
359int skcipher_null_givdecrypt(struct skcipher_givcrypt_request *req)
360{
361 return crypto_ablkcipher_decrypt(&req->creq);
362}
363
b5b7f088
HX		 364static int crypto_init_ablkcipher_ops(struct crypto_tfm *tfm, u32 type,
365 u32 mask)
366{
367 struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher;
368 struct ablkcipher_tfm *crt = &tfm->crt_ablkcipher;
369
370 if (alg->ivsize > PAGE_SIZE / 8)
371 return -EINVAL;
372
373 crt->setkey = setkey;
374 crt->encrypt = alg->encrypt;
375 crt->decrypt = alg->decrypt;
b9c55aa4
HX		 376 if (!alg->ivsize) {
377 crt->givencrypt = skcipher_null_givencrypt;
378 crt->givdecrypt = skcipher_null_givdecrypt;
379 }
ecfc4329 380 crt->base = __crypto_ablkcipher_cast(tfm);
b5b7f088 381 crt->ivsize = alg->ivsize;
16d40448 382 crt->has_setkey = alg->max_keysize;
b5b7f088
HX		 383
384 return 0;
385}
386
3acc8473 387#ifdef CONFIG_NET
29ffc876
SK		 388static int crypto_ablkcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
389{
390 struct crypto_report_blkcipher rblkcipher;
391
9a5467bf
MK		 392 strncpy(rblkcipher.type, "ablkcipher", sizeof(rblkcipher.type));
393 strncpy(rblkcipher.geniv, alg->cra_ablkcipher.geniv ?: "<default>",
394 sizeof(rblkcipher.geniv));
29ffc876
SK		 395
396 rblkcipher.blocksize = alg->cra_blocksize;
397 rblkcipher.min_keysize = alg->cra_ablkcipher.min_keysize;
398 rblkcipher.max_keysize = alg->cra_ablkcipher.max_keysize;
399 rblkcipher.ivsize = alg->cra_ablkcipher.ivsize;
400
6662df33
DM		 401 if (nla_put(skb, CRYPTOCFGA_REPORT_BLKCIPHER,
402 sizeof(struct crypto_report_blkcipher), &rblkcipher))
403 goto nla_put_failure;
29ffc876
SK		 404 return 0;
405
406nla_put_failure:
407 return -EMSGSIZE;
408}
3acc8473
HX		 409#else
410static int crypto_ablkcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
411{
412 return -ENOSYS;
413}
414#endif
29ffc876 415
b5b7f088
HX		 416static void crypto_ablkcipher_show(struct seq_file *m, struct crypto_alg *alg)
417 __attribute__ ((unused));
418static void crypto_ablkcipher_show(struct seq_file *m, struct crypto_alg *alg)
419{
420 struct ablkcipher_alg *ablkcipher = &alg->cra_ablkcipher;
421
422 seq_printf(m, "type : ablkcipher\n");
189ed66e
HX		 423 seq_printf(m, "async : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ?
424 "yes" : "no");
b5b7f088
HX		 425 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize);
426 seq_printf(m, "min keysize : %u\n", ablkcipher->min_keysize);
427 seq_printf(m, "max keysize : %u\n", ablkcipher->max_keysize);
428 seq_printf(m, "ivsize : %u\n", ablkcipher->ivsize);
23508e11 429 seq_printf(m, "geniv : %s\n", ablkcipher->geniv ?: "<default>");
b5b7f088
HX		 430}
431
432const struct crypto_type crypto_ablkcipher_type = {
433 .ctxsize = crypto_ablkcipher_ctxsize,
434 .init = crypto_init_ablkcipher_ops,
435#ifdef CONFIG_PROC_FS
436 .show = crypto_ablkcipher_show,
437#endif
29ffc876 438 .report = crypto_ablkcipher_report,
b5b7f088
HX		 439};
440EXPORT_SYMBOL_GPL(crypto_ablkcipher_type);
441
61da88e2
HX		 442static int no_givdecrypt(struct skcipher_givcrypt_request *req)
443{
444 return -ENOSYS;
445}
446
447static int crypto_init_givcipher_ops(struct crypto_tfm *tfm, u32 type,
448 u32 mask)
449{
450 struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher;
451 struct ablkcipher_tfm *crt = &tfm->crt_ablkcipher;
452
453 if (alg->ivsize > PAGE_SIZE / 8)
454 return -EINVAL;
455
ecfc4329
HX		 456 crt->setkey = tfm->__crt_alg->cra_flags & CRYPTO_ALG_GENIV ?
457 alg->setkey : setkey;
61da88e2
HX		 458 crt->encrypt = alg->encrypt;
459 crt->decrypt = alg->decrypt;
460 crt->givencrypt = alg->givencrypt;
461 crt->givdecrypt = alg->givdecrypt ?: no_givdecrypt;
ecfc4329 462 crt->base = __crypto_ablkcipher_cast(tfm);
61da88e2 463 crt->ivsize = alg->ivsize;
16d40448 464 crt->has_setkey = alg->max_keysize;
61da88e2
HX		 465
466 return 0;
467}
468
3acc8473 469#ifdef CONFIG_NET
3e29c109
SK		 470static int crypto_givcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
471{
472 struct crypto_report_blkcipher rblkcipher;
473
9a5467bf
MK		 474 strncpy(rblkcipher.type, "givcipher", sizeof(rblkcipher.type));
475 strncpy(rblkcipher.geniv, alg->cra_ablkcipher.geniv ?: "<built-in>",
476 sizeof(rblkcipher.geniv));
3e29c109
SK		 477
478 rblkcipher.blocksize = alg->cra_blocksize;
479 rblkcipher.min_keysize = alg->cra_ablkcipher.min_keysize;
480 rblkcipher.max_keysize = alg->cra_ablkcipher.max_keysize;
481 rblkcipher.ivsize = alg->cra_ablkcipher.ivsize;
482
6662df33
DM		 483 if (nla_put(skb, CRYPTOCFGA_REPORT_BLKCIPHER,
484 sizeof(struct crypto_report_blkcipher), &rblkcipher))
485 goto nla_put_failure;
3e29c109
SK		 486 return 0;
487
488nla_put_failure:
489 return -EMSGSIZE;
490}
3acc8473
HX		 491#else
492static int crypto_givcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
493{
494 return -ENOSYS;
495}
496#endif
3e29c109 497
61da88e2
HX		 498static void crypto_givcipher_show(struct seq_file *m, struct crypto_alg *alg)
499 __attribute__ ((unused));
500static void crypto_givcipher_show(struct seq_file *m, struct crypto_alg *alg)
501{
502 struct ablkcipher_alg *ablkcipher = &alg->cra_ablkcipher;
503
504 seq_printf(m, "type : givcipher\n");
189ed66e
HX		 505 seq_printf(m, "async : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ?
506 "yes" : "no");
61da88e2
HX		 507 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize);
508 seq_printf(m, "min keysize : %u\n", ablkcipher->min_keysize);
509 seq_printf(m, "max keysize : %u\n", ablkcipher->max_keysize);
510 seq_printf(m, "ivsize : %u\n", ablkcipher->ivsize);
23508e11 511 seq_printf(m, "geniv : %s\n", ablkcipher->geniv ?: "<built-in>");
61da88e2
HX		 512}
513
514const struct crypto_type crypto_givcipher_type = {
515 .ctxsize = crypto_ablkcipher_ctxsize,
516 .init = crypto_init_givcipher_ops,
517#ifdef CONFIG_PROC_FS
518 .show = crypto_givcipher_show,
519#endif
3e29c109 520 .report = crypto_givcipher_report,
61da88e2
HX		 521};
522EXPORT_SYMBOL_GPL(crypto_givcipher_type);
523
ecfc4329
HX		 524const char *crypto_default_geniv(const struct crypto_alg *alg)
525{
63b5ac28
HX		 526 if (((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) ==
527 CRYPTO_ALG_TYPE_BLKCIPHER ? alg->cra_blkcipher.ivsize :
528 alg->cra_ablkcipher.ivsize) !=
529 alg->cra_blocksize)
530 return "chainiv";
531
0b67fb65
HX		 532 return alg->cra_flags & CRYPTO_ALG_ASYNC ?
533 "eseqiv" : skcipher_default_geniv;
ecfc4329
HX		 534}
535
b9c55aa4
HX		 536static int crypto_givcipher_default(struct crypto_alg *alg, u32 type, u32 mask)
537{
538 struct rtattr *tb[3];
539 struct {
540 struct rtattr attr;
541 struct crypto_attr_type data;
542 } ptype;
543 struct {
544 struct rtattr attr;
545 struct crypto_attr_alg data;
546 } palg;
547 struct crypto_template *tmpl;
548 struct crypto_instance *inst;
549 struct crypto_alg *larval;
550 const char *geniv;
551 int err;
552
553 larval = crypto_larval_lookup(alg->cra_driver_name,
435578ae 554 (type & ~CRYPTO_ALG_TYPE_MASK) |
b9c55aa4 555 CRYPTO_ALG_TYPE_GIVCIPHER,
435578ae 556 mask | CRYPTO_ALG_TYPE_MASK);
b9c55aa4
HX		 557 err = PTR_ERR(larval);
558 if (IS_ERR(larval))
559 goto out;
560
561 err = -EAGAIN;
562 if (!crypto_is_larval(larval))
563 goto drop_larval;
564
565 ptype.attr.rta_len = sizeof(ptype);
566 ptype.attr.rta_type = CRYPTOA_TYPE;
567 ptype.data.type = type | CRYPTO_ALG_GENIV;
568 /* GENIV tells the template that we're making a default geniv. */
569 ptype.data.mask = mask | CRYPTO_ALG_GENIV;
570 tb[0] = &ptype.attr;
571
572 palg.attr.rta_len = sizeof(palg);
573 palg.attr.rta_type = CRYPTOA_ALG;
574 /* Must use the exact name to locate ourselves. */
575 memcpy(palg.data.name, alg->cra_driver_name, CRYPTO_MAX_ALG_NAME);
576 tb[1] = &palg.attr;
577
578 tb[2] = NULL;
579
580 if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) ==
581 CRYPTO_ALG_TYPE_BLKCIPHER)
582 geniv = alg->cra_blkcipher.geniv;
583 else
584 geniv = alg->cra_ablkcipher.geniv;
585
586 if (!geniv)
587 geniv = crypto_default_geniv(alg);
588
589 tmpl = crypto_lookup_template(geniv);
590 err = -ENOENT;
591 if (!tmpl)
592 goto kill_larval;
593
594 inst = tmpl->alloc(tb);
595 err = PTR_ERR(inst);
596 if (IS_ERR(inst))
597 goto put_tmpl;
598
599 if ((err = crypto_register_instance(tmpl, inst))) {
600 tmpl->free(inst);
601 goto put_tmpl;
602 }
603
604 /* Redo the lookup to use the instance we just registered. */
605 err = -EAGAIN;
606
607put_tmpl:
608 crypto_tmpl_put(tmpl);
609kill_larval:
610 crypto_larval_kill(larval);
611drop_larval:
612 crypto_mod_put(larval);
613out:
614 crypto_mod_put(alg);
615 return err;
616}
617
1e122994 618struct crypto_alg *crypto_lookup_skcipher(const char *name, u32 type, u32 mask)
b9c55aa4
HX		 619{
620 struct crypto_alg *alg;
621
622 alg = crypto_alg_mod_lookup(name, type, mask);
623 if (IS_ERR(alg))
624 return alg;
625
626 if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) ==
627 CRYPTO_ALG_TYPE_GIVCIPHER)
628 return alg;
629
630 if (!((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) ==
631 CRYPTO_ALG_TYPE_BLKCIPHER ? alg->cra_blkcipher.ivsize :
632 alg->cra_ablkcipher.ivsize))
633 return alg;
634
b170a137
HX		 635 crypto_mod_put(alg);
636 alg = crypto_alg_mod_lookup(name, type | CRYPTO_ALG_TESTED,
637 mask & ~CRYPTO_ALG_TESTED);
638 if (IS_ERR(alg))
639 return alg;
640
641 if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) ==
642 CRYPTO_ALG_TYPE_GIVCIPHER) {
643 if ((alg->cra_flags ^ type ^ ~mask) & CRYPTO_ALG_TESTED) {
644 crypto_mod_put(alg);
645 alg = ERR_PTR(-ENOENT);
646 }
647 return alg;
648 }
649
650 BUG_ON(!((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) ==
651 CRYPTO_ALG_TYPE_BLKCIPHER ? alg->cra_blkcipher.ivsize :
652 alg->cra_ablkcipher.ivsize));
653
b9c55aa4
HX		 654 return ERR_PTR(crypto_givcipher_default(alg, type, mask));
655}
1e122994 656EXPORT_SYMBOL_GPL(crypto_lookup_skcipher);
b9c55aa4 657
378f4f51
HX		 658int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn, const char *name,
659 u32 type, u32 mask)
660{
661 struct crypto_alg *alg;
662 int err;
663
664 type = crypto_skcipher_type(type);
665 mask = crypto_skcipher_mask(mask);
666
b9c55aa4 667 alg = crypto_lookup_skcipher(name, type, mask);
378f4f51
HX		 668 if (IS_ERR(alg))
669 return PTR_ERR(alg);
670
671 err = crypto_init_spawn(&spawn->base, alg, spawn->base.inst, mask);
672 crypto_mod_put(alg);
673 return err;
674}
675EXPORT_SYMBOL_GPL(crypto_grab_skcipher);
676
b9c55aa4
HX		 677struct crypto_ablkcipher *crypto_alloc_ablkcipher(const char *alg_name,
678 u32 type, u32 mask)
679{
680 struct crypto_tfm *tfm;
681 int err;
682
683 type = crypto_skcipher_type(type);
684 mask = crypto_skcipher_mask(mask);
685
686 for (;;) {
687 struct crypto_alg *alg;
688
689 alg = crypto_lookup_skcipher(alg_name, type, mask);
690 if (IS_ERR(alg)) {
691 err = PTR_ERR(alg);
692 goto err;
693 }
694
695 tfm = __crypto_alloc_tfm(alg, type, mask);
696 if (!IS_ERR(tfm))
697 return __crypto_ablkcipher_cast(tfm);
698
699 crypto_mod_put(alg);
700 err = PTR_ERR(tfm);
701
702err:
703 if (err != -EAGAIN)
704 break;
3f933c55 705 if (fatal_signal_pending(current)) {
b9c55aa4
HX		 706 err = -EINTR;
707 break;
708 }
709 }
710
711 return ERR_PTR(err);
712}
713EXPORT_SYMBOL_GPL(crypto_alloc_ablkcipher);
0b67fb65
HX		 714
715static int __init skcipher_module_init(void)
716{
717 skcipher_default_geniv = num_possible_cpus() > 1 ?
718 "eseqiv" : "chainiv";
719 return 0;
720}
721
722static void skcipher_module_exit(void)
723{
724}
725
726module_init(skcipher_module_init);
727module_exit(skcipher_module_exit);
kernel source for telekom puls (alcatel/mediatek)