[XFS] Fix to prevent the notorious 'NULL files' problem after a crash.

The problem that has been addressed is that of synchronising updates of
the file size with writes that extend a file. Without the fix the update
of a file's size, as a result of a write beyond eof, is independent of
when the cached data is flushed to disk. Often the file size update would
be written to the filesystem log before the data is flushed to disk. When
a system crashes between these two events and the filesystem log is
replayed on mount the file's size will be set but since the contents never
made it to disk the file is full of holes. If some of the cached data was
flushed to disk then it may just be a section of the file at the end that
has holes.

There are existing fixes to help alleviate this problem, particularly in
the case where a file has been truncated, that force cached data to be
flushed to disk when the file is closed. If the system crashes while the
file(s) are still open then this flushing will never occur.

The fix that we have implemented is to introduce a second file size,
called the in-memory file size, that represents the current file size as
viewed by the user. The existing file size, called the on-disk file size,
is the one that get's written to the filesystem log and we only update it
when it is safe to do so. When we write to a file beyond eof we only
update the in- memory file size in the write operation. Later when the I/O
operation, that flushes the cached data to disk completes, an I/O
completion routine will update the on-disk file size. The on-disk file
size will be updated to the maximum offset of the I/O or to the value of
the in-memory file size if the I/O includes eof.

SGI-PV: 958522
SGI-Modid: xfs-linux-melb:xfs-kern:28322a

Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Tim Shimmin <tes@sgi.com>

1 files changed, 55 insertions, 36 deletions

diff --git a/fs/xfs/linux-2.6/xfs_lrw.c b/fs/xfs/linux-2.6/xfs_lrw.c
index 80fe3123347..82ab792c7fc 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.c
+++ b/fs/xfs/linux-2.6/xfs_lrw.c
@@ -224,7 +224,7 @@ xfs_read(
                                 mp->m_rtdev_targp : mp->m_ddev_targp;
                 if ((*offset & target->bt_smask) ||
                     (size & target->bt_smask)) {
-                        if (*offset == ip->i_d.di_size) {
+                        if (*offset == ip->i_size) {
                                 return (0);
                         }
                         return -XFS_ERROR(EINVAL);
@@ -387,9 +387,10 @@ xfs_splice_write(
 {
         xfs_inode_t             *ip = XFS_BHVTOI(bdp);
         xfs_mount_t             *mp = ip->i_mount;
+        xfs_iocore_t            *io = &ip->i_iocore;
         ssize_t                 ret;
         struct inode            *inode = outfilp->f_mapping->host;
-        xfs_fsize_t             isize;
+        xfs_fsize_t             isize, new_size;
 
         XFS_STATS_INC(xs_write_calls);
         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
@@ -410,6 +411,14 @@ xfs_splice_write(
                         return -error;
                 }
         }
+
+        new_size = *ppos + count;
+
+        xfs_ilock(ip, XFS_ILOCK_EXCL);
+        if (new_size > ip->i_size)
+                io->io_new_size = new_size;
+        xfs_iunlock(ip, XFS_ILOCK_EXCL);
+
         xfs_rw_enter_trace(XFS_SPLICE_WRITE_ENTER, &ip->i_iocore,
                            pipe, count, *ppos, ioflags);
         ret = generic_file_splice_write(pipe, outfilp, ppos, count, flags);
@@ -420,14 +429,18 @@ xfs_splice_write(
         if (unlikely(ret < 0 && ret != -EFAULT && *ppos > isize))
                 *ppos = isize;
 
-        if (*ppos > ip->i_d.di_size) {
+        if (*ppos > ip->i_size) {
                 xfs_ilock(ip, XFS_ILOCK_EXCL);
-                if (*ppos > ip->i_d.di_size) {
-                        ip->i_d.di_size = *ppos;
-                        i_size_write(inode, *ppos);
-                        ip->i_update_core = 1;
-                        ip->i_update_size = 1;
-                }
+                if (*ppos > ip->i_size)
+                        ip->i_size = *ppos;
+                xfs_iunlock(ip, XFS_ILOCK_EXCL);
+        }
+
+        if (io->io_new_size) {
+                xfs_ilock(ip, XFS_ILOCK_EXCL);
+                io->io_new_size = 0;
+                if (ip->i_d.di_size > ip->i_size)
+                        ip->i_d.di_size = ip->i_size;
                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
         }
         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
@@ -711,8 +724,6 @@ start:
                 goto out_unlock_mutex;
         }
 
-        isize = i_size_read(inode);
-
         if (ioflags & IO_ISDIRECT) {
                 xfs_buftarg_t   *target =
                         (xip->i_d.di_flags & XFS_DIFLAG_REALTIME) ?
@@ -723,7 +734,7 @@ start:
                         return XFS_ERROR(-EINVAL);
                 }
 
-                if (!need_i_mutex && (VN_CACHED(vp) || pos > isize)) {
+                if (!need_i_mutex && (VN_CACHED(vp) || pos > xip->i_size)) {
                         xfs_iunlock(xip, XFS_ILOCK_EXCL|iolock);
                         iolock = XFS_IOLOCK_EXCL;
                         locktype = VRWLOCK_WRITE;
@@ -735,7 +746,7 @@ start:
         }
 
         new_size = pos + count;
-        if (new_size > isize)
+        if (new_size > xip->i_size)
                 io->io_new_size = new_size;
 
         if ((DM_EVENT_ENABLED(vp->v_vfsp, xip, DM_EVENT_WRITE) &&
@@ -751,8 +762,7 @@ start:
                                       pos, count,
                                       dmflags, &locktype);
                 if (error) {
-                        xfs_iunlock(xip, iolock);
-                        goto out_unlock_mutex;
+                        goto out_unlock_internal;
                 }
                 xfs_ilock(xip, XFS_ILOCK_EXCL);
                 eventsent = 1;
@@ -764,9 +774,8 @@ start:
                  * event prevents another call to XFS_SEND_DATA, which is
                  * what allows the size to change in the first place.
                  */
-                if ((file->f_flags & O_APPEND) && savedsize != isize) {
+                if ((file->f_flags & O_APPEND) && savedsize != xip->i_size)
                         goto start;
-                }
         }
 
         if (likely(!(ioflags & IO_INVIS))) {
@@ -784,11 +793,11 @@ start:
          * to zero it out up to the new size.
          */
 
-        if (pos > isize) {
-                error = xfs_zero_eof(BHV_TO_VNODE(bdp), io, pos, isize);
+        if (pos > xip->i_size) {
+                error = xfs_zero_eof(BHV_TO_VNODE(bdp), io, pos, xip->i_size);
                 if (error) {
-                        xfs_iunlock(xip, XFS_ILOCK_EXCL|iolock);
-                        goto out_unlock_mutex;
+                        xfs_iunlock(xip, XFS_ILOCK_EXCL);
+                        goto out_unlock_internal;
                 }
         }
         xfs_iunlock(xip, XFS_ILOCK_EXCL);
@@ -808,8 +817,7 @@ start:
                 if (likely(!error))
                         error = -remove_suid(file->f_path.dentry);
                 if (unlikely(error)) {
-                        xfs_iunlock(xip, iolock);
-                        goto out_unlock_mutex;
+                        goto out_unlock_internal;
                 }
         }
 
@@ -879,12 +887,12 @@ retry:
                 error = XFS_SEND_NAMESP(xip->i_mount, DM_EVENT_NOSPACE, vp,
                                 DM_RIGHT_NULL, vp, DM_RIGHT_NULL, NULL, NULL,
                                 0, 0, 0); /* Delay flag intentionally  unused */
-                if (error)
-                        goto out_nounlocks;
                 if (need_i_mutex)
                         mutex_lock(&inode->i_mutex);
                 xfs_rwlock(bdp, locktype);
-                pos = xip->i_d.di_size;
+                if (error)
+                        goto out_unlock_internal;
+                pos = xip->i_size;
                 ret = 0;
                 goto retry;
         }
@@ -893,14 +901,10 @@ retry:
         if (unlikely(ret < 0 && ret != -EFAULT && *offset > isize))
                 *offset = isize;
 
-        if (*offset > xip->i_d.di_size) {
+        if (*offset > xip->i_size) {
                 xfs_ilock(xip, XFS_ILOCK_EXCL);
-                if (*offset > xip->i_d.di_size) {
-                        xip->i_d.di_size = *offset;
-                        i_size_write(inode, *offset);
-                        xip->i_update_core = 1;
-                        xip->i_update_size = 1;
-                }
+                if (*offset > xip->i_size)
+                        xip->i_size = *offset;
                 xfs_iunlock(xip, XFS_ILOCK_EXCL);
         }
 
@@ -922,16 +926,31 @@ retry:
 
                 error = sync_page_range(inode, mapping, pos, ret);
                 if (!error)
-                        error = ret;
-                return error;
+                        error = -ret;
+                if (need_i_mutex)
+                        mutex_lock(&inode->i_mutex);
+                xfs_rwlock(bdp, locktype);
         }
 
  out_unlock_internal:
+        if (io->io_new_size) {
+                xfs_ilock(xip, XFS_ILOCK_EXCL);
+                io->io_new_size = 0;
+                /*
+                 * If this was a direct or synchronous I/O that failed (such
+                 * as ENOSPC) then part of the I/O may have been written to
+                 * disk before the error occured.  In this case the on-disk
+                 * file size may have been adjusted beyond the in-memory file
+                 * size and now needs to be truncated back.
+                 */
+                if (xip->i_d.di_size > xip->i_size)
+                        xip->i_d.di_size = xip->i_size;
+                xfs_iunlock(xip, XFS_ILOCK_EXCL);
+        }
         xfs_rwunlock(bdp, locktype);
  out_unlock_mutex:
         if (need_i_mutex)
                 mutex_unlock(&inode->i_mutex);
- out_nounlocks:
         return -error;
 }