Merge branch 'xfs-misc-fixes-3-for-3.16' into for-next

13 files changed, 60 insertions, 53 deletions

diff --git a/fs/xfs/xfs_alloc.c b/fs/xfs/xfs_alloc.c
index c1cf6a336a72..d43813267a80 100644
--- a/fs/xfs/xfs_alloc.c
+++ b/fs/xfs/xfs_alloc.c
@@ -257,16 +257,14 @@ xfs_alloc_fix_len(
         k = rlen % args->prod;
         if (k == args->mod)
                 return;
-        if (k > args->mod) {
-                if ((int)(rlen = rlen - k - args->mod) < (int)args->minlen)
-                        return;
-        } else {
-                if ((int)(rlen = rlen - args->prod - (args->mod - k)) <
-                    (int)args->minlen)
-                        return;
-        }
-        ASSERT(rlen >= args->minlen);
-        ASSERT(rlen <= args->maxlen);
+        if (k > args->mod)
+                rlen = rlen - (k - args->mod);
+        else
+                rlen = rlen - args->prod + (args->mod - k);
+        if ((int)rlen < (int)args->minlen)
+                return;
+        ASSERT(rlen >= args->minlen && rlen <= args->maxlen);
+        ASSERT(rlen % args->prod == args->mod);
         args->len = rlen;
 }
 
@@ -541,7 +539,6 @@ xfs_alloc_read_agfl(
                         XFS_FSS_TO_BB(mp, 1), 0, &bp, &xfs_agfl_buf_ops);
         if (error)
                 return error;
-        ASSERT(!xfs_buf_geterror(bp));
         xfs_buf_set_ref(bp, XFS_AGFL_REF);
         *bpp = bp;
         return 0;
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index d1b99b692ccb..e32640eedea6 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -975,7 +975,7 @@ xfs_vm_writepage(
          * Given that we do not allow direct reclaim to call us, we should
          * never be called while in a filesystem transaction.
          */
-        if (WARN_ON(current->flags & PF_FSTRANS))
+        if (WARN_ON_ONCE(current->flags & PF_FSTRANS))
                 goto redirty;
 
         /* Is this page beyond the end of the file? */
@@ -1225,9 +1225,9 @@ xfs_vm_releasepage(
 
         xfs_count_page_state(page, &delalloc, &unwritten);
 
-        if (WARN_ON(delalloc))
+        if (WARN_ON_ONCE(delalloc))
                 return 0;
-        if (WARN_ON(unwritten))
+        if (WARN_ON_ONCE(unwritten))
                 return 0;
 
         return try_to_free_buffers(page);
diff --git a/fs/xfs/xfs_bit.h b/fs/xfs/xfs_bit.h
index f1e3c907044d..e1649c0d3e02 100644
--- a/fs/xfs/xfs_bit.h
+++ b/fs/xfs/xfs_bit.h
@@ -66,8 +66,11 @@ static inline int xfs_lowbit64(__uint64_t v)
                 n = ffs(w);
         } else {        /* upper bits */
                 w = (__uint32_t)(v >> 32);
-                if (w && (n = ffs(w)))
-                n += 32;
+                if (w) {
+                        n = ffs(w);
+                        if (n)
+                                n += 32;
+                }
         }
         return n - 1;
 }
diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index 057f671811d6..703b3ec1796c 100644
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -258,14 +258,23 @@ xfs_bmapi_allocate_worker(
         struct xfs_bmalloca     *args = container_of(work,
                                                 struct xfs_bmalloca, work);
         unsigned long           pflags;
+        unsigned long           new_pflags = PF_FSTRANS;
 
-        /* we are in a transaction context here */
-        current_set_flags_nested(&pflags, PF_FSTRANS);
+        /*
+         * we are in a transaction context here, but may also be doing work
+         * in kswapd context, and hence we may need to inherit that state
+         * temporarily to ensure that we don't block waiting for memory reclaim
+         * in any way.
+         */
+        if (args->kswapd)
+                new_pflags |= PF_MEMALLOC | PF_SWAPWRITE | PF_KSWAPD;
+
+        current_set_flags_nested(&pflags, new_pflags);
 
         args->result = __xfs_bmapi_allocate(args);
         complete(args->done);
 
-        current_restore_flags_nested(&pflags, PF_FSTRANS);
+        current_restore_flags_nested(&pflags, new_pflags);
 }
 
 /*
@@ -284,6 +293,7 @@ xfs_bmapi_allocate(
 
 
         args->done = &done;
+        args->kswapd = current_is_kswapd();
         INIT_WORK_ONSTACK(&args->work, xfs_bmapi_allocate_worker);
         queue_work(xfs_alloc_wq, &args->work);
         wait_for_completion(&done);
diff --git a/fs/xfs/xfs_bmap_util.h b/fs/xfs/xfs_bmap_util.h
index 935ed2b24edf..075f72232a64 100644
--- a/fs/xfs/xfs_bmap_util.h
+++ b/fs/xfs/xfs_bmap_util.h
@@ -50,12 +50,13 @@ struct xfs_bmalloca {
         xfs_extlen_t            total;  /* total blocks needed for xaction */
         xfs_extlen_t            minlen; /* minimum allocation size (blocks) */
         xfs_extlen_t            minleft; /* amount must be left after alloc */
-        char                    eof;    /* set if allocating past last extent */
-        char                    wasdel; /* replacing a delayed allocation */
-        char                    userdata;/* set if is user data */
-        char                    aeof;   /* allocated space at eof */
-        char                    conv;   /* overwriting unwritten extents */
-        char                    stack_switch;
+        bool                    eof;    /* set if allocating past last extent */
+        bool                    wasdel; /* replacing a delayed allocation */
+        bool                    userdata;/* set if is user data */
+        bool                    aeof;   /* allocated space at eof */
+        bool                    conv;   /* overwriting unwritten extents */
+        bool                    stack_switch;
+        bool                    kswapd; /* allocation in kswapd context */
         int                     flags;
         struct completion       *done;
         struct work_struct      work;
diff --git a/fs/xfs/xfs_btree.c b/fs/xfs/xfs_btree.c
index 182bac2bb276..bf810c6baf2b 100644
--- a/fs/xfs/xfs_btree.c
+++ b/fs/xfs/xfs_btree.c
@@ -553,14 +553,11 @@ xfs_btree_get_bufl(
         xfs_fsblock_t   fsbno,          /* file system block number */
         uint            lock)           /* lock flags for get_buf */
 {
-        xfs_buf_t       *bp;            /* buffer pointer (return value) */
         xfs_daddr_t             d;              /* real disk block address */
 
         ASSERT(fsbno != NULLFSBLOCK);
         d = XFS_FSB_TO_DADDR(mp, fsbno);
-        bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, mp->m_bsize, lock);
-        ASSERT(!xfs_buf_geterror(bp));
-        return bp;
+        return xfs_trans_get_buf(tp, mp->m_ddev_targp, d, mp->m_bsize, lock);
 }
 
 /*
@@ -575,15 +572,12 @@ xfs_btree_get_bufs(
         xfs_agblock_t   agbno,          /* allocation group block number */
         uint            lock)           /* lock flags for get_buf */
 {
-        xfs_buf_t       *bp;            /* buffer pointer (return value) */
         xfs_daddr_t             d;              /* real disk block address */
 
         ASSERT(agno != NULLAGNUMBER);
         ASSERT(agbno != NULLAGBLOCK);
         d = XFS_AGB_TO_DADDR(mp, agno, agbno);
-        bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, mp->m_bsize, lock);
-        ASSERT(!xfs_buf_geterror(bp));
-        return bp;
+        return xfs_trans_get_buf(tp, mp->m_ddev_targp, d, mp->m_bsize, lock);
 }
 
 /*
@@ -723,7 +717,6 @@ xfs_btree_read_bufl(
                                    mp->m_bsize, lock, &bp, ops);
         if (error)
                 return error;
-        ASSERT(!xfs_buf_geterror(bp));
         if (bp)
                 xfs_buf_set_ref(bp, refval);
         *bpp = bp;
@@ -1179,7 +1172,6 @@ xfs_btree_read_buf_block(
         if (error)
                 return error;
 
-        ASSERT(!xfs_buf_geterror(*bpp));
         xfs_btree_set_refs(cur, *bpp);
         *block = XFS_BUF_TO_BLOCK(*bpp);
         return 0;
diff --git a/fs/xfs/xfs_buf.h b/fs/xfs/xfs_buf.h
index 0e47fd1fedba..3a7a5523d3dc 100644
--- a/fs/xfs/xfs_buf.h
+++ b/fs/xfs/xfs_buf.h
@@ -298,11 +298,6 @@ extern void xfs_buf_iomove(xfs_buf_t *, size_t, size_t, void *,
 
 extern int xfs_bioerror_relse(struct xfs_buf *);
 
-static inline int xfs_buf_geterror(xfs_buf_t *bp)
-{
-        return bp ? bp->b_error : ENOMEM;
-}
-
 /* Buffer Utility Routines */
 extern xfs_caddr_t xfs_buf_offset(xfs_buf_t *, size_t);
 
diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c
index 64b17f5bed9a..4654338b03fc 100644
--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -1052,7 +1052,7 @@ xfs_buf_iodone_callbacks(
         static ulong            lasttime;
         static xfs_buftarg_t    *lasttarg;
 
-        if (likely(!xfs_buf_geterror(bp)))
+        if (likely(!bp->b_error))
                 goto do_callbacks;
 
         /*
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 5fec738f1f2e..3ee0cd43edc0 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -353,10 +353,10 @@ xfs_qm_dqalloc(
                                dqp->q_blkno,
                                mp->m_quotainfo->qi_dqchunklen,
                                0);
-
-        error = xfs_buf_geterror(bp);
-        if (error)
+        if (!bp) {
+                error = ENOMEM;
                 goto error1;
+        }
         bp->b_ops = &xfs_dquot_buf_ops;
 
         /*
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c
index e8dfaf039232..5960e5593fe0 100644
--- a/fs/xfs/xfs_ialloc.c
+++ b/fs/xfs/xfs_ialloc.c
@@ -2129,7 +2129,6 @@ xfs_read_agi(
         if (error)
                 return error;
 
-        ASSERT(!xfs_buf_geterror(*bpp));
         xfs_buf_set_ref(*bpp, XFS_AGI_REF);
         return 0;
 }
diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index 3554098692d8..292308dede6d 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -1165,7 +1165,7 @@ xlog_iodone(xfs_buf_t *bp)
         /*
          * Race to shutdown the filesystem if we see an error.
          */
-        if (XFS_TEST_ERROR((xfs_buf_geterror(bp)), l->l_mp,
+        if (XFS_TEST_ERROR(bp->b_error, l->l_mp,
                         XFS_ERRTAG_IODONE_IOERR, XFS_RANDOM_IODONE_IOERR)) {
                 xfs_buf_ioerror_alert(bp, __func__);
                 xfs_buf_stale(bp);
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 03c9d645865c..3507cd0ec400 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -323,8 +323,19 @@ reread:
         /*
          * Initialize the mount structure from the superblock.
          */
-        xfs_sb_from_disk(&mp->m_sb, XFS_BUF_TO_SBP(bp));
-        xfs_sb_quota_from_disk(&mp->m_sb);
+        xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp));
+        xfs_sb_quota_from_disk(sbp);
+
+        /*
+         * If we haven't validated the superblock, do so now before we try
+         * to check the sector size and reread the superblock appropriately.
+         */
+        if (sbp->sb_magicnum != XFS_SB_MAGIC) {
+                if (loud)
+                        xfs_warn(mp, "Invalid superblock magic number");
+                error = EINVAL;
+                goto release_buf;
+        }
 
         /*
          * We must be able to do sector-sized and sector-aligned IO.
@@ -337,11 +348,11 @@ reread:
                 goto release_buf;
         }
 
-        /*
-         * Re-read the superblock so the buffer is correctly sized,
-         * and properly verified.
-         */
         if (buf_ops == NULL) {
+                /*
+                 * Re-read the superblock so the buffer is correctly sized,
+                 * and properly verified.
+                 */
                 xfs_buf_relse(bp);
                 sector_size = sbp->sb_sectsize;
                 buf_ops = loud ? &xfs_sb_buf_ops : &xfs_sb_quiet_buf_ops;
diff --git a/fs/xfs/xfs_rtbitmap.c b/fs/xfs/xfs_rtbitmap.c
index b1f2fe8af4a8..f4dd697cac08 100644
--- a/fs/xfs/xfs_rtbitmap.c
+++ b/fs/xfs/xfs_rtbitmap.c
@@ -74,7 +74,6 @@ xfs_rtbuf_get(
                                    mp->m_bsize, 0, &bp, NULL);
         if (error)
                 return error;
-        ASSERT(!xfs_buf_geterror(bp));
         *bpp = bp;
         return 0;
 }