Merge tag 'nfs-for-4.8-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs

Pull NFS client updates from Trond Myklebust:
 "Highlights include:

  Stable bugfixes:
   - nfs: don't create zero-length requests

   - several LAYOUTGET bugfixes

  Features:
   - several performance related features

   - more aggressive caching when we can rely on close-to-open
     cache consistency

   - remove serialisation of O_DIRECT reads and writes

   - optimise several code paths to not flush to disk unnecessarily.

     However allow for the idiosyncracies of pNFS for those layout
     types that need to issue a LAYOUTCOMMIT before the metadata can
     be updated on the server.

   - SUNRPC updates to the client data receive path

   - pNFS/SCSI support RH/Fedora dm-mpath device nodes

   - pNFS files/flexfiles can now use unprivileged ports when
     the generic NFS mount options allow it.

  Bugfixes:
   - Don't use RDMA direct data placement together with data
     integrity or privacy security flavours

   - Remove the RDMA ALLPHYSICAL memory registration mode as
     it has potential security holes.

   - Several layout recall fixes to improve NFSv4.1 protocol
     compliance.

   - Fix an Oops in the pNFS files and flexfiles connection
     setup to the DS

   - Allow retry of operations that used a returned delegation
      stateid

   - Don't mark the inode as revalidated if a LAYOUTCOMMIT is
     outstanding

   - Fix writeback races in nfs4_copy_range() and
     nfs42_proc_deallocate()"

* tag 'nfs-for-4.8-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs: (104 commits)
  pNFS: Actively set attributes as invalid if LAYOUTCOMMIT is outstanding
  NFSv4: Clean up lookup of SECINFO_NO_NAME
  NFSv4.2: Fix warning "variable ‘stateids’ set but not used"
  NFSv4: Fix warning "no previous prototype for ‘nfs4_listxattr’"
  SUNRPC: Fix a compiler warning in fs/nfs/clnt.c
  pNFS: Remove redundant smp_mb() from pnfs_init_lseg()
  pNFS: Cleanup - do layout segment initialisation in one place
  pNFS: Remove redundant stateid invalidation
  pNFS: Remove redundant pnfs_mark_layout_returned_if_empty()
  pNFS: Clear the layout metadata if the server changed the layout stateid
  pNFS: Cleanup - don't open code pnfs_mark_layout_stateid_invalid()
  NFS: pnfs_mark_matching_lsegs_return() should match the layout sequence id
  pNFS: Do not set plh_return_seq for non-callback related layoutreturns
  pNFS: Ensure layoutreturn acts as a completion for layout callbacks
  pNFS: Fix CB_LAYOUTRECALL stateid verification
  pNFS: Always update the layout barrier seqid on LAYOUTGET
  pNFS: Always update the layout stateid if NFS_LAYOUT_INVALID_STID is set
  pNFS: Clear the layout return tracking on layout reinitialisation
  pNFS: LAYOUTRETURN should only update the stateid if the layout is valid
  nfs: don't create zero-length requests
  ...

1 files changed, 32 insertions, 61 deletions

diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index e6210ead71d0..72b7d13ee3c6 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -196,6 +196,12 @@ static void nfs_direct_set_hdr_verf(struct nfs_direct_req *dreq,
         WARN_ON_ONCE(verfp->committed < 0);
 }
 
+static int nfs_direct_cmp_verf(const struct nfs_writeverf *v1,
+                const struct nfs_writeverf *v2)
+{
+        return nfs_write_verifier_cmp(&v1->verifier, &v2->verifier);
+}
+
 /*
  * nfs_direct_cmp_hdr_verf - compare verifier for pgio header
  * @dreq - direct request possibly spanning multiple servers
@@ -215,7 +221,7 @@ static int nfs_direct_set_or_cmp_hdr_verf(struct nfs_direct_req *dreq,
                 nfs_direct_set_hdr_verf(dreq, hdr);
                 return 0;
         }
-        return memcmp(verfp, &hdr->verf, sizeof(struct nfs_writeverf));
+        return nfs_direct_cmp_verf(verfp, &hdr->verf);
 }
 
 /*
@@ -238,7 +244,7 @@ static int nfs_direct_cmp_commit_data_verf(struct nfs_direct_req *dreq,
         if (verfp->committed < 0)
                 return 1;
 
-        return memcmp(verfp, &data->verf, sizeof(struct nfs_writeverf));
+        return nfs_direct_cmp_verf(verfp, &data->verf);
 }
 
 /**
@@ -366,22 +372,10 @@ out:
  * Synchronous I/O uses a stack-allocated iocb.  Thus we can't trust
  * the iocb is still valid here if this is a synchronous request.
  */
-static void nfs_direct_complete(struct nfs_direct_req *dreq, bool write)
+static void nfs_direct_complete(struct nfs_direct_req *dreq)
 {
         struct inode *inode = dreq->inode;
 
-        if (dreq->iocb && write) {
-                loff_t pos = dreq->iocb->ki_pos + dreq->count;
-
-                spin_lock(&inode->i_lock);
-                if (i_size_read(inode) < pos)
-                        i_size_write(inode, pos);
-                spin_unlock(&inode->i_lock);
-        }
-
-        if (write)
-                nfs_zap_mapping(inode, inode->i_mapping);
-
         inode_dio_end(inode);
 
         if (dreq->iocb) {
@@ -436,7 +430,7 @@ static void nfs_direct_read_completion(struct nfs_pgio_header *hdr)
         }
 out_put:
         if (put_dreq(dreq))
-                nfs_direct_complete(dreq, false);
+                nfs_direct_complete(dreq);
         hdr->release(hdr);
 }
 
@@ -542,7 +536,7 @@ static ssize_t nfs_direct_read_schedule_iovec(struct nfs_direct_req *dreq,
         }
 
         if (put_dreq(dreq))
-                nfs_direct_complete(dreq, false);
+                nfs_direct_complete(dreq);
         return 0;
 }
 
@@ -583,17 +577,12 @@ ssize_t nfs_file_direct_read(struct kiocb *iocb, struct iov_iter *iter)
         if (!count)
                 goto out;
 
-        inode_lock(inode);
-        result = nfs_sync_mapping(mapping);
-        if (result)
-                goto out_unlock;
-
         task_io_account_read(count);
 
         result = -ENOMEM;
         dreq = nfs_direct_req_alloc();
         if (dreq == NULL)
-                goto out_unlock;
+                goto out;
 
         dreq->inode = inode;
         dreq->bytes_left = dreq->max_count = count;
@@ -608,10 +597,12 @@ ssize_t nfs_file_direct_read(struct kiocb *iocb, struct iov_iter *iter)
         if (!is_sync_kiocb(iocb))
                 dreq->iocb = iocb;
 
+        nfs_start_io_direct(inode);
+
         NFS_I(inode)->read_io += count;
         result = nfs_direct_read_schedule_iovec(dreq, iter, iocb->ki_pos);
 
-        inode_unlock(inode);
+        nfs_end_io_direct(inode);
 
         if (!result) {
                 result = nfs_direct_wait(dreq);
@@ -619,13 +610,8 @@ ssize_t nfs_file_direct_read(struct kiocb *iocb, struct iov_iter *iter)
                         iocb->ki_pos += result;
         }
 
-        nfs_direct_req_release(dreq);
-        return result;
-
 out_release:
         nfs_direct_req_release(dreq);
-out_unlock:
-        inode_unlock(inode);
 out:
         return result;
 }
@@ -657,6 +643,8 @@ static void nfs_direct_write_reschedule(struct nfs_direct_req *dreq)
         nfs_direct_write_scan_commit_list(dreq->inode, &reqs, &cinfo);
 
         dreq->count = 0;
+        dreq->verf.committed = NFS_INVALID_STABLE_HOW;
+        nfs_clear_pnfs_ds_commit_verifiers(&dreq->ds_cinfo);
         for (i = 0; i < dreq->mirror_count; i++)
                 dreq->mirrors[i].count = 0;
         get_dreq(dreq);
@@ -775,7 +763,8 @@ static void nfs_direct_write_schedule_work(struct work_struct *work)
                         nfs_direct_write_reschedule(dreq);
                         break;
                 default:
-                        nfs_direct_complete(dreq, true);
+                        nfs_zap_mapping(dreq->inode, dreq->inode->i_mapping);
+                        nfs_direct_complete(dreq);
         }
 }
 
@@ -991,6 +980,7 @@ static ssize_t nfs_direct_write_schedule_iovec(struct nfs_direct_req *dreq,
 ssize_t nfs_file_direct_write(struct kiocb *iocb, struct iov_iter *iter)
 {
         ssize_t result = -EINVAL;
+        size_t count;
         struct file *file = iocb->ki_filp;
         struct address_space *mapping = file->f_mapping;
         struct inode *inode = mapping->host;
@@ -1001,34 +991,24 @@ ssize_t nfs_file_direct_write(struct kiocb *iocb, struct iov_iter *iter)
         dfprintk(FILE, "NFS: direct write(%pD2, %zd@%Ld)\n",
                 file, iov_iter_count(iter), (long long) iocb->ki_pos);
 
-        nfs_add_stats(mapping->host, NFSIOS_DIRECTWRITTENBYTES,
-                      iov_iter_count(iter));
+        result = generic_write_checks(iocb, iter);
+        if (result <= 0)
+                return result;
+        count = result;
+        nfs_add_stats(mapping->host, NFSIOS_DIRECTWRITTENBYTES, count);
 
         pos = iocb->ki_pos;
         end = (pos + iov_iter_count(iter) - 1) >> PAGE_SHIFT;
 
-        inode_lock(inode);
-
-        result = nfs_sync_mapping(mapping);
-        if (result)
-                goto out_unlock;
-
-        if (mapping->nrpages) {
-                result = invalidate_inode_pages2_range(mapping,
-                                        pos >> PAGE_SHIFT, end);
-                if (result)
-                        goto out_unlock;
-        }
-
-        task_io_account_write(iov_iter_count(iter));
+        task_io_account_write(count);
 
         result = -ENOMEM;
         dreq = nfs_direct_req_alloc();
         if (!dreq)
-                goto out_unlock;
+                goto out;
 
         dreq->inode = inode;
-        dreq->bytes_left = dreq->max_count = iov_iter_count(iter);
+        dreq->bytes_left = dreq->max_count = count;
         dreq->io_start = pos;
         dreq->ctx = get_nfs_open_context(nfs_file_open_context(iocb->ki_filp));
         l_ctx = nfs_get_lock_context(dreq->ctx);
@@ -1040,6 +1020,8 @@ ssize_t nfs_file_direct_write(struct kiocb *iocb, struct iov_iter *iter)
         if (!is_sync_kiocb(iocb))
                 dreq->iocb = iocb;
 
+        nfs_start_io_direct(inode);
+
         result = nfs_direct_write_schedule_iovec(dreq, iter, pos);
 
         if (mapping->nrpages) {
@@ -1047,30 +1029,19 @@ ssize_t nfs_file_direct_write(struct kiocb *iocb, struct iov_iter *iter)
                                               pos >> PAGE_SHIFT, end);
         }
 
-        inode_unlock(inode);
+        nfs_end_io_direct(inode);
 
         if (!result) {
                 result = nfs_direct_wait(dreq);
                 if (result > 0) {
-                        struct inode *inode = mapping->host;
-
                         iocb->ki_pos = pos + result;
-                        spin_lock(&inode->i_lock);
-                        if (i_size_read(inode) < iocb->ki_pos)
-                                i_size_write(inode, iocb->ki_pos);
-                        spin_unlock(&inode->i_lock);
-
                         /* XXX: should check the generic_write_sync retval */
                         generic_write_sync(iocb, result);
                 }
         }
-        nfs_direct_req_release(dreq);
-        return result;
-
 out_release:
         nfs_direct_req_release(dreq);
-out_unlock:
-        inode_unlock(inode);
+out:
         return result;
 }