From patchwork Wed Feb 1 12:47:58 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Linus Walleij X-Patchwork-Id: 93018 Delivered-To: patch@linaro.org Received: by 10.182.3.34 with SMTP id 2csp2301266obz; Wed, 1 Feb 2017 04:49:11 -0800 (PST) X-Received: by 10.84.248.10 with SMTP id p10mr4128705pll.87.1485953351833; Wed, 01 Feb 2017 04:49:11 -0800 (PST) Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id b69si19054885pfk.235.2017.02.01.04.49.11; Wed, 01 Feb 2017 04:49:11 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-mmc-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@linaro.org; spf=pass (google.com: best guess record for domain of linux-mmc-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-mmc-owner@vger.kernel.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1750972AbdBAMtL (ORCPT + 5 others); Wed, 1 Feb 2017 07:49:11 -0500 Received: from mail-lf0-f49.google.com ([209.85.215.49]:33906 "EHLO mail-lf0-f49.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750966AbdBAMtK (ORCPT ); Wed, 1 Feb 2017 07:49:10 -0500 Received: by mail-lf0-f49.google.com with SMTP id v186so227912612lfa.1 for ; Wed, 01 Feb 2017 04:49:09 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=dmAjuW/GMKH6E4gSUwyMZ3mfGLEuEBy/KFbaAuLZwLU=; b=N0pgGxKB9FQSIWl5To/Py0NsK6OFOnVasDXblPRwQNLM7TV3T1b3uAvjRl1QmaS9FP 4unD225yWdVcv8+XKnx1pWLal+4iYJLfXzljdHlv9jYcP6+qjewIvRockT5g3szT9xyr edgZP7ax8JtPporWDDQsfUjUPVK7lO0cIZHPI= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=dmAjuW/GMKH6E4gSUwyMZ3mfGLEuEBy/KFbaAuLZwLU=; b=eSd8wqk9Gof/nPAn6LkZsOjKDFAI3TnU7g7oX10zDEuGPJ1bxNii/K7f2jTgq4jy7t iZeT0bpEyEle38YtU6vyzp7PkxRwQOx4THRpEdcIZI95wenyoJktsQN5XcEtNu3Yt6CR 2ZkcWVwoC90hINuyHm746d49w9YZqRn5tw+aXMW9MC3VS6pgMWbfjhxi8eoW5gA0NO+0 K7His1hkKNVRwo92Vd2utkfnoCca4uVd9YfXbxiLEc1rPcWgSTqoVxuxyFSxq2mB4oW7 XGiT5ieEyjFlzkj/nHHGTQ0lIX9iDES3TJaxJwPqBzzXdoYyTVtGBnwKihmJ9dGKs03P NEcw== X-Gm-Message-State: AIkVDXKEpGVaq2GYXjZTDamyoKs2Nb7j0e3s8uEeY4hxele3CE6Eym+Zi9iEmVdE93RhPGOl X-Received: by 10.25.170.7 with SMTP id t7mr1030908lfe.105.1485953348433; Wed, 01 Feb 2017 04:49:08 -0800 (PST) Received: from gnarp.ideon.se ([85.235.10.227]) by smtp.gmail.com with ESMTPSA id t126sm5707754lff.31.2017.02.01.04.49.06 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 01 Feb 2017 04:49:07 -0800 (PST) From: Linus Walleij To: linux-mmc@vger.kernel.org, Ulf Hansson Cc: Chunyan Zhang , Baolin Wang , Linus Walleij Subject: [PATCH 08/10] mmc: block: respect bool returned from blk_end_request() Date: Wed, 1 Feb 2017 13:47:58 +0100 Message-Id: <20170201124800.13865-9-linus.walleij@linaro.org> X-Mailer: git-send-email 2.9.3 In-Reply-To: <20170201124800.13865-1-linus.walleij@linaro.org> References: <20170201124800.13865-1-linus.walleij@linaro.org> Sender: linux-mmc-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-mmc@vger.kernel.org The return value from blk_end_request() is a bool but is treated like an int. This is generally safe, but the variable also has the opaque name "ret" and gets returned from the helper function mmc_blk_cmd_err(). - Switch the variable to a bool, applies everywhere. - Return a bool from mmc_blk_cmd_err() and rename the function mmc_blk_rw_cmd_err() to indicate through the namespace that this is a helper for mmc_blk_issue_rw_rq(). - Rename the variable from "ret" to "req_pending" inside the while() loop inside mmc_blk_issue_rq_rq(), which finally makes it very clear what this while loop is waiting for. - Augment the argument "ret" to mmc_blk_rq_cmd_err() to old_req_pending so it becomes evident that this is an older state, and it is returned only if we fail to get the number of written blocks from an SD card in the function mmc_sd_num_wr_blocks(). - Augment the while() loop in mmc_blk_rq_cmd_abort(): it is evident now that we know this is a bool variable, that the function is just spinning waiting for blk_end_request() to return false. Signed-off-by: Linus Walleij --- drivers/mmc/core/block.c | 51 ++++++++++++++++++++++++------------------------ 1 file changed, 26 insertions(+), 25 deletions(-) -- 2.9.3 -- To unsubscribe from this list: send the line "unsubscribe linux-mmc" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html diff --git a/drivers/mmc/core/block.c b/drivers/mmc/core/block.c index 91d506b37024..92f7772ca56d 100644 --- a/drivers/mmc/core/block.c +++ b/drivers/mmc/core/block.c @@ -1566,11 +1566,13 @@ static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq, mmc_queue_bounce_pre(mqrq); } -static int mmc_blk_cmd_err(struct mmc_blk_data *md, struct mmc_card *card, - struct mmc_blk_request *brq, struct request *req, - int ret) +static bool mmc_blk_rw_cmd_err(struct mmc_blk_data *md, struct mmc_card *card, + struct mmc_blk_request *brq, struct request *req, + bool old_req_pending) { struct mmc_queue_req *mq_rq; + bool req_pending; + mq_rq = container_of(brq, struct mmc_queue_req, brq); /* @@ -1586,24 +1588,23 @@ static int mmc_blk_cmd_err(struct mmc_blk_data *md, struct mmc_card *card, int err; err = mmc_sd_num_wr_blocks(card, &blocks); - if (!err) { - ret = blk_end_request(req, 0, blocks << 9); - } + if (err) + req_pending = old_req_pending; + else + req_pending = blk_end_request(req, 0, blocks << 9); } else { - ret = blk_end_request(req, 0, brq->data.bytes_xfered); + req_pending = blk_end_request(req, 0, brq->data.bytes_xfered); } - return ret; + return req_pending; } static void mmc_blk_rw_cmd_abort(struct mmc_card *card, struct request *req) { - int ret = 1; - if (mmc_card_removed(card)) req->rq_flags |= RQF_QUIET; - while (ret) - ret = blk_end_request(req, -EIO, - blk_rq_cur_bytes(req)); + while (blk_end_request(req, -EIO, blk_rq_cur_bytes(req))) + { + } } /** @@ -1634,12 +1635,13 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req) struct mmc_blk_data *md = mq->blkdata; struct mmc_card *card = md->queue.card; struct mmc_blk_request *brq; - int ret = 1, disable_multi = 0, retry = 0, type, retune_retry_done = 0; + int disable_multi = 0, retry = 0, type, retune_retry_done = 0; enum mmc_blk_status status; struct mmc_queue_req *mq_rq; struct request *old_req; struct mmc_async_req *new_areq; struct mmc_async_req *old_areq; + bool req_pending = true; if (!new_req && !mq->mqrq_prev->req) return; @@ -1693,15 +1695,14 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req) */ mmc_blk_reset_success(md, type); - ret = blk_end_request(old_req, 0, - brq->data.bytes_xfered); - + req_pending = blk_end_request(old_req, 0, + brq->data.bytes_xfered); /* * If the blk_end_request function returns non-zero even * though all data has been transferred and no errors * were returned by the host controller, it's a bug. */ - if (status == MMC_BLK_SUCCESS && ret) { + if (status == MMC_BLK_SUCCESS && req_pending) { pr_err("%s BUG rq_tot %d d_xfer %d\n", __func__, blk_rq_bytes(old_req), brq->data.bytes_xfered); @@ -1710,13 +1711,13 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req) } break; case MMC_BLK_CMD_ERR: - ret = mmc_blk_cmd_err(md, card, brq, old_req, ret); + req_pending = mmc_blk_rw_cmd_err(md, card, brq, old_req, req_pending); if (mmc_blk_reset(md, card->host, type)) { mmc_blk_rw_cmd_abort(card, old_req); mmc_blk_rw_try_restart(mq, new_req); return; } - if (!ret) { + if (!req_pending) { mmc_blk_rw_try_restart(mq, new_req); return; } @@ -1758,9 +1759,9 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req) * time, so we only reach here after trying to * read a single sector. */ - ret = blk_end_request(old_req, -EIO, - brq->data.blksz); - if (!ret) { + req_pending = blk_end_request(old_req, -EIO, + brq->data.blksz); + if (!req_pending) { mmc_blk_rw_try_restart(mq, new_req); return; } @@ -1777,7 +1778,7 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req) return; } - if (ret) { + if (req_pending) { /* * In case of a incomplete request * prepare it again and resend. @@ -1788,7 +1789,7 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req) &mq_rq->areq, NULL); mq_rq->brq.retune_retry_done = retune_retry_done; } - } while (ret); + } while (req_pending); } void mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)