ext4: Properly update i_disksize.

With delayed allocation we use i_data_sem to update i_disksize.  We need
to update i_disksize only if the new size specified is greater than the
current value and we need to make sure we don't race with other
i_disksize update.  With delayed allocation we will switch to the
write_begin function for non-delayed allocation if we are low on free
blocks.  This means the write_begin function for non-delayed allocation
also needs to use the same locking.

We also need to check and update i_disksize even if the new size is less
that inode.i_size because of delayed allocation.

Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

3 files changed, 46 insertions, 28 deletions

diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index e13b9deee866..3e47b99a763c 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -1218,6 +1218,17 @@ do {								\
 #define EXT4_FREEBLOCKS_WATERMARK 0
 #endif
 
+static inline void ext4_update_i_disksize(struct inode *inode, loff_t newsize)
+{
+        /*
+         * XXX: replace with spinlock if seen contended -bzzz
+         */
+        down_write(&EXT4_I(inode)->i_data_sem);
+        if (newsize > EXT4_I(inode)->i_disksize)
+                EXT4_I(inode)->i_disksize = newsize;
+        up_write(&EXT4_I(inode)->i_data_sem);
+        return ;
+}
 
 /*
  * Inodes and files operations
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index 797f0602a68f..e8758df2617b 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -2878,10 +2878,11 @@ static void ext4_falloc_update_inode(struct inode *inode,
          * Update only when preallocation was requested beyond
          * the file size.
          */
-        if (!(mode & FALLOC_FL_KEEP_SIZE) &&
-                                new_size > i_size_read(inode)) {
-                i_size_write(inode, new_size);
-                EXT4_I(inode)->i_disksize = new_size;
+        if (!(mode & FALLOC_FL_KEEP_SIZE)) {
+                if (new_size > i_size_read(inode))
+                        i_size_write(inode, new_size);
+                if (new_size > EXT4_I(inode)->i_disksize)
+                        ext4_update_i_disksize(inode, new_size);
         }
 
 }
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 634f0bc75700..22fcbb67cd88 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -1434,16 +1434,18 @@ static int ext4_ordered_write_end(struct file *file,
         ret = ext4_jbd2_file_inode(handle, inode);
 
         if (ret == 0) {
-                /*
-                 * generic_write_end() will run mark_inode_dirty() if i_size
-                 * changes.  So let's piggyback the i_disksize mark_inode_dirty
-                 * into that.
-                 */
                 loff_t new_i_size;
 
                 new_i_size = pos + copied;
-                if (new_i_size > EXT4_I(inode)->i_disksize)
-                        EXT4_I(inode)->i_disksize = new_i_size;
+                if (new_i_size > EXT4_I(inode)->i_disksize) {
+                        ext4_update_i_disksize(inode, new_i_size);
+                        /* We need to mark inode dirty even if
+                         * new_i_size is less that inode->i_size
+                         * bu greater than i_disksize.(hint delalloc)
+                         */
+                        ext4_mark_inode_dirty(handle, inode);
+                }
+
                 ret2 = generic_write_end(file, mapping, pos, len, copied,
                                                         page, fsdata);
                 copied = ret2;
@@ -1468,8 +1470,14 @@ static int ext4_writeback_write_end(struct file *file,
         loff_t new_i_size;
 
         new_i_size = pos + copied;
-        if (new_i_size > EXT4_I(inode)->i_disksize)
-                EXT4_I(inode)->i_disksize = new_i_size;
+        if (new_i_size > EXT4_I(inode)->i_disksize) {
+                ext4_update_i_disksize(inode, new_i_size);
+                /* We need to mark inode dirty even if
+                 * new_i_size is less that inode->i_size
+                 * bu greater than i_disksize.(hint delalloc)
+                 */
+                ext4_mark_inode_dirty(handle, inode);
+        }
 
         ret2 = generic_write_end(file, mapping, pos, len, copied,
                                                         page, fsdata);
@@ -1494,6 +1502,7 @@ static int ext4_journalled_write_end(struct file *file,
         int ret = 0, ret2;
         int partial = 0;
         unsigned from, to;
+        loff_t new_i_size;
 
         from = pos & (PAGE_CACHE_SIZE - 1);
         to = from + len;
@@ -1508,11 +1517,12 @@ static int ext4_journalled_write_end(struct file *file,
                                 to, &partial, write_end_fn);
         if (!partial)
                 SetPageUptodate(page);
-        if (pos+copied > inode->i_size)
+        new_i_size = pos + copied;
+        if (new_i_size > inode->i_size)
                 i_size_write(inode, pos+copied);
         EXT4_I(inode)->i_state |= EXT4_STATE_JDATA;
-        if (inode->i_size > EXT4_I(inode)->i_disksize) {
-                EXT4_I(inode)->i_disksize = inode->i_size;
+        if (new_i_size > EXT4_I(inode)->i_disksize) {
+                ext4_update_i_disksize(inode, new_i_size);
                 ret2 = ext4_mark_inode_dirty(handle, inode);
                 if (!ret)
                         ret = ret2;
@@ -2227,18 +2237,9 @@ static int ext4_da_get_block_write(struct inode *inode, sector_t iblock,
                 if (disksize > i_size_read(inode))
                         disksize = i_size_read(inode);
                 if (disksize > EXT4_I(inode)->i_disksize) {
-                        /*
-                         * XXX: replace with spinlock if seen contended -bzzz
-                         */
-                        down_write(&EXT4_I(inode)->i_data_sem);
-                        if (disksize > EXT4_I(inode)->i_disksize)
-                                EXT4_I(inode)->i_disksize = disksize;
-                        up_write(&EXT4_I(inode)->i_data_sem);
-
-                        if (EXT4_I(inode)->i_disksize == disksize) {
-                                ret = ext4_mark_inode_dirty(handle, inode);
-                                return ret;
-                        }
+                        ext4_update_i_disksize(inode, disksize);
+                        ret = ext4_mark_inode_dirty(handle, inode);
+                        return ret;
                 }
                 ret = 0;
         }
@@ -2654,6 +2655,11 @@ static int ext4_da_write_end(struct file *file,
                                 EXT4_I(inode)->i_disksize = new_i_size;
                         }
                         up_write(&EXT4_I(inode)->i_data_sem);
+                        /* We need to mark inode dirty even if
+                         * new_i_size is less that inode->i_size
+                         * bu greater than i_disksize.(hint delalloc)
+                         */
+                        ext4_mark_inode_dirty(handle, inode);
                 }
         }
         ret2 = generic_write_end(file, mapping, pos, len, copied,