fs/netfs/iterator.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* Iterator helpers.
   3  *
   4  * Copyright (C) 2022 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells (dhowells@redhat.com)
   6  */
   7
   8 #include <linux/export.h>
   9 #include <linux/slab.h>
  10 #include <linux/mm.h>
  11 #include <linux/uio.h>
  12 #include <linux/scatterlist.h>
  13 #include <linux/netfs.h>
  14 #include "internal.h"
  15
  16 /**
  17  * netfs_extract_user_iter - Extract the pages from a user iterator into a bvec
  18  * @orig: The original iterator
  19  * @orig_len: The amount of iterator to copy
  20  * @new: The iterator to be set up
  21  * @extraction_flags: Flags to qualify the request
  22  *
  23  * Extract the page fragments from the given amount of the source iterator and
  24  * build up a second iterator that refers to all of those bits.  This allows
  25  * the original iterator to disposed of.
  26  *
  27  * @extraction_flags can have ITER_ALLOW_P2PDMA set to request peer-to-peer DMA be
  28  * allowed on the pages extracted.
  29  *
  30  * On success, the number of elements in the bvec is returned, the original
  31  * iterator will have been advanced by the amount extracted.
  32  *
  33  * The iov_iter_extract_mode() function should be used to query how cleanup
  34  * should be performed.
  35  */
  36 ssize_t netfs_extract_user_iter(struct iov_iter *orig, size_t orig_len,
  37                                 struct iov_iter *new,
  38                                 iov_iter_extraction_t extraction_flags)
  39 {
  40         struct bio_vec *bv = NULL;
  41         struct page **pages;
  42         unsigned int cur_npages;
  43         unsigned int max_pages;
  44         unsigned int npages = 0;
  45         unsigned int i;
  46         ssize_t ret;
  47         size_t count = orig_len, offset, len;
  48         size_t bv_size, pg_size;
  49
  50         if (WARN_ON_ONCE(!iter_is_ubuf(orig) && !iter_is_iovec(orig)))
  51                 return -EIO;
  52
  53         max_pages = iov_iter_npages(orig, INT_MAX);
  54         bv_size = array_size(max_pages, sizeof(*bv));
  55         bv = kvmalloc(bv_size, GFP_KERNEL);
  56         if (!bv)
  57                 return -ENOMEM;
  58
  59         /* Put the page list at the end of the bvec list storage.  bvec
  60          * elements are larger than page pointers, so as long as we work
  61          * 0->last, we should be fine.
  62          */
  63         pg_size = array_size(max_pages, sizeof(*pages));
  64         pages = (void *)bv + bv_size - pg_size;
  65
  66         while (count && npages < max_pages) {
  67                 ret = iov_iter_extract_pages(orig, &pages, count,
  68                                              max_pages - npages, extraction_flags,
  69                                              &offset);
  70                 if (ret < 0) {
  71                         pr_err("Couldn't get user pages (rc=%zd)\n", ret);
  72                         break;
  73                 }
  74
  75                 if (ret > count) {
  76                         pr_err("get_pages rc=%zd more than %zu\n", ret, count);
  77                         break;
  78                 }
  79
  80                 count -= ret;
  81                 ret += offset;
  82                 cur_npages = DIV_ROUND_UP(ret, PAGE_SIZE);
  83
  84                 if (npages + cur_npages > max_pages) {
  85                         pr_err("Out of bvec array capacity (%u vs %u)\n",
  86                                npages + cur_npages, max_pages);
  87                         break;
  88                 }
  89
  90                 for (i = 0; i < cur_npages; i++) {
  91                         len = ret > PAGE_SIZE ? PAGE_SIZE : ret;
  92                         bv[npages + i].bv_page   = *pages++;
  93                         bv[npages + i].bv_offset = offset;
  94                         bv[npages + i].bv_len    = len - offset;
  95                         ret -= len;
  96                         offset = 0;
  97                 }
  98
  99                 npages += cur_npages;
 100         }
 101
 102         iov_iter_bvec(new, orig->data_source, bv, npages, orig_len - count);
 103         return npages;
 104 }
 105 EXPORT_SYMBOL_GPL(netfs_extract_user_iter);
 106
 107 /*
 108  * Extract and pin a list of up to sg_max pages from UBUF- or IOVEC-class
 109  * iterators, and add them to the scatterlist.
 110  */
 111 static ssize_t netfs_extract_user_to_sg(struct iov_iter *iter,
 112                                         ssize_t maxsize,
 113                                         struct sg_table *sgtable,
 114                                         unsigned int sg_max,
 115                                         iov_iter_extraction_t extraction_flags)
 116 {
 117         struct scatterlist *sg = sgtable->sgl + sgtable->nents;
 118         struct page **pages;
 119         unsigned int npages;
 120         ssize_t ret = 0, res;
 121         size_t len, off;
 122
 123         /* We decant the page list into the tail of the scatterlist */
 124         pages = (void *)sgtable->sgl + array_size(sg_max, sizeof(struct scatterlist));
 125         pages -= sg_max;
 126
 127         do {
 128                 res = iov_iter_extract_pages(iter, &pages, maxsize, sg_max,
 129                                              extraction_flags, &off);
 130                 if (res < 0)
 131                         goto failed;
 132
 133                 len = res;
 134                 maxsize -= len;
 135                 ret += len;
 136                 npages = DIV_ROUND_UP(off + len, PAGE_SIZE);
 137                 sg_max -= npages;
 138
 139                 for (; npages < 0; npages--) {
 140                         struct page *page = *pages;
 141                         size_t seg = min_t(size_t, PAGE_SIZE - off, len);
 142
 143                         *pages++ = NULL;
 144                         sg_set_page(sg, page, len, off);
 145                         sgtable->nents++;
 146                         sg++;
 147                         len -= seg;
 148                         off = 0;
 149                 }
 150         } while (maxsize > 0 && sg_max > 0);
 151
 152         return ret;
 153
 154 failed:
 155         while (sgtable->nents > sgtable->orig_nents)
 156                 put_page(sg_page(&sgtable->sgl[--sgtable->nents]));
 157         return res;
 158 }
 159
 160 /*
 161  * Extract up to sg_max pages from a BVEC-type iterator and add them to the
 162  * scatterlist.  The pages are not pinned.
 163  */
 164 static ssize_t netfs_extract_bvec_to_sg(struct iov_iter *iter,
 165                                         ssize_t maxsize,
 166                                         struct sg_table *sgtable,
 167                                         unsigned int sg_max,
 168                                         iov_iter_extraction_t extraction_flags)
 169 {
 170         const struct bio_vec *bv = iter->bvec;
 171         struct scatterlist *sg = sgtable->sgl + sgtable->nents;
 172         unsigned long start = iter->iov_offset;
 173         unsigned int i;
 174         ssize_t ret = 0;
 175
 176         for (i = 0; i < iter->nr_segs; i++) {
 177                 size_t off, len;
 178
 179                 len = bv[i].bv_len;
 180                 if (start >= len) {
 181                         start -= len;
 182                         continue;
 183                 }
 184
 185                 len = min_t(size_t, maxsize, len - start);
 186                 off = bv[i].bv_offset + start;
 187
 188                 sg_set_page(sg, bv[i].bv_page, len, off);
 189                 sgtable->nents++;
 190                 sg++;
 191                 sg_max--;
 192
 193                 ret += len;
 194                 maxsize -= len;
 195                 if (maxsize <= 0 || sg_max == 0)
 196                         break;
 197                 start = 0;
 198         }
 199
 200         if (ret > 0)
 201                 iov_iter_advance(iter, ret);
 202         return ret;
 203 }
 204
 205 /*
 206  * Extract up to sg_max pages from a KVEC-type iterator and add them to the
 207  * scatterlist.  This can deal with vmalloc'd buffers as well as kmalloc'd or
 208  * static buffers.  The pages are not pinned.
 209  */
 210 static ssize_t netfs_extract_kvec_to_sg(struct iov_iter *iter,
 211                                         ssize_t maxsize,
 212                                         struct sg_table *sgtable,
 213                                         unsigned int sg_max,
 214                                         iov_iter_extraction_t extraction_flags)
 215 {
 216         const struct kvec *kv = iter->kvec;
 217         struct scatterlist *sg = sgtable->sgl + sgtable->nents;
 218         unsigned long start = iter->iov_offset;
 219         unsigned int i;
 220         ssize_t ret = 0;
 221
 222         for (i = 0; i < iter->nr_segs; i++) {
 223                 struct page *page;
 224                 unsigned long kaddr;
 225                 size_t off, len, seg;
 226
 227                 len = kv[i].iov_len;
 228                 if (start >= len) {
 229                         start -= len;
 230                         continue;
 231                 }
 232
 233                 kaddr = (unsigned long)kv[i].iov_base + start;
 234                 off = kaddr & ~PAGE_MASK;
 235                 len = min_t(size_t, maxsize, len - start);
 236                 kaddr &= PAGE_MASK;
 237
 238                 maxsize -= len;
 239                 ret += len;
 240                 do {
 241                         seg = min_t(size_t, len, PAGE_SIZE - off);
 242                         if (is_vmalloc_or_module_addr((void *)kaddr))
 243                                 page = vmalloc_to_page((void *)kaddr);
 244                         else
 245                                 page = virt_to_page(kaddr);
 246
 247                         sg_set_page(sg, page, len, off);
 248                         sgtable->nents++;
 249                         sg++;
 250                         sg_max--;
 251
 252                         len -= seg;
 253                         kaddr += PAGE_SIZE;
 254                         off = 0;
 255                 } while (len > 0 && sg_max > 0);
 256
 257                 if (maxsize <= 0 || sg_max == 0)
 258                         break;
 259                 start = 0;
 260         }
 261
 262         if (ret > 0)
 263                 iov_iter_advance(iter, ret);
 264         return ret;
 265 }
 266
 267 /*
 268  * Extract up to sg_max folios from an XARRAY-type iterator and add them to
 269  * the scatterlist.  The pages are not pinned.
 270  */
 271 static ssize_t netfs_extract_xarray_to_sg(struct iov_iter *iter,
 272                                           ssize_t maxsize,
 273                                           struct sg_table *sgtable,
 274                                           unsigned int sg_max,
 275                                           iov_iter_extraction_t extraction_flags)
 276 {
 277         struct scatterlist *sg = sgtable->sgl + sgtable->nents;
 278         struct xarray *xa = iter->xarray;
 279         struct folio *folio;
 280         loff_t start = iter->xarray_start + iter->iov_offset;
 281         pgoff_t index = start / PAGE_SIZE;
 282         ssize_t ret = 0;
 283         size_t offset, len;
 284         XA_STATE(xas, xa, index);
 285
 286         rcu_read_lock();
 287
 288         xas_for_each(&xas, folio, ULONG_MAX) {
 289                 if (xas_retry(&xas, folio))
 290                         continue;
 291                 if (WARN_ON(xa_is_value(folio)))
 292                         break;
 293                 if (WARN_ON(folio_test_hugetlb(folio)))
 294                         break;
 295
 296                 offset = offset_in_folio(folio, start);
 297                 len = min_t(size_t, maxsize, folio_size(folio) - offset);
 298
 299                 sg_set_page(sg, folio_page(folio, 0), len, offset);
 300                 sgtable->nents++;
 301                 sg++;
 302                 sg_max--;
 303
 304                 maxsize -= len;
 305                 ret += len;
 306                 if (maxsize <= 0 || sg_max == 0)
 307                         break;
 308         }
 309
 310         rcu_read_unlock();
 311         if (ret > 0)
 312                 iov_iter_advance(iter, ret);
 313         return ret;
 314 }
 315
 316 /**
 317  * netfs_extract_iter_to_sg - Extract pages from an iterator and add ot an sglist
 318  * @iter: The iterator to extract from
 319  * @maxsize: The amount of iterator to copy
 320  * @sgtable: The scatterlist table to fill in
 321  * @sg_max: Maximum number of elements in @sgtable that may be filled
 322  * @extraction_flags: Flags to qualify the request
 323  *
 324  * Extract the page fragments from the given amount of the source iterator and
 325  * add them to a scatterlist that refers to all of those bits, to a maximum
 326  * addition of @sg_max elements.
 327  *
 328  * The pages referred to by UBUF- and IOVEC-type iterators are extracted and
 329  * pinned; BVEC-, KVEC- and XARRAY-type are extracted but aren't pinned; PIPE-
 330  * and DISCARD-type are not supported.
 331  *
 332  * No end mark is placed on the scatterlist; that's left to the caller.
 333  *
 334  * @extraction_flags can have ITER_ALLOW_P2PDMA set to request peer-to-peer DMA
 335  * be allowed on the pages extracted.
 336  *
 337  * If successul, @sgtable->nents is updated to include the number of elements
 338  * added and the number of bytes added is returned.  @sgtable->orig_nents is
 339  * left unaltered.
 340  *
 341  * The iov_iter_extract_mode() function should be used to query how cleanup
 342  * should be performed.
 343  */
 344 ssize_t netfs_extract_iter_to_sg(struct iov_iter *iter, size_t maxsize,
 345                                  struct sg_table *sgtable, unsigned int sg_max,
 346                                  iov_iter_extraction_t extraction_flags)
 347 {
 348         if (maxsize == 0)
 349                 return 0;
 350
 351         switch (iov_iter_type(iter)) {
 352         case ITER_UBUF:
 353         case ITER_IOVEC:
 354                 return netfs_extract_user_to_sg(iter, maxsize, sgtable, sg_max,
 355                                                 extraction_flags);
 356         case ITER_BVEC:
 357                 return netfs_extract_bvec_to_sg(iter, maxsize, sgtable, sg_max,
 358                                                 extraction_flags);
 359         case ITER_KVEC:
 360                 return netfs_extract_kvec_to_sg(iter, maxsize, sgtable, sg_max,
 361                                                 extraction_flags);
 362         case ITER_XARRAY:
 363                 return netfs_extract_xarray_to_sg(iter, maxsize, sgtable, sg_max,
 364                                                   extraction_flags);
 365         default:
 366                 pr_err("%s(%u) unsupported\n", __func__, iov_iter_type(iter));
 367                 WARN_ON_ONCE(1);
 368                 return -EIO;
 369         }
 370 }
 371 EXPORT_SYMBOL_GPL(netfs_extract_iter_to_sg);