* [f2fs-dev 1/5] f2fs: Add flags and helpers to support inline data
2013-10-25 16:01 [f2fs-dev 0/5] f2fs: Enable f2fs support inline data Huajun Li
@ 2013-10-25 16:01 ` Huajun Li
2013-10-25 16:01 ` [f2fs-dev 2/5] f2fs: Add a new mount option: inline_data Huajun Li
` (3 subsequent siblings)
4 siblings, 0 replies; 16+ messages in thread
From: Huajun Li @ 2013-10-25 16:01 UTC (permalink / raw)
To: jaegeuk.kim, linux-f2fs-devel
Cc: linux-fsdevel, linux-kernel, Huajun Li, Haicheng Li, Weihong Xu
From: Huajun Li <huajun.li@intel.com>
Add new inode flags F2FS_INLINE_DATA and FI_INLINE_DATA to indicate
whether the inode has inline data.
Inline data makes use of inode block's data indices region to save small
file. Currently there are 923 data indices in an inode block. Since
inline xattr has made use of the last 50 indices to save its data, there
are 873 indices left which can be used for inline data. When
FI_INLINE_DATA is set, the layout of inode block's indices region is
like below:
+-----------------+
| | Reserved. reserve_new_block() will make use of
| i_addr[0] | i_addr[0] when we need to reserve a new data block
| | to convert inline data into regular one's.
|-----------------|
| | Used by inline data. A file whose size is less than
| i_addr[1..872] | 3488 bytes(~3.4k) and doesn't reserve extra
| | blocks by fallocate() can be saved here.
|-----------------|
| i_addr[873-922] | Reserved for inline xattr
+-----------------+
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
---
fs/f2fs/f2fs.h | 14 ++++++++++++++
include/linux/f2fs_fs.h | 8 ++++++++
2 files changed, 22 insertions(+)
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index a61cc5f..e50a8b0 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -31,6 +31,7 @@
#define F2FS_MOUNT_POSIX_ACL 0x00000020
#define F2FS_MOUNT_DISABLE_EXT_IDENTIFY 0x00000040
#define F2FS_MOUNT_INLINE_XATTR 0x00000080
+#define F2FS_MOUNT_INLINE_DATA 0x00000100
#define clear_opt(sbi, option) (sbi->mount_opt.opt &= ~F2FS_MOUNT_##option)
#define set_opt(sbi, option) (sbi->mount_opt.opt |= F2FS_MOUNT_##option)
@@ -871,6 +872,7 @@ enum {
FI_UPDATE_DIR, /* should update inode block for consistency */
FI_DELAY_IPUT, /* used for the recovery */
FI_INLINE_XATTR, /* used for inline xattr */
+ FI_INLINE_DATA, /* used for inline data*/
};
static inline void set_inode_flag(struct f2fs_inode_info *fi, int flag)
@@ -908,6 +910,8 @@ static inline void get_inline_info(struct f2fs_inode_info *fi,
{
if (ri->i_inline & F2FS_INLINE_XATTR)
set_inode_flag(fi, FI_INLINE_XATTR);
+ if (ri->i_inline & F2FS_INLINE_DATA)
+ set_inode_flag(fi, FI_INLINE_DATA);
}
static inline void set_raw_inline(struct f2fs_inode_info *fi,
@@ -917,6 +921,8 @@ static inline void set_raw_inline(struct f2fs_inode_info *fi,
if (is_inode_flag_set(fi, FI_INLINE_XATTR))
ri->i_inline |= F2FS_INLINE_XATTR;
+ if (is_inode_flag_set(fi, FI_INLINE_DATA))
+ ri->i_inline |= F2FS_INLINE_DATA;
}
static inline unsigned int addrs_per_inode(struct f2fs_inode_info *fi)
@@ -942,6 +948,13 @@ static inline int inline_xattr_size(struct inode *inode)
return 0;
}
+static inline void *inline_data_addr(struct page *page)
+{
+ struct f2fs_inode *ri;
+ ri = (struct f2fs_inode *)page_address(page);
+ return (void *)&(ri->i_addr[1]);
+}
+
static inline int f2fs_readonly(struct super_block *sb)
{
return sb->s_flags & MS_RDONLY;
@@ -1231,4 +1244,5 @@ extern const struct address_space_operations f2fs_meta_aops;
extern const struct inode_operations f2fs_dir_inode_operations;
extern const struct inode_operations f2fs_symlink_inode_operations;
extern const struct inode_operations f2fs_special_inode_operations;
+
#endif
diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
index bb942f6..aea5eed 100644
--- a/include/linux/f2fs_fs.h
+++ b/include/linux/f2fs_fs.h
@@ -153,6 +153,14 @@ struct f2fs_extent {
#define NODE_DIND_BLOCK (DEF_ADDRS_PER_INODE + 5)
#define F2FS_INLINE_XATTR 0x01 /* file inline xattr flag */
+#define F2FS_INLINE_DATA 0x02 /* file inline data flag */
+
+
+#define MAX_INLINE_DATA (sizeof(__le32) * (DEF_ADDRS_PER_INODE - \
+ F2FS_INLINE_XATTR_ADDRS - 1))
+
+#define INLINE_DATA_OFFSET (PAGE_CACHE_SIZE - sizeof(struct node_footer) \
+ - sizeof(__le32)*(DEF_ADDRS_PER_INODE + 5 - 1))
struct f2fs_inode {
__le16 i_mode; /* file mode */
--
1.7.9.5
^ permalink raw reply related [flat|nested] 16+ messages in thread* [f2fs-dev 2/5] f2fs: Add a new mount option: inline_data
2013-10-25 16:01 [f2fs-dev 0/5] f2fs: Enable f2fs support inline data Huajun Li
2013-10-25 16:01 ` [f2fs-dev 1/5] f2fs: Add flags and helpers to " Huajun Li
@ 2013-10-25 16:01 ` Huajun Li
2013-10-25 16:01 ` [f2fs-dev 3/5] f2fs: Add a new function: f2fs_reserve_block() Huajun Li
` (2 subsequent siblings)
4 siblings, 0 replies; 16+ messages in thread
From: Huajun Li @ 2013-10-25 16:01 UTC (permalink / raw)
To: jaegeuk.kim, linux-f2fs-devel
Cc: linux-fsdevel, linux-kernel, Huajun Li, Haicheng Li, Weihong Xu
From: Huajun Li <huajun.li@intel.com>
Add a mount option: inline_data. If the mount option is set,
data of New created small files can be stored in their inode.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
---
fs/f2fs/super.c | 8 +++++++-
1 file changed, 7 insertions(+), 1 deletion(-)
diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index e42351c..e8ad7f2 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -50,6 +50,7 @@ enum {
Opt_active_logs,
Opt_disable_ext_identify,
Opt_inline_xattr,
+ Opt_inline_data,
Opt_err,
};
@@ -65,6 +66,7 @@ static match_table_t f2fs_tokens = {
{Opt_active_logs, "active_logs=%u"},
{Opt_disable_ext_identify, "disable_ext_identify"},
{Opt_inline_xattr, "inline_xattr"},
+ {Opt_inline_data, "inline_data"},
{Opt_err, NULL},
};
@@ -311,6 +313,9 @@ static int parse_options(struct super_block *sb, char *options)
case Opt_disable_ext_identify:
set_opt(sbi, DISABLE_EXT_IDENTIFY);
break;
+ case Opt_inline_data:
+ set_opt(sbi, INLINE_DATA);
+ break;
default:
f2fs_msg(sb, KERN_ERR,
"Unrecognized mount option \"%s\" or missing value",
@@ -508,7 +513,8 @@ static int f2fs_show_options(struct seq_file *seq, struct dentry *root)
#endif
if (test_opt(sbi, DISABLE_EXT_IDENTIFY))
seq_puts(seq, ",disable_ext_identify");
-
+ if (test_opt(sbi, INLINE_DATA))
+ seq_puts(seq, ",inline_data");
seq_printf(seq, ",active_logs=%u", sbi->active_logs);
return 0;
--
1.7.9.5
^ permalink raw reply related [flat|nested] 16+ messages in thread* [f2fs-dev 3/5] f2fs: Add a new function: f2fs_reserve_block()
2013-10-25 16:01 [f2fs-dev 0/5] f2fs: Enable f2fs support inline data Huajun Li
2013-10-25 16:01 ` [f2fs-dev 1/5] f2fs: Add flags and helpers to " Huajun Li
2013-10-25 16:01 ` [f2fs-dev 2/5] f2fs: Add a new mount option: inline_data Huajun Li
@ 2013-10-25 16:01 ` Huajun Li
[not found] ` <1382962607.992.104.camel@kjgkr>
2013-10-25 16:01 ` [f2fs-dev 4/5] f2fs: Key functions to handle inline data Huajun Li
2013-10-25 16:01 ` [f2fs-dev 5/5] f2fs: Handle inline data operations Huajun Li
4 siblings, 1 reply; 16+ messages in thread
From: Huajun Li @ 2013-10-25 16:01 UTC (permalink / raw)
To: jaegeuk.kim, linux-f2fs-devel
Cc: linux-fsdevel, linux-kernel, Huajun Li, Haicheng Li, Weihong Xu
From: Huajun Li <huajun.li@intel.com>
Add the function f2fs_reserve_block() to easily reserve new blocks.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
---
fs/f2fs/data.c | 29 ++++++++++++++++++-----------
fs/f2fs/f2fs.h | 1 +
2 files changed, 19 insertions(+), 11 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index c8887d8..7b31911 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -64,6 +64,23 @@ int reserve_new_block(struct dnode_of_data *dn)
return 0;
}
+int f2fs_reserve_block(struct inode *inode,
+ struct dnode_of_data *dn, pgoff_t index)
+{
+ int err;
+
+ set_new_dnode(dn, inode, NULL, NULL, 0);
+ err = get_dnode_of_data(dn, index, ALLOC_NODE);
+ if (err)
+ return err;
+ if (dn->data_blkaddr == NULL_ADDR)
+ err = reserve_new_block(dn);
+
+ f2fs_put_dnode(dn);
+
+ return err;
+}
+
static int check_extent_cache(struct inode *inode, pgoff_t pgofs,
struct buffer_head *bh_result)
{
@@ -644,19 +661,9 @@ repeat:
*pagep = page;
f2fs_lock_op(sbi);
-
- set_new_dnode(&dn, inode, NULL, NULL, 0);
- err = get_dnode_of_data(&dn, index, ALLOC_NODE);
- if (err)
- goto err;
-
- if (dn.data_blkaddr == NULL_ADDR)
- err = reserve_new_block(&dn);
-
- f2fs_put_dnode(&dn);
+ err = f2fs_reserve_block(inode, &dn, index);
if (err)
goto err;
-
f2fs_unlock_op(sbi);
if ((len == PAGE_CACHE_SIZE) || PageUptodate(page))
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index e50a8b0..4f34330 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1112,6 +1112,7 @@ void destroy_checkpoint_caches(void);
* data.c
*/
int reserve_new_block(struct dnode_of_data *);
+int f2fs_reserve_block(struct inode *, struct dnode_of_data *, pgoff_t);
void update_extent_cache(block_t, struct dnode_of_data *);
struct page *find_data_page(struct inode *, pgoff_t, bool);
struct page *get_lock_data_page(struct inode *, pgoff_t);
--
1.7.9.5
^ permalink raw reply related [flat|nested] 16+ messages in thread* [f2fs-dev 4/5] f2fs: Key functions to handle inline data
2013-10-25 16:01 [f2fs-dev 0/5] f2fs: Enable f2fs support inline data Huajun Li
` (2 preceding siblings ...)
2013-10-25 16:01 ` [f2fs-dev 3/5] f2fs: Add a new function: f2fs_reserve_block() Huajun Li
@ 2013-10-25 16:01 ` Huajun Li
2013-10-28 12:43 ` Jaegeuk Kim
2013-10-25 16:01 ` [f2fs-dev 5/5] f2fs: Handle inline data operations Huajun Li
4 siblings, 1 reply; 16+ messages in thread
From: Huajun Li @ 2013-10-25 16:01 UTC (permalink / raw)
To: jaegeuk.kim, linux-f2fs-devel
Cc: linux-fsdevel, linux-kernel, Huajun Li, Haicheng Li, Weihong Xu
From: Huajun Li <huajun.li@intel.com>
Functions to implement inline data read/write, and move inline data to
normal data block when file size exceeds inline data limitation.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
---
fs/f2fs/Makefile | 2 +-
fs/f2fs/f2fs.h | 7 +++
fs/f2fs/inline.c | 144 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 152 insertions(+), 1 deletion(-)
create mode 100644 fs/f2fs/inline.c
diff --git a/fs/f2fs/Makefile b/fs/f2fs/Makefile
index 27a0820..2e35da1 100644
--- a/fs/f2fs/Makefile
+++ b/fs/f2fs/Makefile
@@ -1,6 +1,6 @@
obj-$(CONFIG_F2FS_FS) += f2fs.o
-f2fs-y := dir.o file.o inode.o namei.o hash.o super.o
+f2fs-y := dir.o file.o inode.o namei.o hash.o super.o inline.o
f2fs-y += checkpoint.o gc.o data.o node.o segment.o recovery.o
f2fs-$(CONFIG_F2FS_STAT_FS) += debug.o
f2fs-$(CONFIG_F2FS_FS_XATTR) += xattr.o
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 4f34330..904ae3d 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1246,4 +1246,11 @@ extern const struct inode_operations f2fs_dir_inode_operations;
extern const struct inode_operations f2fs_symlink_inode_operations;
extern const struct inode_operations f2fs_special_inode_operations;
+/*
+ * inline.c
+ */
+inline int f2fs_has_inline_data(struct inode *);
+int f2fs_read_inline_data(struct inode *, struct page *);
+int f2fs_convert_inline_data(struct inode *, struct page *, unsigned);
+int f2fs_write_inline_data(struct inode *, struct page *, unsigned int);
#endif
diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
new file mode 100644
index 0000000..ec0d00c
--- /dev/null
+++ b/fs/f2fs/inline.c
@@ -0,0 +1,144 @@
+/*
+ * fs/f2fs/inline.c
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/fs.h>
+#include <linux/f2fs_fs.h>
+
+#include "f2fs.h"
+
+inline int f2fs_has_inline_data(struct inode *inode)
+{
+ return is_inode_flag_set(F2FS_I(inode), FI_INLINE_DATA);
+}
+
+int f2fs_read_inline_data(struct inode *inode, struct page *page)
+{
+ struct page *ipage;
+ void *src_addr, *dst_addr;
+
+ BUG_ON(page->index);
+ ipage = get_node_page(F2FS_SB(inode->i_sb), inode->i_ino);
+ if (IS_ERR(ipage))
+ return PTR_ERR(ipage);
+
+ src_addr = inline_data_addr(ipage);
+ dst_addr = page_address(page);
+
+ zero_user_segment(page, INLINE_DATA_OFFSET,
+ INLINE_DATA_OFFSET + MAX_INLINE_DATA);
+ /* Copy the whole inline data block */
+ memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
+ f2fs_put_page(ipage, 1);
+
+ SetPageUptodate(page);
+ unlock_page(page);
+
+ return 0;
+}
+
+static int __f2fs_convert_inline_data(struct inode *inode, struct page *page)
+{
+ int err;
+ struct page *ipage;
+ struct dnode_of_data dn;
+ void *src_addr, *dst_addr;
+ struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+
+ ipage = get_node_page(sbi, inode->i_ino);
+ if (IS_ERR(ipage))
+ return PTR_ERR(ipage);
+
+ f2fs_lock_op(sbi);
+ /* i_addr[0] is not used for inline data,
+ * so reserving new block will not destroy inline data */
+ err = f2fs_reserve_block(inode, &dn, 0);
+ if (err) {
+ f2fs_put_page(ipage, 1);
+ f2fs_unlock_op(sbi);
+ return err;
+ }
+ f2fs_unlock_op(sbi);
+
+ src_addr = inline_data_addr(ipage);
+ dst_addr = page_address(page);
+ zero_user_segment(page, 0, PAGE_CACHE_SIZE);
+ /* Copy the whole inline data block */
+ memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
+ zero_user_segment(ipage, INLINE_DATA_OFFSET,
+ INLINE_DATA_OFFSET + MAX_INLINE_DATA);
+ clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
+ set_raw_inline(F2FS_I(inode),
+ (struct f2fs_inode *)page_address(ipage));
+
+ set_page_dirty(ipage);
+ f2fs_put_page(ipage, 1);
+ set_page_dirty(page);
+
+ return 0;
+}
+
+int f2fs_convert_inline_data(struct inode *inode,
+ struct page *p, unsigned flags)
+{
+ int err;
+ struct page *page;
+
+ if (p && !p->index) {
+ page = p;
+ } else {
+ page = grab_cache_page_write_begin(inode->i_mapping, 0, flags);
+ if (IS_ERR(page))
+ return PTR_ERR(page);
+ }
+
+ err = __f2fs_convert_inline_data(inode, page);
+
+ if (p && !p->index)
+ f2fs_put_page(page, 1);
+
+ return err;
+}
+
+int f2fs_write_inline_data(struct inode *inode,
+ struct page *page, unsigned size)
+{
+ void *src_addr, *dst_addr;
+ struct page *ipage;
+ struct dnode_of_data dn;
+ int err;
+
+ set_new_dnode(&dn, inode, NULL, NULL, 0);
+ err = get_dnode_of_data(&dn, 0, LOOKUP_NODE);
+ if (err)
+ return err;
+ ipage = dn.inode_page;
+
+ src_addr = page_address(page);
+ dst_addr = inline_data_addr(ipage);
+
+ zero_user_segment(ipage, INLINE_DATA_OFFSET,
+ INLINE_DATA_OFFSET + MAX_INLINE_DATA);
+ memcpy(dst_addr, src_addr, size);
+ if (!f2fs_has_inline_data(inode))
+ set_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
+ set_raw_inline(F2FS_I(inode),
+ (struct f2fs_inode *)page_address(ipage));
+ set_page_dirty(ipage);
+
+ if ((F2FS_I(inode)->i_xattr_nid && inode->i_blocks == 2) ||
+ (!F2FS_I(inode)->i_xattr_nid && inode->i_blocks == 1)) {
+ f2fs_put_dnode(&dn);
+ return 0;
+ }
+
+ /* Release the first data block if it is allocated */
+ truncate_data_blocks_range(&dn, 1);
+ f2fs_put_dnode(&dn);
+
+ return 0;
+}
--
1.7.9.5
^ permalink raw reply related [flat|nested] 16+ messages in thread* Re: [f2fs-dev 4/5] f2fs: Key functions to handle inline data
2013-10-25 16:01 ` [f2fs-dev 4/5] f2fs: Key functions to handle inline data Huajun Li
@ 2013-10-28 12:43 ` Jaegeuk Kim
2013-10-28 17:20 ` Huajun Li
0 siblings, 1 reply; 16+ messages in thread
From: Jaegeuk Kim @ 2013-10-28 12:43 UTC (permalink / raw)
To: Huajun Li
Cc: linux-f2fs-devel, linux-fsdevel, linux-kernel, Huajun Li,
Haicheng Li, Weihong Xu
Hi,
2013-10-26 (토), 00:01 +0800, Huajun Li:
> From: Huajun Li <huajun.li@intel.com>
>
> Functions to implement inline data read/write, and move inline data to
> normal data block when file size exceeds inline data limitation.
>
> Signed-off-by: Huajun Li <huajun.li@intel.com>
> Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
> Signed-off-by: Weihong Xu <weihong.xu@intel.com>
> ---
> fs/f2fs/Makefile | 2 +-
> fs/f2fs/f2fs.h | 7 +++
> fs/f2fs/inline.c | 144 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 3 files changed, 152 insertions(+), 1 deletion(-)
> create mode 100644 fs/f2fs/inline.c
>
[snip]
> +static int __f2fs_convert_inline_data(struct inode *inode, struct page *page)
> +{
> + int err;
> + struct page *ipage;
> + struct dnode_of_data dn;
> + void *src_addr, *dst_addr;
> + struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
> +
Here.. f2fs_lock_op(sbi);
> + ipage = get_node_page(sbi, inode->i_ino);
> + if (IS_ERR(ipage))
> + return PTR_ERR(ipage);
> +
Need to move f2fs_lock_op prior to get_node_page.
> + /* i_addr[0] is not used for inline data,
Coding style.
/*
* ...
*/
> + * so reserving new block will not destroy inline data */
> + err = f2fs_reserve_block(inode, &dn, 0);
> + if (err) {
> + f2fs_put_page(ipage, 1);
> + f2fs_unlock_op(sbi);
> + return err;
> + }
Need to move this too.
> +
> + src_addr = inline_data_addr(ipage);
> + dst_addr = page_address(page);
> + zero_user_segment(page, 0, PAGE_CACHE_SIZE);
+ space for readability.
> + /* Copy the whole inline data block */
> + memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
> + zero_user_segment(ipage, INLINE_DATA_OFFSET,
> + INLINE_DATA_OFFSET + MAX_INLINE_DATA);
> + clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
> + set_raw_inline(F2FS_I(inode),
> + (struct f2fs_inode *)page_address(ipage));
--> sync_inode_page()?
> +
> + set_page_dirty(ipage);
> + f2fs_put_page(ipage, 1);
> + set_page_dirty(page);
Here... f2fs_unlock_op(sbi);
Here, we need to consider data consistency.
Let's think about the below scenario.
1. inline_data was written.
2. sync_fs is done.
3. additional data were written.
: this triggers f2fs_convert_inline_data(), produces a page, and then
unsets the inline flag.
4. checkpoint was done with updated inode page. Note that, checkpoint
doesn't guarantee any user data.
5. sudden power-off is occurred.
-> Once power-off-recovery is done, we loose the inline_data which was
written successfully at step #2.
So, I think we need to do f2fs_sync_file() procedure at this moment.
Any idea?
> +
> + return 0;
> +}
> +
> +int f2fs_convert_inline_data(struct inode *inode,
> + struct page *p, unsigned flags)
> +{
> + int err;
> + struct page *page;
> +
> + if (p && !p->index) {
> + page = p;
> + } else {
> + page = grab_cache_page_write_begin(inode->i_mapping, 0, flags);
> + if (IS_ERR(page))
> + return PTR_ERR(page);
> + }
> +
> + err = __f2fs_convert_inline_data(inode, page);
> +
> + if (p && !p->index)
> + f2fs_put_page(page, 1);
> +
> + return err;
> +}
> +
> +int f2fs_write_inline_data(struct inode *inode,
> + struct page *page, unsigned size)
> +{
> + void *src_addr, *dst_addr;
> + struct page *ipage;
> + struct dnode_of_data dn;
> + int err;
> +
> + set_new_dnode(&dn, inode, NULL, NULL, 0);
> + err = get_dnode_of_data(&dn, 0, LOOKUP_NODE);
> + if (err)
> + return err;
> + ipage = dn.inode_page;
> +
> + src_addr = page_address(page);
> + dst_addr = inline_data_addr(ipage);
> +
> + zero_user_segment(ipage, INLINE_DATA_OFFSET,
> + INLINE_DATA_OFFSET + MAX_INLINE_DATA);
> + memcpy(dst_addr, src_addr, size);
> + if (!f2fs_has_inline_data(inode))
> + set_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
> + set_raw_inline(F2FS_I(inode),
> + (struct f2fs_inode *)page_address(ipage));
> + set_page_dirty(ipage);
> +
> + if ((F2FS_I(inode)->i_xattr_nid && inode->i_blocks == 2) ||
> + (!F2FS_I(inode)->i_xattr_nid && inode->i_blocks == 1)) {
> + f2fs_put_dnode(&dn);
> + return 0;
> + }
> +
> + /* Release the first data block if it is allocated */
> + truncate_data_blocks_range(&dn, 1);
> + f2fs_put_dnode(&dn);
> +
> + return 0;
> +}
--
Jaegeuk Kim
Samsung
^ permalink raw reply [flat|nested] 16+ messages in thread* Re: [f2fs-dev 4/5] f2fs: Key functions to handle inline data
2013-10-28 12:43 ` Jaegeuk Kim
@ 2013-10-28 17:20 ` Huajun Li
2013-10-29 1:06 ` Jaegeuk Kim
0 siblings, 1 reply; 16+ messages in thread
From: Huajun Li @ 2013-10-28 17:20 UTC (permalink / raw)
To: jaegeuk.kim
Cc: Huajun Li, Weihong Xu, linux-kernel, linux-f2fs-devel,
linux-fsdevel
On Mon, Oct 28, 2013 at 8:43 PM, Jaegeuk Kim <jaegeuk.kim@samsung.com> wrote:
> Hi,
>
> 2013-10-26 (토), 00:01 +0800, Huajun Li:
>> From: Huajun Li <huajun.li@intel.com>
>>
>> Functions to implement inline data read/write, and move inline data to
>> normal data block when file size exceeds inline data limitation.
>>
>> Signed-off-by: Huajun Li <huajun.li@intel.com>
>> Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
>> Signed-off-by: Weihong Xu <weihong.xu@intel.com>
>> ---
>> fs/f2fs/Makefile | 2 +-
>> fs/f2fs/f2fs.h | 7 +++
>> fs/f2fs/inline.c | 144 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
>> 3 files changed, 152 insertions(+), 1 deletion(-)
>> create mode 100644 fs/f2fs/inline.c
>>
>
> [snip]
>
>> +static int __f2fs_convert_inline_data(struct inode *inode, struct page *page)
>> +{
>> + int err;
>> + struct page *ipage;
>> + struct dnode_of_data dn;
>> + void *src_addr, *dst_addr;
>> + struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
>> +
>
> Here.. f2fs_lock_op(sbi);
>
>> + ipage = get_node_page(sbi, inode->i_ino);
>> + if (IS_ERR(ipage))
>> + return PTR_ERR(ipage);
>> +
>
> Need to move f2fs_lock_op prior to get_node_page.
>
>> + /* i_addr[0] is not used for inline data,
>
> Coding style.
> /*
> * ...
> */
>
>> + * so reserving new block will not destroy inline data */
>> + err = f2fs_reserve_block(inode, &dn, 0);
>> + if (err) {
>> + f2fs_put_page(ipage, 1);
>> + f2fs_unlock_op(sbi);
>> + return err;
>> + }
>
> Need to move this too.
>
>> +
>> + src_addr = inline_data_addr(ipage);
>> + dst_addr = page_address(page);
>> + zero_user_segment(page, 0, PAGE_CACHE_SIZE);
>
> + space for readability.
>
>> + /* Copy the whole inline data block */
>> + memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
>> + zero_user_segment(ipage, INLINE_DATA_OFFSET,
>> + INLINE_DATA_OFFSET + MAX_INLINE_DATA);
>> + clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
>> + set_raw_inline(F2FS_I(inode),
>> + (struct f2fs_inode *)page_address(ipage));
Thanks for your comments, I will update them according to above comments.
>
> --> sync_inode_page()?
>
IMO, we just handle file data, so do we still need call sync_inode_page() ?
>> +
>> + set_page_dirty(ipage);
>> + f2fs_put_page(ipage, 1);
>> + set_page_dirty(page);
>
> Here... f2fs_unlock_op(sbi);
>
> Here, we need to consider data consistency.
> Let's think about the below scenario.
> 1. inline_data was written.
> 2. sync_fs is done.
> 3. additional data were written.
> : this triggers f2fs_convert_inline_data(), produces a page, and then
> unsets the inline flag.
> 4. checkpoint was done with updated inode page. Note that, checkpoint
> doesn't guarantee any user data.
> 5. sudden power-off is occurred.
> -> Once power-off-recovery is done, we loose the inline_data which was
> written successfully at step #2.
>
> So, I think we need to do f2fs_sync_file() procedure at this moment.
> Any idea?
>
Yes, need consider this case carefully, thanks for your reminder.
Considering sudden power-off may happen before f2fs_sync_file() is
called, so how about following solutions:
...
/* Copy the whole inline data block */
memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
do f2fs_sync_file() procedure ( Or do write_data_page() procedure ? )
zero_user_segment(ipage, INLINE_DATA_OFFSET, INLINE_DATA_OFFSET +
MAX_INLINE_DATA);
clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
set_raw_inline(F2FS_I(inode), (struct f2fs_inode *)page_address(ipage));
...
>> +
>> + return 0;
>> +}
>> +
>> +int f2fs_convert_inline_data(struct inode *inode,
>> + struct page *p, unsigned flags)
>> +{
>> + int err;
>> + struct page *page;
>> +
>> + if (p && !p->index) {
>> + page = p;
>> + } else {
>> + page = grab_cache_page_write_begin(inode->i_mapping, 0, flags);
>> + if (IS_ERR(page))
>> + return PTR_ERR(page);
>> + }
>> +
>> + err = __f2fs_convert_inline_data(inode, page);
>> +
>> + if (p && !p->index)
>> + f2fs_put_page(page, 1);
>> +
>> + return err;
>> +}
>> +
>> +int f2fs_write_inline_data(struct inode *inode,
>> + struct page *page, unsigned size)
>> +{
>> + void *src_addr, *dst_addr;
>> + struct page *ipage;
>> + struct dnode_of_data dn;
>> + int err;
>> +
>> + set_new_dnode(&dn, inode, NULL, NULL, 0);
>> + err = get_dnode_of_data(&dn, 0, LOOKUP_NODE);
>> + if (err)
>> + return err;
>> + ipage = dn.inode_page;
>> +
>> + src_addr = page_address(page);
>> + dst_addr = inline_data_addr(ipage);
>> +
>> + zero_user_segment(ipage, INLINE_DATA_OFFSET,
>> + INLINE_DATA_OFFSET + MAX_INLINE_DATA);
>> + memcpy(dst_addr, src_addr, size);
>> + if (!f2fs_has_inline_data(inode))
>> + set_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
>> + set_raw_inline(F2FS_I(inode),
>> + (struct f2fs_inode *)page_address(ipage));
>> + set_page_dirty(ipage);
>> +
>> + if ((F2FS_I(inode)->i_xattr_nid && inode->i_blocks == 2) ||
>> + (!F2FS_I(inode)->i_xattr_nid && inode->i_blocks == 1)) {
>> + f2fs_put_dnode(&dn);
>> + return 0;
>> + }
>> +
>> + /* Release the first data block if it is allocated */
>> + truncate_data_blocks_range(&dn, 1);
>> + f2fs_put_dnode(&dn);
>> +
>> + return 0;
>> +}
>
> --
> Jaegeuk Kim
> Samsung
>
------------------------------------------------------------------------------
October Webinars: Code for Performance
Free Intel webinars can help you accelerate application performance.
Explore tips for MPI, OpenMP, advanced profiling, and more. Get the most from
the latest Intel processors and coprocessors. See abstracts and register >
http://pubads.g.doubleclick.net/gampad/clk?id=60135991&iu=/4140/ostg.clktrk
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 16+ messages in thread* Re: [f2fs-dev 4/5] f2fs: Key functions to handle inline data
2013-10-28 17:20 ` Huajun Li
@ 2013-10-29 1:06 ` Jaegeuk Kim
2013-10-29 15:33 ` Huajun Li
0 siblings, 1 reply; 16+ messages in thread
From: Jaegeuk Kim @ 2013-10-29 1:06 UTC (permalink / raw)
To: Huajun Li
Cc: Huajun Li, Weihong Xu, linux-kernel, linux-f2fs-devel,
linux-fsdevel
Hi,
2013-10-29 (화), 01:20 +0800, Huajun Li:
> On Mon, Oct 28, 2013 at 8:43 PM, Jaegeuk Kim <jaegeuk.kim@samsung.com> wrote:
> > Hi,
> >
> > 2013-10-26 (토), 00:01 +0800, Huajun Li:
> >> From: Huajun Li <huajun.li@intel.com>
> >>
> >> Functions to implement inline data read/write, and move inline data to
> >> normal data block when file size exceeds inline data limitation.
> >>
> >> Signed-off-by: Huajun Li <huajun.li@intel.com>
> >> Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
> >> Signed-off-by: Weihong Xu <weihong.xu@intel.com>
> >> ---
> >> fs/f2fs/Makefile | 2 +-
> >> fs/f2fs/f2fs.h | 7 +++
> >> fs/f2fs/inline.c | 144 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
> >> 3 files changed, 152 insertions(+), 1 deletion(-)
> >> create mode 100644 fs/f2fs/inline.c
> >>
> >
> > [snip]
> >
> >> +static int __f2fs_convert_inline_data(struct inode *inode, struct page *page)
> >> +{
> >> + int err;
> >> + struct page *ipage;
> >> + struct dnode_of_data dn;
> >> + void *src_addr, *dst_addr;
> >> + struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
> >> +
> >
> > Here.. f2fs_lock_op(sbi);
> >
> >> + ipage = get_node_page(sbi, inode->i_ino);
> >> + if (IS_ERR(ipage))
> >> + return PTR_ERR(ipage);
> >> +
> >
> > Need to move f2fs_lock_op prior to get_node_page.
> >
> >> + /* i_addr[0] is not used for inline data,
> >
> > Coding style.
> > /*
> > * ...
> > */
> >
> >> + * so reserving new block will not destroy inline data */
> >> + err = f2fs_reserve_block(inode, &dn, 0);
> >> + if (err) {
> >> + f2fs_put_page(ipage, 1);
> >> + f2fs_unlock_op(sbi);
> >> + return err;
> >> + }
> >
> > Need to move this too.
> >
> >> +
> >> + src_addr = inline_data_addr(ipage);
> >> + dst_addr = page_address(page);
> >> + zero_user_segment(page, 0, PAGE_CACHE_SIZE);
> >
> > + space for readability.
> >
> >> + /* Copy the whole inline data block */
> >> + memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
> >> + zero_user_segment(ipage, INLINE_DATA_OFFSET,
> >> + INLINE_DATA_OFFSET + MAX_INLINE_DATA);
> >> + clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
> >> + set_raw_inline(F2FS_I(inode),
> >> + (struct f2fs_inode *)page_address(ipage));
>
> Thanks for your comments, I will update them according to above comments.
>
> >
> > --> sync_inode_page()?
> >
> IMO, we just handle file data, so do we still need call sync_inode_page() ?
I think sync_inode_page() is more suitable, since we need to sync
between i_size, i_blocks and its i_flag, inline_data, at this moment.
>
> >> +
> >> + set_page_dirty(ipage);
Need to consider skipping set_page_dirty(ipage).
> >> + f2fs_put_page(ipage, 1);
> >> + set_page_dirty(page);
> >
> > Here... f2fs_unlock_op(sbi);
> >
> > Here, we need to consider data consistency.
> > Let's think about the below scenario.
> > 1. inline_data was written.
> > 2. sync_fs is done.
> > 3. additional data were written.
> > : this triggers f2fs_convert_inline_data(), produces a page, and then
> > unsets the inline flag.
> > 4. checkpoint was done with updated inode page. Note that, checkpoint
> > doesn't guarantee any user data.
> > 5. sudden power-off is occurred.
> > -> Once power-off-recovery is done, we loose the inline_data which was
> > written successfully at step #2.
> >
> > So, I think we need to do f2fs_sync_file() procedure at this moment.
> > Any idea?
> >
>
> Yes, need consider this case carefully, thanks for your reminder.
>
> Considering sudden power-off may happen before f2fs_sync_file() is
> called, so how about following solutions:
> ...
> /* Copy the whole inline data block */
> memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
>
> do f2fs_sync_file() procedure ( Or do write_data_page() procedure ? )
Ya, but it may still have some conditions to do this or not.
One of them is checking whether previous inline data should be recovered
or not, for example.
>
> zero_user_segment(ipage, INLINE_DATA_OFFSET, INLINE_DATA_OFFSET +
> MAX_INLINE_DATA);
> clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
> set_raw_inline(F2FS_I(inode), (struct f2fs_inode *)page_address(ipage));
> ...
>
> >> +
> >> + return 0;
> >> +}
> >> +
> >> +int f2fs_convert_inline_data(struct inode *inode,
> >> + struct page *p, unsigned flags)
> >> +{
> >> + int err;
> >> + struct page *page;
> >> +
> >> + if (p && !p->index) {
> >> + page = p;
> >> + } else {
> >> + page = grab_cache_page_write_begin(inode->i_mapping, 0, flags);
> >> + if (IS_ERR(page))
> >> + return PTR_ERR(page);
> >> + }
> >> +
> >> + err = __f2fs_convert_inline_data(inode, page);
> >> +
> >> + if (p && !p->index)
> >> + f2fs_put_page(page, 1);
> >> +
> >> + return err;
> >> +}
> >> +
> >> +int f2fs_write_inline_data(struct inode *inode,
> >> + struct page *page, unsigned size)
> >> +{
> >> + void *src_addr, *dst_addr;
> >> + struct page *ipage;
> >> + struct dnode_of_data dn;
> >> + int err;
> >> +
> >> + set_new_dnode(&dn, inode, NULL, NULL, 0);
> >> + err = get_dnode_of_data(&dn, 0, LOOKUP_NODE);
> >> + if (err)
> >> + return err;
> >> + ipage = dn.inode_page;
> >> +
> >> + src_addr = page_address(page);
> >> + dst_addr = inline_data_addr(ipage);
> >> +
> >> + zero_user_segment(ipage, INLINE_DATA_OFFSET,
> >> + INLINE_DATA_OFFSET + MAX_INLINE_DATA);
> >> + memcpy(dst_addr, src_addr, size);
> >> + if (!f2fs_has_inline_data(inode))
> >> + set_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
> >> + set_raw_inline(F2FS_I(inode),
> >> + (struct f2fs_inode *)page_address(ipage));
> >> + set_page_dirty(ipage);
> >> +
> >> + if ((F2FS_I(inode)->i_xattr_nid && inode->i_blocks == 2) ||
> >> + (!F2FS_I(inode)->i_xattr_nid && inode->i_blocks == 1)) {
> >> + f2fs_put_dnode(&dn);
> >> + return 0;
> >> + }
> >> +
> >> + /* Release the first data block if it is allocated */
> >> + truncate_data_blocks_range(&dn, 1);
> >> + f2fs_put_dnode(&dn);
> >> +
> >> + return 0;
> >> +}
> >
> > --
> > Jaegeuk Kim
> > Samsung
> >
> --
> To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
--
Jaegeuk Kim
Samsung
------------------------------------------------------------------------------
Android is increasing in popularity, but the open development platform that
developers love is also attractive to malware creators. Download this white
paper to learn more about secure code signing practices that can help keep
Android apps secure.
http://pubads.g.doubleclick.net/gampad/clk?id=65839951&iu=/4140/ostg.clktrk
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 16+ messages in thread* Re: [f2fs-dev 4/5] f2fs: Key functions to handle inline data
2013-10-29 1:06 ` Jaegeuk Kim
@ 2013-10-29 15:33 ` Huajun Li
0 siblings, 0 replies; 16+ messages in thread
From: Huajun Li @ 2013-10-29 15:33 UTC (permalink / raw)
To: jaegeuk.kim
Cc: Huajun Li, Weihong Xu, linux-kernel, linux-f2fs-devel,
linux-fsdevel
Yes, will think over these cases carefully, and send out new version. thanks.
On Tue, Oct 29, 2013 at 9:06 AM, Jaegeuk Kim <jaegeuk.kim@samsung.com> wrote:
> Hi,
>
> 2013-10-29 (화), 01:20 +0800, Huajun Li:
>> On Mon, Oct 28, 2013 at 8:43 PM, Jaegeuk Kim <jaegeuk.kim@samsung.com> wrote:
>> > Hi,
>> >
>> > 2013-10-26 (토), 00:01 +0800, Huajun Li:
>> >> From: Huajun Li <huajun.li@intel.com>
>> >>
>> >> Functions to implement inline data read/write, and move inline data to
>> >> normal data block when file size exceeds inline data limitation.
>> >>
>> >> Signed-off-by: Huajun Li <huajun.li@intel.com>
>> >> Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
>> >> Signed-off-by: Weihong Xu <weihong.xu@intel.com>
>> >> ---
>> >> fs/f2fs/Makefile | 2 +-
>> >> fs/f2fs/f2fs.h | 7 +++
>> >> fs/f2fs/inline.c | 144 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
>> >> 3 files changed, 152 insertions(+), 1 deletion(-)
>> >> create mode 100644 fs/f2fs/inline.c
>> >>
>> >
>> > [snip]
>> >
>> >> +static int __f2fs_convert_inline_data(struct inode *inode, struct page *page)
>> >> +{
>> >> + int err;
>> >> + struct page *ipage;
>> >> + struct dnode_of_data dn;
>> >> + void *src_addr, *dst_addr;
>> >> + struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
>> >> +
>> >
>> > Here.. f2fs_lock_op(sbi);
>> >
>> >> + ipage = get_node_page(sbi, inode->i_ino);
>> >> + if (IS_ERR(ipage))
>> >> + return PTR_ERR(ipage);
>> >> +
>> >
>> > Need to move f2fs_lock_op prior to get_node_page.
>> >
>> >> + /* i_addr[0] is not used for inline data,
>> >
>> > Coding style.
>> > /*
>> > * ...
>> > */
>> >
>> >> + * so reserving new block will not destroy inline data */
>> >> + err = f2fs_reserve_block(inode, &dn, 0);
>> >> + if (err) {
>> >> + f2fs_put_page(ipage, 1);
>> >> + f2fs_unlock_op(sbi);
>> >> + return err;
>> >> + }
>> >
>> > Need to move this too.
>> >
>> >> +
>> >> + src_addr = inline_data_addr(ipage);
>> >> + dst_addr = page_address(page);
>> >> + zero_user_segment(page, 0, PAGE_CACHE_SIZE);
>> >
>> > + space for readability.
>> >
>> >> + /* Copy the whole inline data block */
>> >> + memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
>> >> + zero_user_segment(ipage, INLINE_DATA_OFFSET,
>> >> + INLINE_DATA_OFFSET + MAX_INLINE_DATA);
>> >> + clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
>> >> + set_raw_inline(F2FS_I(inode),
>> >> + (struct f2fs_inode *)page_address(ipage));
>>
>> Thanks for your comments, I will update them according to above comments.
>>
>> >
>> > --> sync_inode_page()?
>> >
>> IMO, we just handle file data, so do we still need call sync_inode_page() ?
>
> I think sync_inode_page() is more suitable, since we need to sync
> between i_size, i_blocks and its i_flag, inline_data, at this moment.
>
>>
>> >> +
>> >> + set_page_dirty(ipage);
>
> Need to consider skipping set_page_dirty(ipage).
>
>> >> + f2fs_put_page(ipage, 1);
>> >> + set_page_dirty(page);
>> >
>> > Here... f2fs_unlock_op(sbi);
>> >
>> > Here, we need to consider data consistency.
>> > Let's think about the below scenario.
>> > 1. inline_data was written.
>> > 2. sync_fs is done.
>> > 3. additional data were written.
>> > : this triggers f2fs_convert_inline_data(), produces a page, and then
>> > unsets the inline flag.
>> > 4. checkpoint was done with updated inode page. Note that, checkpoint
>> > doesn't guarantee any user data.
>> > 5. sudden power-off is occurred.
>> > -> Once power-off-recovery is done, we loose the inline_data which was
>> > written successfully at step #2.
>> >
>> > So, I think we need to do f2fs_sync_file() procedure at this moment.
>> > Any idea?
>> >
>>
>> Yes, need consider this case carefully, thanks for your reminder.
>>
>> Considering sudden power-off may happen before f2fs_sync_file() is
>> called, so how about following solutions:
>> ...
>> /* Copy the whole inline data block */
>> memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
>>
>> do f2fs_sync_file() procedure ( Or do write_data_page() procedure ? )
>
> Ya, but it may still have some conditions to do this or not.
> One of them is checking whether previous inline data should be recovered
> or not, for example.
>
>>
>> zero_user_segment(ipage, INLINE_DATA_OFFSET, INLINE_DATA_OFFSET +
>> MAX_INLINE_DATA);
>> clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
>> set_raw_inline(F2FS_I(inode), (struct f2fs_inode *)page_address(ipage));
>> ...
>>
>> >> +
>> >> + return 0;
>> >> +}
>> >> +
>> >> +int f2fs_convert_inline_data(struct inode *inode,
>> >> + struct page *p, unsigned flags)
>> >> +{
>> >> + int err;
>> >> + struct page *page;
>> >> +
>> >> + if (p && !p->index) {
>> >> + page = p;
>> >> + } else {
>> >> + page = grab_cache_page_write_begin(inode->i_mapping, 0, flags);
>> >> + if (IS_ERR(page))
>> >> + return PTR_ERR(page);
>> >> + }
>> >> +
>> >> + err = __f2fs_convert_inline_data(inode, page);
>> >> +
>> >> + if (p && !p->index)
>> >> + f2fs_put_page(page, 1);
>> >> +
>> >> + return err;
>> >> +}
>> >> +
>> >> +int f2fs_write_inline_data(struct inode *inode,
>> >> + struct page *page, unsigned size)
>> >> +{
>> >> + void *src_addr, *dst_addr;
>> >> + struct page *ipage;
>> >> + struct dnode_of_data dn;
>> >> + int err;
>> >> +
>> >> + set_new_dnode(&dn, inode, NULL, NULL, 0);
>> >> + err = get_dnode_of_data(&dn, 0, LOOKUP_NODE);
>> >> + if (err)
>> >> + return err;
>> >> + ipage = dn.inode_page;
>> >> +
>> >> + src_addr = page_address(page);
>> >> + dst_addr = inline_data_addr(ipage);
>> >> +
>> >> + zero_user_segment(ipage, INLINE_DATA_OFFSET,
>> >> + INLINE_DATA_OFFSET + MAX_INLINE_DATA);
>> >> + memcpy(dst_addr, src_addr, size);
>> >> + if (!f2fs_has_inline_data(inode))
>> >> + set_inode_flag(F2FS_I(inode), FI_INLINE_DATA);
>> >> + set_raw_inline(F2FS_I(inode),
>> >> + (struct f2fs_inode *)page_address(ipage));
>> >> + set_page_dirty(ipage);
>> >> +
>> >> + if ((F2FS_I(inode)->i_xattr_nid && inode->i_blocks == 2) ||
>> >> + (!F2FS_I(inode)->i_xattr_nid && inode->i_blocks == 1)) {
>> >> + f2fs_put_dnode(&dn);
>> >> + return 0;
>> >> + }
>> >> +
>> >> + /* Release the first data block if it is allocated */
>> >> + truncate_data_blocks_range(&dn, 1);
>> >> + f2fs_put_dnode(&dn);
>> >> +
>> >> + return 0;
>> >> +}
>> >
>> > --
>> > Jaegeuk Kim
>> > Samsung
>> >
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in
>> the body of a message to majordomo@vger.kernel.org
>> More majordomo info at http://vger.kernel.org/majordomo-info.html
>
> --
> Jaegeuk Kim
> Samsung
>
------------------------------------------------------------------------------
Android is increasing in popularity, but the open development platform that
developers love is also attractive to malware creators. Download this white
paper to learn more about secure code signing practices that can help keep
Android apps secure.
http://pubads.g.doubleclick.net/gampad/clk?id=65839951&iu=/4140/ostg.clktrk
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 16+ messages in thread
* [f2fs-dev 5/5] f2fs: Handle inline data operations
2013-10-25 16:01 [f2fs-dev 0/5] f2fs: Enable f2fs support inline data Huajun Li
` (3 preceding siblings ...)
2013-10-25 16:01 ` [f2fs-dev 4/5] f2fs: Key functions to handle inline data Huajun Li
@ 2013-10-25 16:01 ` Huajun Li
2013-10-28 12:44 ` Jaegeuk Kim
4 siblings, 1 reply; 16+ messages in thread
From: Huajun Li @ 2013-10-25 16:01 UTC (permalink / raw)
To: jaegeuk.kim, linux-f2fs-devel
Cc: linux-fsdevel, linux-kernel, Huajun Li, Haicheng Li, Weihong Xu
From: Huajun Li <huajun.li@intel.com>
Hook inline data read/write, truncate, fallocate, setattr, etc.
Files need meet following 2 requirement to inline:
1) file size is not greater than MAX_INLINE_DATA;
2) file doesn't pre-allocate data blocks by fallocate().
FI_INLINE_DATA will not be set while creating a new regular inode because
most of the files are bigger than ~3.4K. Set FI_INLINE_DATA only when
data is submitted to block layer, ranther than set it while creating a new
inode, this also avoids converting data from inline to normal data block
and vice versa.
While writting inline data to inode block, the first data block should be
released if the file has a block indexed by i_addr[0].
On the other hand, when a file operation is appied to a file with inline
data, we need to test if this file can remain inline by doing this
operation, otherwise it should be convert into normal file by reserving
a new data block, copying inline data to this new block and clear
FI_INLINE_DATA flag. Because reserve a new data block here will make use
of i_addr[0], if we save inline data in i_addr[0..822], then the first
4 bytes would be overwriten. This problem can be avoided simply by
not using i_addr[0] for inline data.
Signed-off-by: Huajun Li <huajun.li@intel.com>
Signed-off-by: Haicheng Li <haicheng.li@linux.intel.com>
Signed-off-by: Weihong Xu <weihong.xu@intel.com>
---
fs/f2fs/data.c | 48 ++++++++++++++++++++++++++++++++++++++++++++----
fs/f2fs/file.c | 42 +++++++++++++++++++++++++++++++++++++++---
2 files changed, 83 insertions(+), 7 deletions(-)
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 7b31911..73ef248 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -481,13 +481,28 @@ static int get_data_block_ro(struct inode *inode, sector_t iblock,
static int f2fs_read_data_page(struct file *file, struct page *page)
{
- return mpage_readpage(page, get_data_block_ro);
+ int ret;
+ struct inode *inode = file->f_mapping->host;
+
+ /* If the file has inline data, try to read it directlly */
+ if (f2fs_has_inline_data(inode))
+ ret = f2fs_read_inline_data(inode, page);
+ else
+ ret = mpage_readpage(page, get_data_block_ro);
+
+ return ret;
}
static int f2fs_read_data_pages(struct file *file,
struct address_space *mapping,
struct list_head *pages, unsigned nr_pages)
{
+ struct inode *inode = file->f_mapping->host;
+
+ /* If the file has inline data, skip readpages */
+ if (f2fs_has_inline_data(inode))
+ return 0;
+
return mpage_readpages(mapping, pages, nr_pages, get_data_block_ro);
}
@@ -538,7 +553,7 @@ static int f2fs_write_data_page(struct page *page,
loff_t i_size = i_size_read(inode);
const pgoff_t end_index = ((unsigned long long) i_size)
>> PAGE_CACHE_SHIFT;
- unsigned offset;
+ unsigned offset = 0;
bool need_balance_fs = false;
int err = 0;
@@ -572,7 +587,14 @@ write:
err = do_write_data_page(page);
} else {
f2fs_lock_op(sbi);
- err = do_write_data_page(page);
+ if (test_opt(sbi, INLINE_DATA) && (i_size <= MAX_INLINE_DATA)) {
+ err = f2fs_write_inline_data(inode, page, offset);
+ ClearPageDirty(page);
+ f2fs_unlock_op(sbi);
+ goto out;
+ } else {
+ err = do_write_data_page(page);
+ }
f2fs_unlock_op(sbi);
need_balance_fs = true;
}
@@ -660,12 +682,22 @@ repeat:
return -ENOMEM;
*pagep = page;
+ if ((pos + len) < MAX_INLINE_DATA) {
+ if (f2fs_has_inline_data(inode))
+ goto inline_data;
+ } else if (f2fs_has_inline_data(inode)) {
+ err = f2fs_convert_inline_data(inode, page, flags);
+ if (err)
+ return err;
+ }
+
f2fs_lock_op(sbi);
err = f2fs_reserve_block(inode, &dn, index);
if (err)
goto err;
f2fs_unlock_op(sbi);
+inline_data:
if ((len == PAGE_CACHE_SIZE) || PageUptodate(page))
return 0;
@@ -681,7 +713,11 @@ repeat:
if (dn.data_blkaddr == NEW_ADDR) {
zero_user_segment(page, 0, PAGE_CACHE_SIZE);
} else {
- err = f2fs_readpage(sbi, page, dn.data_blkaddr, READ_SYNC);
+ if (f2fs_has_inline_data(inode))
+ err = f2fs_read_inline_data(inode, page);
+ else
+ err = f2fs_readpage(sbi, page,
+ dn.data_blkaddr, READ_SYNC);
if (err)
return err;
lock_page(page);
@@ -735,6 +771,10 @@ static ssize_t f2fs_direct_IO(int rw, struct kiocb *iocb,
if (rw == WRITE)
return 0;
+ /* Let buffer I/O handle the inline data case. */
+ if (f2fs_has_inline_data(inode))
+ return 0;
+
/* Needs synchronization with the cleaner */
return blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,
get_data_block_ro);
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 2d4190a..b38118e 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -305,7 +305,8 @@ static int truncate_blocks(struct inode *inode, u64 from)
f2fs_put_dnode(&dn);
free_next:
- err = truncate_inode_blocks(inode, free_from);
+ if (!f2fs_has_inline_data(inode))
+ err = truncate_inode_blocks(inode, free_from);
f2fs_unlock_op(sbi);
/* lastly zero out the first data page */
@@ -381,8 +382,17 @@ 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);
+ if (err)
+ return err;
+ }
+
truncate_setsize(inode, attr->ia_size);
- f2fs_truncate(inode);
+ if (!f2fs_has_inline_data(inode))
+ f2fs_truncate(inode);
f2fs_balance_fs(F2FS_SB(inode->i_sb));
}
@@ -464,6 +474,26 @@ static int punch_hole(struct inode *inode, loff_t offset, loff_t len, int mode)
loff_t off_start, off_end;
int ret = 0;
+ if (f2fs_has_inline_data(inode)) {
+ struct page *page;
+ unsigned flags = AOP_FLAG_NOFS;
+ page = grab_cache_page_write_begin(inode->i_mapping, 0, flags);
+ if (IS_ERR(page))
+ return PTR_ERR(page);
+ if (offset + len > MAX_INLINE_DATA) {
+ ret = f2fs_convert_inline_data(inode, page, flags);
+ f2fs_put_page(page, 1);
+ if (ret)
+ return ret;
+ } else {
+ zero_user_segment(page, offset, offset + len);
+ SetPageUptodate(page);
+ set_page_dirty(page);
+ f2fs_put_page(page, 1);
+ goto out;
+ }
+ }
+
pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
@@ -497,7 +527,7 @@ static int punch_hole(struct inode *inode, loff_t offset, loff_t len, int mode)
f2fs_unlock_op(sbi);
}
}
-
+out:
if (!(mode & FALLOC_FL_KEEP_SIZE) &&
i_size_read(inode) <= (offset + len)) {
i_size_write(inode, offset);
@@ -520,6 +550,12 @@ static int expand_inode_data(struct inode *inode, loff_t offset,
if (ret)
return ret;
+ if (f2fs_has_inline_data(inode) && (offset + len > MAX_INLINE_DATA)) {
+ ret = f2fs_convert_inline_data(inode, NULL, AOP_FLAG_NOFS);
+ if (ret)
+ return ret;
+ }
+
pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
--
1.7.9.5
^ permalink raw reply related [flat|nested] 16+ messages in thread* Re: [f2fs-dev 5/5] f2fs: Handle inline data operations
2013-10-25 16:01 ` [f2fs-dev 5/5] f2fs: Handle inline data operations Huajun Li
@ 2013-10-28 12:44 ` Jaegeuk Kim
2013-10-28 16:56 ` Huajun Li
0 siblings, 1 reply; 16+ messages in thread
From: Jaegeuk Kim @ 2013-10-28 12:44 UTC (permalink / raw)
To: Huajun Li
Cc: linux-f2fs-devel, linux-fsdevel, linux-kernel, Huajun Li,
Haicheng Li, Weihong Xu
Hi,
2013-10-26 (토), 00:01 +0800, Huajun Li:
> From: Huajun Li <huajun.li@intel.com>
>
[snip]
>
> @@ -538,7 +553,7 @@ static int f2fs_write_data_page(struct page *page,
> loff_t i_size = i_size_read(inode);
> const pgoff_t end_index = ((unsigned long long) i_size)
> >> PAGE_CACHE_SHIFT;
> - unsigned offset;
> + unsigned offset = 0;
> bool need_balance_fs = false;
> int err = 0;
>
> @@ -572,7 +587,14 @@ write:
> err = do_write_data_page(page);
> } else {
> f2fs_lock_op(sbi);
> - err = do_write_data_page(page);
> + if (test_opt(sbi, INLINE_DATA) && (i_size <= MAX_INLINE_DATA)) {
> + err = f2fs_write_inline_data(inode, page, offset);
> + ClearPageDirty(page);
Don't need to call ClearPageDirty(page).
> + f2fs_unlock_op(sbi);
> + goto out;
> + } else {
> + err = do_write_data_page(page);
> + }
> f2fs_unlock_op(sbi);
> need_balance_fs = true;
>
--
Jaegeuk Kim
Samsung
^ permalink raw reply [flat|nested] 16+ messages in thread* Re: [f2fs-dev 5/5] f2fs: Handle inline data operations
2013-10-28 12:44 ` Jaegeuk Kim
@ 2013-10-28 16:56 ` Huajun Li
0 siblings, 0 replies; 16+ messages in thread
From: Huajun Li @ 2013-10-28 16:56 UTC (permalink / raw)
To: jaegeuk.kim
Cc: Huajun Li, Weihong Xu, linux-kernel, linux-f2fs-devel,
linux-fsdevel
On Mon, Oct 28, 2013 at 8:44 PM, Jaegeuk Kim <jaegeuk.kim@samsung.com> wrote:
> Hi,
>
> 2013-10-26 (토), 00:01 +0800, Huajun Li:
>> From: Huajun Li <huajun.li@intel.com>
>>
>
> [snip]
>
>>
>> @@ -538,7 +553,7 @@ static int f2fs_write_data_page(struct page *page,
>> loff_t i_size = i_size_read(inode);
>> const pgoff_t end_index = ((unsigned long long) i_size)
>> >> PAGE_CACHE_SHIFT;
>> - unsigned offset;
>> + unsigned offset = 0;
>> bool need_balance_fs = false;
>> int err = 0;
>>
>> @@ -572,7 +587,14 @@ write:
>> err = do_write_data_page(page);
>> } else {
>> f2fs_lock_op(sbi);
>> - err = do_write_data_page(page);
>> + if (test_opt(sbi, INLINE_DATA) && (i_size <= MAX_INLINE_DATA)) {
>> + err = f2fs_write_inline_data(inode, page, offset);
>> + ClearPageDirty(page);
>
> Don't need to call ClearPageDirty(page).
>
Yes. I will remove it in next version, thanks.
>> + f2fs_unlock_op(sbi);
>> + goto out;
>> + } else {
>> + err = do_write_data_page(page);
>> + }
>> f2fs_unlock_op(sbi);
>> need_balance_fs = true;
>>
> --
> Jaegeuk Kim
> Samsung
>
------------------------------------------------------------------------------
October Webinars: Code for Performance
Free Intel webinars can help you accelerate application performance.
Explore tips for MPI, OpenMP, advanced profiling, and more. Get the most from
the latest Intel processors and coprocessors. See abstracts and register >
http://pubads.g.doubleclick.net/gampad/clk?id=60135991&iu=/4140/ostg.clktrk
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
^ permalink raw reply [flat|nested] 16+ messages in thread