From patchwork Thu Jan 10 03:19:27 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mauricio Faria de Oliveira X-Patchwork-Id: 1022692 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=lists.ubuntu.com (client-ip=91.189.94.19; helo=huckleberry.canonical.com; envelope-from=kernel-team-bounces@lists.ubuntu.com; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=none dis=none) header.from=canonical.com Received: from huckleberry.canonical.com (huckleberry.canonical.com [91.189.94.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 43Zrq936Svz9sNs; Thu, 10 Jan 2019 14:20:36 +1100 (AEDT) Received: from localhost ([127.0.0.1] helo=huckleberry.canonical.com) by huckleberry.canonical.com with esmtp (Exim 4.86_2) (envelope-from ) id 1ghQtS-0000GY-OT; Thu, 10 Jan 2019 03:20:30 +0000 Received: from youngberry.canonical.com ([91.189.89.112]) by huckleberry.canonical.com with esmtps (TLS1.0:DHE_RSA_AES_128_CBC_SHA1:128) (Exim 4.86_2) (envelope-from ) id 1ghQtN-0000B9-Vo for kernel-team@lists.ubuntu.com; Thu, 10 Jan 2019 03:20:26 +0000 Received: from mail-qk1-f200.google.com ([209.85.222.200]) by youngberry.canonical.com with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.76) (envelope-from ) id 1ghQtM-00014B-Nr for kernel-team@lists.ubuntu.com; Thu, 10 Jan 2019 03:20:24 +0000 Received: by mail-qk1-f200.google.com with SMTP id u197so8068067qka.8 for ; Wed, 09 Jan 2019 19:20:24 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references; bh=DhqmZTnBwjLkM2HprUYZqykZAYIjmECXz46EE/o6KXU=; b=MOTWUXqrST2X9U0pU57QtL1jUOYMmIZydT0fXnTmMUX5JMcTaezgMVhWNNTTBWZfAM 0ywuphf3mZ2UzOIj8dlDgJb3QPTnbWy1PhM2Y0L9uVTSJ9YI/enGitjb7q6oPMSJ99VL kbMtydwVTFSsyYlGzYT72Qn97eknSxVp9FlSvk79XQ8gUpwHZp45F/mOzRSQ6c7bQ0oJ uZDkJ6SQcv5spcCDxFKe/Itw7K6lCSsbI6G2PHuc8A/n4ZwFardNEv6VDb4jGjsxqYBJ L2q7X1Iq8tjgXlOBQIDaf7kyqi4m/LhsCQDqveBc1qaUd1Uptilnwa31Q74KhZkuVgYr DWvg== X-Gm-Message-State: AJcUukeoss78P9PRUXMoRqgyAAp8XTDZnFZjWUdI3hUnc3Wx/ZsKei/Z J2mzmBcWujNgduAp0MeXBPM6n/7x0d6PQWFiJ5l7hjD7TYr/MmDy+adQkhiV3cT5gJc6XO7+f2y ms5MjMkGglitlc5gGNevbHQUh3KbMKBMCG465pE5tRQ== X-Received: by 2002:a37:4953:: with SMTP id w80mr7689426qka.238.1547090423691; Wed, 09 Jan 2019 19:20:23 -0800 (PST) X-Google-Smtp-Source: ALg8bN5f8R1/idhaMmzI/Rs8xny/pePeCI52uBfNaGkxqMpi+nxsFb/eJUpgPyXeNk33aSzpf8/oBg== X-Received: by 2002:a37:4953:: with SMTP id w80mr7689418qka.238.1547090423484; Wed, 09 Jan 2019 19:20:23 -0800 (PST) Received: from localhost.localdomain ([177.181.227.0]) by smtp.gmail.com with ESMTPSA id e129sm32371961qkf.85.2019.01.09.19.20.22 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 09 Jan 2019 19:20:23 -0800 (PST) From: Mauricio Faria de Oliveira To: kernel-team@lists.ubuntu.com Subject: [SRU C][PATCH 7/8] blk-wbt: improve waking of tasks Date: Thu, 10 Jan 2019 01:19:27 -0200 Message-Id: <20190110031928.30981-8-mfo@canonical.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20190110031928.30981-1-mfo@canonical.com> References: <20190110031928.30981-1-mfo@canonical.com> X-BeenThere: kernel-team@lists.ubuntu.com X-Mailman-Version: 2.1.20 Precedence: list List-Id: Kernel team discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Errors-To: kernel-team-bounces@lists.ubuntu.com Sender: "kernel-team" From: Jens Axboe BugLink: https://bugs.launchpad.net/bugs/1810998 We have two potential issues: 1) After commit 2887e41b910b, we only wake one process at the time when we finish an IO. We really want to wake up as many tasks as can queue IO. Before this commit, we woke up everyone, which could cause a thundering herd issue. 2) A task can potentially consume two wakeups, causing us to (in practice) miss a wakeup. Fix both by providing our own wakeup function, which stops __wake_up_common() from waking up more tasks if we fail to get a queueing token. With the strict ordering we have on the wait list, this wakes the right tasks and the right amount of tasks. Based on a patch from Jianchao Wang . Tested-by: Agarwal, Anchal Signed-off-by: Jens Axboe (cherry picked from commit 38cfb5a45ee013bfab5d1ae4c4738815e744b440) Signed-off-by: Mauricio Faria de Oliveira --- block/blk-wbt.c | 63 +++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 56 insertions(+), 7 deletions(-) diff --git a/block/blk-wbt.c b/block/blk-wbt.c index 72b1fa8a75c6..d6c1d42b85c5 100644 --- a/block/blk-wbt.c +++ b/block/blk-wbt.c @@ -161,7 +161,7 @@ static void wbt_rqw_done(struct rq_wb *rwb, struct rq_wait *rqw, int diff = limit - inflight; if (!inflight || diff >= rwb->wb_background / 2) - wake_up(&rqw->wait); + wake_up_all(&rqw->wait); } } @@ -488,6 +488,34 @@ static inline unsigned int get_limit(struct rq_wb *rwb, unsigned long rw) return limit; } +struct wbt_wait_data { + struct wait_queue_entry wq; + struct task_struct *task; + struct rq_wb *rwb; + struct rq_wait *rqw; + unsigned long rw; + bool got_token; +}; + +static int wbt_wake_function(struct wait_queue_entry *curr, unsigned int mode, + int wake_flags, void *key) +{ + struct wbt_wait_data *data = container_of(curr, struct wbt_wait_data, + wq); + + /* + * If we fail to get a budget, return -1 to interrupt the wake up + * loop in __wake_up_common. + */ + if (!rq_wait_inc_below(data->rqw, get_limit(data->rwb, data->rw))) + return -1; + + data->got_token = true; + list_del_init(&curr->entry); + wake_up_process(data->task); + return 1; +} + /* * Block if we will exceed our limit, or if we are currently waiting for * the timer to kick off queuing again. @@ -498,19 +526,40 @@ static void __wbt_wait(struct rq_wb *rwb, enum wbt_flags wb_acct, __acquires(lock) { struct rq_wait *rqw = get_rq_wait(rwb, wb_acct); - DECLARE_WAITQUEUE(wait, current); + struct wbt_wait_data data = { + .wq = { + .func = wbt_wake_function, + .entry = LIST_HEAD_INIT(data.wq.entry), + }, + .task = current, + .rwb = rwb, + .rqw = rqw, + .rw = rw, + }; bool has_sleeper; has_sleeper = wq_has_sleeper(&rqw->wait); if (!has_sleeper && rq_wait_inc_below(rqw, get_limit(rwb, rw))) return; - add_wait_queue_exclusive(&rqw->wait, &wait); + prepare_to_wait_exclusive(&rqw->wait, &data.wq, TASK_UNINTERRUPTIBLE); do { - set_current_state(TASK_UNINTERRUPTIBLE); + if (data.got_token) + break; - if (!has_sleeper && rq_wait_inc_below(rqw, get_limit(rwb, rw))) + if (!has_sleeper && + rq_wait_inc_below(rqw, get_limit(rwb, rw))) { + finish_wait(&rqw->wait, &data.wq); + + /* + * We raced with wbt_wake_function() getting a token, + * which means we now have two. Put our local token + * and wake anyone else potentially waiting for one. + */ + if (data.got_token) + wbt_rqw_done(rwb, rqw, wb_acct); break; + } if (lock) { spin_unlock_irq(lock); @@ -518,11 +567,11 @@ static void __wbt_wait(struct rq_wb *rwb, enum wbt_flags wb_acct, spin_lock_irq(lock); } else io_schedule(); + has_sleeper = false; } while (1); - __set_current_state(TASK_RUNNING); - remove_wait_queue(&rqw->wait, &wait); + finish_wait(&rqw->wait, &data.wq); } static inline bool wbt_should_throttle(struct rq_wb *rwb, struct bio *bio)