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

Commit 9e09fc85 authored by Jaegeuk Kim's avatar Jaegeuk Kim
Browse files

f2fs: refactor f2fs_convert_inline_data 



Change log from v1:
 o handle NULL pointer of grab_cache_page_write_begin() pointed by Chao Yu.

This patch refactors f2fs_convert_inline_data to check a couple of conditions
internally for deciding whether it needs to convert inline_data or not.

So, the new f2fs_convert_inline_data initially checks:
1) f2fs_has_inline_data(), and
2) the data size to be changed.

If the inode has inline_data but the size to fill is less than MAX_INLINE_DATA,
then we don't need to convert the inline_data with data allocation.

Signed-off-by: default avatarJaegeuk Kim <jaegeuk.kim@samsung.com>
parent 26f466f4

fs/f2fs/data.c

+6 −10
Original line number Diff line number Diff line
@@ -906,21 +906,17 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping, 


	f2fs_balance_fs(sbi);

repeat:

	err = f2fs_convert_inline_data(inode, pos + len);

	if (err)

		return err;



	page = grab_cache_page_write_begin(mapping, index, flags);

	if (!page)

		return -ENOMEM;

	*pagep = page;



	if ((pos + len) < MAX_INLINE_DATA) {

		if (f2fs_has_inline_data(inode))

	if (f2fs_has_inline_data(inode) && (pos + len) <= MAX_INLINE_DATA)

		goto inline_data;

	} else if (f2fs_has_inline_data(inode)) {

		err = f2fs_convert_inline_data(inode, page, flags);

		if (err) {

			f2fs_put_page(page, 1);

			return err;

		}

	}



	f2fs_lock_op(sbi);

	set_new_dnode(&dn, inode, NULL, NULL, 0);

fs/f2fs/f2fs.h

+1 −1
Original line number Diff line number Diff line
@@ -1302,6 +1302,6 @@ extern const struct inode_operations f2fs_special_inode_operations; 
inline int f2fs_has_inline_data(struct inode *);

bool f2fs_may_inline(struct inode *);

int f2fs_read_inline_data(struct inode *, struct page *);

int f2fs_convert_inline_data(struct inode *, struct page *, unsigned);

int f2fs_convert_inline_data(struct inode *, pgoff_t);

int f2fs_write_inline_data(struct inode *, struct page *, unsigned int);

#endif

fs/f2fs/file.c

+9 −16
Original line number Diff line number Diff line
@@ -370,16 +370,11 @@ int f2fs_setattr(struct dentry *dentry, struct iattr *attr) 


	if ((attr->ia_valid & ATTR_SIZE) &&

			attr->ia_size != i_size_read(inode)) {

		if (f2fs_has_inline_data(inode) &&

				(attr->ia_size > MAX_INLINE_DATA)) {

			unsigned flags = AOP_FLAG_NOFS;

			err = f2fs_convert_inline_data(inode, NULL, flags);

		err = f2fs_convert_inline_data(inode, attr->ia_size);

		if (err)

			return err;

		}



		truncate_setsize(inode, attr->ia_size);

		if (!f2fs_has_inline_data(inode))

		f2fs_truncate(inode);

		f2fs_balance_fs(F2FS_SB(inode->i_sb));

	}
@@ -462,7 +457,7 @@ static int punch_hole(struct inode *inode, loff_t offset, loff_t len) 
	loff_t off_start, off_end;

	int ret = 0;



	ret = f2fs_convert_inline_data(inode, NULL, AOP_FLAG_NOFS);

	ret = f2fs_convert_inline_data(inode, MAX_INLINE_DATA + 1);

	if (ret)

		return ret;
@@ -512,13 +507,11 @@ static int expand_inode_data(struct inode *inode, loff_t offset, 
	loff_t off_start, off_end;

	int ret = 0;



	if (f2fs_has_inline_data(inode) && (offset + len > MAX_INLINE_DATA)) {

		ret = f2fs_convert_inline_data(inode, NULL, AOP_FLAG_NOFS);

	ret = inode_newsize_ok(inode, (len + offset));

	if (ret)

		return ret;

	}



	ret = inode_newsize_ok(inode, (len + offset));

	ret = f2fs_convert_inline_data(inode, offset + len);

	if (ret)

		return ret;

fs/f2fs/inline.c

+12 −14
Original line number Diff line number Diff line
@@ -101,6 +101,7 @@ static int __f2fs_convert_inline_data(struct inode *inode, struct page *page) 
	dst_addr = kmap(page);

	memcpy(dst_addr, src_addr, MAX_INLINE_DATA);

	kunmap(page);

	SetPageUptodate(page);



	/* write data page to try to make data consistent */

	set_page_writeback(page);
@@ -120,25 +121,22 @@ static int __f2fs_convert_inline_data(struct inode *inode, struct page *page) 
	return err;

}



int f2fs_convert_inline_data(struct inode *inode,

			     struct page *p, unsigned flags)

int f2fs_convert_inline_data(struct inode *inode, pgoff_t to_size)

{

	int err;

	struct page *page;

	int err;



	if (!p || p->index) {

		page = grab_cache_page_write_begin(inode->i_mapping, 0, flags);

		if (IS_ERR(page))

			return PTR_ERR(page);

	} else {

		page = p;

	}

	if (!f2fs_has_inline_data(inode))

		return 0;

	else if (to_size <= MAX_INLINE_DATA)

		return 0;



	err = __f2fs_convert_inline_data(inode, page);

	page = grab_cache_page_write_begin(inode->i_mapping, 0, AOP_FLAG_NOFS);

	if (!page)

		return -ENOMEM;



	if (!p || p->index)

	err = __f2fs_convert_inline_data(inode, page);

	f2fs_put_page(page, 1);



	return err;

}