10 files changed, 53 insertions, 22 deletions

diff --git a/fs/xfs/linux-2.6/xfs_fs_subr.c b/fs/xfs/linux-2.6/xfs_fs_subr.c
index dc0562828e76..2eb87cd082af 100644
--- a/fs/xfs/linux-2.6/xfs_fs_subr.c
+++ b/fs/xfs/linux-2.6/xfs_fs_subr.c
@@ -35,7 +35,7 @@ fs_tosspages(
                 truncate_inode_pages(ip->i_mapping, first);
 }
 
-void
+int
 fs_flushinval_pages(
         bhv_desc_t      *bdp,
         xfs_off_t       first,
@@ -44,13 +44,16 @@ fs_flushinval_pages(
 {
         bhv_vnode_t     *vp = BHV_TO_VNODE(bdp);
         struct inode    *ip = vn_to_inode(vp);
+        int             ret = 0;
 
         if (VN_CACHED(vp)) {
                 if (VN_TRUNC(vp))
                         VUNTRUNCATE(vp);
-                filemap_write_and_wait(ip->i_mapping);
-                truncate_inode_pages(ip->i_mapping, first);
+                ret = filemap_write_and_wait(ip->i_mapping);
+                if (!ret)
+                        truncate_inode_pages(ip->i_mapping, first);
         }
+        return ret;
 }
 
 int
@@ -63,14 +66,18 @@ fs_flush_pages(
 {
         bhv_vnode_t     *vp = BHV_TO_VNODE(bdp);
         struct inode    *ip = vn_to_inode(vp);
+        int             ret = 0;
+        int             ret2;
 
         if (VN_DIRTY(vp)) {
                 if (VN_TRUNC(vp))
                         VUNTRUNCATE(vp);
-                filemap_fdatawrite(ip->i_mapping);
+                ret = filemap_fdatawrite(ip->i_mapping);
                 if (flags & XFS_B_ASYNC)
-                        return 0;
-                filemap_fdatawait(ip->i_mapping);
+                        return ret;
+                ret2 = filemap_fdatawait(ip->i_mapping);
+                if (!ret)
+                        ret = ret2;
         }
-        return 0;
+        return ret;
 }
diff --git a/fs/xfs/linux-2.6/xfs_fs_subr.h b/fs/xfs/linux-2.6/xfs_fs_subr.h
index aee9ccdd18f7..c1b53118a303 100644
--- a/fs/xfs/linux-2.6/xfs_fs_subr.h
+++ b/fs/xfs/linux-2.6/xfs_fs_subr.h
@@ -23,7 +23,7 @@ extern int  fs_noerr(void);
 extern int  fs_nosys(void);
 extern void fs_noval(void);
 extern void fs_tosspages(bhv_desc_t *, xfs_off_t, xfs_off_t, int);
-extern void fs_flushinval_pages(bhv_desc_t *, xfs_off_t, xfs_off_t, int);
+extern int  fs_flushinval_pages(bhv_desc_t *, xfs_off_t, xfs_off_t, int);
 extern int  fs_flush_pages(bhv_desc_t *, xfs_off_t, xfs_off_t, uint64_t, int);
 
 #endif  /* __XFS_FS_SUBR_H__ */
diff --git a/fs/xfs/linux-2.6/xfs_lrw.c b/fs/xfs/linux-2.6/xfs_lrw.c
index ff8d64eba9f8..8e46c9798fbf 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.c
+++ b/fs/xfs/linux-2.6/xfs_lrw.c
@@ -191,7 +191,7 @@ xfs_read(
         struct file             *file = iocb->ki_filp;
         struct inode            *inode = file->f_mapping->host;
         size_t                  size = 0;
-        ssize_t                 ret;
+        ssize_t                 ret = 0;
         xfs_fsize_t             n;
         xfs_inode_t             *ip;
         xfs_mount_t             *mp;
@@ -263,9 +263,13 @@ xfs_read(
 
         if (unlikely(ioflags & IO_ISDIRECT)) {
                 if (VN_CACHED(vp))
-                        bhv_vop_flushinval_pages(vp, ctooff(offtoct(*offset)),
+                        ret = bhv_vop_flushinval_pages(vp, ctooff(offtoct(*offset)),
                                                  -1, FI_REMAPF_LOCKED);
                 mutex_unlock(&inode->i_mutex);
+                if (ret) {
+                        xfs_iunlock(ip, XFS_IOLOCK_SHARED);
+                        return ret;
+                }
         }
 
         xfs_rw_enter_trace(XFS_READ_ENTER, &ip->i_iocore,
@@ -814,8 +818,10 @@ retry:
                 if (need_flush) {
                         xfs_inval_cached_trace(io, pos, -1,
                                         ctooff(offtoct(pos)), -1);
-                        bhv_vop_flushinval_pages(vp, ctooff(offtoct(pos)),
+                        error = bhv_vop_flushinval_pages(vp, ctooff(offtoct(pos)),
                                         -1, FI_REMAPF_LOCKED);
+                        if (error)
+                                goto out_unlock_internal;
                 }
 
                 if (need_i_mutex) {
diff --git a/fs/xfs/linux-2.6/xfs_vnode.h b/fs/xfs/linux-2.6/xfs_vnode.h
index b76118cf4897..d1b2d01843d1 100644
--- a/fs/xfs/linux-2.6/xfs_vnode.h
+++ b/fs/xfs/linux-2.6/xfs_vnode.h
@@ -194,7 +194,7 @@ typedef	int	(*vop_attr_list_t)(bhv_desc_t *, char *, int, int,
 typedef void    (*vop_link_removed_t)(bhv_desc_t *, bhv_vnode_t *, int);
 typedef void    (*vop_vnode_change_t)(bhv_desc_t *, bhv_vchange_t, __psint_t);
 typedef void    (*vop_ptossvp_t)(bhv_desc_t *, xfs_off_t, xfs_off_t, int);
-typedef void    (*vop_pflushinvalvp_t)(bhv_desc_t *, xfs_off_t, xfs_off_t, int);
+typedef int     (*vop_pflushinvalvp_t)(bhv_desc_t *, xfs_off_t, xfs_off_t, int);
 typedef int     (*vop_pflushvp_t)(bhv_desc_t *, xfs_off_t, xfs_off_t,
                                 uint64_t, int);
 typedef int     (*vop_iflush_t)(bhv_desc_t *, int);
diff --git a/fs/xfs/xfs_dfrag.c b/fs/xfs/xfs_dfrag.c
index fb6f22c511e2..de35d18cc002 100644
--- a/fs/xfs/xfs_dfrag.c
+++ b/fs/xfs/xfs_dfrag.c
@@ -199,7 +199,9 @@ xfs_swap_extents(
 
         if (VN_CACHED(tvp) != 0) {
                 xfs_inval_cached_trace(&tip->i_iocore, 0, -1, 0, -1);
-                bhv_vop_flushinval_pages(tvp, 0, -1, FI_REMAPF_LOCKED);
+                error = bhv_vop_flushinval_pages(tvp, 0, -1, FI_REMAPF_LOCKED);
+                if (error)
+                        goto error0;
         }
 
         /* Verify O_DIRECT for ftmp */
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 3541d19859e1..7d1ab3967b8e 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -1421,7 +1421,7 @@ xfs_itrunc_trace(
  * must be called again with all the same restrictions as the initial
  * call.
  */
-void
+int
 xfs_itruncate_start(
         xfs_inode_t     *ip,
         uint            flags,
@@ -1431,6 +1431,7 @@ xfs_itruncate_start(
         xfs_off_t       toss_start;
         xfs_mount_t     *mp;
         bhv_vnode_t     *vp;
+        int             error = 0;
 
         ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE) != 0);
         ASSERT((new_size == 0) || (new_size <= ip->i_d.di_size));
@@ -1468,7 +1469,7 @@ xfs_itruncate_start(
                  * file size, so there is no way that the data extended
                  * out there.
                  */
-                return;
+                return 0;
         }
         last_byte = xfs_file_last_byte(ip);
         xfs_itrunc_trace(XFS_ITRUNC_START, ip, flags, new_size, toss_start,
@@ -1477,7 +1478,7 @@ xfs_itruncate_start(
                 if (flags & XFS_ITRUNC_DEFINITE) {
                         bhv_vop_toss_pages(vp, toss_start, -1, FI_REMAPF_LOCKED);
                 } else {
-                        bhv_vop_flushinval_pages(vp, toss_start, -1, FI_REMAPF_LOCKED);
+                        error = bhv_vop_flushinval_pages(vp, toss_start, -1, FI_REMAPF_LOCKED);
                 }
         }
 
@@ -1486,6 +1487,7 @@ xfs_itruncate_start(
                 ASSERT(VN_CACHED(vp) == 0);
         }
 #endif
+        return error;
 }
 
 /*
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index bc823720d88f..699960f3459f 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -481,7 +481,7 @@ uint		xfs_ip2xflags(struct xfs_inode *);
 uint            xfs_dic2xflags(struct xfs_dinode_core *);
 int             xfs_ifree(struct xfs_trans *, xfs_inode_t *,
                            struct xfs_bmap_free *);
-void            xfs_itruncate_start(xfs_inode_t *, uint, xfs_fsize_t);
+int             xfs_itruncate_start(xfs_inode_t *, uint, xfs_fsize_t);
 int             xfs_itruncate_finish(struct xfs_trans **, xfs_inode_t *,
                                      xfs_fsize_t, int, int);
 int             xfs_iunlink(struct xfs_trans *, xfs_inode_t *);
diff --git a/fs/xfs/xfs_utils.c b/fs/xfs/xfs_utils.c
index 948b0c892e96..20ffec308e1e 100644
--- a/fs/xfs/xfs_utils.c
+++ b/fs/xfs/xfs_utils.c
@@ -420,7 +420,11 @@ xfs_truncate_file(
          * in a transaction.
          */
         xfs_ilock(ip, XFS_IOLOCK_EXCL);
-        xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE, (xfs_fsize_t)0);
+        error = xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE, (xfs_fsize_t)0);
+        if (error) {
+                xfs_iunlock(ip, XFS_IOLOCK_EXCL);
+                return error;
+        }
 
         tp = xfs_trans_alloc(mp, XFS_TRANS_TRUNCATE_FILE);
         if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
diff --git a/fs/xfs/xfs_vfsops.c b/fs/xfs/xfs_vfsops.c
index 22a09273748f..2e830e7f52e0 100644
--- a/fs/xfs/xfs_vfsops.c
+++ b/fs/xfs/xfs_vfsops.c
@@ -1147,7 +1147,7 @@ xfs_sync_inodes(
                         if (XFS_FORCED_SHUTDOWN(mp)) {
                                 bhv_vop_toss_pages(vp, 0, -1, FI_REMAPF);
                         } else {
-                                bhv_vop_flushinval_pages(vp, 0, -1, FI_REMAPF);
+                                error = bhv_vop_flushinval_pages(vp, 0, -1, FI_REMAPF);
                         }
 
                         xfs_ilock(ip, XFS_ILOCK_SHARED);
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 5ed349eccb00..6e49bd362460 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -1257,8 +1257,12 @@ xfs_inactive_free_eofblocks(
                  * do that within a transaction.
                  */
                 xfs_ilock(ip, XFS_IOLOCK_EXCL);
-                xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE,
+                error = xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE,
                                     ip->i_d.di_size);
+                if (error) {
+                        xfs_iunlock(ip, XFS_IOLOCK_EXCL);
+                        return error;
+                }
 
                 error = xfs_trans_reserve(tp, 0,
                                           XFS_ITRUNCATE_LOG_RES(mp),
@@ -1674,7 +1678,11 @@ xfs_inactive(
                  */
                 xfs_ilock(ip, XFS_IOLOCK_EXCL);
 
-                xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE, 0);
+                error = xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE, 0);
+                if (error) {
+                        xfs_iunlock(ip, XFS_IOLOCK_EXCL);
+                        return VN_INACTIVE_CACHE;
+                }
 
                 error = xfs_trans_reserve(tp, 0,
                                           XFS_ITRUNCATE_LOG_RES(mp),
@@ -4338,8 +4346,10 @@ xfs_free_file_space(
         if (VN_CACHED(vp) != 0) {
                 xfs_inval_cached_trace(&ip->i_iocore, ioffset, -1,
                                 ctooff(offtoct(ioffset)), -1);
-                bhv_vop_flushinval_pages(vp, ctooff(offtoct(ioffset)),
+                error = bhv_vop_flushinval_pages(vp, ctooff(offtoct(ioffset)),
                                 -1, FI_REMAPF_LOCKED);
+                if (error)
+                        goto out_unlock_iolock;
         }
 
         /*