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

16 files changed, 57 insertions, 61 deletions

diff --git a/fs/xfs/kmem.c b/fs/xfs/kmem.c
index 844e288b9576..53e95b2a1369 100644
--- a/fs/xfs/kmem.c
+++ b/fs/xfs/kmem.c
@@ -21,7 +21,6 @@
 #include <linux/swap.h>
 #include <linux/blkdev.h>
 #include <linux/backing-dev.h>
-#include "time.h"
 #include "kmem.h"
 #include "xfs_message.h"
 
diff --git a/fs/xfs/libxfs/xfs_da_btree.c b/fs/xfs/libxfs/xfs_da_btree.c
index 2c42ae28d027..fd827530afec 100644
--- a/fs/xfs/libxfs/xfs_da_btree.c
+++ b/fs/xfs/libxfs/xfs_da_btree.c
@@ -2563,7 +2563,8 @@ xfs_da_get_buf(
                                     mapp, nmap, 0);
         error = bp ? bp->b_error : -EIO;
         if (error) {
-                xfs_trans_brelse(trans, bp);
+                if (bp)
+                        xfs_trans_brelse(trans, bp);
                 goto out_free;
         }
 
diff --git a/fs/xfs/libxfs/xfs_sb.c b/fs/xfs/libxfs/xfs_sb.c
index 8426e5e2682e..5f902fa7913f 100644
--- a/fs/xfs/libxfs/xfs_sb.c
+++ b/fs/xfs/libxfs/xfs_sb.c
@@ -445,6 +445,8 @@ __xfs_sb_from_disk(
         to->sb_features_incompat = be32_to_cpu(from->sb_features_incompat);
         to->sb_features_log_incompat =
                                 be32_to_cpu(from->sb_features_log_incompat);
+        /* crc is only used on disk, not in memory; just init to 0 here. */
+        to->sb_crc = 0;
         to->sb_pad = 0;
         to->sb_pquotino = be64_to_cpu(from->sb_pquotino);
         to->sb_lsn = be64_to_cpu(from->sb_lsn);
@@ -550,6 +552,9 @@ xfs_sb_to_disk(
         if (!fields)
                 return;
 
+        /* We should never write the crc here, it's updated in the IO path */
+        fields &= ~XFS_SB_CRC;
+
         xfs_sb_quota_to_disk(to, from, &fields);
         while (fields) {
                 f = (xfs_sb_field_t)xfs_lowbit64((__uint64_t)fields);
diff --git a/fs/xfs/time.h b/fs/xfs/time.h
deleted file mode 100644
index 387e695a184c..000000000000
--- a/fs/xfs/time.h
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
- * All Rights Reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it would be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write the Free Software Foundation,
- * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-#ifndef __XFS_SUPPORT_TIME_H__
-#define __XFS_SUPPORT_TIME_H__
-
-#include <linux/sched.h>
-#include <linux/time.h>
-
-typedef struct timespec timespec_t;
-
-static inline void delay(long ticks)
-{
-        schedule_timeout_uninterruptible(ticks);
-}
-
-static inline void nanotime(struct timespec *tvp)
-{
-        *tvp = CURRENT_TIME;
-}
-
-#endif /* __XFS_SUPPORT_TIME_H__ */
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 2f502537a39c..f5b2453a43b2 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -560,6 +560,13 @@ xfs_cancel_ioend(
                 do {
                         next_bh = bh->b_private;
                         clear_buffer_async_write(bh);
+                        /*
+                         * The unwritten flag is cleared when added to the
+                         * ioend. We're not submitting for I/O so mark the
+                         * buffer unwritten again for next time around.
+                         */
+                        if (ioend->io_type == XFS_IO_UNWRITTEN)
+                                set_buffer_unwritten(bh);
                         unlock_buffer(bh);
                 } while ((bh = next_bh) != NULL);
 
diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index c2aaa58e59ee..92e8f99a5857 100644
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -1368,14 +1368,14 @@ xfs_zero_file_space(
 
         if (start_boundary < end_boundary - 1) {
                 /*
-                 * punch out delayed allocation blocks and the page cache over
-                 * the conversion range
+                 * Writeback the range to ensure any inode size updates due to
+                 * appending writes make it to disk (otherwise we could just
+                 * punch out the delalloc blocks).
                  */
-                xfs_ilock(ip, XFS_ILOCK_EXCL);
-                error = xfs_bmap_punch_delalloc_range(ip,
-                                XFS_B_TO_FSBT(mp, start_boundary),
-                                XFS_B_TO_FSB(mp, end_boundary - start_boundary));
-                xfs_iunlock(ip, XFS_ILOCK_EXCL);
+                error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
+                                start_boundary, end_boundary - 1);
+                if (error)
+                        goto out;
                 truncate_pagecache_range(VFS_I(ip), start_boundary,
                                          end_boundary - 1);
 
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index e5bbc1f30f16..8ed049d1e332 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -654,7 +654,7 @@ xfs_ialloc(
         xfs_inode_t     *ip;
         uint            flags;
         int             error;
-        timespec_t      tv;
+        struct timespec tv;
 
         /*
          * Call the space management code to pick
@@ -720,7 +720,7 @@ xfs_ialloc(
         ip->i_d.di_nextents = 0;
         ASSERT(ip->i_d.di_nblocks == 0);
 
-        nanotime(&tv);
+        tv = current_fs_time(mp->m_super);
         ip->i_d.di_mtime.t_sec = (__int32_t)tv.tv_sec;
         ip->i_d.di_mtime.t_nsec = (__int32_t)tv.tv_nsec;
         ip->i_d.di_atime = ip->i_d.di_mtime;
@@ -769,6 +769,8 @@ xfs_ialloc(
                                         di_flags |= XFS_DIFLAG_EXTSZINHERIT;
                                         ip->i_d.di_extsize = pip->i_d.di_extsize;
                                 }
+                                if (pip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
+                                        di_flags |= XFS_DIFLAG_PROJINHERIT;
                         } else if (S_ISREG(mode)) {
                                 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
                                         di_flags |= XFS_DIFLAG_REALTIME;
@@ -789,8 +791,6 @@ xfs_ialloc(
                         if ((pip->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) &&
                             xfs_inherit_nosymlinks)
                                 di_flags |= XFS_DIFLAG_NOSYMLINKS;
-                        if (pip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
-                                di_flags |= XFS_DIFLAG_PROJINHERIT;
                         if ((pip->i_d.di_flags & XFS_DIFLAG_NODEFRAG) &&
                             xfs_inherit_nodefrag)
                                 di_flags |= XFS_DIFLAG_NODEFRAG;
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index c10e3fadd9af..9af2882e1f4c 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -102,7 +102,7 @@ xfs_new_eof(struct xfs_inode *ip, xfs_fsize_t new_size)
 {
         xfs_fsize_t i_size = i_size_read(VFS_I(ip));
 
-        if (new_size > i_size)
+        if (new_size > i_size || new_size < 0)
                 new_size = i_size;
         return new_size > ip->i_d.di_size ? new_size : 0;
 }
diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c
index de5a7be36e60..63de0b0acc32 100644
--- a/fs/xfs/xfs_inode_item.c
+++ b/fs/xfs/xfs_inode_item.c
@@ -615,7 +615,7 @@ xfs_iflush_done(
         blip = bp->b_fspriv;
         prev = NULL;
         while (blip != NULL) {
-                if (lip->li_cb != xfs_iflush_done) {
+                if (blip->li_cb != xfs_iflush_done) {
                         prev = blip;
                         blip = blip->li_bio_list;
                         continue;
diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c
index 7a6b406ce6c9..24c926b6fe85 100644
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -968,8 +968,6 @@ xfs_set_diflags(
                 di_flags |= XFS_DIFLAG_NOATIME;
         if (xflags & XFS_XFLAG_NODUMP)
                 di_flags |= XFS_DIFLAG_NODUMP;
-        if (xflags & XFS_XFLAG_PROJINHERIT)
-                di_flags |= XFS_DIFLAG_PROJINHERIT;
         if (xflags & XFS_XFLAG_NODEFRAG)
                 di_flags |= XFS_DIFLAG_NODEFRAG;
         if (xflags & XFS_XFLAG_FILESTREAM)
@@ -981,6 +979,8 @@ xfs_set_diflags(
                         di_flags |= XFS_DIFLAG_NOSYMLINKS;
                 if (xflags & XFS_XFLAG_EXTSZINHERIT)
                         di_flags |= XFS_DIFLAG_EXTSZINHERIT;
+                if (xflags & XFS_XFLAG_PROJINHERIT)
+                        di_flags |= XFS_DIFLAG_PROJINHERIT;
         } else if (S_ISREG(ip->i_d.di_mode)) {
                 if (xflags & XFS_XFLAG_REALTIME)
                         di_flags |= XFS_DIFLAG_REALTIME;
@@ -1231,13 +1231,25 @@ xfs_ioctl_setattr(
 
         }
 
-        if (mask & FSX_EXTSIZE)
-                ip->i_d.di_extsize = fa->fsx_extsize >> mp->m_sb.sb_blocklog;
         if (mask & FSX_XFLAGS) {
                 xfs_set_diflags(ip, fa->fsx_xflags);
                 xfs_diflags_to_linux(ip);
         }
 
+        /*
+         * Only set the extent size hint if we've already determined that the
+         * extent size hint should be set on the inode. If no extent size flags
+         * are set on the inode then unconditionally clear the extent size hint.
+         */
+        if (mask & FSX_EXTSIZE) {
+                int     extsize = 0;
+
+                if (ip->i_d.di_flags &
+                                (XFS_DIFLAG_EXTSIZE | XFS_DIFLAG_EXTSZINHERIT))
+                        extsize = fa->fsx_extsize >> mp->m_sb.sb_blocklog;
+                ip->i_d.di_extsize = extsize;
+        }
+
         xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_CHG);
         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 
diff --git a/fs/xfs/xfs_ioctl32.c b/fs/xfs/xfs_ioctl32.c
index a554646ff141..94ce027e28e3 100644
--- a/fs/xfs/xfs_ioctl32.c
+++ b/fs/xfs/xfs_ioctl32.c
@@ -160,6 +160,7 @@ xfs_ioctl32_bstat_copyin(
             get_user(bstat->bs_gen,     &bstat32->bs_gen)       ||
             get_user(bstat->bs_projid_lo, &bstat32->bs_projid_lo) ||
             get_user(bstat->bs_projid_hi, &bstat32->bs_projid_hi) ||
+            get_user(bstat->bs_forkoff, &bstat32->bs_forkoff)   ||
             get_user(bstat->bs_dmevmask, &bstat32->bs_dmevmask) ||
             get_user(bstat->bs_dmstate, &bstat32->bs_dmstate)   ||
             get_user(bstat->bs_aextents, &bstat32->bs_aextents))
@@ -214,6 +215,7 @@ xfs_bulkstat_one_fmt_compat(
             put_user(buffer->bs_gen,      &p32->bs_gen)         ||
             put_user(buffer->bs_projid,   &p32->bs_projid)      ||
             put_user(buffer->bs_projid_hi,      &p32->bs_projid_hi)     ||
+            put_user(buffer->bs_forkoff,  &p32->bs_forkoff)     ||
             put_user(buffer->bs_dmevmask, &p32->bs_dmevmask)    ||
             put_user(buffer->bs_dmstate,  &p32->bs_dmstate)     ||
             put_user(buffer->bs_aextents, &p32->bs_aextents))
diff --git a/fs/xfs/xfs_ioctl32.h b/fs/xfs/xfs_ioctl32.h
index 80f4060e8970..b1bb45444df8 100644
--- a/fs/xfs/xfs_ioctl32.h
+++ b/fs/xfs/xfs_ioctl32.h
@@ -67,8 +67,9 @@ typedef struct compat_xfs_bstat {
         __u32           bs_gen;         /* generation count             */
         __u16           bs_projid_lo;   /* lower part of project id     */
 #define bs_projid       bs_projid_lo    /* (previously just bs_projid)  */
+        __u16           bs_forkoff;     /* inode fork offset in bytes   */
         __u16           bs_projid_hi;   /* high part of project id      */
-        unsigned char   bs_pad[12];     /* pad space, unused            */
+        unsigned char   bs_pad[10];     /* pad space, unused            */
         __u32           bs_dmevmask;    /* DMIG event mask              */
         __u16           bs_dmstate;     /* DMIG state info              */
         __u16           bs_aextents;    /* attribute number of extents  */
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index e9c47b6f5e5a..afcf3c926565 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -404,8 +404,8 @@ xfs_quota_calc_throttle(
         int shift = 0;
         struct xfs_dquot *dq = xfs_inode_dquot(ip, type);
 
-        /* over hi wmark, squash the prealloc completely */
-        if (dq->q_res_bcount >= dq->q_prealloc_hi_wmark) {
+        /* no dq, or over hi wmark, squash the prealloc completely */
+        if (!dq || dq->q_res_bcount >= dq->q_prealloc_hi_wmark) {
                 *qblocks = 0;
                 *qfreesp = 0;
                 return;
diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c
index f71be9c68017..f1deb961a296 100644
--- a/fs/xfs/xfs_itable.c
+++ b/fs/xfs/xfs_itable.c
@@ -639,7 +639,8 @@ next_ag:
                 xfs_buf_relse(agbp);
                 agbp = NULL;
                 agino = 0;
-        } while (++agno < mp->m_sb.sb_agcount);
+                agno++;
+        } while (agno < mp->m_sb.sb_agcount);
 
         if (!error) {
                 if (bufidx) {
diff --git a/fs/xfs/xfs_linux.h b/fs/xfs/xfs_linux.h
index d10dc8f397c9..6a51619d8690 100644
--- a/fs/xfs/xfs_linux.h
+++ b/fs/xfs/xfs_linux.h
@@ -56,7 +56,6 @@ typedef __uint64_t __psunsigned_t;
 
 #include "kmem.h"
 #include "mrlock.h"
-#include "time.h"
 #include "uuid.h"
 
 #include <linux/semaphore.h>
@@ -179,6 +178,11 @@ typedef __uint64_t __psunsigned_t;
 #define MAX(a,b)        (max(a,b))
 #define howmany(x, y)   (((x)+((y)-1))/(y))
 
+static inline void delay(long ticks)
+{
+        schedule_timeout_uninterruptible(ticks);
+}
+
 /*
  * XFS wrapper structure for sysfs support. It depends on external data
  * structures and is embedded in various internal data structures to implement
diff --git a/fs/xfs/xfs_trans_inode.c b/fs/xfs/xfs_trans_inode.c
index 50c3f5614288..cdb4d86520e1 100644
--- a/fs/xfs/xfs_trans_inode.c
+++ b/fs/xfs/xfs_trans_inode.c
@@ -70,7 +70,7 @@ xfs_trans_ichgtime(
         int                     flags)
 {
         struct inode            *inode = VFS_I(ip);
-        timespec_t              tv;
+        struct timespec         tv;
 
         ASSERT(tp);
         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));