Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs

Pull vfs updates from Al Viro:
 "The big thing in this pile is Eric's unmount-on-rmdir series; we
  finally have everything we need for that.  The final piece of prereqs
  is delayed mntput() - now filesystem shutdown always happens on
  shallow stack.

  Other than that, we have several new primitives for iov_iter (Matt
  Wilcox, culled from his XIP-related series) pushing the conversion to
  ->read_iter()/ ->write_iter() a bit more, a bunch of fs/dcache.c
  cleanups and fixes (including the external name refcounting, which
  gives consistent behaviour of d_move() wrt procfs symlinks for long
  and short names alike) and assorted cleanups and fixes all over the
  place.

  This is just the first pile; there's a lot of stuff from various
  people that ought to go in this window.  Starting with
  unionmount/overlayfs mess...  ;-/"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs: (60 commits)
  fs/file_table.c: Update alloc_file() comment
  vfs: Deduplicate code shared by xattr system calls operating on paths
  reiserfs: remove pointless forward declaration of struct nameidata
  don't need that forward declaration of struct nameidata in dcache.h anymore
  take dname_external() into fs/dcache.c
  let path_init() failures treated the same way as subsequent link_path_walk()
  fix misuses of f_count() in ppp and netlink
  ncpfs: use list_for_each_entry() for d_subdirs walk
  vfs: move getname() from callers to do_mount()
  gfs2_atomic_open(): skip lookups on hashed dentry
  [infiniband] remove pointless assignments
  gadgetfs: saner API for gadgetfs_create_file()
  f_fs: saner API for ffs_sb_create_file()
  jfs: don't hash direct inode
  [s390] remove pointless assignment of ->f_op in vmlogrdr ->open()
  ecryptfs: ->f_op is never NULL
  android: ->f_op is never NULL
  nouveau: __iomem misannotations
  missing annotation in fs/file.c
  fs: namespace: suppress 'may be used uninitialized' warnings
  ...

1 files changed, 226 insertions, 14 deletions

diff --git a/mm/iov_iter.c b/mm/iov_iter.c
index 9a09f2034fcc..eafcf60f6b83 100644
--- a/mm/iov_iter.c
+++ b/mm/iov_iter.c
@@ -4,6 +4,96 @@
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
 
+static size_t copy_to_iter_iovec(void *from, size_t bytes, struct iov_iter *i)
+{
+        size_t skip, copy, left, wanted;
+        const struct iovec *iov;
+        char __user *buf;
+
+        if (unlikely(bytes > i->count))
+                bytes = i->count;
+
+        if (unlikely(!bytes))
+                return 0;
+
+        wanted = bytes;
+        iov = i->iov;
+        skip = i->iov_offset;
+        buf = iov->iov_base + skip;
+        copy = min(bytes, iov->iov_len - skip);
+
+        left = __copy_to_user(buf, from, copy);
+        copy -= left;
+        skip += copy;
+        from += copy;
+        bytes -= copy;
+        while (unlikely(!left && bytes)) {
+                iov++;
+                buf = iov->iov_base;
+                copy = min(bytes, iov->iov_len);
+                left = __copy_to_user(buf, from, copy);
+                copy -= left;
+                skip = copy;
+                from += copy;
+                bytes -= copy;
+        }
+
+        if (skip == iov->iov_len) {
+                iov++;
+                skip = 0;
+        }
+        i->count -= wanted - bytes;
+        i->nr_segs -= iov - i->iov;
+        i->iov = iov;
+        i->iov_offset = skip;
+        return wanted - bytes;
+}
+
+static size_t copy_from_iter_iovec(void *to, size_t bytes, struct iov_iter *i)
+{
+        size_t skip, copy, left, wanted;
+        const struct iovec *iov;
+        char __user *buf;
+
+        if (unlikely(bytes > i->count))
+                bytes = i->count;
+
+        if (unlikely(!bytes))
+                return 0;
+
+        wanted = bytes;
+        iov = i->iov;
+        skip = i->iov_offset;
+        buf = iov->iov_base + skip;
+        copy = min(bytes, iov->iov_len - skip);
+
+        left = __copy_from_user(to, buf, copy);
+        copy -= left;
+        skip += copy;
+        to += copy;
+        bytes -= copy;
+        while (unlikely(!left && bytes)) {
+                iov++;
+                buf = iov->iov_base;
+                copy = min(bytes, iov->iov_len);
+                left = __copy_from_user(to, buf, copy);
+                copy -= left;
+                skip = copy;
+                to += copy;
+                bytes -= copy;
+        }
+
+        if (skip == iov->iov_len) {
+                iov++;
+                skip = 0;
+        }
+        i->count -= wanted - bytes;
+        i->nr_segs -= iov - i->iov;
+        i->iov = iov;
+        i->iov_offset = skip;
+        return wanted - bytes;
+}
+
 static size_t copy_page_to_iter_iovec(struct page *page, size_t offset, size_t bytes,
                          struct iov_iter *i)
 {
@@ -166,6 +256,50 @@ done:
         return wanted - bytes;
 }
 
+static size_t zero_iovec(size_t bytes, struct iov_iter *i)
+{
+        size_t skip, copy, left, wanted;
+        const struct iovec *iov;
+        char __user *buf;
+
+        if (unlikely(bytes > i->count))
+                bytes = i->count;
+
+        if (unlikely(!bytes))
+                return 0;
+
+        wanted = bytes;
+        iov = i->iov;
+        skip = i->iov_offset;
+        buf = iov->iov_base + skip;
+        copy = min(bytes, iov->iov_len - skip);
+
+        left = __clear_user(buf, copy);
+        copy -= left;
+        skip += copy;
+        bytes -= copy;
+
+        while (unlikely(!left && bytes)) {
+                iov++;
+                buf = iov->iov_base;
+                copy = min(bytes, iov->iov_len);
+                left = __clear_user(buf, copy);
+                copy -= left;
+                skip = copy;
+                bytes -= copy;
+        }
+
+        if (skip == iov->iov_len) {
+                iov++;
+                skip = 0;
+        }
+        i->count -= wanted - bytes;
+        i->nr_segs -= iov - i->iov;
+        i->iov = iov;
+        i->iov_offset = skip;
+        return wanted - bytes;
+}
+
 static size_t __iovec_copy_from_user_inatomic(char *vaddr,
                         const struct iovec *iov, size_t base, size_t bytes)
 {
@@ -414,12 +548,17 @@ static void memcpy_to_page(struct page *page, size_t offset, char *from, size_t
         kunmap_atomic(to);
 }
 
-static size_t copy_page_to_iter_bvec(struct page *page, size_t offset, size_t bytes,
-                         struct iov_iter *i)
+static void memzero_page(struct page *page, size_t offset, size_t len)
+{
+        char *addr = kmap_atomic(page);
+        memset(addr + offset, 0, len);
+        kunmap_atomic(addr);
+}
+
+static size_t copy_to_iter_bvec(void *from, size_t bytes, struct iov_iter *i)
 {
         size_t skip, copy, wanted;
         const struct bio_vec *bvec;
-        void *kaddr, *from;
 
         if (unlikely(bytes > i->count))
                 bytes = i->count;
@@ -432,8 +571,6 @@ static size_t copy_page_to_iter_bvec(struct page *page, size_t offset, size_t by
         skip = i->iov_offset;
         copy = min_t(size_t, bytes, bvec->bv_len - skip);
 
-        kaddr = kmap_atomic(page);
-        from = kaddr + offset;
         memcpy_to_page(bvec->bv_page, skip + bvec->bv_offset, from, copy);
         skip += copy;
         from += copy;
@@ -446,7 +583,6 @@ static size_t copy_page_to_iter_bvec(struct page *page, size_t offset, size_t by
                 from += copy;
                 bytes -= copy;
         }
-        kunmap_atomic(kaddr);
         if (skip == bvec->bv_len) {
                 bvec++;
                 skip = 0;
@@ -458,12 +594,10 @@ static size_t copy_page_to_iter_bvec(struct page *page, size_t offset, size_t by
         return wanted - bytes;
 }
 
-static size_t copy_page_from_iter_bvec(struct page *page, size_t offset, size_t bytes,
-                         struct iov_iter *i)
+static size_t copy_from_iter_bvec(void *to, size_t bytes, struct iov_iter *i)
 {
         size_t skip, copy, wanted;
         const struct bio_vec *bvec;
-        void *kaddr, *to;
 
         if (unlikely(bytes > i->count))
                 bytes = i->count;
@@ -475,10 +609,6 @@ static size_t copy_page_from_iter_bvec(struct page *page, size_t offset, size_t
         bvec = i->bvec;
         skip = i->iov_offset;
 
-        kaddr = kmap_atomic(page);
-
-        to = kaddr + offset;
-
         copy = min(bytes, bvec->bv_len - skip);
 
         memcpy_from_page(to, bvec->bv_page, bvec->bv_offset + skip, copy);
@@ -495,7 +625,6 @@ static size_t copy_page_from_iter_bvec(struct page *page, size_t offset, size_t
                 to += copy;
                 bytes -= copy;
         }
-        kunmap_atomic(kaddr);
         if (skip == bvec->bv_len) {
                 bvec++;
                 skip = 0;
@@ -507,6 +636,61 @@ static size_t copy_page_from_iter_bvec(struct page *page, size_t offset, size_t
         return wanted;
 }
 
+static size_t copy_page_to_iter_bvec(struct page *page, size_t offset,
+                                        size_t bytes, struct iov_iter *i)
+{
+        void *kaddr = kmap_atomic(page);
+        size_t wanted = copy_to_iter_bvec(kaddr + offset, bytes, i);
+        kunmap_atomic(kaddr);
+        return wanted;
+}
+
+static size_t copy_page_from_iter_bvec(struct page *page, size_t offset,
+                                        size_t bytes, struct iov_iter *i)
+{
+        void *kaddr = kmap_atomic(page);
+        size_t wanted = copy_from_iter_bvec(kaddr + offset, bytes, i);
+        kunmap_atomic(kaddr);
+        return wanted;
+}
+
+static size_t zero_bvec(size_t bytes, struct iov_iter *i)
+{
+        size_t skip, copy, wanted;
+        const struct bio_vec *bvec;
+
+        if (unlikely(bytes > i->count))
+                bytes = i->count;
+
+        if (unlikely(!bytes))
+                return 0;
+
+        wanted = bytes;
+        bvec = i->bvec;
+        skip = i->iov_offset;
+        copy = min_t(size_t, bytes, bvec->bv_len - skip);
+
+        memzero_page(bvec->bv_page, skip + bvec->bv_offset, copy);
+        skip += copy;
+        bytes -= copy;
+        while (bytes) {
+                bvec++;
+                copy = min(bytes, (size_t)bvec->bv_len);
+                memzero_page(bvec->bv_page, bvec->bv_offset, copy);
+                skip = copy;
+                bytes -= copy;
+        }
+        if (skip == bvec->bv_len) {
+                bvec++;
+                skip = 0;
+        }
+        i->count -= wanted - bytes;
+        i->nr_segs -= bvec - i->bvec;
+        i->bvec = bvec;
+        i->iov_offset = skip;
+        return wanted - bytes;
+}
+
 static size_t copy_from_user_bvec(struct page *page,
                 struct iov_iter *i, unsigned long offset, size_t bytes)
 {
@@ -672,6 +856,34 @@ size_t copy_page_from_iter(struct page *page, size_t offset, size_t bytes,
 }
 EXPORT_SYMBOL(copy_page_from_iter);
 
+size_t copy_to_iter(void *addr, size_t bytes, struct iov_iter *i)
+{
+        if (i->type & ITER_BVEC)
+                return copy_to_iter_bvec(addr, bytes, i);
+        else
+                return copy_to_iter_iovec(addr, bytes, i);
+}
+EXPORT_SYMBOL(copy_to_iter);
+
+size_t copy_from_iter(void *addr, size_t bytes, struct iov_iter *i)
+{
+        if (i->type & ITER_BVEC)
+                return copy_from_iter_bvec(addr, bytes, i);
+        else
+                return copy_from_iter_iovec(addr, bytes, i);
+}
+EXPORT_SYMBOL(copy_from_iter);
+
+size_t iov_iter_zero(size_t bytes, struct iov_iter *i)
+{
+        if (i->type & ITER_BVEC) {
+                return zero_bvec(bytes, i);
+        } else {
+                return zero_iovec(bytes, i);
+        }
+}
+EXPORT_SYMBOL(iov_iter_zero);
+
 size_t iov_iter_copy_from_user_atomic(struct page *page,
                 struct iov_iter *i, unsigned long offset, size_t bytes)
 {