get rid of block_write_begin_newtrunc

Move the call to vmtruncate to get rid of accessive blocks to the callers
in preparation of the new truncate sequence and rename the non-truncating
version to block_write_begin.

While we're at it also remove several unused arguments to block_write_begin.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

12 files changed, 101 insertions, 85 deletions

diff --git a/fs/bfs/file.c b/fs/bfs/file.c
index 88b9a3ff44e4..8fc2e9c9739d 100644
--- a/fs/bfs/file.c
+++ b/fs/bfs/file.c
@@ -168,9 +168,17 @@ static int bfs_write_begin(struct file *file, struct address_space *mapping,
                         loff_t pos, unsigned len, unsigned flags,
                         struct page **pagep, void **fsdata)
 {
-        *pagep = NULL;
-        return block_write_begin(file, mapping, pos, len, flags,
-                                        pagep, fsdata, bfs_get_block);
+        int ret;
+
+        ret = block_write_begin(mapping, pos, len, flags, pagep,
+                                bfs_get_block);
+        if (unlikely(ret)) {
+                loff_t isize = mapping->host->i_size;
+                if (pos + len > isize)
+                        vmtruncate(mapping->host, isize);
+        }
+
+        return ret;
 }
 
 static sector_t bfs_bmap(struct address_space *mapping, sector_t block)
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 65a0c26508e5..63c9d6076205 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -308,9 +308,8 @@ static int blkdev_write_begin(struct file *file, struct address_space *mapping,
                         loff_t pos, unsigned len, unsigned flags,
                         struct page **pagep, void **fsdata)
 {
-        *pagep = NULL;
-        return block_write_begin_newtrunc(file, mapping, pos, len, flags,
-                                pagep, fsdata, blkdev_get_block);
+        return block_write_begin(mapping, pos, len, flags, pagep,
+                                 blkdev_get_block);
 }
 
 static int blkdev_write_end(struct file *file, struct address_space *mapping,
diff --git a/fs/buffer.c b/fs/buffer.c
index c319c49da511..50efa339e051 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -1962,14 +1962,13 @@ int __block_write_begin(struct page *page, loff_t pos, unsigned len,
 EXPORT_SYMBOL(__block_write_begin);
 
 /*
- * Filesystems implementing the new truncate sequence should use the
- * _newtrunc postfix variant which won't incorrectly call vmtruncate.
+ * block_write_begin takes care of the basic task of block allocation and
+ * bringing partial write blocks uptodate first.
+ *
  * The filesystem needs to handle block truncation upon failure.
  */
-int block_write_begin_newtrunc(struct file *file, struct address_space *mapping,
-                        loff_t pos, unsigned len, unsigned flags,
-                        struct page **pagep, void **fsdata,
-                        get_block_t *get_block)
+int block_write_begin(struct address_space *mapping, loff_t pos, unsigned len,
+                unsigned flags, struct page **pagep, get_block_t *get_block)
 {
         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
         struct page *page;
@@ -1989,44 +1988,6 @@ int block_write_begin_newtrunc(struct file *file, struct address_space *mapping,
         *pagep = page;
         return status;
 }
-EXPORT_SYMBOL(block_write_begin_newtrunc);
-
-/*
- * block_write_begin takes care of the basic task of block allocation and
- * bringing partial write blocks uptodate first.
- *
- * If *pagep is not NULL, then block_write_begin uses the locked page
- * at *pagep rather than allocating its own. In this case, the page will
- * not be unlocked or deallocated on failure.
- */
-int block_write_begin(struct file *file, struct address_space *mapping,
-                        loff_t pos, unsigned len, unsigned flags,
-                        struct page **pagep, void **fsdata,
-                        get_block_t *get_block)
-{
-        int ret;
-
-        ret = block_write_begin_newtrunc(file, mapping, pos, len, flags,
-                                        pagep, fsdata, get_block);
-
-        /*
-         * prepare_write() may have instantiated a few blocks
-         * outside i_size.  Trim these off again. Don't need
-         * i_size_read because we hold i_mutex.
-         *
-         * Filesystems which pass down their own page also cannot
-         * call into vmtruncate here because it would lead to lock
-         * inversion problems (*pagep is locked). This is a further
-         * example of where the old truncate sequence is inadequate.
-         */
-        if (unlikely(ret) && *pagep == NULL) {
-                loff_t isize = mapping->host->i_size;
-                if (pos + len > isize)
-                        vmtruncate(mapping->host, isize);
-        }
-
-        return ret;
-}
 EXPORT_SYMBOL(block_write_begin);
 
 int block_write_end(struct file *file, struct address_space *mapping,
@@ -2357,7 +2318,7 @@ int cont_write_begin(struct file *file, struct address_space *mapping,
 
         err = cont_expand_zero(file, mapping, pos, bytes);
         if (err)
-                goto out;
+                return err;
 
         zerofrom = *bytes & ~PAGE_CACHE_MASK;
         if (pos+len > *bytes && zerofrom & (blocksize-1)) {
@@ -2365,11 +2326,7 @@ int cont_write_begin(struct file *file, struct address_space *mapping,
                 (*bytes)++;
         }
 
-        *pagep = NULL;
-        err = block_write_begin_newtrunc(file, mapping, pos, len,
-                                flags, pagep, fsdata, get_block);
-out:
-        return err;
+        return block_write_begin(mapping, pos, len, flags, pagep, get_block);
 }
 EXPORT_SYMBOL(cont_write_begin);
 
@@ -2511,8 +2468,8 @@ int nobh_write_begin(struct address_space *mapping,
                 unlock_page(page);
                 page_cache_release(page);
                 *pagep = NULL;
-                return block_write_begin_newtrunc(NULL, mapping, pos, len,
-                                        flags, pagep, fsdata, get_block);
+                return block_write_begin(mapping, pos, len, flags, pagep,
+                                         get_block);
         }
 
         if (PageMappedToDisk(page))
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 2f4dfbcd7696..74dfe5f73330 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -772,9 +772,8 @@ ext2_write_begin(struct file *file, struct address_space *mapping,
 {
         int ret;
 
-        *pagep = NULL;
-        ret = block_write_begin_newtrunc(file, mapping, pos, len, flags,
-                                         pagep, fsdata, ext2_get_block);
+        ret = block_write_begin(mapping, pos, len, flags, pagep,
+                                ext2_get_block);
         if (ret < 0)
                 ext2_write_failed(mapping, pos + len);
         return ret;
diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index 6b29e73f0ca6..125062f55ef2 100644
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -366,9 +366,17 @@ static int minix_write_begin(struct file *file, struct address_space *mapping,
                         loff_t pos, unsigned len, unsigned flags,
                         struct page **pagep, void **fsdata)
 {
-        *pagep = NULL;
-        return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
+        int ret;
+
+        ret = block_write_begin(mapping, pos, len, flags, pagep,
                                 minix_get_block);
+        if (unlikely(ret)) {
+                loff_t isize = mapping->host->i_size;
+                if (pos + len > isize)
+                        vmtruncate(mapping->host, isize);
+        }
+
+        return ret;
 }
 
 static sector_t minix_bmap(struct address_space *mapping, sector_t block)
diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
index 1dd9e6a7d787..5c694ece172e 100644
--- a/fs/nilfs2/inode.c
+++ b/fs/nilfs2/inode.c
@@ -197,11 +197,15 @@ static int nilfs_write_begin(struct file *file, struct address_space *mapping,
         if (unlikely(err))
                 return err;
 
-        *pagep = NULL;
-        err = block_write_begin(file, mapping, pos, len, flags, pagep,
-                                fsdata, nilfs_get_block);
-        if (unlikely(err))
+        err = block_write_begin(mapping, pos, len, flags, pagep,
+                                nilfs_get_block);
+        if (unlikely(err)) {
+                loff_t isize = mapping->host->i_size;
+                if (pos + len > isize)
+                        vmtruncate(mapping->host, isize);
+
                 nilfs_transaction_abort(inode->i_sb);
+        }
         return err;
 }
 
diff --git a/fs/nilfs2/recovery.c b/fs/nilfs2/recovery.c
index bae2a516b4ee..2f11f0868d87 100644
--- a/fs/nilfs2/recovery.c
+++ b/fs/nilfs2/recovery.c
@@ -505,11 +505,14 @@ static int recover_dsync_blocks(struct nilfs_sb_info *sbi,
                 }
 
                 pos = rb->blkoff << inode->i_blkbits;
-                page = NULL;
-                err = block_write_begin(NULL, inode->i_mapping, pos, blocksize,
-                                        0, &page, NULL, nilfs_get_block);
-                if (unlikely(err))
+                err = block_write_begin(inode->i_mapping, pos, blocksize,
+                                        0, &page, nilfs_get_block);
+                if (unlikely(err)) {
+                        loff_t isize = inode->i_size;
+                        if (pos + blocksize > isize)
+                                vmtruncate(inode, isize);
                         goto failed_inode;
+                }
 
                 err = nilfs_recovery_copy_block(sbi, rb, page);
                 if (unlikely(err))
diff --git a/fs/omfs/file.c b/fs/omfs/file.c
index 6e7a3291bbe8..810cff346468 100644
--- a/fs/omfs/file.c
+++ b/fs/omfs/file.c
@@ -312,9 +312,17 @@ static int omfs_write_begin(struct file *file, struct address_space *mapping,
                         loff_t pos, unsigned len, unsigned flags,
                         struct page **pagep, void **fsdata)
 {
-        *pagep = NULL;
-        return block_write_begin(file, mapping, pos, len, flags,
-                                pagep, fsdata, omfs_get_block);
+        int ret;
+
+        ret = block_write_begin(mapping, pos, len, flags, pagep,
+                                omfs_get_block);
+        if (unlikely(ret)) {
+                loff_t isize = mapping->host->i_size;
+                if (pos + len > isize)
+                        vmtruncate(mapping->host, isize);
+        }
+
+        return ret;
 }
 
 static sector_t omfs_bmap(struct address_space *mapping, sector_t block)
diff --git a/fs/sysv/itree.c b/fs/sysv/itree.c
index 82a005c3d7eb..9ca66276315e 100644
--- a/fs/sysv/itree.c
+++ b/fs/sysv/itree.c
@@ -468,9 +468,16 @@ static int sysv_write_begin(struct file *file, struct address_space *mapping,
                         loff_t pos, unsigned len, unsigned flags,
                         struct page **pagep, void **fsdata)
 {
-        *pagep = NULL;
-        return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
-                                get_block);
+        int ret;
+
+        ret = block_write_begin(mapping, pos, len, flags, pagep, get_block);
+        if (unlikely(ret)) {
+                loff_t isize = mapping->host->i_size;
+                if (pos + len > isize)
+                        vmtruncate(mapping->host, isize);
+        }
+
+        return ret;
 }
 
 static sector_t sysv_bmap(struct address_space *mapping, sector_t block)
diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index 124852bcf6fe..ecddcc2ed746 100644
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -127,9 +127,16 @@ static int udf_write_begin(struct file *file, struct address_space *mapping,
                         loff_t pos, unsigned len, unsigned flags,
                         struct page **pagep, void **fsdata)
 {
-        *pagep = NULL;
-        return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
-                                udf_get_block);
+        int ret;
+
+        ret = block_write_begin(mapping, pos, len, flags, pagep, udf_get_block);
+        if (unlikely(ret)) {
+                loff_t isize = mapping->host->i_size;
+                if (pos + len > isize)
+                        vmtruncate(mapping->host, isize);
+        }
+
+        return ret;
 }
 
 static sector_t udf_bmap(struct address_space *mapping, sector_t block)
diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index 45ce32391f8f..45cafa937a4b 100644
--- a/fs/ufs/inode.c
+++ b/fs/ufs/inode.c
@@ -567,9 +567,17 @@ static int ufs_write_begin(struct file *file, struct address_space *mapping,
                         loff_t pos, unsigned len, unsigned flags,
                         struct page **pagep, void **fsdata)
 {
-        *pagep = NULL;
-        return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
+        int ret;
+
+        ret = block_write_begin(mapping, pos, len, flags, pagep,
                                 ufs_getfrag_block);
+        if (unlikely(ret)) {
+                loff_t isize = mapping->host->i_size;
+                if (pos + len > isize)
+                        vmtruncate(mapping->host, isize);
+        }
+
+        return ret;
 }
 
 static sector_t ufs_bmap(struct address_space *mapping, sector_t block)
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 7968d41e27ad..bf7aad0d78b8 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -1504,9 +1504,17 @@ xfs_vm_write_begin(
         struct page             **pagep,
         void                    **fsdata)
 {
-        *pagep = NULL;
-        return block_write_begin(file, mapping, pos, len, flags | AOP_FLAG_NOFS,
-                                 pagep, fsdata, xfs_get_blocks);
+        int                     ret;
+
+        ret = block_write_begin(mapping, pos, len, flags | AOP_FLAG_NOFS,
+                                pagep, xfs_get_blocks);
+        if (unlikely(ret)) {
+                loff_t isize = mapping->host->i_size;
+                if (pos + len > isize)
+                        vmtruncate(mapping->host, isize);
+        }
+
+        return ret;
 }
 
 STATIC sector_t