Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > linux.kernel > #1688138 > unrolled thread

[PATCH 2/6] f2fs: make max inline size changeable

Started byChao Yu <chao@kernel.org>
First post2017-07-16 09:20 +0200
Last post2017-07-18 03:50 +0200
Articles 3 — 3 participants

Back to article view | Back to linux.kernel

This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by below is the oldest one visible, not the original post.

Contents

  [PATCH 2/6] f2fs: make max inline size changeable Chao Yu <chao@kernel.org> - 2017-07-16 09:20 +0200
    Re: [PATCH 2/6] f2fs: make max inline size changeable Jaegeuk Kim <jaegeuk@kernel.org> - 2017-07-18 01:20 +0200
      Re: [PATCH 2/6] f2fs: make max inline size changeable Chao Yu <yuchao0@huawei.com> - 2017-07-18 03:50 +0200

#1688138 — [PATCH 2/6] f2fs: make max inline size changeable

FromChao Yu <chao@kernel.org>
Date2017-07-16 09:20 +0200
Subject[PATCH 2/6] f2fs: make max inline size changeable
Message-ID<u3M0p-44x-1@gated-at.bofh.it>
From: Chao Yu <yuchao0@huawei.com>

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: Chao Yu <yuchao0@huawei.com>
---
 fs/f2fs/data.c          |   6 +--
 fs/f2fs/f2fs.h          |  51 +++++++++++++++++++-----
 fs/f2fs/inline.c        | 101 ++++++++++++++++++++++++------------------------
 fs/f2fs/inode.c         |   4 +-
 fs/f2fs/super.c         |   3 ++
 include/linux/f2fs_fs.h |  23 +----------
 6 files changed, 102 insertions(+), 86 deletions(-)

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 251356859476..f42a93781119 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -813,7 +813,7 @@ int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from)
 				F2FS_GET_BLOCK_PRE_AIO :
 				F2FS_GET_BLOCK_PRE_DIO);
 	}
-	if (iocb->ki_pos + iov_iter_count(from) > MAX_INLINE_DATA) {
+	if (iocb->ki_pos + iov_iter_count(from) > MAX_INLINE_DATA(inode)) {
 		err = f2fs_convert_inline_inode(inode);
 		if (err)
 			return err;
@@ -1857,8 +1857,8 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi,
 	set_new_dnode(&dn, inode, ipage, ipage, 0);
 
 	if (f2fs_has_inline_data(inode)) {
-		if (pos + len <= MAX_INLINE_DATA) {
-			read_inline_data(page, ipage);
+		if (pos + len <= MAX_INLINE_DATA(inode)) {
+			read_inline_data(inode, page, ipage);
 			set_inode_flag(inode, FI_DATA_EXIST);
 			if (inode->i_nlink)
 				set_inline_node(ipage);
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 23f117e4aeb8..8a23001e2ed2 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -355,6 +355,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
  */
@@ -380,14 +399,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;
 }
 
 /*
@@ -540,6 +564,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,
@@ -2069,11 +2095,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)
@@ -2184,6 +2211,11 @@ static inline void *f2fs_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))
@@ -2681,7 +2713,8 @@ extern struct kmem_cache *inode_entry_slab;
  */
 bool f2fs_may_inline_data(struct inode *inode);
 bool f2fs_may_inline_dentry(struct inode *inode);
-void read_inline_data(struct page *page, struct page *ipage);
+void read_inline_data(struct inode *inode, struct page *page,
+							struct page *ipage);
 void truncate_inline_inode(struct inode *inode, struct page *ipage, u64 from);
 int f2fs_read_inline_data(struct inode *inode, struct page *page);
 int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page);
diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index 2082816a504a..838ad2339e54 100644
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -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))
@@ -42,7 +42,8 @@ bool f2fs_may_inline_dentry(struct inode *inode)
 	return true;
 }
 
-void read_inline_data(struct page *page, struct page *ipage)
+void read_inline_data(struct inode *inode, struct page *page,
+						struct page *ipage)
 {
 	void *src_addr, *dst_addr;
 
@@ -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)
@@ -98,7 +99,7 @@ int f2fs_read_inline_data(struct inode *inode, struct page *page)
 	if (page->index)
 		zero_user_segment(page, 0, PAGE_SIZE);
 	else
-		read_inline_data(page, ipage);
+		read_inline_data(inode, page, ipage);
 
 	if (!PageUptodate(page))
 		SetPageUptodate(page);
@@ -128,7 +129,7 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
 
 	f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page));
 
-	read_inline_data(page, dn->inode_page);
+	read_inline_data(dn->inode, page, dn->inode_page);
 	set_page_dirty(page);
 
 	/* clear dirty state */
@@ -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 @@ bool recover_inline_data(struct inode *inode, struct page *npage)
 
 		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 @@ static int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage,
 	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 @@ static int f2fs_add_inline_entries(struct inode *dir,
 }
 
 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 @@ static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage,
 }
 
 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 @@ int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name,
 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);
diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index 6cd312a17c69..32ec6b23fe01 100644
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -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++) {
diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index dd92170e0d6d..71ad30214ef0 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -446,6 +446,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;
 }
 
diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
index b6feed6547ce..060b1c5b0836 100644
--- a/include/linux/f2fs_fs.h
+++ b/include/linux/f2fs_fs.h
@@ -206,9 +206,6 @@ struct f2fs_extent {
 #define F2FS_DATA_EXIST		0x08	/* file inline data exist flag */
 #define F2FS_INLINE_DOTS	0x10	/* file having implicit dot dentries */
 
-#define MAX_INLINE_DATA		(sizeof(__le32) * (DEF_ADDRS_PER_INODE - \
-						F2FS_INLINE_XATTR_ADDRS - 1))
-
 struct f2fs_inode {
 	__le16 i_mode;			/* file mode */
 	__u8 i_advise;			/* file hints */
@@ -465,7 +462,7 @@ typedef __le32	f2fs_hash_t;
 #define MAX_DIR_BUCKETS		(1 << ((MAX_DIR_HASH_DEPTH / 2) - 1))
 
 /*
- * space utilization of regular dentry and inline dentry
+ * space utilization of regular dentry and inline dentry (w/o extra reservation)
  *		regular dentry			inline dentry
  * bitmap	1 * 27 = 27			1 * 23 = 23
  * reserved	1 * 3 = 3			1 * 7 = 7
@@ -501,24 +498,6 @@ struct f2fs_dentry_block {
 	__u8 filename[NR_DENTRY_IN_BLOCK][F2FS_SLOT_LEN];
 } __packed;
 
-/* for inline dir */
-#define NR_INLINE_DENTRY	(MAX_INLINE_DATA * BITS_PER_BYTE / \
-				((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
-				BITS_PER_BYTE + 1))
-#define INLINE_DENTRY_BITMAP_SIZE	((NR_INLINE_DENTRY + \
-					BITS_PER_BYTE - 1) / BITS_PER_BYTE)
-#define INLINE_RESERVED_SIZE	(MAX_INLINE_DATA - \
-				((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
-				NR_INLINE_DENTRY + INLINE_DENTRY_BITMAP_SIZE))
-
-/* inline directory entry structure */
-struct f2fs_inline_dentry {
-	__u8 dentry_bitmap[INLINE_DENTRY_BITMAP_SIZE];
-	__u8 reserved[INLINE_RESERVED_SIZE];
-	struct f2fs_dir_entry dentry[NR_INLINE_DENTRY];
-	__u8 filename[NR_INLINE_DENTRY][F2FS_SLOT_LEN];
-} __packed;
-
 /* file types used in inode_info->flags */
 enum {
 	F2FS_FT_UNKNOWN,
-- 
2.13.0.90.g1eb437020

[toc] | [next] | [standalone]

#1689560

FromJaegeuk Kim <jaegeuk@kernel.org>
Date2017-07-18 01:20 +0200
Message-ID<u4nt0-33h-9@gated-at.bofh.it>
In reply to#1688138
Hi Chao,

On 07/16, Chao Yu wrote:
> From: Chao Yu <yuchao0@huawei.com>
> 
> 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: Chao Yu <yuchao0@huawei.com>
> ---
>  fs/f2fs/data.c          |   6 +--
>  fs/f2fs/f2fs.h          |  51 +++++++++++++++++++-----
>  fs/f2fs/inline.c        | 101 ++++++++++++++++++++++++------------------------
>  fs/f2fs/inode.c         |   4 +-
>  fs/f2fs/super.c         |   3 ++
>  include/linux/f2fs_fs.h |  23 +----------
>  6 files changed, 102 insertions(+), 86 deletions(-)
> 
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index 251356859476..f42a93781119 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -813,7 +813,7 @@ int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from)
>  				F2FS_GET_BLOCK_PRE_AIO :
>  				F2FS_GET_BLOCK_PRE_DIO);
>  	}
> -	if (iocb->ki_pos + iov_iter_count(from) > MAX_INLINE_DATA) {
> +	if (iocb->ki_pos + iov_iter_count(from) > MAX_INLINE_DATA(inode)) {
>  		err = f2fs_convert_inline_inode(inode);
>  		if (err)
>  			return err;
> @@ -1857,8 +1857,8 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi,
>  	set_new_dnode(&dn, inode, ipage, ipage, 0);
>  
>  	if (f2fs_has_inline_data(inode)) {
> -		if (pos + len <= MAX_INLINE_DATA) {
> -			read_inline_data(page, ipage);
> +		if (pos + len <= MAX_INLINE_DATA(inode)) {
> +			read_inline_data(inode, page, ipage);
>  			set_inode_flag(inode, FI_DATA_EXIST);
>  			if (inode->i_nlink)
>  				set_inline_node(ipage);
> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> index 23f117e4aeb8..8a23001e2ed2 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -355,6 +355,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
>   */
> @@ -380,14 +399,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;
>  }
>  
>  /*
> @@ -540,6 +564,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,
> @@ -2069,11 +2095,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)
> @@ -2184,6 +2211,11 @@ static inline void *f2fs_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))
> @@ -2681,7 +2713,8 @@ extern struct kmem_cache *inode_entry_slab;
>   */
>  bool f2fs_may_inline_data(struct inode *inode);
>  bool f2fs_may_inline_dentry(struct inode *inode);
> -void read_inline_data(struct page *page, struct page *ipage);
> +void read_inline_data(struct inode *inode, struct page *page,
> +							struct page *ipage);
>  void truncate_inline_inode(struct inode *inode, struct page *ipage, u64 from);
>  int f2fs_read_inline_data(struct inode *inode, struct page *page);
>  int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page);
> diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
> index 2082816a504a..838ad2339e54 100644
> --- a/fs/f2fs/inline.c
> +++ b/fs/f2fs/inline.c
> @@ -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))
> @@ -42,7 +42,8 @@ bool f2fs_may_inline_dentry(struct inode *inode)
>  	return true;
>  }
>  
> -void read_inline_data(struct page *page, struct page *ipage)
> +void read_inline_data(struct inode *inode, struct page *page,
> +						struct page *ipage)
>  {
>  	void *src_addr, *dst_addr;

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

Thanks,

>  
> @@ -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)
> @@ -98,7 +99,7 @@ int f2fs_read_inline_data(struct inode *inode, struct page *page)
>  	if (page->index)
>  		zero_user_segment(page, 0, PAGE_SIZE);
>  	else
> -		read_inline_data(page, ipage);
> +		read_inline_data(inode, page, ipage);
>  
>  	if (!PageUptodate(page))
>  		SetPageUptodate(page);
> @@ -128,7 +129,7 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
>  
>  	f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page));
>  
> -	read_inline_data(page, dn->inode_page);
> +	read_inline_data(dn->inode, page, dn->inode_page);
>  	set_page_dirty(page);
>  
>  	/* clear dirty state */
> @@ -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 @@ bool recover_inline_data(struct inode *inode, struct page *npage)
>  
>  		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 @@ static int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage,
>  	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 @@ static int f2fs_add_inline_entries(struct inode *dir,
>  }
>  
>  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 @@ static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage,
>  }
>  
>  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 @@ int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name,
>  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);
> diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
> index 6cd312a17c69..32ec6b23fe01 100644
> --- a/fs/f2fs/inode.c
> +++ b/fs/f2fs/inode.c
> @@ -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++) {
> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
> index dd92170e0d6d..71ad30214ef0 100644
> --- a/fs/f2fs/super.c
> +++ b/fs/f2fs/super.c
> @@ -446,6 +446,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;
>  }
>  
> diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
> index b6feed6547ce..060b1c5b0836 100644
> --- a/include/linux/f2fs_fs.h
> +++ b/include/linux/f2fs_fs.h
> @@ -206,9 +206,6 @@ struct f2fs_extent {
>  #define F2FS_DATA_EXIST		0x08	/* file inline data exist flag */
>  #define F2FS_INLINE_DOTS	0x10	/* file having implicit dot dentries */
>  
> -#define MAX_INLINE_DATA		(sizeof(__le32) * (DEF_ADDRS_PER_INODE - \
> -						F2FS_INLINE_XATTR_ADDRS - 1))
> -
>  struct f2fs_inode {
>  	__le16 i_mode;			/* file mode */
>  	__u8 i_advise;			/* file hints */
> @@ -465,7 +462,7 @@ typedef __le32	f2fs_hash_t;
>  #define MAX_DIR_BUCKETS		(1 << ((MAX_DIR_HASH_DEPTH / 2) - 1))
>  
>  /*
> - * space utilization of regular dentry and inline dentry
> + * space utilization of regular dentry and inline dentry (w/o extra reservation)
>   *		regular dentry			inline dentry
>   * bitmap	1 * 27 = 27			1 * 23 = 23
>   * reserved	1 * 3 = 3			1 * 7 = 7
> @@ -501,24 +498,6 @@ struct f2fs_dentry_block {
>  	__u8 filename[NR_DENTRY_IN_BLOCK][F2FS_SLOT_LEN];
>  } __packed;
>  
> -/* for inline dir */
> -#define NR_INLINE_DENTRY	(MAX_INLINE_DATA * BITS_PER_BYTE / \
> -				((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
> -				BITS_PER_BYTE + 1))
> -#define INLINE_DENTRY_BITMAP_SIZE	((NR_INLINE_DENTRY + \
> -					BITS_PER_BYTE - 1) / BITS_PER_BYTE)
> -#define INLINE_RESERVED_SIZE	(MAX_INLINE_DATA - \
> -				((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
> -				NR_INLINE_DENTRY + INLINE_DENTRY_BITMAP_SIZE))
> -
> -/* inline directory entry structure */
> -struct f2fs_inline_dentry {
> -	__u8 dentry_bitmap[INLINE_DENTRY_BITMAP_SIZE];
> -	__u8 reserved[INLINE_RESERVED_SIZE];
> -	struct f2fs_dir_entry dentry[NR_INLINE_DENTRY];
> -	__u8 filename[NR_INLINE_DENTRY][F2FS_SLOT_LEN];
> -} __packed;
> -
>  /* file types used in inode_info->flags */
>  enum {
>  	F2FS_FT_UNKNOWN,
> -- 
> 2.13.0.90.g1eb437020

[toc] | [prev] | [next] | [standalone]

#1689605

FromChao Yu <yuchao0@huawei.com>
Date2017-07-18 03:50 +0200
Message-ID<u4pOa-4ov-3@gated-at.bofh.it>
In reply to#1689560
Hi Jaegeuk,

On 2017/7/18 7:12, Jaegeuk Kim wrote:
> Hi Chao,
> 
> On 07/16, Chao Yu wrote:
>> From: Chao Yu <yuchao0@huawei.com>
>>
>> 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: Chao Yu <yuchao0@huawei.com>
>> ---
>>  fs/f2fs/data.c          |   6 +--
>>  fs/f2fs/f2fs.h          |  51 +++++++++++++++++++-----
>>  fs/f2fs/inline.c        | 101 ++++++++++++++++++++++++------------------------
>>  fs/f2fs/inode.c         |   4 +-
>>  fs/f2fs/super.c         |   3 ++
>>  include/linux/f2fs_fs.h |  23 +----------
>>  6 files changed, 102 insertions(+), 86 deletions(-)
>>
>> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
>> index 251356859476..f42a93781119 100644
>> --- a/fs/f2fs/data.c
>> +++ b/fs/f2fs/data.c
>> @@ -813,7 +813,7 @@ int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from)
>>  				F2FS_GET_BLOCK_PRE_AIO :
>>  				F2FS_GET_BLOCK_PRE_DIO);
>>  	}
>> -	if (iocb->ki_pos + iov_iter_count(from) > MAX_INLINE_DATA) {
>> +	if (iocb->ki_pos + iov_iter_count(from) > MAX_INLINE_DATA(inode)) {
>>  		err = f2fs_convert_inline_inode(inode);
>>  		if (err)
>>  			return err;
>> @@ -1857,8 +1857,8 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi,
>>  	set_new_dnode(&dn, inode, ipage, ipage, 0);
>>  
>>  	if (f2fs_has_inline_data(inode)) {
>> -		if (pos + len <= MAX_INLINE_DATA) {
>> -			read_inline_data(page, ipage);
>> +		if (pos + len <= MAX_INLINE_DATA(inode)) {
>> +			read_inline_data(inode, page, ipage);
>>  			set_inode_flag(inode, FI_DATA_EXIST);
>>  			if (inode->i_nlink)
>>  				set_inline_node(ipage);
>> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
>> index 23f117e4aeb8..8a23001e2ed2 100644
>> --- a/fs/f2fs/f2fs.h
>> +++ b/fs/f2fs/f2fs.h
>> @@ -355,6 +355,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
>>   */
>> @@ -380,14 +399,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;
>>  }
>>  
>>  /*
>> @@ -540,6 +564,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,
>> @@ -2069,11 +2095,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)
>> @@ -2184,6 +2211,11 @@ static inline void *f2fs_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))
>> @@ -2681,7 +2713,8 @@ extern struct kmem_cache *inode_entry_slab;
>>   */
>>  bool f2fs_may_inline_data(struct inode *inode);
>>  bool f2fs_may_inline_dentry(struct inode *inode);
>> -void read_inline_data(struct page *page, struct page *ipage);
>> +void read_inline_data(struct inode *inode, struct page *page,
>> +							struct page *ipage);
>>  void truncate_inline_inode(struct inode *inode, struct page *ipage, u64 from);
>>  int f2fs_read_inline_data(struct inode *inode, struct page *page);
>>  int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page);
>> diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
>> index 2082816a504a..838ad2339e54 100644
>> --- a/fs/f2fs/inline.c
>> +++ b/fs/f2fs/inline.c
>> @@ -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))
>> @@ -42,7 +42,8 @@ bool f2fs_may_inline_dentry(struct inode *inode)
>>  	return true;
>>  }
>>  
>> -void read_inline_data(struct page *page, struct page *ipage)
>> +void read_inline_data(struct inode *inode, struct page *page,
>> +						struct page *ipage)
>>  {
>>  	void *src_addr, *dst_addr;
> 
> How about
> 	struct inode *inode = page->mapping->host;

More clean, I will update it.

Thanks,

> 
> Thanks,
> 
>>  
>> @@ -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)
>> @@ -98,7 +99,7 @@ int f2fs_read_inline_data(struct inode *inode, struct page *page)
>>  	if (page->index)
>>  		zero_user_segment(page, 0, PAGE_SIZE);
>>  	else
>> -		read_inline_data(page, ipage);
>> +		read_inline_data(inode, page, ipage);
>>  
>>  	if (!PageUptodate(page))
>>  		SetPageUptodate(page);
>> @@ -128,7 +129,7 @@ int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
>>  
>>  	f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page));
>>  
>> -	read_inline_data(page, dn->inode_page);
>> +	read_inline_data(dn->inode, page, dn->inode_page);
>>  	set_page_dirty(page);
>>  
>>  	/* clear dirty state */
>> @@ -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 @@ bool recover_inline_data(struct inode *inode, struct page *npage)
>>  
>>  		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 @@ static int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage,
>>  	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 @@ static int f2fs_add_inline_entries(struct inode *dir,
>>  }
>>  
>>  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 @@ static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage,
>>  }
>>  
>>  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 @@ int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name,
>>  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);
>> diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
>> index 6cd312a17c69..32ec6b23fe01 100644
>> --- a/fs/f2fs/inode.c
>> +++ b/fs/f2fs/inode.c
>> @@ -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++) {
>> diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
>> index dd92170e0d6d..71ad30214ef0 100644
>> --- a/fs/f2fs/super.c
>> +++ b/fs/f2fs/super.c
>> @@ -446,6 +446,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;
>>  }
>>  
>> diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
>> index b6feed6547ce..060b1c5b0836 100644
>> --- a/include/linux/f2fs_fs.h
>> +++ b/include/linux/f2fs_fs.h
>> @@ -206,9 +206,6 @@ struct f2fs_extent {
>>  #define F2FS_DATA_EXIST		0x08	/* file inline data exist flag */
>>  #define F2FS_INLINE_DOTS	0x10	/* file having implicit dot dentries */
>>  
>> -#define MAX_INLINE_DATA		(sizeof(__le32) * (DEF_ADDRS_PER_INODE - \
>> -						F2FS_INLINE_XATTR_ADDRS - 1))
>> -
>>  struct f2fs_inode {
>>  	__le16 i_mode;			/* file mode */
>>  	__u8 i_advise;			/* file hints */
>> @@ -465,7 +462,7 @@ typedef __le32	f2fs_hash_t;
>>  #define MAX_DIR_BUCKETS		(1 << ((MAX_DIR_HASH_DEPTH / 2) - 1))
>>  
>>  /*
>> - * space utilization of regular dentry and inline dentry
>> + * space utilization of regular dentry and inline dentry (w/o extra reservation)
>>   *		regular dentry			inline dentry
>>   * bitmap	1 * 27 = 27			1 * 23 = 23
>>   * reserved	1 * 3 = 3			1 * 7 = 7
>> @@ -501,24 +498,6 @@ struct f2fs_dentry_block {
>>  	__u8 filename[NR_DENTRY_IN_BLOCK][F2FS_SLOT_LEN];
>>  } __packed;
>>  
>> -/* for inline dir */
>> -#define NR_INLINE_DENTRY	(MAX_INLINE_DATA * BITS_PER_BYTE / \
>> -				((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
>> -				BITS_PER_BYTE + 1))
>> -#define INLINE_DENTRY_BITMAP_SIZE	((NR_INLINE_DENTRY + \
>> -					BITS_PER_BYTE - 1) / BITS_PER_BYTE)
>> -#define INLINE_RESERVED_SIZE	(MAX_INLINE_DATA - \
>> -				((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
>> -				NR_INLINE_DENTRY + INLINE_DENTRY_BITMAP_SIZE))
>> -
>> -/* inline directory entry structure */
>> -struct f2fs_inline_dentry {
>> -	__u8 dentry_bitmap[INLINE_DENTRY_BITMAP_SIZE];
>> -	__u8 reserved[INLINE_RESERVED_SIZE];
>> -	struct f2fs_dir_entry dentry[NR_INLINE_DENTRY];
>> -	__u8 filename[NR_INLINE_DENTRY][F2FS_SLOT_LEN];
>> -} __packed;
>> -
>>  /* file types used in inode_info->flags */
>>  enum {
>>  	F2FS_FT_UNKNOWN,
>> -- 
>> 2.13.0.90.g1eb437020
> 
> .
>

[toc] | [prev] | [standalone]

Back to top | Article view | linux.kernel

csiph-web