root/lib/sg_split.c

DEFINITIONS

1. sg_calculate_split
2. sg_split_phys
3. sg_split_mapped
4. sg_split

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