f2fs: add fast symlink support
Subsystems (2)
PATCH v3 1/1 f2fs: add fast symlink support
This patch introduces the improvement fast symlinks to allow storage of the target path within inode, thus symlinks with short target paths are more accessed quickly. It will fall back to using the original slow symlink if the target path exceeds the available inode space.
---
v2 -> v3:
* handle fast symlink in remove_inode_page
v1 -> v2:
* set max size of fast symlink according to inline_xattr flag
fs/f2fs/f2fs.h | 15 ++++++++++++++ fs/f2fs/file.c | 2 ++ fs/f2fs/inode.c | 9 +++++++-- fs/f2fs/namei.c | 53 +++++++++++++++++++++++++++++++++++++++++++++---- fs/f2fs/node.c | 5 +++-- include/linux/f2fs_fs.h | 2 ++ 6 files changed, 78 insertions(+), 8 deletions(-)
fs/f2fs/f2fs.h +15 -0
@@ -1226,6 +1226,7 @@ enum {FI_VOLATILE_FILE ,/* indicate volatile file */ FI_DROP_CACHE ,/* drop dirty page cache */ FI_DATA_EXIST ,/* indicate data exists */ + FI_FAST_SYMLINK, /* indicate fast symlink */ };static inline void set_inode_flag (struct f2fs_inode_info *fi,int flag)
@@ -1262,6 +1263,8 @@ static inline void get_inline_info(struct f2fs_inode_info *fi,set_inode_flag (fi,FI_INLINE_DENTRY );if (ri->i_inline &F2FS_DATA_EXIST )set_inode_flag (fi,FI_DATA_EXIST ); +if (ri->i_inline &F2FS_FAST_SYMLINK ) +set_inode_flag (fi,FI_FAST_SYMLINK ); } static inline void set_raw_inline(struct f2fs_inode_info *fi,
@@ -1277,6 +1280,8 @@ static inline void set_raw_inline(struct f2fs_inode_info *fi, ri->i_inline |=F2FS_INLINE_DENTRY ;if (is_inode_flag_set (fi,FI_DATA_EXIST )) ri->i_inline |=F2FS_DATA_EXIST ; +if (is_inode_flag_set (fi,FI_FAST_SYMLINK )) + ri->i_inline |=F2FS_FAST_SYMLINK ; }static inline int f2fs_has_inline_xattr (struct inode *inode)
@@ -1370,6 +1375,15 @@ static inline void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi) sbi->sb->s_flags |=MS_RDONLY ; } +/* +* Test whether an inode is a fast symlink. +*/ +static inline int f2fs_inode_is_fast_symlink (struct inode *inode) +{ +return (S_ISLNK (inode->i_mode) && +is_inode_flag_set (F2FS_I (inode),FI_FAST_SYMLINK )); +} +#define get_inode_mode (i) \ ((is_inode_flag_set(F2FS_I(i), FI_ACL_MODE)) ? \ (F2FS_I(i)->i_acl_mode) : ((i)->i_mode))
@@ -1746,6 +1760,7 @@ extern const struct address_space_operations f2fs_node_aops;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_fast_symlink_inode_operations;extern const struct inode_operations f2fs_special_inode_operations;extern struct kmem_cache *inode_entry_slab;
fs/f2fs/file.c +2 -0
@@ -546,6 +546,8 @@ void f2fs_truncate(struct inode *inode)if (!(S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) ||S_ISLNK (inode->i_mode)))return ; +if (f2fs_inode_is_fast_symlink (inode)) +return ;trace_f2fs_truncate (inode);
fs/f2fs/inode.c +7 -2
@@ -13,6 +13,7 @@#include <linux/buffer_head.h> #include <linux/writeback.h> #include <linux/bitops.h> +#include <linux/namei.h> #include "f2fs.h" #include "node.h"
@@ -188,8 +189,12 @@ make_now: inode->i_mapping->a_ops = &f2fs_dblock_aops;mapping_set_gfp_mask (inode->i_mapping,GFP_F2FS_HIGH_ZERO ); }else if (S_ISLNK (inode->i_mode)) { - inode->i_op = &f2fs_symlink_inode_operations; - inode->i_mapping->a_ops = &f2fs_dblock_aops; +if (f2fs_inode_is_fast_symlink (inode)) + inode->i_op = &f2fs_fast_symlink_inode_operations; +else { + inode->i_op = &f2fs_symlink_inode_operations; + inode->i_mapping->a_ops = &f2fs_dblock_aops; + } }else if (S_ISCHR (inode->i_mode) ||S_ISBLK (inode->i_mode) ||S_ISFIFO (inode->i_mode) ||S_ISSOCK (inode->i_mode)) { inode->i_op = &f2fs_special_inode_operations;
fs/f2fs/namei.c +49 -4
83 lines not on this page · raw message
fs/f2fs/node.c +3 -2
@@ -908,8 +908,9 @@ void remove_inode_page(struct inode *inode) }/* remove potential inline_data blocks */ -if (S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || -S_ISLNK (inode->i_mode)) +if ((S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || +S_ISLNK (inode->i_mode)) && + !f2fs_inode_is_fast_symlink (inode))truncate_data_blocks_range (&dn,1 );/* 0 is possible, after f2fs_new_inode() has failed */
include/linux/f2fs_fs.h +2 -0
@@ -178,9 +178,11 @@ struct f2fs_extent {#define F2FS_INLINE_DATA 0x02/* file inline data flag */ #define F2FS_INLINE_DENTRY 0x04/* file inline dentry flag */ #define F2FS_DATA_EXIST 0x08/* file inline data exist flag */ +#define F2FS_FAST_SYMLINK 0x10/* file fast symlink flag */ #define MAX_INLINE_DATA (sizeof(__le32) * (DEF_ADDRS_PER_INODE - \ F2FS_INLINE_XATTR_ADDRS - 1)) +#define MAX_FAST_SYMLINK_SIZE (MAX_INLINE_DATA + 1)struct f2fs_inode {__le16 i_mode;/* file mode */
Signature · 1 line
1.9.1
Hi Wanpeng, Jaegeuk,
Quoted 59 lines
-----Original Message-----
From: Wanpeng Li [mailto:[email protected]]
Sent: Friday, March 13, 2015 2:34 PM
To: Jaegeuk Kim
Cc: Changman Lee; Chao Yu; [email protected]; [email protected]; [email protected]; Wanpeng Li
Subject: [PATCH v3] f2fs: add fast symlink supportThis patch introduces the improvement fast symlinks to allow storage of the target path within inode, thus symlinks with short target paths are more accessed quickly. It will fall back to using the original slow symlink if the target path exceeds the available inode space.
Signed-off-by Wanpeng Li <[email protected]>---
v2 -> v3:
* handle fast symlink inremove_inode_page
v1 -> v2:
* set max size of fast symlink according toinline_xattrflagfs/f2fs/f2fs.h | 15 ++++++++++++++ fs/f2fs/file.c | 2 ++ fs/f2fs/inode.c | 9 +++++++-- fs/f2fs/namei.c | 53 +++++++++++++++++++++++++++++++++++++++++++++---- fs/f2fs/node.c | 5 +++-- include/linux/f2fs_fs.h | 2 ++ 6 files changed, 78 insertions(+), 8 deletions(-)fs/f2fs/f2fs.h +5
-0@@ -1226,6 +1226,7 @@ enum {FI_VOLATILE_FILE ,/* indicate volatile file */ FI_DROP_CACHE ,/* drop dirty page cache */ FI_DATA_EXIST ,/* indicate data exists */ + FI_FAST_SYMLINK, /* indicate fast symlink */ };static inline void set_inode_flag (struct f2fs_inode_info *fi,int flag)@@ -1262,6 +1263,8 @@ static inline void get_inline_info(struct f2fs_inode_info *fi,set_inode_flag (fi,FI_INLINE_DENTRY );if (ri->i_inline &F2FS_DATA_EXIST )set_inode_flag (fi,FI_DATA_EXIST ); +if (ri->i_inline &F2FS_FAST_SYMLINK ) +set_inode_flag (fi,FI_FAST_SYMLINK ); } static inline void set_raw_inline(struct f2fs_inode_info *fi,@@ -1277,6 +1280,8 @@ static inline void set_raw_inline(struct f2fs_inode_info *fi, ri->i_inline |=F2FS_INLINE_DENTRY ;if (is_inode_flag_set (fi,FI_DATA_EXIST )) ri->i_inline |=F2FS_DATA_EXIST ; +if (is_inode_flag_set (fi,FI_FAST_SYMLINK )) + ri->i_inline |=F2FS_FAST_SYMLINK ; }static inline int f2fs_has_inline_xattr (struct inode *inode)
fs/f2fs/f2fs.h static inline void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi) · line 1384
Quoted 10 lines
fs/f2fs/f2fs.h +7
-0@@ -1370,6 +1375,15 @@ static inline void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi) sbi->sb->s_flags |=MS_RDONLY ; } +/* +* Test whether an inode is a fast symlink. +*/ +static inline int f2fs_inode_is_fast_symlink (struct inode *inode) +{ +return (S_ISLNK (inode->i_mode) && +is_inode_flag_set (F2FS_I (inode),FI_FAST_SYMLINK ));
Look at this again, it seems that it's not necessary to introduce FI_FAST_SYMLINK & F2FS_FAST_SYNLINK as we waste one bit in i_inline flag, for fast symlink, using your original design will be enough until we consider xattr node block case.
static inline int f2fs_inode_is_fast_symlink(struct inode *inode)
{
return (S_ISLNK(inode->i_mode) && !F2FS_HAS_BLOCKS(inode));
}Wanpeng, how about waiting for Jaegeuk's opinion?
Quoted 73 lines
fs/f2fs/f2fs.h +3
-0+} +#define get_inode_mode (i) \ ((is_inode_flag_set(F2FS_I(i), FI_ACL_MODE)) ? \ (F2FS_I(i)->i_acl_mode) : ((i)->i_mode))@@ -1746,6 +1760,7 @@ extern const struct address_space_operations f2fs_node_aops;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_fast_symlink_inode_operations;extern const struct inode_operations f2fs_special_inode_operations;extern struct kmem_cache *inode_entry_slab;fs/f2fs/file.c +2
-0@@ -546,6 +546,8 @@ void f2fs_truncate(struct inode *inode)if (!(S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) ||S_ISLNK (inode->i_mode)))return ; +if (f2fs_inode_is_fast_symlink (inode)) +return ;trace_f2fs_truncate (inode);fs/f2fs/inode.c +7
-2@@ -13,6 +13,7 @@#include <linux/buffer_head.h> #include <linux/writeback.h> #include <linux/bitops.h> +#include <linux/namei.h> #include "f2fs.h" #include "node.h" @@ -188,8 +189,12 @@ make_now: inode->i_mapping->a_ops = &f2fs_dblock_aops;mapping_set_gfp_mask (inode->i_mapping,GFP_F2FS_HIGH_ZERO ); }else if (S_ISLNK (inode->i_mode)) { - inode->i_op = &f2fs_symlink_inode_operations; - inode->i_mapping->a_ops = &f2fs_dblock_aops; +if (f2fs_inode_is_fast_symlink (inode)) + inode->i_op = &f2fs_fast_symlink_inode_operations; +else { + inode->i_op = &f2fs_symlink_inode_operations; + inode->i_mapping->a_ops = &f2fs_dblock_aops; + } }else if (S_ISCHR (inode->i_mode) ||S_ISBLK (inode->i_mode) ||S_ISFIFO (inode->i_mode) ||S_ISSOCK (inode->i_mode)) { inode->i_op = &f2fs_special_inode_operations;fs/f2fs/namei.c +5
-0@@ -14,6 +14,7 @@#include <linux/sched.h> #include <linux/ctype.h> #include <linux/dcache.h> +#include <linux/namei.h> #include "f2fs.h" #include "node.h" @@ -247,6 +248,21 @@ fail:return err; } +static void *f2fs_follow_link (struct dentry *dentry,struct nameidata *nd) +{ +struct page *node_page; +
fs/f2fs/namei.c fail: · line 264
Quoted 10 lines
fs/f2fs/namei.c +10
-0+ node_page =get_node_page (F2FS_I_SB (dentry->d_inode), + dentry->d_inode->i_ino); +if (IS_ERR (node_page)) { +nd_set_link (nd,NULL ); +return NULL ; + } +nd_set_link (nd, (char *)(F2FS_INODE (node_page)->i_addr)); +f2fs_put_page (node_page,1 ); +return NULL ; +}
The only different of i_op for fast symlink and normal symlink is that we use different callback function for ->follow_link, if we merge page_follow_link_light & f2fs_follow_link into one, we can remove duplicated f2fs_fast_symlink_inode_operations. How do you think of it?
Quoted 10 lines
fs/f2fs/namei.c +1
-2+static int f2fs_symlink (struct inode *dir,struct dentry *dentry,const char *symname) {@@ -261,16 +277,31 @@ static int f2fs_symlink(struct inode *dir, struct dentry *dentry,if (IS_ERR (inode))return PTR_ERR (inode); - inode->i_op = &f2fs_symlink_inode_operations; - inode->i_mapping->a_ops = &f2fs_dblock_aops;
fs/f2fs/namei.c static int f2fs_symlink(struct inode *dir, struct dentry *dentry, · line 287
Quoted 10 lines
fs/f2fs/namei.c +2
-2-f2fs_lock_op (sbi); err =f2fs_add_link (dentry, inode);if (err) goto out;f2fs_unlock_op (sbi); - err =page_symlink (inode, symname, symlen); + +if (symlen >MAX_FAST_SYMLINK_SIZE ) {
I think we should be pick up max_fast_symlink_size which is introduced in v2.
Quoted 4 lines
fs/f2fs/namei.c +4
-0+/* slow symlink */ + inode->i_op = &f2fs_symlink_inode_operations; + inode->i_mapping->a_ops = &f2fs_dblock_aops; + err =page_symlink (inode, symname, symlen);
fs/f2fs/namei.c static int f2fs_symlink(struct inode *dir, struct dentry *dentry, · line 301
Quoted 10 lines
fs/f2fs/namei.c +10
-0+ }else { +/* fast symlink */ +struct page *node_page; + + inode->i_op = &f2fs_fast_symlink_inode_operations; + node_page =get_node_page (sbi, inode->i_ino); +memcpy ((char *)&F2FS_INODE (node_page)->i_addr, symname, symlen); +set_page_dirty (node_page); +f2fs_put_page (node_page,1 ); + inode->i_size = symlen-1 ;
trivial coding style issue.inode->i_size = symlen - 1;
Thanks,
Quoted 61 lines
fs/f2fs/namei.c +17
-0+set_inode_flag (F2FS_I (inode),FI_FAST_SYMLINK ); +mark_inode_dirty (inode); + }alloc_nid_done (sbi, inode->i_ino);d_instantiate (dentry, inode);@@ -743,6 +774,20 @@ const struct inode_operations f2fs_symlink_inode_operations = {#endif }; +const struct inode_operations f2fs_fast_symlink_inode_operations = { + .readlink = generic_readlink, + .follow_link = f2fs_follow_link, + .put_link = page_put_link, + .getattr = f2fs_getattr, + .setattr = f2fs_setattr, +#ifdef CONFIG_F2FS_FS_XATTR + .setxattr = generic_setxattr, + .getxattr = generic_getxattr, + .listxattr = f2fs_listxattr, + .removexattr = generic_removexattr, +#endif +}; +const struct inode_operations f2fs_special_inode_operations = { .getattr = f2fs_getattr, .setattr = f2fs_setattr,fs/f2fs/node.c +3
-2@@ -908,8 +908,9 @@ void remove_inode_page(struct inode *inode) }/* remove potential inline_data blocks */ -if (S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || -S_ISLNK (inode->i_mode)) +if ((S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || +S_ISLNK (inode->i_mode)) && + !f2fs_inode_is_fast_symlink (inode))truncate_data_blocks_range (&dn,1 );/* 0 is possible, after f2fs_new_inode() has failed */ include/linux/f2fs_fs.h +2
-1@@ -178,9 +178,11 @@ struct f2fs_extent {#define F2FS_INLINE_DATA 0x02/* file inline data flag */ #define F2FS_INLINE_DENTRY 0x04/* file inline dentry flag */ #define F2FS_DATA_EXIST 0x08/* file inline data exist flag */ +#define F2FS_FAST_SYMLINK 0x10/* file fast symlink flag */ #define MAX_INLINE_DATA (sizeof(__le32) * (DEF_ADDRS_PER_INODE - \ F2FS_INLINE_XATTR_ADDRS - 1)) +#define MAX_FAST_SYMLINK_SIZE (MAX_INLINE_DATA + 1)struct f2fs_inode {__le16 i_mode;/* file mode */ --1.9.1
Hi Chao,
Quoted 163 lines · Chao Yu
Hi Wanpeng, Jaegeuk,
Quoted 59 lines
-----Original Message-----
From: Wanpeng Li [mailto:[email protected]]
Sent: Friday, March 13, 2015 2:34 PM
To: Jaegeuk Kim
Cc: Changman Lee; Chao Yu; [email protected]; [email protected]; [email protected]; Wanpeng Li
Subject: [PATCH v3] f2fs: add fast symlink supportThis patch introduces the improvement fast symlinks to allow storage of the target path within inode, thus symlinks with short target paths are more accessed quickly. It will fall back to using the original slow symlink if the target path exceeds the available inode space.
Signed-off-by Wanpeng Li <[email protected]>---
v2 -> v3:
* handle fast symlink inremove_inode_page
v1 -> v2:
* set max size of fast symlink according toinline_xattrflagfs/f2fs/f2fs.h | 15 ++++++++++++++ fs/f2fs/file.c | 2 ++ fs/f2fs/inode.c | 9 +++++++-- fs/f2fs/namei.c | 53 +++++++++++++++++++++++++++++++++++++++++++++---- fs/f2fs/node.c | 5 +++-- include/linux/f2fs_fs.h | 2 ++ 6 files changed, 78 insertions(+), 8 deletions(-)fs/f2fs/f2fs.h +5
-0@@ -1226,6 +1226,7 @@ enum {FI_VOLATILE_FILE ,/* indicate volatile file */ FI_DROP_CACHE ,/* drop dirty page cache */ FI_DATA_EXIST ,/* indicate data exists */ + FI_FAST_SYMLINK, /* indicate fast symlink */ };static inline void set_inode_flag (struct f2fs_inode_info *fi,int flag)@@ -1262,6 +1263,8 @@ static inline void get_inline_info(struct f2fs_inode_info *fi,set_inode_flag (fi,FI_INLINE_DENTRY );if (ri->i_inline &F2FS_DATA_EXIST )set_inode_flag (fi,FI_DATA_EXIST ); +if (ri->i_inline &F2FS_FAST_SYMLINK ) +set_inode_flag (fi,FI_FAST_SYMLINK ); } static inline void set_raw_inline(struct f2fs_inode_info *fi,@@ -1277,6 +1280,8 @@ static inline void set_raw_inline(struct f2fs_inode_info *fi, ri->i_inline |=F2FS_INLINE_DENTRY ;if (is_inode_flag_set (fi,FI_DATA_EXIST )) ri->i_inline |=F2FS_DATA_EXIST ; +if (is_inode_flag_set (fi,FI_FAST_SYMLINK )) + ri->i_inline |=F2FS_FAST_SYMLINK ; }static inline int f2fs_has_inline_xattr (struct inode *inode)fs/f2fs/f2fs.h static inline void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi) · line 1384
Quoted 10 lines
fs/f2fs/f2fs.h +7
-0@@ -1370,6 +1375,15 @@ static inline void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi) sbi->sb->s_flags |=MS_RDONLY ; } +/* +* Test whether an inode is a fast symlink. +*/ +static inline int f2fs_inode_is_fast_symlink (struct inode *inode) +{ +return (S_ISLNK (inode->i_mode) && +is_inode_flag_set (F2FS_I (inode),FI_FAST_SYMLINK ));Look at this again, it seems that it's not necessary to introduce
FI_FAST_SYMLINK&F2FS_FAST_SYNLINKas we waste one bit ini_inlineflag, for fast symlink, using your original design will be enough until we consider xattr node block case.static inline int
f2fs_inode_is_fast_symlink(struct inode *inode){ return (S_ISLNK(inode->i_mode) && !F2FS_HAS_BLOCKS(inode)); }Wanpeng, how about waiting for Jaegeuk's opinion?
Quoted 80 lines
fs/f2fs/f2fs.h +3
-0+} +#define get_inode_mode (i) \ ((is_inode_flag_set(F2FS_I(i), FI_ACL_MODE)) ? \ (F2FS_I(i)->i_acl_mode) : ((i)->i_mode))@@ -1746,6 +1760,7 @@ extern const struct address_space_operations f2fs_node_aops;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_fast_symlink_inode_operations;extern const struct inode_operations f2fs_special_inode_operations;extern struct kmem_cache *inode_entry_slab;fs/f2fs/file.c +2
-0@@ -546,6 +546,8 @@ void f2fs_truncate(struct inode *inode)if (!(S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) ||S_ISLNK (inode->i_mode)))return ; +if (f2fs_inode_is_fast_symlink (inode)) +return ;trace_f2fs_truncate (inode);fs/f2fs/inode.c +7
-2@@ -13,6 +13,7 @@#include <linux/buffer_head.h> #include <linux/writeback.h> #include <linux/bitops.h> +#include <linux/namei.h> #include "f2fs.h" #include "node.h" @@ -188,8 +189,12 @@ make_now: inode->i_mapping->a_ops = &f2fs_dblock_aops;mapping_set_gfp_mask (inode->i_mapping,GFP_F2FS_HIGH_ZERO ); }else if (S_ISLNK (inode->i_mode)) { - inode->i_op = &f2fs_symlink_inode_operations; - inode->i_mapping->a_ops = &f2fs_dblock_aops; +if (f2fs_inode_is_fast_symlink (inode)) + inode->i_op = &f2fs_fast_symlink_inode_operations; +else { + inode->i_op = &f2fs_symlink_inode_operations; + inode->i_mapping->a_ops = &f2fs_dblock_aops; + } }else if (S_ISCHR (inode->i_mode) ||S_ISBLK (inode->i_mode) ||S_ISFIFO (inode->i_mode) ||S_ISSOCK (inode->i_mode)) { inode->i_op = &f2fs_special_inode_operations;fs/f2fs/namei.c +12
-0@@ -14,6 +14,7 @@#include <linux/sched.h> #include <linux/ctype.h> #include <linux/dcache.h> +#include <linux/namei.h> #include "f2fs.h" #include "node.h" @@ -247,6 +248,21 @@ fail:return err; } +static void *f2fs_follow_link (struct dentry *dentry,struct nameidata *nd) +{ +struct page *node_page; + + node_page =get_node_page (F2FS_I_SB (dentry->d_inode), + dentry->d_inode->i_ino); +if (IS_ERR (node_page)) { +nd_set_link (nd,NULL ); +return NULL ; + } +nd_set_link (nd, (char *)(F2FS_INODE (node_page)->i_addr));
Quoted 8 lines
fs/f2fs/namei.c fail: · line 264
Quoted 3 lines
fs/f2fs/namei.c +3
-0+f2fs_put_page (node_page,1 ); +return NULL ; +}The only different of
i_opfor fast symlink and normal symlink is that we use different callback function for ->follow_link, if we mergepage_follow_link_light&f2fs_follow_linkinto one, we can remove duplicatedf2fs_fast_symlink_inode_operations. How do you think of it?
I found that ext2/3/4 do the same as mine. ;-)
Regards,
Wanpeng Li
Quoted 105 lines
Quoted 11 lines
fs/f2fs/namei.c +1
-2+static int f2fs_symlink (struct inode *dir,struct dentry *dentry,const char *symname) {@@ -261,16 +277,31 @@ static int f2fs_symlink(struct inode *dir, struct dentry *dentry,if (IS_ERR (inode))return PTR_ERR (inode); - inode->i_op = &f2fs_symlink_inode_operations; - inode->i_mapping->a_ops = &f2fs_dblock_aops;fs/f2fs/namei.c static int f2fs_symlink(struct inode *dir, struct dentry *dentry, · line 287
Quoted 10 lines
fs/f2fs/namei.c +2
-2-f2fs_lock_op (sbi); err =f2fs_add_link (dentry, inode);if (err) goto out;f2fs_unlock_op (sbi); - err =page_symlink (inode, symname, symlen); + +if (symlen >MAX_FAST_SYMLINK_SIZE ) {I think we should be pick up
max_fast_symlink_sizewhich is introduced in v2.Quoted 4 lines
fs/f2fs/namei.c +4
-0+/* slow symlink */ + inode->i_op = &f2fs_symlink_inode_operations; + inode->i_mapping->a_ops = &f2fs_dblock_aops; + err =page_symlink (inode, symname, symlen);fs/f2fs/namei.c static int f2fs_symlink(struct inode *dir, struct dentry *dentry, · line 301
Quoted 10 lines
fs/f2fs/namei.c +10
-0+ }else { +/* fast symlink */ +struct page *node_page; + + inode->i_op = &f2fs_fast_symlink_inode_operations; + node_page =get_node_page (sbi, inode->i_ino); +memcpy ((char *)&F2FS_INODE (node_page)->i_addr, symname, symlen); +set_page_dirty (node_page); +f2fs_put_page (node_page,1 ); + inode->i_size = symlen-1 ;trivial coding style issue.
inode->i_size= symlen - 1;Thanks,
Quoted 61 lines
fs/f2fs/namei.c +17
-0+set_inode_flag (F2FS_I (inode),FI_FAST_SYMLINK ); +mark_inode_dirty (inode); + }alloc_nid_done (sbi, inode->i_ino);d_instantiate (dentry, inode);@@ -743,6 +774,20 @@ const struct inode_operations f2fs_symlink_inode_operations = {#endif }; +const struct inode_operations f2fs_fast_symlink_inode_operations = { + .readlink = generic_readlink, + .follow_link = f2fs_follow_link, + .put_link = page_put_link, + .getattr = f2fs_getattr, + .setattr = f2fs_setattr, +#ifdef CONFIG_F2FS_FS_XATTR + .setxattr = generic_setxattr, + .getxattr = generic_getxattr, + .listxattr = f2fs_listxattr, + .removexattr = generic_removexattr, +#endif +}; +const struct inode_operations f2fs_special_inode_operations = { .getattr = f2fs_getattr, .setattr = f2fs_setattr,fs/f2fs/node.c +3
-2@@ -908,8 +908,9 @@ void remove_inode_page(struct inode *inode) }/* remove potential inline_data blocks */ -if (S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || -S_ISLNK (inode->i_mode)) +if ((S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || +S_ISLNK (inode->i_mode)) && + !f2fs_inode_is_fast_symlink (inode))truncate_data_blocks_range (&dn,1 );/* 0 is possible, after f2fs_new_inode() has failed */ include/linux/f2fs_fs.h +2
-1@@ -178,9 +178,11 @@ struct f2fs_extent {#define F2FS_INLINE_DATA 0x02/* file inline data flag */ #define F2FS_INLINE_DENTRY 0x04/* file inline dentry flag */ #define F2FS_DATA_EXIST 0x08/* file inline data exist flag */ +#define F2FS_FAST_SYMLINK 0x10/* file fast symlink flag */ #define MAX_INLINE_DATA (sizeof(__le32) * (DEF_ADDRS_PER_INODE - \ F2FS_INLINE_XATTR_ADDRS - 1)) +#define MAX_FAST_SYMLINK_SIZE (MAX_INLINE_DATA + 1)struct f2fs_inode {__le16 i_mode;/* file mode */ --1.9.1
Ping Jaegeuk,
Quoted 239 lines · Wanpeng Li
This patch introduces the improvement fast symlinks to allow storage of the target path within inode, thus symlinks with short target paths are more accessed quickly. It will fall back to using the original slow symlink if the target path exceeds the available inode space.
Signed-off-by Wanpeng Li <[email protected]>---
v2 -> v3:
* handle fast symlink inremove_inode_page
v1 -> v2:
* set max size of fast symlink according toinline_xattrflagfs/f2fs/f2fs.h | 15 ++++++++++++++ fs/f2fs/file.c | 2 ++ fs/f2fs/inode.c | 9 +++++++-- fs/f2fs/namei.c | 53 +++++++++++++++++++++++++++++++++++++++++++++---- fs/f2fs/node.c | 5 +++-- include/linux/f2fs_fs.h | 2 ++ 6 files changed, 78 insertions(+), 8 deletions(-)fs/f2fs/f2fs.h +15
-0@@ -1226,6 +1226,7 @@ enum {FI_VOLATILE_FILE ,/* indicate volatile file */ FI_DROP_CACHE ,/* drop dirty page cache */ FI_DATA_EXIST ,/* indicate data exists */ + FI_FAST_SYMLINK, /* indicate fast symlink */ };static inline void set_inode_flag (struct f2fs_inode_info *fi,int flag)@@ -1262,6 +1263,8 @@ static inline void get_inline_info(struct f2fs_inode_info *fi,set_inode_flag (fi,FI_INLINE_DENTRY );if (ri->i_inline &F2FS_DATA_EXIST )set_inode_flag (fi,FI_DATA_EXIST ); +if (ri->i_inline &F2FS_FAST_SYMLINK ) +set_inode_flag (fi,FI_FAST_SYMLINK ); } static inline void set_raw_inline(struct f2fs_inode_info *fi,@@ -1277,6 +1280,8 @@ static inline void set_raw_inline(struct f2fs_inode_info *fi, ri->i_inline |=F2FS_INLINE_DENTRY ;if (is_inode_flag_set (fi,FI_DATA_EXIST )) ri->i_inline |=F2FS_DATA_EXIST ; +if (is_inode_flag_set (fi,FI_FAST_SYMLINK )) + ri->i_inline |=F2FS_FAST_SYMLINK ; }static inline int f2fs_has_inline_xattr (struct inode *inode)@@ -1370,6 +1375,15 @@ static inline void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi) sbi->sb->s_flags |=MS_RDONLY ; } +/* +* Test whether an inode is a fast symlink. +*/ +static inline int f2fs_inode_is_fast_symlink (struct inode *inode) +{ +return (S_ISLNK (inode->i_mode) && +is_inode_flag_set (F2FS_I (inode),FI_FAST_SYMLINK )); +} +#define get_inode_mode (i) \ ((is_inode_flag_set(F2FS_I(i), FI_ACL_MODE)) ? \ (F2FS_I(i)->i_acl_mode) : ((i)->i_mode))@@ -1746,6 +1760,7 @@ extern const struct address_space_operations f2fs_node_aops;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_fast_symlink_inode_operations;extern const struct inode_operations f2fs_special_inode_operations;extern struct kmem_cache *inode_entry_slab;fs/f2fs/file.c +2
-0@@ -546,6 +546,8 @@ void f2fs_truncate(struct inode *inode)if (!(S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) ||S_ISLNK (inode->i_mode)))return ; +if (f2fs_inode_is_fast_symlink (inode)) +return ;trace_f2fs_truncate (inode);fs/f2fs/inode.c +7
-2@@ -13,6 +13,7 @@#include <linux/buffer_head.h> #include <linux/writeback.h> #include <linux/bitops.h> +#include <linux/namei.h> #include "f2fs.h" #include "node.h" @@ -188,8 +189,12 @@ make_now: inode->i_mapping->a_ops = &f2fs_dblock_aops;mapping_set_gfp_mask (inode->i_mapping,GFP_F2FS_HIGH_ZERO ); }else if (S_ISLNK (inode->i_mode)) { - inode->i_op = &f2fs_symlink_inode_operations; - inode->i_mapping->a_ops = &f2fs_dblock_aops; +if (f2fs_inode_is_fast_symlink (inode)) + inode->i_op = &f2fs_fast_symlink_inode_operations; +else { + inode->i_op = &f2fs_symlink_inode_operations; + inode->i_mapping->a_ops = &f2fs_dblock_aops; + } }else if (S_ISCHR (inode->i_mode) ||S_ISBLK (inode->i_mode) ||S_ISFIFO (inode->i_mode) ||S_ISSOCK (inode->i_mode)) { inode->i_op = &f2fs_special_inode_operations;fs/f2fs/namei.c +49
-4@@ -14,6 +14,7 @@#include <linux/sched.h> #include <linux/ctype.h> #include <linux/dcache.h> +#include <linux/namei.h> #include "f2fs.h" #include "node.h" @@ -247,6 +248,21 @@ fail:return err; } +static void *f2fs_follow_link (struct dentry *dentry,struct nameidata *nd) +{ +struct page *node_page; + + node_page =get_node_page (F2FS_I_SB (dentry->d_inode), + dentry->d_inode->i_ino); +if (IS_ERR (node_page)) { +nd_set_link (nd,NULL ); +return NULL ; + } +nd_set_link (nd, (char *)(F2FS_INODE (node_page)->i_addr)); +f2fs_put_page (node_page,1 ); +return NULL ; +} +static int f2fs_symlink (struct inode *dir,struct dentry *dentry,const char *symname) {@@ -261,16 +277,31 @@ static int f2fs_symlink(struct inode *dir, struct dentry *dentry,if (IS_ERR (inode))return PTR_ERR (inode); - inode->i_op = &f2fs_symlink_inode_operations; - inode->i_mapping->a_ops = &f2fs_dblock_aops; -f2fs_lock_op (sbi); err =f2fs_add_link (dentry, inode);if (err) goto out;f2fs_unlock_op (sbi); - err =page_symlink (inode, symname, symlen); + +if (symlen >MAX_FAST_SYMLINK_SIZE ) { +/* slow symlink */ + inode->i_op = &f2fs_symlink_inode_operations; + inode->i_mapping->a_ops = &f2fs_dblock_aops; + err =page_symlink (inode, symname, symlen); + }else { +/* fast symlink */ +struct page *node_page; + + inode->i_op = &f2fs_fast_symlink_inode_operations; + node_page =get_node_page (sbi, inode->i_ino); +memcpy ((char *)&F2FS_INODE (node_page)->i_addr, symname, symlen); +set_page_dirty (node_page); +f2fs_put_page (node_page,1 ); + inode->i_size = symlen-1 ; +set_inode_flag (F2FS_I (inode),FI_FAST_SYMLINK ); +mark_inode_dirty (inode); + }alloc_nid_done (sbi, inode->i_ino);d_instantiate (dentry, inode);@@ -743,6 +774,20 @@ const struct inode_operations f2fs_symlink_inode_operations = {#endif }; +const struct inode_operations f2fs_fast_symlink_inode_operations = { + .readlink = generic_readlink, + .follow_link = f2fs_follow_link, + .put_link = page_put_link, + .getattr = f2fs_getattr, + .setattr = f2fs_setattr, +#ifdef CONFIG_F2FS_FS_XATTR + .setxattr = generic_setxattr, + .getxattr = generic_getxattr, + .listxattr = f2fs_listxattr, + .removexattr = generic_removexattr, +#endif +}; +const struct inode_operations f2fs_special_inode_operations = { .getattr = f2fs_getattr, .setattr = f2fs_setattr,fs/f2fs/node.c +3
-2@@ -908,8 +908,9 @@ void remove_inode_page(struct inode *inode) }/* remove potential inline_data blocks */ -if (S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || -S_ISLNK (inode->i_mode)) +if ((S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || +S_ISLNK (inode->i_mode)) && + !f2fs_inode_is_fast_symlink (inode))truncate_data_blocks_range (&dn,1 );/* 0 is possible, after f2fs_new_inode() has failed */ include/linux/f2fs_fs.h +2
-0@@ -178,9 +178,11 @@ struct f2fs_extent {#define F2FS_INLINE_DATA 0x02/* file inline data flag */ #define F2FS_INLINE_DENTRY 0x04/* file inline dentry flag */ #define F2FS_DATA_EXIST 0x08/* file inline data exist flag */ +#define F2FS_FAST_SYMLINK 0x10/* file fast symlink flag */ #define MAX_INLINE_DATA (sizeof(__le32) * (DEF_ADDRS_PER_INODE - \ F2FS_INLINE_XATTR_ADDRS - 1)) +#define MAX_FAST_SYMLINK_SIZE (MAX_INLINE_DATA + 1)struct f2fs_inode {__le16 i_mode;/* file mode */ Signature · 1 line
1.9.1
Jaegeuk Kim
maintainerHi guys,
Sorry for the delay due to travel.
Quoted 165 lines · Wanpeng Li
This patch introduces the improvement fast symlinks to allow storage of the target path within inode, thus symlinks with short target paths are more accessed quickly. It will fall back to using the original slow symlink if the target path exceeds the available inode space.
Signed-off-by Wanpeng Li <[email protected]>---
v2 -> v3:
* handle fast symlink inremove_inode_page
v1 -> v2:
* set max size of fast symlink according toinline_xattrflagfs/f2fs/f2fs.h | 15 ++++++++++++++ fs/f2fs/file.c | 2 ++ fs/f2fs/inode.c | 9 +++++++-- fs/f2fs/namei.c | 53 +++++++++++++++++++++++++++++++++++++++++++++---- fs/f2fs/node.c | 5 +++-- include/linux/f2fs_fs.h | 2 ++ 6 files changed, 78 insertions(+), 8 deletions(-)fs/f2fs/f2fs.h +15
-0@@ -1226,6 +1226,7 @@ enum {FI_VOLATILE_FILE ,/* indicate volatile file */ FI_DROP_CACHE ,/* drop dirty page cache */ FI_DATA_EXIST ,/* indicate data exists */ + FI_FAST_SYMLINK, /* indicate fast symlink */ };static inline void set_inode_flag (struct f2fs_inode_info *fi,int flag)@@ -1262,6 +1263,8 @@ static inline void get_inline_info(struct f2fs_inode_info *fi,set_inode_flag (fi,FI_INLINE_DENTRY );if (ri->i_inline &F2FS_DATA_EXIST )set_inode_flag (fi,FI_DATA_EXIST ); +if (ri->i_inline &F2FS_FAST_SYMLINK ) +set_inode_flag (fi,FI_FAST_SYMLINK ); } static inline void set_raw_inline(struct f2fs_inode_info *fi,@@ -1277,6 +1280,8 @@ static inline void set_raw_inline(struct f2fs_inode_info *fi, ri->i_inline |=F2FS_INLINE_DENTRY ;if (is_inode_flag_set (fi,FI_DATA_EXIST )) ri->i_inline |=F2FS_DATA_EXIST ; +if (is_inode_flag_set (fi,FI_FAST_SYMLINK )) + ri->i_inline |=F2FS_FAST_SYMLINK ; }static inline int f2fs_has_inline_xattr (struct inode *inode)@@ -1370,6 +1375,15 @@ static inline void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi) sbi->sb->s_flags |=MS_RDONLY ; } +/* +* Test whether an inode is a fast symlink. +*/ +static inline int f2fs_inode_is_fast_symlink (struct inode *inode) +{ +return (S_ISLNK (inode->i_mode) && +is_inode_flag_set (F2FS_I (inode),FI_FAST_SYMLINK )); +} +#define get_inode_mode (i) \ ((is_inode_flag_set(F2FS_I(i), FI_ACL_MODE)) ? \ (F2FS_I(i)->i_acl_mode) : ((i)->i_mode))@@ -1746,6 +1760,7 @@ extern const struct address_space_operations f2fs_node_aops;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_fast_symlink_inode_operations;extern const struct inode_operations f2fs_special_inode_operations;extern struct kmem_cache *inode_entry_slab;fs/f2fs/file.c +2
-0@@ -546,6 +546,8 @@ void f2fs_truncate(struct inode *inode)if (!(S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) ||S_ISLNK (inode->i_mode)))return ; +if (f2fs_inode_is_fast_symlink (inode)) +return ;trace_f2fs_truncate (inode);fs/f2fs/inode.c +7
-2@@ -13,6 +13,7 @@#include <linux/buffer_head.h> #include <linux/writeback.h> #include <linux/bitops.h> +#include <linux/namei.h> #include "f2fs.h" #include "node.h" @@ -188,8 +189,12 @@ make_now: inode->i_mapping->a_ops = &f2fs_dblock_aops;mapping_set_gfp_mask (inode->i_mapping,GFP_F2FS_HIGH_ZERO ); }else if (S_ISLNK (inode->i_mode)) { - inode->i_op = &f2fs_symlink_inode_operations; - inode->i_mapping->a_ops = &f2fs_dblock_aops; +if (f2fs_inode_is_fast_symlink (inode)) + inode->i_op = &f2fs_fast_symlink_inode_operations; +else { + inode->i_op = &f2fs_symlink_inode_operations; + inode->i_mapping->a_ops = &f2fs_dblock_aops; + } }else if (S_ISCHR (inode->i_mode) ||S_ISBLK (inode->i_mode) ||S_ISFIFO (inode->i_mode) ||S_ISSOCK (inode->i_mode)) { inode->i_op = &f2fs_special_inode_operations;fs/f2fs/namei.c +19
-4@@ -14,6 +14,7 @@#include <linux/sched.h> #include <linux/ctype.h> #include <linux/dcache.h> +#include <linux/namei.h> #include "f2fs.h" #include "node.h" @@ -247,6 +248,21 @@ fail:return err; } +static void *f2fs_follow_link (struct dentry *dentry,struct nameidata *nd) +{ +struct page *node_page; + + node_page =get_node_page (F2FS_I_SB (dentry->d_inode), + dentry->d_inode->i_ino); +if (IS_ERR (node_page)) { +nd_set_link (nd,NULL ); +return NULL ; + } +nd_set_link (nd, (char *)(F2FS_INODE (node_page)->i_addr)); +f2fs_put_page (node_page,1 ); +return NULL ; +} +static int f2fs_symlink (struct inode *dir,struct dentry *dentry,const char *symname) {@@ -261,16 +277,31 @@ static int f2fs_symlink(struct inode *dir, struct dentry *dentry,if (IS_ERR (inode))return PTR_ERR (inode); - inode->i_op = &f2fs_symlink_inode_operations; - inode->i_mapping->a_ops = &f2fs_dblock_aops; -f2fs_lock_op (sbi); err =f2fs_add_link (dentry, inode);if (err) goto out;f2fs_unlock_op (sbi); - err =page_symlink (inode, symname, symlen); + +if (symlen >MAX_FAST_SYMLINK_SIZE ) { +/* slow symlink */
fs/f2fs/namei.c static int f2fs_symlink(struct inode *dir, struct dentry *dentry, · line 298
Quoted 10 lines
fs/f2fs/namei.c +10
-0+ inode->i_op = &f2fs_symlink_inode_operations; + inode->i_mapping->a_ops = &f2fs_dblock_aops; + err =page_symlink (inode, symname, symlen); + }else { +/* fast symlink */ +struct page *node_page; + + inode->i_op = &f2fs_fast_symlink_inode_operations; + node_page =get_node_page (sbi, inode->i_ino); +memcpy ((char *)&F2FS_INODE (node_page)->i_addr, symname, symlen);
This is mostly likewise the inline_data flow.
As of now, I can't recommend using any i_addr region, since we need to handle many cases such as truncation, roll-forward recovery, and fsck/dump tools.
It is more sensible to enable inline_data by default, isn't it?
Thanks,
Quoted 64 lines
fs/f2fs/namei.c +20
-0+set_page_dirty (node_page); +f2fs_put_page (node_page,1 ); + inode->i_size = symlen-1 ; +set_inode_flag (F2FS_I (inode),FI_FAST_SYMLINK ); +mark_inode_dirty (inode); + }alloc_nid_done (sbi, inode->i_ino);d_instantiate (dentry, inode);@@ -743,6 +774,20 @@ const struct inode_operations f2fs_symlink_inode_operations = {#endif }; +const struct inode_operations f2fs_fast_symlink_inode_operations = { + .readlink = generic_readlink, + .follow_link = f2fs_follow_link, + .put_link = page_put_link, + .getattr = f2fs_getattr, + .setattr = f2fs_setattr, +#ifdef CONFIG_F2FS_FS_XATTR + .setxattr = generic_setxattr, + .getxattr = generic_getxattr, + .listxattr = f2fs_listxattr, + .removexattr = generic_removexattr, +#endif +}; +const struct inode_operations f2fs_special_inode_operations = { .getattr = f2fs_getattr, .setattr = f2fs_setattr,fs/f2fs/node.c +3
-2@@ -908,8 +908,9 @@ void remove_inode_page(struct inode *inode) }/* remove potential inline_data blocks */ -if (S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || -S_ISLNK (inode->i_mode)) +if ((S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || +S_ISLNK (inode->i_mode)) && + !f2fs_inode_is_fast_symlink (inode))truncate_data_blocks_range (&dn,1 );/* 0 is possible, after f2fs_new_inode() has failed */ include/linux/f2fs_fs.h +2
-0@@ -178,9 +178,11 @@ struct f2fs_extent {#define F2FS_INLINE_DATA 0x02/* file inline data flag */ #define F2FS_INLINE_DENTRY 0x04/* file inline dentry flag */ #define F2FS_DATA_EXIST 0x08/* file inline data exist flag */ +#define F2FS_FAST_SYMLINK 0x10/* file fast symlink flag */ #define MAX_INLINE_DATA (sizeof(__le32) * (DEF_ADDRS_PER_INODE - \ F2FS_INLINE_XATTR_ADDRS - 1)) +#define MAX_FAST_SYMLINK_SIZE (MAX_INLINE_DATA + 1)struct f2fs_inode {__le16 i_mode;/* file mode */ Signature · 1 line
1.9.1
Hi Jaegeuk,
Quoted 19 lines · Jaegeuk Kim
Quoted 4 lines
fs/f2fs/namei.c +3
-1- err =page_symlink (inode, symname, symlen); + +if (symlen >MAX_FAST_SYMLINK_SIZE ) { +/* slow symlink */ fs/f2fs/namei.c static int f2fs_symlink(struct inode *dir, struct dentry *dentry, · line 298
Quoted 10 lines
fs/f2fs/namei.c +10
-0+ inode->i_op = &f2fs_symlink_inode_operations; + inode->i_mapping->a_ops = &f2fs_dblock_aops; + err =page_symlink (inode, symname, symlen); + }else { +/* fast symlink */ +struct page *node_page; + + inode->i_op = &f2fs_fast_symlink_inode_operations; + node_page =get_node_page (sbi, inode->i_ino); +memcpy ((char *)&F2FS_INODE (node_page)->i_addr, symname, symlen);This is mostly likewise the
inline_dataflow.
As of now, I can't recommend using anyi_addrregion, since we need to handle many cases such as truncation, roll-forward recovery, and fsck/dump tools.
Quoted 1 line
It is more sensible to enable
inline_databy default, isn't it?
Do you mean to replace the codes above by something like f2fs_write_inline_data()?
Regards,
Wanpeng Li
Quoted 59 lines
Thanks,
Quoted 56 lines
fs/f2fs/namei.c +20
-0+set_page_dirty (node_page); +f2fs_put_page (node_page,1 ); + inode->i_size = symlen-1 ; +set_inode_flag (F2FS_I (inode),FI_FAST_SYMLINK ); +mark_inode_dirty (inode); + }alloc_nid_done (sbi, inode->i_ino);d_instantiate (dentry, inode);@@ -743,6 +774,20 @@ const struct inode_operations f2fs_symlink_inode_operations = {#endif }; +const struct inode_operations f2fs_fast_symlink_inode_operations = { + .readlink = generic_readlink, + .follow_link = f2fs_follow_link, + .put_link = page_put_link, + .getattr = f2fs_getattr, + .setattr = f2fs_setattr, +#ifdef CONFIG_F2FS_FS_XATTR + .setxattr = generic_setxattr, + .getxattr = generic_getxattr, + .listxattr = f2fs_listxattr, + .removexattr = generic_removexattr, +#endif +}; +const struct inode_operations f2fs_special_inode_operations = { .getattr = f2fs_getattr, .setattr = f2fs_setattr,fs/f2fs/node.c +3
-2@@ -908,8 +908,9 @@ void remove_inode_page(struct inode *inode) }/* remove potential inline_data blocks */ -if (S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || -S_ISLNK (inode->i_mode)) +if ((S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || +S_ISLNK (inode->i_mode)) && + !f2fs_inode_is_fast_symlink (inode))truncate_data_blocks_range (&dn,1 );/* 0 is possible, after f2fs_new_inode() has failed */ include/linux/f2fs_fs.h +1
-0@@ -178,9 +178,11 @@ struct f2fs_extent {#define F2FS_INLINE_DATA 0x02/* file inline data flag */ #define F2FS_INLINE_DENTRY 0x04/* file inline dentry flag */ #define F2FS_DATA_EXIST 0x08/* file inline data exist flag */ +#define F2FS_FAST_SYMLINK 0x10/* file fast symlink flag */
Quoted 8 lines
Quoted 8 lines
include/linux/f2fs_fs.h +1
-0#define MAX_INLINE_DATA (sizeof(__le32) * (DEF_ADDRS_PER_INODE - \ F2FS_INLINE_XATTR_ADDRS - 1)) +#define MAX_FAST_SYMLINK_SIZE (MAX_INLINE_DATA + 1)struct f2fs_inode {__le16 i_mode;/* file mode */ Signature · 1 line
1.9.1
------------------------------------------------------------------------------
Dive into the World of Parallel Programming The Go Parallel Website, sponsored by Intel and developed in partnership with Slashdot Media, is your hub for all things parallel software development, from weekly thought leadership blogs to news, videos, case studies, tutorials and more. Take a look and join the conversation now. http://goparallel.sourceforge.net/
Jaegeuk Kim
maintainerHi,
Quoted 21 lines · Wanpeng Li
Hi Jaegeuk,
Quoted 19 lines · Jaegeuk Kim
Quoted 4 lines
fs/f2fs/namei.c +3
-1- err =page_symlink (inode, symname, symlen); + +if (symlen >MAX_FAST_SYMLINK_SIZE ) { +/* slow symlink */ fs/f2fs/namei.c static int f2fs_symlink(struct inode *dir, struct dentry *dentry, · line 298
Quoted 10 lines
fs/f2fs/namei.c +10
-0+ inode->i_op = &f2fs_symlink_inode_operations; + inode->i_mapping->a_ops = &f2fs_dblock_aops; + err =page_symlink (inode, symname, symlen); + }else { +/* fast symlink */ +struct page *node_page; + + inode->i_op = &f2fs_fast_symlink_inode_operations; + node_page =get_node_page (sbi, inode->i_ino); +memcpy ((char *)&F2FS_INODE (node_page)->i_addr, symname, symlen);This is mostly likewise the
inline_dataflow.
As of now, I can't recommend using anyi_addrregion, since we need to handle many cases such as truncation, roll-forward recovery, and fsck/dump tools.
Quoted 4 lines
Quoted 1 line
It is more sensible to enable
inline_databy default, isn't it?Do you mean to replace the codes above by something like
f2fs_write_inline_data()?
I meant the mount option, inline_data.
Currently, f2fs doesn't set that option at mount time, but I thought that we can set it by default since it becomes stable.
Thanks,
Quoted 71 lines
Regards,
Wanpeng LiQuoted 67 lines
Thanks,
Quoted 64 lines
fs/f2fs/namei.c +20
-0+set_page_dirty (node_page); +f2fs_put_page (node_page,1 ); + inode->i_size = symlen-1 ; +set_inode_flag (F2FS_I (inode),FI_FAST_SYMLINK ); +mark_inode_dirty (inode); + }alloc_nid_done (sbi, inode->i_ino);d_instantiate (dentry, inode);@@ -743,6 +774,20 @@ const struct inode_operations f2fs_symlink_inode_operations = {#endif }; +const struct inode_operations f2fs_fast_symlink_inode_operations = { + .readlink = generic_readlink, + .follow_link = f2fs_follow_link, + .put_link = page_put_link, + .getattr = f2fs_getattr, + .setattr = f2fs_setattr, +#ifdef CONFIG_F2FS_FS_XATTR + .setxattr = generic_setxattr, + .getxattr = generic_getxattr, + .listxattr = f2fs_listxattr, + .removexattr = generic_removexattr, +#endif +}; +const struct inode_operations f2fs_special_inode_operations = { .getattr = f2fs_getattr, .setattr = f2fs_setattr,fs/f2fs/node.c +3
-2@@ -908,8 +908,9 @@ void remove_inode_page(struct inode *inode) }/* remove potential inline_data blocks */ -if (S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || -S_ISLNK (inode->i_mode)) +if ((S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || +S_ISLNK (inode->i_mode)) && + !f2fs_inode_is_fast_symlink (inode))truncate_data_blocks_range (&dn,1 );/* 0 is possible, after f2fs_new_inode() has failed */ include/linux/f2fs_fs.h +2
-0@@ -178,9 +178,11 @@ struct f2fs_extent {#define F2FS_INLINE_DATA 0x02/* file inline data flag */ #define F2FS_INLINE_DENTRY 0x04/* file inline dentry flag */ #define F2FS_DATA_EXIST 0x08/* file inline data exist flag */ +#define F2FS_FAST_SYMLINK 0x10/* file fast symlink flag */ #define MAX_INLINE_DATA (sizeof(__le32) * (DEF_ADDRS_PER_INODE - \ F2FS_INLINE_XATTR_ADDRS - 1)) +#define MAX_FAST_SYMLINK_SIZE (MAX_INLINE_DATA + 1)struct f2fs_inode {__le16 i_mode;/* file mode */ Signature · 1 line
1.9.1
Hi Jaegeuk,
Quoted 24 lines · Jaegeuk Kim
Hi,
Quoted 21 lines · Wanpeng Li
Hi Jaegeuk,
Quoted 19 lines · Jaegeuk Kim
Quoted 4 lines
fs/f2fs/namei.c +3
-1- err =page_symlink (inode, symname, symlen); + +if (symlen >MAX_FAST_SYMLINK_SIZE ) { +/* slow symlink */ fs/f2fs/namei.c static int f2fs_symlink(struct inode *dir, struct dentry *dentry, · line 298
Quoted 10 lines
fs/f2fs/namei.c +10
-0+ inode->i_op = &f2fs_symlink_inode_operations; + inode->i_mapping->a_ops = &f2fs_dblock_aops; + err =page_symlink (inode, symname, symlen); + }else { +/* fast symlink */ +struct page *node_page; + + inode->i_op = &f2fs_fast_symlink_inode_operations; + node_page =get_node_page (sbi, inode->i_ino); +memcpy ((char *)&F2FS_INODE (node_page)->i_addr, symname, symlen);This is mostly likewise the
inline_dataflow.
As of now, I can't recommend using anyi_addrregion, since we need to handle many cases such as truncation, roll-forward recovery, and fsck/dump tools.
Quoted 8 lines
Quoted 4 lines
Quoted 1 line
It is more sensible to enable
inline_databy default, isn't it?Do you mean to replace the codes above by something like
f2fs_write_inline_data()?I meant the mount option,
inline_data.
Currently, f2fs doesn't set that option at mount time, but I thought that we can set it by default since it becomes stable.
So I think you mean my codes should memcpy i_addr[1~872] instead of i_addr[0~872], right?
Regards,
Wanpeng Li
Quoted 74 lines
Thanks,
Quoted 71 lines
Regards,
Wanpeng LiQuoted 67 lines
Thanks,
Quoted 64 lines
fs/f2fs/namei.c +20
-0+set_page_dirty (node_page); +f2fs_put_page (node_page,1 ); + inode->i_size = symlen-1 ; +set_inode_flag (F2FS_I (inode),FI_FAST_SYMLINK ); +mark_inode_dirty (inode); + }alloc_nid_done (sbi, inode->i_ino);d_instantiate (dentry, inode);@@ -743,6 +774,20 @@ const struct inode_operations f2fs_symlink_inode_operations = {#endif }; +const struct inode_operations f2fs_fast_symlink_inode_operations = { + .readlink = generic_readlink, + .follow_link = f2fs_follow_link, + .put_link = page_put_link, + .getattr = f2fs_getattr, + .setattr = f2fs_setattr, +#ifdef CONFIG_F2FS_FS_XATTR + .setxattr = generic_setxattr, + .getxattr = generic_getxattr, + .listxattr = f2fs_listxattr, + .removexattr = generic_removexattr, +#endif +}; +const struct inode_operations f2fs_special_inode_operations = { .getattr = f2fs_getattr, .setattr = f2fs_setattr,fs/f2fs/node.c +3
-2@@ -908,8 +908,9 @@ void remove_inode_page(struct inode *inode) }/* remove potential inline_data blocks */ -if (S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || -S_ISLNK (inode->i_mode)) +if ((S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || +S_ISLNK (inode->i_mode)) && + !f2fs_inode_is_fast_symlink (inode))truncate_data_blocks_range (&dn,1 );/* 0 is possible, after f2fs_new_inode() has failed */ include/linux/f2fs_fs.h +2
-0@@ -178,9 +178,11 @@ struct f2fs_extent {#define F2FS_INLINE_DATA 0x02/* file inline data flag */ #define F2FS_INLINE_DENTRY 0x04/* file inline dentry flag */ #define F2FS_DATA_EXIST 0x08/* file inline data exist flag */ +#define F2FS_FAST_SYMLINK 0x10/* file fast symlink flag */ #define MAX_INLINE_DATA (sizeof(__le32) * (DEF_ADDRS_PER_INODE - \ F2FS_INLINE_XATTR_ADDRS - 1)) +#define MAX_FAST_SYMLINK_SIZE (MAX_INLINE_DATA + 1)struct f2fs_inode {__le16 i_mode;/* file mode */ Signature · 1 line
1.9.1
Hi Wanpeng,
Quoted 36 lines
-----Original Message-----
From: Wanpeng Li [mailto:[email protected]]
Sent: Thursday, March 19, 2015 7:02 AM
To: Jaegeuk Kim
Cc: Wanpeng Li; Changman Lee; Chao Yu; [email protected]; [email protected]; [email protected]
Subject: Re: [PATCH v3] f2fs: add fast symlink supportHi Jaegeuk,
Quoted 26 lines · Jaegeuk Kim
Hi,
Quoted 23 lines · Wanpeng Li
Hi Jaegeuk,
Quoted 20 lines · Jaegeuk Kim
Quoted 4 lines
(quoted diff) +3
-1- err = page_symlink(inode, symname, symlen); + + if (symlen > MAX_FAST_SYMLINK_SIZE) { + /* slow symlink */Review
Quoted 10 lines
(quoted diff) +10
-0+ inode->i_op = &f2fs_symlink_inode_operations; + inode->i_mapping->a_ops = &f2fs_dblock_aops; + err = page_symlink(inode, symname, symlen); + } else { + /* fast symlink */ + struct page *node_page; + + inode->i_op = &f2fs_fast_symlink_inode_operations; + node_page = get_node_page(sbi, inode->i_ino); + memcpy((char *)&F2FS_INODE(node_page)->i_addr, symname, symlen);This is mostly likewise the
inline_dataflow.
As of now, I can't recommend using anyi_addrregion, since we need to handle many cases such as truncation, roll-forward recovery, and fsck/dump tools.It is more sensible to enable
inline_databy default, isn't it?
Quoted 8 lines
Quoted 6 lines
Quoted 2 lines
Do you mean to replace the codes above by something like
f2fs_write_inline_data()?I meant the mount option,
inline_data.
Currently, f2fs doesn't set that option at mount time, but I thought that we can set it by default since it becomes stable.So I think you mean my codes should memcpy i_addr[1~872] instead of i_addr[0~872], right?
I think what Jaegeuk means is that we can use inline_data in f2fs by default with patch like below firstly:
Quoted 1 line
From
a7320bfe94239ea4ceb193621a3a1a4d11a40d07Mon Sep 17 00:00:00 2001
From: Chao Yu <[email protected]>
Date: Thu, 19 Mar 2015 10:02:08 +0800
Subject: [PATCH] f2fs: use inline_data by default
Use inline_data feature by default since it brings us better performance & space utilization and now it is already stable.
--- fs/f2fs/super.c | 1 + 1 file changed, 1 insertion(+)
fs/f2fs/super.c +1 -0
@@ -991,6 +991,7 @@ try_onemore: sbi->active_logs =NR_CURSEG_TYPE ;set_opt (sbi,BG_GC ); +set_opt (sbi,INLINE_DATA );#ifdef CONFIG_F2FS_FS_XATTR set_opt (sbi,XATTR_USER );
Signature · 8 lines
2.3.1 Then we enable inline_data feature for symlink in f2fs_may_inline, after that by default our symlink created has inline_data flag in it, we treat small size symlink as an inline regular file, we can write its data page which is written in page_symlink into inode page like normal inline data procedure. Thanks,
Quoted 70 lines
Regards,
Wanpeng LiQuoted 66 lines
Thanks,
Quoted 63 lines
Regards,
Wanpeng LiQuoted 59 lines
Thanks,
Quoted 56 lines
(quoted diff) +20
-0+ set_page_dirty(node_page); + f2fs_put_page(node_page, 1); + inode->i_size = symlen-1; + set_inode_flag(F2FS_I(inode), FI_FAST_SYMLINK); + mark_inode_dirty(inode); + } alloc_nid_done(sbi, inode->i_ino); d_instantiate(dentry, inode);@@ -743,6 +774,20 @@ const struct inode_operations f2fs_symlink_inode_operations = { #endif }; +const struct inode_operations f2fs_fast_symlink_inode_operations = { + .readlink = generic_readlink, + .follow_link = f2fs_follow_link, + .put_link = page_put_link, + .getattr = f2fs_getattr, + .setattr = f2fs_setattr, +#ifdef CONFIG_F2FS_FS_XATTR + .setxattr = generic_setxattr, + .getxattr = generic_getxattr, + .listxattr = f2fs_listxattr, + .removexattr = generic_removexattr, +#endif +}; + const struct inode_operations f2fs_special_inode_operations = { .getattr = f2fs_getattr, .setattr = f2fs_setattr,fs/f2fs/node.c +3
-2@@ -908,8 +908,9 @@ void remove_inode_page(struct inode *inode) }/* remove potential inline_data blocks */ -if (S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || -S_ISLNK (inode->i_mode)) +if ((S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || +S_ISLNK (inode->i_mode)) && + !f2fs_inode_is_fast_symlink (inode))truncate_data_blocks_range (&dn,1 );/* 0 is possible, after f2fs_new_inode() has failed */ include/linux/f2fs_fs.h +1
-0@@ -178,9 +178,11 @@ struct f2fs_extent {#define F2FS_INLINE_DATA 0x02/* file inline data flag */ #define F2FS_INLINE_DENTRY 0x04/* file inline dentry flag */ #define F2FS_DATA_EXIST 0x08/* file inline data exist flag */ +#define F2FS_FAST_SYMLINK 0x10/* file fast symlink flag */
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
include/linux/f2fs_fs.h +1
-1#define MAX_INLINE_DATA (sizeof(__le32) * (DEF_ADDRS_PER_INODE - \ F2FS_INLINE_XATTR_ADDRS - 1)) +#define MAX_FAST_SYMLINK_SIZE (MAX_INLINE_DATA + 1)struct f2fs_inode {__le16 i_mode;/* file mode */ --1.9.1
------------------------------------------------------------------------------
Dive into the World of Parallel Programming The Go Parallel Website, sponsored by Intel and developed in partnership with Slashdot Media, is your hub for all things parallel software development, from weekly thought leadership blogs to news, videos, case studies, tutorials and more. Take a look and join the conversation now. http://goparallel.sourceforge.net/
Jaegeuk Kim
maintainerHi Wanpeng,
The Chao's patch is what I intended.
Could anyone of you enhance that patch?
If we use inline_data by default, we need another option to disable it. Like "noinline_data"?
Thanks,
Quoted 165 lines · Chao Yu
Hi Wanpeng,
Quoted 36 lines
-----Original Message-----
From: Wanpeng Li [mailto:[email protected]]
Sent: Thursday, March 19, 2015 7:02 AM
To: Jaegeuk Kim
Cc: Wanpeng Li; Changman Lee; Chao Yu; [email protected]; [email protected]; [email protected]
Subject: Re: [PATCH v3] f2fs: add fast symlink supportHi Jaegeuk,
Quoted 26 lines · Jaegeuk Kim
Hi,
Quoted 23 lines · Wanpeng Li
Hi Jaegeuk,
Quoted 20 lines · Jaegeuk Kim
Quoted 4 lines
(quoted diff) +3
-1- err = page_symlink(inode, symname, symlen); + + if (symlen > MAX_FAST_SYMLINK_SIZE) { + /* slow symlink */Review
Quoted 10 lines
(quoted diff) +10
-0+ inode->i_op = &f2fs_symlink_inode_operations; + inode->i_mapping->a_ops = &f2fs_dblock_aops; + err = page_symlink(inode, symname, symlen); + } else { + /* fast symlink */ + struct page *node_page; + + inode->i_op = &f2fs_fast_symlink_inode_operations; + node_page = get_node_page(sbi, inode->i_ino); + memcpy((char *)&F2FS_INODE(node_page)->i_addr, symname, symlen);This is mostly likewise the
inline_dataflow.
As of now, I can't recommend using anyi_addrregion, since we need to handle many cases such as truncation, roll-forward recovery, and fsck/dump tools.It is more sensible to enable
inline_databy default, isn't it?Quoted 8 lines
Quoted 6 lines
Quoted 2 lines
Do you mean to replace the codes above by something like
f2fs_write_inline_data()?I meant the mount option,
inline_data.
Currently, f2fs doesn't set that option at mount time, but I thought that we can set it by default since it becomes stable.So I think you mean my codes should memcpy i_addr[1~872] instead of i_addr[0~872], right?
I think what Jaegeuk means is that we can use
inline_datain f2fs by default with patch like below firstly:Quoted 1 line
From
a7320bfe94239ea4ceb193621a3a1a4d11a40d07Mon Sep 17 00:00:00 2001From: Chao Yu <[email protected]>
Date: Thu, 19 Mar 2015 10:02:08 +0800
Subject: [PATCH] f2fs: useinline_databy defaultUse
inline_datafeature by default since it brings us better performance & space utilization and now it is already stable.Suggested-by Jaegeuk Kim <[email protected]>Signed-off-by Chao Yu <[email protected]>Signed-off-by Wanpeng Li <[email protected]>--- fs/f2fs/super.c | 1 + 1 file changed, 1 insertion(+)fs/f2fs/super.c +1
-0@@ -991,6 +991,7 @@ try_onemore: sbi->active_logs =NR_CURSEG_TYPE ;set_opt (sbi,BG_GC ); +set_opt (sbi,INLINE_DATA );#ifdef CONFIG_F2FS_FS_XATTR set_opt (sbi,XATTR_USER );Signature · 8 lines
2.3.1 Then we enable inline_data feature for symlink in f2fs_may_inline, after that by default our symlink created has inline_data flag in it, we treat small size symlink as an inline regular file, we can write its data page which is written in page_symlink into inode page like normal inline data procedure. Thanks,Quoted 70 lines
Regards,
Wanpeng LiQuoted 66 lines
Thanks,
Quoted 63 lines
Regards,
Wanpeng LiQuoted 59 lines
Thanks,
Quoted 56 lines
(quoted diff) +20
-0+ set_page_dirty(node_page); + f2fs_put_page(node_page, 1); + inode->i_size = symlen-1; + set_inode_flag(F2FS_I(inode), FI_FAST_SYMLINK); + mark_inode_dirty(inode); + } alloc_nid_done(sbi, inode->i_ino); d_instantiate(dentry, inode);@@ -743,6 +774,20 @@ const struct inode_operations f2fs_symlink_inode_operations = { #endif }; +const struct inode_operations f2fs_fast_symlink_inode_operations = { + .readlink = generic_readlink, + .follow_link = f2fs_follow_link, + .put_link = page_put_link, + .getattr = f2fs_getattr, + .setattr = f2fs_setattr, +#ifdef CONFIG_F2FS_FS_XATTR + .setxattr = generic_setxattr, + .getxattr = generic_getxattr, + .listxattr = f2fs_listxattr, + .removexattr = generic_removexattr, +#endif +}; + const struct inode_operations f2fs_special_inode_operations = { .getattr = f2fs_getattr, .setattr = f2fs_setattr,fs/f2fs/node.c +3
-2@@ -908,8 +908,9 @@ void remove_inode_page(struct inode *inode) }/* remove potential inline_data blocks */ -if (S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || -S_ISLNK (inode->i_mode)) +if ((S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || +S_ISLNK (inode->i_mode)) && + !f2fs_inode_is_fast_symlink (inode))truncate_data_blocks_range (&dn,1 );/* 0 is possible, after f2fs_new_inode() has failed */ include/linux/f2fs_fs.h +1
-0@@ -178,9 +178,11 @@ struct f2fs_extent {#define F2FS_INLINE_DATA 0x02/* file inline data flag */ #define F2FS_INLINE_DENTRY 0x04/* file inline dentry flag */ #define F2FS_DATA_EXIST 0x08/* file inline data exist flag */ +#define F2FS_FAST_SYMLINK 0x10/* file fast symlink flag */ Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
include/linux/f2fs_fs.h +1
-1#define MAX_INLINE_DATA (sizeof(__le32) * (DEF_ADDRS_PER_INODE - \ F2FS_INLINE_XATTR_ADDRS - 1)) +#define MAX_FAST_SYMLINK_SIZE (MAX_INLINE_DATA + 1)struct f2fs_inode {__le16 i_mode;/* file mode */ --1.9.1
------------------------------------------------------------------------------
Dive into the World of Parallel Programming The Go Parallel Website, sponsored by Intel and developed in partnership with Slashdot Media, is your hub for all things parallel software development, from weekly thought leadership blogs to news, videos, case studies, tutorials and more. Take a look and join the conversation now. http://goparallel.sourceforge.net/
Hi Jaegeuk,
Quoted 7 lines · Jaegeuk Kim
Hi Wanpeng,
The Chao's patch is what I intended.
Could anyone of you enhance that patch?
If we useinline_databy default, we need another option to disable it. Like "noinline_data"?
Will do, thanks for you and Chao's help.
Regards,
Wanpeng Li
Quoted 169 lines
Thanks,
Quoted 165 lines · Chao Yu
Hi Wanpeng,
Quoted 36 lines
-----Original Message-----
From: Wanpeng Li [mailto:[email protected]]
Sent: Thursday, March 19, 2015 7:02 AM
To: Jaegeuk Kim
Cc: Wanpeng Li; Changman Lee; Chao Yu; [email protected]; [email protected]; [email protected]
Subject: Re: [PATCH v3] f2fs: add fast symlink supportHi Jaegeuk,
Quoted 26 lines · Jaegeuk Kim
Hi,
Quoted 23 lines · Wanpeng Li
Hi Jaegeuk,
Quoted 20 lines · Jaegeuk Kim
Quoted 4 lines
(quoted diff) +3
-1- err = page_symlink(inode, symname, symlen); + + if (symlen > MAX_FAST_SYMLINK_SIZE) { + /* slow symlink */Review
Quoted 10 lines
(quoted diff) +10
-0+ inode->i_op = &f2fs_symlink_inode_operations; + inode->i_mapping->a_ops = &f2fs_dblock_aops; + err = page_symlink(inode, symname, symlen); + } else { + /* fast symlink */ + struct page *node_page; + + inode->i_op = &f2fs_fast_symlink_inode_operations; + node_page = get_node_page(sbi, inode->i_ino); + memcpy((char *)&F2FS_INODE(node_page)->i_addr, symname, symlen);This is mostly likewise the
inline_dataflow.
As of now, I can't recommend using anyi_addrregion, since we need to handle many cases such as truncation, roll-forward recovery, and fsck/dump tools.It is more sensible to enable
inline_databy default, isn't it?Quoted 8 lines
Quoted 6 lines
Quoted 2 lines
Do you mean to replace the codes above by something like
f2fs_write_inline_data()?I meant the mount option,
inline_data.
Currently, f2fs doesn't set that option at mount time, but I thought that we can set it by default since it becomes stable.So I think you mean my codes should memcpy i_addr[1~872] instead of i_addr[0~872], right?
I think what Jaegeuk means is that we can use
inline_datain f2fs by default with patch like below firstly:Quoted 1 line
From
a7320bfe94239ea4ceb193621a3a1a4d11a40d07Mon Sep 17 00:00:00 2001From: Chao Yu <[email protected]>
Date: Thu, 19 Mar 2015 10:02:08 +0800
Subject: [PATCH] f2fs: useinline_databy defaultUse
inline_datafeature by default since it brings us better performance & space utilization and now it is already stable.Suggested-by Jaegeuk Kim <[email protected]>Signed-off-by Chao Yu <[email protected]>Signed-off-by Wanpeng Li <[email protected]>--- fs/f2fs/super.c | 1 + 1 file changed, 1 insertion(+)fs/f2fs/super.c +1
-0@@ -991,6 +991,7 @@ try_onemore: sbi->active_logs =NR_CURSEG_TYPE ;set_opt (sbi,BG_GC ); +set_opt (sbi,INLINE_DATA );#ifdef CONFIG_F2FS_FS_XATTR set_opt (sbi,XATTR_USER );Signature · 8 lines
2.3.1 Then we enable inline_data feature for symlink in f2fs_may_inline, after that by default our symlink created has inline_data flag in it, we treat small size symlink as an inline regular file, we can write its data page which is written in page_symlink into inode page like normal inline data procedure. Thanks,Quoted 78 lines
Regards,
Wanpeng LiQuoted 74 lines
Thanks,
Quoted 71 lines
Regards,
Wanpeng LiQuoted 67 lines
Thanks,
Quoted 64 lines
(quoted diff) +20
-0+ set_page_dirty(node_page); + f2fs_put_page(node_page, 1); + inode->i_size = symlen-1; + set_inode_flag(F2FS_I(inode), FI_FAST_SYMLINK); + mark_inode_dirty(inode); + } alloc_nid_done(sbi, inode->i_ino); d_instantiate(dentry, inode);@@ -743,6 +774,20 @@ const struct inode_operations f2fs_symlink_inode_operations = { #endif }; +const struct inode_operations f2fs_fast_symlink_inode_operations = { + .readlink = generic_readlink, + .follow_link = f2fs_follow_link, + .put_link = page_put_link, + .getattr = f2fs_getattr, + .setattr = f2fs_setattr, +#ifdef CONFIG_F2FS_FS_XATTR + .setxattr = generic_setxattr, + .getxattr = generic_getxattr, + .listxattr = f2fs_listxattr, + .removexattr = generic_removexattr, +#endif +}; + const struct inode_operations f2fs_special_inode_operations = { .getattr = f2fs_getattr, .setattr = f2fs_setattr,fs/f2fs/node.c +3
-2@@ -908,8 +908,9 @@ void remove_inode_page(struct inode *inode) }/* remove potential inline_data blocks */ -if (S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || -S_ISLNK (inode->i_mode)) +if ((S_ISREG (inode->i_mode) ||S_ISDIR (inode->i_mode) || +S_ISLNK (inode->i_mode)) && + !f2fs_inode_is_fast_symlink (inode))truncate_data_blocks_range (&dn,1 );/* 0 is possible, after f2fs_new_inode() has failed */ include/linux/f2fs_fs.h +2
-1@@ -178,9 +178,11 @@ struct f2fs_extent {#define F2FS_INLINE_DATA 0x02/* file inline data flag */ #define F2FS_INLINE_DENTRY 0x04/* file inline dentry flag */ #define F2FS_DATA_EXIST 0x08/* file inline data exist flag */ +#define F2FS_FAST_SYMLINK 0x10/* file fast symlink flag */ #define MAX_INLINE_DATA (sizeof(__le32) * (DEF_ADDRS_PER_INODE - \ F2FS_INLINE_XATTR_ADDRS - 1)) +#define MAX_FAST_SYMLINK_SIZE (MAX_INLINE_DATA + 1)struct f2fs_inode {__le16 i_mode;/* file mode */ --1.9.1