Merge remote-tracking branch 'vfs/for-next'

Conflicts:
	fs/ext4/file.c
	fs/f2fs/file.c
	fs/nfs/direct.c
	fs/splice.c

diff --cc drivers/staging/lustre/lustre/llite/file.c
Simple merge

diff --cc fs/9p/vfs_file.c
Simple merge

diff --cc fs/afs/internal.h
Simple merge

diff --cc fs/cifs/cifsfs.c
Simple merge

diff --cc fs/cifs/cifsfs.h
Simple merge

diff --cc fs/cifs/file.c
index 208f56eca4bf4de164d8af873b0050ac4884c5ea,60e9b5fa22128fc7a127a5859f0c6070aae09c36..e90a1e9aa627642c9ccefd428319f43b3d379c2f
--- 1/fs/cifs/file.c
--- 2/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@@ -2560,9 -2558,9 +2558,9 @@@ ssize_t cifs_user_writev(struct kiocb *
         * write request.
         */
  
-       written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
+       written = cifs_iovec_write(iocb->ki_filp, from, &pos);
        if (written > 0) {
 -              CIFS_I(inode)->invalid_mapping = true;
 +              set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
                iocb->ki_pos = pos;
        }
  

diff --cc fs/ecryptfs/file.c
Simple merge

diff --cc fs/ext4/ext4.h
Simple merge

diff --cc fs/ext4/file.c
index e5cd87fa45973262cffd69bc88f943f23750cf0d,708aad7681991368262332520f09f5490af848de..9ace5e7d0b7059b52f07dc635cce59fff0f8efa2
--- 1/fs/ext4/file.c
--- 2/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@@ -101,13 -97,10 +97,12 @@@ ext4_file_write_iter(struct kiocb *iocb
        struct blk_plug plug;
        int o_direct = file->f_flags & O_DIRECT;
        int overwrite = 0;
-       size_t length = iov_length(iov, nr_segs);
+       size_t length = iov_iter_count(from);
        ssize_t ret;
- 
-       BUG_ON(iocb->ki_pos != pos);
+       loff_t pos = iocb->ki_pos;
  
 +      mutex_lock(&EXT4_I(inode)->i_write_mutex);
 +
        /*
         * Unaligned direct AIO must be serialized; see comment above
         * In the case of O_APPEND, assume that we must always serialize
@@@ -116,8 -109,9 +111,8 @@@
            ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) &&
            !is_sync_kiocb(iocb) &&
            (file->f_flags & O_APPEND ||
-            ext4_unaligned_aio(inode, iov, nr_segs, pos))) {
+            ext4_unaligned_aio(inode, from, pos))) {
 -              aio_mutex = ext4_aio_mutex(inode);
 -              mutex_lock(aio_mutex);
 +              unaligned_direct_aio = true;
                ext4_unwritten_wait(inode);
        }
  
@@@ -135,14 -129,12 +130,12 @@@
                if ((pos > sbi->s_bitmap_maxbytes) ||
                    (pos == sbi->s_bitmap_maxbytes && length > 0)) {
                        mutex_unlock(&inode->i_mutex);
 -                      ret = -EFBIG;
 -                      goto errout;
 +                      mutex_unlock(&EXT4_I(inode)->i_write_mutex);
 +                      return -EFBIG;
                }
  
-               if (pos + length > sbi->s_bitmap_maxbytes) {
-                       nr_segs = iov_shorten((struct iovec *)iov, nr_segs,
-                                             sbi->s_bitmap_maxbytes - pos);
-               }
+               if (pos + length > sbi->s_bitmap_maxbytes)
+                       iov_iter_truncate(from, sbi->s_bitmap_maxbytes - pos);
        }
  
        if (o_direct) {
@@@ -181,10 -172,8 +174,10 @@@
                }
        }
  
-       ret = __generic_file_aio_write(iocb, iov, nr_segs);
+       ret = __generic_file_write_iter(iocb, from);
        mutex_unlock(&inode->i_mutex);
 +      if (!unaligned_direct_aio)
 +              mutex_unlock(&EXT4_I(inode)->i_write_mutex);
  
        if (ret > 0) {
                ssize_t err;

diff --cc fs/ext4/inode.c
Simple merge

diff --cc fs/f2fs/data.c
Simple merge

diff --cc fs/f2fs/file.c
index d97e5c458f360bab7e531c771ba7e60026650dfa,e4ba4b93f96a90e70c173fa309b242c0390ef8cf..37d0e1f512a993d07c75ba0b7e121855db939f3e
--- 1/fs/f2fs/file.c
--- 2/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@@ -805,11 -678,11 +805,11 @@@ long f2fs_compat_ioctl(struct file *fil
  #endif
  
  const struct file_operations f2fs_file_operations = {
 -      .llseek         = generic_file_llseek,
 +      .llseek         = f2fs_llseek,
-       .read           = do_sync_read,
-       .write          = do_sync_write,
-       .aio_read       = generic_file_aio_read,
-       .aio_write      = generic_file_aio_write,
+       .read           = new_sync_read,
+       .write          = new_sync_write,
+       .read_iter      = generic_file_read_iter,
+       .write_iter     = generic_file_write_iter,
        .open           = generic_file_open,
        .mmap           = f2fs_file_mmap,
        .fsync          = f2fs_sync_file,

diff --cc fs/fuse/file.c
Simple merge

diff --cc fs/gfs2/aops.c
Simple merge

diff --cc fs/gfs2/file.c
Simple merge

diff --cc fs/nfs/direct.c
index 4ad7bc3886791b0078ebc3ae4b326ed5e4c6566b,b122fe21fea0dce3ae5dbcbb362dcbb4820e73b8..8f98138cbc4385ba63b3af77ae907219d22e6991
--- 1/fs/nfs/direct.c
--- 2/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@@ -414,60 -322,37 +414,37 @@@ static const struct nfs_pgio_completion
   * handled automatically by nfs_direct_read_result().  Otherwise, if
   * no requests have been sent, just return an error.
   */
- static ssize_t nfs_direct_read_schedule_segment(struct nfs_pageio_descriptor *desc,
-                                               const struct iovec *iov,
-                                               loff_t pos, bool uio)
- {
-       struct nfs_direct_req *dreq = desc->pg_dreq;
-       struct nfs_open_context *ctx = dreq->ctx;
-       struct inode *inode = ctx->dentry->d_inode;
-       unsigned long user_addr = (unsigned long)iov->iov_base;
-       size_t count = iov->iov_len;
-       size_t rsize = NFS_SERVER(inode)->rsize;
-       unsigned int pgbase;
-       int result;
-       ssize_t started = 0;
-       struct page **pagevec = NULL;
-       unsigned int npages;
- 
-       do {
-               size_t bytes;
-               int i;
  
-               pgbase = user_addr & ~PAGE_MASK;
-               bytes = min(max_t(size_t, rsize, PAGE_SIZE), count);
+ static ssize_t nfs_direct_read_schedule_iovec(struct nfs_direct_req *dreq,
+                                             struct iov_iter *iter,
+                                             loff_t pos)
+ {
+       struct nfs_pageio_descriptor desc;
+       struct inode *inode = dreq->inode;
+       ssize_t result = -EINVAL;
+       size_t requested_bytes = 0;
+       size_t rsize = max_t(size_t, NFS_SERVER(inode)->rsize, PAGE_SIZE);
  
-               result = -ENOMEM;
-               npages = nfs_page_array_len(pgbase, bytes);
-               if (!pagevec)
-                       pagevec = kmalloc(npages * sizeof(struct page *),
-                                         GFP_KERNEL);
-               if (!pagevec)
-                       break;
-               if (uio) {
-                       down_read(&current->mm->mmap_sem);
-                       result = get_user_pages(current, current->mm, user_addr,
-                                       npages, 1, 0, pagevec, NULL);
-                       up_read(&current->mm->mmap_sem);
-                       if (result < 0)
-                               break;
-               } else {
-                       WARN_ON(npages != 1);
-                       result = get_kernel_page(user_addr, 1, pagevec);
-                       if (WARN_ON(result != 1))
-                               break;
-               }
 -      NFS_PROTO(dreq->inode)->read_pageio_init(&desc, dreq->inode,
++      nfs_pageio_init_read(&desc, dreq->inode, false,
+                            &nfs_direct_read_completion_ops);
+       get_dreq(dreq);
+       desc.pg_dreq = dreq;
+       atomic_inc(&inode->i_dio_count);
  
-               if ((unsigned)result < npages) {
-                       bytes = result * PAGE_SIZE;
-                       if (bytes <= pgbase) {
-                               nfs_direct_release_pages(pagevec, result);
-                               break;
-                       }
-                       bytes -= pgbase;
-                       npages = result;
-               }
+       while (iov_iter_count(iter)) {
+               struct page **pagevec;
+               size_t bytes;
+               size_t pgbase;
+               unsigned npages, i;
  
+               result = iov_iter_get_pages_alloc(iter, &pagevec, 
+                                                 rsize, &pgbase);
+               if (result < 0)
+                       break;
+       
+               bytes = result;
+               iov_iter_advance(iter, bytes);
+               npages = (result + pgbase + PAGE_SIZE - 1) / PAGE_SIZE;
                for (i = 0; i < npages; i++) {
                        struct nfs_page *req;
                        unsigned int req_len = min_t(size_t, bytes, PAGE_SIZE - pgbase);
@@@ -965,24 -719,58 +813,57 @@@ static ssize_t nfs_direct_write_schedul
        struct inode *inode = dreq->inode;
        ssize_t result = 0;
        size_t requested_bytes = 0;
-       unsigned long seg;
+       size_t wsize = max_t(size_t, NFS_SERVER(inode)->wsize, PAGE_SIZE);
  
 -      NFS_PROTO(inode)->write_pageio_init(&desc, inode, FLUSH_COND_STABLE,
 +      nfs_pageio_init_write(&desc, inode, FLUSH_COND_STABLE, false,
                              &nfs_direct_write_completion_ops);
        desc.pg_dreq = dreq;
        get_dreq(dreq);
        atomic_inc(&inode->i_dio_count);
  
-       NFS_I(dreq->inode)->write_io += iov_length(iov, nr_segs);
-       for (seg = 0; seg < nr_segs; seg++) {
-               const struct iovec *vec = &iov[seg];
-               result = nfs_direct_write_schedule_segment(&desc, vec, pos, uio);
+       NFS_I(inode)->write_io += iov_iter_count(iter);
+       while (iov_iter_count(iter)) {
+               struct page **pagevec;
+               size_t bytes;
+               size_t pgbase;
+               unsigned npages, i;
+ 
+               result = iov_iter_get_pages_alloc(iter, &pagevec, 
+                                                 wsize, &pgbase);
                if (result < 0)
                        break;
-               requested_bytes += result;
-               if ((size_t)result < vec->iov_len)
+ 
+               bytes = result;
+               iov_iter_advance(iter, bytes);
+               npages = (result + pgbase + PAGE_SIZE - 1) / PAGE_SIZE;
+               for (i = 0; i < npages; i++) {
+                       struct nfs_page *req;
+                       unsigned int req_len = min_t(size_t, bytes, PAGE_SIZE - pgbase);
+ 
 -                      req = nfs_create_request(dreq->ctx, inode,
 -                                               pagevec[i],
++                      req = nfs_create_request(dreq->ctx, pagevec[i], NULL,
+                                                pgbase, req_len);
+                       if (IS_ERR(req)) {
+                               result = PTR_ERR(req);
+                               break;
+                       }
+                       nfs_lock_request(req);
+                       req->wb_index = pos >> PAGE_SHIFT;
+                       req->wb_offset = pos & ~PAGE_MASK;
+                       if (!nfs_pageio_add_request(&desc, req)) {
+                               result = desc.pg_error;
+                               nfs_unlock_and_release_request(req);
+                               break;
+                       }
+                       pgbase = 0;
+                       bytes -= req_len;
+                       requested_bytes += req_len;
+                       pos += req_len;
+                       dreq->bytes_left -= req_len;
+               }
+               nfs_direct_release_pages(pagevec, npages);
+               kvfree(pagevec);
+               if (result < 0)
                        break;
-               pos += vec->iov_len;
        }
        nfs_pageio_complete(&desc);
  

diff --cc fs/nfs/file.c
Simple merge

diff --cc fs/nfs/internal.h
Simple merge

diff --cc fs/nfs/nfs4file.c
Simple merge

diff --cc fs/splice.c
index e246954ea48cb486b1c8101e6f621364d6844535,9dc23de0f146cba6d4d5423a131d59c219d6eb9c..a4ae4e958e14337beb1be6fc36039d6b17555152
--- 1/fs/splice.c
--- 2/fs/splice.c
+++ b/fs/splice.c
@@@ -1546,10 -1556,9 +1556,10 @@@ static long vmsplice_to_user(struct fil
        ret = rw_copy_check_uvector(READ, uiov, nr_segs,
                                    ARRAY_SIZE(iovstack), iovstack, &iov);
        if (ret <= 0)
 -              return ret;
 +              goto out;
  
-       iov_iter_init(&iter, iov, nr_segs, count, 0);
 +      count = ret;
+       iov_iter_init(&iter, READ, iov, nr_segs, count);
  
        sd.len = 0;
        sd.total_len = count;

diff --cc fs/ubifs/file.c
Simple merge

diff --cc fs/xfs/xfs_aops.c
Simple merge

diff --cc fs/xfs/xfs_file.c
Simple merge

diff --cc fs/xfs/xfs_trace.h
Simple merge

diff --cc include/linux/nfs_fs.h
Simple merge

diff --cc mm/filemap.c
Simple merge