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

Commit ef1dd485 authored by Chao Yu's avatar Chao Yu Committed by Jaegeuk Kim
Browse files

f2fs: make max inline size changeable 



This patch tries to make below macros calculating max inline size,
inline dentry field size considerring reserving size-changeable
space:
- MAX_INLINE_DATA
- NR_INLINE_DENTRY
- INLINE_DENTRY_BITMAP_SIZE
- INLINE_RESERVED_SIZE

Then, when inline_{data,dentry} options is enabled, it allows us to
reserve inline space with different size flexibly for adding newly
introduced inode attribute.

Signed-off-by: default avatarChao Yu <yuchao0@huawei.com>
Signed-off-by: default avatarJaegeuk Kim <jaegeuk@kernel.org>
parent 41054d54

fs/f2fs/data.c

+2 −2
Original line number Diff line number Diff line
@@ -810,7 +810,7 @@ int f2fs_preallocate_blocks(struct inode *inode, loff_t pos, 
				F2FS_GET_BLOCK_PRE_AIO :

				F2FS_GET_BLOCK_PRE_DIO);

	}

	if (pos + count > MAX_INLINE_DATA) {

	if (pos + count > MAX_INLINE_DATA(inode)) {

		err = f2fs_convert_inline_inode(inode);

		if (err)

			return err;
@@ -1852,7 +1852,7 @@ restart: 
	set_new_dnode(&dn, inode, ipage, ipage, 0);



	if (f2fs_has_inline_data(inode)) {

		if (pos + len <= MAX_INLINE_DATA) {

		if (pos + len <= MAX_INLINE_DATA(inode)) {

			read_inline_data(page, ipage);

			set_inode_flag(inode, FI_DATA_EXIST);

			if (inode->i_nlink)

fs/f2fs/f2fs.h

+40 −8
Original line number Diff line number Diff line
@@ -456,6 +456,25 @@ struct f2fs_flush_device { 
	u32 segments;		/* # of segments to flush */

};



/* for inline stuff */

#define DEF_INLINE_RESERVED_SIZE	1



static inline int get_inline_reserved_size(struct inode *inode);

#define MAX_INLINE_DATA(inode)	(sizeof(__le32) * (DEF_ADDRS_PER_INODE -\

				get_inline_reserved_size(inode) -\

				F2FS_INLINE_XATTR_ADDRS))



/* for inline dir */

#define NR_INLINE_DENTRY(inode)	(MAX_INLINE_DATA(inode) * BITS_PER_BYTE / \

				((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \

				BITS_PER_BYTE + 1))

#define INLINE_DENTRY_BITMAP_SIZE(inode)	((NR_INLINE_DENTRY(inode) + \

					BITS_PER_BYTE - 1) / BITS_PER_BYTE)

#define INLINE_RESERVED_SIZE(inode)	(MAX_INLINE_DATA(inode) - \

				((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \

				NR_INLINE_DENTRY(inode) + \

				INLINE_DENTRY_BITMAP_SIZE(inode)))



/*

 * For INODE and NODE manager

 */
@@ -481,14 +500,19 @@ static inline void make_dentry_ptr_block(struct inode *inode, 
}



static inline void make_dentry_ptr_inline(struct inode *inode,

		struct f2fs_dentry_ptr *d, struct f2fs_inline_dentry *t)

					struct f2fs_dentry_ptr *d, void *t)

{

	int entry_cnt = NR_INLINE_DENTRY(inode);

	int bitmap_size = INLINE_DENTRY_BITMAP_SIZE(inode);

	int reserved_size = INLINE_RESERVED_SIZE(inode);



	d->inode = inode;

	d->max = NR_INLINE_DENTRY;

	d->nr_bitmap = INLINE_DENTRY_BITMAP_SIZE;

	d->bitmap = &t->dentry_bitmap;

	d->dentry = t->dentry;

	d->filename = t->filename;

	d->max = entry_cnt;

	d->nr_bitmap = bitmap_size;

	d->bitmap = t;

	d->dentry = t + bitmap_size + reserved_size;

	d->filename = t + bitmap_size + reserved_size +

					SIZE_OF_DIR_ENTRY * entry_cnt;

}



/*
@@ -640,6 +664,8 @@ struct f2fs_inode_info { 
	struct extent_tree *extent_tree;	/* cached extent_tree entry */

	struct rw_semaphore dio_rwsem[2];/* avoid racing between dio and gc */

	struct rw_semaphore i_mmap_sem;



	int i_inline_reserved;		/* reserved size in inline data */

};



static inline void get_extent_info(struct extent_info *ext,
@@ -2168,11 +2194,12 @@ static inline bool f2fs_is_drop_cache(struct inode *inode) 
	return is_inode_flag_set(inode, FI_DROP_CACHE);

}



static inline void *inline_data_addr(struct page *page)

static inline void *inline_data_addr(struct inode *inode, struct page *page)

{

	struct f2fs_inode *ri = F2FS_INODE(page);

	int reserved_size = get_inline_reserved_size(inode);



	return (void *)&(ri->i_addr[1]);

	return (void *)&(ri->i_addr[reserved_size]);

}



static inline int f2fs_has_inline_dentry(struct inode *inode)
@@ -2283,6 +2310,11 @@ static inline void *kvzalloc(size_t size, gfp_t flags) 
	return ret;

}



static inline int get_inline_reserved_size(struct inode *inode)

{

	return F2FS_I(inode)->i_inline_reserved;

}



#define get_inode_mode(i) \

	((is_inode_flag_set(i, FI_ACL_MODE)) ? \

	 (F2FS_I(i)->i_acl_mode) : ((i)->i_mode))

fs/f2fs/inline.c

+48 −47
Original line number Diff line number Diff line
@@ -22,7 +22,7 @@ bool f2fs_may_inline_data(struct inode *inode) 
	if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode))

		return false;



	if (i_size_read(inode) > MAX_INLINE_DATA)

	if (i_size_read(inode) > MAX_INLINE_DATA(inode))

		return false;



	if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))
@@ -44,6 +44,7 @@ bool f2fs_may_inline_dentry(struct inode *inode) 


void read_inline_data(struct page *page, struct page *ipage)

{

	struct inode *inode = page->mapping->host;

	void *src_addr, *dst_addr;



	if (PageUptodate(page))
@@ -51,12 +52,12 @@ void read_inline_data(struct page *page, struct page *ipage) 


	f2fs_bug_on(F2FS_P_SB(page), page->index);



	zero_user_segment(page, MAX_INLINE_DATA, PAGE_SIZE);

	zero_user_segment(page, MAX_INLINE_DATA(inode), PAGE_SIZE);



	/* Copy the whole inline data block */

	src_addr = inline_data_addr(ipage);

	src_addr = inline_data_addr(inode, ipage);

	dst_addr = kmap_atomic(page);

	memcpy(dst_addr, src_addr, MAX_INLINE_DATA);

	memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode));

	flush_dcache_page(page);

	kunmap_atomic(dst_addr);

	if (!PageUptodate(page))
@@ -67,13 +68,13 @@ void truncate_inline_inode(struct inode *inode, struct page *ipage, u64 from) 
{

	void *addr;



	if (from >= MAX_INLINE_DATA)

	if (from >= MAX_INLINE_DATA(inode))

		return;



	addr = inline_data_addr(ipage);

	addr = inline_data_addr(inode, ipage);



	f2fs_wait_on_page_writeback(ipage, NODE, true);

	memset(addr + from, 0, MAX_INLINE_DATA - from);

	memset(addr + from, 0, MAX_INLINE_DATA(inode) - from);

	set_page_dirty(ipage);



	if (from == 0)
@@ -216,8 +217,8 @@ int f2fs_write_inline_data(struct inode *inode, struct page *page) 


	f2fs_wait_on_page_writeback(dn.inode_page, NODE, true);

	src_addr = kmap_atomic(page);

	dst_addr = inline_data_addr(dn.inode_page);

	memcpy(dst_addr, src_addr, MAX_INLINE_DATA);

	dst_addr = inline_data_addr(inode, dn.inode_page);

	memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode));

	kunmap_atomic(src_addr);

	set_page_dirty(dn.inode_page);
@@ -255,9 +256,9 @@ process_inline: 


		f2fs_wait_on_page_writeback(ipage, NODE, true);



		src_addr = inline_data_addr(npage);

		dst_addr = inline_data_addr(ipage);

		memcpy(dst_addr, src_addr, MAX_INLINE_DATA);

		src_addr = inline_data_addr(inode, npage);

		dst_addr = inline_data_addr(inode, ipage);

		memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode));



		set_inode_flag(inode, FI_INLINE_DATA);

		set_inode_flag(inode, FI_DATA_EXIST);
@@ -285,11 +286,11 @@ struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir, 
			struct fscrypt_name *fname, struct page **res_page)

{

	struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);

	struct f2fs_inline_dentry *inline_dentry;

	struct qstr name = FSTR_TO_QSTR(&fname->disk_name);

	struct f2fs_dir_entry *de;

	struct f2fs_dentry_ptr d;

	struct page *ipage;

	void *inline_dentry;

	f2fs_hash_t namehash;



	ipage = get_node_page(sbi, dir->i_ino);
@@ -300,9 +301,9 @@ struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir, 


	namehash = f2fs_dentry_hash(&name, fname);



	inline_dentry = inline_data_addr(ipage);

	inline_dentry = inline_data_addr(dir, ipage);



	make_dentry_ptr_inline(NULL, &d, inline_dentry);

	make_dentry_ptr_inline(dir, &d, inline_dentry);

	de = find_target_dentry(fname, namehash, NULL, &d);

	unlock_page(ipage);

	if (de)
@@ -316,19 +317,19 @@ struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir, 
int make_empty_inline_dir(struct inode *inode, struct inode *parent,

							struct page *ipage)

{

	struct f2fs_inline_dentry *inline_dentry;

	struct f2fs_dentry_ptr d;

	void *inline_dentry;



	inline_dentry = inline_data_addr(ipage);

	inline_dentry = inline_data_addr(inode, ipage);



	make_dentry_ptr_inline(NULL, &d, inline_dentry);

	make_dentry_ptr_inline(inode, &d, inline_dentry);

	do_make_empty_dir(inode, parent, &d);



	set_page_dirty(ipage);



	/* update i_size to MAX_INLINE_DATA */

	if (i_size_read(inode) < MAX_INLINE_DATA)

		f2fs_i_size_write(inode, MAX_INLINE_DATA);

	if (i_size_read(inode) < MAX_INLINE_DATA(inode))

		f2fs_i_size_write(inode, MAX_INLINE_DATA(inode));

	return 0;

}
@@ -337,7 +338,7 @@ int make_empty_inline_dir(struct inode *inode, struct inode *parent, 
 * release ipage in this function.

 */

static int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage,

				struct f2fs_inline_dentry *inline_dentry)

							void *inline_dentry)

{

	struct page *page;

	struct dnode_of_data dn;
@@ -357,12 +358,12 @@ static int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage, 
		goto out;



	f2fs_wait_on_page_writeback(page, DATA, true);

	zero_user_segment(page, MAX_INLINE_DATA, PAGE_SIZE);

	zero_user_segment(page, MAX_INLINE_DATA(dir), PAGE_SIZE);



	dentry_blk = kmap_atomic(page);



	make_dentry_ptr_inline(NULL, &src, inline_dentry);

	make_dentry_ptr_block(NULL, &dst, dentry_blk);

	make_dentry_ptr_inline(dir, &src, inline_dentry);

	make_dentry_ptr_block(dir, &dst, dentry_blk);



	/* copy data from inline dentry block to new dentry block */

	memcpy(dst.bitmap, src.bitmap, src.nr_bitmap);
@@ -395,14 +396,13 @@ out: 
	return err;

}



static int f2fs_add_inline_entries(struct inode *dir,

			struct f2fs_inline_dentry *inline_dentry)

static int f2fs_add_inline_entries(struct inode *dir, void *inline_dentry)

{

	struct f2fs_dentry_ptr d;

	unsigned long bit_pos = 0;

	int err = 0;



	make_dentry_ptr_inline(NULL, &d, inline_dentry);

	make_dentry_ptr_inline(dir, &d, inline_dentry);



	while (bit_pos < d.max) {

		struct f2fs_dir_entry *de;
@@ -444,19 +444,19 @@ punch_dentry_pages: 
}



static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage,

				struct f2fs_inline_dentry *inline_dentry)

							void *inline_dentry)

{

	struct f2fs_inline_dentry *backup_dentry;

	void *backup_dentry;

	int err;



	backup_dentry = f2fs_kmalloc(F2FS_I_SB(dir),

			sizeof(struct f2fs_inline_dentry), GFP_F2FS_ZERO);

				MAX_INLINE_DATA(dir), GFP_F2FS_ZERO);

	if (!backup_dentry) {

		f2fs_put_page(ipage, 1);

		return -ENOMEM;

	}



	memcpy(backup_dentry, inline_dentry, MAX_INLINE_DATA);

	memcpy(backup_dentry, inline_dentry, MAX_INLINE_DATA(dir));

	truncate_inline_inode(dir, ipage, 0);



	unlock_page(ipage);
@@ -473,9 +473,9 @@ static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage, 
	return 0;

recover:

	lock_page(ipage);

	memcpy(inline_dentry, backup_dentry, MAX_INLINE_DATA);

	memcpy(inline_dentry, backup_dentry, MAX_INLINE_DATA(dir));

	f2fs_i_depth_write(dir, 0);

	f2fs_i_size_write(dir, MAX_INLINE_DATA);

	f2fs_i_size_write(dir, MAX_INLINE_DATA(dir));

	set_page_dirty(ipage);

	f2fs_put_page(ipage, 1);
@@ -484,7 +484,7 @@ recover: 
}



static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage,

				struct f2fs_inline_dentry *inline_dentry)

							void *inline_dentry)

{

	if (!F2FS_I(dir)->i_dir_level)

		return f2fs_move_inline_dirents(dir, ipage, inline_dentry);
@@ -500,7 +500,7 @@ int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name, 
	struct page *ipage;

	unsigned int bit_pos;

	f2fs_hash_t name_hash;

	struct f2fs_inline_dentry *inline_dentry = NULL;

	void *inline_dentry = NULL;

	struct f2fs_dentry_ptr d;

	int slots = GET_DENTRY_SLOTS(new_name->len);

	struct page *page = NULL;
@@ -510,8 +510,8 @@ int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name, 
	if (IS_ERR(ipage))

		return PTR_ERR(ipage);



	inline_dentry = inline_data_addr(ipage);

	make_dentry_ptr_inline(NULL, &d, inline_dentry);

	inline_dentry = inline_data_addr(dir, ipage);

	make_dentry_ptr_inline(dir, &d, inline_dentry);



	bit_pos = room_for_filename(d.bitmap, slots, d.max);

	if (bit_pos >= d.max) {
@@ -557,8 +557,8 @@ out: 
void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,

					struct inode *dir, struct inode *inode)

{

	struct f2fs_inline_dentry *inline_dentry;

	struct f2fs_dentry_ptr d;

	void *inline_dentry;

	int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));

	unsigned int bit_pos;

	int i;
@@ -566,8 +566,8 @@ void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page, 
	lock_page(page);

	f2fs_wait_on_page_writeback(page, NODE, true);



	inline_dentry = inline_data_addr(page);

	make_dentry_ptr_inline(NULL, &d, inline_dentry);

	inline_dentry = inline_data_addr(dir, page);

	make_dentry_ptr_inline(dir, &d, inline_dentry);



	bit_pos = dentry - d.dentry;

	for (i = 0; i < slots; i++)
@@ -588,15 +588,15 @@ bool f2fs_empty_inline_dir(struct inode *dir) 
	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);

	struct page *ipage;

	unsigned int bit_pos = 2;

	struct f2fs_inline_dentry *inline_dentry;

	void *inline_dentry;

	struct f2fs_dentry_ptr d;



	ipage = get_node_page(sbi, dir->i_ino);

	if (IS_ERR(ipage))

		return false;



	inline_dentry = inline_data_addr(ipage);

	make_dentry_ptr_inline(NULL, &d, inline_dentry);

	inline_dentry = inline_data_addr(dir, ipage);

	make_dentry_ptr_inline(dir, &d, inline_dentry);



	bit_pos = find_next_bit_le(d.bitmap, d.max, bit_pos);
@@ -612,9 +612,9 @@ int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx, 
				struct fscrypt_str *fstr)

{

	struct inode *inode = file_inode(file);

	struct f2fs_inline_dentry *inline_dentry = NULL;

	struct page *ipage = NULL;

	struct f2fs_dentry_ptr d;

	void *inline_dentry = NULL;

	int err;



	make_dentry_ptr_inline(inode, &d, inline_dentry);
@@ -626,7 +626,7 @@ int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx, 
	if (IS_ERR(ipage))

		return PTR_ERR(ipage);



	inline_dentry = inline_data_addr(ipage);

	inline_dentry = inline_data_addr(inode, ipage);



	make_dentry_ptr_inline(inode, &d, inline_dentry);
@@ -657,7 +657,7 @@ int f2fs_inline_data_fiemap(struct inode *inode, 
		goto out;

	}



	ilen = min_t(size_t, MAX_INLINE_DATA, i_size_read(inode));

	ilen = min_t(size_t, MAX_INLINE_DATA(inode), i_size_read(inode));

	if (start >= ilen)

		goto out;

	if (start + len < ilen)
@@ -666,7 +666,8 @@ int f2fs_inline_data_fiemap(struct inode *inode, 


	get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni);

	byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits;

	byteaddr += (char *)inline_data_addr(ipage) - (char *)F2FS_INODE(ipage);

	byteaddr += (char *)inline_data_addr(inode, ipage) -

					(char *)F2FS_INODE(ipage);

	err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags);

out:

	f2fs_put_page(ipage, 1);

fs/f2fs/inode.c

+2 −2
Original line number Diff line number Diff line
@@ -87,9 +87,9 @@ static void __set_inode_rdev(struct inode *inode, struct f2fs_inode *ri) 


static void __recover_inline_status(struct inode *inode, struct page *ipage)

{

	void *inline_data = inline_data_addr(ipage);

	void *inline_data = inline_data_addr(inode, ipage);

	__le32 *start = inline_data;

	__le32 *end = start + MAX_INLINE_DATA / sizeof(__le32);

	__le32 *end = start + MAX_INLINE_DATA(inode) / sizeof(__le32);



	while (start < end) {

		if (*start++) {

fs/f2fs/super.c

+3 −0
Original line number Diff line number Diff line
@@ -435,6 +435,9 @@ static struct inode *f2fs_alloc_inode(struct super_block *sb) 
#endif

	/* Will be used by directory only */

	fi->i_dir_level = F2FS_SB(sb)->dir_level;



	fi->i_inline_reserved = DEF_INLINE_RESERVED_SIZE;



	return &fi->vfs_inode;

}