Commit 338a528b authored by Filipe Manana's avatar Filipe Manana Committed by Greg Kroah-Hartman

Btrfs: fix deadlock with memory reclaim during scrub

[ Upstream commit a5fb1142 ]

When a transaction commit starts, it attempts to pause scrub and it blocks
until the scrub is paused. So while the transaction is blocked waiting for
scrub to pause, we can not do memory allocation with GFP_KERNEL from scrub,
otherwise we risk getting into a deadlock with reclaim.

Checking for scrub pause requests is done early at the beginning of the
while loop of scrub_stripe() and later in the loop, scrub_extent() and
scrub_raid56_parity() are called, which in turn call scrub_pages() and
scrub_pages_for_parity() respectively. These last two functions do memory
allocations using GFP_KERNEL. Same problem could happen while scrubbing
the super blocks, since it calls scrub_pages().

We also can not have any of the worker tasks, created by the scrub task,
doing GFP_KERNEL allocations, because before pausing, the scrub task waits
for all the worker tasks to complete (also done at scrub_stripe()).

So make sure GFP_NOFS is used for the memory allocations because at any
time a scrub pause request can happen from another task that started to
commit a transaction.

Fixes: 58c4e173 ("btrfs: scrub: use GFP_KERNEL on the submission path")
CC: stable@vger.kernel.org # 4.6+
Reviewed-by: default avatarNikolay Borisov <nborisov@suse.com>
Signed-off-by: default avatarFilipe Manana <fdmanana@suse.com>
Reviewed-by: default avatarDavid Sterba <dsterba@suse.com>
Signed-off-by: default avatarDavid Sterba <dsterba@suse.com>
Signed-off-by: default avatarSasha Levin <sashal@kernel.org>
parent fac80347
...@@ -322,6 +322,7 @@ static struct full_stripe_lock *insert_full_stripe_lock( ...@@ -322,6 +322,7 @@ static struct full_stripe_lock *insert_full_stripe_lock(
struct rb_node *parent = NULL; struct rb_node *parent = NULL;
struct full_stripe_lock *entry; struct full_stripe_lock *entry;
struct full_stripe_lock *ret; struct full_stripe_lock *ret;
unsigned int nofs_flag;
lockdep_assert_held(&locks_root->lock); lockdep_assert_held(&locks_root->lock);
...@@ -339,8 +340,17 @@ static struct full_stripe_lock *insert_full_stripe_lock( ...@@ -339,8 +340,17 @@ static struct full_stripe_lock *insert_full_stripe_lock(
} }
} }
/* Insert new lock */ /*
* Insert new lock.
*
* We must use GFP_NOFS because the scrub task might be waiting for a
* worker task executing this function and in turn a transaction commit
* might be waiting the scrub task to pause (which needs to wait for all
* the worker tasks to complete before pausing).
*/
nofs_flag = memalloc_nofs_save();
ret = kmalloc(sizeof(*ret), GFP_KERNEL); ret = kmalloc(sizeof(*ret), GFP_KERNEL);
memalloc_nofs_restore(nofs_flag);
if (!ret) if (!ret)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
ret->logical = fstripe_logical; ret->logical = fstripe_logical;
...@@ -1622,8 +1632,19 @@ static int scrub_add_page_to_wr_bio(struct scrub_ctx *sctx, ...@@ -1622,8 +1632,19 @@ static int scrub_add_page_to_wr_bio(struct scrub_ctx *sctx,
mutex_lock(&sctx->wr_lock); mutex_lock(&sctx->wr_lock);
again: again:
if (!sctx->wr_curr_bio) { if (!sctx->wr_curr_bio) {
unsigned int nofs_flag;
/*
* We must use GFP_NOFS because the scrub task might be waiting
* for a worker task executing this function and in turn a
* transaction commit might be waiting the scrub task to pause
* (which needs to wait for all the worker tasks to complete
* before pausing).
*/
nofs_flag = memalloc_nofs_save();
sctx->wr_curr_bio = kzalloc(sizeof(*sctx->wr_curr_bio), sctx->wr_curr_bio = kzalloc(sizeof(*sctx->wr_curr_bio),
GFP_KERNEL); GFP_KERNEL);
memalloc_nofs_restore(nofs_flag);
if (!sctx->wr_curr_bio) { if (!sctx->wr_curr_bio) {
mutex_unlock(&sctx->wr_lock); mutex_unlock(&sctx->wr_lock);
return -ENOMEM; return -ENOMEM;
...@@ -3775,6 +3796,7 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start, ...@@ -3775,6 +3796,7 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
struct scrub_ctx *sctx; struct scrub_ctx *sctx;
int ret; int ret;
struct btrfs_device *dev; struct btrfs_device *dev;
unsigned int nofs_flag;
if (btrfs_fs_closing(fs_info)) if (btrfs_fs_closing(fs_info))
return -EINVAL; return -EINVAL;
...@@ -3878,6 +3900,16 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start, ...@@ -3878,6 +3900,16 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
atomic_inc(&fs_info->scrubs_running); atomic_inc(&fs_info->scrubs_running);
mutex_unlock(&fs_info->scrub_lock); mutex_unlock(&fs_info->scrub_lock);
/*
* In order to avoid deadlock with reclaim when there is a transaction
* trying to pause scrub, make sure we use GFP_NOFS for all the
* allocations done at btrfs_scrub_pages() and scrub_pages_for_parity()
* invoked by our callees. The pausing request is done when the
* transaction commit starts, and it blocks the transaction until scrub
* is paused (done at specific points at scrub_stripe() or right above
* before incrementing fs_info->scrubs_running).
*/
nofs_flag = memalloc_nofs_save();
if (!is_dev_replace) { if (!is_dev_replace) {
/* /*
* by holding device list mutex, we can * by holding device list mutex, we can
...@@ -3890,6 +3922,7 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start, ...@@ -3890,6 +3922,7 @@ int btrfs_scrub_dev(struct btrfs_fs_info *fs_info, u64 devid, u64 start,
if (!ret) if (!ret)
ret = scrub_enumerate_chunks(sctx, dev, start, end); ret = scrub_enumerate_chunks(sctx, dev, start, end);
memalloc_nofs_restore(nofs_flag);
wait_event(sctx->list_wait, atomic_read(&sctx->bios_in_flight) == 0); wait_event(sctx->list_wait, atomic_read(&sctx->bios_in_flight) == 0);
atomic_dec(&fs_info->scrubs_running); atomic_dec(&fs_info->scrubs_running);
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment