lkml.org 
[lkml]   [2020]   [Mar]   [3]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 5.4 062/152] bcache: ignore pending signals when creating gc and allocator thread
    Date
    From: Coly Li <colyli@suse.de>

    [ Upstream commit 0b96da639a4874311e9b5156405f69ef9fc3bef8 ]

    When run a cache set, all the bcache btree node of this cache set will
    be checked by bch_btree_check(). If the bcache btree is very large,
    iterating all the btree nodes will occupy too much system memory and
    the bcache registering process might be selected and killed by system
    OOM killer. kthread_run() will fail if current process has pending
    signal, therefore the kthread creating in run_cache_set() for gc and
    allocator kernel threads are very probably failed for a very large
    bcache btree.

    Indeed such OOM is safe and the registering process will exit after
    the registration done. Therefore this patch flushes pending signals
    during the cache set start up, specificly in bch_cache_allocator_start()
    and bch_gc_thread_start(), to make sure run_cache_set() won't fail for
    large cahced data set.

    Signed-off-by: Coly Li <colyli@suse.de>
    Signed-off-by: Jens Axboe <axboe@kernel.dk>
    Signed-off-by: Sasha Levin <sashal@kernel.org>
    ---
    drivers/md/bcache/alloc.c | 18 ++++++++++++++++--
    drivers/md/bcache/btree.c | 13 +++++++++++++
    2 files changed, 29 insertions(+), 2 deletions(-)

    diff --git a/drivers/md/bcache/alloc.c b/drivers/md/bcache/alloc.c
    index a1df0d95151c6..8bc1faf71ff2f 100644
    --- a/drivers/md/bcache/alloc.c
    +++ b/drivers/md/bcache/alloc.c
    @@ -67,6 +67,7 @@
    #include <linux/blkdev.h>
    #include <linux/kthread.h>
    #include <linux/random.h>
    +#include <linux/sched/signal.h>
    #include <trace/events/bcache.h>

    #define MAX_OPEN_BUCKETS 128
    @@ -733,8 +734,21 @@ int bch_open_buckets_alloc(struct cache_set *c)

    int bch_cache_allocator_start(struct cache *ca)
    {
    - struct task_struct *k = kthread_run(bch_allocator_thread,
    - ca, "bcache_allocator");
    + struct task_struct *k;
    +
    + /*
    + * In case previous btree check operation occupies too many
    + * system memory for bcache btree node cache, and the
    + * registering process is selected by OOM killer. Here just
    + * ignore the SIGKILL sent by OOM killer if there is, to
    + * avoid kthread_run() being failed by pending signals. The
    + * bcache registering process will exit after the registration
    + * done.
    + */
    + if (signal_pending(current))
    + flush_signals(current);
    +
    + k = kthread_run(bch_allocator_thread, ca, "bcache_allocator");
    if (IS_ERR(k))
    return PTR_ERR(k);

    diff --git a/drivers/md/bcache/btree.c b/drivers/md/bcache/btree.c
    index 46a8b5a91c386..a6e05503b7723 100644
    --- a/drivers/md/bcache/btree.c
    +++ b/drivers/md/bcache/btree.c
    @@ -34,6 +34,7 @@
    #include <linux/random.h>
    #include <linux/rcupdate.h>
    #include <linux/sched/clock.h>
    +#include <linux/sched/signal.h>
    #include <linux/rculist.h>
    #include <linux/delay.h>
    #include <trace/events/bcache.h>
    @@ -1908,6 +1909,18 @@ static int bch_gc_thread(void *arg)

    int bch_gc_thread_start(struct cache_set *c)
    {
    + /*
    + * In case previous btree check operation occupies too many
    + * system memory for bcache btree node cache, and the
    + * registering process is selected by OOM killer. Here just
    + * ignore the SIGKILL sent by OOM killer if there is, to
    + * avoid kthread_run() being failed by pending signals. The
    + * bcache registering process will exit after the registration
    + * done.
    + */
    + if (signal_pending(current))
    + flush_signals(current);
    +
    c->gc_thread = kthread_run(bch_gc_thread, c, "bcache_gc");
    return PTR_ERR_OR_ZERO(c->gc_thread);
    }
    --
    2.20.1


    \
     
     \ /
      Last update: 2020-03-03 19:08    [W:4.035 / U:1.372 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site