ia64/linux-2.6.18-xen.hg

view net/xfrm/xfrm_algo.c @ 871:9cbcc9008446

xen/x86: don't initialize cpu_data[]'s apicid field on generic code

Afaict, this is not only redundant with the intialization done in
drivers/xen/core/smpboot.c, but actually results - at least for
secondary CPUs - in the Xen-specific value written to be later
overwritten with whatever the generic code determines (with no
guarantee that the two values are identical).

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu May 14 10:09:15 2009 +0100 (2009-05-14)
parents 831230e53067
children
line source
1 /*
2 * xfrm algorithm interface
3 *
4 * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation; either version 2 of the License, or (at your option)
9 * any later version.
10 */
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/pfkeyv2.h>
15 #include <linux/crypto.h>
16 #include <net/xfrm.h>
17 #if defined(CONFIG_INET_AH) || defined(CONFIG_INET_AH_MODULE) || defined(CONFIG_INET6_AH) || defined(CONFIG_INET6_AH_MODULE)
18 #include <net/ah.h>
19 #endif
20 #if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
21 #include <net/esp.h>
22 #endif
23 #include <asm/scatterlist.h>
25 /*
26 * Algorithms supported by IPsec. These entries contain properties which
27 * are used in key negotiation and xfrm processing, and are used to verify
28 * that instantiated crypto transforms have correct parameters for IPsec
29 * purposes.
30 */
31 static struct xfrm_algo_desc aalg_list[] = {
32 {
33 .name = "digest_null",
35 .uinfo = {
36 .auth = {
37 .icv_truncbits = 0,
38 .icv_fullbits = 0,
39 }
40 },
42 .desc = {
43 .sadb_alg_id = SADB_X_AALG_NULL,
44 .sadb_alg_ivlen = 0,
45 .sadb_alg_minbits = 0,
46 .sadb_alg_maxbits = 0
47 }
48 },
49 {
50 .name = "md5",
52 .uinfo = {
53 .auth = {
54 .icv_truncbits = 96,
55 .icv_fullbits = 128,
56 }
57 },
59 .desc = {
60 .sadb_alg_id = SADB_AALG_MD5HMAC,
61 .sadb_alg_ivlen = 0,
62 .sadb_alg_minbits = 128,
63 .sadb_alg_maxbits = 128
64 }
65 },
66 {
67 .name = "sha1",
69 .uinfo = {
70 .auth = {
71 .icv_truncbits = 96,
72 .icv_fullbits = 160,
73 }
74 },
76 .desc = {
77 .sadb_alg_id = SADB_AALG_SHA1HMAC,
78 .sadb_alg_ivlen = 0,
79 .sadb_alg_minbits = 160,
80 .sadb_alg_maxbits = 160
81 }
82 },
83 {
84 .name = "sha256",
86 .uinfo = {
87 .auth = {
88 .icv_truncbits = 96,
89 .icv_fullbits = 256,
90 }
91 },
93 .desc = {
94 .sadb_alg_id = SADB_X_AALG_SHA2_256HMAC,
95 .sadb_alg_ivlen = 0,
96 .sadb_alg_minbits = 256,
97 .sadb_alg_maxbits = 256
98 }
99 },
100 {
101 .name = "ripemd160",
103 .uinfo = {
104 .auth = {
105 .icv_truncbits = 96,
106 .icv_fullbits = 160,
107 }
108 },
110 .desc = {
111 .sadb_alg_id = SADB_X_AALG_RIPEMD160HMAC,
112 .sadb_alg_ivlen = 0,
113 .sadb_alg_minbits = 160,
114 .sadb_alg_maxbits = 160
115 }
116 },
117 };
119 static struct xfrm_algo_desc ealg_list[] = {
120 {
121 .name = "cipher_null",
123 .uinfo = {
124 .encr = {
125 .blockbits = 8,
126 .defkeybits = 0,
127 }
128 },
130 .desc = {
131 .sadb_alg_id = SADB_EALG_NULL,
132 .sadb_alg_ivlen = 0,
133 .sadb_alg_minbits = 0,
134 .sadb_alg_maxbits = 0
135 }
136 },
137 {
138 .name = "des",
140 .uinfo = {
141 .encr = {
142 .blockbits = 64,
143 .defkeybits = 64,
144 }
145 },
147 .desc = {
148 .sadb_alg_id = SADB_EALG_DESCBC,
149 .sadb_alg_ivlen = 8,
150 .sadb_alg_minbits = 64,
151 .sadb_alg_maxbits = 64
152 }
153 },
154 {
155 .name = "des3_ede",
157 .uinfo = {
158 .encr = {
159 .blockbits = 64,
160 .defkeybits = 192,
161 }
162 },
164 .desc = {
165 .sadb_alg_id = SADB_EALG_3DESCBC,
166 .sadb_alg_ivlen = 8,
167 .sadb_alg_minbits = 192,
168 .sadb_alg_maxbits = 192
169 }
170 },
171 {
172 .name = "cast128",
174 .uinfo = {
175 .encr = {
176 .blockbits = 64,
177 .defkeybits = 128,
178 }
179 },
181 .desc = {
182 .sadb_alg_id = SADB_X_EALG_CASTCBC,
183 .sadb_alg_ivlen = 8,
184 .sadb_alg_minbits = 40,
185 .sadb_alg_maxbits = 128
186 }
187 },
188 {
189 .name = "blowfish",
191 .uinfo = {
192 .encr = {
193 .blockbits = 64,
194 .defkeybits = 128,
195 }
196 },
198 .desc = {
199 .sadb_alg_id = SADB_X_EALG_BLOWFISHCBC,
200 .sadb_alg_ivlen = 8,
201 .sadb_alg_minbits = 40,
202 .sadb_alg_maxbits = 448
203 }
204 },
205 {
206 .name = "aes",
208 .uinfo = {
209 .encr = {
210 .blockbits = 128,
211 .defkeybits = 128,
212 }
213 },
215 .desc = {
216 .sadb_alg_id = SADB_X_EALG_AESCBC,
217 .sadb_alg_ivlen = 8,
218 .sadb_alg_minbits = 128,
219 .sadb_alg_maxbits = 256
220 }
221 },
222 {
223 .name = "serpent",
225 .uinfo = {
226 .encr = {
227 .blockbits = 128,
228 .defkeybits = 128,
229 }
230 },
232 .desc = {
233 .sadb_alg_id = SADB_X_EALG_SERPENTCBC,
234 .sadb_alg_ivlen = 8,
235 .sadb_alg_minbits = 128,
236 .sadb_alg_maxbits = 256,
237 }
238 },
239 {
240 .name = "twofish",
242 .uinfo = {
243 .encr = {
244 .blockbits = 128,
245 .defkeybits = 128,
246 }
247 },
249 .desc = {
250 .sadb_alg_id = SADB_X_EALG_TWOFISHCBC,
251 .sadb_alg_ivlen = 8,
252 .sadb_alg_minbits = 128,
253 .sadb_alg_maxbits = 256
254 }
255 },
256 };
258 static struct xfrm_algo_desc calg_list[] = {
259 {
260 .name = "deflate",
261 .uinfo = {
262 .comp = {
263 .threshold = 90,
264 }
265 },
266 .desc = { .sadb_alg_id = SADB_X_CALG_DEFLATE }
267 },
268 {
269 .name = "lzs",
270 .uinfo = {
271 .comp = {
272 .threshold = 90,
273 }
274 },
275 .desc = { .sadb_alg_id = SADB_X_CALG_LZS }
276 },
277 {
278 .name = "lzjh",
279 .uinfo = {
280 .comp = {
281 .threshold = 50,
282 }
283 },
284 .desc = { .sadb_alg_id = SADB_X_CALG_LZJH }
285 },
286 };
288 static inline int aalg_entries(void)
289 {
290 return ARRAY_SIZE(aalg_list);
291 }
293 static inline int ealg_entries(void)
294 {
295 return ARRAY_SIZE(ealg_list);
296 }
298 static inline int calg_entries(void)
299 {
300 return ARRAY_SIZE(calg_list);
301 }
303 /* Todo: generic iterators */
304 struct xfrm_algo_desc *xfrm_aalg_get_byid(int alg_id)
305 {
306 int i;
308 for (i = 0; i < aalg_entries(); i++) {
309 if (aalg_list[i].desc.sadb_alg_id == alg_id) {
310 if (aalg_list[i].available)
311 return &aalg_list[i];
312 else
313 break;
314 }
315 }
316 return NULL;
317 }
318 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byid);
320 struct xfrm_algo_desc *xfrm_ealg_get_byid(int alg_id)
321 {
322 int i;
324 for (i = 0; i < ealg_entries(); i++) {
325 if (ealg_list[i].desc.sadb_alg_id == alg_id) {
326 if (ealg_list[i].available)
327 return &ealg_list[i];
328 else
329 break;
330 }
331 }
332 return NULL;
333 }
334 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byid);
336 struct xfrm_algo_desc *xfrm_calg_get_byid(int alg_id)
337 {
338 int i;
340 for (i = 0; i < calg_entries(); i++) {
341 if (calg_list[i].desc.sadb_alg_id == alg_id) {
342 if (calg_list[i].available)
343 return &calg_list[i];
344 else
345 break;
346 }
347 }
348 return NULL;
349 }
350 EXPORT_SYMBOL_GPL(xfrm_calg_get_byid);
352 static struct xfrm_algo_desc *xfrm_get_byname(struct xfrm_algo_desc *list,
353 int entries, char *name,
354 int probe)
355 {
356 int i, status;
358 if (!name)
359 return NULL;
361 for (i = 0; i < entries; i++) {
362 if (strcmp(name, list[i].name))
363 continue;
365 if (list[i].available)
366 return &list[i];
368 if (!probe)
369 break;
371 status = crypto_alg_available(name, 0);
372 if (!status)
373 break;
375 list[i].available = status;
376 return &list[i];
377 }
378 return NULL;
379 }
381 struct xfrm_algo_desc *xfrm_aalg_get_byname(char *name, int probe)
382 {
383 return xfrm_get_byname(aalg_list, aalg_entries(), name, probe);
384 }
385 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byname);
387 struct xfrm_algo_desc *xfrm_ealg_get_byname(char *name, int probe)
388 {
389 return xfrm_get_byname(ealg_list, ealg_entries(), name, probe);
390 }
391 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byname);
393 struct xfrm_algo_desc *xfrm_calg_get_byname(char *name, int probe)
394 {
395 return xfrm_get_byname(calg_list, calg_entries(), name, probe);
396 }
397 EXPORT_SYMBOL_GPL(xfrm_calg_get_byname);
399 struct xfrm_algo_desc *xfrm_aalg_get_byidx(unsigned int idx)
400 {
401 if (idx >= aalg_entries())
402 return NULL;
404 return &aalg_list[idx];
405 }
406 EXPORT_SYMBOL_GPL(xfrm_aalg_get_byidx);
408 struct xfrm_algo_desc *xfrm_ealg_get_byidx(unsigned int idx)
409 {
410 if (idx >= ealg_entries())
411 return NULL;
413 return &ealg_list[idx];
414 }
415 EXPORT_SYMBOL_GPL(xfrm_ealg_get_byidx);
417 /*
418 * Probe for the availability of crypto algorithms, and set the available
419 * flag for any algorithms found on the system. This is typically called by
420 * pfkey during userspace SA add, update or register.
421 */
422 void xfrm_probe_algs(void)
423 {
424 #ifdef CONFIG_CRYPTO
425 int i, status;
427 BUG_ON(in_softirq());
429 for (i = 0; i < aalg_entries(); i++) {
430 status = crypto_alg_available(aalg_list[i].name, 0);
431 if (aalg_list[i].available != status)
432 aalg_list[i].available = status;
433 }
435 for (i = 0; i < ealg_entries(); i++) {
436 status = crypto_alg_available(ealg_list[i].name, 0);
437 if (ealg_list[i].available != status)
438 ealg_list[i].available = status;
439 }
441 for (i = 0; i < calg_entries(); i++) {
442 status = crypto_alg_available(calg_list[i].name, 0);
443 if (calg_list[i].available != status)
444 calg_list[i].available = status;
445 }
446 #endif
447 }
448 EXPORT_SYMBOL_GPL(xfrm_probe_algs);
450 int xfrm_count_auth_supported(void)
451 {
452 int i, n;
454 for (i = 0, n = 0; i < aalg_entries(); i++)
455 if (aalg_list[i].available)
456 n++;
457 return n;
458 }
459 EXPORT_SYMBOL_GPL(xfrm_count_auth_supported);
461 int xfrm_count_enc_supported(void)
462 {
463 int i, n;
465 for (i = 0, n = 0; i < ealg_entries(); i++)
466 if (ealg_list[i].available)
467 n++;
468 return n;
469 }
470 EXPORT_SYMBOL_GPL(xfrm_count_enc_supported);
472 /* Move to common area: it is shared with AH. */
474 void skb_icv_walk(const struct sk_buff *skb, struct crypto_tfm *tfm,
475 int offset, int len, icv_update_fn_t icv_update)
476 {
477 int start = skb_headlen(skb);
478 int i, copy = start - offset;
479 struct scatterlist sg;
481 /* Checksum header. */
482 if (copy > 0) {
483 if (copy > len)
484 copy = len;
486 sg.page = virt_to_page(skb->data + offset);
487 sg.offset = (unsigned long)(skb->data + offset) % PAGE_SIZE;
488 sg.length = copy;
490 icv_update(tfm, &sg, 1);
492 if ((len -= copy) == 0)
493 return;
494 offset += copy;
495 }
497 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
498 int end;
500 BUG_TRAP(start <= offset + len);
502 end = start + skb_shinfo(skb)->frags[i].size;
503 if ((copy = end - offset) > 0) {
504 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
506 if (copy > len)
507 copy = len;
509 sg.page = frag->page;
510 sg.offset = frag->page_offset + offset-start;
511 sg.length = copy;
513 icv_update(tfm, &sg, 1);
515 if (!(len -= copy))
516 return;
517 offset += copy;
518 }
519 start = end;
520 }
522 if (skb_shinfo(skb)->frag_list) {
523 struct sk_buff *list = skb_shinfo(skb)->frag_list;
525 for (; list; list = list->next) {
526 int end;
528 BUG_TRAP(start <= offset + len);
530 end = start + list->len;
531 if ((copy = end - offset) > 0) {
532 if (copy > len)
533 copy = len;
534 skb_icv_walk(list, tfm, offset-start, copy, icv_update);
535 if ((len -= copy) == 0)
536 return;
537 offset += copy;
538 }
539 start = end;
540 }
541 }
542 BUG_ON(len);
543 }
544 EXPORT_SYMBOL_GPL(skb_icv_walk);
546 #if defined(CONFIG_INET_ESP) || defined(CONFIG_INET_ESP_MODULE) || defined(CONFIG_INET6_ESP) || defined(CONFIG_INET6_ESP_MODULE)
548 /* Looking generic it is not used in another places. */
550 int
551 skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len)
552 {
553 int start = skb_headlen(skb);
554 int i, copy = start - offset;
555 int elt = 0;
557 if (copy > 0) {
558 if (copy > len)
559 copy = len;
560 sg[elt].page = virt_to_page(skb->data + offset);
561 sg[elt].offset = (unsigned long)(skb->data + offset) % PAGE_SIZE;
562 sg[elt].length = copy;
563 elt++;
564 if ((len -= copy) == 0)
565 return elt;
566 offset += copy;
567 }
569 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
570 int end;
572 BUG_TRAP(start <= offset + len);
574 end = start + skb_shinfo(skb)->frags[i].size;
575 if ((copy = end - offset) > 0) {
576 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
578 if (copy > len)
579 copy = len;
580 sg[elt].page = frag->page;
581 sg[elt].offset = frag->page_offset+offset-start;
582 sg[elt].length = copy;
583 elt++;
584 if (!(len -= copy))
585 return elt;
586 offset += copy;
587 }
588 start = end;
589 }
591 if (skb_shinfo(skb)->frag_list) {
592 struct sk_buff *list = skb_shinfo(skb)->frag_list;
594 for (; list; list = list->next) {
595 int end;
597 BUG_TRAP(start <= offset + len);
599 end = start + list->len;
600 if ((copy = end - offset) > 0) {
601 if (copy > len)
602 copy = len;
603 elt += skb_to_sgvec(list, sg+elt, offset - start, copy);
604 if ((len -= copy) == 0)
605 return elt;
606 offset += copy;
607 }
608 start = end;
609 }
610 }
611 BUG_ON(len);
612 return elt;
613 }
614 EXPORT_SYMBOL_GPL(skb_to_sgvec);
616 /* Check that skb data bits are writable. If they are not, copy data
617 * to newly created private area. If "tailbits" is given, make sure that
618 * tailbits bytes beyond current end of skb are writable.
619 *
620 * Returns amount of elements of scatterlist to load for subsequent
621 * transformations and pointer to writable trailer skb.
622 */
624 int skb_cow_data(struct sk_buff *skb, int tailbits, struct sk_buff **trailer)
625 {
626 int copyflag;
627 int elt;
628 struct sk_buff *skb1, **skb_p;
630 /* If skb is cloned or its head is paged, reallocate
631 * head pulling out all the pages (pages are considered not writable
632 * at the moment even if they are anonymous).
633 */
634 if ((skb_cloned(skb) || skb_shinfo(skb)->nr_frags) &&
635 __pskb_pull_tail(skb, skb_pagelen(skb)-skb_headlen(skb)) == NULL)
636 return -ENOMEM;
638 /* Easy case. Most of packets will go this way. */
639 if (!skb_shinfo(skb)->frag_list) {
640 /* A little of trouble, not enough of space for trailer.
641 * This should not happen, when stack is tuned to generate
642 * good frames. OK, on miss we reallocate and reserve even more
643 * space, 128 bytes is fair. */
645 if (skb_tailroom(skb) < tailbits &&
646 pskb_expand_head(skb, 0, tailbits-skb_tailroom(skb)+128, GFP_ATOMIC))
647 return -ENOMEM;
649 /* Voila! */
650 *trailer = skb;
651 return 1;
652 }
654 /* Misery. We are in troubles, going to mincer fragments... */
656 elt = 1;
657 skb_p = &skb_shinfo(skb)->frag_list;
658 copyflag = 0;
660 while ((skb1 = *skb_p) != NULL) {
661 int ntail = 0;
663 /* The fragment is partially pulled by someone,
664 * this can happen on input. Copy it and everything
665 * after it. */
667 if (skb_shared(skb1))
668 copyflag = 1;
670 /* If the skb is the last, worry about trailer. */
672 if (skb1->next == NULL && tailbits) {
673 if (skb_shinfo(skb1)->nr_frags ||
674 skb_shinfo(skb1)->frag_list ||
675 skb_tailroom(skb1) < tailbits)
676 ntail = tailbits + 128;
677 }
679 if (copyflag ||
680 skb_cloned(skb1) ||
681 ntail ||
682 skb_shinfo(skb1)->nr_frags ||
683 skb_shinfo(skb1)->frag_list) {
684 struct sk_buff *skb2;
686 /* Fuck, we are miserable poor guys... */
687 if (ntail == 0)
688 skb2 = skb_copy(skb1, GFP_ATOMIC);
689 else
690 skb2 = skb_copy_expand(skb1,
691 skb_headroom(skb1),
692 ntail,
693 GFP_ATOMIC);
694 if (unlikely(skb2 == NULL))
695 return -ENOMEM;
697 if (skb1->sk)
698 skb_set_owner_w(skb2, skb1->sk);
700 /* Looking around. Are we still alive?
701 * OK, link new skb, drop old one */
703 skb2->next = skb1->next;
704 *skb_p = skb2;
705 kfree_skb(skb1);
706 skb1 = skb2;
707 }
708 elt++;
709 *trailer = skb1;
710 skb_p = &skb1->next;
711 }
713 return elt;
714 }
715 EXPORT_SYMBOL_GPL(skb_cow_data);
717 void *pskb_put(struct sk_buff *skb, struct sk_buff *tail, int len)
718 {
719 if (tail != skb) {
720 skb->data_len += len;
721 skb->len += len;
722 }
723 return skb_put(tail, len);
724 }
725 EXPORT_SYMBOL_GPL(pskb_put);
726 #endif