From: Badari Pulavarty <pbadari@us.ibm.com>
Add nobh_wripage() support for the filesystems which uses
nobh_prepare_write/nobh_commit_write().
Idea here is to reduce unnecessary bufferhead creation/attachment to the
page through pageout()->block_write_full_page(). nobh_wripage() tries to
operate by directly creating bios, but it falls back to
__block_write_full_page() if it can't make progress.
Note that this is not really generic routine and can't be used for
filesystems which uses page->Private for anything other than buffer heads.
Signed-off-by: Badari Pulavarty <pbadari@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
---
25-akpm/fs/buffer.c | 56 ++++++++++++++++++++++++++++++++++++
25-akpm/fs/ext2/inode.c | 8 ++++-
25-akpm/fs/jfs/inode.c | 2 -
25-akpm/fs/mpage.c | 34 ++++++++++++++++++---
25-akpm/include/linux/buffer_head.h | 3 +
25-akpm/include/linux/mpage.h | 3 +
6 files changed, 99 insertions(+), 7 deletions(-)
diff -puN fs/buffer.c~add-nobh_writepage-support fs/buffer.c
--- 25/fs/buffer.c~add-nobh_writepage-support 2005-02-23 02:12:39.000000000 -0800
+++ 25-akpm/fs/buffer.c 2005-02-23 02:12:41.000000000 -0800
@@ -39,6 +39,7 @@
#include <linux/notifier.h>
#include <linux/cpu.h>
#include <linux/bitops.h>
+#include <linux/mpage.h>
static int fsync_buffers_list(spinlock_t *lock, struct list_head *list);
static void invalidate_bh_lrus(void);
@@ -2509,6 +2510,61 @@ int nobh_commit_write(struct file *file,
EXPORT_SYMBOL(nobh_commit_write);
/*
+ * nobh_writepage() - based on block_full_write_page() except
+ * that it tries to operate without attaching bufferheads to
+ * the page.
+ */
+int nobh_writepage(struct page *page, get_block_t *get_block,
+ struct writeback_control *wbc)
+{
+ struct inode * const inode = page->mapping->host;
+ loff_t i_size = i_size_read(inode);
+ const pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
+ unsigned offset;
+ void *kaddr;
+ int ret;
+
+ /* Is the page fully inside i_size? */
+ if (page->index < end_index)
+ goto out;
+
+ /* Is the page fully outside i_size? (truncate in progress) */
+ offset = i_size & (PAGE_CACHE_SIZE-1);
+ if (page->index >= end_index+1 || !offset) {
+ /*
+ * The page may have dirty, unmapped buffers. For example,
+ * they may have been added in ext3_writepage(). Make them
+ * freeable here, so the page does not leak.
+ */
+#if 0
+ /* Not really sure about this - do we need this ? */
+ if (page->mapping->a_ops->invalidatepage)
+ page->mapping->a_ops->invalidatepage(page, offset);
+#endif
+ unlock_page(page);
+ return 0; /* don't care */
+ }
+
+ /*
+ * The page straddles i_size. It must be zeroed out on each and every
+ * writepage invocation because it may be mmapped. "A file is mapped
+ * in multiples of the page size. For a file that is not a multiple of
+ * the page size, the remaining memory is zeroed when mapped, and
+ * writes to that region are not written out to the file."
+ */
+ kaddr = kmap_atomic(page, KM_USER0);
+ memset(kaddr + offset, 0, PAGE_CACHE_SIZE - offset);
+ flush_dcache_page(page);
+ kunmap_atomic(kaddr, KM_USER0);
+out:
+ ret = mpage_writepage(page, get_block, wbc);
+ if (ret == -EAGAIN)
+ ret = __block_write_full_page(inode, page, get_block, wbc);
+ return ret;
+}
+EXPORT_SYMBOL(nobh_writepage);
+
+/*
* This function assumes that ->prepare_write() uses nobh_prepare_write().
*/
int nobh_truncate_page(struct address_space *mapping, loff_t from)
diff -puN fs/ext2/inode.c~add-nobh_writepage-support fs/ext2/inode.c
--- 25/fs/ext2/inode.c~add-nobh_writepage-support 2005-02-23 02:12:39.000000000 -0800
+++ 25-akpm/fs/ext2/inode.c 2005-02-23 02:12:39.000000000 -0800
@@ -626,6 +626,12 @@ ext2_nobh_prepare_write(struct file *fil
return nobh_prepare_write(page,from,to,ext2_get_block);
}
+static int ext2_nobh_writepage(struct page *page,
+ struct writeback_control *wbc)
+{
+ return nobh_writepage(page, ext2_get_block, wbc);
+}
+
static sector_t ext2_bmap(struct address_space *mapping, sector_t block)
{
return generic_block_bmap(mapping,block,ext2_get_block);
@@ -675,7 +681,7 @@ struct address_space_operations ext2_aop
struct address_space_operations ext2_nobh_aops = {
.readpage = ext2_readpage,
.readpages = ext2_readpages,
- .writepage = ext2_writepage,
+ .writepage = ext2_nobh_writepage,
.sync_page = block_sync_page,
.prepare_write = ext2_nobh_prepare_write,
.commit_write = nobh_commit_write,
diff -puN fs/jfs/inode.c~add-nobh_writepage-support fs/jfs/inode.c
--- 25/fs/jfs/inode.c~add-nobh_writepage-support 2005-02-23 02:12:39.000000000 -0800
+++ 25-akpm/fs/jfs/inode.c 2005-02-23 02:12:39.000000000 -0800
@@ -286,7 +286,7 @@ static int jfs_get_block(struct inode *i
static int jfs_writepage(struct page *page, struct writeback_control *wbc)
{
- return block_write_full_page(page, jfs_get_block, wbc);
+ return nobh_writepage(page, jfs_get_block, wbc);
}
static int jfs_writepages(struct address_space *mapping,
diff -puN fs/mpage.c~add-nobh_writepage-support fs/mpage.c
--- 25/fs/mpage.c~add-nobh_writepage-support 2005-02-23 02:12:39.000000000 -0800
+++ 25-akpm/fs/mpage.c 2005-02-23 02:12:56.000000000 -0800
@@ -386,8 +386,9 @@ EXPORT_SYMBOL(mpage_readpage);
* just allocate full-size (16-page) BIOs.
*/
static struct bio *
-mpage_writepage(struct bio *bio, struct page *page, get_block_t get_block,
- sector_t *last_block_in_bio, int *ret, struct writeback_control *wbc)
+__mpage_writepage(struct bio *bio, struct page *page, get_block_t get_block,
+ sector_t *last_block_in_bio, int *ret, struct writeback_control *wbc,
+ writepage_t writepage_fn)
{
struct address_space *mapping = page->mapping;
struct inode *inode = page->mapping->host;
@@ -580,7 +581,13 @@ alloc_new:
confused:
if (bio)
bio = mpage_bio_submit(WRITE, bio);
- *ret = page->mapping->a_ops->writepage(page, wbc);
+
+ if (writepage_fn) {
+ *ret = (*writepage_fn)(page, wbc);
+ } else {
+ *ret = -EAGAIN;
+ goto out;
+ }
/*
* The caller has a ref on the inode, so *mapping is stable
*/
@@ -706,8 +713,9 @@ retry:
&mapping->flags);
}
} else {
- bio = mpage_writepage(bio, page, get_block,
- &last_block_in_bio, &ret, wbc);
+ bio = __mpage_writepage(bio, page, get_block,
+ &last_block_in_bio, &ret, wbc,
+ page->mapping->a_ops->writepage);
}
if (ret || (--(wbc->nr_to_write) <= 0))
done = 1;
@@ -735,3 +743,19 @@ retry:
return ret;
}
EXPORT_SYMBOL(mpage_writepages);
+
+int mpage_writepage(struct page *page, get_block_t get_block,
+ struct writeback_control *wbc)
+{
+ int ret = 0;
+ struct bio *bio;
+ sector_t last_block_in_bio = 0;
+
+ bio = __mpage_writepage(NULL, page, get_block,
+ &last_block_in_bio, &ret, wbc, NULL);
+ if (bio)
+ mpage_bio_submit(WRITE, bio);
+
+ return ret;
+}
+EXPORT_SYMBOL(mpage_writepage);
diff -puN include/linux/buffer_head.h~add-nobh_writepage-support include/linux/buffer_head.h
--- 25/include/linux/buffer_head.h~add-nobh_writepage-support 2005-02-23 02:12:39.000000000 -0800
+++ 25-akpm/include/linux/buffer_head.h 2005-02-23 02:12:39.000000000 -0800
@@ -203,6 +203,9 @@ int file_fsync(struct file *, struct den
int nobh_prepare_write(struct page*, unsigned, unsigned, get_block_t*);
int nobh_commit_write(struct file *, struct page *, unsigned, unsigned);
int nobh_truncate_page(struct address_space *, loff_t);
+int nobh_writepage(struct page *page, get_block_t *get_block,
+ struct writeback_control *wbc);
+
/*
* inline definitions
diff -puN include/linux/mpage.h~add-nobh_writepage-support include/linux/mpage.h
--- 25/include/linux/mpage.h~add-nobh_writepage-support 2005-02-23 02:12:39.000000000 -0800
+++ 25-akpm/include/linux/mpage.h 2005-02-23 02:12:39.000000000 -0800
@@ -11,12 +11,15 @@
*/
struct writeback_control;
+typedef int (writepage_t)(struct page *page, struct writeback_control *wbc);
int mpage_readpages(struct address_space *mapping, struct list_head *pages,
unsigned nr_pages, get_block_t get_block);
int mpage_readpage(struct page *page, get_block_t get_block);
int mpage_writepages(struct address_space *mapping,
struct writeback_control *wbc, get_block_t get_block);
+int mpage_writepage(struct page *page, get_block_t *get_block,
+ struct writeback_control *wbc);
static inline int
generic_writepages(struct address_space *mapping, struct writeback_control *wbc)
_