f2fs: Fix deadlock between f2fs_quota_sync and block_operation
Subsystems (2)
PATCH 1/1 f2fs: Fix deadlock between f2fs_quota_sync and block_operation
f2fs_quota_sync is calling f2fs_lock_op, in an attempt to prevent an AB/BA type deadlock with quota_sem locking in block_operation. However, rwsem in Linux is not recursive. As a result, the following deadlock may occur:
f2fs_quota_syncdown_read(cp_rwsem) // f2fs_lock_opfilemap_fdatawritef2fs_write_data_pages
...
block_opertaion
down_write(cp_rwsem) - marks rwsem as "writer pending"down_read_trylock(cp_rwsem) - fails as there is
a writer pending.
Code keeps on trying.
We solve this by creating a new rwsem, used specifically to synchronize this case, instead of attempting to reuse an existing lock for this
--- fs/f2fs/f2fs.h | 3 +++ fs/f2fs/super.c | 13 +++++++++++-- 2 files changed, 14 insertions(+), 2 deletions(-)
fs/f2fs/f2fs.h +3 -0
@@ -1448,6 +1448,7 @@ struct f2fs_sb_info {struct inode *meta_inode;/* cache meta blocks */ struct mutex cp_mutex;/* checkpoint procedure lock */ struct rw_semaphore cp_rwsem;/* blocking FS operations */ +struct rw_semaphore cp_quota_rwsem;/* blocking quota sync operations */ struct rw_semaphore node_write;/* locking node writes */ struct rw_semaphore node_change;/* locking node change */ wait_queue_head_t cp_wait;
@@ -1961,12 +1962,14 @@ static inline void f2fs_unlock_op(struct f2fs_sb_info *sbi)static inline void f2fs_lock_all (struct f2fs_sb_info *sbi) { +down_write (&sbi->cp_quota_rwsem);down_write (&sbi->cp_rwsem); }static inline void f2fs_unlock_all (struct f2fs_sb_info *sbi) {up_write (&sbi->cp_rwsem); +up_write (&sbi->cp_quota_rwsem); }static inline int __get_cp_reason (struct f2fs_sb_info *sbi)
fs/f2fs/super.c +11 -2
@@ -2209,8 +2209,16 @@ int f2fs_quota_sync(struct super_block *sb, int type)* f2fs_dquot_commit * block_operation * down_read(quota_sem) +* +* However, we cannot use the cp_rwsem to prevent this +* deadlock, as the cp_rwsem is taken for read inside the +* f2fs_dquot_commit code, and rwsem is not recursive. +* +* We therefore use a special lock to synchronize +* f2fs_quota_sync with block_operations, as this is the only +* place where such recurrsion occurs. */ -f2fs_lock_op (sbi); +down_read (&sbi->cp_quota_rwsem);down_read (&sbi->quota_sem); ret =dquot_writeback_dquots (sb, type);
@@ -2251,7 +2259,7 @@ int f2fs_quota_sync(struct super_block *sb, int type)if (ret)set_sbi_flag (F2FS_SB (sb),SBI_QUOTA_NEED_REPAIR );up_read (&sbi->quota_sem); -f2fs_unlock_op (sbi); +up_read (&sbi->cp_quota_rwsem);return ret; }
@@ -3599,6 +3607,7 @@ static int f2fs_fill_super(struct super_block *sb, void *data, int silent)init_rwsem (&sbi->cp_rwsem);init_rwsem (&sbi->quota_sem); +init_rwsem (&sbi->cp_quota_rwsem);init_waitqueue_head (&sbi->cp_wait);init_sb_info (sbi);
Signature · 8 lines
2.29.2 _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel