Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 05eb0b51 authored by OGAWA Hirofumi's avatar OGAWA Hirofumi Committed by Linus Torvalds
Browse files

[PATCH] fat: support a truncate() for expanding size (generic_cont_expand) 



This patch changes generic_cont_expand(), in order to share the code
with fatfs.

  - Use vmtruncate() if ->prepare_write() returns a error.

Even if ->prepare_write() returns an error, it may already have added some
blocks.  So, this truncates blocks outside of ->i_size by vmtruncate().

  - Add generic_cont_expand_simple().

The generic_cont_expand_simple() assumes that ->prepare_write() can handle
the block boundary.  With this, we don't need to care the extra byte.

And for expanding a file size by truncate(), fatfs uses the
added generic_cont_expand_simple().

Signed-off-by: default avatarOGAWA Hirofumi <hirofumi@mail.parknet.co.jp>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent 268fc16e

fs/buffer.c

+46 −14
Original line number Diff line number Diff line
@@ -2160,11 +2160,12 @@ int block_read_full_page(struct page *page, get_block_t *get_block) 
 * truncates.  Uses prepare/commit_write to allow the filesystem to

 * deal with the hole.  

 */

int generic_cont_expand(struct inode *inode, loff_t size)

static int __generic_cont_expand(struct inode *inode, loff_t size,

				 pgoff_t index, unsigned int offset)

{

	struct address_space *mapping = inode->i_mapping;

	struct page *page;

	unsigned long index, offset, limit;

	unsigned long limit;

	int err;



	err = -EFBIG;
@@ -2176,24 +2177,24 @@ int generic_cont_expand(struct inode *inode, loff_t size) 
	if (size > inode->i_sb->s_maxbytes)

		goto out;



	offset = (size & (PAGE_CACHE_SIZE-1)); /* Within page */



	/* ugh.  in prepare/commit_write, if from==to==start of block, we 

	** skip the prepare.  make sure we never send an offset for the start

	** of a block

	*/

	if ((offset & (inode->i_sb->s_blocksize - 1)) == 0) {

		offset++;

	}

	index = size >> PAGE_CACHE_SHIFT;

	err = -ENOMEM;

	page = grab_cache_page(mapping, index);

	if (!page)

		goto out;

	err = mapping->a_ops->prepare_write(NULL, page, offset, offset);

	if (!err) {

		err = mapping->a_ops->commit_write(NULL, page, offset, offset);

	if (err) {

		/*

		 * ->prepare_write() may have instantiated a few blocks

		 * outside i_size.  Trim these off again.

		 */

		unlock_page(page);

		page_cache_release(page);

		vmtruncate(inode, inode->i_size);

		goto out;

	}



	err = mapping->a_ops->commit_write(NULL, page, offset, offset);



	unlock_page(page);

	page_cache_release(page);

	if (err > 0)
@@ -2202,6 +2203,36 @@ int generic_cont_expand(struct inode *inode, loff_t size) 
	return err;

}



int generic_cont_expand(struct inode *inode, loff_t size)

{

	pgoff_t index;

	unsigned int offset;



	offset = (size & (PAGE_CACHE_SIZE - 1)); /* Within page */



	/* ugh.  in prepare/commit_write, if from==to==start of block, we

	** skip the prepare.  make sure we never send an offset for the start

	** of a block

	*/

	if ((offset & (inode->i_sb->s_blocksize - 1)) == 0) {

		/* caller must handle this extra byte. */

		offset++;

	}

	index = size >> PAGE_CACHE_SHIFT;



	return __generic_cont_expand(inode, size, index, offset);

}



int generic_cont_expand_simple(struct inode *inode, loff_t size)

{

	loff_t pos = size - 1;

	pgoff_t index = pos >> PAGE_CACHE_SHIFT;

	unsigned int offset = (pos & (PAGE_CACHE_SIZE - 1)) + 1;



	/* prepare/commit_write can handle even if from==to==start of block. */

	return __generic_cont_expand(inode, size, index, offset);

}



/*

 * For moronic filesystems that do not allow holes in file.

 * We may have to extend the file.
@@ -3145,6 +3176,7 @@ EXPORT_SYMBOL(fsync_bdev); 
EXPORT_SYMBOL(generic_block_bmap);

EXPORT_SYMBOL(generic_commit_write);

EXPORT_SYMBOL(generic_cont_expand);

EXPORT_SYMBOL(generic_cont_expand_simple);

EXPORT_SYMBOL(init_buffer);

EXPORT_SYMBOL(invalidate_bdev);

EXPORT_SYMBOL(ll_rw_block);

fs/fat/file.c

+28 −3
Original line number Diff line number Diff line
@@ -11,6 +11,7 @@ 
#include <linux/msdos_fs.h>

#include <linux/smp_lock.h>

#include <linux/buffer_head.h>

#include <linux/writeback.h>



int fat_generic_ioctl(struct inode *inode, struct file *filp,

		      unsigned int cmd, unsigned long arg)
@@ -124,6 +125,24 @@ struct file_operations fat_file_operations = { 
	.sendfile	= generic_file_sendfile,

};



static int fat_cont_expand(struct inode *inode, loff_t size)

{

	struct address_space *mapping = inode->i_mapping;

	loff_t start = inode->i_size, count = size - inode->i_size;

	int err;



	err = generic_cont_expand_simple(inode, size);

	if (err)

		goto out;



	inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;

	mark_inode_dirty(inode);

	if (IS_SYNC(inode))

		err = sync_page_range_nolock(inode, mapping, start, count);

out:

	return err;

}



int fat_notify_change(struct dentry *dentry, struct iattr *attr)

{

	struct msdos_sb_info *sbi = MSDOS_SB(dentry->d_sb);
@@ -132,11 +151,17 @@ int fat_notify_change(struct dentry *dentry, struct iattr *attr) 


	lock_kernel();



	/* FAT cannot truncate to a longer file */

	/*

	 * Expand the file. Since inode_setattr() updates ->i_size

	 * before calling the ->truncate(), but FAT needs to fill the

	 * hole before it.

	 */

	if (attr->ia_valid & ATTR_SIZE) {

		if (attr->ia_size > inode->i_size) {

			error = -EPERM;

			error = fat_cont_expand(inode, attr->ia_size);

			if (error || attr->ia_valid == ATTR_SIZE)

				goto out;

			attr->ia_valid &= ~ATTR_SIZE;

		}

	}

include/linux/buffer_head.h

+2 −1
Original line number Diff line number Diff line
@@ -198,6 +198,7 @@ int block_prepare_write(struct page*, unsigned, unsigned, get_block_t*); 
int cont_prepare_write(struct page*, unsigned, unsigned, get_block_t*,

				loff_t *);

int generic_cont_expand(struct inode *inode, loff_t size);

int generic_cont_expand_simple(struct inode *inode, loff_t size);

int block_commit_write(struct page *page, unsigned from, unsigned to);

int block_sync_page(struct page *);

sector_t generic_block_bmap(struct address_space *, sector_t, get_block_t *);