clean up write_begin usage for directories in pagecache

For filesystem that implement directories in pagecache we call
block_write_begin with an already allocated page for this code, while the
normal regular file write path uses the default block_write_begin behaviour.

Get rid of the __foofs_write_begin helper and opencode the normal write_begin
call in foofs_write_begin, while adding a new foofs_prepare_chunk helper for
the directory code.  The added benefit is that foofs_prepare_chunk has
a much saner calling convention.

Note that the interruptible flag passed into block_write_begin is always
ignored if we already pass in a page (see next patch for details), and
we never were doing truncations of exessive blocks for this case either so we
can switch directly to block_write_begin_newtrunc.

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

diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 7516957273ed7c4bccc516c0b48c204841f56f71..6b946bae11cfaa1b9b89a371488fd35382e04c18 100644 (file)
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -448,6 +448,12 @@ ino_t ext2_inode_by_name(struct inode *dir, struct qstr *child)
        return res;
 }
 
+static int ext2_prepare_chunk(struct page *page, loff_t pos, unsigned len)
+{
+       return block_write_begin_newtrunc(NULL, page->mapping, pos, len, 0,
+                                         &page, NULL, ext2_get_block);
+}
+
 /* Releases the page */
 void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
                   struct page *page, struct inode *inode, int update_times)
@@ -458,8 +464,7 @@ void ext2_set_link(struct inode *dir, struct ext2_dir_entry_2 *de,
        int err;
 
        lock_page(page);
-       err = __ext2_write_begin(NULL, page->mapping, pos, len,
-                               AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
+       err = ext2_prepare_chunk(page, pos, len);
        BUG_ON(err);
        de->inode = cpu_to_le32(inode->i_ino);
        ext2_set_de_type(de, inode);
@@ -542,8 +547,7 @@ int ext2_add_link (struct dentry *dentry, struct inode *inode)
 got_it:
        pos = page_offset(page) +
                (char*)de - (char*)page_address(page);
-       err = __ext2_write_begin(NULL, page->mapping, pos, rec_len, 0,
-                                                       &page, NULL);
+       err = ext2_prepare_chunk(page, pos, rec_len);
        if (err)
                goto out_unlock;
        if (de->inode) {
@@ -576,8 +580,7 @@ out_unlock:
  */
 int ext2_delete_entry (struct ext2_dir_entry_2 * dir, struct page * page )
 {
-       struct address_space *mapping = page->mapping;
-       struct inode *inode = mapping->host;
+       struct inode *inode = page->mapping->host;
        char *kaddr = page_address(page);
        unsigned from = ((char*)dir - kaddr) & ~(ext2_chunk_size(inode)-1);
        unsigned to = ((char *)dir - kaddr) +
@@ -601,8 +604,7 @@ int ext2_delete_entry (struct ext2_dir_entry_2 * dir, struct page * page )
                from = (char*)pde - (char*)page_address(page);
        pos = page_offset(page) + from;
        lock_page(page);
-       err = __ext2_write_begin(NULL, page->mapping, pos, to - from, 0,
-                                                       &page, NULL);
+       err = ext2_prepare_chunk(page, pos, to - from);
        BUG_ON(err);
        if (pde)
                pde->rec_len = ext2_rec_len_to_disk(to - from);
@@ -621,8 +623,7 @@ out:
  */
 int ext2_make_empty(struct inode *inode, struct inode *parent)
 {
-       struct address_space *mapping = inode->i_mapping;
-       struct page *page = grab_cache_page(mapping, 0);
+       struct page *page = grab_cache_page(inode->i_mapping, 0);
        unsigned chunk_size = ext2_chunk_size(inode);
        struct ext2_dir_entry_2 * de;
        int err;
@@ -631,8 +632,7 @@ int ext2_make_empty(struct inode *inode, struct inode *parent)
        if (!page)
                return -ENOMEM;
 
-       err = __ext2_write_begin(NULL, page->mapping, 0, chunk_size, 0,
-                                                       &page, NULL);
+       err = ext2_prepare_chunk(page, 0, chunk_size);
        if (err) {
                unlock_page(page);
                goto fail;

diff --git a/fs/ext2/ext2.h b/fs/ext2/ext2.h
index 52b34f1d27383b1189ef61d1a45ce650782ad0f7..8f53d11bf95787c50618254d519245fe9fde8e33 100644 (file)
--- a/fs/ext2/ext2.h
+++ b/fs/ext2/ext2.h
@@ -127,9 +127,6 @@ extern void ext2_set_inode_flags(struct inode *inode);
 extern void ext2_get_inode_flags(struct ext2_inode_info *);
 extern int ext2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                       u64 start, u64 len);
-int __ext2_write_begin(struct file *file, struct address_space *mapping,
-               loff_t pos, unsigned len, unsigned flags,
-               struct page **pagep, void **fsdata);
 
 /* ioctl.c */
 extern long ext2_ioctl(struct file *, unsigned int, unsigned long);

diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 348805cd410926e9b79738a3a33e00f048d61db9..2f4dfbcd769646c7b390284aacf5f086784fc10a 100644 (file)
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -765,14 +765,6 @@ ext2_readpages(struct file *file, struct address_space *mapping,
        return mpage_readpages(mapping, pages, nr_pages, ext2_get_block);
 }
 
-int __ext2_write_begin(struct file *file, struct address_space *mapping,
-               loff_t pos, unsigned len, unsigned flags,
-               struct page **pagep, void **fsdata)
-{
-       return block_write_begin_newtrunc(file, mapping, pos, len, flags,
-                                       pagep, fsdata, ext2_get_block);
-}
-
 static int
 ext2_write_begin(struct file *file, struct address_space *mapping,
                loff_t pos, unsigned len, unsigned flags,
@@ -781,7 +773,8 @@ ext2_write_begin(struct file *file, struct address_space *mapping,
        int ret;
 
        *pagep = NULL;
-       ret = __ext2_write_begin(file, mapping, pos, len, flags, pagep, fsdata);
+       ret = block_write_begin_newtrunc(file, mapping, pos, len, flags,
+                                        pagep, fsdata, ext2_get_block);
        if (ret < 0)
                ext2_write_failed(mapping, pos + len);
        return ret;

diff --git a/fs/minix/dir.c b/fs/minix/dir.c
index 1dbf921ca44b42de92c6dda06e014b395dfcdae9..085a9262c6926466a397cff2b643375c0cf18084 100644 (file)
--- a/fs/minix/dir.c
+++ b/fs/minix/dir.c
@@ -271,8 +271,7 @@ int minix_add_link(struct dentry *dentry, struct inode *inode)
 
 got_it:
        pos = page_offset(page) + p - (char *)page_address(page);
-       err = __minix_write_begin(NULL, page->mapping, pos, sbi->s_dirsize,
-                                       AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
+       err = minix_prepare_chunk(page, pos, sbi->s_dirsize);
        if (err)
                goto out_unlock;
        memcpy (namx, name, namelen);
@@ -297,8 +296,7 @@ out_unlock:
 
 int minix_delete_entry(struct minix_dir_entry *de, struct page *page)
 {
-       struct address_space *mapping = page->mapping;
-       struct inode *inode = (struct inode*)mapping->host;
+       struct inode *inode = page->mapping->host;
        char *kaddr = page_address(page);
        loff_t pos = page_offset(page) + (char*)de - kaddr;
        struct minix_sb_info *sbi = minix_sb(inode->i_sb);
@@ -306,8 +304,7 @@ int minix_delete_entry(struct minix_dir_entry *de, struct page *page)
        int err;
 
        lock_page(page);
-       err = __minix_write_begin(NULL, mapping, pos, len,
-                                       AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
+       err = minix_prepare_chunk(page, pos, len);
        if (err == 0) {
                if (sbi->s_version == MINIX_V3)
                        ((minix3_dirent *) de)->inode = 0;
@@ -325,16 +322,14 @@ int minix_delete_entry(struct minix_dir_entry *de, struct page *page)
 
 int minix_make_empty(struct inode *inode, struct inode *dir)
 {
-       struct address_space *mapping = inode->i_mapping;
-       struct page *page = grab_cache_page(mapping, 0);
+       struct page *page = grab_cache_page(inode->i_mapping, 0);
        struct minix_sb_info *sbi = minix_sb(inode->i_sb);
        char *kaddr;
        int err;
 
        if (!page)
                return -ENOMEM;
-       err = __minix_write_begin(NULL, mapping, 0, 2 * sbi->s_dirsize,
-                                       AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
+       err = minix_prepare_chunk(page, 0, 2 * sbi->s_dirsize);
        if (err) {
                unlock_page(page);
                goto fail;
@@ -425,8 +420,7 @@ not_empty:
 void minix_set_link(struct minix_dir_entry *de, struct page *page,
        struct inode *inode)
 {
-       struct address_space *mapping = page->mapping;
-       struct inode *dir = mapping->host;
+       struct inode *dir = page->mapping->host;
        struct minix_sb_info *sbi = minix_sb(dir->i_sb);
        loff_t pos = page_offset(page) +
                        (char *)de-(char*)page_address(page);
@@ -434,8 +428,7 @@ void minix_set_link(struct minix_dir_entry *de, struct page *page,
 
        lock_page(page);
 
-       err = __minix_write_begin(NULL, mapping, pos, sbi->s_dirsize,
-                                       AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
+       err = minix_prepare_chunk(page, pos, sbi->s_dirsize);
        if (err == 0) {
                if (sbi->s_version == MINIX_V3)
                        ((minix3_dirent *) de)->inode = inode->i_ino;

diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index 756f8c93780ca5232cbfba4b85128d30cd79b3ba..f4abe45229bbcbdef1f8893bc110833fcee6c7e3 100644 (file)
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -357,12 +357,10 @@ static int minix_readpage(struct file *file, struct page *page)
        return block_read_full_page(page,minix_get_block);
 }
 
-int __minix_write_begin(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len, unsigned flags,
-                       struct page **pagep, void **fsdata)
+int minix_prepare_chunk(struct page *page, loff_t pos, unsigned len)
 {
-       return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
-                               minix_get_block);
+       return block_write_begin_newtrunc(NULL, page->mapping, pos, len, 0,
+                                         &page, NULL, minix_get_block);
 }
 
 static int minix_write_begin(struct file *file, struct address_space *mapping,
@@ -370,7 +368,8 @@ static int minix_write_begin(struct file *file, struct address_space *mapping,
                        struct page **pagep, void **fsdata)
 {
        *pagep = NULL;
-       return __minix_write_begin(file, mapping, pos, len, flags, pagep, fsdata);
+       return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
+                               minix_get_block);
 }
 
 static sector_t minix_bmap(struct address_space *mapping, sector_t block)

diff --git a/fs/minix/minix.h b/fs/minix/minix.h
index 111f34ee9e3b09702f63a045e6ff555c4c1059f5..407b1c84911e9402df59b886cf25b036f346f441 100644 (file)
--- a/fs/minix/minix.h
+++ b/fs/minix/minix.h
@@ -53,9 +53,7 @@ extern int minix_new_block(struct inode * inode);
 extern void minix_free_block(struct inode *inode, unsigned long block);
 extern unsigned long minix_count_free_blocks(struct minix_sb_info *sbi);
 extern int minix_getattr(struct vfsmount *, struct dentry *, struct kstat *);
-extern int __minix_write_begin(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len, unsigned flags,
-                       struct page **pagep, void **fsdata);
+extern int minix_prepare_chunk(struct page *page, loff_t pos, unsigned len);
 
 extern void V1_minix_truncate(struct inode *);
 extern void V2_minix_truncate(struct inode *);

diff --git a/fs/nilfs2/dir.c b/fs/nilfs2/dir.c
index 85c89dfc71f0985c12f0355a5e397272078c48cc..fc2bcfa599a35bd477d84363332229a820d1b99f 100644 (file)
--- a/fs/nilfs2/dir.c
+++ b/fs/nilfs2/dir.c
@@ -80,23 +80,11 @@ static unsigned nilfs_last_byte(struct inode *inode, unsigned long page_nr)
        return last_byte;
 }
 
-static int nilfs_prepare_chunk_uninterruptible(struct page *page,
-                                              struct address_space *mapping,
-                                              unsigned from, unsigned to)
+static int nilfs_prepare_chunk(struct page *page, unsigned from, unsigned to)
 {
        loff_t pos = page_offset(page) + from;
-       return block_write_begin(NULL, mapping, pos, to - from,
-                                AOP_FLAG_UNINTERRUPTIBLE, &page,
-                                NULL, nilfs_get_block);
-}
-
-static int nilfs_prepare_chunk(struct page *page,
-                              struct address_space *mapping,
-                              unsigned from, unsigned to)
-{
-       loff_t pos = page_offset(page) + from;
-       return block_write_begin(NULL, mapping, pos, to - from, 0, &page,
-                                NULL, nilfs_get_block);
+       return block_write_begin_newtrunc(NULL, page->mapping, pos, to - from,
+                                         0, &page, NULL, nilfs_get_block);
 }
 
 static void nilfs_commit_chunk(struct page *page,
@@ -449,7 +437,7 @@ void nilfs_set_link(struct inode *dir, struct nilfs_dir_entry *de,
        int err;
 
        lock_page(page);
-       err = nilfs_prepare_chunk_uninterruptible(page, mapping, from, to);
+       err = nilfs_prepare_chunk(page, from, to);
        BUG_ON(err);
        de->inode = cpu_to_le64(inode->i_ino);
        nilfs_set_de_type(de, inode);
@@ -530,7 +518,7 @@ int nilfs_add_link(struct dentry *dentry, struct inode *inode)
 got_it:
        from = (char *)de - (char *)page_address(page);
        to = from + rec_len;
-       err = nilfs_prepare_chunk(page, page->mapping, from, to);
+       err = nilfs_prepare_chunk(page, from, to);
        if (err)
                goto out_unlock;
        if (de->inode) {
@@ -587,7 +575,7 @@ int nilfs_delete_entry(struct nilfs_dir_entry *dir, struct page *page)
        if (pde)
                from = (char *)pde - (char *)page_address(page);
        lock_page(page);
-       err = nilfs_prepare_chunk(page, mapping, from, to);
+       err = nilfs_prepare_chunk(page, from, to);
        BUG_ON(err);
        if (pde)
                pde->rec_len = cpu_to_le16(to - from);
@@ -615,7 +603,7 @@ int nilfs_make_empty(struct inode *inode, struct inode *parent)
        if (!page)
                return -ENOMEM;
 
-       err = nilfs_prepare_chunk(page, mapping, 0, chunk_size);
+       err = nilfs_prepare_chunk(page, 0, chunk_size);
        if (unlikely(err)) {
                unlock_page(page);
                goto fail;

diff --git a/fs/sysv/dir.c b/fs/sysv/dir.c
index 79941e4964a4eda4b1a55255fddbc2b6e1d853ef..a77c421576209174bf3d649a4370e33e0cbe4e79 100644 (file)
--- a/fs/sysv/dir.c
+++ b/fs/sysv/dir.c
@@ -218,8 +218,7 @@ got_it:
        pos = page_offset(page) +
                        (char*)de - (char*)page_address(page);
        lock_page(page);
-       err = __sysv_write_begin(NULL, page->mapping, pos, SYSV_DIRSIZE,
-                               AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
+       err = sysv_prepare_chunk(page, pos, SYSV_DIRSIZE);
        if (err)
                goto out_unlock;
        memcpy (de->name, name, namelen);
@@ -239,15 +238,13 @@ out_unlock:
 
 int sysv_delete_entry(struct sysv_dir_entry *de, struct page *page)
 {
-       struct address_space *mapping = page->mapping;
-       struct inode *inode = (struct inode*)mapping->host;
+       struct inode *inode = page->mapping->host;
        char *kaddr = (char*)page_address(page);
        loff_t pos = page_offset(page) + (char *)de - kaddr;
        int err;
 
        lock_page(page);
-       err = __sysv_write_begin(NULL, mapping, pos, SYSV_DIRSIZE,
-                               AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
+       err = sysv_prepare_chunk(page, pos, SYSV_DIRSIZE);
        BUG_ON(err);
        de->inode = 0;
        err = dir_commit_chunk(page, pos, SYSV_DIRSIZE);
@@ -259,16 +256,14 @@ int sysv_delete_entry(struct sysv_dir_entry *de, struct page *page)
 
 int sysv_make_empty(struct inode *inode, struct inode *dir)
 {
-       struct address_space *mapping = inode->i_mapping;
-       struct page *page = grab_cache_page(mapping, 0);
+       struct page *page = grab_cache_page(inode->i_mapping, 0);
        struct sysv_dir_entry * de;
        char *base;
        int err;
 
        if (!page)
                return -ENOMEM;
-       err = __sysv_write_begin(NULL, mapping, 0, 2 * SYSV_DIRSIZE,
-                               AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
+       err = sysv_prepare_chunk(page, 0, 2 * SYSV_DIRSIZE);
        if (err) {
                unlock_page(page);
                goto fail;
@@ -341,15 +336,13 @@ not_empty:
 void sysv_set_link(struct sysv_dir_entry *de, struct page *page,
        struct inode *inode)
 {
-       struct address_space *mapping = page->mapping;
-       struct inode *dir = mapping->host;
+       struct inode *dir = page->mapping->host;
        loff_t pos = page_offset(page) +
                        (char *)de-(char*)page_address(page);
        int err;
 
        lock_page(page);
-       err = __sysv_write_begin(NULL, mapping, pos, SYSV_DIRSIZE,
-                               AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
+       err = sysv_prepare_chunk(page, pos, SYSV_DIRSIZE);
        BUG_ON(err);
        de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino);
        err = dir_commit_chunk(page, pos, SYSV_DIRSIZE);

diff --git a/fs/sysv/itree.c b/fs/sysv/itree.c
index f042eec464c2df768e34a992a0845a82887af77b..4068f485cfd6a04e319c964e7569618a5fd853a6 100644 (file)
--- a/fs/sysv/itree.c
+++ b/fs/sysv/itree.c
@@ -459,12 +459,10 @@ static int sysv_readpage(struct file *file, struct page *page)
        return block_read_full_page(page,get_block);
 }
 
-int __sysv_write_begin(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len, unsigned flags,
-                       struct page **pagep, void **fsdata)
+int sysv_prepare_chunk(struct page *page, loff_t pos, unsigned len)
 {
-       return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
-                               get_block);
+       return block_write_begin_newtrunc(NULL, page->mapping, pos, len, 0,
+                                         &page, NULL, get_block);
 }
 
 static int sysv_write_begin(struct file *file, struct address_space *mapping,
@@ -472,7 +470,8 @@ static int sysv_write_begin(struct file *file, struct address_space *mapping,
                        struct page **pagep, void **fsdata)
 {
        *pagep = NULL;
-       return __sysv_write_begin(file, mapping, pos, len, flags, pagep, fsdata);
+       return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
+                               get_block);
 }
 
 static sector_t sysv_bmap(struct address_space *mapping, sector_t block)

diff --git a/fs/sysv/sysv.h b/fs/sysv/sysv.h
index 94cb9b4d76c28871c7d5dfcdb8869118f1f1e7b8..bb55cdb394bfae0e39a035f3be5b9bb3eea1363a 100644 (file)
--- a/fs/sysv/sysv.h
+++ b/fs/sysv/sysv.h
@@ -136,9 +136,7 @@ extern unsigned long sysv_count_free_blocks(struct super_block *);
 
 /* itree.c */
 extern void sysv_truncate(struct inode *);
-extern int __sysv_write_begin(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len, unsigned flags,
-                       struct page **pagep, void **fsdata);
+extern int sysv_prepare_chunk(struct page *page, loff_t pos, unsigned len);
 
 /* inode.c */
 extern struct inode *sysv_iget(struct super_block *, unsigned int);

diff --git a/fs/ufs/dir.c b/fs/ufs/dir.c
index ec784756dc6597d97f67444380bcaeb81ac74283..dbc90994715a1967f70e41387280fe0a7283efe3 100644 (file)
--- a/fs/ufs/dir.c
+++ b/fs/ufs/dir.c
@@ -95,8 +95,7 @@ void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de,
        int err;
 
        lock_page(page);
-       err = __ufs_write_begin(NULL, page->mapping, pos, len,
-                               AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
+       err = ufs_prepare_chunk(page, pos, len);
        BUG_ON(err);
 
        de->d_ino = cpu_to_fs32(dir->i_sb, inode->i_ino);
@@ -381,8 +380,7 @@ int ufs_add_link(struct dentry *dentry, struct inode *inode)
 got_it:
        pos = page_offset(page) +
                        (char*)de - (char*)page_address(page);
-       err = __ufs_write_begin(NULL, page->mapping, pos, rec_len,
-                               AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
+       err = ufs_prepare_chunk(page, pos, rec_len);
        if (err)
                goto out_unlock;
        if (de->d_ino) {
@@ -518,7 +516,6 @@ int ufs_delete_entry(struct inode *inode, struct ufs_dir_entry *dir,
                     struct page * page)
 {
        struct super_block *sb = inode->i_sb;
-       struct address_space *mapping = page->mapping;
        char *kaddr = page_address(page);
        unsigned from = ((char*)dir - kaddr) & ~(UFS_SB(sb)->s_uspi->s_dirblksize - 1);
        unsigned to = ((char*)dir - kaddr) + fs16_to_cpu(sb, dir->d_reclen);
@@ -549,8 +546,7 @@ int ufs_delete_entry(struct inode *inode, struct ufs_dir_entry *dir,
 
        pos = page_offset(page) + from;
        lock_page(page);
-       err = __ufs_write_begin(NULL, mapping, pos, to - from,
-                               AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
+       err = ufs_prepare_chunk(page, pos, to - from);
        BUG_ON(err);
        if (pde)
                pde->d_reclen = cpu_to_fs16(sb, to - from);
@@ -577,8 +573,7 @@ int ufs_make_empty(struct inode * inode, struct inode *dir)
        if (!page)
                return -ENOMEM;
 
-       err = __ufs_write_begin(NULL, mapping, 0, chunk_size,
-                               AOP_FLAG_UNINTERRUPTIBLE, &page, NULL);
+       err = ufs_prepare_chunk(page, 0, chunk_size);
        if (err) {
                unlock_page(page);
                goto fail;

diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index 73fe773aa03418d3eb1ba4b2e8e71d08ff524e5c..a9555b1ffd286bd60da3ced32a9ab2c692a4233f 100644 (file)
--- a/fs/ufs/inode.c
+++ b/fs/ufs/inode.c
@@ -558,12 +558,10 @@ static int ufs_readpage(struct file *file, struct page *page)
        return block_read_full_page(page,ufs_getfrag_block);
 }
 
-int __ufs_write_begin(struct file *file, struct address_space *mapping,
-                       loff_t pos, unsigned len, unsigned flags,
-                       struct page **pagep, void **fsdata)
+int ufs_prepare_chunk(struct page *page, loff_t pos, unsigned len)
 {
-       return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
-                               ufs_getfrag_block);
+       return block_write_begin_newtrunc(NULL, page->mapping, pos, len, 0,
+                                         &page, NULL, ufs_getfrag_block);
 }
 
 static int ufs_write_begin(struct file *file, struct address_space *mapping,
@@ -571,7 +569,8 @@ static int ufs_write_begin(struct file *file, struct address_space *mapping,
                        struct page **pagep, void **fsdata)
 {
        *pagep = NULL;
-       return __ufs_write_begin(file, mapping, pos, len, flags, pagep, fsdata);
+       return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
+                               ufs_getfrag_block);
 }
 
 static sector_t ufs_bmap(struct address_space *mapping, sector_t block)

diff --git a/fs/ufs/util.h b/fs/ufs/util.h
index 23ceed8c8fb9d42bbadb2166c4a99625a19afed9..0466036912f1adb41ccf85eb2d3dbd81b669ef4e 100644 (file)
--- a/fs/ufs/util.h
+++ b/fs/ufs/util.h
@@ -257,9 +257,7 @@ ufs_set_inode_gid(struct super_block *sb, struct ufs_inode *inode, u32 value)
 
 extern dev_t ufs_get_inode_dev(struct super_block *, struct ufs_inode_info *);
 extern void ufs_set_inode_dev(struct super_block *, struct ufs_inode_info *, dev_t);
-extern int __ufs_write_begin(struct file *file, struct address_space *mapping,
-               loff_t pos, unsigned len, unsigned flags,
-               struct page **pagep, void **fsdata);
+extern int ufs_prepare_chunk(struct page *page, loff_t pos, unsigned len);
 
 /*
  * These functions manipulate ufs buffers