Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

Several cases of bug fixes in 'net' overlapping other changes in
'net-next-.

Signed-off-by: David S. Miller <davem@davemloft.net>

23 files changed, 268 insertions, 242 deletions

diff --git a/fs/aio.c b/fs/aio.c
index 1157e13a36d6..428484f2f841 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -1078,6 +1078,17 @@ static void aio_complete(struct kiocb *kiocb, long res, long res2)
         unsigned tail, pos, head;
         unsigned long   flags;
 
+        if (kiocb->ki_flags & IOCB_WRITE) {
+                struct file *file = kiocb->ki_filp;
+
+                /*
+                 * Tell lockdep we inherited freeze protection from submission
+                 * thread.
+                 */
+                __sb_writers_acquired(file_inode(file)->i_sb, SB_FREEZE_WRITE);
+                file_end_write(file);
+        }
+
         /*
          * Special case handling for sync iocbs:
          *  - events go directly into the iocb for fast handling
@@ -1392,122 +1403,106 @@ SYSCALL_DEFINE1(io_destroy, aio_context_t, ctx)
         return -EINVAL;
 }
 
-typedef ssize_t (rw_iter_op)(struct kiocb *, struct iov_iter *);
-
-static int aio_setup_vectored_rw(int rw, char __user *buf, size_t len,
-                                 struct iovec **iovec,
-                                 bool compat,
-                                 struct iov_iter *iter)
+static int aio_setup_rw(int rw, struct iocb *iocb, struct iovec **iovec,
+                bool vectored, bool compat, struct iov_iter *iter)
 {
+        void __user *buf = (void __user *)(uintptr_t)iocb->aio_buf;
+        size_t len = iocb->aio_nbytes;
+
+        if (!vectored) {
+                ssize_t ret = import_single_range(rw, buf, len, *iovec, iter);
+                *iovec = NULL;
+                return ret;
+        }
 #ifdef CONFIG_COMPAT
         if (compat)
-                return compat_import_iovec(rw,
-                                (struct compat_iovec __user *)buf,
-                                len, UIO_FASTIOV, iovec, iter);
+                return compat_import_iovec(rw, buf, len, UIO_FASTIOV, iovec,
+                                iter);
 #endif
-        return import_iovec(rw, (struct iovec __user *)buf,
-                                len, UIO_FASTIOV, iovec, iter);
+        return import_iovec(rw, buf, len, UIO_FASTIOV, iovec, iter);
 }
 
-/*
- * aio_run_iocb:
- *      Performs the initial checks and io submission.
- */
-static ssize_t aio_run_iocb(struct kiocb *req, unsigned opcode,
-                            char __user *buf, size_t len, bool compat)
+static inline ssize_t aio_ret(struct kiocb *req, ssize_t ret)
+{
+        switch (ret) {
+        case -EIOCBQUEUED:
+                return ret;
+        case -ERESTARTSYS:
+        case -ERESTARTNOINTR:
+        case -ERESTARTNOHAND:
+        case -ERESTART_RESTARTBLOCK:
+                /*
+                 * There's no easy way to restart the syscall since other AIO's
+                 * may be already running. Just fail this IO with EINTR.
+                 */
+                ret = -EINTR;
+                /*FALLTHRU*/
+        default:
+                aio_complete(req, ret, 0);
+                return 0;
+        }
+}
+
+static ssize_t aio_read(struct kiocb *req, struct iocb *iocb, bool vectored,
+                bool compat)
 {
         struct file *file = req->ki_filp;
-        ssize_t ret;
-        int rw;
-        fmode_t mode;
-        rw_iter_op *iter_op;
         struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
         struct iov_iter iter;
+        ssize_t ret;
 
-        switch (opcode) {
-        case IOCB_CMD_PREAD:
-        case IOCB_CMD_PREADV:
-                mode    = FMODE_READ;
-                rw      = READ;
-                iter_op = file->f_op->read_iter;
-                goto rw_common;
-
-        case IOCB_CMD_PWRITE:
-        case IOCB_CMD_PWRITEV:
-                mode    = FMODE_WRITE;
-                rw      = WRITE;
-                iter_op = file->f_op->write_iter;
-                goto rw_common;
-rw_common:
-                if (unlikely(!(file->f_mode & mode)))
-                        return -EBADF;
-
-                if (!iter_op)
-                        return -EINVAL;
-
-                if (opcode == IOCB_CMD_PREADV || opcode == IOCB_CMD_PWRITEV)
-                        ret = aio_setup_vectored_rw(rw, buf, len,
-                                                &iovec, compat, &iter);
-                else {
-                        ret = import_single_range(rw, buf, len, iovec, &iter);
-                        iovec = NULL;
-                }
-                if (!ret)
-                        ret = rw_verify_area(rw, file, &req->ki_pos,
-                                             iov_iter_count(&iter));
-                if (ret < 0) {
-                        kfree(iovec);
-                        return ret;
-                }
-
-                if (rw == WRITE)
-                        file_start_write(file);
-
-                ret = iter_op(req, &iter);
-
-                if (rw == WRITE)
-                        file_end_write(file);
-                kfree(iovec);
-                break;
-
-        case IOCB_CMD_FDSYNC:
-                if (!file->f_op->aio_fsync)
-                        return -EINVAL;
-
-                ret = file->f_op->aio_fsync(req, 1);
-                break;
+        if (unlikely(!(file->f_mode & FMODE_READ)))
+                return -EBADF;
+        if (unlikely(!file->f_op->read_iter))
+                return -EINVAL;
 
-        case IOCB_CMD_FSYNC:
-                if (!file->f_op->aio_fsync)
-                        return -EINVAL;
+        ret = aio_setup_rw(READ, iocb, &iovec, vectored, compat, &iter);
+        if (ret)
+                return ret;
+        ret = rw_verify_area(READ, file, &req->ki_pos, iov_iter_count(&iter));
+        if (!ret)
+                ret = aio_ret(req, file->f_op->read_iter(req, &iter));
+        kfree(iovec);
+        return ret;
+}
 
-                ret = file->f_op->aio_fsync(req, 0);
-                break;
+static ssize_t aio_write(struct kiocb *req, struct iocb *iocb, bool vectored,
+                bool compat)
+{
+        struct file *file = req->ki_filp;
+        struct iovec inline_vecs[UIO_FASTIOV], *iovec = inline_vecs;
+        struct iov_iter iter;
+        ssize_t ret;
 
-        default:
-                pr_debug("EINVAL: no operation provided\n");
+        if (unlikely(!(file->f_mode & FMODE_WRITE)))
+                return -EBADF;
+        if (unlikely(!file->f_op->write_iter))
                 return -EINVAL;
-        }
 
-        if (ret != -EIOCBQUEUED) {
+        ret = aio_setup_rw(WRITE, iocb, &iovec, vectored, compat, &iter);
+        if (ret)
+                return ret;
+        ret = rw_verify_area(WRITE, file, &req->ki_pos, iov_iter_count(&iter));
+        if (!ret) {
+                req->ki_flags |= IOCB_WRITE;
+                file_start_write(file);
+                ret = aio_ret(req, file->f_op->write_iter(req, &iter));
                 /*
-                 * There's no easy way to restart the syscall since other AIO's
-                 * may be already running. Just fail this IO with EINTR.
+                 * We release freeze protection in aio_complete().  Fool lockdep
+                 * by telling it the lock got released so that it doesn't
+                 * complain about held lock when we return to userspace.
                  */
-                if (unlikely(ret == -ERESTARTSYS || ret == -ERESTARTNOINTR ||
-                             ret == -ERESTARTNOHAND ||
-                             ret == -ERESTART_RESTARTBLOCK))
-                        ret = -EINTR;
-                aio_complete(req, ret, 0);
+                __sb_writers_release(file_inode(file)->i_sb, SB_FREEZE_WRITE);
         }
-
-        return 0;
+        kfree(iovec);
+        return ret;
 }
 
 static int io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
                          struct iocb *iocb, bool compat)
 {
         struct aio_kiocb *req;
+        struct file *file;
         ssize_t ret;
 
         /* enforce forwards compatibility on users */
@@ -1530,7 +1525,7 @@ static int io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
         if (unlikely(!req))
                 return -EAGAIN;
 
-        req->common.ki_filp = fget(iocb->aio_fildes);
+        req->common.ki_filp = file = fget(iocb->aio_fildes);
         if (unlikely(!req->common.ki_filp)) {
                 ret = -EBADF;
                 goto out_put_req;
@@ -1565,13 +1560,29 @@ static int io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
         req->ki_user_iocb = user_iocb;
         req->ki_user_data = iocb->aio_data;
 
-        ret = aio_run_iocb(&req->common, iocb->aio_lio_opcode,
-                           (char __user *)(unsigned long)iocb->aio_buf,
-                           iocb->aio_nbytes,
-                           compat);
-        if (ret)
-                goto out_put_req;
+        get_file(file);
+        switch (iocb->aio_lio_opcode) {
+        case IOCB_CMD_PREAD:
+                ret = aio_read(&req->common, iocb, false, compat);
+                break;
+        case IOCB_CMD_PWRITE:
+                ret = aio_write(&req->common, iocb, false, compat);
+                break;
+        case IOCB_CMD_PREADV:
+                ret = aio_read(&req->common, iocb, true, compat);
+                break;
+        case IOCB_CMD_PWRITEV:
+                ret = aio_write(&req->common, iocb, true, compat);
+                break;
+        default:
+                pr_debug("invalid aio operation %d\n", iocb->aio_lio_opcode);
+                ret = -EINVAL;
+                break;
+        }
+        fput(file);
 
+        if (ret && ret != -EIOCBQUEUED)
+                goto out_put_req;
         return 0;
 out_put_req:
         put_reqs_available(ctx, 1);
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 210c94ac8818..4607af38c72e 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -2647,7 +2647,10 @@ static noinline int __btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
 
                 btrfs_free_delayed_extent_op(extent_op);
                 if (ret) {
+                        spin_lock(&delayed_refs->lock);
                         locked_ref->processing = 0;
+                        delayed_refs->num_heads_ready++;
+                        spin_unlock(&delayed_refs->lock);
                         btrfs_delayed_ref_unlock(locked_ref);
                         btrfs_put_delayed_ref(ref);
                         btrfs_debug(fs_info, "run_one_delayed_ref returned %d",
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 66a755150056..8ed05d95584a 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -5569,7 +5569,7 @@ void le_bitmap_set(u8 *map, unsigned int start, int len)
                 *p |= mask_to_set;
                 len -= bits_to_set;
                 bits_to_set = BITS_PER_BYTE;
-                mask_to_set = ~(u8)0;
+                mask_to_set = ~0;
                 p++;
         }
         if (len) {
@@ -5589,7 +5589,7 @@ void le_bitmap_clear(u8 *map, unsigned int start, int len)
                 *p &= ~mask_to_clear;
                 len -= bits_to_clear;
                 bits_to_clear = BITS_PER_BYTE;
-                mask_to_clear = ~(u8)0;
+                mask_to_clear = ~0;
                 p++;
         }
         if (len) {
@@ -5679,7 +5679,7 @@ void extent_buffer_bitmap_set(struct extent_buffer *eb, unsigned long start,
                 kaddr[offset] |= mask_to_set;
                 len -= bits_to_set;
                 bits_to_set = BITS_PER_BYTE;
-                mask_to_set = ~(u8)0;
+                mask_to_set = ~0;
                 if (++offset >= PAGE_SIZE && len > 0) {
                         offset = 0;
                         page = eb->pages[++i];
@@ -5721,7 +5721,7 @@ void extent_buffer_bitmap_clear(struct extent_buffer *eb, unsigned long start,
                 kaddr[offset] &= ~mask_to_clear;
                 len -= bits_to_clear;
                 bits_to_clear = BITS_PER_BYTE;
-                mask_to_clear = ~(u8)0;
+                mask_to_clear = ~0;
                 if (++offset >= PAGE_SIZE && len > 0) {
                         offset = 0;
                         page = eb->pages[++i];
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 2b790bda7998..8e3a5a266917 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -4605,8 +4605,8 @@ delete:
                         BUG_ON(ret);
                         if (btrfs_should_throttle_delayed_refs(trans, root))
                                 btrfs_async_run_delayed_refs(root,
-                                                             trans->transid,
-                                        trans->delayed_ref_updates * 2, 0);
+                                        trans->delayed_ref_updates * 2,
+                                        trans->transid, 0);
                         if (be_nice) {
                                 if (truncate_space_check(trans, root,
                                                          extent_num_bytes)) {
@@ -8931,9 +8931,14 @@ again:
          *    So even we call qgroup_free_data(), it won't decrease reserved
          *    space.
          * 2) Not written to disk
-         *    This means the reserved space should be freed here.
+         *    This means the reserved space should be freed here. However,
+         *    if a truncate invalidates the page (by clearing PageDirty)
+         *    and the page is accounted for while allocating extent
+         *    in btrfs_check_data_free_space() we let delayed_ref to
+         *    free the entire extent.
          */
-        btrfs_qgroup_free_data(inode, page_start, PAGE_SIZE);
+        if (PageDirty(page))
+                btrfs_qgroup_free_data(inode, page_start, PAGE_SIZE);
         if (!inode_evicting) {
                 clear_extent_bit(tree, page_start, page_end,
                                  EXTENT_LOCKED | EXTENT_DIRTY |
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 18e1aa0f85f5..7acbd2cf6192 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -3814,6 +3814,11 @@ process_slot:
                 }
                 btrfs_release_path(path);
                 key.offset = next_key_min_offset;
+
+                if (fatal_signal_pending(current)) {
+                        ret = -EINTR;
+                        goto out;
+                }
         }
         ret = 0;
 
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 0ec8ffa37ab0..c4af0cdb783d 100644
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -2728,7 +2728,14 @@ static int do_relocation(struct btrfs_trans_handle *trans,
 
                 bytenr = btrfs_node_blockptr(upper->eb, slot);
                 if (lowest) {
-                        BUG_ON(bytenr != node->bytenr);
+                        if (bytenr != node->bytenr) {
+                                btrfs_err(root->fs_info,
+                "lowest leaf/node mismatch: bytenr %llu node->bytenr %llu slot %d upper %llu",
+                                          bytenr, node->bytenr, slot,
+                                          upper->eb->start);
+                                err = -EIO;
+                                goto next;
+                        }
                 } else {
                         if (node->eb->start == bytenr)
                                 goto next;
diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index 18630e800208..f995e3528a33 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -1770,7 +1770,6 @@ const struct file_operations ceph_file_fops = {
         .fsync = ceph_fsync,
         .lock = ceph_lock,
         .flock = ceph_flock,
-        .splice_read = generic_file_splice_read,
         .splice_write = iter_file_splice_write,
         .unlocked_ioctl = ceph_ioctl,
         .compat_ioctl   = ceph_ioctl,
diff --git a/fs/coredump.c b/fs/coredump.c
index 281b768000e6..eb9c92c9b20f 100644
--- a/fs/coredump.c
+++ b/fs/coredump.c
@@ -1,6 +1,7 @@
 #include <linux/slab.h>
 #include <linux/file.h>
 #include <linux/fdtable.h>
+#include <linux/freezer.h>
 #include <linux/mm.h>
 #include <linux/stat.h>
 #include <linux/fcntl.h>
@@ -423,7 +424,9 @@ static int coredump_wait(int exit_code, struct core_state *core_state)
         if (core_waiters > 0) {
                 struct core_thread *ptr;
 
+                freezer_do_not_count();
                 wait_for_completion(&core_state->startup);
+                freezer_count();
                 /*
                  * Wait for all the threads to become inactive, so that
                  * all the thread context (extended register state, like
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 7555ba889d1f..ebecfb8fba06 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -314,7 +314,8 @@ static struct nfs_client *nfs_match_client(const struct nfs_client_initdata *dat
                 /* Match the full socket address */
                 if (!rpc_cmp_addr_port(sap, clap))
                         /* Match all xprt_switch full socket addresses */
-                        if (!rpc_clnt_xprt_switch_has_addr(clp->cl_rpcclient,
+                        if (IS_ERR(clp->cl_rpcclient) ||
+                            !rpc_clnt_xprt_switch_has_addr(clp->cl_rpcclient,
                                                            sap))
                                 continue;
 
diff --git a/fs/nfs/namespace.c b/fs/nfs/namespace.c
index c8162c660c44..5551e8ef67fd 100644
--- a/fs/nfs/namespace.c
+++ b/fs/nfs/namespace.c
@@ -98,7 +98,7 @@ rename_retry:
                 return end;
         }
         namelen = strlen(base);
-        if (flags & NFS_PATH_CANONICAL) {
+        if (*end == '/') {
                 /* Strip off excess slashes in base string */
                 while (namelen > 0 && base[namelen - 1] == '/')
                         namelen--;
diff --git a/fs/nfs/nfs4session.c b/fs/nfs/nfs4session.c
index b62973045a3e..a61350f75c74 100644
--- a/fs/nfs/nfs4session.c
+++ b/fs/nfs/nfs4session.c
@@ -178,12 +178,14 @@ static int nfs4_slot_get_seqid(struct nfs4_slot_table  *tbl, u32 slotid,
         __must_hold(&tbl->slot_tbl_lock)
 {
         struct nfs4_slot *slot;
+        int ret;
 
         slot = nfs4_lookup_slot(tbl, slotid);
-        if (IS_ERR(slot))
-                return PTR_ERR(slot);
-        *seq_nr = slot->seq_nr;
-        return 0;
+        ret = PTR_ERR_OR_ZERO(slot);
+        if (!ret)
+                *seq_nr = slot->seq_nr;
+
+        return ret;
 }
 
 /*
@@ -196,7 +198,7 @@ static int nfs4_slot_get_seqid(struct nfs4_slot_table  *tbl, u32 slotid,
 static bool nfs4_slot_seqid_in_use(struct nfs4_slot_table *tbl,
                 u32 slotid, u32 seq_nr)
 {
-        u32 cur_seq;
+        u32 cur_seq = 0;
         bool ret = false;
 
         spin_lock(&tbl->slot_tbl_lock);
diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c
index 56b2d96f9103..259ef85f435a 100644
--- a/fs/nfs/pnfs.c
+++ b/fs/nfs/pnfs.c
@@ -146,6 +146,8 @@ set_pnfs_layoutdriver(struct nfs_server *server, const struct nfs_fh *mntfh,
         u32 id;
         int i;
 
+        if (fsinfo->nlayouttypes == 0)
+                goto out_no_driver;
         if (!(server->nfs_client->cl_exchange_flags &
                  (EXCHGID4_FLAG_USE_NON_PNFS | EXCHGID4_FLAG_USE_PNFS_MDS))) {
                 printk(KERN_ERR "NFS: %s: cl_exchange_flags 0x%x\n",
diff --git a/fs/nfsd/netns.h b/fs/nfsd/netns.h
index b10d557f9c9e..ee36efd5aece 100644
--- a/fs/nfsd/netns.h
+++ b/fs/nfsd/netns.h
@@ -84,6 +84,8 @@ struct nfsd_net {
         struct list_head client_lru;
         struct list_head close_lru;
         struct list_head del_recall_lru;
+
+        /* protected by blocked_locks_lock */
         struct list_head blocked_locks_lru;
 
         struct delayed_work laundromat_work;
@@ -91,6 +93,9 @@ struct nfsd_net {
         /* client_lock protects the client lru list and session hash table */
         spinlock_t client_lock;
 
+        /* protects blocked_locks_lru */
+        spinlock_t blocked_locks_lock;
+
         struct file *rec_file;
         bool in_grace;
         const struct nfsd4_client_tracking_ops *client_tracking_ops;
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 9752beb78659..4b4beaaa4eaa 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -217,7 +217,7 @@ find_blocked_lock(struct nfs4_lockowner *lo, struct knfsd_fh *fh,
 {
         struct nfsd4_blocked_lock *cur, *found = NULL;
 
-        spin_lock(&nn->client_lock);
+        spin_lock(&nn->blocked_locks_lock);
         list_for_each_entry(cur, &lo->lo_blocked, nbl_list) {
                 if (fh_match(fh, &cur->nbl_fh)) {
                         list_del_init(&cur->nbl_list);
@@ -226,7 +226,7 @@ find_blocked_lock(struct nfs4_lockowner *lo, struct knfsd_fh *fh,
                         break;
                 }
         }
-        spin_unlock(&nn->client_lock);
+        spin_unlock(&nn->blocked_locks_lock);
         if (found)
                 posix_unblock_lock(&found->nbl_lock);
         return found;
@@ -1227,9 +1227,7 @@ static void put_ol_stateid_locked(struct nfs4_ol_stateid *stp,
 
 static bool unhash_lock_stateid(struct nfs4_ol_stateid *stp)
 {
-        struct nfs4_openowner *oo = openowner(stp->st_openstp->st_stateowner);
-
-        lockdep_assert_held(&oo->oo_owner.so_client->cl_lock);
+        lockdep_assert_held(&stp->st_stid.sc_client->cl_lock);
 
         list_del_init(&stp->st_locks);
         nfs4_unhash_stid(&stp->st_stid);
@@ -1238,12 +1236,12 @@ static bool unhash_lock_stateid(struct nfs4_ol_stateid *stp)
 
 static void release_lock_stateid(struct nfs4_ol_stateid *stp)
 {
-        struct nfs4_openowner *oo = openowner(stp->st_openstp->st_stateowner);
+        struct nfs4_client *clp = stp->st_stid.sc_client;
         bool unhashed;
 
-        spin_lock(&oo->oo_owner.so_client->cl_lock);
+        spin_lock(&clp->cl_lock);
         unhashed = unhash_lock_stateid(stp);
-        spin_unlock(&oo->oo_owner.so_client->cl_lock);
+        spin_unlock(&clp->cl_lock);
         if (unhashed)
                 nfs4_put_stid(&stp->st_stid);
 }
@@ -4665,7 +4663,7 @@ nfs4_laundromat(struct nfsd_net *nn)
          * indefinitely once the lock does become free.
          */
         BUG_ON(!list_empty(&reaplist));
-        spin_lock(&nn->client_lock);
+        spin_lock(&nn->blocked_locks_lock);
         while (!list_empty(&nn->blocked_locks_lru)) {
                 nbl = list_first_entry(&nn->blocked_locks_lru,
                                         struct nfsd4_blocked_lock, nbl_lru);
@@ -4678,7 +4676,7 @@ nfs4_laundromat(struct nfsd_net *nn)
                 list_move(&nbl->nbl_lru, &reaplist);
                 list_del_init(&nbl->nbl_list);
         }
-        spin_unlock(&nn->client_lock);
+        spin_unlock(&nn->blocked_locks_lock);
 
         while (!list_empty(&reaplist)) {
                 nbl = list_first_entry(&nn->blocked_locks_lru,
@@ -5439,13 +5437,13 @@ nfsd4_lm_notify(struct file_lock *fl)
         bool queue = false;
 
         /* An empty list means that something else is going to be using it */
-        spin_lock(&nn->client_lock);
+        spin_lock(&nn->blocked_locks_lock);
         if (!list_empty(&nbl->nbl_list)) {
                 list_del_init(&nbl->nbl_list);
                 list_del_init(&nbl->nbl_lru);
                 queue = true;
         }
-        spin_unlock(&nn->client_lock);
+        spin_unlock(&nn->blocked_locks_lock);
 
         if (queue)
                 nfsd4_run_cb(&nbl->nbl_cb);
@@ -5868,10 +5866,10 @@ nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
 
         if (fl_flags & FL_SLEEP) {
                 nbl->nbl_time = jiffies;
-                spin_lock(&nn->client_lock);
+                spin_lock(&nn->blocked_locks_lock);
                 list_add_tail(&nbl->nbl_list, &lock_sop->lo_blocked);
                 list_add_tail(&nbl->nbl_lru, &nn->blocked_locks_lru);
-                spin_unlock(&nn->client_lock);
+                spin_unlock(&nn->blocked_locks_lock);
         }
 
         err = vfs_lock_file(filp, F_SETLK, file_lock, conflock);
@@ -5900,10 +5898,10 @@ out:
         if (nbl) {
                 /* dequeue it if we queued it before */
                 if (fl_flags & FL_SLEEP) {
-                        spin_lock(&nn->client_lock);
+                        spin_lock(&nn->blocked_locks_lock);
                         list_del_init(&nbl->nbl_list);
                         list_del_init(&nbl->nbl_lru);
-                        spin_unlock(&nn->client_lock);
+                        spin_unlock(&nn->blocked_locks_lock);
                 }
                 free_blocked_lock(nbl);
         }
@@ -6943,9 +6941,11 @@ static int nfs4_state_create_net(struct net *net)
         INIT_LIST_HEAD(&nn->client_lru);
         INIT_LIST_HEAD(&nn->close_lru);
         INIT_LIST_HEAD(&nn->del_recall_lru);
-        INIT_LIST_HEAD(&nn->blocked_locks_lru);
         spin_lock_init(&nn->client_lock);
 
+        spin_lock_init(&nn->blocked_locks_lock);
+        INIT_LIST_HEAD(&nn->blocked_locks_lru);
+
         INIT_DELAYED_WORK(&nn->laundromat_work, laundromat_main);
         get_net(net);
 
@@ -7063,14 +7063,14 @@ nfs4_state_shutdown_net(struct net *net)
         }
 
         BUG_ON(!list_empty(&reaplist));
-        spin_lock(&nn->client_lock);
+        spin_lock(&nn->blocked_locks_lock);
         while (!list_empty(&nn->blocked_locks_lru)) {
                 nbl = list_first_entry(&nn->blocked_locks_lru,
                                         struct nfsd4_blocked_lock, nbl_lru);
                 list_move(&nbl->nbl_lru, &reaplist);
                 list_del_init(&nbl->nbl_list);
         }
-        spin_unlock(&nn->client_lock);
+        spin_unlock(&nn->blocked_locks_lock);
 
         while (!list_empty(&reaplist)) {
                 nbl = list_first_entry(&nn->blocked_locks_lru,
diff --git a/fs/ntfs/dir.c b/fs/ntfs/dir.c
index a18613579001..0ee19ecc982d 100644
--- a/fs/ntfs/dir.c
+++ b/fs/ntfs/dir.c
@@ -1544,8 +1544,6 @@ const struct file_operations ntfs_dir_ops = {
         .iterate        = ntfs_readdir,         /* Read directory contents. */
 #ifdef NTFS_RW
         .fsync          = ntfs_dir_fsync,       /* Sync a directory to disk. */
-        /*.aio_fsync    = ,*/                   /* Sync all outstanding async
-                                                   i/o operations on a kiocb. */
 #endif /* NTFS_RW */
         /*.ioctl        = ,*/                   /* Perform function on the
                                                    mounted filesystem. */
diff --git a/fs/ocfs2/dir.c b/fs/ocfs2/dir.c
index e7054e2ac922..3ecb9f337b7d 100644
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -3699,7 +3699,7 @@ static void ocfs2_dx_dir_transfer_leaf(struct inode *dir, u32 split_hash,
 static int ocfs2_dx_dir_rebalance_credits(struct ocfs2_super *osb,
                                           struct ocfs2_dx_root_block *dx_root)
 {
-        int credits = ocfs2_clusters_to_blocks(osb->sb, 2);
+        int credits = ocfs2_clusters_to_blocks(osb->sb, 3);
 
         credits += ocfs2_calc_extend_credits(osb->sb, &dx_root->dr_list);
         credits += ocfs2_quota_trans_credits(osb->sb);
diff --git a/fs/orangefs/orangefs-debugfs.c b/fs/orangefs/orangefs-debugfs.c
index eb09aa026723..d484068ca716 100644
--- a/fs/orangefs/orangefs-debugfs.c
+++ b/fs/orangefs/orangefs-debugfs.c
@@ -141,6 +141,9 @@ static struct client_debug_mask client_debug_mask;
  */
 static DEFINE_MUTEX(orangefs_debug_lock);
 
+/* Used to protect data in ORANGEFS_KMOD_DEBUG_HELP_FILE */
+static DEFINE_MUTEX(orangefs_help_file_lock);
+
 /*
  * initialize kmod debug operations, create orangefs debugfs dir and
  * ORANGEFS_KMOD_DEBUG_HELP_FILE.
@@ -289,6 +292,8 @@ static void *help_start(struct seq_file *m, loff_t *pos)
 
         gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_start: start\n");
 
+        mutex_lock(&orangefs_help_file_lock);
+
         if (*pos == 0)
                 payload = m->private;
 
@@ -305,6 +310,7 @@ static void *help_next(struct seq_file *m, void *v, loff_t *pos)
 static void help_stop(struct seq_file *m, void *p)
 {
         gossip_debug(GOSSIP_DEBUGFS_DEBUG, "help_stop: start\n");
+        mutex_unlock(&orangefs_help_file_lock);
 }
 
 static int help_show(struct seq_file *m, void *v)
@@ -610,32 +616,54 @@ out:
  * /sys/kernel/debug/orangefs/debug-help can be catted to
  * see all the available kernel and client debug keywords.
  *
- * When the kernel boots, we have no idea what keywords the
+ * When orangefs.ko initializes, we have no idea what keywords the
  * client supports, nor their associated masks.
  *
- * We pass through this function once at boot and stamp a
+ * We pass through this function once at module-load and stamp a
  * boilerplate "we don't know" message for the client in the
  * debug-help file. We pass through here again when the client
  * starts and then we can fill out the debug-help file fully.
  *
  * The client might be restarted any number of times between
- * reboots, we only build the debug-help file the first time.
+ * module reloads, we only build the debug-help file the first time.
  */
 int orangefs_prepare_debugfs_help_string(int at_boot)
 {
-        int rc = -EINVAL;
-        int i;
-        int byte_count = 0;
         char *client_title = "Client Debug Keywords:\n";
         char *kernel_title = "Kernel Debug Keywords:\n";
+        size_t string_size =  DEBUG_HELP_STRING_SIZE;
+        size_t result_size;
+        size_t i;
+        char *new;
+        int rc = -EINVAL;
 
         gossip_debug(GOSSIP_UTILS_DEBUG, "%s: start\n", __func__);
 
-        if (at_boot) {
-                byte_count += strlen(HELP_STRING_UNINITIALIZED);
+        if (at_boot)
                 client_title = HELP_STRING_UNINITIALIZED;
-        } else {
-                /*
+
+        /* build a new debug_help_string. */
+        new = kzalloc(DEBUG_HELP_STRING_SIZE, GFP_KERNEL);
+        if (!new) {
+                rc = -ENOMEM;
+                goto out;
+        }
+
+        /*
+         * strlcat(dst, src, size) will append at most
+         * "size - strlen(dst) - 1" bytes of src onto dst,
+         * null terminating the result, and return the total
+         * length of the string it tried to create.
+         *
+         * We'll just plow through here building our new debug
+         * help string and let strlcat take care of assuring that
+         * dst doesn't overflow.
+         */
+        strlcat(new, client_title, string_size);
+
+        if (!at_boot) {
+
+                /*
                  * fill the client keyword/mask array and remember
                  * how many elements there were.
                  */
@@ -644,64 +672,40 @@ int orangefs_prepare_debugfs_help_string(int at_boot)
                 if (cdm_element_count <= 0)
                         goto out;
 
-                /* Count the bytes destined for debug_help_string. */
-                byte_count += strlen(client_title);
-
                 for (i = 0; i < cdm_element_count; i++) {
-                        byte_count += strlen(cdm_array[i].keyword + 2);
-                        if (byte_count >= DEBUG_HELP_STRING_SIZE) {
-                                pr_info("%s: overflow 1!\n", __func__);
-                                goto out;
-                        }
+                        strlcat(new, "\t", string_size);
+                        strlcat(new, cdm_array[i].keyword, string_size);
+                        strlcat(new, "\n", string_size);
                 }
-
-                gossip_debug(GOSSIP_UTILS_DEBUG,
-                             "%s: cdm_element_count:%d:\n",
-                             __func__,
-                             cdm_element_count);
         }
 
-        byte_count += strlen(kernel_title);
+        strlcat(new, "\n", string_size);
+        strlcat(new, kernel_title, string_size);
+
         for (i = 0; i < num_kmod_keyword_mask_map; i++) {
-                byte_count +=
-                        strlen(s_kmod_keyword_mask_map[i].keyword + 2);
-                if (byte_count >= DEBUG_HELP_STRING_SIZE) {
-                        pr_info("%s: overflow 2!\n", __func__);
-                        goto out;
-                }
+                strlcat(new, "\t", string_size);
+                strlcat(new, s_kmod_keyword_mask_map[i].keyword, string_size);
+                result_size = strlcat(new, "\n", string_size);
         }
 
-        /* build debug_help_string. */
-        debug_help_string = kzalloc(DEBUG_HELP_STRING_SIZE, GFP_KERNEL);
-        if (!debug_help_string) {
-                rc = -ENOMEM;
+        /* See if we tried to put too many bytes into "new"... */
+        if (result_size >= string_size) {
+                kfree(new);
                 goto out;
         }
 
-        strcat(debug_help_string, client_title);
-
-        if (!at_boot) {
-                for (i = 0; i < cdm_element_count; i++) {
-                        strcat(debug_help_string, "\t");
-                        strcat(debug_help_string, cdm_array[i].keyword);
-                        strcat(debug_help_string, "\n");
-                }
-        }
-
-        strcat(debug_help_string, "\n");
-        strcat(debug_help_string, kernel_title);
-
-        for (i = 0; i < num_kmod_keyword_mask_map; i++) {
-                strcat(debug_help_string, "\t");
-                strcat(debug_help_string, s_kmod_keyword_mask_map[i].keyword);
-                strcat(debug_help_string, "\n");
+        if (at_boot) {
+                debug_help_string = new;
+        } else {
+                mutex_lock(&orangefs_help_file_lock);
+                memset(debug_help_string, 0, DEBUG_HELP_STRING_SIZE);
+                strlcat(debug_help_string, new, string_size);
+                mutex_unlock(&orangefs_help_file_lock);
         }
 
         rc = 0;
 
-out:
-
-        return rc;
+out:    return rc;
 
 }
 
@@ -959,8 +963,12 @@ int orangefs_debugfs_new_client_string(void __user *arg)
         ret = copy_from_user(&client_debug_array_string,
                                      (void __user *)arg,
                                      ORANGEFS_MAX_DEBUG_STRING_LEN);
-        if (ret != 0)
+
+        if (ret != 0) {
+                pr_info("%s: CLIENT_STRING: copy_from_user failed\n",
+                        __func__);
                 return -EIO;
+        }
 
         /*
          * The real client-core makes an effort to ensure
@@ -975,45 +983,18 @@ int orangefs_debugfs_new_client_string(void __user *arg)
         client_debug_array_string[ORANGEFS_MAX_DEBUG_STRING_LEN - 1] =
                 '\0';
         
-        if (ret != 0) {
-                pr_info("%s: CLIENT_STRING: copy_from_user failed\n",
-                        __func__);
-                return -EIO;
-        }
-
         pr_info("%s: client debug array string has been received.\n",
                 __func__);
 
         if (!help_string_initialized) {
 
-                /* Free the "we don't know yet" default string... */
-                kfree(debug_help_string);
-
-                /* build a proper debug help string */
+                /* Build a proper debug help string. */
                 if (orangefs_prepare_debugfs_help_string(0)) {
                         gossip_err("%s: no debug help string \n",
                                    __func__);
                         return -EIO;
                 }
 
-                /* Replace the boilerplate boot-time debug-help file. */
-                debugfs_remove(help_file_dentry);
-
-                help_file_dentry =
-                        debugfs_create_file(
-                                ORANGEFS_KMOD_DEBUG_HELP_FILE,
-                                0444,
-                                debug_dir,
-                                debug_help_string,
-                                &debug_help_fops);
-
-                if (!help_file_dentry) {
-                        gossip_err("%s: debugfs_create_file failed for"
-                                   " :%s:!\n",
-                                   __func__,
-                                   ORANGEFS_KMOD_DEBUG_HELP_FILE);
-                        return -EIO;
-                }
         }
 
         debug_mask_to_string(&client_debug_mask, 1);
diff --git a/fs/orangefs/orangefs-mod.c b/fs/orangefs/orangefs-mod.c
index 2e5b03065f34..4113eb0495bf 100644
--- a/fs/orangefs/orangefs-mod.c
+++ b/fs/orangefs/orangefs-mod.c
@@ -124,7 +124,7 @@ static int __init orangefs_init(void)
          * unknown at boot time.
          *
          * orangefs_prepare_debugfs_help_string will be used again
-         * later to rebuild the debug-help file after the client starts
+         * later to rebuild the debug-help-string after the client starts
          * and passes along the needed info. The argument signifies
          * which time orangefs_prepare_debugfs_help_string is being
          * called.
@@ -152,7 +152,9 @@ static int __init orangefs_init(void)
 
         ret = register_filesystem(&orangefs_fs_type);
         if (ret == 0) {
-                pr_info("orangefs: module version %s loaded\n", ORANGEFS_VERSION);
+                pr_info("%s: module version %s loaded\n",
+                        __func__,
+                        ORANGEFS_VERSION);
                 ret = 0;
                 goto out;
         }
diff --git a/fs/overlayfs/copy_up.c b/fs/overlayfs/copy_up.c
index aeb60f791418..36795eed40b0 100644
--- a/fs/overlayfs/copy_up.c
+++ b/fs/overlayfs/copy_up.c
@@ -178,6 +178,8 @@ static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len)
                 len -= bytes;
         }
 
+        if (!error)
+                error = vfs_fsync(new_file, 0);
         fput(new_file);
 out_fput:
         fput(old_file);
diff --git a/fs/overlayfs/inode.c b/fs/overlayfs/inode.c
index c58f01babf30..7fb53d055537 100644
--- a/fs/overlayfs/inode.c
+++ b/fs/overlayfs/inode.c
@@ -270,9 +270,6 @@ struct posix_acl *ovl_get_acl(struct inode *inode, int type)
         if (!IS_ENABLED(CONFIG_FS_POSIX_ACL) || !IS_POSIXACL(realinode))
                 return NULL;
 
-        if (!realinode->i_op->get_acl)
-                return NULL;
-
         old_cred = ovl_override_creds(inode->i_sb);
         acl = get_acl(realinode, type);
         revert_creds(old_cred);
diff --git a/fs/overlayfs/super.c b/fs/overlayfs/super.c
index bcf3965be819..edd46a0e951d 100644
--- a/fs/overlayfs/super.c
+++ b/fs/overlayfs/super.c
@@ -1037,6 +1037,21 @@ ovl_posix_acl_xattr_set(const struct xattr_handler *handler,
 
         posix_acl_release(acl);
 
+        /*
+         * Check if sgid bit needs to be cleared (actual setacl operation will
+         * be done with mounter's capabilities and so that won't do it for us).
+         */
+        if (unlikely(inode->i_mode & S_ISGID) &&
+            handler->flags == ACL_TYPE_ACCESS &&
+            !in_group_p(inode->i_gid) &&
+            !capable_wrt_inode_uidgid(inode, CAP_FSETID)) {
+                struct iattr iattr = { .ia_valid = ATTR_KILL_SGID };
+
+                err = ovl_setattr(dentry, &iattr);
+                if (err)
+                        return err;
+        }
+
         err = ovl_xattr_set(dentry, handler->name, value, size, flags);
         if (!err)
                 ovl_copyattr(ovl_inode_real(inode, NULL), inode);
diff --git a/fs/splice.c b/fs/splice.c
index 153d4f3bd441..dcaf185a5731 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -299,13 +299,8 @@ ssize_t generic_file_splice_read(struct file *in, loff_t *ppos,
 {
         struct iov_iter to;
         struct kiocb kiocb;
-        loff_t isize;
         int idx, ret;
 
-        isize = i_size_read(in->f_mapping->host);
-        if (unlikely(*ppos >= isize))
-                return 0;
-
         iov_iter_pipe(&to, ITER_PIPE | READ, pipe, len);
         idx = to.idx;
         init_sync_kiocb(&kiocb, in);
diff --git a/fs/xfs/libxfs/xfs_defer.c b/fs/xfs/libxfs/xfs_defer.c
index 613c5cf19436..5c2929f94bd3 100644
--- a/fs/xfs/libxfs/xfs_defer.c
+++ b/fs/xfs/libxfs/xfs_defer.c
@@ -199,9 +199,9 @@ xfs_defer_intake_work(
         struct xfs_defer_pending        *dfp;
 
         list_for_each_entry(dfp, &dop->dop_intake, dfp_list) {
-                trace_xfs_defer_intake_work(tp->t_mountp, dfp);
                 dfp->dfp_intent = dfp->dfp_type->create_intent(tp,
                                 dfp->dfp_count);
+                trace_xfs_defer_intake_work(tp->t_mountp, dfp);
                 list_sort(tp->t_mountp, &dfp->dfp_work,
                                 dfp->dfp_type->diff_items);
                 list_for_each(li, &dfp->dfp_work)
@@ -221,21 +221,14 @@ xfs_defer_trans_abort(
         struct xfs_defer_pending        *dfp;
 
         trace_xfs_defer_trans_abort(tp->t_mountp, dop);
-        /*
-         * If the transaction was committed, drop the intent reference
-         * since we're bailing out of here. The other reference is
-         * dropped when the intent hits the AIL.  If the transaction
-         * was not committed, the intent is freed by the intent item
-         * unlock handler on abort.
-         */
-        if (!dop->dop_committed)
-                return;
 
-        /* Abort intent items. */
+        /* Abort intent items that don't have a done item. */
         list_for_each_entry(dfp, &dop->dop_pending, dfp_list) {
                 trace_xfs_defer_pending_abort(tp->t_mountp, dfp);
-                if (!dfp->dfp_done)
+                if (dfp->dfp_intent && !dfp->dfp_done) {
                         dfp->dfp_type->abort_intent(dfp->dfp_intent);
+                        dfp->dfp_intent = NULL;
+                }
         }
 
         /* Shut down FS. */