/include/crypto/scatterwalk.h

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t · C Header · 138 lines · 101 code · 23 blank · 14 comment · 5 complexity · 0f085b5f6ae1351de68279c4d163e08d MD5 · raw file 

    

  1. /*
    2. 

  2.  * Cryptographic scatter and gather helpers.
    3. 

  3.  *
    4. 

  4.  * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
    5. 

  5.  * Copyright (c) 2002 Adam J. Richter <adam@yggdrasil.com>
    6. 

  6.  * Copyright (c) 2004 Jean-Luc Cooke <jlcooke@certainkey.com>
    7. 

  7.  * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au>
    8. 

  8.  *
    9. 

  9.  * This program is free software; you can redistribute it and/or modify it
    10. 

  10.  * under the terms of the GNU General Public License as published by the Free
    11. 

  11.  * Software Foundation; either version 2 of the License, or (at your option)
    12. 

  12.  * any later version.
    13. 

  13.  *
    14. 

  14.  */
    15. 

  15. 

  16. #ifndef _CRYPTO_SCATTERWALK_H
    17. 

  17. #define _CRYPTO_SCATTERWALK_H
    18. 

  18. 

  19. #include <asm/kmap_types.h>
    20. 

  20. #include <crypto/algapi.h>
    21. 

  21. #include <linux/hardirq.h>
    22. 

  22. #include <linux/highmem.h>
    23. 

  23. #include <linux/kernel.h>
    24. 

  24. #include <linux/mm.h>
    25. 

  25. #include <linux/scatterlist.h>
    26. 

  26. #include <linux/sched.h>
    27. 

  27. 

  28. static inline enum km_type crypto_kmap_type(int out)
    29. 

  29. {
    30. 

  30. 	enum km_type type;
    31. 

  31. 

  32. 	if (in_softirq())
    33. 

  33. 		type = out * (KM_SOFTIRQ1 - KM_SOFTIRQ0) + KM_SOFTIRQ0;
    34. 

  34. 	else
    35. 

  35. 		type = out * (KM_USER1 - KM_USER0) + KM_USER0;
    36. 

  36. 

  37. 	return type;
    38. 

  38. }
    39. 

  39. 

  40. static inline void *crypto_kmap(struct page *page, int out)
    41. 

  41. {
    42. 

  42. 	return kmap_atomic(page, crypto_kmap_type(out));
    43. 

  43. }
    44. 

  44. 

  45. static inline void crypto_kunmap(void *vaddr, int out)
    46. 

  46. {
    47. 

  47. 	kunmap_atomic(vaddr, crypto_kmap_type(out));
    48. 

  48. }
    49. 

  49. 

  50. static inline void crypto_yield(u32 flags)
    51. 

  51. {
    52. 

  52. 	if (flags & CRYPTO_TFM_REQ_MAY_SLEEP)
    53. 

  53. 		cond_resched();
    54. 

  54. }
    55. 

  55. 

  56. static inline void scatterwalk_sg_chain(struct scatterlist *sg1, int num,
    57. 

  57. 					struct scatterlist *sg2)
    58. 

  58. {
    59. 

  59. 	sg_set_page(&sg1[num - 1], (void *)sg2, 0, 0);
    60. 

  60. 	sg1[num - 1].page_link &= ~0x02;
    61. 

  61. }
    62. 

  62. 

  63. static inline struct scatterlist *scatterwalk_sg_next(struct scatterlist *sg)
    64. 

  64. {
    65. 

  65. 	if (sg_is_last(sg))
    66. 

  66. 		return NULL;
    67. 

  67. 

  68. 	return (++sg)->length ? sg : (void *)sg_page(sg);
    69. 

  69. }
    70. 

  70. 

  71. static inline void scatterwalk_crypto_chain(struct scatterlist *head,
    72. 

  72. 					    struct scatterlist *sg,
    73. 

  73. 					    int chain, int num)
    74. 

  74. {
    75. 

  75. 	if (chain) {
    76. 

  76. 		head->length += sg->length;
    77. 

  77. 		sg = scatterwalk_sg_next(sg);
    78. 

  78. 	}
    79. 

  79. 

  80. 	if (sg)
    81. 

  81. 		scatterwalk_sg_chain(head, num, sg);
    82. 

  82. 	else
    83. 

  83. 		sg_mark_end(head);
    84. 

  84. }
    85. 

  85. 

  86. static inline unsigned long scatterwalk_samebuf(struct scatter_walk *walk_in,
    87. 

  87. 						struct scatter_walk *walk_out)
    88. 

  88. {
    89. 

  89. 	return !(((sg_page(walk_in->sg) - sg_page(walk_out->sg)) << PAGE_SHIFT) +
    90. 

  90. 		 (int)(walk_in->offset - walk_out->offset));
    91. 

  91. }
    92. 

  92. 

  93. static inline unsigned int scatterwalk_pagelen(struct scatter_walk *walk)
    94. 

  94. {
    95. 

  95. 	unsigned int len = walk->sg->offset + walk->sg->length - walk->offset;
    96. 

  96. 	unsigned int len_this_page = offset_in_page(~walk->offset) + 1;
    97. 

  97. 	return len_this_page > len ? len : len_this_page;
    98. 

  98. }
    99. 

  99. 

  100. static inline unsigned int scatterwalk_clamp(struct scatter_walk *walk,
    101. 

  101. 					     unsigned int nbytes)
    102. 

  102. {
    103. 

  103. 	unsigned int len_this_page = scatterwalk_pagelen(walk);
    104. 

  104. 	return nbytes > len_this_page ? len_this_page : nbytes;
    105. 

  105. }
    106. 

  106. 

  107. static inline void scatterwalk_advance(struct scatter_walk *walk,
    108. 

  108. 				       unsigned int nbytes)
    109. 

  109. {
    110. 

  110. 	walk->offset += nbytes;
    111. 

  111. }
    112. 

  112. 

  113. static inline unsigned int scatterwalk_aligned(struct scatter_walk *walk,
    114. 

  114. 					       unsigned int alignmask)
    115. 

  115. {
    116. 

  116. 	return !(walk->offset & alignmask);
    117. 

  117. }
    118. 

  118. 

  119. static inline struct page *scatterwalk_page(struct scatter_walk *walk)
    120. 

  120. {
    121. 

  121. 	return sg_page(walk->sg) + (walk->offset >> PAGE_SHIFT);
    122. 

  122. }
    123. 

  123. 

  124. static inline void scatterwalk_unmap(void *vaddr, int out)
    125. 

  125. {
    126. 

  126. 	crypto_kunmap(vaddr, out);
    127. 

  127. }
    128. 

  128. 

  129. void scatterwalk_start(struct scatter_walk *walk, struct scatterlist *sg);
    130. 

  130. void scatterwalk_copychunks(void *buf, struct scatter_walk *walk,
    131. 

  131. 			    size_t nbytes, int out);
    132. 

  132. void *scatterwalk_map(struct scatter_walk *walk, int out);
    133. 

  133. void scatterwalk_done(struct scatter_walk *walk, int out, int more);
    134. 

  134. 

  135. void scatterwalk_map_and_copy(void *buf, struct scatterlist *sg,
    136. 

  136. 			      unsigned int start, unsigned int nbytes, int out);
    137. 

  137. 

  138. #endif  /* _CRYPTO_SCATTERWALK_H */
    139.