f2fs: call __add_ino_entry out of the eviction path
Jaegeuk Kim
maintainerPATCH 1/1 f2fs: call __add_ino_entry out of the eviction path
The f2fs_evict_inode() can be called during the direct reclaim path, but __add_ino_entry requires allocating some memory. Since we don't need to do that in that context, let's migrate it in other workqueue context.
--- fs/f2fs/checkpoint.c | 15 ++++++++ fs/f2fs/data.c | 13 ++++++- fs/f2fs/f2fs.h | 4 ++ fs/f2fs/inode.c | 88 +++++++++++++++++++++++++++++++++++++++++--- fs/f2fs/super.c | 9 ++++- 5 files changed, 122 insertions(+), 7 deletions(-)
fs/f2fs/checkpoint.c +15 -0
@@ -766,6 +766,15 @@ static void __remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)spin_unlock (&im->ino_lock); } +static void f2fs_wait_for_inode_record (struct f2fs_sb_info *sbi,int mode) +{ +if (mode !=APPEND_INO && mode !=UPDATE_INO ) +return ; + +/* Let's wait for some pending updates for APPEND_INO and UPDATE_INO. */ +flush_workqueue (sbi->evict_wq); +} +void f2fs_add_ino_entry (struct f2fs_sb_info *sbi,nid_t ino,int type) {/* add new dirty ino entry into list */
@@ -774,6 +783,8 @@ void f2fs_add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)void f2fs_remove_ino_entry (struct f2fs_sb_info *sbi,nid_t ino,int type) { +f2fs_wait_for_inode_record (sbi, type); +/* remove dirty ino entry from list */ __remove_ino_entry (sbi, ino, type); }
@@ -784,6 +795,8 @@ bool f2fs_exist_written_data(struct f2fs_sb_info *sbi, nid_t ino, int mode)struct inode_management *im = &sbi->im[mode];struct ino_entry *e; +f2fs_wait_for_inode_record (sbi, mode); +spin_lock (&im->ino_lock); e =radix_tree_lookup (&im->ino_root, ino);spin_unlock (&im->ino_lock);
@@ -798,6 +811,8 @@ void f2fs_release_ino_entry(struct f2fs_sb_info *sbi, bool all)for (i = all ?ORPHAN_INO :APPEND_INO ; i <MAX_INO_ENTRY ; i++) {struct inode_management *im = &sbi->im[i]; +f2fs_wait_for_inode_record (sbi, i); +spin_lock (&im->ino_lock);list_for_each_entry_safe (e, tmp, &im->ino_list, list) {list_del (&e->list);
fs/f2fs/data.c +12 -1
@@ -4558,13 +4558,24 @@ int f2fs_init_wq(struct f2fs_sb_info *sbi) { sbi->wq =alloc_workqueue ("f2fs_wq" ,WQ_UNBOUND |WQ_HIGHPRI ,num_online_cpus ()); -return sbi->wq ?0 : -ENOMEM ; +if (!sbi->wq) +return -ENOMEM ; + + sbi->evict_wq =alloc_workqueue ("f2fs_evict_wq" , +WQ_UNBOUND |WQ_HIGHPRI ,num_online_cpus ()); +if (!sbi->evict_wq) { +destroy_workqueue (sbi->wq); +return -ENOMEM ; + } +return 0 ; }void f2fs_destroy_wq (struct f2fs_sb_info *sbi) {if (sbi->wq)destroy_workqueue (sbi->wq); +if (sbi->evict_wq) +destroy_workqueue (sbi->evict_wq); }int __init f2fs_init_bio_entry_cache (void )
fs/f2fs/f2fs.h +4 -0
@@ -2016,6 +2016,8 @@ struct f2fs_sb_info {struct workqueue_struct *wq;/* bio completion workqueue */ +struct workqueue_struct *evict_wq;/* inode eviction workqueue */ +/* * If we are in irq context, let's update error information into * on-disk superblock in the work.
@@ -3875,6 +3877,8 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc);void f2fs_remove_donate_inode (struct inode *inode);void f2fs_evict_inode (struct inode *inode);void f2fs_handle_failed_inode (struct inode *inode,struct f2fs_lock_context *lc); +int f2fs_init_evict_inode_work (void ); +void f2fs_destroy_evict_inode_work (void );/* * namei.c
fs/f2fs/inode.c +83 -5
116 lines not on this page · raw message
fs/f2fs/super.c +8 -1
@@ -5763,10 +5763,16 @@ static int __init init_f2fs_fs(void) err =f2fs_init_xattr_cache ();if (err) goto free_casefold_cache; - err =register_filesystem (&f2fs_fs_type); + err =f2fs_init_evict_inode_work ();if (err) goto free_xattr_cache; + err =register_filesystem (&f2fs_fs_type); +if (err) + goto free_evict_inode_cache;return 0 ; + +free_evict_inode_cache: +f2fs_destroy_evict_inode_work (); free_xattr_cache:f2fs_destroy_xattr_cache (); free_casefold_cache:
@@ -5809,6 +5815,7 @@ static int __init init_f2fs_fs(void) static void __exit exit_f2fs_fs(void) {unregister_filesystem (&f2fs_fs_type); +f2fs_destroy_evict_inode_work ();f2fs_destroy_xattr_cache ();f2fs_destroy_casefold_cache ();f2fs_destroy_compress_cache ();
Signature · 1 line
2.55.0.571.g244d577d93-goog
Jaegeuk Kim
maintainerThe f2fs_evict_inode() can be called during the direct reclaim path, but __add_ino_entry requires allocating some memory. Since we don't need to do that in that context, let's migrate it in other workqueue context.
---
Change log from v1:
- fix a bug on the wait logic
fs/f2fs/checkpoint.c | 11 ++++++ fs/f2fs/data.c | 13 ++++++- fs/f2fs/f2fs.h | 4 ++ fs/f2fs/inode.c | 91 +++++++++++++++++++++++++++++++++++++++++--- fs/f2fs/super.c | 9 ++++- 5 files changed, 121 insertions(+), 7 deletions(-)
fs/f2fs/checkpoint.c +11 -0
@@ -766,6 +766,15 @@ static void __remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)spin_unlock (&im->ino_lock); } +static void f2fs_wait_for_inode_record (struct f2fs_sb_info *sbi,int mode) +{ +if (mode !=APPEND_INO && mode !=UPDATE_INO ) +return ; + +/* Let's wait for some pending updates for APPEND_INO and UPDATE_INO. */ +flush_workqueue (sbi->evict_wq); +} +void f2fs_add_ino_entry (struct f2fs_sb_info *sbi,nid_t ino,int type) {/* add new dirty ino entry into list */
@@ -798,6 +807,8 @@ void f2fs_release_ino_entry(struct f2fs_sb_info *sbi, bool all)for (i = all ?ORPHAN_INO :APPEND_INO ; i <MAX_INO_ENTRY ; i++) {struct inode_management *im = &sbi->im[i]; +f2fs_wait_for_inode_record (sbi, i); +spin_lock (&im->ino_lock);list_for_each_entry_safe (e, tmp, &im->ino_list, list) {list_del (&e->list);
fs/f2fs/data.c +12 -1
@@ -4558,13 +4558,24 @@ int f2fs_init_wq(struct f2fs_sb_info *sbi) { sbi->wq =alloc_workqueue ("f2fs_wq" ,WQ_UNBOUND |WQ_HIGHPRI ,num_online_cpus ()); -return sbi->wq ?0 : -ENOMEM ; +if (!sbi->wq) +return -ENOMEM ; + + sbi->evict_wq =alloc_workqueue ("f2fs_evict_wq" , +WQ_UNBOUND |WQ_HIGHPRI ,num_online_cpus ()); +if (!sbi->evict_wq) { +destroy_workqueue (sbi->wq); +return -ENOMEM ; + } +return 0 ; }void f2fs_destroy_wq (struct f2fs_sb_info *sbi) {if (sbi->wq)destroy_workqueue (sbi->wq); +if (sbi->evict_wq) +destroy_workqueue (sbi->evict_wq); }int __init f2fs_init_bio_entry_cache (void )
fs/f2fs/f2fs.h +4 -0
@@ -2016,6 +2016,8 @@ struct f2fs_sb_info {struct workqueue_struct *wq;/* bio completion workqueue */ +struct workqueue_struct *evict_wq;/* inode eviction workqueue */ +/* * If we are in irq context, let's update error information into * on-disk superblock in the work.
@@ -3875,6 +3877,8 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc);void f2fs_remove_donate_inode (struct inode *inode);void f2fs_evict_inode (struct inode *inode);void f2fs_handle_failed_inode (struct inode *inode,struct f2fs_lock_context *lc); +int f2fs_init_evict_inode_work (void ); +void f2fs_destroy_evict_inode_work (void );/* * namei.c
fs/f2fs/inode.c +86 -5
125 lines not on this page · raw message
fs/f2fs/super.c +8 -1
@@ -5763,10 +5763,16 @@ static int __init init_f2fs_fs(void) err =f2fs_init_xattr_cache ();if (err) goto free_casefold_cache; - err =register_filesystem (&f2fs_fs_type); + err =f2fs_init_evict_inode_work ();if (err) goto free_xattr_cache; + err =register_filesystem (&f2fs_fs_type); +if (err) + goto free_evict_inode_cache;return 0 ; + +free_evict_inode_cache: +f2fs_destroy_evict_inode_work (); free_xattr_cache:f2fs_destroy_xattr_cache (); free_casefold_cache:
@@ -5809,6 +5815,7 @@ static int __init init_f2fs_fs(void) static void __exit exit_f2fs_fs(void) {unregister_filesystem (&f2fs_fs_type); +f2fs_destroy_evict_inode_work ();f2fs_destroy_xattr_cache ();f2fs_destroy_casefold_cache ();f2fs_destroy_compress_cache ();
Signature · 1 line
2.55.0.571.g244d577d93-goog
Chao Yu
maintainerQuoted 189 lines · On 8/5/26 09:28, Jaegeuk Kim via Linux-f2fs-devel wrote:
The
f2fs_evict_inode()can be called during the direct reclaim path, but__add_ino_entryrequires allocating some memory. Since we don't need to do that in that context, let's migrate it in other workqueue context.Signed-off-by Jaegeuk Kim <[email protected]>---
Change log from v1:
- fix a bug on the wait logicfs/f2fs/checkpoint.c | 11 ++++++ fs/f2fs/data.c | 13 ++++++- fs/f2fs/f2fs.h | 4 ++ fs/f2fs/inode.c | 91 +++++++++++++++++++++++++++++++++++++++++--- fs/f2fs/super.c | 9 ++++- 5 files changed, 121 insertions(+), 7 deletions(-)fs/f2fs/checkpoint.c +11
-0@@ -766,6 +766,15 @@ static void __remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)spin_unlock (&im->ino_lock); } +static void f2fs_wait_for_inode_record (struct f2fs_sb_info *sbi,int mode) +{ +if (mode !=APPEND_INO && mode !=UPDATE_INO ) +return ; + +/* Let's wait for some pending updates for APPEND_INO and UPDATE_INO. */ +flush_workqueue (sbi->evict_wq); +} +void f2fs_add_ino_entry (struct f2fs_sb_info *sbi,nid_t ino,int type) {/* add new dirty ino entry into list */ @@ -798,6 +807,8 @@ void f2fs_release_ino_entry(struct f2fs_sb_info *sbi, bool all)for (i = all ?ORPHAN_INO :APPEND_INO ; i <MAX_INO_ENTRY ; i++) {struct inode_management *im = &sbi->im[i]; +f2fs_wait_for_inode_record (sbi, i); +spin_lock (&im->ino_lock);list_for_each_entry_safe (e, tmp, &im->ino_list, list) {list_del (&e->list);fs/f2fs/data.c +12
-1@@ -4558,13 +4558,24 @@ int f2fs_init_wq(struct f2fs_sb_info *sbi) { sbi->wq =alloc_workqueue ("f2fs_wq" ,WQ_UNBOUND |WQ_HIGHPRI ,num_online_cpus ()); -return sbi->wq ?0 : -ENOMEM ; +if (!sbi->wq) +return -ENOMEM ; + + sbi->evict_wq =alloc_workqueue ("f2fs_evict_wq" , +WQ_UNBOUND |WQ_HIGHPRI ,num_online_cpus ()); +if (!sbi->evict_wq) { +destroy_workqueue (sbi->wq); +return -ENOMEM ; + } +return 0 ; }void f2fs_destroy_wq (struct f2fs_sb_info *sbi) {if (sbi->wq)destroy_workqueue (sbi->wq); +if (sbi->evict_wq) +destroy_workqueue (sbi->evict_wq); }int __init f2fs_init_bio_entry_cache (void )fs/f2fs/f2fs.h +4
-0@@ -2016,6 +2016,8 @@ struct f2fs_sb_info {struct workqueue_struct *wq;/* bio completion workqueue */ +struct workqueue_struct *evict_wq;/* inode eviction workqueue */ +/* * If we are in irq context, let's update error information into * on-disk superblock in the work. @@ -3875,6 +3877,8 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc);void f2fs_remove_donate_inode (struct inode *inode);void f2fs_evict_inode (struct inode *inode);void f2fs_handle_failed_inode (struct inode *inode,struct f2fs_lock_context *lc); +int f2fs_init_evict_inode_work (void ); +void f2fs_destroy_evict_inode_work (void );/* * namei.c fs/f2fs/inode.c +51
-5@@ -24,6 +24,18 @@extern const struct address_space_operations f2fs_compress_aops;#endif +#define NUM_PREALLOC_EVICT_INODE_WORK 8 + +static struct kmem_cache *evict_inode_work_cache; +static mempool_t *evict_inode_work_pool; + +struct evict_inode_work { +struct work_struct work; +struct f2fs_sb_info *sbi; +nid_t ino; +unsigned int add_ino_entry_bits; +}; +void f2fs_mark_inode_dirty_sync (struct inode *inode,bool sync) {if (is_inode_flag_set (inode,FI_NEW_INODE ))@@ -637,6 +649,9 @@ struct inode *f2fs_iget(struct super_block *sb, unsigned long ino) inode->i_fop = &f2fs_dir_operations; inode->i_mapping->a_ops = &f2fs_dblock_aops;mapping_set_gfp_mask (inode->i_mapping,GFP_NOFS ); + +/* Let's prepare APPEND/UPDATE_INO before future access. */ +flush_workqueue (sbi->evict_wq); }else if (S_ISLNK (inode->i_mode)) {if (file_is_encrypt (inode)) inode->i_op = &f2fs_encrypted_symlink_inode_operations;@@ -854,6 +869,25 @@ void f2fs_remove_donate_inode(struct inode *inode)spin_unlock (&sbi->inode_lock[DONATE_INODE ]); } +static void f2fs_record_inode_state (struct f2fs_sb_info *sbi,nid_t ino, +unsigned int bits) +{ +if (bits &BIT (APPEND_INO )) +f2fs_add_ino_entry (sbi, ino,APPEND_INO ); +if (bits &BIT (UPDATE_INO )) +f2fs_add_ino_entry (sbi, ino,UPDATE_INO ); +} + +static void f2fs_evict_inode_work (struct work_struct *work) +{ +struct evict_inode_work *ew = + container_of(work, struct evict_inode_work, work); + +f2fs_record_inode_state (ew->sbi, ew->ino, ew->add_ino_entry_bits); + +mempool_free (ew, evict_inode_work_pool); +} +/* * Called at the last iput() if i_nlink is zero */ @@ -864,6 +898,7 @@ void f2fs_evict_inode(struct inode *inode)nid_t xnid = fi->i_xattr_nid;int err =0 ;bool freeze_protected = false; +unsigned int record_bits =0 ;f2fs_abort_atomic_write (inode, true);@@ -1003,12 +1038,32 @@ void f2fs_evict_inode(struct inode *inode) inode->i_ino);if (xnid)invalidate_mapping_pages (NODE_MAPPING (sbi), xnid, xnid); -if (inode->i_nlink) { -if (is_inode_flag_set (inode,FI_APPEND_WRITE )) -f2fs_add_ino_entry (sbi, inode->i_ino,APPEND_INO ); -if (is_inode_flag_set (inode,FI_UPDATE_WRITE )) -f2fs_add_ino_entry (sbi, inode->i_ino,UPDATE_INO ); + +if (!inode->i_nlink) + goto skip_record; + +if (is_inode_flag_set (inode,FI_APPEND_WRITE )) + record_bits =BIT (APPEND_INO ); +if (is_inode_flag_set (inode,FI_UPDATE_WRITE )) + record_bits =BIT (UPDATE_INO ); + +if (!record_bits) + goto skip_record; + +/* Let's do this in workqueue out of the direct reclaim path. */ +if (current_is_kswapd ()) { +f2fs_record_inode_state (sbi, inode->i_ino, record_bits); + }else {
fs/f2fs/inode.c void f2fs_evict_inode(struct inode *inode) · line 1066
Quoted 10 lines
fs/f2fs/inode.c +9
-0+struct evict_inode_work *ew = +mempool_alloc (evict_inode_work_pool,GFP_NOFS ); + + ew->sbi = sbi; + ew->ino = inode->i_ino; + ew->add_ino_entry_bits = record_bits; +INIT_WORK (&ew->work, f2fs_evict_inode_work); +queue_work (sbi->evict_wq, &ew->work); } +skip_record:
What do you think of wrapping above codes into a static function for cleanup?
Thanks,
Quoted 63 lines
fs/f2fs/inode.c +26
-0if (is_inode_flag_set (inode,FI_FREE_NID )) {f2fs_alloc_nid_failed (sbi, inode->i_ino);clear_inode_flag (inode,FI_FREE_NID );@@ -1079,3 +1134,29 @@ void f2fs_handle_failed_inode(struct inode *inode, struct f2fs_lock_context *lc)/* iput will drop the inode object */ iput (inode); } + +int __init f2fs_init_evict_inode_work (void ) +{ + evict_inode_work_cache = +kmem_cache_create ("f2fs_evict_inode_work" , +sizeof (struct evict_inode_work ),0 ,0 ,NULL ); +if (!evict_inode_work_cache) + goto fail; + evict_inode_work_pool = +mempool_create_slab_pool (NUM_PREALLOC_EVICT_INODE_WORK , + evict_inode_work_cache); +if (!evict_inode_work_pool) + goto fail_free_cache; +return 0 ; + +fail_free_cache: +kmem_cache_destroy (evict_inode_work_cache); +fail: +return -ENOMEM ; +} + +void f2fs_destroy_evict_inode_work (void ) +{ +mempool_destroy (evict_inode_work_pool); +kmem_cache_destroy (evict_inode_work_cache); +}fs/f2fs/super.c +8
-1@@ -5763,10 +5763,16 @@ static int __init init_f2fs_fs(void) err =f2fs_init_xattr_cache ();if (err) goto free_casefold_cache; - err =register_filesystem (&f2fs_fs_type); + err =f2fs_init_evict_inode_work ();if (err) goto free_xattr_cache; + err =register_filesystem (&f2fs_fs_type); +if (err) + goto free_evict_inode_cache;return 0 ; + +free_evict_inode_cache: +f2fs_destroy_evict_inode_work (); free_xattr_cache:f2fs_destroy_xattr_cache (); free_casefold_cache:@@ -5809,6 +5815,7 @@ static int __init init_f2fs_fs(void) static void __exit exit_f2fs_fs(void) {unregister_filesystem (&f2fs_fs_type); +f2fs_destroy_evict_inode_work ();f2fs_destroy_xattr_cache ();f2fs_destroy_casefold_cache ();f2fs_destroy_compress_cache ();
Jaegeuk Kim
maintainerQuoted 194 lines · On 08/06, Chao Yu via Linux-f2fs-devel wrote:
Quoted 193 lines · On 8/5/26 09:28, Jaegeuk Kim via Linux-f2fs-devel wrote:
The
f2fs_evict_inode()can be called during the direct reclaim path, but__add_ino_entryrequires allocating some memory. Since we don't need to do that in that context, let's migrate it in other workqueue context.Signed-off-by Jaegeuk Kim <[email protected]>---
Change log from v1:
- fix a bug on the wait logicfs/f2fs/checkpoint.c | 11 ++++++ fs/f2fs/data.c | 13 ++++++- fs/f2fs/f2fs.h | 4 ++ fs/f2fs/inode.c | 91 +++++++++++++++++++++++++++++++++++++++++--- fs/f2fs/super.c | 9 ++++- 5 files changed, 121 insertions(+), 7 deletions(-)fs/f2fs/checkpoint.c +11
-0@@ -766,6 +766,15 @@ static void __remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)spin_unlock (&im->ino_lock); } +static void f2fs_wait_for_inode_record (struct f2fs_sb_info *sbi,int mode) +{ +if (mode !=APPEND_INO && mode !=UPDATE_INO ) +return ; + +/* Let's wait for some pending updates for APPEND_INO and UPDATE_INO. */ +flush_workqueue (sbi->evict_wq); +} +void f2fs_add_ino_entry (struct f2fs_sb_info *sbi,nid_t ino,int type) {/* add new dirty ino entry into list */ @@ -798,6 +807,8 @@ void f2fs_release_ino_entry(struct f2fs_sb_info *sbi, bool all)for (i = all ?ORPHAN_INO :APPEND_INO ; i <MAX_INO_ENTRY ; i++) {struct inode_management *im = &sbi->im[i]; +f2fs_wait_for_inode_record (sbi, i); +spin_lock (&im->ino_lock);list_for_each_entry_safe (e, tmp, &im->ino_list, list) {list_del (&e->list);fs/f2fs/data.c +12
-1@@ -4558,13 +4558,24 @@ int f2fs_init_wq(struct f2fs_sb_info *sbi) { sbi->wq =alloc_workqueue ("f2fs_wq" ,WQ_UNBOUND |WQ_HIGHPRI ,num_online_cpus ()); -return sbi->wq ?0 : -ENOMEM ; +if (!sbi->wq) +return -ENOMEM ; + + sbi->evict_wq =alloc_workqueue ("f2fs_evict_wq" , +WQ_UNBOUND |WQ_HIGHPRI ,num_online_cpus ()); +if (!sbi->evict_wq) { +destroy_workqueue (sbi->wq); +return -ENOMEM ; + } +return 0 ; }void f2fs_destroy_wq (struct f2fs_sb_info *sbi) {if (sbi->wq)destroy_workqueue (sbi->wq); +if (sbi->evict_wq) +destroy_workqueue (sbi->evict_wq); }int __init f2fs_init_bio_entry_cache (void )fs/f2fs/f2fs.h +4
-0@@ -2016,6 +2016,8 @@ struct f2fs_sb_info {struct workqueue_struct *wq;/* bio completion workqueue */ +struct workqueue_struct *evict_wq;/* inode eviction workqueue */ +/* * If we are in irq context, let's update error information into * on-disk superblock in the work. @@ -3875,6 +3877,8 @@ int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc);void f2fs_remove_donate_inode (struct inode *inode);void f2fs_evict_inode (struct inode *inode);void f2fs_handle_failed_inode (struct inode *inode,struct f2fs_lock_context *lc); +int f2fs_init_evict_inode_work (void ); +void f2fs_destroy_evict_inode_work (void );/* * namei.c fs/f2fs/inode.c +55
-5@@ -24,6 +24,18 @@extern const struct address_space_operations f2fs_compress_aops;#endif +#define NUM_PREALLOC_EVICT_INODE_WORK 8 + +static struct kmem_cache *evict_inode_work_cache; +static mempool_t *evict_inode_work_pool; + +struct evict_inode_work { +struct work_struct work; +struct f2fs_sb_info *sbi; +nid_t ino; +unsigned int add_ino_entry_bits; +}; +void f2fs_mark_inode_dirty_sync (struct inode *inode,bool sync) {if (is_inode_flag_set (inode,FI_NEW_INODE ))@@ -637,6 +649,9 @@ struct inode *f2fs_iget(struct super_block *sb, unsigned long ino) inode->i_fop = &f2fs_dir_operations; inode->i_mapping->a_ops = &f2fs_dblock_aops;mapping_set_gfp_mask (inode->i_mapping,GFP_NOFS ); + +/* Let's prepare APPEND/UPDATE_INO before future access. */ +flush_workqueue (sbi->evict_wq); }else if (S_ISLNK (inode->i_mode)) {if (file_is_encrypt (inode)) inode->i_op = &f2fs_encrypted_symlink_inode_operations;@@ -854,6 +869,25 @@ void f2fs_remove_donate_inode(struct inode *inode)spin_unlock (&sbi->inode_lock[DONATE_INODE ]); } +static void f2fs_record_inode_state (struct f2fs_sb_info *sbi,nid_t ino, +unsigned int bits) +{ +if (bits &BIT (APPEND_INO )) +f2fs_add_ino_entry (sbi, ino,APPEND_INO ); +if (bits &BIT (UPDATE_INO )) +f2fs_add_ino_entry (sbi, ino,UPDATE_INO ); +} + +static void f2fs_evict_inode_work (struct work_struct *work) +{ +struct evict_inode_work *ew = + container_of(work, struct evict_inode_work, work); + +f2fs_record_inode_state (ew->sbi, ew->ino, ew->add_ino_entry_bits); + +mempool_free (ew, evict_inode_work_pool); +} +/* * Called at the last iput() if i_nlink is zero */ @@ -864,6 +898,7 @@ void f2fs_evict_inode(struct inode *inode)nid_t xnid = fi->i_xattr_nid;int err =0 ;bool freeze_protected = false; +unsigned int record_bits =0 ;f2fs_abort_atomic_write (inode, true);@@ -1003,12 +1038,32 @@ void f2fs_evict_inode(struct inode *inode) inode->i_ino);if (xnid)invalidate_mapping_pages (NODE_MAPPING (sbi), xnid, xnid); -if (inode->i_nlink) { -if (is_inode_flag_set (inode,FI_APPEND_WRITE )) -f2fs_add_ino_entry (sbi, inode->i_ino,APPEND_INO ); -if (is_inode_flag_set (inode,FI_UPDATE_WRITE )) -f2fs_add_ino_entry (sbi, inode->i_ino,UPDATE_INO ); + +if (!inode->i_nlink) + goto skip_record; + +if (is_inode_flag_set (inode,FI_APPEND_WRITE )) + record_bits =BIT (APPEND_INO ); +if (is_inode_flag_set (inode,FI_UPDATE_WRITE )) + record_bits =BIT (UPDATE_INO ); + +if (!record_bits) + goto skip_record; + +/* Let's do this in workqueue out of the direct reclaim path. */ +if (current_is_kswapd ()) { +f2fs_record_inode_state (sbi, inode->i_ino, record_bits); + }else { +struct evict_inode_work *ew = +mempool_alloc (evict_inode_work_pool,GFP_NOFS ); + + ew->sbi = sbi;
Quoted 8 lines
fs/f2fs/inode.c void f2fs_evict_inode(struct inode *inode) · line 1066
Quoted 6 lines
fs/f2fs/inode.c +5
-0+ ew->ino = inode->i_ino; + ew->add_ino_entry_bits = record_bits; +INIT_WORK (&ew->work, f2fs_evict_inode_work); +queue_work (sbi->evict_wq, &ew->work); } +skip_record:What do you think of wrapping above codes into a static function for cleanup?
Sumbitted another patch series having the refactoring patch. Thanks,
Quoted 73 lines
Thanks,
Quoted 56 lines
fs/f2fs/inode.c +26
-0if (is_inode_flag_set (inode,FI_FREE_NID )) {f2fs_alloc_nid_failed (sbi, inode->i_ino);clear_inode_flag (inode,FI_FREE_NID );@@ -1079,3 +1134,29 @@ void f2fs_handle_failed_inode(struct inode *inode, struct f2fs_lock_context *lc)/* iput will drop the inode object */ iput (inode); } + +int __init f2fs_init_evict_inode_work (void ) +{ + evict_inode_work_cache = +kmem_cache_create ("f2fs_evict_inode_work" , +sizeof (struct evict_inode_work ),0 ,0 ,NULL ); +if (!evict_inode_work_cache) + goto fail; + evict_inode_work_pool = +mempool_create_slab_pool (NUM_PREALLOC_EVICT_INODE_WORK , + evict_inode_work_cache); +if (!evict_inode_work_pool) + goto fail_free_cache; +return 0 ; + +fail_free_cache: +kmem_cache_destroy (evict_inode_work_cache); +fail: +return -ENOMEM ; +} + +void f2fs_destroy_evict_inode_work (void ) +{ +mempool_destroy (evict_inode_work_pool); +kmem_cache_destroy (evict_inode_work_cache); +}fs/f2fs/super.c +7
-1@@ -5763,10 +5763,16 @@ static int __init init_f2fs_fs(void) err =f2fs_init_xattr_cache ();if (err) goto free_casefold_cache; - err =register_filesystem (&f2fs_fs_type); + err =f2fs_init_evict_inode_work ();if (err) goto free_xattr_cache; + err =register_filesystem (&f2fs_fs_type); +if (err) + goto free_evict_inode_cache;return 0 ; + +free_evict_inode_cache: +f2fs_destroy_evict_inode_work (); free_xattr_cache:f2fs_destroy_xattr_cache (); free_casefold_cache:fs/f2fs/super.c static int __init init_f2fs_fs(void) · line 5821
Quoted 7 lines
fs/f2fs/super.c +1
-0@@ -5809,6 +5815,7 @@ static int __init init_f2fs_fs(void) static void __exit exit_f2fs_fs(void) {unregister_filesystem (&f2fs_fs_type); +f2fs_destroy_evict_inode_work ();f2fs_destroy_xattr_cache ();f2fs_destroy_casefold_cache ();f2fs_destroy_compress_cache ();_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
kernel test robot
build botkernel test robot noticed the following build errors:
Hi Jaegeuk,
kernel test robot noticed the following build errors:
[auto build test ERROR on v7.2-rc7]
[also build test ERROR on linus/master]
[cannot apply to jaegeuk-f2fs/dev-test jaegeuk-f2fs/dev next-20260814] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Jaegeuk-Kim/f2fs-call-__add_ino_entry-out-of-the-eviction-path/20260815-151820 base: v7.2-rc7 patch link: https://lore.kernel.org/r/20260804002027.2196300-1-jaegeuk%40kernel.org patch subject: [PATCH] f2fs: call __add_ino_entry out of the eviction path config: x86_64-kexec (https://download.01.org/0day-ci/archive/20260816/[email protected]/config) compiler: clang version 22.1.8 (https://github.com/llvm/llvm-project ca7933e47d3a3451d81e72ac174dcb5aa28b59d1) reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260816/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All errors (new ones prefixed by >>):
>> fs/f2fs/inode.c:1051:6: error: call to undeclared function 'current_is_kswapd'; ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]
1051 | if (current_is_kswapd()) {
| ^1 error generated.
vim +/current_is_kswapd +1051 fs/f2fs/inode.c
887
888 /*
889 * Called at the last iput() if i_nlink is zero
890 */
891 void f2fs_evict_inode(struct inode *inode)
892 {
893 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
894 struct f2fs_inode_info *fi = F2FS_I(inode);
895 nid_t xnid = fi->i_xattr_nid;
896 int err = 0;
897 bool freeze_protected = false;
898 unsigned int record_bits = 0;
899
900 f2fs_abort_atomic_write(inode, true);
901
902 if (fi->cow_inode && f2fs_is_cow_file(fi->cow_inode)) {
903 struct inode *cow_inode = fi->cow_inode;
904
905 f2fs_down_write(&F2FS_I(cow_inode)->i_sem);
906 clear_inode_flag(cow_inode, FI_COW_FILE);
907 F2FS_I(cow_inode)->atomic_inode = NULL;
908 fi->cow_inode = NULL;
909 f2fs_up_write(&F2FS_I(cow_inode)->i_sem);
910
911 iput(cow_inode);
912 }
913
914 trace_f2fs_evict_inode(inode);
915 truncate_inode_pages_final(&inode->i_data);
916
917 if ((inode->i_nlink || is_bad_inode(inode)) &&
918 test_opt(sbi, COMPRESS_CACHE) && f2fs_compressed_file(inode))
919 f2fs_invalidate_compress_pages(sbi, inode->i_ino);
920
921 if (inode->i_ino == F2FS_NODE_INO(sbi) ||
922 inode->i_ino == F2FS_META_INO(sbi) ||
923 inode->i_ino == F2FS_COMPRESS_INO(sbi))
924 goto out_clear;
925
926 f2fs_bug_on(sbi, get_dirty_pages(inode));
927 f2fs_remove_dirty_inode(inode);
928 f2fs_remove_donate_inode(inode);
929
930 if (!IS_DEVICE_ALIASING(inode))
931 f2fs_destroy_extent_tree(inode);
932
933 if (inode->i_nlink || is_bad_inode(inode))
934 goto no_delete;
935
936 err = f2fs_dquot_initialize(inode);
937 if (err) {
938 err = 0;
939 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
940 }
941
942 f2fs_remove_ino_entry(sbi, inode->i_ino, APPEND_INO);
943 f2fs_remove_ino_entry(sbi, inode->i_ino, UPDATE_INO);
944 f2fs_remove_ino_entry(sbi, inode->i_ino, FLUSH_INO);
945
946 if (!is_sbi_flag_set(sbi, SBI_IS_FREEZING)) {
947 sb_start_intwrite(inode->i_sb);
948 freeze_protected = true;
949 }
950 set_inode_flag(inode, FI_NO_ALLOC);
951 i_size_write(inode, 0);
952 retry:
953 if (F2FS_HAS_BLOCKS(inode))
954 err = f2fs_truncate(inode);
955
956 if (time_to_inject(sbi, FAULT_EVICT_INODE))
957 err = -EIO;
958
959 if (!err) {
960 struct f2fs_lock_context lc;
961
962 f2fs_lock_op(sbi, &lc);
963 err = f2fs_remove_inode_page(inode);
964 f2fs_unlock_op(sbi, &lc);
965 if (err == -ENOENT) {
966 err = 0;
967
968 /*
969 * in fuzzed image, another node may has the same
970 * block address as inode's, if it was truncated
971 * previously, truncation of inode node will fail.
972 */
973 if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {
974 f2fs_warn(F2FS_I_SB(inode),
975 "f2fs_evict_inode: inconsistent node id, ino:%llu",
976 inode->i_ino);
977 f2fs_inode_synced(inode);
978 set_sbi_flag(sbi, SBI_NEED_FSCK);
979 }
980 }
981 }
982
983 /* give more chances, if ENOMEM case */
984 if (err == -ENOMEM) {
985 err = 0;
986 goto retry;
987 }
988
989 if (IS_DEVICE_ALIASING(inode))
990 f2fs_destroy_extent_tree(inode);
991
992 if (err) {
993 f2fs_update_inode_page(inode);
994 if (dquot_initialize_needed(inode))
995 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
996
997 /*
998 * If both f2fs_truncate() and f2fs_update_inode_page() failed
999 * due to fuzzed corrupted inode, call f2fs_inode_synced() to
1000 * avoid triggering later f2fs_bug_on().
1001 */
1002 if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {
1003 f2fs_warn(sbi,
1004 "f2fs_evict_inode: inode is dirty, ino:%llu",
1005 inode->i_ino);
1006 f2fs_inode_synced(inode);
1007 set_sbi_flag(sbi, SBI_NEED_FSCK);
1008 }
1009 }
1010 if (freeze_protected)
1011 sb_end_intwrite(inode->i_sb);
1012 no_delete:
1013 dquot_drop(inode);
1014
1015 stat_dec_inline_xattr(inode);
1016 stat_dec_inline_dir(inode);
1017 stat_dec_inline_inode(inode);
1018 stat_dec_compr_inode(inode);
1019 stat_sub_compr_blocks(inode,
1020 atomic_read(&fi->i_compr_blocks));
1021
1022 if (likely(!f2fs_cp_error(sbi) &&
1023 !is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
1024 f2fs_bug_on(sbi, is_inode_flag_set(inode, FI_DIRTY_INODE));
1025
1026 /*
1027 * anyway, it needs to remove the inode from sbi->inode_list[DIRTY_META]
1028 * list to avoid UAF in f2fs_sync_inode_meta() during checkpoint.
1029 */
1030 f2fs_inode_synced(inode);
1031
1032 /* for the case f2fs_new_inode() was failed, .i_ino is zero, skip it */
1033 if (inode->i_ino)
1034 invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino,
1035 inode->i_ino);
1036 if (xnid)
1037 invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid);
1038
1039 if (!inode->i_nlink)
1040 goto skip_record;
1041
1042 if (is_inode_flag_set(inode, FI_APPEND_WRITE))
1043 record_bits = BIT(APPEND_INO);
1044 if (is_inode_flag_set(inode, FI_UPDATE_WRITE))
1045 record_bits = BIT(UPDATE_INO);
1046
1047 if (!record_bits)
1048 goto skip_record;
1049
1050 /* Let's do this in workqueue out of the direct reclaim path. */
> 1051 if (current_is_kswapd()) { 1052 f2fs_record_inode_state(sbi, inode->i_ino, record_bits);
1053 } else {
1054 struct evict_inode_work *ew =
1055 mempool_alloc(evict_inode_work_pool, GFP_NOFS);
1056
1057 ew->sbi = sbi;
1058 ew->ino = inode->i_ino;
1059 ew->add_ino_entry_bits = record_bits;
1060 INIT_WORK(&ew->work, f2fs_evict_inode_work);
1061 queue_work(sbi->evict_wq, &ew->work);
1062 }
1063 skip_record:
1064 if (is_inode_flag_set(inode, FI_FREE_NID)) {
1065 f2fs_alloc_nid_failed(sbi, inode->i_ino);
1066 clear_inode_flag(inode, FI_FREE_NID);
1067 } else {
1068 /*
1069 * If xattr nid is corrupted, we can reach out error condition,
1070 * err & !f2fs_exist_written_data(sbi, inode->i_ino, ORPHAN_INO)).
1071 * In that case, f2fs_check_nid_range() is enough to give a clue.
1072 */
1073 }
1074 out_clear:
1075 fscrypt_put_encryption_info(inode);
1076 clear_inode(inode);
1077 }
1078
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
kernel test robot
build botkernel test robot noticed the following build errors:
Hi Jaegeuk,
kernel test robot noticed the following build errors:
[auto build test ERROR on v7.2-rc7]
[also build test ERROR on linus/master]
[cannot apply to jaegeuk-f2fs/dev-test jaegeuk-f2fs/dev next-20260817] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Jaegeuk-Kim/f2fs-call-__add_ino_entry-out-of-the-eviction-path/20260815-151820 base: v7.2-rc7 patch link: https://lore.kernel.org/r/20260804002027.2196300-1-jaegeuk%40kernel.org patch subject: [PATCH] f2fs: call __add_ino_entry out of the eviction path config: x86_64-kexec (https://download.01.org/0day-ci/archive/20260818/[email protected]/config) compiler: clang version 22.1.3 (https://github.com/llvm/llvm-project e9846648fd6183ee6d8cbdb4502213fcf902a211) reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260818/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All errors (new ones prefixed by >>):
>> fs/f2fs/inode.c:1051:6: error: call to undeclared function 'current_is_kswapd'; ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]
1051 | if (current_is_kswapd()) {
| ^1 error generated.
vim +/current_is_kswapd +1051 fs/f2fs/inode.c
887
888 /*
889 * Called at the last iput() if i_nlink is zero
890 */
891 void f2fs_evict_inode(struct inode *inode)
892 {
893 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
894 struct f2fs_inode_info *fi = F2FS_I(inode);
895 nid_t xnid = fi->i_xattr_nid;
896 int err = 0;
897 bool freeze_protected = false;
898 unsigned int record_bits = 0;
899
900 f2fs_abort_atomic_write(inode, true);
901
902 if (fi->cow_inode && f2fs_is_cow_file(fi->cow_inode)) {
903 struct inode *cow_inode = fi->cow_inode;
904
905 f2fs_down_write(&F2FS_I(cow_inode)->i_sem);
906 clear_inode_flag(cow_inode, FI_COW_FILE);
907 F2FS_I(cow_inode)->atomic_inode = NULL;
908 fi->cow_inode = NULL;
909 f2fs_up_write(&F2FS_I(cow_inode)->i_sem);
910
911 iput(cow_inode);
912 }
913
914 trace_f2fs_evict_inode(inode);
915 truncate_inode_pages_final(&inode->i_data);
916
917 if ((inode->i_nlink || is_bad_inode(inode)) &&
918 test_opt(sbi, COMPRESS_CACHE) && f2fs_compressed_file(inode))
919 f2fs_invalidate_compress_pages(sbi, inode->i_ino);
920
921 if (inode->i_ino == F2FS_NODE_INO(sbi) ||
922 inode->i_ino == F2FS_META_INO(sbi) ||
923 inode->i_ino == F2FS_COMPRESS_INO(sbi))
924 goto out_clear;
925
926 f2fs_bug_on(sbi, get_dirty_pages(inode));
927 f2fs_remove_dirty_inode(inode);
928 f2fs_remove_donate_inode(inode);
929
930 if (!IS_DEVICE_ALIASING(inode))
931 f2fs_destroy_extent_tree(inode);
932
933 if (inode->i_nlink || is_bad_inode(inode))
934 goto no_delete;
935
936 err = f2fs_dquot_initialize(inode);
937 if (err) {
938 err = 0;
939 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
940 }
941
942 f2fs_remove_ino_entry(sbi, inode->i_ino, APPEND_INO);
943 f2fs_remove_ino_entry(sbi, inode->i_ino, UPDATE_INO);
944 f2fs_remove_ino_entry(sbi, inode->i_ino, FLUSH_INO);
945
946 if (!is_sbi_flag_set(sbi, SBI_IS_FREEZING)) {
947 sb_start_intwrite(inode->i_sb);
948 freeze_protected = true;
949 }
950 set_inode_flag(inode, FI_NO_ALLOC);
951 i_size_write(inode, 0);
952 retry:
953 if (F2FS_HAS_BLOCKS(inode))
954 err = f2fs_truncate(inode);
955
956 if (time_to_inject(sbi, FAULT_EVICT_INODE))
957 err = -EIO;
958
959 if (!err) {
960 struct f2fs_lock_context lc;
961
962 f2fs_lock_op(sbi, &lc);
963 err = f2fs_remove_inode_page(inode);
964 f2fs_unlock_op(sbi, &lc);
965 if (err == -ENOENT) {
966 err = 0;
967
968 /*
969 * in fuzzed image, another node may has the same
970 * block address as inode's, if it was truncated
971 * previously, truncation of inode node will fail.
972 */
973 if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {
974 f2fs_warn(F2FS_I_SB(inode),
975 "f2fs_evict_inode: inconsistent node id, ino:%llu",
976 inode->i_ino);
977 f2fs_inode_synced(inode);
978 set_sbi_flag(sbi, SBI_NEED_FSCK);
979 }
980 }
981 }
982
983 /* give more chances, if ENOMEM case */
984 if (err == -ENOMEM) {
985 err = 0;
986 goto retry;
987 }
988
989 if (IS_DEVICE_ALIASING(inode))
990 f2fs_destroy_extent_tree(inode);
991
992 if (err) {
993 f2fs_update_inode_page(inode);
994 if (dquot_initialize_needed(inode))
995 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
996
997 /*
998 * If both f2fs_truncate() and f2fs_update_inode_page() failed
999 * due to fuzzed corrupted inode, call f2fs_inode_synced() to
1000 * avoid triggering later f2fs_bug_on().
1001 */
1002 if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {
1003 f2fs_warn(sbi,
1004 "f2fs_evict_inode: inode is dirty, ino:%llu",
1005 inode->i_ino);
1006 f2fs_inode_synced(inode);
1007 set_sbi_flag(sbi, SBI_NEED_FSCK);
1008 }
1009 }
1010 if (freeze_protected)
1011 sb_end_intwrite(inode->i_sb);
1012 no_delete:
1013 dquot_drop(inode);
1014
1015 stat_dec_inline_xattr(inode);
1016 stat_dec_inline_dir(inode);
1017 stat_dec_inline_inode(inode);
1018 stat_dec_compr_inode(inode);
1019 stat_sub_compr_blocks(inode,
1020 atomic_read(&fi->i_compr_blocks));
1021
1022 if (likely(!f2fs_cp_error(sbi) &&
1023 !is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
1024 f2fs_bug_on(sbi, is_inode_flag_set(inode, FI_DIRTY_INODE));
1025
1026 /*
1027 * anyway, it needs to remove the inode from sbi->inode_list[DIRTY_META]
1028 * list to avoid UAF in f2fs_sync_inode_meta() during checkpoint.
1029 */
1030 f2fs_inode_synced(inode);
1031
1032 /* for the case f2fs_new_inode() was failed, .i_ino is zero, skip it */
1033 if (inode->i_ino)
1034 invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino,
1035 inode->i_ino);
1036 if (xnid)
1037 invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid);
1038
1039 if (!inode->i_nlink)
1040 goto skip_record;
1041
1042 if (is_inode_flag_set(inode, FI_APPEND_WRITE))
1043 record_bits = BIT(APPEND_INO);
1044 if (is_inode_flag_set(inode, FI_UPDATE_WRITE))
1045 record_bits = BIT(UPDATE_INO);
1046
1047 if (!record_bits)
1048 goto skip_record;
1049
1050 /* Let's do this in workqueue out of the direct reclaim path. */
> 1051 if (current_is_kswapd()) { 1052 f2fs_record_inode_state(sbi, inode->i_ino, record_bits);
1053 } else {
1054 struct evict_inode_work *ew =
1055 mempool_alloc(evict_inode_work_pool, GFP_NOFS);
1056
1057 ew->sbi = sbi;
1058 ew->ino = inode->i_ino;
1059 ew->add_ino_entry_bits = record_bits;
1060 INIT_WORK(&ew->work, f2fs_evict_inode_work);
1061 queue_work(sbi->evict_wq, &ew->work);
1062 }
1063 skip_record:
1064 if (is_inode_flag_set(inode, FI_FREE_NID)) {
1065 f2fs_alloc_nid_failed(sbi, inode->i_ino);
1066 clear_inode_flag(inode, FI_FREE_NID);
1067 } else {
1068 /*
1069 * If xattr nid is corrupted, we can reach out error condition,
1070 * err & !f2fs_exist_written_data(sbi, inode->i_ino, ORPHAN_INO)).
1071 * In that case, f2fs_check_nid_range() is enough to give a clue.
1072 */
1073 }
1074 out_clear:
1075 fscrypt_put_encryption_info(inode);
1076 clear_inode(inode);
1077 }
1078
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki