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 7ff5770..f37211d 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 9c8ef33..eb971e1 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 11404f8..4b6d8e1 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 9cc5798..1753c26 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 ab4f336..a43adea 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 424450e..a523883 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 207101a..d18458a 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 c88908f..ce3d4f6 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 ff34f40..4dd5edc 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;
                }