sg_split.c 5.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (C) 2015 Robert Jarzmik <robert.jarzmik@free.fr>
  4. *
  5. * Scatterlist splitting helpers.
  6. */
  7. #include <linux/scatterlist.h>
  8. #include <linux/slab.h>
  9. struct sg_splitter {
  10. struct scatterlist *in_sg0;
  11. int nents;
  12. off_t skip_sg0;
  13. unsigned int length_last_sg;
  14. struct scatterlist *out_sg;
  15. };
  16. static int sg_calculate_split(struct scatterlist *in, int nents, int nb_splits,
  17. off_t skip, const size_t *sizes,
  18. struct sg_splitter *splitters, bool mapped)
  19. {
  20. int i;
  21. unsigned int sglen;
  22. size_t size = sizes[0], len;
  23. struct sg_splitter *curr = splitters;
  24. struct scatterlist *sg;
  25. for (i = 0; i < nb_splits; i++) {
  26. splitters[i].in_sg0 = NULL;
  27. splitters[i].nents = 0;
  28. }
  29. for_each_sg(in, sg, nents, i) {
  30. sglen = mapped ? sg_dma_len(sg) : sg->length;
  31. if (skip > sglen) {
  32. skip -= sglen;
  33. continue;
  34. }
  35. len = min_t(size_t, size, sglen - skip);
  36. if (!curr->in_sg0) {
  37. curr->in_sg0 = sg;
  38. curr->skip_sg0 = skip;
  39. }
  40. size -= len;
  41. curr->nents++;
  42. curr->length_last_sg = len;
  43. while (!size && (skip + len < sglen) && (--nb_splits > 0)) {
  44. curr++;
  45. size = *(++sizes);
  46. skip += len;
  47. len = min_t(size_t, size, sglen - skip);
  48. curr->in_sg0 = sg;
  49. curr->skip_sg0 = skip;
  50. curr->nents = 1;
  51. curr->length_last_sg = len;
  52. size -= len;
  53. }
  54. skip = 0;
  55. if (!size && --nb_splits > 0) {
  56. curr++;
  57. size = *(++sizes);
  58. }
  59. if (!nb_splits)
  60. break;
  61. }
  62. return (size || !splitters[0].in_sg0) ? -EINVAL : 0;
  63. }
  64. static void sg_split_phys(struct sg_splitter *splitters, const int nb_splits)
  65. {
  66. int i, j;
  67. struct scatterlist *in_sg, *out_sg;
  68. struct sg_splitter *split;
  69. for (i = 0, split = splitters; i < nb_splits; i++, split++) {
  70. in_sg = split->in_sg0;
  71. out_sg = split->out_sg;
  72. for (j = 0; j < split->nents; j++, out_sg++) {
  73. *out_sg = *in_sg;
  74. if (!j) {
  75. out_sg->offset += split->skip_sg0;
  76. out_sg->length -= split->skip_sg0;
  77. } else {
  78. out_sg->offset = 0;
  79. }
  80. sg_dma_address(out_sg) = 0;
  81. sg_dma_len(out_sg) = 0;
  82. in_sg = sg_next(in_sg);
  83. }
  84. out_sg[-1].length = split->length_last_sg;
  85. sg_mark_end(out_sg - 1);
  86. }
  87. }
  88. static void sg_split_mapped(struct sg_splitter *splitters, const int nb_splits)
  89. {
  90. int i, j;
  91. struct scatterlist *in_sg, *out_sg;
  92. struct sg_splitter *split;
  93. for (i = 0, split = splitters; i < nb_splits; i++, split++) {
  94. in_sg = split->in_sg0;
  95. out_sg = split->out_sg;
  96. for (j = 0; j < split->nents; j++, out_sg++) {
  97. sg_dma_address(out_sg) = sg_dma_address(in_sg);
  98. sg_dma_len(out_sg) = sg_dma_len(in_sg);
  99. if (!j) {
  100. sg_dma_address(out_sg) += split->skip_sg0;
  101. sg_dma_len(out_sg) -= split->skip_sg0;
  102. }
  103. in_sg = sg_next(in_sg);
  104. }
  105. sg_dma_len(--out_sg) = split->length_last_sg;
  106. }
  107. }
  108. /**
  109. * sg_split - split a scatterlist into several scatterlists
  110. * @in: the input sg list
  111. * @in_mapped_nents: the result of a dma_map_sg(in, ...), or 0 if not mapped.
  112. * @skip: the number of bytes to skip in the input sg list
  113. * @nb_splits: the number of desired sg outputs
  114. * @split_sizes: the respective size of each output sg list in bytes
  115. * @out: an array where to store the allocated output sg lists
  116. * @out_mapped_nents: the resulting sg lists mapped number of sg entries. Might
  117. * be NULL if sglist not already mapped (in_mapped_nents = 0)
  118. * @gfp_mask: the allocation flag
  119. *
  120. * This function splits the input sg list into nb_splits sg lists, which are
  121. * allocated and stored into out.
  122. * The @in is split into :
  123. * - @out[0], which covers bytes [@skip .. @skip + @split_sizes[0] - 1] of @in
  124. * - @out[1], which covers bytes [@skip + split_sizes[0] ..
  125. * @skip + @split_sizes[0] + @split_sizes[1] -1]
  126. * etc ...
  127. * It will be the caller's duty to kfree() out array members.
  128. *
  129. * Returns 0 upon success, or error code
  130. */
  131. int sg_split(struct scatterlist *in, const int in_mapped_nents,
  132. const off_t skip, const int nb_splits,
  133. const size_t *split_sizes,
  134. struct scatterlist **out, int *out_mapped_nents,
  135. gfp_t gfp_mask)
  136. {
  137. int i, ret;
  138. struct sg_splitter *splitters;
  139. splitters = kcalloc(nb_splits, sizeof(*splitters), gfp_mask);
  140. if (!splitters)
  141. return -ENOMEM;
  142. ret = sg_calculate_split(in, sg_nents(in), nb_splits, skip, split_sizes,
  143. splitters, false);
  144. if (ret < 0)
  145. goto err;
  146. ret = -ENOMEM;
  147. for (i = 0; i < nb_splits; i++) {
  148. splitters[i].out_sg = kmalloc_array(splitters[i].nents,
  149. sizeof(struct scatterlist),
  150. gfp_mask);
  151. if (!splitters[i].out_sg)
  152. goto err;
  153. }
  154. /*
  155. * The order of these 3 calls is important and should be kept.
  156. */
  157. sg_split_phys(splitters, nb_splits);
  158. if (in_mapped_nents) {
  159. ret = sg_calculate_split(in, in_mapped_nents, nb_splits, skip,
  160. split_sizes, splitters, true);
  161. if (ret < 0)
  162. goto err;
  163. sg_split_mapped(splitters, nb_splits);
  164. }
  165. for (i = 0; i < nb_splits; i++) {
  166. out[i] = splitters[i].out_sg;
  167. if (out_mapped_nents)
  168. out_mapped_nents[i] = splitters[i].nents;
  169. }
  170. kfree(splitters);
  171. return 0;
  172. err:
  173. for (i = 0; i < nb_splits; i++)
  174. kfree(splitters[i].out_sg);
  175. kfree(splitters);
  176. return ret;
  177. }
  178. EXPORT_SYMBOL(sg_split);