iov_iter: Turn iov_iter_fault_in_readable into fault_in_iov_iter_readable

Turn iov_iter_fault_in_readable into a function that returns the number
of bytes not faulted in, similar to copy_to_user, instead of returning a
non-zero value when any of the requested pages couldn't be faulted in.
This supports the existing users that require all pages to be faulted in
as well as new users that are happy if any pages can be faulted in.

Rename iov_iter_fault_in_readable to fault_in_iov_iter_readable to make
sure this change doesn't silently break things.

Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 7ff577005d0febbf6be14c21a2d1c81f3e600c50..f37211d3bb69e4cc7b7ac0a1e3fe978370a3b590 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1710,7 +1710,7 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,
                 * Fault pages before locking them in prepare_pages
                 * to avoid recursive lock
                 */
-               if (unlikely(iov_iter_fault_in_readable(i, write_bytes))) {
+               if (unlikely(fault_in_iov_iter_readable(i, write_bytes))) {
                        ret = -EFAULT;
                        break;
                }

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 9c8ef33bd8d32fe39610d4fd4cd3e5acc44b9345..eb971e1e7227683c7b22118099b9a902c5056ae4 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -4276,7 +4276,7 @@ static ssize_t f2fs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
                size_t target_size = 0;
                int err;
 
-               if (iov_iter_fault_in_readable(from, iov_iter_count(from)))
+               if (fault_in_iov_iter_readable(from, iov_iter_count(from)))
                        set_inode_flag(inode, FI_NO_PREALLOC);
 
                if ((iocb->ki_flags & IOCB_NOWAIT)) {

diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 11404f8c21c75ff193ae487f151cb6762d07742b..4b6d8e13322d686e478be5b4c65f842c8f8cf7c6 100644 (file)
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -1164,7 +1164,7 @@ static ssize_t fuse_fill_write_pages(struct fuse_io_args *ia,
 
  again:
                err = -EFAULT;
-               if (iov_iter_fault_in_readable(ii, bytes))
+               if (fault_in_iov_iter_readable(ii, bytes))
                        break;
 
                err = -ENOMEM;

diff --git a/fs/iomap/buffered-io.c b/fs/iomap/buffered-io.c
index 9cc5798423d12174fe2a1826345ab332740821d2..1753c26c8e76e300ff59c296d2b6b88d2b968db4 100644 (file)
--- a/fs/iomap/buffered-io.c
+++ b/fs/iomap/buffered-io.c
@@ -750,7 +750,7 @@ again:
                 * same page as we're writing to, without it being marked
                 * up-to-date.
                 */
-               if (unlikely(iov_iter_fault_in_readable(i, bytes))) {
+               if (unlikely(fault_in_iov_iter_readable(i, bytes))) {
                        status = -EFAULT;
                        break;
                }

diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index ab4f3362466d068d06c76497b68c70ed5481245f..a43adeacd930c8c7af47381e5c15f1b16385f4ec 100644 (file)
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -1829,7 +1829,7 @@ again:
                 * pages being swapped out between us bringing them into memory
                 * and doing the actual copying.
                 */
-               if (unlikely(iov_iter_fault_in_readable(i, bytes))) {
+               if (unlikely(fault_in_iov_iter_readable(i, bytes))) {
                        status = -EFAULT;
                        break;
                }

diff --git a/fs/ntfs3/file.c b/fs/ntfs3/file.c
index 424450e77ad52ae550e8de444dc393411d97cde6..a52388387175ac6ed8bfa31ee1af0c78455582be 100644 (file)
--- a/fs/ntfs3/file.c
+++ b/fs/ntfs3/file.c
@@ -987,7 +987,7 @@ static ssize_t ntfs_compress_write(struct kiocb *iocb, struct iov_iter *from)
                frame_vbo = pos & ~(frame_size - 1);
                index = frame_vbo >> PAGE_SHIFT;
 
-               if (unlikely(iov_iter_fault_in_readable(from, bytes))) {
+               if (unlikely(fault_in_iov_iter_readable(from, bytes))) {
                        err = -EFAULT;
                        goto out;
                }

diff --git a/include/linux/uio.h b/include/linux/uio.h
index 207101a9c5c326958eaae5b4be2208f0b6e2028e..d18458af6681f2bc6211b575e5b4b127068c2746 100644 (file)
--- a/include/linux/uio.h
+++ b/include/linux/uio.h
@@ -133,7 +133,7 @@ size_t copy_page_from_iter_atomic(struct page *page, unsigned offset,
                                  size_t bytes, struct iov_iter *i);
 void iov_iter_advance(struct iov_iter *i, size_t bytes);
 void iov_iter_revert(struct iov_iter *i, size_t bytes);
-int iov_iter_fault_in_readable(const struct iov_iter *i, size_t bytes);
+size_t fault_in_iov_iter_readable(const struct iov_iter *i, size_t bytes);
 size_t iov_iter_single_seg_count(const struct iov_iter *i);
 size_t copy_page_to_iter(struct page *page, size_t offset, size_t bytes,
                         struct iov_iter *i);

diff --git a/lib/iov_iter.c b/lib/iov_iter.c
index c88908f0f13824bf188586808e830b71d34f0704..ce3d4f61062624872b71648a7c0aef89e8ff0d47 100644 (file)
--- a/lib/iov_iter.c
+++ b/lib/iov_iter.c
@@ -430,33 +430,42 @@ out:
 }
 
 /*
+ * fault_in_iov_iter_readable - fault in iov iterator for reading
+ * @i: iterator
+ * @size: maximum length
+ *
  * Fault in one or more iovecs of the given iov_iter, to a maximum length of
- * bytes.  For each iovec, fault in each page that constitutes the iovec.
+ * @size.  For each iovec, fault in each page that constitutes the iovec.
+ *
+ * Returns the number of bytes not faulted in (like copy_to_user() and
+ * copy_from_user()).
  *
- * Return 0 on success, or non-zero if the memory could not be accessed (i.e.
- * because it is an invalid address).
+ * Always returns 0 for non-userspace iterators.
  */
-int iov_iter_fault_in_readable(const struct iov_iter *i, size_t bytes)
+size_t fault_in_iov_iter_readable(const struct iov_iter *i, size_t size)
 {
        if (iter_is_iovec(i)) {
+               size_t count = min(size, iov_iter_count(i));
                const struct iovec *p;
                size_t skip;
 
-               if (bytes > i->count)
-                       bytes = i->count;
-               for (p = i->iov, skip = i->iov_offset; bytes; p++, skip = 0) {
-                       size_t len = min(bytes, p->iov_len - skip);
+               size -= count;
+               for (p = i->iov, skip = i->iov_offset; count; p++, skip = 0) {
+                       size_t len = min(count, p->iov_len - skip);
+                       size_t ret;
 
                        if (unlikely(!len))
                                continue;
-                       if (fault_in_readable(p->iov_base + skip, len))
-                               return -EFAULT;
-                       bytes -= len;
+                       ret = fault_in_readable(p->iov_base + skip, len);
+                       count -= len - ret;
+                       if (ret)
+                               break;
                }
+               return count + size;
        }
        return 0;
 }
-EXPORT_SYMBOL(iov_iter_fault_in_readable);
+EXPORT_SYMBOL(fault_in_iov_iter_readable);
 
 void iov_iter_init(struct iov_iter *i, unsigned int direction,
                        const struct iovec *iov, unsigned long nr_segs,

diff --git a/mm/filemap.c b/mm/filemap.c
index ff34f4087f87aa38cf6ab28fcc5a21976d52137f..4dd5edcd39fda2084f6446191115c4c8b4211e0d 100644 (file)
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -3757,7 +3757,7 @@ again:
                 * same page as we're writing to, without it being marked
                 * up-to-date.
                 */
-               if (unlikely(iov_iter_fault_in_readable(i, bytes))) {
+               if (unlikely(fault_in_iov_iter_readable(i, bytes))) {
                        status = -EFAULT;
                        break;
                }