From patchwork Tue Jan 24 19:02:47 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114585 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 503B1C54EAA for ; Tue, 24 Jan 2023 19:03:33 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234433AbjAXTDb (ORCPT ); Tue, 24 Jan 2023 14:03:31 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42050 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233989AbjAXTDY (ORCPT ); Tue, 24 Jan 2023 14:03:24 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 476404ABD9; Tue, 24 Jan 2023 11:03:20 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587000; x=1706123000; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=UzT5GVJNV/JFPdkmk0111+wWTNNszb/ahmQd8s5F0yY=; b=Y6wAjNHa5/cnBcCUsak0oo98A8EmLZHX6xAL5ejpt0C88nff+AoEnRcz fVW73HgiLJZXetd8PHIQENOFv/KhH6SiaVtw/MnHm3gRyK0TjELRvoHIe 5+8WYsaHyNvmWpiD2y1abUlJgqqAvEQj0w+rI2LibqO38ym+NwHGAFRfE Dx3mRX0yxXmyavGk49aluR5Kdm70jknrKbjtr0P9g66vFvxN/IS+uHk0l Z6v7wv5PXv/03kKwq1cm6i3APDEKBZR4C2FnucTj1sJqwC2pUNF/shsXH P8F3cZGDZ3CrSz/x0mH4DfI7l3vxgXHm2uTJ8K6JL+V+gyj9JVA72psLt Q==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472921" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:03:19 +0800 IronPort-SDR: B752Nl9NcMpbFC+veqL9xcaxfqJGlkN+eyC10CXT5KLD9ubvIWffwn/bTsv3qo9Nld6I2MAltF KR7j/grYDnbsk2ziQe63Ew6tGhCmk+gY+zJ0t1NpcG9hIhGC5PrmgUZUTimoX44wxvyr/Xo4dx JzzqjRz7dG8CItneM1QcYbBQ9DQxNlyjred/b6zo3luD19WayqngL4ut+8lmbM1GLUcD9n22jf v6RC10FlVmD4hYTWfdytaxweT2j3OFTegdhACCEX6yTkmDU+l3w4aZM4QZy8UZG6X5T1iAz/6b 5/I= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:15:08 -0800 IronPort-SDR: qSTBWHUaiYtsGCSECsfB4ZOnKpmpHJ67q9P9Jb0AqpR/smS8JB/+pD9rqPALjTzs4IKwMOvciZ W8mQMN8ASMMuTTSuLXwBfPId4ldsawqUJPFYH3duhP5AGSw1noqzxAY8/3hsMLPjAisA99iEaN ijL5FBtQBT2A0P4IJBQtkXz2xfY5mb39KR4Ve13Q3G6lFUXjgYlbWxSiLaRaq6u/dS2D3ATSOf RqOPG7BaTLCYCnZYlVeo2wd6m/lPqghvQ9dDRDcQ4bHonhNK/MP37Si8TWigBDLBtZSM1aFKWw cWI= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:03:17 -0800 From: Niklas Cassel To: Paolo Valente , Jens Axboe Cc: Christoph Hellwig , Hannes Reinecke , Damien Le Moal , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel Subject: [PATCH v3 01/18] block: introduce duration-limits priority class Date: Tue, 24 Jan 2023 20:02:47 +0100 Message-Id: <20230124190308.127318-2-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org From: Damien Le Moal Introduce the IOPRIO_CLASS_DL priority class to indicate that IOs should be executed using duration-limits targets. The duration target to apply to a command is indicated using the priority level. Up to 8 levels are supported, with level 0 indiating "no limit". This priority class has effect only if the target device supports the command duration limits feature and this feature is enabled by the user. While it is recommended to not use an ioscheduler when using the IOPRIO_CLASS_DL priority class, if using the BFQ or mq-deadline scheduler, IOPRIO_CLASS_DL is mapped to IOPRIO_CLASS_RT. The reason for this is twofold: 1) Each priority level for the IOPRIO_CLASS_DL priority class represents a duration limit descriptor (DLD) inside the device. Users can configure these limits themselves using passthrough commands, so from a block layer perspective, Linux has no idea of how each DLD is actually configured. By mapping a command to IOPRIO_CLASS_RT, the chance that a command exceeds its duration limit (because it was held too long in the scheduler) is decreased. It is still possible to use the IOPRIO_CLASS_DL priority class for "low priority" IOs by configuring a large limit in the respective DLD. 2) On ATA drives, IOPRIO_CLASS_DL commands and NCQ priority commands (IOPRIO_CLASS_RT) cannot be used together. A mix of CDL and high priority commands cannot be sent to a device. By mapping IOPRIO_CLASS_DL to IOPRIO_CLASS_RT, we ensure that a device will never receive a mix of these two incompatible priority classes. Signed-off-by: Damien Le Moal Signed-off-by: Niklas Cassel Reviewed-by: Hannes Reinecke --- block/bfq-iosched.c | 10 ++++++++++ block/blk-ioprio.c | 3 +++ block/ioprio.c | 3 ++- block/mq-deadline.c | 1 + include/linux/ioprio.h | 2 +- include/uapi/linux/ioprio.h | 7 +++++++ 6 files changed, 24 insertions(+), 2 deletions(-) diff --git a/block/bfq-iosched.c b/block/bfq-iosched.c index 815b884d6c5a..7add9346c585 100644 --- a/block/bfq-iosched.c +++ b/block/bfq-iosched.c @@ -5545,6 +5545,14 @@ bfq_set_next_ioprio_data(struct bfq_queue *bfqq, struct bfq_io_cq *bic) bfqq->new_ioprio_class = IOPRIO_CLASS_IDLE; bfqq->new_ioprio = 7; break; + case IOPRIO_CLASS_DL: + /* + * For the duration-limits class, we want the disk to do the + * scheduling. So map all levels to the highest RT level. + */ + bfqq->new_ioprio = 0; + bfqq->new_ioprio_class = IOPRIO_CLASS_RT; + break; } if (bfqq->new_ioprio >= IOPRIO_NR_LEVELS) { @@ -5673,6 +5681,8 @@ static struct bfq_queue **bfq_async_queue_prio(struct bfq_data *bfqd, return &bfqg->async_bfqq[1][ioprio][act_idx]; case IOPRIO_CLASS_IDLE: return &bfqg->async_idle_bfqq[act_idx]; + case IOPRIO_CLASS_DL: + return &bfqg->async_bfqq[0][0][act_idx]; default: return NULL; } diff --git a/block/blk-ioprio.c b/block/blk-ioprio.c index 8bb6b8eba4ce..dfb5c3f447f4 100644 --- a/block/blk-ioprio.c +++ b/block/blk-ioprio.c @@ -27,6 +27,7 @@ * @POLICY_RESTRICT_TO_BE: modify IOPRIO_CLASS_NONE and IOPRIO_CLASS_RT into * IOPRIO_CLASS_BE. * @POLICY_ALL_TO_IDLE: change the I/O priority class into IOPRIO_CLASS_IDLE. + * @POLICY_ALL_TO_DL: change the I/O priority class into IOPRIO_CLASS_DL. * * See also . */ @@ -35,6 +36,7 @@ enum prio_policy { POLICY_NONE_TO_RT = 1, POLICY_RESTRICT_TO_BE = 2, POLICY_ALL_TO_IDLE = 3, + POLICY_ALL_TO_DL = 4, }; static const char *policy_name[] = { @@ -42,6 +44,7 @@ static const char *policy_name[] = { [POLICY_NONE_TO_RT] = "none-to-rt", [POLICY_RESTRICT_TO_BE] = "restrict-to-be", [POLICY_ALL_TO_IDLE] = "idle", + [POLICY_ALL_TO_DL] = "duration-limits", }; static struct blkcg_policy ioprio_policy; diff --git a/block/ioprio.c b/block/ioprio.c index 32a456b45804..1b3a9da82597 100644 --- a/block/ioprio.c +++ b/block/ioprio.c @@ -37,6 +37,7 @@ int ioprio_check_cap(int ioprio) switch (class) { case IOPRIO_CLASS_RT: + case IOPRIO_CLASS_DL: /* * Originally this only checked for CAP_SYS_ADMIN, * which was implicitly allowed for pid 0 by security @@ -47,7 +48,7 @@ int ioprio_check_cap(int ioprio) if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_NICE)) return -EPERM; fallthrough; - /* rt has prio field too */ + /* RT and DL have prio field too */ case IOPRIO_CLASS_BE: if (data >= IOPRIO_NR_LEVELS || data < 0) return -EINVAL; diff --git a/block/mq-deadline.c b/block/mq-deadline.c index f10c2a0d18d4..526d0ea4dbf9 100644 --- a/block/mq-deadline.c +++ b/block/mq-deadline.c @@ -113,6 +113,7 @@ static const enum dd_prio ioprio_class_to_prio[] = { [IOPRIO_CLASS_RT] = DD_RT_PRIO, [IOPRIO_CLASS_BE] = DD_BE_PRIO, [IOPRIO_CLASS_IDLE] = DD_IDLE_PRIO, + [IOPRIO_CLASS_DL] = DD_RT_PRIO, }; static inline struct rb_root * diff --git a/include/linux/ioprio.h b/include/linux/ioprio.h index 7578d4f6a969..2f3fc2fbd668 100644 --- a/include/linux/ioprio.h +++ b/include/linux/ioprio.h @@ -20,7 +20,7 @@ static inline bool ioprio_valid(unsigned short ioprio) { unsigned short class = IOPRIO_PRIO_CLASS(ioprio); - return class > IOPRIO_CLASS_NONE && class <= IOPRIO_CLASS_IDLE; + return class > IOPRIO_CLASS_NONE && class <= IOPRIO_CLASS_DL; } /* diff --git a/include/uapi/linux/ioprio.h b/include/uapi/linux/ioprio.h index f70f2596a6bf..15908b9e9d8c 100644 --- a/include/uapi/linux/ioprio.h +++ b/include/uapi/linux/ioprio.h @@ -29,6 +29,7 @@ enum { IOPRIO_CLASS_RT, IOPRIO_CLASS_BE, IOPRIO_CLASS_IDLE, + IOPRIO_CLASS_DL, }; /* @@ -37,6 +38,12 @@ enum { #define IOPRIO_NR_LEVELS 8 #define IOPRIO_BE_NR IOPRIO_NR_LEVELS +/* + * The Duration limits class allows 8 levels: level 0 for "no limit" and levels + * 1 to 7, each corresponding to a read or write limit descriptor. + */ +#define IOPRIO_DL_NR_LEVELS 8 + enum { IOPRIO_WHO_PROCESS = 1, IOPRIO_WHO_PGRP, From patchwork Tue Jan 24 19:02:48 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114586 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7D598C61D97 for ; Tue, 24 Jan 2023 19:03:34 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233925AbjAXTDd (ORCPT ); Tue, 24 Jan 2023 14:03:33 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42160 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234361AbjAXTDb (ORCPT ); Tue, 24 Jan 2023 14:03:31 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 06E9B4A1D3; Tue, 24 Jan 2023 11:03:23 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587002; x=1706123002; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=svVehXplb02VowJ4EoTxl3Wqf+J8HsTcqAMlcWrlec0=; b=nAVNZubp9bvMbchgT7Qc5TOIQJdpGKUjlZTeFK82PGCDKQ3/1+Qx/JjK sMLRpZj50cmJV+WsJYyWMzr42ZwgJOVMn2H/IINvBuQb0f6xnAuQb4fkq n4mJCes4MiwyeinvKLB0vfKJ94+Zgqz6y353ujbOSW/tNjRQEuT91T58L XDy1+GgR/PY52koNaJvKhO/A4AeHNxsS0FY0Wtx7XBYBnUd8e8uTtYPiT Z9woXjq4robBvTFl20BnCUvyHKgQAAyl5bMbhi4KzHWt7UBQriLGxQZat U6C9+Sx1PhcL4Al9aHH6/V1ap5S86XYq+gNCxEDsADQe/xypVOEumteah A==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472925" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:03:22 +0800 IronPort-SDR: 27XlF67F+t5m7u0aacHnYtWjkv1JZyzGQKCMoC8+RjKMoD3ZuyM7jDGVQPnGLAzkkm15f6Vj/u 561pD22pFZt0joJJsF2teK4PSKy3w87seWkzdAn3Z+3/fD6Drpqv9E6Us3czEH/gNplkzDn9Ir eno7m/8qfHnNT4piHusRRyrxHVXYmABMX/g9+c6MjgNhev1Nk+wCjrQ8bs9Nb1ZKB5y+FA/7Lo SkgJlKhd0EbdP3sElTNsJLmi1h7jyexFTEyaMTahmh4TlI7/ke78saMvMekSzoknEeTwDbRU9l Mq0= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:15:11 -0800 IronPort-SDR: qv2KL4ExEdEJri197Mb+lwO6rT8Pt5sNCoTqnLG5+6qxOnU7Yn1HQXi4X+B7s+gbrDBz5bJqTm x/gifDAjSOE9FqmlP/L+fHQsWHy8UFIlfy8HK6CzTG5RhZzjGYE4Sfx+VDvZ95XzpATxH4lt+w g2NN30ByfMYhhgW+OenxFkQhg/ojc4IoxkgvfVFF7bmbwM8p58xzddqtBvwxG6K5kT7OmifkSC FPaF8BaYTzvsg8HJW7A7braeWs3O26lw4qJng8SxZu4zBKzSqX8iUclkDNhKQLoyfi3OLncAUx 4ao= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:03:20 -0800 From: Niklas Cassel To: Jens Axboe Cc: Christoph Hellwig , Hannes Reinecke , Damien Le Moal , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel Subject: [PATCH v3 02/18] block: introduce BLK_STS_DURATION_LIMIT Date: Tue, 24 Jan 2023 20:02:48 +0100 Message-Id: <20230124190308.127318-3-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org From: Damien Le Moal Introduce the new block IO status BLK_STS_DURATION_LIMIT for LLDDs to report command that failed due to a command duration limit being exceeded. This new status is mapped to the ETIME error code to allow users to differentiate "soft" duration limit failures from other more serious hardware related errors. Signed-off-by: Damien Le Moal Co-developed-by: Niklas Cassel Signed-off-by: Niklas Cassel Reviewed-by: Hannes Reinecke Reviewed-by: Christoph Hellwig --- block/blk-core.c | 3 +++ include/linux/blk_types.h | 6 ++++++ 2 files changed, 9 insertions(+) diff --git a/block/blk-core.c b/block/blk-core.c index 46d12b3344c9..9ca31b779fc1 100644 --- a/block/blk-core.c +++ b/block/blk-core.c @@ -170,6 +170,9 @@ static const struct { [BLK_STS_ZONE_OPEN_RESOURCE] = { -ETOOMANYREFS, "open zones exceeded" }, [BLK_STS_ZONE_ACTIVE_RESOURCE] = { -EOVERFLOW, "active zones exceeded" }, + /* Command duration limit device-side timeout */ + [BLK_STS_DURATION_LIMIT] = { -ETIME, "duration limit exceeded" }, + /* everything else not covered above: */ [BLK_STS_IOERR] = { -EIO, "I/O" }, }; diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h index 99be590f952f..cde997590765 100644 --- a/include/linux/blk_types.h +++ b/include/linux/blk_types.h @@ -166,6 +166,12 @@ typedef u16 blk_short_t; */ #define BLK_STS_OFFLINE ((__force blk_status_t)17) +/* + * BLK_STS_DURATION_LIMIT is returned from the driver when the target device + * aborted the command because it exceeded one of its Command Duration Limits. + */ +#define BLK_STS_DURATION_LIMIT ((__force blk_status_t)18) + /** * blk_path_error - returns true if error may be path related * @error: status the request was completed with From patchwork Tue Jan 24 19:02:49 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114587 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 41E82C61D9D for ; Tue, 24 Jan 2023 19:03:35 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234110AbjAXTDd (ORCPT ); Tue, 24 Jan 2023 14:03:33 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42176 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233302AbjAXTDb (ORCPT ); Tue, 24 Jan 2023 14:03:31 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 413D24DBC1; Tue, 24 Jan 2023 11:03:26 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587007; x=1706123007; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=pNo/ONgWK3h7ifeuxClWzQxjAfmdUE96jJQ6AnBvniM=; b=Es6TturyWw4ZZa79qwd/401w6lKRlFNLtvM4KcubFR7h2T9DnkHuC6VI UwvnS4vI+BW1Em0RN3S7soi3kqBrkIF5fE36ykZhd6Ankq3Ox9h119ZbR 7v6SiwFZMdmoVA5GPyP4HynLtZ33us6I7PdNUNW/FDvd39Mpjr0aqFWid msi4MgKCSoZmYsquBws1TsG+Z8QU3VJxO2Po8KG9J1W1XhLlXDRAkPZnP oUowBjw22I/bCvf7apn8wrc8DkphixlBnVQI4KaHghkXA9cFr6H5wKKfx UVTAwkbRx1GO+N3aX8sK9/x+Ok4sPv1C9w6GEcHvS1ESCFQIm/o0YbaRn A==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472931" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:03:25 +0800 IronPort-SDR: gVB5eLklO+z7RtiNv6kuFqVpmezJHODK6WTilxCgBFVqSAYEMKBshSz9pKaKFCvy2gQ57qBCVv 0RUlc0JsyTp/6LSzY6uY4wYizzvdRo37ZYvpSfSwNxDnO/13wsnueYaMitDbtIusP2yRZ/py7H 8LANbzQRk9q5l7MiuNJqHWdwccXY4r7q8tQdfC1unaKmnsXvbxDgI6YXgRnv70750UoyihODQJ miBnY/IlYf4s2QJ6Ue/I09eJUNonbBNswpMmbHZZuJLBw12JNIYFPgqfQfkjFsSppru1upho6/ xK8= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:15:14 -0800 IronPort-SDR: udPOZv2hhQ/gXE+5fFMIonvg5RbS851RQTpBjyC8UriQEQUWC1k59AF3J265v62gFOCstwTXzX yzqr1xZINKJJRAb7dtW02ZqpOB0ofJ+qA1n6LDlFLbm6FyIqH07PCTnuU1agkXS7X9zvYj6JdK /84aq6vsb3sIeCXOe8HkdtdUooqbv88kkdhlKT99Mp0BmhCz0stG4E2A7Z8ETo4dWq6xqpd+O4 t9go4PwGFTz9JtRmHUK0pPD0GcVe0TvzLu9LPpHSKiDAHDEIKUrQ5lDHKuFf23atlx/VSsTjL9 j7w= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:03:23 -0800 From: Niklas Cassel To: "James E.J. Bottomley" , "Martin K. Petersen" Cc: Christoph Hellwig , Hannes Reinecke , Damien Le Moal , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel Subject: [PATCH v3 03/18] scsi: core: allow libata to complete successful commands via EH Date: Tue, 24 Jan 2023 20:02:49 +0100 Message-Id: <20230124190308.127318-4-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org In SCSI, we get the sense data as part of the completion, for ATA however, we need to fetch the sense data as an extra step. For an aborted ATA command the sense data is fetched via libata's ->eh_strategy_handler(). For Command Duration Limits policy 0xD: The device shall complete the command without error with the additional sense code set to DATA CURRENTLY UNAVAILABLE. In order to handle this policy in libata, we intend to send a successful command via SCSI EH, and let libata's ->eh_strategy_handler() fetch the sense data for the good command. This is similar to how we handle an aborted ATA command, just that we need to read the Successful NCQ Commands log instead of the NCQ Command Error log. When we get a SATA completion with successful commands, ATA_SENSE will be set, indicating that some commands in the completion have sense data. The sense_valid bitmask in the Sense Data for Successful NCQ Commands log will inform exactly which commands that had sense data, which might be a subset of all the commands that was completed in the same completion. (Yet all will have ATA_SENSE set, since the status is per completion.) The successful commands that have e.g. a "DATA CURRENTLY UNAVAILABLE" sense data will have a SCSI ML byte set, so scsi_eh_flush_done_q() will not set the scmd->result to DID_TIME_OUT for these commands. However, the successful commands that did not have sense data, must not get their result marked as DID_TIME_OUT by SCSI EH. Add a new flag SCMD_FORCE_EH_SUCCESS, which tells SCSI EH to not mark a command as DID_TIME_OUT, even if it has scmd->result == SAM_STAT_GOOD. This will be used by libata in a follow-up patch. Signed-off-by: Niklas Cassel Reviewed-by: Christoph Hellwig Reviewed-by: Hannes Reinecke --- drivers/scsi/scsi_error.c | 3 ++- include/scsi/scsi_cmnd.h | 5 +++++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c index 2aa2c2aee6e7..cf5ec5f5f4f6 100644 --- a/drivers/scsi/scsi_error.c +++ b/drivers/scsi/scsi_error.c @@ -2165,7 +2165,8 @@ void scsi_eh_flush_done_q(struct list_head *done_q) * scsi_eh_get_sense), scmd->result is already * set, do not set DID_TIME_OUT. */ - if (!scmd->result) + if (!scmd->result && + !(scmd->flags & SCMD_FORCE_EH_SUCCESS)) scmd->result |= (DID_TIME_OUT << 16); SCSI_LOG_ERROR_RECOVERY(3, scmd_printk(KERN_INFO, scmd, diff --git a/include/scsi/scsi_cmnd.h b/include/scsi/scsi_cmnd.h index c2cb5f69635c..526def14e7fb 100644 --- a/include/scsi/scsi_cmnd.h +++ b/include/scsi/scsi_cmnd.h @@ -52,6 +52,11 @@ struct scsi_pointer { #define SCMD_TAGGED (1 << 0) #define SCMD_INITIALIZED (1 << 1) #define SCMD_LAST (1 << 2) +/* + * libata uses SCSI EH to fetch sense data for successful commands. + * SCSI EH should not overwrite scmd->result when SCMD_FORCE_EH_SUCCESS is set. + */ +#define SCMD_FORCE_EH_SUCCESS (1 << 3) #define SCMD_FAIL_IF_RECOVERING (1 << 4) /* flags preserved across unprep / reprep */ #define SCMD_PRESERVED_FLAGS (SCMD_INITIALIZED | SCMD_FAIL_IF_RECOVERING) From patchwork Tue Jan 24 19:02:50 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114596 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3CA78C54EAA for ; Tue, 24 Jan 2023 19:03:50 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234538AbjAXTDs (ORCPT ); Tue, 24 Jan 2023 14:03:48 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42186 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234443AbjAXTDb (ORCPT ); Tue, 24 Jan 2023 14:03:31 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5CA9F4C6F3; Tue, 24 Jan 2023 11:03:29 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587009; x=1706123009; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=udGgt0VZGVaV1F90mGCYD9DD4Pho2abcG3HITsaVOEY=; b=i56xwrPdPsK/GcgL0rZZ8QsryNLIF2vpsCOY/4WAKYWyVV97smw8nqni h3pcqZzTL90m0rgHQptOdcMeW93hv7gRY32sye0Qjg6nMYN6PbNNjiOup PwtEv99vGNJMVpBHXd5FiwwpeIC4bnBhJuXa8J78keyj+8dEF6LBJpcSA l3PTFIAeK4P3ZF7riR5OsQYovpDcy/4v9CvUlw442pXPojI397ZidjtYR tC0ZMGvx+QK+Y8gOpO6maCIP2nM6JgrMVxfMPCSmlU39PW/WG2NkKA5q5 a6RvCTlTFMMqQcdtbyIuwM4F24+NC2MZ3TzxKRMQpJZMDSmzzII5giDHL w==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472935" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:03:28 +0800 IronPort-SDR: fzIj+0hRMJK9Pf/ZWdhBf4P2OYCQ9d4CQfJC4vjOl7eJvTv3dXeBC/F8/wVi0rLzCS9cGi1HTx WUkPhf6kpLohJpxUQvDeCGegSqP7s7m1Ia7nY7K2GbKBsfdZW5EZsMWNiWkBHhVwjPQyBYlXth irasXtNUiTzem5ZE4lKHg9G7ecnGaXeXu5NSo1ukyIwuoC9LIOl1MaJp/u8OP2H5Vg7U45N+rm f/7htRk8BDcyg+BfI4NEMjQzkm6k1bwbiAHKbpYp0pItvwRxeMA1XYYRr3j2RDifSMoIwcqMUW 0XM= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:15:17 -0800 IronPort-SDR: mw6e2Em107+OhxI0epu9UaZcQajJNodr/WotN84GeDRGOnV16qOEuHOcY0qqZ1rszIvHTbON/Q fJFmuTVF59/S25zjoGqsga4CC6A4LHH04YTyPIu52I696iA+8hUwXjHgSEH1ExT7uAz3xnBmhV FzFKirpQrVlqCNSQdktqlInUrUV771BRPW4N9iyh5C5/HyL/EXEKwtI+J+roRgsrBYRcZdoR4r 3TmQgkhRLyE4L6BL/0E0WtGcKDglp04RQHwM6+yaFV6DUAZQ4Max0/Y26zPdhvzUaTslB1y7cf r4s= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:03:26 -0800 From: Niklas Cassel To: "James E.J. Bottomley" , "Martin K. Petersen" Cc: Christoph Hellwig , Hannes Reinecke , Damien Le Moal , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel , Mike Christie Subject: [PATCH v3 04/18] scsi: rename and move get_scsi_ml_byte() Date: Tue, 24 Jan 2023 20:02:50 +0100 Message-Id: <20230124190308.127318-5-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org SCSI has two different getters: - get_XXX_byte() (in scsi_cmnd.h) which takes a struct scsi_cmnd *, and - XXX_byte() (in scsi.h) which takes a scmd->result. The proper name for get_scsi_ml_byte() should thus be without the get_ prefix, as it takes a scmd->result. Rename the function to rectify this. (This change was suggested by Mike Christie.) Additionally, move get_scsi_ml_byte() to scsi_priv.h since both scsi_lib.c and scsi_error.c will need to use this helper in a follow-up patch. Cc: Mike Christie Signed-off-by: Niklas Cassel Reviewed-by: Hannes Reinecke Reviewed-by: Christoph Hellwig Reviewed-by: Bart Van Assche --- drivers/scsi/scsi_lib.c | 7 +------ drivers/scsi/scsi_priv.h | 5 +++++ 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c index abe93ec8b7d0..b1dcd7eb831e 100644 --- a/drivers/scsi/scsi_lib.c +++ b/drivers/scsi/scsi_lib.c @@ -577,11 +577,6 @@ static bool scsi_end_request(struct request *req, blk_status_t error, return false; } -static inline u8 get_scsi_ml_byte(int result) -{ - return (result >> 8) & 0xff; -} - /** * scsi_result_to_blk_status - translate a SCSI result code into blk_status_t * @result: scsi error code @@ -594,7 +589,7 @@ static blk_status_t scsi_result_to_blk_status(int result) * Check the scsi-ml byte first in case we converted a host or status * byte. */ - switch (get_scsi_ml_byte(result)) { + switch (scsi_ml_byte(result)) { case SCSIML_STAT_OK: break; case SCSIML_STAT_RESV_CONFLICT: diff --git a/drivers/scsi/scsi_priv.h b/drivers/scsi/scsi_priv.h index 96284a0e13fe..74324fba4281 100644 --- a/drivers/scsi/scsi_priv.h +++ b/drivers/scsi/scsi_priv.h @@ -29,6 +29,11 @@ enum scsi_ml_status { SCSIML_STAT_TGT_FAILURE = 0x04, /* Permanent target failure */ }; +static inline u8 scsi_ml_byte(int result) +{ + return (result >> 8) & 0xff; +} + /* * Scsi Error Handler Flags */ From patchwork Tue Jan 24 19:02:51 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114597 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 86D5AC61D97 for ; Tue, 24 Jan 2023 19:03:51 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233302AbjAXTDt (ORCPT ); Tue, 24 Jan 2023 14:03:49 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42226 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234374AbjAXTDf (ORCPT ); Tue, 24 Jan 2023 14:03:35 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CB84119696; Tue, 24 Jan 2023 11:03:32 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587012; x=1706123012; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=gQWO39m8k+LJb3LXZV8zqxZCYF7g0p0iv9QtsuMobKY=; b=IbeAJX+IAQZgCk120izVNa3roZji2CWU7ZY/7ipJEdH0zBzwga17JBPp ZJcPxSZWsJxTZjaoNoZTQ6DAg7K5vIOIFaQEahKDqwnt+Y8KOB/tUhFDM lFOSNJnzeYricRuW35YCLA/hpcSVdM3L7Ohjrm1GfI5WPymqv7shLsEwk rVtkXxMf74JOmCe7x0g+3tYDd5gn9j9qw1DW8COHY3TreBFYjC+DFTR2U GBWyN5IYDD2FZeZ9HBT9BXbWkn/9v1GHs0iVC5qi0pvHDldsoJiHpVSfF 6bL+V9KJUTCGfhjXpVGotNJ0Sw8tDyTH3MTs9rha95/mUN+4BBZugTrif Q==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472943" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:03:32 +0800 IronPort-SDR: ySs4x0x+8Nbh6jz7t5TM/PLQoWsgg81WTePm7VdaDXYR4rpxSr6pY3bHrMPY2YwBEUtLkiiJWz lF4u7AON/PjvcWzr1VhG4Nghgox5DjN3CVWXeoreVsGDAQGWpZBbCtOiogzokNCXW+hm7GxyMm h7WGkTebAjIt03U6aJukujMyNZ7SEz74FCGToXCc+uSFx773tLYnQuNthM9k1o+X6ordl/6S2V o8cAeG8Fg2ChHWcqa3IM+4PEiOon8YwZ4WX9PTrZMtEWbGt5qevQuBFHiYDRRhjk9M2xcr94Bz bco= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:15:20 -0800 IronPort-SDR: 0vhsgxNBlBUD20Vy3CkCEK85SeAzamEl8OcVxfuYrxuN1ize1tAOaSxatQqmfQHV9XnxfUF6+6 pSKGlfctGHL85+ZVyvPjeYXLm6+Ob1+SDEwOrTmsqhzLsf8nE0xmn5mvrlUURPl1Q1e2ZDjiHm Iy9qiK/Vg6Jb2l7J6ExugpPXr3+XuYFn7M7y29+pZ3YIz1j6CmppLhDHtHPP/ITM/hND2IKtt/ ZB8c4zVvwIDvA2UmTsk0zkqzGSewT2CtG0JfmfvEZ5tVI0Qq+fLgcsUaNFyfBbvrAezsyVS4Zz Ah8= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:03:30 -0800 From: Niklas Cassel To: "James E.J. Bottomley" , "Martin K. Petersen" Cc: Christoph Hellwig , Hannes Reinecke , Damien Le Moal , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel Subject: [PATCH v3 05/18] scsi: support retrieving sub-pages of mode pages Date: Tue, 24 Jan 2023 20:02:51 +0100 Message-Id: <20230124190308.127318-6-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org From: Damien Le Moal Allow scsi_mode_sense() to retrieve sub-pages of mode pages by adding the subpage argument. Change all the current caller sites to specify the subpage 0. Signed-off-by: Damien Le Moal Signed-off-by: Niklas Cassel Reviewed-by: Hannes Reinecke Reviewed-by: Christoph Hellwig Reviewed-by: Bart Van Assche --- drivers/scsi/scsi_lib.c | 4 +++- drivers/scsi/scsi_transport_sas.c | 2 +- drivers/scsi/sd.c | 9 ++++----- drivers/scsi/sr.c | 2 +- include/scsi/scsi_device.h | 8 ++++---- 5 files changed, 13 insertions(+), 12 deletions(-) diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c index b1dcd7eb831e..e1a021dd4da2 100644 --- a/drivers/scsi/scsi_lib.c +++ b/drivers/scsi/scsi_lib.c @@ -2143,6 +2143,7 @@ EXPORT_SYMBOL_GPL(scsi_mode_select); * @sdev: SCSI device to be queried * @dbd: set to prevent mode sense from returning block descriptors * @modepage: mode page being requested + * @subpage: sub-page of the mode page being requested * @buffer: request buffer (may not be smaller than eight bytes) * @len: length of request buffer. * @timeout: command timeout @@ -2154,7 +2155,7 @@ EXPORT_SYMBOL_GPL(scsi_mode_select); * Returns zero if successful, or a negative error number on failure */ int -scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, +scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, int subpage, unsigned char *buffer, int len, int timeout, int retries, struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr) { @@ -2174,6 +2175,7 @@ scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, dbd = sdev->set_dbd_for_ms ? 8 : dbd; cmd[1] = dbd & 0x18; /* allows DBD and LLBA bits */ cmd[2] = modepage; + cmd[3] = subpage; sshdr = exec_args.sshdr; diff --git a/drivers/scsi/scsi_transport_sas.c b/drivers/scsi/scsi_transport_sas.c index 74b99f2b0b74..d704c484a251 100644 --- a/drivers/scsi/scsi_transport_sas.c +++ b/drivers/scsi/scsi_transport_sas.c @@ -1245,7 +1245,7 @@ int sas_read_port_mode_page(struct scsi_device *sdev) if (!buffer) return -ENOMEM; - error = scsi_mode_sense(sdev, 1, 0x19, buffer, BUF_SIZE, 30*HZ, 3, + error = scsi_mode_sense(sdev, 1, 0x19, 0, buffer, BUF_SIZE, 30*HZ, 3, &mode_data, NULL); if (error) diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c index 2aa3b0393b96..7582e02a8d5a 100644 --- a/drivers/scsi/sd.c +++ b/drivers/scsi/sd.c @@ -184,7 +184,7 @@ cache_type_store(struct device *dev, struct device_attribute *attr, return count; } - if (scsi_mode_sense(sdp, 0x08, 8, buffer, sizeof(buffer), SD_TIMEOUT, + if (scsi_mode_sense(sdp, 0x08, 8, 0, buffer, sizeof(buffer), SD_TIMEOUT, sdkp->max_retries, &data, NULL)) return -EINVAL; len = min_t(size_t, sizeof(buffer), data.length - data.header_length - @@ -2616,9 +2616,8 @@ sd_do_mode_sense(struct scsi_disk *sdkp, int dbd, int modepage, if (sdkp->device->use_10_for_ms && len < 8) len = 8; - return scsi_mode_sense(sdkp->device, dbd, modepage, buffer, len, - SD_TIMEOUT, sdkp->max_retries, data, - sshdr); + return scsi_mode_sense(sdkp->device, dbd, modepage, 0, buffer, len, + SD_TIMEOUT, sdkp->max_retries, data, sshdr); } /* @@ -2875,7 +2874,7 @@ static void sd_read_app_tag_own(struct scsi_disk *sdkp, unsigned char *buffer) if (sdkp->protection_type == 0) return; - res = scsi_mode_sense(sdp, 1, 0x0a, buffer, 36, SD_TIMEOUT, + res = scsi_mode_sense(sdp, 1, 0x0a, 0, buffer, 36, SD_TIMEOUT, sdkp->max_retries, &data, &sshdr); if (res < 0 || !data.header_length || diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c index 9e51dcd30bfd..09fdb0e269d9 100644 --- a/drivers/scsi/sr.c +++ b/drivers/scsi/sr.c @@ -830,7 +830,7 @@ static int get_capabilities(struct scsi_cd *cd) scsi_test_unit_ready(cd->device, SR_TIMEOUT, MAX_RETRIES, &sshdr); /* ask for mode page 0x2a */ - rc = scsi_mode_sense(cd->device, 0, 0x2a, buffer, ms_len, + rc = scsi_mode_sense(cd->device, 0, 0x2a, 0, buffer, ms_len, SR_TIMEOUT, 3, &data, NULL); if (rc < 0 || data.length > ms_len || diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h index 7e95ec45138f..15e005982032 100644 --- a/include/scsi/scsi_device.h +++ b/include/scsi/scsi_device.h @@ -419,10 +419,10 @@ extern int scsi_track_queue_full(struct scsi_device *, int); extern int scsi_set_medium_removal(struct scsi_device *, char); -extern int scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, - unsigned char *buffer, int len, int timeout, - int retries, struct scsi_mode_data *data, - struct scsi_sense_hdr *); +int scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, + int subpage, unsigned char *buffer, int len, int timeout, + int retries, struct scsi_mode_data *data, + struct scsi_sense_hdr *); extern int scsi_mode_select(struct scsi_device *sdev, int pf, int sp, unsigned char *buffer, int len, int timeout, int retries, struct scsi_mode_data *data, From patchwork Tue Jan 24 19:02:52 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114598 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id C8D6CC54EED for ; Tue, 24 Jan 2023 19:03:51 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233657AbjAXTDu (ORCPT ); Tue, 24 Jan 2023 14:03:50 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42334 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233948AbjAXTDi (ORCPT ); Tue, 24 Jan 2023 14:03:38 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id D37CD4B4AD; Tue, 24 Jan 2023 11:03:36 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587016; x=1706123016; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=tWcH+ezRg/kwhnexReKYcxZ35N6BGIua5vM2sIwNQTk=; b=Mk0fZv9XTib/CnxVF7cFsl6jEabhf0ZhKIEg8MQkHQ4sfKkAwXyIL9Gv NuuSLyb3+R/wLGRZ2C8H3cdZmwJO+kboQ+k2YjURvBmSaEcbl9U7HomYf mP/ZgCQgo8erLsTyiTPhdNWynGlm0rXjHogFdD8qt370SM6FWqGGCrTkn DIr0J4lHjsdeeblx/BB0ZPr1FYNqrPfn2DhudxHJcOf1T3CQbNBFRR9TD EYHVr+x4dXdyGL8EiYkuUIZBOr5DeRap3A0zM7kTP4qB2i1TuTVemgG0b sTq5r3dmUbb/39jp0MwVf1jNgHPVXtA1SKbVRGiFGUeUH21HjOTTmvZUe g==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472946" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:03:35 +0800 IronPort-SDR: fJs1s7gmOLNq7Je/V8kF43nePRhq8ysOcT3P4SBFAfjS7j6h3gdS9T0mCj6iCvAJ+MuH4P1nbG lprySJXpg5cUGeiZ5qCW9toreFlg9IDz6gjP3x+64pLuchSlSTwQbjA/NpiOlGxXLMl1WpbiwU qnVKC2HJsW52Vn6cWr20QcEnX7Oe2N8H3bgmUBNvHzjOLeYTG+C4fmYkGi1jOPk9oIYz3DSmM2 loibBF/lBnfV2iZij4XrPR83JeNfTPePaUbmH2ZxxsSZBoAZ4jW2IY6mPgCkCM2jgdJ69pIVU1 OKg= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:15:23 -0800 IronPort-SDR: 4b6pU8JszX5Mkv6QEpiCtvIFA456383YlzbSajRm2w02XgkZiiwUseX9z+J3Cd5kuTCNYIPWO2 tVwqp5azQah9eTKE08vOqK2WahLi44Z8xm4CHLcAiBKrjqDdJ4OUxdVPP5x5LExCIcGfOIyFiS oOJ6w5dbKma2ceCOPBdjPDMksSXr6kiZehvE/58inyGT5mU4cLVvviO+0hyaD6uPbIbJEV8S0f kXxrBdFUG40TzrAz+MQXVaWOS1msm0QoV2pJ1oHIVStUn9ADW0/LWZy1+GuYub+i4Pl3UHmVvB GlQ= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:03:33 -0800 From: Niklas Cassel To: "James E.J. Bottomley" , "Martin K. Petersen" Cc: Christoph Hellwig , Hannes Reinecke , Damien Le Moal , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel Subject: [PATCH v3 06/18] scsi: support service action in scsi_report_opcode() Date: Tue, 24 Jan 2023 20:02:52 +0100 Message-Id: <20230124190308.127318-7-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org From: Damien Le Moal The REPORT_SUPPORTED_OPERATION_CODES command allows checking for support of commands that have the same opcode but different service actions, such as READ 32 and WRITE 32. However, the current implementation of scsi_report_opcode() only allows checking an operation code without a service action differentiation. Add the "sa" argument to scsi_report_opcode() to allow passing a service action. If a non-zero service action is specified, the reporting options field value is set to 3 to have the service action field taken into account by the device. If no service action field is specified (zero), the reporting options field is set to 1 as before. Signed-off-by: Damien Le Moal Signed-off-by: Niklas Cassel Reviewed-by: Hannes Reinecke Reviewed-by: Christoph Hellwig Reviewed-by: Bart Van Assche --- drivers/scsi/scsi.c | 28 +++++++++++++++++++--------- drivers/scsi/sd.c | 10 +++++----- include/scsi/scsi_device.h | 5 +++-- 3 files changed, 27 insertions(+), 16 deletions(-) diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c index 00ee47a04403..579c3153b9f3 100644 --- a/drivers/scsi/scsi.c +++ b/drivers/scsi/scsi.c @@ -494,18 +494,22 @@ void scsi_attach_vpd(struct scsi_device *sdev) } /** - * scsi_report_opcode - Find out if a given command opcode is supported + * scsi_report_opcode - Find out if a given command is supported * @sdev: scsi device to query * @buffer: scratch buffer (must be at least 20 bytes long) * @len: length of buffer - * @opcode: opcode for command to look up - * - * Uses the REPORT SUPPORTED OPERATION CODES to look up the given - * opcode. Returns -EINVAL if RSOC fails, 0 if the command opcode is - * unsupported and 1 if the device claims to support the command. + * @opcode: opcode for the command to look up + * @sa: service action for the command to look up + * + * Uses the REPORT SUPPORTED OPERATION CODES to check support for the + * command identified with @opcode and @sa. If the command does not + * have a service action, @sa must be 0. Returns -EINVAL if RSOC fails, + * 0 if the command is not supported and 1 if the device claims to + * support the command. */ int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer, - unsigned int len, unsigned char opcode) + unsigned int len, unsigned char opcode, + unsigned short sa) { unsigned char cmd[16]; struct scsi_sense_hdr sshdr; @@ -529,8 +533,14 @@ int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer, memset(cmd, 0, 16); cmd[0] = MAINTENANCE_IN; cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES; - cmd[2] = 1; /* One command format */ - cmd[3] = opcode; + if (!sa) { + cmd[2] = 1; /* One command format */ + cmd[3] = opcode; + } else { + cmd[2] = 3; /* One command format with service action */ + cmd[3] = opcode; + put_unaligned_be16(sa, &cmd[4]); + } put_unaligned_be32(request_len, &cmd[6]); memset(buffer, 0, len); diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c index 7582e02a8d5a..45945bfeee92 100644 --- a/drivers/scsi/sd.c +++ b/drivers/scsi/sd.c @@ -3058,7 +3058,7 @@ static void sd_read_write_same(struct scsi_disk *sdkp, unsigned char *buffer) return; } - if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, INQUIRY) < 0) { + if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, INQUIRY, 0) < 0) { struct scsi_vpd *vpd; sdev->no_report_opcodes = 1; @@ -3074,10 +3074,10 @@ static void sd_read_write_same(struct scsi_disk *sdkp, unsigned char *buffer) rcu_read_unlock(); } - if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, WRITE_SAME_16) == 1) + if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, WRITE_SAME_16, 0) == 1) sdkp->ws16 = 1; - if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, WRITE_SAME) == 1) + if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, WRITE_SAME, 0) == 1) sdkp->ws10 = 1; } @@ -3089,9 +3089,9 @@ static void sd_read_security(struct scsi_disk *sdkp, unsigned char *buffer) return; if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, - SECURITY_PROTOCOL_IN) == 1 && + SECURITY_PROTOCOL_IN, 0) == 1 && scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, - SECURITY_PROTOCOL_OUT) == 1) + SECURITY_PROTOCOL_OUT, 0) == 1) sdkp->security = 1; } diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h index 15e005982032..8978c2a58702 100644 --- a/include/scsi/scsi_device.h +++ b/include/scsi/scsi_device.h @@ -431,8 +431,9 @@ extern int scsi_test_unit_ready(struct scsi_device *sdev, int timeout, int retries, struct scsi_sense_hdr *sshdr); extern int scsi_get_vpd_page(struct scsi_device *, u8 page, unsigned char *buf, int buf_len); -extern int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer, - unsigned int len, unsigned char opcode); +int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer, + unsigned int len, unsigned char opcode, + unsigned short sa); extern int scsi_device_set_state(struct scsi_device *sdev, enum scsi_device_state state); extern struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type, From patchwork Tue Jan 24 19:02:53 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114599 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2E623C54EAA for ; Tue, 24 Jan 2023 19:03:54 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234494AbjAXTDw (ORCPT ); Tue, 24 Jan 2023 14:03:52 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42188 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234518AbjAXTDs (ORCPT ); Tue, 24 Jan 2023 14:03:48 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 09EE24DCD9; Tue, 24 Jan 2023 11:03:40 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587019; x=1706123019; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=ceUiXUdpTlHvuIOy8MkLv0jGn2gaE71+QVXaVKn2ryI=; b=UIDB5gnkwgFWwK281iG8cVfNUNek3cScMnvQBNMGsXzAKXc/89nBWA89 ijWQD+ERsgt1mnGtL3buAe/yY664TayMPAnJz70pLgg8FBW0LuRJRz5sz OmUyH1aR9SlMnjGFs8lNZVFCCCPY2ZCe36rDzyCnaDl1mkmyqtDmVQSSm I9hpe6ymurZzubyk1yri/rMDlXweOyN7OGTvfUpUMfMXobLphb5nDVl5w ClBMWKEzBU3TdxlqrhBQDkX246fK13Xf/xLGGOSZ69OdzJ0oetvPXq1I1 qW+koXXQRYD6icMhZDaxSF5f73a8H5sPtnUCuNEMvyQnMF802WfBGTyH3 A==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472957" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:03:39 +0800 IronPort-SDR: P84jq6l6IstsXsEe8sv2N5SMSxxXvJIl1pPezklMHujawbJZ3X3CD7NSx4y5VG+v60nPzmlvJL c6cMbUjAjCfXX3gR3/rgGJvUnosPxtJqlyPpa2N4L7qJDCpPBGV/j36GOvCWi28RfH7hkO7tNh 1fxO8pnBExrKWw8l4Y96IB0gW+FjalE2dAcfz+VnA7H9FzgwEgBZg8fP41Or1B354vVDcmnwFS X6FG111NU0vL2XQDZW2N8IPVQRftm6S+tOe3CT944Wf3mAlHqlG2QJGkZ0VavaHDOE09Qrt0SI 3F0= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:15:27 -0800 IronPort-SDR: yTWCekvwoxo/SzE3e7LFDNu6MLCqs0fADYFkVZsB85ylbXQhPPd0On6A/v/PiXa+OCrQlJWNDn C5thJTIA3hXL2szY4O9woiQwP/1siDytKS8V3kihPS4bvS/p3Oy7Ei6KaSfXhw12nNvCiEtEG9 O6LdTE5nKOPEfJzG2VqMU4FgXF6r682d5AqPRLiDW8PHDUTUeobWU9L7GLgXUeJWQXBT99xV9s AsVnpW6Hex7BFumO9dRwndQNymCiL7taejQXg9vjVpUsOweqFh2CvzUOjHJiMG0L3SkFLf3Aet vPI= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:03:37 -0800 From: Niklas Cassel To: "James E.J. Bottomley" , "Martin K. Petersen" Cc: Christoph Hellwig , Hannes Reinecke , Damien Le Moal , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel Subject: [PATCH v3 07/18] scsi: sd: detect support for command duration limits Date: Tue, 24 Jan 2023 20:02:53 +0100 Message-Id: <20230124190308.127318-8-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org From: Damien Le Moal Detect if a disk supports command duration limits. Support for the READ 16, WRITE 16, READ 32 and WRITE 32 commands is tested using the function scsi_report_opcode(). For a disk supporting command duration limits, the mode page indicating the command duration limits descriptors that apply to the command is indicated using the rwcdlp and cdlp bits. Support duration limits is advertizes through sysfs using the new "duration_limits" sysfs sub-directory of the generic device directory, that is, /sys/block/sdX/device/duration_limits. Within this new directory, the limit descriptors that apply to read and write operations are exposed within the read and write directories, with descriptor attributes grouped together in directories. The overall sysfs structure created is: /sys/block/sde/device/duration_limits/ ├── perf_vs_duration_guideline ├── read │   ├── 1 │   │   ├── duration_guideline │   │   ├── duration_guideline_policy │   │   ├── max_active_time │   │   ├── max_active_time_policy │   │   ├── max_inactive_time │   │   └── max_inactive_time_policy │   ├── 2 │   │   ├── duration_guideline ... │   └── page └── write ├── 1 │   ├── duration_guideline │   ├── duration_guideline_policy ... For each of the read and write descriptor directories, the page attribute file indicate the command duration limit page providing the descriptors. The possible values for the page attribute are "A", "B", "T2A" and "T2B". The new "duration_limits" attributes directory is added only for disks that supports command duration limits. Signed-off-by: Damien Le Moal Signed-off-by: Niklas Cassel Reviewed-by: Hannes Reinecke --- drivers/scsi/Makefile | 2 +- drivers/scsi/sd.c | 2 + drivers/scsi/sd.h | 61 ++++ drivers/scsi/sd_cdl.c | 764 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 828 insertions(+), 1 deletion(-) create mode 100644 drivers/scsi/sd_cdl.c diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile index f055bfd54a68..0e48cb6d21d6 100644 --- a/drivers/scsi/Makefile +++ b/drivers/scsi/Makefile @@ -170,7 +170,7 @@ scsi_mod-$(CONFIG_BLK_DEV_BSG) += scsi_bsg.o hv_storvsc-y := storvsc_drv.o -sd_mod-objs := sd.o +sd_mod-objs := sd.o sd_cdl.o sd_mod-$(CONFIG_BLK_DEV_INTEGRITY) += sd_dif.o sd_mod-$(CONFIG_BLK_DEV_ZONED) += sd_zbc.o diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c index 45945bfeee92..7879a5470773 100644 --- a/drivers/scsi/sd.c +++ b/drivers/scsi/sd.c @@ -3326,6 +3326,7 @@ static int sd_revalidate_disk(struct gendisk *disk) sd_read_write_same(sdkp, buffer); sd_read_security(sdkp, buffer); sd_config_protection(sdkp); + sd_read_cdl(sdkp, buffer); } /* @@ -3646,6 +3647,7 @@ static void scsi_disk_release(struct device *dev) ida_free(&sd_index_ida, sdkp->index); sd_zbc_free_zone_info(sdkp); + sd_cdl_release(sdkp); put_device(&sdkp->device->sdev_gendev); free_opal_dev(sdkp->opal_dev); diff --git a/drivers/scsi/sd.h b/drivers/scsi/sd.h index 5eea762f84d1..e60d33bd222a 100644 --- a/drivers/scsi/sd.h +++ b/drivers/scsi/sd.h @@ -81,6 +81,62 @@ struct zoned_disk_info { u32 zone_blocks; }; +/* + * Command duration limits sub-pages for the control mode page 0Ah. + */ +enum sd_cdlp { + SD_CDLP_A, + SD_CDLP_B, + SD_CDLP_T2A, + SD_CDLP_T2B, + SD_CDLP_NONE, + + SD_CDL_MAX_PAGES = SD_CDLP_NONE, +}; + +enum sd_cdl_cmd { + SD_CDL_READ_16, + SD_CDL_WRITE_16, + SD_CDL_READ_32, + SD_CDL_WRITE_32, + + SD_CDL_CMD_MAX, +}; + +enum sd_cdl_rw { + SD_CDL_READ, + SD_CDL_WRITE, + SD_CDL_RW, +}; + +struct sd_cdl_desc { + struct kobject kobj; + u64 max_inactive_time; + u64 max_active_time; + u64 duration; + u8 max_inactive_policy; + u8 max_active_policy; + u8 duration_policy; + u8 cdlp; +}; + +#define SD_CDL_MAX_DESC 7 + +struct sd_cdl_page { + struct kobject kobj; + bool sysfs_registered; + enum sd_cdl_rw rw; + enum sd_cdlp cdlp; + struct sd_cdl_desc descs[SD_CDL_MAX_DESC]; +}; + +struct sd_cdl { + struct kobject kobj; + bool sysfs_registered; + u8 perf_vs_duration_guideline; + struct sd_cdl_page pages[SD_CDL_RW]; +}; + struct scsi_disk { struct scsi_device *device; @@ -131,6 +187,7 @@ struct scsi_disk { u8 provisioning_mode; u8 zeroing_mode; u8 nr_actuators; /* Number of actuators */ + struct sd_cdl *cdl; unsigned ATO : 1; /* state of disk ATO bit */ unsigned cache_override : 1; /* temp override of WCE,RCD */ unsigned WCE : 1; /* state of disk WCE bit */ @@ -295,4 +352,8 @@ static inline blk_status_t sd_zbc_prepare_zone_append(struct scsi_cmnd *cmd, void sd_print_sense_hdr(struct scsi_disk *sdkp, struct scsi_sense_hdr *sshdr); void sd_print_result(const struct scsi_disk *sdkp, const char *msg, int result); +/* Command duration limits support (in sd_cdl.c) */ +void sd_read_cdl(struct scsi_disk *sdkp, unsigned char *buf); +void sd_cdl_release(struct scsi_disk *sdkp); + #endif /* _SCSI_DISK_H */ diff --git a/drivers/scsi/sd_cdl.c b/drivers/scsi/sd_cdl.c new file mode 100644 index 000000000000..513cd989f19a --- /dev/null +++ b/drivers/scsi/sd_cdl.c @@ -0,0 +1,764 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * SCSI Command Duration Limits (CDL) + * + * Copyright (C) 2021 Western Digital Corporation or its affiliates. + */ +#include +#include + +#include + +#include +#include + +#include "sd.h" + +/* + * Command duration limits sub-pages for the control mode page 0Ah. + */ +static const struct sd_cdlp_info { + u8 subpage; + char *name; +} cdl_page[SD_CDL_MAX_PAGES + 1] = { + { 0x03, "A" }, + { 0x04, "B" }, + { 0x07, "T2A" }, + { 0x08, "T2B" }, + { 0x00, "none" }, +}; + +static const struct sd_cdl_cmd_info { + u8 opcode; + u16 sa; + char *name; +} cdl_cmd[SD_CDL_CMD_MAX] = { + { READ_16, 0, "READ_16" }, + { WRITE_16, 0, "WRITE_16" }, + { VARIABLE_LENGTH_CMD, READ_32, "READ_32" }, + { VARIABLE_LENGTH_CMD, WRITE_32, "WRITE_32" }, +}; + +static const char *sd_cdl_perf_name(u8 val) +{ + switch (val) { + case 0x00: + return "0"; + case 0x01: + return "0.5"; + case 0x02: + return "1.0"; + case 0x03: + return "1.5"; + case 0x04: + return "2.0"; + case 0x05: + return "2.5"; + case 0x06: + return "3"; + case 0x07: + return "4"; + case 0x08: + return "5"; + case 0x09: + return "8"; + case 0x0A: + return "10"; + case 0x0B: + return "15"; + case 0x0C: + return "20"; + default: + return "?"; + } +} + +static const char *sd_cdl_policy_name(u8 policy) +{ + switch (policy) { + case 0x00: + return "complete-earliest"; + case 0x01: + return "continue-next-limit"; + case 0x02: + return "continue-no-limit"; + case 0x0d: + return "complete-unavailable"; + case 0x0e: + return "abort-recovery"; + case 0x0f: + return "abort"; + default: + return "?"; + } +} + +/* + * Command duration limits descriptors sysfs plumbing. + */ +struct sd_cdl_desc_sysfs_entry { + struct attribute attr; + ssize_t (*show)(struct sd_cdl_desc *desc, char *buf); +}; + +#define CDL_DESC_ATTR_RO(_name) \ + static struct sd_cdl_desc_sysfs_entry \ + cdl_desc_##_name##_entry = { \ + .attr = { .name = __stringify(_name), .mode = 0444 }, \ + .show = cdl_desc_##_name##_show, \ + } + +static ssize_t cdl_desc_max_inactive_time_show(struct sd_cdl_desc *desc, + char *buf) +{ + return sysfs_emit(buf, "%llu\n", desc->max_inactive_time); +} +CDL_DESC_ATTR_RO(max_inactive_time); + +static ssize_t cdl_desc_max_inactive_time_policy_show(struct sd_cdl_desc *desc, + char *buf) +{ + return sysfs_emit(buf, "%s\n", + sd_cdl_policy_name(desc->max_inactive_policy)); +} +CDL_DESC_ATTR_RO(max_inactive_time_policy); + +static ssize_t cdl_desc_max_active_time_show(struct sd_cdl_desc *desc, + char *buf) +{ + return sysfs_emit(buf, "%llu\n", desc->max_active_time); +} +CDL_DESC_ATTR_RO(max_active_time); + +static ssize_t cdl_desc_max_active_time_policy_show(struct sd_cdl_desc *desc, + char *buf) +{ + return sysfs_emit(buf, "%s\n", + sd_cdl_policy_name(desc->max_active_policy)); +} +CDL_DESC_ATTR_RO(max_active_time_policy); + +static ssize_t cdl_desc_duration_guideline_show(struct sd_cdl_desc *desc, + char *buf) +{ + return sysfs_emit(buf, "%llu\n", desc->duration); +} +CDL_DESC_ATTR_RO(duration_guideline); + +static ssize_t cdl_desc_duration_guideline_policy_show(struct sd_cdl_desc *desc, + char *buf) +{ + return sysfs_emit(buf, "%s\n", + sd_cdl_policy_name(desc->duration_policy)); +} +CDL_DESC_ATTR_RO(duration_guideline_policy); + +static umode_t sd_cdl_desc_attr_visible(struct kobject *kobj, + struct attribute *attr, int n) +{ + struct sd_cdl_desc *desc = container_of(kobj, struct sd_cdl_desc, kobj); + + /* + * Descriptors in pages A and B only have the duration guideline + * field. + */ + if ((desc->cdlp == SD_CDLP_A || desc->cdlp == SD_CDLP_B) && + (attr != &cdl_desc_duration_guideline_entry.attr)) + return 0; + + return attr->mode; +} + +static struct attribute *sd_cdl_desc_attrs[] = { + &cdl_desc_max_inactive_time_entry.attr, + &cdl_desc_max_inactive_time_policy_entry.attr, + &cdl_desc_max_active_time_entry.attr, + &cdl_desc_max_active_time_policy_entry.attr, + &cdl_desc_duration_guideline_entry.attr, + &cdl_desc_duration_guideline_policy_entry.attr, + NULL, +}; + +static const struct attribute_group sd_cdl_desc_group = { + .attrs = sd_cdl_desc_attrs, + .is_visible = sd_cdl_desc_attr_visible, +}; +__ATTRIBUTE_GROUPS(sd_cdl_desc); + +static ssize_t sd_cdl_desc_sysfs_show(struct kobject *kobj, + struct attribute *attr, char *buf) +{ + struct sd_cdl_desc_sysfs_entry *entry = + container_of(attr, struct sd_cdl_desc_sysfs_entry, attr); + struct sd_cdl_desc *desc = container_of(kobj, struct sd_cdl_desc, kobj); + + return entry->show(desc, buf); +} + +static const struct sysfs_ops sd_cdl_desc_sysfs_ops = { + .show = sd_cdl_desc_sysfs_show, +}; + +static void sd_cdl_sysfs_nop_release(struct kobject *kobj) { } + +static struct kobj_type sd_cdl_desc_ktype = { + .sysfs_ops = &sd_cdl_desc_sysfs_ops, + .default_groups = sd_cdl_desc_groups, + .release = sd_cdl_sysfs_nop_release, +}; + +/* + * Duration limits page sysfs plumbing. + */ +struct sd_cdl_page_sysfs_entry { + struct attribute attr; + ssize_t (*show)(struct sd_cdl_page *page, char *buf); +}; + +#define CDL_PAGE_ATTR_RO(_name) \ + static struct sd_cdl_page_sysfs_entry \ + cdl_page_##_name##_entry = { \ + .attr = { .name = __stringify(_name), .mode = 0444 }, \ + .show = cdl_page_##_name##_show, \ + } + +static ssize_t cdl_page_page_show(struct sd_cdl_page *page, char *buf) +{ + return sysfs_emit(buf, "%s\n", cdl_page[page->cdlp].name); +} +CDL_PAGE_ATTR_RO(page); + +static struct attribute *sd_cdl_page_attrs[] = { + &cdl_page_page_entry.attr, + NULL, +}; + +static const struct attribute_group sd_cdl_page_group = { + .attrs = sd_cdl_page_attrs, +}; +__ATTRIBUTE_GROUPS(sd_cdl_page); + +static ssize_t sd_cdl_page_sysfs_show(struct kobject *kobj, + struct attribute *attr, char *buf) +{ + struct sd_cdl_page_sysfs_entry *entry = + container_of(attr, struct sd_cdl_page_sysfs_entry, attr); + struct sd_cdl_page *page = container_of(kobj, struct sd_cdl_page, kobj); + + return entry->show(page, buf); +} + +static const struct sysfs_ops sd_cdl_page_sysfs_ops = { + .show = sd_cdl_page_sysfs_show, +}; + +static struct kobj_type sd_cdl_page_ktype = { + .sysfs_ops = &sd_cdl_page_sysfs_ops, + .default_groups = sd_cdl_page_groups, + .release = sd_cdl_sysfs_nop_release, +}; + +static void sd_cdl_sysfs_unregister_page(struct sd_cdl_page *page) +{ + int i; + + for (i = 0; i < SD_CDL_MAX_DESC; i++) { + if (page->sysfs_registered) + kobject_del(&page->descs[i].kobj); + kobject_put(&page->descs[i].kobj); + } + if (page->sysfs_registered) + kobject_del(&page->kobj); + kobject_put(&page->kobj); + + page->cdlp = SD_CDLP_NONE; + page->sysfs_registered = false; +} + +static int sd_cdl_sysfs_register_page(struct scsi_disk *sdkp, + struct sd_cdl_page *page) +{ + int i, ret; + + /* + * If the page is already registered, the updated page descriptors + * are already exported. + */ + if (page->sysfs_registered) + return 0; + + ret = kobject_add(&page->kobj, &sdkp->cdl->kobj, + "%s", page->rw ? "write" : "read"); + if (ret) { + kobject_put(&page->kobj); + return ret; + } + + for (i = 0; i < SD_CDL_MAX_DESC; i++) { + ret = kobject_add(&page->descs[i].kobj, &page->kobj, + "%d", i + 1); + if (ret) { + int j; + + kobject_put(&page->descs[i].kobj); + for (j = 0; j < SD_CDL_MAX_DESC; j++) { + if (j < i) + kobject_del(&page->descs[j].kobj); + kobject_put(&page->descs[j].kobj); + } + kobject_del(&page->kobj); + kobject_put(&page->kobj); + return ret; + } + } + + page->sysfs_registered = true; + + return 0; +} + +/* + * Command duration limits sysfs plumbing, top level (duration limits directory + * under the "device" sysfs directory. + */ +struct sd_cdl_sysfs_entry { + struct attribute attr; + ssize_t (*show)(struct sd_cdl *cdl, char *buf); +}; + +#define CDL_ATTR_RO(_name) \ + static struct sd_cdl_sysfs_entry cdl_##_name##_entry = { \ + .attr = { .name = __stringify(_name), .mode = 0444 }, \ + .show = cdl_##_name##_show, \ + } + +static ssize_t cdl_perf_vs_duration_guideline_show(struct sd_cdl *cdl, + char *buf) +{ + return sysfs_emit(buf, "%s\n", + sd_cdl_perf_name(cdl->perf_vs_duration_guideline)); +} +CDL_ATTR_RO(perf_vs_duration_guideline); + +static struct attribute *sd_cdl_attrs[] = { + &cdl_perf_vs_duration_guideline_entry.attr, + NULL, +}; + +static umode_t sd_cdl_attr_visible(struct kobject *kobj, + struct attribute *attr, int n) +{ + struct sd_cdl *cdl = container_of(kobj, struct sd_cdl, kobj); + + /* perf_vs_duration_guideline exists only if page T2A is supported */ + if (attr == &cdl_perf_vs_duration_guideline_entry.attr && + cdl->pages[SD_CDL_READ].cdlp != SD_CDLP_T2A && + cdl->pages[SD_CDL_WRITE].cdlp != SD_CDLP_T2A) + return 0; + + return attr->mode; +} + +static const struct attribute_group sd_cdl_group = { + .attrs = sd_cdl_attrs, + .is_visible = sd_cdl_attr_visible, +}; +__ATTRIBUTE_GROUPS(sd_cdl); + +static ssize_t sd_cdl_sysfs_show(struct kobject *kobj, + struct attribute *attr, char *page) +{ + struct sd_cdl_sysfs_entry *entry = + container_of(attr, struct sd_cdl_sysfs_entry, attr); + struct sd_cdl *cdl = container_of(kobj, struct sd_cdl, kobj); + + return entry->show(cdl, page); +} + +static const struct sysfs_ops sd_cdl_sysfs_ops = { + .show = sd_cdl_sysfs_show, +}; + +static void sd_cdl_sysfs_release(struct kobject *kobj) +{ + struct sd_cdl *cdl = container_of(kobj, struct sd_cdl, kobj); + + kfree(cdl); +} + +static struct kobj_type sd_cdl_ktype = { + .sysfs_ops = &sd_cdl_sysfs_ops, + .default_groups = sd_cdl_groups, + .release = sd_cdl_sysfs_release, +}; + +static void sd_cdl_sysfs_unregister(struct scsi_disk *sdkp) +{ + struct sd_cdl *cdl = NULL; + int i; + + swap(sdkp->cdl, cdl); + if (!cdl) + return; + + if (!cdl->sysfs_registered) { + kfree(cdl); + return; + } + + for (i = 0; i < SD_CDL_RW; i++) { + if (cdl->pages[i].sysfs_registered) + sd_cdl_sysfs_unregister_page(&cdl->pages[i]); + } + + kobject_del(&cdl->kobj); + kobject_put(&cdl->kobj); +} + +static void sd_cdl_sysfs_register(struct scsi_disk *sdkp) +{ + struct scsi_device *sdev = sdkp->device; + struct sd_cdl *cdl = sdkp->cdl; + struct sd_cdl_page *page; + int i, ret; + + if (!cdl->sysfs_registered) { + ret = kobject_add(&cdl->kobj, &sdev->sdev_gendev.kobj, + "duration_limits"); + if (ret) { + kobject_put(&cdl->kobj); + goto unregister; + } + + cdl->sysfs_registered = true; + } + + /* Check if the pages changed */ + for (i = 0; i < SD_CDL_RW; i++) { + page = &cdl->pages[i]; + if (page->cdlp == SD_CDLP_NONE) { + sd_cdl_sysfs_unregister_page(page); + continue; + } + + ret = sd_cdl_sysfs_register_page(sdkp, page); + if (ret) { + page->cdlp = SD_CDLP_NONE; + goto unregister; + } + } + + return; + +unregister: + sd_cdl_sysfs_unregister(sdkp); +} + +/* + * CDL pages A and B time limits in microseconds. + */ +static u64 sd_cdl_time(u8 *buf, u8 cdlunit) +{ + u64 val = get_unaligned_be16(buf); + u64 factor; + + switch (cdlunit) { + case 0x00: + return 0; + case 0x04: + /* 1 microsecond */ + factor = NSEC_PER_USEC; + break; + case 0x05: + /* 10 milliseconds */ + factor = 10ULL * USEC_PER_MSEC; + break; + case 0x06: + /* 500 milliseconds */ + factor = 500ULL * USEC_PER_MSEC; + break; + default: + return 0; + } + + return val * factor; +} + +/* + * CDL pages T2A and T2B time limits in microseconds. + */ +static u64 sd_cdl_t2time(u8 *buf, u8 t2cdlunits) +{ + u64 val = get_unaligned_be16(buf); + u64 factor; + + switch (t2cdlunits) { + case 0x00: + return 0; + case 0x06: + /* 500 nanoseconds */ + factor = 500; + break; + case 0x08: + /* 1 microsecond */ + factor = NSEC_PER_USEC; + break; + case 0x0A: + /* 10 milliseconds */ + factor = 10ULL * NSEC_PER_MSEC; + break; + case 0x0E: + /* 500 milliseconds */ + factor = 500ULL * NSEC_PER_MSEC; + break; + default: + return 0; + } + + val *= factor; + do_div(val, NSEC_PER_USEC); + + return val; +} + +static int sd_cdl_read_page(struct scsi_disk *sdkp, struct sd_cdl_page *page, + unsigned char *buf) +{ + struct sd_cdl *cdl = sdkp->cdl; + struct sd_cdl_desc *desc = &page->descs[0]; + u8 cdlp = page->cdlp; + struct scsi_mode_data data; + int i, ret; + + ret = scsi_mode_sense(sdkp->device, 0x08, 0x0a, cdl_page[cdlp].subpage, + buf, SD_BUF_SIZE, SD_TIMEOUT, sdkp->max_retries, + &data, NULL); + if (ret) { + sd_printk(KERN_ERR, sdkp, + "Command duration limits: read CDL page %s failed\n", + cdl_page[cdlp].name); + return ret; + } + buf += data.header_length + data.block_descriptor_length; + + if (cdlp == SD_CDLP_A || cdlp == SD_CDLP_B) { + buf += 8; + + for (i = 0; i < SD_CDL_MAX_DESC; i++, buf += 4, desc++) { + u8 cdlunit = (buf[0] & 0xe0) >> 5; + + desc->duration = sd_cdl_time(&buf[2], cdlunit); + desc->cdlp = cdlp; + } + } else { + /* T2A and T2B limits page */ + if (cdlp == SD_CDLP_T2A) + cdl->perf_vs_duration_guideline = buf[7] >> 4; + + buf += 8; + + for (i = 0; i < SD_CDL_MAX_DESC; i++, buf += 32, desc++) { + u8 t2cdlunits = buf[0] & 0x0f; + + desc->max_inactive_time = + sd_cdl_t2time(&buf[2], t2cdlunits); + desc->max_active_time = + sd_cdl_t2time(&buf[4], t2cdlunits); + desc->duration = + sd_cdl_t2time(&buf[10], t2cdlunits); + desc->max_inactive_policy = (buf[6] >> 4) & 0x0f; + desc->max_active_policy = buf[6] & 0x0f; + desc->duration_policy = buf[14] & 0x0f; + desc->cdlp = cdlp; + } + } + + return 0; +} + +static int sd_cdl_read_pages(struct scsi_disk *sdkp, enum sd_cdlp *rw_cdlp, + unsigned char *buf) +{ + struct sd_cdl *cdl = sdkp->cdl; + struct sd_cdl_page *page; + int i, ret; + + /* Read supported pages */ + for (i = 0; i < SD_CDL_RW; i++) { + page = &cdl->pages[i]; + page->cdlp = rw_cdlp[i]; + if (page->cdlp == SD_CDLP_NONE) + continue; + + ret = sd_cdl_read_page(sdkp, page, buf); + if (ret) { + page->cdlp = SD_CDLP_NONE; + return ret; + } + } + + return 0; +} + +static u8 sd_cdl_check_cmd_support(struct scsi_disk *sdkp, + enum sd_cdl_cmd cmd, unsigned char *buf) +{ + u8 opcode = cdl_cmd[cmd].opcode; + u16 sa = cdl_cmd[cmd].sa; + u8 cdlp; + + /* + * READ 32 and WRITE 32 are used only for disks that also support + * type 2 data protection. If the disk does not have such feature, + * ignore these commands. + */ + if ((sa == READ_32 || sa == WRITE_32) && + sdkp->protection_type != T10_PI_TYPE2_PROTECTION) + return SD_CDLP_NONE; + + /* Check operation code */ + if (scsi_report_opcode(sdkp->device, buf, SD_BUF_SIZE, opcode, sa) < 0) + return SD_CDLP_NONE; + + if ((buf[1] & 0x03) != 0x03) + return SD_CDLP_NONE; + + /* See SPC-6, one command format of REPORT SUPPORTED OPERATION CODES */ + cdlp = (buf[1] & 0x18) >> 3; + if (buf[0] & 0x01) { + /* rwcdlp == 1 */ + switch (cdlp) { + case 0x01: + return SD_CDLP_T2A; + case 0x02: + return SD_CDLP_T2B; + } + } else { + /* rwcdlp == 0 */ + switch (cdlp) { + case 0x01: + return SD_CDLP_A; + case 0x02: + return SD_CDLP_B; + } + } + + return SD_CDLP_NONE; +} + +static bool sd_cdl_supported(struct scsi_disk *sdkp, enum sd_cdlp *rw_cdlp, + unsigned char *buf) +{ + enum sd_cdlp cmd_cdlp[SD_CDL_CMD_MAX]; + int i; + + /* + * Command duration limits is supported for READ 16, WRITE 16, + * READ 32 and WRITE 32. Go through all these commands one at a time + * and check if any support duration limits. + */ + for (i = 0; i < SD_CDL_CMD_MAX; i++) + cmd_cdlp[i] = sd_cdl_check_cmd_support(sdkp, i, buf); + + /* + * Allow support only for drives that report the same CDL page for the + * read 16 and 32 variants and the same page for the write 16 and 32 + * variants. + */ + if (cmd_cdlp[SD_CDL_READ_32] != SD_CDLP_NONE && + cmd_cdlp[SD_CDL_READ_16] != SD_CDLP_NONE) { + if (cmd_cdlp[SD_CDL_READ_32] != cmd_cdlp[SD_CDL_READ_16]) + rw_cdlp[SD_CDL_READ] = SD_CDLP_NONE; + else + rw_cdlp[SD_CDL_READ] = cmd_cdlp[SD_CDL_READ_16]; + } else { + rw_cdlp[SD_CDL_READ] = cmd_cdlp[SD_CDL_READ_16]; + } + + if (cmd_cdlp[SD_CDL_WRITE_32] != SD_CDLP_NONE && + cmd_cdlp[SD_CDL_WRITE_16] != SD_CDLP_NONE) { + if (cmd_cdlp[SD_CDL_WRITE_32] != cmd_cdlp[SD_CDL_WRITE_16]) + rw_cdlp[SD_CDL_WRITE] = SD_CDLP_NONE; + else + rw_cdlp[SD_CDL_WRITE] = cmd_cdlp[SD_CDL_WRITE_16]; + } else { + rw_cdlp[SD_CDL_WRITE] = cmd_cdlp[SD_CDL_WRITE_16]; + } + + return rw_cdlp[SD_CDL_READ] != SD_CDLP_NONE || + rw_cdlp[SD_CDL_WRITE] != SD_CDLP_NONE; +} + +static struct sd_cdl *sd_cdl_alloc(void) +{ + struct sd_cdl *cdl; + struct sd_cdl_page *page; + int i, j; + + cdl = kzalloc(sizeof(struct sd_cdl), GFP_KERNEL); + if (!cdl) + return NULL; + + kobject_init(&cdl->kobj, &sd_cdl_ktype); + for (i = 0; i < SD_CDL_RW; i++) { + page = &cdl->pages[i]; + kobject_init(&page->kobj, &sd_cdl_page_ktype); + page->rw = i; + page->cdlp = SD_CDLP_NONE; + for (j = 0; j < SD_CDL_MAX_DESC; j++) + kobject_init(&page->descs[j].kobj, &sd_cdl_desc_ktype); + } + + return cdl; +} + +void sd_read_cdl(struct scsi_disk *sdkp, unsigned char *buf) +{ + struct sd_cdl *cdl = sdkp->cdl; + enum sd_cdlp rw_cdlp[SD_CDL_RW]; + + /* + * Check for CDL support. If the disk does not support duration limits, + * clear any support information that was previously registered. + */ + if (!sd_cdl_supported(sdkp, rw_cdlp, buf)) + goto unregister; + + if (!cdl) { + cdl = sd_cdl_alloc(); + if (!cdl) + return; + } + + /* + * We have CDL support: force the use of READ16/WRITE16. + * READ32 and WRITE32 will be used automatically for disks with + * T10_PI_TYPE2_PROTECTION support. + */ + sdkp->device->use_16_for_rw = 1; + sdkp->device->use_10_for_rw = 0; + + if (!sdkp->cdl) { + sd_printk(KERN_NOTICE, sdkp, + "Command duration limits supported, reads: %s, writes: %s\n", + cdl_page[rw_cdlp[SD_CDL_READ]].name, + cdl_page[rw_cdlp[SD_CDL_WRITE]].name); + sdkp->cdl = cdl; + } + + /* Update duration limits descriptor pages */ + if (sd_cdl_read_pages(sdkp, rw_cdlp, buf)) + goto unregister; + + sd_cdl_sysfs_register(sdkp); + + return; + +unregister: + sd_cdl_sysfs_unregister(sdkp); +} + +void sd_cdl_release(struct scsi_disk *sdkp) +{ + sd_cdl_sysfs_unregister(sdkp); +} From patchwork Tue Jan 24 19:02:54 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114600 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id A8D1FC54EAA for ; Tue, 24 Jan 2023 19:04:12 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234551AbjAXTEL (ORCPT ); Tue, 24 Jan 2023 14:04:11 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42506 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234552AbjAXTDt (ORCPT ); Tue, 24 Jan 2023 14:03:49 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 420E74ED06; Tue, 24 Jan 2023 11:03:43 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587022; x=1706123022; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=pobrlvYoTX/PYwboOlKJpMpvRa7MeZqJJlH3D+Ot7f0=; b=lzfklLEd8YYYQkL7U1f/CqiGO7rr0Mmr6aXv959NLWZ5zNpEqGc81SRL jIX4tu89pfEKhsOlVX3QZ9LqPM7qD3HclW4lNCRxUrBNvPyoailvTVXAG DVpFlNP/uGhnRS3lHf158ftKsUKZts2iPuNeoQRt518/lE3OYesm0Yky8 VqcIc/ABJloa240dwLYQCAKSLWPTpK4WwuVI370vxhUlhhUkgYT+SLffZ 6DD2h4/x5j5tZBNQFS5FEx3ybT/v+mhjvWdzeOqj6vVEORmiju3aB+zQA V8L7aC0XvXSN6McPc2taNPLmvcx6OuycszbCeCrH7Nt5PkvZspiwd5brw Q==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472959" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:03:42 +0800 IronPort-SDR: TleJzGUyYvCS1zz6JxtHRh8cfzmOPv6mGOyS6rtcMk6Lk5yidNDXNakPVLgnHJoIoNDVg7ZrIK b2Xq10WkxSL6FnvdbCylrIlwr5qt+PD1le0kcvocX3EBmcRAvjTS2haXljTig+WvnDSo5TZt6t h3RwT7VQ252ADC2VYjU1i/RZqTFHOpFj2LlsMHmi5Q1o4FSBemqR5BZSN3ZoFQwsYbT473mg3F df3ce04CWCWSxmRoXA6iO9uiEzhQSC8inoSuddrrg/vprv49RiRvxlBOlpE2NYY0F54RNcotA6 aVE= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:15:31 -0800 IronPort-SDR: 7sMVhInxPkSG7GR62Rs6+13eiRNKtmqENTSAP61lq2gDg+OIll5W0/3YfKe44SeT1rewgfBquZ Vn6oya7tyO9sFYhbDs3Z03RhXCKwsC94vyxGECcXS3e2Jx6GBrXxYQrsVK2JED6vc2f6wftIoz KglDDw0J4ul0UyOHZHPR6TNrQ/sHwOa28qLW+P4Tpc6XK9m0anjXogrefEnv6LoYBNtgL8Qzf/ cU/JyoGuAUVJejmu6evcIvFXFaFxOy8U+0AuoDK8LkfLreVWSY+ZjheSmlyYauJF4WzgOTFf5R DZI= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:03:40 -0800 From: Niklas Cassel To: "James E.J. Bottomley" , "Martin K. Petersen" Cc: Christoph Hellwig , Hannes Reinecke , Damien Le Moal , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel Subject: [PATCH v3 08/18] scsi: sd: set read/write commands CDL index Date: Tue, 24 Jan 2023 20:02:54 +0100 Message-Id: <20230124190308.127318-9-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org From: Damien Le Moal Introduce the command duration limits helper function sd_cdl_cmd_limit() to retrieve and set the DLD bits of the READ/WRITE 16 and READ/WRITE 32 commands to indicate to the device the command duration limit descriptor to apply to the command. When command duration limits are enabled, sd_cdl_cmd_limit() obtains the index of the descriptor to apply to the command for requests that have the IOPRIO_CLASS_DL priority class with a priority data sepcifying a valid descriptor index (1 to 7). The read-write sysfs attribute "enable" is introduced to control setting the command duration limits indexes. If this attribute is set to 0 (default), command duration limits specified by the user are ignored. The user must set this attribute to 1 for command duration limits to be set. Enabling and disabling the command duration limits feature for ATA devices must be done using the ATA feature sub-page of the control mode page. The sd_cdl_enable() function is introduced to check if this mode page is supported by the device and if it is, use it to enable/disable CDL. Signed-off-by: Damien Le Moal Co-developed-by: Niklas Cassel Signed-off-by: Niklas Cassel Reviewed-by: Hannes Reinecke --- drivers/scsi/sd.c | 16 +++-- drivers/scsi/sd.h | 10 ++++ drivers/scsi/sd_cdl.c | 134 +++++++++++++++++++++++++++++++++++++++++- 3 files changed, 152 insertions(+), 8 deletions(-) diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c index 7879a5470773..d2eb01337943 100644 --- a/drivers/scsi/sd.c +++ b/drivers/scsi/sd.c @@ -1045,13 +1045,14 @@ static blk_status_t sd_setup_flush_cmnd(struct scsi_cmnd *cmd) static blk_status_t sd_setup_rw32_cmnd(struct scsi_cmnd *cmd, bool write, sector_t lba, unsigned int nr_blocks, - unsigned char flags) + unsigned char flags, unsigned int dld) { cmd->cmd_len = SD_EXT_CDB_SIZE; cmd->cmnd[0] = VARIABLE_LENGTH_CMD; cmd->cmnd[7] = 0x18; /* Additional CDB len */ cmd->cmnd[9] = write ? WRITE_32 : READ_32; cmd->cmnd[10] = flags; + cmd->cmnd[11] = dld & 0x07; put_unaligned_be64(lba, &cmd->cmnd[12]); put_unaligned_be32(lba, &cmd->cmnd[20]); /* Expected Indirect LBA */ put_unaligned_be32(nr_blocks, &cmd->cmnd[28]); @@ -1061,12 +1062,12 @@ static blk_status_t sd_setup_rw32_cmnd(struct scsi_cmnd *cmd, bool write, static blk_status_t sd_setup_rw16_cmnd(struct scsi_cmnd *cmd, bool write, sector_t lba, unsigned int nr_blocks, - unsigned char flags) + unsigned char flags, unsigned int dld) { cmd->cmd_len = 16; cmd->cmnd[0] = write ? WRITE_16 : READ_16; - cmd->cmnd[1] = flags; - cmd->cmnd[14] = 0; + cmd->cmnd[1] = flags | ((dld >> 2) & 0x01); + cmd->cmnd[14] = (dld & 0x03) << 6; cmd->cmnd[15] = 0; put_unaligned_be64(lba, &cmd->cmnd[2]); put_unaligned_be32(nr_blocks, &cmd->cmnd[10]); @@ -1129,6 +1130,7 @@ static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd) unsigned int mask = logical_to_sectors(sdp, 1) - 1; bool write = rq_data_dir(rq) == WRITE; unsigned char protect, fua; + unsigned int dld = 0; blk_status_t ret; unsigned int dif; bool dix; @@ -1178,6 +1180,8 @@ static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd) fua = rq->cmd_flags & REQ_FUA ? 0x8 : 0; dix = scsi_prot_sg_count(cmd); dif = scsi_host_dif_capable(cmd->device->host, sdkp->protection_type); + if (sd_cdl_enabled(sdkp)) + dld = sd_cdl_dld(sdkp, cmd); if (dif || dix) protect = sd_setup_protect_cmnd(cmd, dix, dif); @@ -1186,10 +1190,10 @@ static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd) if (protect && sdkp->protection_type == T10_PI_TYPE2_PROTECTION) { ret = sd_setup_rw32_cmnd(cmd, write, lba, nr_blocks, - protect | fua); + protect | fua, dld); } else if (sdp->use_16_for_rw || (nr_blocks > 0xffff)) { ret = sd_setup_rw16_cmnd(cmd, write, lba, nr_blocks, - protect | fua); + protect | fua, dld); } else if ((nr_blocks > 0xff) || (lba > 0x1fffff) || sdp->use_10_for_rw || protect) { ret = sd_setup_rw10_cmnd(cmd, write, lba, nr_blocks, diff --git a/drivers/scsi/sd.h b/drivers/scsi/sd.h index e60d33bd222a..5b6b6dc4b92d 100644 --- a/drivers/scsi/sd.h +++ b/drivers/scsi/sd.h @@ -130,8 +130,11 @@ struct sd_cdl_page { struct sd_cdl_desc descs[SD_CDL_MAX_DESC]; }; +struct scsi_disk; + struct sd_cdl { struct kobject kobj; + struct scsi_disk *sdkp; bool sysfs_registered; u8 perf_vs_duration_guideline; struct sd_cdl_page pages[SD_CDL_RW]; @@ -188,6 +191,7 @@ struct scsi_disk { u8 zeroing_mode; u8 nr_actuators; /* Number of actuators */ struct sd_cdl *cdl; + unsigned cdl_enabled : 1; unsigned ATO : 1; /* state of disk ATO bit */ unsigned cache_override : 1; /* temp override of WCE,RCD */ unsigned WCE : 1; /* state of disk WCE bit */ @@ -355,5 +359,11 @@ void sd_print_result(const struct scsi_disk *sdkp, const char *msg, int result); /* Command duration limits support (in sd_cdl.c) */ void sd_read_cdl(struct scsi_disk *sdkp, unsigned char *buf); void sd_cdl_release(struct scsi_disk *sdkp); +int sd_cdl_dld(struct scsi_disk *sdkp, struct scsi_cmnd *scmd); + +static inline bool sd_cdl_enabled(struct scsi_disk *sdkp) +{ + return sdkp->cdl && sdkp->cdl_enabled; +} #endif /* _SCSI_DISK_H */ diff --git a/drivers/scsi/sd_cdl.c b/drivers/scsi/sd_cdl.c index 513cd989f19a..59d02dbb5ea1 100644 --- a/drivers/scsi/sd_cdl.c +++ b/drivers/scsi/sd_cdl.c @@ -93,6 +93,63 @@ static const char *sd_cdl_policy_name(u8 policy) } } +/* + * Enable/disable CDL. + */ +static int sd_cdl_enable(struct scsi_disk *sdkp, bool enable) +{ + struct scsi_device *sdp = sdkp->device; + struct scsi_mode_data data; + struct scsi_sense_hdr sshdr; + struct scsi_vpd *vpd; + bool is_ata = false; + char buf[64]; + int ret; + + rcu_read_lock(); + vpd = rcu_dereference(sdp->vpd_pg89); + if (vpd) + is_ata = true; + rcu_read_unlock(); + + /* + * For ATA devices, CDL needs to be enabled with a SET FEATURES command. + */ + if (is_ata) { + char *buf_data; + int len; + + ret = scsi_mode_sense(sdp, 0x08, 0x0a, 0xf2, buf, sizeof(buf), + SD_TIMEOUT, sdkp->max_retries, &data, + NULL); + if (ret) + return -EINVAL; + + /* Enable CDL using the ATA feature page */ + len = min_t(size_t, sizeof(buf), + data.length - data.header_length - + data.block_descriptor_length); + buf_data = buf + data.header_length + + data.block_descriptor_length; + if (enable) + buf_data[4] = 0x02; + else + buf_data[4] = 0; + + ret = scsi_mode_select(sdp, 1, 0, buf_data, len, SD_TIMEOUT, + sdkp->max_retries, &data, &sshdr); + if (ret) { + if (scsi_sense_valid(&sshdr)) + sd_print_sense_hdr(sdkp, &sshdr); + return -EINVAL; + } + } + + sdkp->cdl_enabled = enable; + + return 0; +} + /* * Command duration limits descriptors sysfs plumbing. */ @@ -324,6 +381,7 @@ static int sd_cdl_sysfs_register_page(struct scsi_disk *sdkp, struct sd_cdl_sysfs_entry { struct attribute attr; ssize_t (*show)(struct sd_cdl *cdl, char *buf); + ssize_t (*store)(struct sd_cdl *cdl, const char *buf, size_t length); }; #define CDL_ATTR_RO(_name) \ @@ -332,6 +390,13 @@ struct sd_cdl_sysfs_entry { .show = cdl_##_name##_show, \ } +#define CDL_ATTR_RW(_name) \ + static struct sd_cdl_sysfs_entry cdl_##_name##_entry = { \ + .attr = { .name = __stringify(_name), .mode = 0644 }, \ + .show = cdl_##_name##_show, \ + .store = cdl_##_name##_store, \ + } + static ssize_t cdl_perf_vs_duration_guideline_show(struct sd_cdl *cdl, char *buf) { @@ -340,8 +405,31 @@ static ssize_t cdl_perf_vs_duration_guideline_show(struct sd_cdl *cdl, } CDL_ATTR_RO(perf_vs_duration_guideline); +static ssize_t cdl_enable_show(struct sd_cdl *cdl, char *buf) +{ + return sysfs_emit(buf, "%d\n", (int)cdl->sdkp->cdl_enabled); +} + +static ssize_t cdl_enable_store(struct sd_cdl *cdl, + const char *buf, size_t count) +{ + int ret; + bool v; + + if (kstrtobool(buf, &v)) + return -EINVAL; + + ret = sd_cdl_enable(cdl->sdkp, v); + if (ret) + return ret; + + return count; +} +CDL_ATTR_RW(enable); + static struct attribute *sd_cdl_attrs[] = { &cdl_perf_vs_duration_guideline_entry.attr, + &cdl_enable_entry.attr, NULL, }; @@ -375,8 +463,25 @@ static ssize_t sd_cdl_sysfs_show(struct kobject *kobj, return entry->show(cdl, page); } +static ssize_t sd_cdl_sysfs_store(struct kobject *kobj, struct attribute *attr, + const char *buf, size_t length) +{ + struct sd_cdl_sysfs_entry *entry = + container_of(attr, struct sd_cdl_sysfs_entry, attr); + struct sd_cdl *cdl = container_of(kobj, struct sd_cdl, kobj); + + if (!capable(CAP_SYS_ADMIN)) + return -EACCES; + + if (!entry->store) + return -EIO; + + return entry->store(cdl, buf, length); +} + static const struct sysfs_ops sd_cdl_sysfs_ops = { .show = sd_cdl_sysfs_show, + .store = sd_cdl_sysfs_store, }; static void sd_cdl_sysfs_release(struct kobject *kobj) @@ -411,6 +516,7 @@ static void sd_cdl_sysfs_unregister(struct scsi_disk *sdkp) sd_cdl_sysfs_unregister_page(&cdl->pages[i]); } + cdl->sdkp->cdl_enabled = 0; kobject_del(&cdl->kobj); kobject_put(&cdl->kobj); } @@ -689,7 +795,7 @@ static bool sd_cdl_supported(struct scsi_disk *sdkp, enum sd_cdlp *rw_cdlp, rw_cdlp[SD_CDL_WRITE] != SD_CDLP_NONE; } -static struct sd_cdl *sd_cdl_alloc(void) +static struct sd_cdl *sd_cdl_alloc(struct scsi_disk *sdkp) { struct sd_cdl *cdl; struct sd_cdl_page *page; @@ -699,6 +805,7 @@ static struct sd_cdl *sd_cdl_alloc(void) if (!cdl) return NULL; + cdl->sdkp = sdkp; kobject_init(&cdl->kobj, &sd_cdl_ktype); for (i = 0; i < SD_CDL_RW; i++) { page = &cdl->pages[i]; @@ -725,7 +832,7 @@ void sd_read_cdl(struct scsi_disk *sdkp, unsigned char *buf) goto unregister; if (!cdl) { - cdl = sd_cdl_alloc(); + cdl = sd_cdl_alloc(sdkp); if (!cdl) return; } @@ -762,3 +869,26 @@ void sd_cdl_release(struct scsi_disk *sdkp) { sd_cdl_sysfs_unregister(sdkp); } + +/* + * Check if a command has a duration limit set. If it does, return the + * descriptor index to use and 0 if the command has no limit set. + */ +int sd_cdl_dld(struct scsi_disk *sdkp, struct scsi_cmnd *scmd) +{ + unsigned int ioprio = req_get_ioprio(scsi_cmd_to_rq(scmd)); + unsigned int dld; + + /* + * Use "no limit" if the request ioprio class is not IOPRIO_CLASS_DL + * or if the user specified an invalid CDL descriptor index. + */ + if (IOPRIO_PRIO_CLASS(ioprio) != IOPRIO_CLASS_DL) + return 0; + + dld = IOPRIO_PRIO_DATA(ioprio); + if (dld > SD_CDL_MAX_DESC) + return 0; + + return dld; +} From patchwork Tue Jan 24 19:02:55 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114601 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 29132C54E94 for ; Tue, 24 Jan 2023 19:04:31 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234407AbjAXTE3 (ORCPT ); Tue, 24 Jan 2023 14:04:29 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42460 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234099AbjAXTDv (ORCPT ); Tue, 24 Jan 2023 14:03:51 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 92E8D4C6CB; Tue, 24 Jan 2023 11:03:46 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587026; x=1706123026; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=6oDKD33iLyFlkza0939wBUOZBw8it5v7VOb75buLVt8=; b=dH3i4n3CLHWe4T6BANPuIYcG6raMU2pfOxZNOHNgOSTIU8361ndnatv+ My1FXz1wo9acD/x3NON6hhDs+FM8MBHp7awa5hDuFiV1Oh1hBFA5WmOnc NFrEC9U1Lb5MqD15pKNrfDlQ1If+wUQ8FOGP/IEV7DHw33q/oE9U/fWM8 DOqPlXc3jQMbWYiXPkLMWBSnfF8HsaltU5vRwUkypLbao7+7NxpVgbCN4 HAf4tpeMf7jnumf8hFpFYNir2qxJ/m/yDFQmJFlRaucEIQ08nQjvQ1LqS SWYNg0NLXAqd8X4iz06t76Dcu1u3OGd5IBJ045sJVObPIiDIUe0vYYXfc w==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472963" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:03:46 +0800 IronPort-SDR: AKDUQy4TyMgR46vL7ezcudAzMr9J0o7E59+Unxf8GdpO0qH1Y2RdDFkRIhpbwluFO8nSa8yJgN waJtfv9ooSD9x/c9SkVE1c0+RWMRu3XBKUvIbDjKlq83nlgv3Cags6fnuc1pUbPDkanNHSjNRt V9GqKsVOF3pfCPiVYlkLvy9MY+59JMk873CyAHYRixxbF/ESjuAj0KTqew2iO4Zd4mT2DmDD/r zFVzrdAJbyqneqTRaH0K3K3zGENs4ejtAy0riI7Ne0Hl6CTQTYmo4wCGzDUWDmJS9KGAVZOKfC IYo= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:15:34 -0800 IronPort-SDR: ngsA6SwW4iM9Bq4Xe5GA4PXJxcDEhSqo1fSslD343ShBf+L/W9RzVDqpXckTc08vK+8jhuPDXH t01Hek5tEaCtElSgE+VsGFZsj7wkLgGJBxhH+/a+aaO0gnytvTfFMHcVEd0jNTotjxybXOiN4o 2AAJu3RwH/vRfi2D/zUsFjWw2/j4SW7mz/X4izOyEe+DdCeZfGA+S6AMQZYpVei9TMW0GFD+V7 OFaIyuKNViW0ERytkHvc0vpPjiv2xGVr5CWSdhHXUOosz5gwoorFReSnV7dGi6uc+YB14h9oyT hZE= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:03:44 -0800 From: Niklas Cassel To: "James E.J. Bottomley" , "Martin K. Petersen" Cc: Christoph Hellwig , Hannes Reinecke , Damien Le Moal , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel Subject: [PATCH v3 09/18] scsi: sd: handle read/write CDL timeout failures Date: Tue, 24 Jan 2023 20:02:55 +0100 Message-Id: <20230124190308.127318-10-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org Commands using a duration limit descriptor that has limit policies set to a value other than 0x0 may be failed by the device if one of the limits are exceeded. For such commands, since the failure is the result of the user duration limit configuration and workload, the commands should not be retried and terminated immediately. Furthermore, to allow the user to differentiate these "soft" failures from hard errors due to hardware problem, a different error code than EIO should be returned. There are 2 cases to consider: (1) The failure is due to a limit policy failing the command with a check condition sense key, that is, any limit policy other than 0xD. For this case, scsi_check_sense() is modified to detect failures with the ABORTED COMMAND sense key and the COMMAND TIMEOUT BEFORE PROCESSING or COMMAND TIMEOUT DURING PROCESSING or COMMAND TIMEOUT DURING PROCESSING DUE TO ERROR RECOVERY additional sense code. For these failures, a SUCCESS disposition is returned so that scsi_finish_command() is called to terminate the command. (2) The failure is due to a limit policy set to 0xD, which result in the command being terminated with a GOOD status, COMPLETED sense key, and DATA CURRENTLY UNAVAILABLE additional sense code. To handle this case, the scsi_check_sense() is modified to return a SUCCESS disposition so that scsi_finish_command() is called to terminate the command. In addition, scsi_decide_disposition() has to be modified to see if a command being terminated with GOOD status has sense data. This is as defined in SCSI Primary Commands - 6 (SPC-6), so all according to spec, even if GOOD status commands were not checked before. If scsi_check_sense() detects sense data representing a duration limit, scsi_check_sense() will set the newly introduced SCSI ML byte SCSIML_STAT_DL_TIMEOUT. This SCSI ML byte is checked in scsi_noretry_cmd(), so that a command that failed because of a CDL timeout cannot be retried. The SCSI ML byte is also checked in scsi_result_to_blk_status() to complete the command request with the BLK_STS_DURATION_LIMIT status, which result in the user seeing ETIME errors for the failed commands. Co-developed-by: Damien Le Moal Signed-off-by: Damien Le Moal Signed-off-by: Niklas Cassel --- drivers/scsi/scsi_error.c | 46 +++++++++++++++++++++++++++++++++++++++ drivers/scsi/scsi_lib.c | 4 ++++ drivers/scsi/scsi_priv.h | 1 + 3 files changed, 51 insertions(+) diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c index cf5ec5f5f4f6..9988539bc348 100644 --- a/drivers/scsi/scsi_error.c +++ b/drivers/scsi/scsi_error.c @@ -536,6 +536,7 @@ static inline void set_scsi_ml_byte(struct scsi_cmnd *cmd, u8 status) */ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd) { + struct request *req = scsi_cmd_to_rq(scmd); struct scsi_device *sdev = scmd->device; struct scsi_sense_hdr sshdr; @@ -595,6 +596,22 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd) if (sshdr.asc == 0x10) /* DIF */ return SUCCESS; + /* + * Check aborts due to command duration limit policy: + * ABORTED COMMAND additional sense code with the + * COMMAND TIMEOUT BEFORE PROCESSING or + * COMMAND TIMEOUT DURING PROCESSING or + * COMMAND TIMEOUT DURING PROCESSING DUE TO ERROR RECOVERY + * additional sense code qualifiers. + */ + if (sshdr.asc == 0x2e && + sshdr.ascq >= 0x01 && sshdr.ascq <= 0x03) { + set_scsi_ml_byte(scmd, SCSIML_STAT_DL_TIMEOUT); + req->cmd_flags |= REQ_FAILFAST_DEV; + req->rq_flags |= RQF_QUIET; + return SUCCESS; + } + if (sshdr.asc == 0x44 && sdev->sdev_bflags & BLIST_RETRY_ITF) return ADD_TO_MLQUEUE; if (sshdr.asc == 0xc1 && sshdr.ascq == 0x01 && @@ -691,6 +708,15 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd) } return SUCCESS; + case COMPLETED: + if (sshdr.asc == 0x55 && sshdr.ascq == 0x0a) { + set_scsi_ml_byte(scmd, SCSIML_STAT_DL_TIMEOUT); + req->cmd_flags |= REQ_FAILFAST_DEV; + req->rq_flags |= RQF_QUIET; + return SUCCESS; + } + return SUCCESS; + default: return SUCCESS; } @@ -785,6 +811,14 @@ static enum scsi_disposition scsi_eh_completed_normally(struct scsi_cmnd *scmd) switch (get_status_byte(scmd)) { case SAM_STAT_GOOD: scsi_handle_queue_ramp_up(scmd->device); + if (scmd->sense_buffer && SCSI_SENSE_VALID(scmd)) + /* + * If we have sense data, call scsi_check_sense() in + * order to set the correct SCSI ML byte (if any). + * No point in checking the return value, since the + * command has already completed successfully. + */ + scsi_check_sense(scmd); fallthrough; case SAM_STAT_COMMAND_TERMINATED: return SUCCESS; @@ -1807,6 +1841,10 @@ bool scsi_noretry_cmd(struct scsi_cmnd *scmd) return !!(req->cmd_flags & REQ_FAILFAST_DRIVER); } + /* Never retry commands aborted due to a duration limit timeout */ + if (scsi_ml_byte(scmd->result) == SCSIML_STAT_DL_TIMEOUT) + return true; + if (!scsi_status_is_check_condition(scmd->result)) return false; @@ -1966,6 +2004,14 @@ enum scsi_disposition scsi_decide_disposition(struct scsi_cmnd *scmd) if (scmd->cmnd[0] == REPORT_LUNS) scmd->device->sdev_target->expecting_lun_change = 0; scsi_handle_queue_ramp_up(scmd->device); + if (scmd->sense_buffer && SCSI_SENSE_VALID(scmd)) + /* + * If we have sense data, call scsi_check_sense() in + * order to set the correct SCSI ML byte (if any). + * No point in checking the return value, since the + * command has already completed successfully. + */ + scsi_check_sense(scmd); fallthrough; case SAM_STAT_COMMAND_TERMINATED: return SUCCESS; diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c index e1a021dd4da2..406952e72a68 100644 --- a/drivers/scsi/scsi_lib.c +++ b/drivers/scsi/scsi_lib.c @@ -600,6 +600,8 @@ static blk_status_t scsi_result_to_blk_status(int result) return BLK_STS_MEDIUM; case SCSIML_STAT_TGT_FAILURE: return BLK_STS_TARGET; + case SCSIML_STAT_DL_TIMEOUT: + return BLK_STS_DURATION_LIMIT; } switch (host_byte(result)) { @@ -797,6 +799,8 @@ static void scsi_io_completion_action(struct scsi_cmnd *cmd, int result) blk_stat = BLK_STS_ZONE_OPEN_RESOURCE; } break; + case COMPLETED: + fallthrough; default: action = ACTION_FAIL; break; diff --git a/drivers/scsi/scsi_priv.h b/drivers/scsi/scsi_priv.h index 74324fba4281..f42388ecb024 100644 --- a/drivers/scsi/scsi_priv.h +++ b/drivers/scsi/scsi_priv.h @@ -27,6 +27,7 @@ enum scsi_ml_status { SCSIML_STAT_NOSPC = 0x02, /* Space allocation on the dev failed */ SCSIML_STAT_MED_ERROR = 0x03, /* Medium error */ SCSIML_STAT_TGT_FAILURE = 0x04, /* Permanent target failure */ + SCSIML_STAT_DL_TIMEOUT = 0x05, /* Command Duration Limit timeout */ }; static inline u8 scsi_ml_byte(int result) From patchwork Tue Jan 24 19:02:56 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114602 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id F31B3C54E94 for ; Tue, 24 Jan 2023 19:04:41 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234617AbjAXTEk (ORCPT ); Tue, 24 Jan 2023 14:04:40 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42164 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234451AbjAXTDw (ORCPT ); Tue, 24 Jan 2023 14:03:52 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id F412E19696; Tue, 24 Jan 2023 11:03:48 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587028; x=1706123028; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=xQaojDl/zBRreCgbFNYyP4u+d54nre5JLHifYVnzUBw=; b=jyGysHVu0qEz56WQND2Uf75WfJSFchrDbbZBWk8etEySwm47HBDUM9Fb z3TjzBT39OKM1S0VC/1lwJHkU7oqVEoC0N2GhIHLseNvBdVO30AUUOTaZ sjTZ5aiRdPzaiXJTx3vIll+iHwQ0puPCuxCX00TxfbOHDpP+z1Cg6iDc4 6kHBaai7WXxcL3gp+BNzxwAdqXH8oPKBgRhcXqo8wSX/qDcnpMqqIx6zZ ewqhe0bK72Wz4/8okjJugU/kHtMIZIlZ5m6YFIbUiYIlr5MPQYQ1R6XuQ 3XqY4nRxasa5FVXlEq+4fSuITx13bJDGgkC82aIXAfVcRp1F2bXaec1wx A==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472966" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:03:48 +0800 IronPort-SDR: +PzpOKcGEa95q2nkJLfNvJnUN/Q+pjtb93z/8JJeRRCdxQXlT6B9wqn4KYRq+fqhRsO+oCzbeX OIYEM7eEsZCJpyXVlrPg+/X1XldH9mcKJm9D+PKZrlNOXiqdAnfaqQPDsNrsfTRHAGWR3rQquj U2F+QWssSIwcSDLrFl99gEdtHKx5+MjMIOki2yHW9/hYwFhgWetR+dZemM3Zx4p99N1GytzP15 CwiIjd1ZkQCzv6ZArEBMHBL+VSZ4+jz2p3ozaJYbc0hHaQjmchLJR8KkUfCRMQN2RwQTPSZghX gEg= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:15:37 -0800 IronPort-SDR: IoTpfbX3rV3FS6/lN8qLeO9B07tGetx9Y6VptVR0uPmkKfol2pDLblxlhfuSF2iJh0Bw2CykqS llvgsJfNbpcYa2hRYLIJWPJGP0G/KZuIFJSX/87pStgIOJYM/M/tYqCCrpoHbP0VaR+AEQv7hx KayZFRkAdzD1/8e2czFxrvMShK838hbYedOEM94EG5nb01s98gg62Tm0vHTeoHJoOEO7u9Nimo D6zWlOYekuYVFCtiRIgc/+1AJztVUyHlU9Su4uh/Qb74RAejuA79lqeoKoAf+kHf6uJJDoPGMM mGg= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:03:47 -0800 From: Niklas Cassel To: Damien Le Moal Cc: Christoph Hellwig , Hannes Reinecke , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel Subject: [PATCH v3 10/18] ata: libata-scsi: remove unnecessary !cmd checks Date: Tue, 24 Jan 2023 20:02:56 +0100 Message-Id: <20230124190308.127318-11-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org There is no need to check if !cmd as this can only happen for ATA internal commands which uses the ATA internal tag (32). Most users of ata_scsi_set_sense() are from _xlat functions that translate a scsicmd to an ATA command. These obviously have a qc->scsicmd. ata_scsi_qc_complete() can also call ata_scsi_set_sense() via ata_gen_passthru_sense() / ata_gen_ata_sense(), called via ata_scsi_qc_complete(). This callback is only called for translated commands, so it also has a qc->scsicmd. ata_eh_analyze_ncq_error(): the NCQ error log can only contain a 0-31 value, so it will never be able to get the ATA internal tag (32). ata_eh_request_sense(): only called by ata_eh_analyze_tf(), which is only called when iteratating the QCs using ata_qc_for_each_raw(), which does not include the internal tag. Since there is no existing call site where cmd can be NULL, remove the !cmd check from ata_scsi_set_sense() and ata_scsi_set_sense_information(). Suggested-by: Christoph Hellwig Signed-off-by: Niklas Cassel Reviewed-by: Hannes Reinecke --- drivers/ata/libata-scsi.c | 6 ------ 1 file changed, 6 deletions(-) diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c index e093c7a7deeb..26746609bf76 100644 --- a/drivers/ata/libata-scsi.c +++ b/drivers/ata/libata-scsi.c @@ -209,9 +209,6 @@ void ata_scsi_set_sense(struct ata_device *dev, struct scsi_cmnd *cmd, { bool d_sense = (dev->flags & ATA_DFLAG_D_SENSE); - if (!cmd) - return; - scsi_build_sense(cmd, d_sense, sk, asc, ascq); } @@ -221,9 +218,6 @@ void ata_scsi_set_sense_information(struct ata_device *dev, { u64 information; - if (!cmd) - return; - information = ata_tf_read_block(tf, dev); if (information == U64_MAX) return; From patchwork Tue Jan 24 19:02:57 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114603 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 56305C61D9D for ; Tue, 24 Jan 2023 19:04:43 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234638AbjAXTEl (ORCPT ); Tue, 24 Jan 2023 14:04:41 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42492 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234574AbjAXTDx (ORCPT ); Tue, 24 Jan 2023 14:03:53 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B1DB44DBCB; Tue, 24 Jan 2023 11:03:51 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587031; x=1706123031; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=pPfChadvZkjWP5BXTDptKrvxhcFM28TnCX7UlT8m74c=; b=rHe6lxt+ahs1dE6/Yk0m6HnFiDbNf7uFkZCL4e/WqBPujoG1zfw/rlGJ KbRazTMQef+WgJJvA/ot7GS5EBQXq8qpiuF84eiBAKEuhv14NweGHhKtN NWvS3raMifYcUW9MUf9YXlQqf0Q6a8QITmm3RzeJBAQMCgVCGU3MwByud jIU5gk2w1d1SdbW2wjnanUzxOCn5XiiFLA62+NTBy8fBf53eSLGfxWPS2 r30v8qEIkYitG2BMeJIM54IoqPRrAGdRqIATEMuPV6lQj8Mbb5YSiJ7LW 5miX3Iu0Vw29XPq2QWVi2BHR6H58VlUNsA6exTQJ2qd8dis5qLkqCt164 w==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472972" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:03:51 +0800 IronPort-SDR: 0hYa7oe0XqNYIKjo38IvYXuZLF6ZFjO5O5PTVn1tgNWbcBwQZGGnqnea36d69jZ9+wImb7UshZ JY5/7NTBiT9j1yRCJhOHWIAZ5DgUc7VcFQt3M+x+KO8vNWUXdDuf4UicAvgzUwwmTdCr/uxoBM gVaxQviBvkyJyBjhJjb6BTFeFvSF1qzw5W+dVcJoy+MUITC1KPFKKkGc+aqrfLYPTusHtAvHpC 3KyK5RhKxJKuYAf/aSQOwGGEqdJvwkNA9T2ZJgtosX/HBPUkbQD+olmyvirIITZvUUtxiNMlOW CvU= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:15:39 -0800 IronPort-SDR: DMA61RK9yqrwkv7mL8wZ7CNlqamy1epfDOQX6JofKneDaF6u4l83MYeQuPHSRzJYJFr+S1v3ya E8cBZtfu3Lvg18d0UiP4hgBsrRsJRnD/zSN21OiAkMIiGuVGXI9n9b8AGZ7XfHlg7UNiwJ5whj Ly3Sjo9gPKyfTJl3U1yTdu6vddHKmtJDaYk4VKMdRHEwbke4lnywLWPitxs7MppViKpna+42Og aFt3lrDkIsgwiYr0mlmAzWNJzg2I8wCjyhSsGzp5rFta2wfsePTCOQkxyk0AxRZXBrDMZ/ZjVC YdU= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:03:49 -0800 From: Niklas Cassel To: Damien Le Moal Cc: Christoph Hellwig , Hannes Reinecke , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel Subject: [PATCH v3 11/18] ata: libata: change ata_eh_request_sense() to not set CHECK_CONDITION Date: Tue, 24 Jan 2023 20:02:57 +0100 Message-Id: <20230124190308.127318-12-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org Currently, ata_eh_request_sense() unconditionally sets the scsicmd->result to SAM_STAT_CHECK_CONDITION. For Command Duration Limits policy 0xD: The device shall complete the command without error (SAM_STAT_GOOD) with the additional sense code set to DATA CURRENTLY UNAVAILABLE. It is perfectly fine to have sense data for a command that returned completion without error. In order to support for CDL policy 0xD, we have to remove this assumption that having sense data means that the command failed (SAM_STAT_CHECK_CONDITION). Change ata_eh_request_sense() to not set SAM_STAT_CHECK_CONDITION, and instead move the setting of SAM_STAT_CHECK_CONDITION to the single caller that wants SAM_STAT_CHECK_CONDITION set, that way ata_eh_request_sense() can be reused in a follow-up patch that adds support for CDL policy 0xD. The only caller of ata_eh_request_sense() is protected by: if (!(qc->flags & ATA_QCFLAG_SENSE_VALID)), so we can remove this duplicated check from ata_eh_request_sense() itself. Additionally, ata_eh_request_sense() is only called from ata_eh_analyze_tf(), which is only called when iteratating the QCs using ata_qc_for_each_raw(), which does not include the internal tag, so cmd can never be NULL (all non-internal commands have qc->scsicmd set), so remove the !cmd check as well. Signed-off-by: Niklas Cassel Reviewed-by: Hannes Reinecke --- drivers/ata/libata-eh.c | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-) diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c index a6c901811802..598ae07195b6 100644 --- a/drivers/ata/libata-eh.c +++ b/drivers/ata/libata-eh.c @@ -1401,8 +1401,11 @@ unsigned int atapi_eh_tur(struct ata_device *dev, u8 *r_sense_key) * * LOCKING: * Kernel thread context (may sleep). + * + * RETURNS: + * true if sense data could be fetched, false otherwise. */ -static void ata_eh_request_sense(struct ata_queued_cmd *qc) +static bool ata_eh_request_sense(struct ata_queued_cmd *qc) { struct scsi_cmnd *cmd = qc->scsicmd; struct ata_device *dev = qc->dev; @@ -1411,15 +1414,12 @@ static void ata_eh_request_sense(struct ata_queued_cmd *qc) if (ata_port_is_frozen(qc->ap)) { ata_dev_warn(dev, "sense data available but port frozen\n"); - return; + return false; } - if (!cmd || qc->flags & ATA_QCFLAG_SENSE_VALID) - return; - if (!ata_id_sense_reporting_enabled(dev->id)) { ata_dev_warn(qc->dev, "sense data reporting disabled\n"); - return; + return false; } ata_tf_init(dev, &tf); @@ -1432,13 +1432,19 @@ static void ata_eh_request_sense(struct ata_queued_cmd *qc) /* Ignore err_mask; ATA_ERR might be set */ if (tf.status & ATA_SENSE) { if (ata_scsi_sense_is_valid(tf.lbah, tf.lbam, tf.lbal)) { - ata_scsi_set_sense(dev, cmd, tf.lbah, tf.lbam, tf.lbal); + /* Set sense without also setting scsicmd->result */ + scsi_build_sense_buffer(dev->flags & ATA_DFLAG_D_SENSE, + cmd->sense_buffer, tf.lbah, + tf.lbam, tf.lbal); qc->flags |= ATA_QCFLAG_SENSE_VALID; + return true; } } else { ata_dev_warn(dev, "request sense failed stat %02x emask %x\n", tf.status, err_mask); } + + return false; } /** @@ -1588,8 +1594,9 @@ static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc) * was not included in the NCQ command error log * (i.e. NCQ autosense is not supported by the device). */ - if (!(qc->flags & ATA_QCFLAG_SENSE_VALID) && (stat & ATA_SENSE)) - ata_eh_request_sense(qc); + if (!(qc->flags & ATA_QCFLAG_SENSE_VALID) && + (stat & ATA_SENSE) && ata_eh_request_sense(qc)) + set_status_byte(qc->scsicmd, SAM_STAT_CHECK_CONDITION); if (err & ATA_ICRC) qc->err_mask |= AC_ERR_ATA_BUS; if (err & (ATA_UNC | ATA_AMNF)) From patchwork Tue Jan 24 19:02:58 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114604 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9DCE1C25B4E for ; Tue, 24 Jan 2023 19:04:51 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229792AbjAXTEt (ORCPT ); Tue, 24 Jan 2023 14:04:49 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42668 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234578AbjAXTD4 (ORCPT ); Tue, 24 Jan 2023 14:03:56 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 196434F353; Tue, 24 Jan 2023 11:03:55 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587034; x=1706123034; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=QHK96wjbqenc7PSXWPwg1n4f0guPd2Q706gRZq0k2ro=; b=heG4a5CspzZM9tLSOv4yEoITkYGQn0m6yq2sXmeuYJIFESOS12zJgTWp Wro72UD6hte2wy9S3SRtpWdHnqAD0Uz40ubbR4YCQdkIF9Nw506VBNIWJ WYZbQI56kQY9cTHxj7cYeVKBA5OqonVVfjOEqwjuGYYpQrcPqe7ib1ra4 RFfGkqpkstpWTXBDCtkMiVkqAn74PQ4Fb8Snlk+hqtQk6fa5TKMaDhz46 Vvt5i0J1rHmDHC5C01HfbpwsUQzQcWnYuIdVobLRH2V88XgWhoH4SEP1O R/AQxh2ixn+sS7RvrU/6dtobmxEDC/tsV/ZMM9Yqn/G967zh1IaiN232L A==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472974" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:03:54 +0800 IronPort-SDR: ONfjVCYd08WIIt4GZ1552urlBDzpNBIS5IygNrhf01YNBX3hRZIyvPiSIpOccOngN4MBRjV93j O01RRb+XRm9W/4GmpYeuX8wT5BUda+AKQNEGyLoclAnfxSUVYqOLw1xHsrMRO4yJU0ETWh8QcE VjSOhkyOkaqZ+01xOCt/QfiUlh6zByrtKY6GNMoQ+JjFU9AQ3blHwFOgyhGyDkwAoL99fUvAQx /EZ4MFU0QJU+Yimy3coSU1Hx2hjEiRXivTXhTURZuapTnxos+6720GlQmeuUAzAVNTZX0IPfnl jO4= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:15:43 -0800 IronPort-SDR: rGcTGNzEvwN6lyQPmsYpxPZ+8n27KOx/xNyMXwVJOtk+w6F9w0FI4zpyfFL+soYzsdFHVItanT MXMgMp2urP2FheAN8x+iME6wpj3sE6fGD4iE5gG5Txttp7fAA4l+DYkMgICDietguc2mxvJUAa WwKrspcJOA6uN4ddw7Ub9jRg8s3mDp8KNR8LhcRMH0aYZuQmxI/sCXxmDwc4/y5EpmsrFRWd4I 0+0SHS1DNpaPvp/uUmrBcwoof6Zx9KwCUoamCd9qAQkaOm1JyW3r8hLvOWXLrOEZzi/eQvCFl+ 24c= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:03:52 -0800 From: Niklas Cassel To: Damien Le Moal Cc: Christoph Hellwig , Hannes Reinecke , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel Subject: [PATCH v3 12/18] ata: libata: detect support for command duration limits Date: Tue, 24 Jan 2023 20:02:58 +0100 Message-Id: <20230124190308.127318-13-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org From: Damien Le Moal Use the supported capabilities identify device data log page to detect if a device supports the command duration limits feature. For devices supporting this feature, set the device flag ATA_DFLAG_CDL. To support scsi-ata translation, retrieve the command duration limits log page 18h and cache this page content using the cdl array added to the ata_device data structure. Signed-off-by: Damien Le Moal Co-developed-by: Niklas Cassel Signed-off-by: Niklas Cassel Reviewed-by: Hannes Reinecke --- drivers/ata/libata-core.c | 52 ++++++++++++++++++++++++++++++++++++++- drivers/ata/libata-scsi.c | 17 ++++++------- include/linux/ata.h | 5 +++- include/linux/libata.h | 29 +++++++++++++--------- 4 files changed, 80 insertions(+), 23 deletions(-) diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c index 36c1aca310e9..17e32b0a6364 100644 --- a/drivers/ata/libata-core.c +++ b/drivers/ata/libata-core.c @@ -2367,6 +2367,54 @@ static void ata_dev_config_trusted(struct ata_device *dev) dev->flags |= ATA_DFLAG_TRUSTED; } +static void ata_dev_config_cdl(struct ata_device *dev) +{ + struct ata_port *ap = dev->link->ap; + unsigned int err_mask; + u64 val; + + if (ata_id_major_version(dev->id) < 12) + goto not_supported; + + if (!ata_log_supported(dev, ATA_LOG_IDENTIFY_DEVICE) || + !ata_identify_page_supported(dev, ATA_LOG_SUPPORTED_CAPABILITIES)) + goto not_supported; + + err_mask = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE, + ATA_LOG_SUPPORTED_CAPABILITIES, + ap->sector_buf, 1); + if (err_mask) + goto not_supported; + + /* Check Command Duration Limit Supported bits */ + val = get_unaligned_le64(&ap->sector_buf[168]); + if (!(val & BIT_ULL(63)) || !(val & BIT_ULL(0))) + goto not_supported; + + /* Warn the user if command duration guideline is not supported */ + if (!(val & BIT_ULL(1))) + ata_dev_warn(dev, + "Command duration guideline is not supported\n"); + + /* + * Command duration limits is supported: cache the CDL log page 18h + * (command duration descriptors). + */ + err_mask = ata_read_log_page(dev, ATA_LOG_CDL, 0, ap->sector_buf, 1); + if (err_mask) { + ata_dev_warn(dev, "Read Command Duration Limits log failed\n"); + goto not_supported; + } + + memcpy(dev->cdl, ap->sector_buf, ATA_LOG_CDL_SIZE); + dev->flags |= ATA_DFLAG_CDL; + + return; + +not_supported: + dev->flags &= ~ATA_DFLAG_CDL; +} + static int ata_dev_config_lba(struct ata_device *dev) { const u16 *id = dev->id; @@ -2534,13 +2582,14 @@ static void ata_dev_print_features(struct ata_device *dev) return; ata_dev_info(dev, - "Features:%s%s%s%s%s%s%s\n", + "Features:%s%s%s%s%s%s%s%s\n", dev->flags & ATA_DFLAG_FUA ? " FUA" : "", dev->flags & ATA_DFLAG_TRUSTED ? " Trust" : "", dev->flags & ATA_DFLAG_DA ? " Dev-Attention" : "", dev->flags & ATA_DFLAG_DEVSLP ? " Dev-Sleep" : "", dev->flags & ATA_DFLAG_NCQ_SEND_RECV ? " NCQ-sndrcv" : "", dev->flags & ATA_DFLAG_NCQ_PRIO ? " NCQ-prio" : "", + dev->flags & ATA_DFLAG_CDL ? " CDL" : "", dev->cpr_log ? " CPR" : ""); } @@ -2702,6 +2751,7 @@ int ata_dev_configure(struct ata_device *dev) ata_dev_config_zac(dev); ata_dev_config_trusted(dev); ata_dev_config_cpr(dev); + ata_dev_config_cdl(dev); dev->cdb_len = 32; if (print_info) diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c index 26746609bf76..716c33af999c 100644 --- a/drivers/ata/libata-scsi.c +++ b/drivers/ata/libata-scsi.c @@ -47,15 +47,14 @@ typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *qc); static struct ata_device *__ata_scsi_find_dev(struct ata_port *ap, const struct scsi_device *scsidev); -#define RW_RECOVERY_MPAGE 0x1 -#define RW_RECOVERY_MPAGE_LEN 12 -#define CACHE_MPAGE 0x8 -#define CACHE_MPAGE_LEN 20 -#define CONTROL_MPAGE 0xa -#define CONTROL_MPAGE_LEN 12 -#define ALL_MPAGES 0x3f -#define ALL_SUB_MPAGES 0xff - +#define RW_RECOVERY_MPAGE 0x1 +#define RW_RECOVERY_MPAGE_LEN 12 +#define CACHE_MPAGE 0x8 +#define CACHE_MPAGE_LEN 20 +#define CONTROL_MPAGE 0xa +#define CONTROL_MPAGE_LEN 12 +#define ALL_MPAGES 0x3f +#define ALL_SUB_MPAGES 0xff static const u8 def_rw_recovery_mpage[RW_RECOVERY_MPAGE_LEN] = { RW_RECOVERY_MPAGE, diff --git a/include/linux/ata.h b/include/linux/ata.h index 0c18499f60b6..b01e2cebe1fe 100644 --- a/include/linux/ata.h +++ b/include/linux/ata.h @@ -323,15 +323,18 @@ enum { ATA_LOG_SATA_NCQ = 0x10, ATA_LOG_NCQ_NON_DATA = 0x12, ATA_LOG_NCQ_SEND_RECV = 0x13, + ATA_LOG_CDL = 0x18, + ATA_LOG_CDL_SIZE = ATA_SECT_SIZE, ATA_LOG_IDENTIFY_DEVICE = 0x30, ATA_LOG_CONCURRENT_POSITIONING_RANGES = 0x47, /* Identify device log pages: */ + ATA_LOG_SUPPORTED_CAPABILITIES = 0x03, ATA_LOG_SECURITY = 0x06, ATA_LOG_SATA_SETTINGS = 0x08, ATA_LOG_ZONED_INFORMATION = 0x09, - /* Identify device SATA settings log:*/ + /* Identify device SATA settings log: */ ATA_LOG_DEVSLP_OFFSET = 0x30, ATA_LOG_DEVSLP_SIZE = 0x08, ATA_LOG_DEVSLP_MDAT = 0x00, diff --git a/include/linux/libata.h b/include/linux/libata.h index a759dfbdcc91..2b17d6c99a37 100644 --- a/include/linux/libata.h +++ b/include/linux/libata.h @@ -94,17 +94,18 @@ enum { ATA_DFLAG_DMADIR = (1 << 10), /* device requires DMADIR */ ATA_DFLAG_NCQ_SEND_RECV = (1 << 11), /* device supports NCQ SEND and RECV */ ATA_DFLAG_NCQ_PRIO = (1 << 12), /* device supports NCQ priority */ - ATA_DFLAG_CFG_MASK = (1 << 13) - 1, - - ATA_DFLAG_PIO = (1 << 13), /* device limited to PIO mode */ - ATA_DFLAG_NCQ_OFF = (1 << 14), /* device limited to non-NCQ mode */ - ATA_DFLAG_SLEEPING = (1 << 15), /* device is sleeping */ - ATA_DFLAG_DUBIOUS_XFER = (1 << 16), /* data transfer not verified */ - ATA_DFLAG_NO_UNLOAD = (1 << 17), /* device doesn't support unload */ - ATA_DFLAG_UNLOCK_HPA = (1 << 18), /* unlock HPA */ - ATA_DFLAG_INIT_MASK = (1 << 19) - 1, - - ATA_DFLAG_NCQ_PRIO_ENABLED = (1 << 19), /* Priority cmds sent to dev */ + ATA_DFLAG_CDL = (1 << 13), /* supports cmd duration limits */ + ATA_DFLAG_CFG_MASK = (1 << 14) - 1, + + ATA_DFLAG_PIO = (1 << 14), /* device limited to PIO mode */ + ATA_DFLAG_NCQ_OFF = (1 << 15), /* device limited to non-NCQ mode */ + ATA_DFLAG_SLEEPING = (1 << 16), /* device is sleeping */ + ATA_DFLAG_DUBIOUS_XFER = (1 << 17), /* data transfer not verified */ + ATA_DFLAG_NO_UNLOAD = (1 << 18), /* device doesn't support unload */ + ATA_DFLAG_UNLOCK_HPA = (1 << 19), /* unlock HPA */ + ATA_DFLAG_INIT_MASK = (1 << 20) - 1, + + ATA_DFLAG_NCQ_PRIO_ENABLED = (1 << 20), /* Priority cmds sent to dev */ ATA_DFLAG_DETACH = (1 << 24), ATA_DFLAG_DETACHED = (1 << 25), ATA_DFLAG_DA = (1 << 26), /* device supports Device Attention */ @@ -115,7 +116,8 @@ enum { ATA_DFLAG_FEATURES_MASK = (ATA_DFLAG_TRUSTED | ATA_DFLAG_DA | \ ATA_DFLAG_DEVSLP | ATA_DFLAG_NCQ_SEND_RECV | \ - ATA_DFLAG_NCQ_PRIO | ATA_DFLAG_FUA), + ATA_DFLAG_NCQ_PRIO | ATA_DFLAG_FUA | \ + ATA_DFLAG_CDL), ATA_DEV_UNKNOWN = 0, /* unknown device */ ATA_DEV_ATA = 1, /* ATA device */ @@ -709,6 +711,9 @@ struct ata_device { /* Concurrent positioning ranges */ struct ata_cpr_log *cpr_log; + /* Command Duration Limits log support */ + u8 cdl[ATA_LOG_CDL_SIZE]; + /* error history */ int spdn_cnt; /* ering is CLEAR_END, read comment above CLEAR_END */ From patchwork Tue Jan 24 19:02:59 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114605 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 497FFC61D97 for ; Tue, 24 Jan 2023 19:04:52 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233568AbjAXTEu (ORCPT ); Tue, 24 Jan 2023 14:04:50 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42820 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234584AbjAXTD7 (ORCPT ); Tue, 24 Jan 2023 14:03:59 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 92ADD4F344; Tue, 24 Jan 2023 11:03:57 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587037; x=1706123037; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=2sRoI7igCq6tyeL8Xu4jn4gnzdhs69h2QV+ki1N1wq4=; b=cmwmvaKN0OyGmKhMiqgwCe3nt0XadEGlTlhJBmMqNaeJciytPe+jnUmS fkxI+sqQyH/968FbsbGt85XMGo5FgnUBxstF2npfCTbIGElNhB/x3a1/F KhnXfZaik7Vx8lim9jplNDgyUCO3G6mMeR8pxSVfnXWDILk4iHorxZGIB LDEd6Y/krDLgdnKGKRISz3ggKsMaFFbwHZNg4V1ZA+3wqHipsb4P6BY2B 9WdeK7KuOqUDHyxp8eFg4IDf78Us0BcXsbkutrQ7b5U5g5EoPQVYNTkQA jIVM4KFdicPHFDRPPqGJHuUPoSmziiUqxXg4gZ8HroIdXBEoeQ/iAq3rg g==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472975" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:03:57 +0800 IronPort-SDR: UfcgIlt8rmdQeAb9EV+CIABQDahEz4/A6JyiLniaU5yp1J0q1oRsMlUW+CFRqikqiNpznUDEga sZUAK0SLLsgHJZcwT22AznSzU9i1Q5KuDtXT1I6OseGTwDoPM6OEkbCsvM5COz/mql79cZ58gq H2MQ68FnaNB82OpRIlP6U8+Wlh0lemGpON9WPmI3kpYPVj3zDIYS9Qv7sW1a3OQuswvrL4N8Qq N9yV7rchloHCXQnnyYLbzTP0765xJNv8vCuj5NgoRjZIBtwdaMLqvtkb5D7+BB+DTD+60JCWdh fmo= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:15:45 -0800 IronPort-SDR: HWKfTWct6OeRFRk1MbcavBXo5idrii9QPPxkEwImhN7gsRSUuWlkkEL2h1hmXl7+3MNSHzUm5s MBKsdK1yaGtX6fPBZXrHkZ9joKmv2+TMmOadzVKSroXcvpWZLgPi0jK5JMvQ8r53OQhCc4jPRX WRUqTXs8ZY97E6dOAwHkBUW2Vsp08bkC/UiTZZcQmFGQhyLhuh7N8HYM8vTZnuLETUUtUpTKYx 62t27QHtRod/EkrBy8PFyyjHdX8Oh+z4Eg5odMfFNXWU8aF0rEgZg+WvGR6QttQW+DSe5GGPwa sSM= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:03:55 -0800 From: Niklas Cassel To: Damien Le Moal Cc: Christoph Hellwig , Hannes Reinecke , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel Subject: [PATCH v3 13/18] ata: libata-scsi: handle CDL bits in ata_scsiop_maint_in() Date: Tue, 24 Jan 2023 20:02:59 +0100 Message-Id: <20230124190308.127318-14-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org From: Damien Le Moal For a scsi MAINTENANCE_IN/MI_REPORT_SUPPORTED_OPERATION_CODES operation, add the translation of the rwcdlp and cdlp bits for the READ16 and WRITE16 commands. If the ATA device does not support command duration limits, these bits are always 0. If the ATA device supports command duration limits, the rwcdlp bit is set to 1 for READ16 and WRITE16 and the cdlp bits are set to 0x1 for READ16 and 0x2 for WRITE16. These correspond to the T2A mode page containing the read descriptors and to the T2B mode page containing the write descriptors, as defined in SAT-5. Signed-off-by: Damien Le Moal Signed-off-by: Niklas Cassel Reviewed-by: Hannes Reinecke --- drivers/ata/libata-scsi.c | 30 ++++++++++++++++++++++++++---- 1 file changed, 26 insertions(+), 4 deletions(-) diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c index 716c33af999c..2a0a04c9e658 100644 --- a/drivers/ata/libata-scsi.c +++ b/drivers/ata/libata-scsi.c @@ -3235,7 +3235,7 @@ static unsigned int ata_scsiop_maint_in(struct ata_scsi_args *args, u8 *rbuf) { struct ata_device *dev = args->dev; u8 *cdb = args->cmd->cmnd; - u8 supported = 0; + u8 supported = 0, cdlp = 0, rwcdlp = 0; unsigned int err = 0; if (cdb[2] != 1 && cdb[2] != 3) { @@ -3262,10 +3262,8 @@ static unsigned int ata_scsiop_maint_in(struct ata_scsi_args *args, u8 *rbuf) case MAINTENANCE_IN: case READ_6: case READ_10: - case READ_16: case WRITE_6: case WRITE_10: - case WRITE_16: case ATA_12: case ATA_16: case VERIFY: @@ -3275,6 +3273,28 @@ static unsigned int ata_scsiop_maint_in(struct ata_scsi_args *args, u8 *rbuf) case START_STOP: supported = 3; break; + case READ_16: + supported = 3; + if (dev->flags & ATA_DFLAG_CDL) { + /* + * CDL read descriptors map to the T2A page, that is, + * rwcdlp = 0x01 and cdlp = 0x01 + */ + rwcdlp = 0x01; + cdlp = 0x01 << 3; + } + break; + case WRITE_16: + supported = 3; + if (dev->flags & ATA_DFLAG_CDL) { + /* + * CDL write descriptors map to the T2B page, that is, + * rwcdlp = 0x01 and cdlp = 0x02 + */ + rwcdlp = 0x01; + cdlp = 0x02 << 3; + } + break; case ZBC_IN: case ZBC_OUT: if (ata_id_zoned_cap(dev->id) || @@ -3290,7 +3310,9 @@ static unsigned int ata_scsiop_maint_in(struct ata_scsi_args *args, u8 *rbuf) break; } out: - rbuf[1] = supported; /* supported */ + /* One command format */ + rbuf[0] = rwcdlp; + rbuf[1] = cdlp | supported; return err; } From patchwork Tue Jan 24 19:03:00 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114606 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 40AE7C54E94 for ; Tue, 24 Jan 2023 19:05:05 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234518AbjAXTFD (ORCPT ); Tue, 24 Jan 2023 14:05:03 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43172 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234593AbjAXTEK (ORCPT ); Tue, 24 Jan 2023 14:04:10 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5B1B14F34A; Tue, 24 Jan 2023 11:04:00 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587040; x=1706123040; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=wrwtx3mr1Ry/N2tv/cKR0V38n6uOJgV5e5aDZynmUk4=; b=KAJ49CzXXB6rnhCaPvFPg2Ux4WM3Zi6ihju4ZgrqIDPMm/p4kEPeQlwM I9AeB3Fo+NALwCiClm1eFAK6v3Wkz1SfkccPLzYxBNLPvAhWoh5a94q/p SPsgk760Dp3PdL2UL8/pzTxktrnJyRyTDRMtywY3ea9319MKuIAmyOpgs V6TwGObzVDiiNuAxfRU+72I4koJeq5xR8IJydH639fXMyJD4yiLEQuDOE WiNF4EK8RyiWI+3P9B9iS81RCkGnzLTeOe8A2gIads401W67WMLoGXF6S dsQC2WoNVkhYwN1T+61n6lZiDTlr7By3JFW2Hj8U9xn/AzWOvSs9bRjlc g==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472978" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:03:59 +0800 IronPort-SDR: W4H0Lb+i0tNAm3vQBFRPaiu7mZhxmJq0MaZrLAkfiFdfWGBLBNeh8o60s/TQROd3qgKFK4/gNN 0+3CEMlE2lcI80w5LKXUCkrH3QIqVEsl+BG6RgjzWPyWaoJ+PMLsMIhIx9Zuk8//1cG3WoC3tD Y2scL2HIz8hfm/MAELrneK+Hh3CockD24TglvnoDyHJ/hT4pXPMiC+7KR5WQ3J8S6UcwX7XLqR G5b+kwOWJ7qFr50cYiCf14NDVIKKad5Zsc4RR2qLjqDKEvikcxLDwC8z1xjDDQHpSv/8x76lSt Jlc= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:15:48 -0800 IronPort-SDR: Jtc13l0aiaSNyyowGrm0lJy4As+5EhRg9qLUCBMBHvnDeWLehLJvHF2EM0hurkidAEtZ3pk8fM 7LmkYk+6M9Zlp8wlPKe1dcH9lvj/Z8KB4vOrd9TWk/JaMVCatefpptFFX2sCvBFdLfSULh73wu GOXs56/az+9Ut6M9PQS9918cxl8YeYXF923gS+xcqaza4LzkaVPg2Ylt1u2hAnr+1mMdgDGvVd y4ZdVxTSbyxbnvPmlPjbMD2x5WTr+gbhUjdVjFd6zMHr6ggcbjZciz/q1N4w98cUjoP7BgwcfF UxI= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:03:58 -0800 From: Niklas Cassel To: Damien Le Moal Cc: Christoph Hellwig , Hannes Reinecke , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel Subject: [PATCH v3 14/18] ata: libata-scsi: add support for CDL pages mode sense Date: Tue, 24 Jan 2023 20:03:00 +0100 Message-Id: <20230124190308.127318-15-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org From: Damien Le Moal Modify ata_scsiop_mode_sense() and ata_msense_control() to support mode sense access to the T2A and T2B sub-pages of the control mode page. ata_msense_control() is modified to support sub-pages. The T2A sub-page is generated using the read descriptors of the command duration limits log page 18h. The T2B sub-page is generated using the write descriptors of the same log page. With the addition of these sub-pages, getting all sub-pages of the control mode page is also supported by increasing the value of ATA_SCSI_RBUF_SIZE from 576B up to 2048B to ensure that all sub-pages fit in the fill buffer. Signed-off-by: Damien Le Moal Co-developed-by: Niklas Cassel Signed-off-by: Niklas Cassel Reviewed-by: Hannes Reinecke --- drivers/ata/libata-scsi.c | 150 ++++++++++++++++++++++++++++++++------ 1 file changed, 128 insertions(+), 22 deletions(-) diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c index 2a0a04c9e658..9315a4c01276 100644 --- a/drivers/ata/libata-scsi.c +++ b/drivers/ata/libata-scsi.c @@ -37,7 +37,7 @@ #include "libata.h" #include "libata-transport.h" -#define ATA_SCSI_RBUF_SIZE 576 +#define ATA_SCSI_RBUF_SIZE 2048 static DEFINE_SPINLOCK(ata_scsi_rbuf_lock); static u8 ata_scsi_rbuf[ATA_SCSI_RBUF_SIZE]; @@ -55,6 +55,9 @@ static struct ata_device *__ata_scsi_find_dev(struct ata_port *ap, #define CONTROL_MPAGE_LEN 12 #define ALL_MPAGES 0x3f #define ALL_SUB_MPAGES 0xff +#define CDL_T2A_SUB_MPAGE 0x07 +#define CDL_T2B_SUB_MPAGE 0x08 +#define CDL_T2_SUB_MPAGE_LEN 232 static const u8 def_rw_recovery_mpage[RW_RECOVERY_MPAGE_LEN] = { RW_RECOVERY_MPAGE, @@ -2196,10 +2199,98 @@ static unsigned int ata_msense_caching(u16 *id, u8 *buf, bool changeable) return sizeof(def_cache_mpage); } +/* + * Simulate MODE SENSE control mode page, sub-page 0. + */ +static unsigned int ata_msense_control_spg0(struct ata_device *dev, u8 *buf, + bool changeable) +{ + modecpy(buf, def_control_mpage, + sizeof(def_control_mpage), changeable); + if (changeable) { + /* ata_mselect_control() */ + buf[2] |= (1 << 2); + } else { + bool d_sense = (dev->flags & ATA_DFLAG_D_SENSE); + + /* descriptor format sense data */ + buf[2] |= (d_sense << 2); + } + + return sizeof(def_control_mpage); +} + +/* + * Translate an ATA duration limit in microseconds to a SCSI duration limit + * using the t2cdlunits 0xa (10ms). Since the SCSI duration limits are 2-bytes + * only, take care of overflows. + */ +static inline u16 ata_xlat_cdl_limit(u8 *buf) +{ + u32 limit = get_unaligned_le32(buf); + + return min_t(u32, limit / 10000, 65535); +} + +/* + * Simulate MODE SENSE control mode page, sub-pages 07h and 08h + * (command duration limits T2A and T2B mode pages). + */ +static unsigned int ata_msense_control_spgt2(struct ata_device *dev, u8 *buf, + u8 spg) +{ + u8 *b, *cdl = dev->cdl, *desc; + u32 policy; + int i; + + /* + * Fill the subpage. The first four bytes of the T2A/T2B mode pages + * are a header. The PAGE LENGTH field is the size of the page + * excluding the header. + */ + buf[0] = CONTROL_MPAGE; + buf[1] = spg; + put_unaligned_be16(CDL_T2_SUB_MPAGE_LEN - 4, &buf[2]); + if (spg == CDL_T2A_SUB_MPAGE) { + /* + * Read descriptors map to the T2A page: + * set perf_vs_duration_guidleine. + */ + buf[7] = (cdl[0] & 0x03) << 4; + desc = cdl + 64; + } else { + /* Write descriptors map to the T2B page */ + desc = cdl + 288; + } + + /* Fill the T2 page descriptors */ + b = &buf[8]; + policy = get_unaligned_le32(&cdl[0]); + for (i = 0; i < 7; i++, b += 32, desc += 32) { + /* t2cdlunits: fixed to 10ms */ + b[0] = 0x0a; + + /* Max inactive time and its policy */ + put_unaligned_be16(ata_xlat_cdl_limit(&desc[8]), &b[2]); + b[6] = ((policy >> 8) & 0x0f) << 4; + + /* Max active time and its policy */ + put_unaligned_be16(ata_xlat_cdl_limit(&desc[4]), &b[4]); + b[6] |= (policy >> 4) & 0x0f; + + /* Command duration guideline and its policy */ + put_unaligned_be16(ata_xlat_cdl_limit(&desc[16]), &b[10]); + b[14] = policy & 0x0f; + } + + return CDL_T2_SUB_MPAGE_LEN; +} + /** * ata_msense_control - Simulate MODE SENSE control mode page * @dev: ATA device of interest * @buf: output buffer + * @spg: sub-page code * @changeable: whether changeable parameters are requested * * Generate a generic MODE SENSE control mode page. @@ -2208,17 +2299,24 @@ static unsigned int ata_msense_caching(u16 *id, u8 *buf, bool changeable) * None. */ static unsigned int ata_msense_control(struct ata_device *dev, u8 *buf, - bool changeable) + u8 spg, bool changeable) { - modecpy(buf, def_control_mpage, sizeof(def_control_mpage), changeable); - if (changeable) { - buf[2] |= (1 << 2); /* ata_mselect_control() */ - } else { - bool d_sense = (dev->flags & ATA_DFLAG_D_SENSE); - - buf[2] |= (d_sense << 2); /* descriptor format sense data */ + unsigned int n; + + switch (spg) { + case 0: + return ata_msense_control_spg0(dev, buf, changeable); + case CDL_T2A_SUB_MPAGE: + case CDL_T2B_SUB_MPAGE: + return ata_msense_control_spgt2(dev, buf, spg); + case ALL_SUB_MPAGES: + n = ata_msense_control_spg0(dev, buf, changeable); + n += ata_msense_control_spgt2(dev, buf + n, CDL_T2A_SUB_MPAGE); + n += ata_msense_control_spgt2(dev, buf + n, CDL_T2A_SUB_MPAGE); + return n; + default: + return 0; } - return sizeof(def_control_mpage); } /** @@ -2291,13 +2389,24 @@ static unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf) pg = scsicmd[2] & 0x3f; spg = scsicmd[3]; + /* - * No mode subpages supported (yet) but asking for _all_ - * subpages may be valid + * Supported subpages: all subpages and sub-pages 07h and 08h of + * the control page. */ - if (spg && (spg != ALL_SUB_MPAGES)) { - fp = 3; - goto invalid_fld; + if (spg) { + switch (spg) { + case ALL_SUB_MPAGES: + break; + case CDL_T2A_SUB_MPAGE: + case CDL_T2B_SUB_MPAGE: + if (dev->flags & ATA_DFLAG_CDL && pg == CONTROL_MPAGE) + break; + fallthrough; + default: + fp = 3; + goto invalid_fld; + } } switch(pg) { @@ -2310,13 +2419,13 @@ static unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf) break; case CONTROL_MPAGE: - p += ata_msense_control(args->dev, p, page_control == 1); + p += ata_msense_control(args->dev, p, spg, page_control == 1); break; case ALL_MPAGES: p += ata_msense_rw_recovery(p, page_control == 1); p += ata_msense_caching(args->id, p, page_control == 1); - p += ata_msense_control(args->dev, p, page_control == 1); + p += ata_msense_control(args->dev, p, spg, page_control == 1); break; default: /* invalid page code */ @@ -2335,10 +2444,7 @@ static unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf) memcpy(rbuf + 4, sat_blk_desc, sizeof(sat_blk_desc)); } } else { - unsigned int output_len = p - rbuf - 2; - - rbuf[0] = output_len >> 8; - rbuf[1] = output_len; + put_unaligned_be16(p - rbuf - 2, &rbuf[0]); rbuf[3] |= dpofua; if (ebd) { rbuf[7] = sizeof(sat_blk_desc); @@ -3637,7 +3743,7 @@ static int ata_mselect_control(struct ata_queued_cmd *qc, /* * Check that read-only bits are not modified. */ - ata_msense_control(dev, mpage, false); + ata_msense_control_spg0(dev, mpage, false); for (i = 0; i < CONTROL_MPAGE_LEN - 2; i++) { if (i == 0) continue; From patchwork Tue Jan 24 19:03:01 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114608 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id F4154C25B50 for ; Tue, 24 Jan 2023 19:05:22 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234451AbjAXTFV (ORCPT ); Tue, 24 Jan 2023 14:05:21 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43628 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234621AbjAXTEk (ORCPT ); Tue, 24 Jan 2023 14:04:40 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 42F1D4FC1A; Tue, 24 Jan 2023 11:04:03 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587043; x=1706123043; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=gcd4VFI1BnX0yfMhvOiJPl9VYlxzxUP4HPck1etqeqQ=; b=n4j/DP/2gtAlLwZQWIuYC8rEPV+YeuOYesVdvESNiuab6G+5H9OY9s5e ijRTNvfLfB89PLGSp9QuTR2bUJhN3l7CtNW9KWeIeS+KGP/hfYwqGQKi9 T5OeAij5ehHUnxo3XMbEKWnsM+ENxPLbfRCUFkqwsm2liHE0KxQNzac10 gvjE/ncLJSc0C05DPxWg/P7aAhaqXf/XjjSnPpcL05FF4tBu5v8l+w8/Q JTyjPONOP0dx9+Dve+VwisUmc8Y8JtoZcpNav6xqtBQPUbjqBOItefsc9 P89PM6CNw5S4mhe21xQekv+c5mH/TZI1s4qEKbIEb5eVihIVZM3pGTo7K g==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472981" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:04:02 +0800 IronPort-SDR: 7jDm+7IGNixeEGsZnCtaGC0ywVtPNwbUj8r+ZR4+z4Drtzz6e21qMvdzdR5PSRM0YyYGZgzMmP 5+vyrnSqyZjZr+T+Ozf6stFJJXjYCo2RmB+ZORjyRkRe2N/rldxMP/SzapocXpi8NnHCu1luB+ 7qfLq8EXIFiY1zl+h1bSf+4iRGV+5DxABKMl1MD4mXh76WWUwTNbbIasCwYJGNshqudBVJID9s JmdgQ7bEGQ04CqplqcZ9VBaR+LAVnOZ7Dvj1aRQjdc2W5M8PYZdygGRwtDozpN/SDaLDs0HPhs w64= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:15:51 -0800 IronPort-SDR: XNcg8hsCrf9fMcVBZdicarA9quhPvwOk7+Fk/x6lvqE5Xh5cDTzY7m8sdOCrSpwami7f+3P2YI EofA2H3mpk7cLSfjiyXnBKGPKe2KPv9OE/CAMvpxAGuZNxGxQ7moHiBIN/O1eP44zeDV1gp4Te d03KzH/BxQpAo67T9XkbmQ1UsNEy4DQAA/ooJcgXsamWYDLrU4OQPOHWJ8JkLrSyJxyFYN+phG DnEDpQ/2CtbxeQgjDHFrQJ+Iq9Oot2A/jfrMawZV25/ARfm7QiZBlU/drAzJbOGEHRosDAJBYJ hcc= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:04:01 -0800 From: Niklas Cassel To: Damien Le Moal Cc: Christoph Hellwig , Hannes Reinecke , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel Subject: [PATCH v3 15/18] ata: libata: add ATA feature control sub-page translation Date: Tue, 24 Jan 2023 20:03:01 +0100 Message-Id: <20230124190308.127318-16-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org From: Damien Le Moal Add support for the ATA feature control sub-page of the control mode page to enable/disable the command duration limits feature using the cdl_ctrl field of the ATA feature control sub-page. Both mode sense and mode select translation are supported. For mode sense, the ata device flag ATA_DFLAG_CDL_ENABLED is used to cache the status of the command duration limits feature. Enabling this feature is done using a SET FEATURES command with a cdl action set to 1 when the page cdl_ctrl field value is 0x2 (T2A and T2B pages supported). If this field is 0, CDL is disabled using the SET FEATURES command with a cdl action set to 0. Since a device CDL and NCQ priority features should not be used simultaneously, ata_mselect_control_ata_feature() returns an error when attempting to enable CDL with the device priority feature enabled. Conversely, the function ata_ncq_prio_enable_store() used to enable the use of the device NCQ priority feature through sysfs is modified to return an error if the device CDL feature is enabled. Signed-off-by: Damien Le Moal Co-developed-by: Niklas Cassel Signed-off-by: Niklas Cassel Reviewed-by: Hannes Reinecke --- drivers/ata/libata-core.c | 40 ++++++++- drivers/ata/libata-sata.c | 11 ++- drivers/ata/libata-scsi.c | 167 ++++++++++++++++++++++++++++++++------ include/linux/ata.h | 3 + include/linux/libata.h | 1 + 5 files changed, 193 insertions(+), 29 deletions(-) diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c index 17e32b0a6364..9aa49eab2b95 100644 --- a/drivers/ata/libata-core.c +++ b/drivers/ata/libata-core.c @@ -2371,13 +2371,15 @@ static void ata_dev_config_cdl(struct ata_device *dev) { struct ata_port *ap = dev->link->ap; unsigned int err_mask; + bool cdl_enabled; u64 val; if (ata_id_major_version(dev->id) < 12) goto not_supported; if (!ata_log_supported(dev, ATA_LOG_IDENTIFY_DEVICE) || - !ata_identify_page_supported(dev, ATA_LOG_SUPPORTED_CAPABILITIES)) + !ata_identify_page_supported(dev, ATA_LOG_SUPPORTED_CAPABILITIES) || + !ata_identify_page_supported(dev, ATA_LOG_CURRENT_SETTINGS)) goto not_supported; err_mask = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE, @@ -2396,6 +2398,40 @@ static void ata_dev_config_cdl(struct ata_device *dev) ata_dev_warn(dev, "Command duration guideline is not supported\n"); + /* + * If CDL is marked as enabled, make sure the feature is enabled too. + * Conversely, if CDL is disabled, make sure the feature is turned off. + */ + err_mask = ata_read_log_page(dev, ATA_LOG_IDENTIFY_DEVICE, + ATA_LOG_CURRENT_SETTINGS, + ap->sector_buf, 1); + if (err_mask) + goto not_supported; + + val = get_unaligned_le64(&ap->sector_buf[8]); + cdl_enabled = val & BIT_ULL(63) && val & BIT_ULL(21); + if (dev->flags & ATA_DFLAG_CDL_ENABLED) { + if (!cdl_enabled) { + /* Enable CDL on the device */ + err_mask = ata_dev_set_feature(dev, SETFEATURES_CDL, 1); + if (err_mask) { + ata_dev_err(dev, + "Enable CDL feature failed\n"); + goto not_supported; + } + } + } else { + if (cdl_enabled) { + /* Disable CDL on the device */ + err_mask = ata_dev_set_feature(dev, SETFEATURES_CDL, 0); + if (err_mask) { + ata_dev_err(dev, + "Disable CDL feature failed\n"); + goto not_supported; + } + } + } + /* * Command duration limits is supported: cache the CDL log page 18h * (command duration descriptors). @@ -2412,7 +2448,7 @@ static void ata_dev_config_cdl(struct ata_device *dev) return; not_supported: - dev->flags &= ~ATA_DFLAG_CDL; + dev->flags &= ~(ATA_DFLAG_CDL | ATA_DFLAG_CDL_ENABLED); } static int ata_dev_config_lba(struct ata_device *dev) diff --git a/drivers/ata/libata-sata.c b/drivers/ata/libata-sata.c index f3e7396e3191..57cb33060c9d 100644 --- a/drivers/ata/libata-sata.c +++ b/drivers/ata/libata-sata.c @@ -907,10 +907,17 @@ static ssize_t ata_ncq_prio_enable_store(struct device *device, goto unlock; } - if (input) + if (input) { + if (dev->flags & ATA_DFLAG_CDL_ENABLED) { + ata_dev_err(dev, + "CDL must be disabled to enable NCQ priority\n"); + rc = -EINVAL; + goto unlock; + } dev->flags |= ATA_DFLAG_NCQ_PRIO_ENABLED; - else + } else { dev->flags &= ~ATA_DFLAG_NCQ_PRIO_ENABLED; + } unlock: spin_unlock_irq(ap->lock); diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c index 9315a4c01276..8dde1cede5ca 100644 --- a/drivers/ata/libata-scsi.c +++ b/drivers/ata/libata-scsi.c @@ -58,6 +58,8 @@ static struct ata_device *__ata_scsi_find_dev(struct ata_port *ap, #define CDL_T2A_SUB_MPAGE 0x07 #define CDL_T2B_SUB_MPAGE 0x08 #define CDL_T2_SUB_MPAGE_LEN 232 +#define ATA_FEATURE_SUB_MPAGE 0xf2 +#define ATA_FEATURE_SUB_MPAGE_LEN 16 static const u8 def_rw_recovery_mpage[RW_RECOVERY_MPAGE_LEN] = { RW_RECOVERY_MPAGE, @@ -2286,6 +2288,31 @@ static unsigned int ata_msense_control_spgt2(struct ata_device *dev, u8 *buf, return CDL_T2_SUB_MPAGE_LEN; } +/* + * Simulate MODE SENSE control mode page, sub-page f2h + * (ATA feature control mode page). + */ +static unsigned int ata_msense_control_ata_feature(struct ata_device *dev, + u8 *buf) +{ + /* PS=0, SPF=1 */ + buf[0] = CONTROL_MPAGE | (1 << 6); + buf[1] = ATA_FEATURE_SUB_MPAGE; + + /* + * The first four bytes of ATA Feature Control mode page are a header. + * The PAGE LENGTH field is the size of the page excluding the header. + */ + put_unaligned_be16(ATA_FEATURE_SUB_MPAGE_LEN - 4, &buf[2]); + + if (dev->flags & ATA_DFLAG_CDL) + buf[4] = 0x02; /* Support T2A and T2B pages */ + else + buf[4] = 0; + + return ATA_FEATURE_SUB_MPAGE_LEN; +} + /** * ata_msense_control - Simulate MODE SENSE control mode page * @dev: ATA device of interest @@ -2309,10 +2336,13 @@ static unsigned int ata_msense_control(struct ata_device *dev, u8 *buf, case CDL_T2A_SUB_MPAGE: case CDL_T2B_SUB_MPAGE: return ata_msense_control_spgt2(dev, buf, spg); + case ATA_FEATURE_SUB_MPAGE: + return ata_msense_control_ata_feature(dev, buf); case ALL_SUB_MPAGES: n = ata_msense_control_spg0(dev, buf, changeable); n += ata_msense_control_spgt2(dev, buf + n, CDL_T2A_SUB_MPAGE); n += ata_msense_control_spgt2(dev, buf + n, CDL_T2A_SUB_MPAGE); + n += ata_msense_control_ata_feature(dev, buf + n); return n; default: return 0; @@ -2391,7 +2421,7 @@ static unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf) spg = scsicmd[3]; /* - * Supported subpages: all subpages and sub-pages 07h and 08h of + * Supported subpages: all subpages and sub-pages 07h, 08h and f2h of * the control page. */ if (spg) { @@ -2400,6 +2430,7 @@ static unsigned int ata_scsiop_mode_sense(struct ata_scsi_args *args, u8 *rbuf) break; case CDL_T2A_SUB_MPAGE: case CDL_T2B_SUB_MPAGE: + case ATA_FEATURE_SUB_MPAGE: if (dev->flags & ATA_DFLAG_CDL && pg == CONTROL_MPAGE) break; fallthrough; @@ -3708,20 +3739,11 @@ static int ata_mselect_caching(struct ata_queued_cmd *qc, return 0; } -/** - * ata_mselect_control - Simulate MODE SELECT for control page - * @qc: Storage for translated ATA taskfile - * @buf: input buffer - * @len: number of valid bytes in the input buffer - * @fp: out parameter for the failed field on error - * - * Prepare a taskfile to modify caching information for the device. - * - * LOCKING: - * None. +/* + * Simulate MODE SELECT control mode page, sub-page 0. */ -static int ata_mselect_control(struct ata_queued_cmd *qc, - const u8 *buf, int len, u16 *fp) +static int ata_mselect_control_spg0(struct ata_queued_cmd *qc, + const u8 *buf, int len, u16 *fp) { struct ata_device *dev = qc->dev; u8 mpage[CONTROL_MPAGE_LEN]; @@ -3759,6 +3781,83 @@ static int ata_mselect_control(struct ata_queued_cmd *qc, return 0; } +/* + * Translate MODE SELECT control mode page, sub-pages f2h (ATA feature mode + * page) into a SET FEATURES command. + */ +static unsigned int ata_mselect_control_ata_feature(struct ata_queued_cmd *qc, + const u8 *buf, int len, + u16 *fp) +{ + struct ata_device *dev = qc->dev; + struct ata_taskfile *tf = &qc->tf; + u8 cdl_action; + + /* + * The first four bytes of ATA Feature Control mode page are a header, + * so offsets in mpage are off by 4 compared to buf. Same for len. + */ + if (len != ATA_FEATURE_SUB_MPAGE_LEN - 4) { + *fp = min(len, ATA_FEATURE_SUB_MPAGE_LEN - 4); + return -EINVAL; + } + + /* Check cdl_ctrl */ + switch (buf[0] & 0x03) { + case 0: + /* Disable CDL */ + cdl_action = 0; + dev->flags &= ~ATA_DFLAG_CDL_ENABLED; + break; + case 0x02: + /* Enable CDL T2A/T2B: NCQ priority must be disabled */ + if (dev->flags & ATA_DFLAG_NCQ_PRIO_ENABLED) { + ata_dev_err(dev, + "NCQ priority must be disabled to enable CDL\n"); + return -EINVAL; + } + cdl_action = 1; + dev->flags |= ATA_DFLAG_CDL_ENABLED; + break; + default: + *fp = 0; + return -EINVAL; + } + + tf->flags |= ATA_TFLAG_DEVICE | ATA_TFLAG_ISADDR; + tf->protocol = ATA_PROT_NODATA; + tf->command = ATA_CMD_SET_FEATURES; + tf->feature = SETFEATURES_CDL; + tf->nsect = cdl_action; + + return 1; +} + +/** + * ata_mselect_control - Simulate MODE SELECT for control page + * @qc: Storage for translated ATA taskfile + * @buf: input buffer + * @len: number of valid bytes in the input buffer + * @fp: out parameter for the failed field on error + * + * Prepare a taskfile to modify caching information for the device. + * + * LOCKING: + * None. + */ +static int ata_mselect_control(struct ata_queued_cmd *qc, u8 spg, + const u8 *buf, int len, u16 *fp) +{ + switch (spg) { + case 0: + return ata_mselect_control_spg0(qc, buf, len, fp); + case ATA_FEATURE_SUB_MPAGE: + return ata_mselect_control_ata_feature(qc, buf, len, fp); + default: + return -EINVAL; + } +} + /** * ata_scsi_mode_select_xlat - Simulate MODE SELECT 6, 10 commands * @qc: Storage for translated ATA taskfile @@ -3776,7 +3875,7 @@ static unsigned int ata_scsi_mode_select_xlat(struct ata_queued_cmd *qc) const u8 *cdb = scmd->cmnd; u8 pg, spg; unsigned six_byte, pg_len, hdr_len, bd_len; - int len; + int len, ret; u16 fp = (u16)-1; u8 bp = 0xff; u8 buffer[64]; @@ -3861,13 +3960,29 @@ static unsigned int ata_scsi_mode_select_xlat(struct ata_queued_cmd *qc) } /* - * No mode subpages supported (yet) but asking for _all_ - * subpages may be valid + * Supported subpages: all subpages and ATA feature sub-page f2h of + * the control page. */ - if (spg && (spg != ALL_SUB_MPAGES)) { - fp = (p[0] & 0x40) ? 1 : 0; - fp += hdr_len + bd_len; - goto invalid_param; + if (spg) { + switch (spg) { + case ALL_SUB_MPAGES: + /* All subpages is not supported for the control page */ + if (pg == CONTROL_MPAGE) { + fp = (p[0] & 0x40) ? 1 : 0; + fp += hdr_len + bd_len; + goto invalid_param; + } + break; + case ATA_FEATURE_SUB_MPAGE: + if (qc->dev->flags & ATA_DFLAG_CDL && + pg == CONTROL_MPAGE) + break; + fallthrough; + default: + fp = (p[0] & 0x40) ? 1 : 0; + fp += hdr_len + bd_len; + goto invalid_param; + } } if (pg_len > len) goto invalid_param_len; @@ -3880,14 +3995,16 @@ static unsigned int ata_scsi_mode_select_xlat(struct ata_queued_cmd *qc) } break; case CONTROL_MPAGE: - if (ata_mselect_control(qc, p, pg_len, &fp) < 0) { + ret = ata_mselect_control(qc, spg, p, pg_len, &fp); + if (ret < 0) { fp += hdr_len + bd_len; goto invalid_param; - } else { - goto skip; /* No ATA command to send */ } + if (!ret) + goto skip; /* No ATA command to send */ break; - default: /* invalid page code */ + default: + /* Invalid page code */ fp = bd_len + hdr_len; goto invalid_param; } diff --git a/include/linux/ata.h b/include/linux/ata.h index b01e2cebe1fe..a59b17d6ad11 100644 --- a/include/linux/ata.h +++ b/include/linux/ata.h @@ -330,6 +330,7 @@ enum { /* Identify device log pages: */ ATA_LOG_SUPPORTED_CAPABILITIES = 0x03, + ATA_LOG_CURRENT_SETTINGS = 0x04, ATA_LOG_SECURITY = 0x06, ATA_LOG_SATA_SETTINGS = 0x08, ATA_LOG_ZONED_INFORMATION = 0x09, @@ -419,6 +420,8 @@ enum { SETFEATURES_SATA_ENABLE = 0x10, /* Enable use of SATA feature */ SETFEATURES_SATA_DISABLE = 0x90, /* Disable use of SATA feature */ + SETFEATURES_CDL = 0x0d, /* Enable/disable cmd duration limits */ + /* SETFEATURE Sector counts for SATA features */ SATA_FPDMA_OFFSET = 0x01, /* FPDMA non-zero buffer offsets */ SATA_FPDMA_AA = 0x02, /* FPDMA Setup FIS Auto-Activate */ diff --git a/include/linux/libata.h b/include/linux/libata.h index 2b17d6c99a37..d7fe735e6322 100644 --- a/include/linux/libata.h +++ b/include/linux/libata.h @@ -106,6 +106,7 @@ enum { ATA_DFLAG_INIT_MASK = (1 << 20) - 1, ATA_DFLAG_NCQ_PRIO_ENABLED = (1 << 20), /* Priority cmds sent to dev */ + ATA_DFLAG_CDL_ENABLED = (1 << 21), /* cmd duration limits is enabled */ ATA_DFLAG_DETACH = (1 << 24), ATA_DFLAG_DETACHED = (1 << 25), ATA_DFLAG_DA = (1 << 26), /* device supports Device Attention */ From patchwork Tue Jan 24 19:03:02 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114607 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id B8E51C54EED for ; Tue, 24 Jan 2023 19:05:25 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234612AbjAXTFX (ORCPT ); Tue, 24 Jan 2023 14:05:23 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43706 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234655AbjAXTEo (ORCPT ); Tue, 24 Jan 2023 14:04:44 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 363214FCD4; Tue, 24 Jan 2023 11:04:06 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587045; x=1706123045; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=2L3tWWnJ6QIqgTYypH5d+eVrRfVHJAkXfzHHNeLWbLc=; b=EtMtg8UAXEr5bCsseAYyAIuiLHhKxRkpTybC5D4NBbc337lwfByf4iAz R27DSMtlvSLF8Ry3wejPaPvWNcv7O/7x4rBQPwACfC9WhF7QN17t6rN8L eZMi1hKth4OhfRe/UYipBhgDCbC6lTeftLXCBsVX8Bh4NAz+0kuLf+bdm 9RPBYPdFKoTx+AMyjMdMQw90DFdcjRkxl1YElG4AdueUV63sjcia7H7in 2NBMF7IZ7sgqFDxj0Ud1qv27G/haj2RBSdGB9E8YVw5EEO3X4YaCog7a0 Lgx71Q0X8G8LKxfWc5gaP5CkSicfAA5uXxPw6b9p6f8w/klaXP2lGIXVG g==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472983" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:04:05 +0800 IronPort-SDR: 31i3DEvpJL4l7iiV19ZtKe6LUrbu98sX7G7zCqzDwgcWukDRyNG3f1pdtdDUkqf3IQwfVR7KM+ syUaNHf0YsBhthGxtVMYIn6TqDBRtgIm06b6TTBJKsq8NJ1TlDU1G7RTwNtLafq291AKlSHjBo 2P8dqfKofIIi3HYNtyT59WZdQt21/gd5z0LobTrYa/lRNOnoIVLjH2UyEl6UDewHfe40NgwdZK viqgMo/y6xHnp+LaFpAS+ft8E0MpJFSXgmLdanilSvymNOErl9pRAX6V53G5suqvJcFFNjjS/U tR8= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:15:54 -0800 IronPort-SDR: DD3g/oM8XaZonsKOWyxJAccC1U7+WjxPD33WeiZghxfuYMsCnj5uYprHiT8qg1pmDuJP0QQw8F yzpsbYvUGiJdTqSn6Crkuj4By1tBMvhYUW2XJ1cdg5QTJxKnyD6W/4/JosC1CmVBXFgfFTenLR /TKWZvoJoyb/a+UQ4UbZrYJr026dESZy40+Xx7rDrM7SMlf6tIPEwLFx2JAE7YQh4CQDG5OpPW aoGf3sspUeR6Uh6EXDXSixf1yWaHXg4SLY1i1WD8B0Ot05tTgEks9NkpRLJClzr5f9JO/hfwqB 8fY= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:04:04 -0800 From: Niklas Cassel To: Damien Le Moal Cc: Christoph Hellwig , Hannes Reinecke , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel Subject: [PATCH v3 16/18] ata: libata: set read/write commands CDL index Date: Tue, 24 Jan 2023 20:03:02 +0100 Message-Id: <20230124190308.127318-17-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org From: Damien Le Moal For devices supporting the command duration limits feature, when a read or write operation has the IOPRIO_CLASS_DL priority class and the command duration limits feature is enabled, set the command duration limit index field of the command to the priority level. For unqueued read and write operations, the command duration limit index is set as the lower 2 bits of the feature field. For queued NCQ read/write commands, the index is set as the lower 2 bits of the auxiliary field. Signed-off-by: Damien Le Moal Co-developed-by: Niklas Cassel Signed-off-by: Niklas Cassel Reviewed-by: Hannes Reinecke --- drivers/ata/libata-core.c | 43 ++++++++++++++++++++++++++++++++++----- drivers/ata/libata-scsi.c | 3 +-- drivers/ata/libata.h | 2 +- include/linux/libata.h | 1 + 4 files changed, 41 insertions(+), 8 deletions(-) diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c index 9aa49eab2b95..2c1531ef169d 100644 --- a/drivers/ata/libata-core.c +++ b/drivers/ata/libata-core.c @@ -665,13 +665,37 @@ u64 ata_tf_read_block(const struct ata_taskfile *tf, struct ata_device *dev) return block; } +/* + * Set a taskfile CDL index. + */ +static inline void ata_set_tf_cdl(struct ata_queued_cmd *qc, int ioprio) +{ + struct ata_taskfile *tf = &qc->tf; + int cdl; + + if (IOPRIO_PRIO_CLASS(ioprio) != IOPRIO_CLASS_DL) + return; + + cdl = IOPRIO_PRIO_DATA(ioprio) & 0x07; + if (!cdl) + return; + + if (tf->protocol == ATA_PROT_NCQ) + tf->auxiliary |= cdl; + else + tf->feature |= cdl; + + /* Mark this command as having a CDL */ + qc->flags |= ATA_QCFLAG_HAS_CDL; +} + /** * ata_build_rw_tf - Build ATA taskfile for given read/write request * @qc: Metadata associated with the taskfile to build * @block: Block address * @n_block: Number of blocks * @tf_flags: RW/FUA etc... - * @class: IO priority class + * @ioprio: IO priority class and level * * LOCKING: * None. @@ -685,7 +709,7 @@ u64 ata_tf_read_block(const struct ata_taskfile *tf, struct ata_device *dev) * -EINVAL if the request is invalid. */ int ata_build_rw_tf(struct ata_queued_cmd *qc, u64 block, u32 n_block, - unsigned int tf_flags, int class) + unsigned int tf_flags, int ioprio) { struct ata_taskfile *tf = &qc->tf; struct ata_device *dev = qc->dev; @@ -722,13 +746,22 @@ int ata_build_rw_tf(struct ata_queued_cmd *qc, u64 block, u32 n_block, tf->device |= 1 << 7; if (dev->flags & ATA_DFLAG_NCQ_PRIO_ENABLED && - class == IOPRIO_CLASS_RT) + IOPRIO_PRIO_CLASS(ioprio) == IOPRIO_CLASS_RT) tf->hob_nsect |= ATA_PRIO_HIGH << ATA_SHIFT_PRIO; + + if (dev->flags & ATA_DFLAG_CDL_ENABLED) + ata_set_tf_cdl(qc, ioprio); + } else if (dev->flags & ATA_DFLAG_LBA) { tf->flags |= ATA_TFLAG_LBA; - /* We need LBA48 for FUA writes */ - if (!(tf->flags & ATA_TFLAG_FUA) && lba_28_ok(block, n_block)) { + if (dev->flags & ATA_DFLAG_CDL_ENABLED) + ata_set_tf_cdl(qc, ioprio); + + /* Both FUA writes and a CDL index require 48-bit commands */ + if (!(tf->flags & ATA_TFLAG_FUA) && + !(qc->flags & ATA_QCFLAG_HAS_CDL) && + lba_28_ok(block, n_block)) { /* use LBA28 */ tf->device |= (block >> 24) & 0xf; } else if (lba_48_ok(block, n_block)) { diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c index 8dde1cede5ca..ce5c6a49a098 100644 --- a/drivers/ata/libata-scsi.c +++ b/drivers/ata/libata-scsi.c @@ -1546,7 +1546,6 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc) struct scsi_cmnd *scmd = qc->scsicmd; const u8 *cdb = scmd->cmnd; struct request *rq = scsi_cmd_to_rq(scmd); - int class = IOPRIO_PRIO_CLASS(req_get_ioprio(rq)); unsigned int tf_flags = 0; u64 block; u32 n_block; @@ -1622,7 +1621,7 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc) qc->flags |= ATA_QCFLAG_IO; qc->nbytes = n_block * scmd->device->sector_size; - rc = ata_build_rw_tf(qc, block, n_block, tf_flags, class); + rc = ata_build_rw_tf(qc, block, n_block, tf_flags, req_get_ioprio(rq)); if (likely(rc == 0)) return 0; diff --git a/drivers/ata/libata.h b/drivers/ata/libata.h index 2cd6124a01e8..26aa777a2ad0 100644 --- a/drivers/ata/libata.h +++ b/drivers/ata/libata.h @@ -45,7 +45,7 @@ static inline void ata_force_cbl(struct ata_port *ap) { } extern u64 ata_tf_to_lba(const struct ata_taskfile *tf); extern u64 ata_tf_to_lba48(const struct ata_taskfile *tf); extern int ata_build_rw_tf(struct ata_queued_cmd *qc, u64 block, u32 n_block, - unsigned int tf_flags, int class); + unsigned int tf_flags, int ioprio); extern u64 ata_tf_read_block(const struct ata_taskfile *tf, struct ata_device *dev); extern unsigned ata_exec_internal(struct ata_device *dev, diff --git a/include/linux/libata.h b/include/linux/libata.h index d7fe735e6322..ab8b62036c12 100644 --- a/include/linux/libata.h +++ b/include/linux/libata.h @@ -209,6 +209,7 @@ enum { ATA_QCFLAG_CLEAR_EXCL = (1 << 5), /* clear excl_link on completion */ ATA_QCFLAG_QUIET = (1 << 6), /* don't report device error */ ATA_QCFLAG_RETRY = (1 << 7), /* retry after failure */ + ATA_QCFLAG_HAS_CDL = (1 << 8), /* qc has CDL a descriptor set */ ATA_QCFLAG_EH = (1 << 16), /* cmd aborted and owned by EH */ ATA_QCFLAG_SENSE_VALID = (1 << 17), /* sense data valid */ From patchwork Tue Jan 24 19:03:03 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114609 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id C137EC54EB4 for ; Tue, 24 Jan 2023 19:05:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234671AbjAXTFg (ORCPT ); Tue, 24 Jan 2023 14:05:36 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42270 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234727AbjAXTEs (ORCPT ); Tue, 24 Jan 2023 14:04:48 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 3D2524FCE3; Tue, 24 Jan 2023 11:04:09 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587048; x=1706123048; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=poQcRLiqchIUPpnAwgCA552iMaEg2365i03ShC1g3m4=; b=GExkCs+zekeK5kWDLXERVdDQ77Qf4w/6olgUWI+hW7TXXOx/HWDCtt9d ip18Pr4sLYdLERYdnQI6H3OJmJsU79O4CVI2d2dWJ73RpIJ4YQzS+5KB3 aoEJkcK8QxnItBiLy1rEZZXUMA70U+5t3unFp8phKOufzBb7BBw1ELMYO ATVjgivYH6O3+OMMXuN5AsAvUTJ+epU7ec5RPsO7hRPGFHNtBP0gsiWll hMuNlxyn6EVv1opiWcVrZsysyV6GBvA8wAZYvc37lyWZ8BIBd4fROXvAy w/OD3SO3+zASj5TRomVGaW7Q+NTlTpy6iEuAUPwj56pYf7dhCpK7Srd6S Q==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472989" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:04:08 +0800 IronPort-SDR: mMfQ0+4q0MSZhFa6dvc+HdvCS+wcUBX+gxomzwkTasIy49PQJxY947ipUgZARJKjqqF9kBLPBD PDMi/fdIWgklzTU0q3y4Yr79RaR9l9j+lNU0jMM2ORhku8OtvlezNZiRL1P9r7+5JuKjAfqqAN oTLzol6YpwQ1RJg4b1Tk217mKXSn0aRpOmWROEQw4Wmk30SqlkYXGgiTD8V4oQ/RFcFzYUisCr G+eQhuC/fDDHhhzqujrRD29HVQ99VEySpOla3yGeQWfbi/PgEvLUX3xcB6szERX6GLDKmccBuX rEA= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:15:57 -0800 IronPort-SDR: u40xJrsUebLK+fcewq0APVybSf1vF4sFYc4kQsWburykQmT6V1hrYlMdI7g/JZurFPAs5UfQzL zTE4kqqe82+uu+CtjSvN5ASylumTNHTrceBj9MNOCJtxiJ3QMmvN1hqo9aevVCBPRhz5HxxmSO S1wWdYIiQjnmLff/uSCwXbenLOx2SoiRzce8zQrqEH7LYexJGLV/XJJnQ3dtAcFeQmXfZ7tARP dYLPLtLcThM6ecARcnGt/KN4m8tdXGRrlI5seYvXmzxzS7aKwUl41umF3oS3DKJpAwlCLt44qH IPs= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:04:07 -0800 From: Niklas Cassel To: Damien Le Moal Cc: Christoph Hellwig , Hannes Reinecke , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel Subject: [PATCH v3 17/18] ata: libata: handle completion of CDL commands using policy 0xD Date: Tue, 24 Jan 2023 20:03:03 +0100 Message-Id: <20230124190308.127318-18-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org A CDL timeout for policy 0xF is defined as a NCQ error, just with a CDL specific sk/asc/ascq in the sense data. Therefore, the existing code in libata does not need to be modified to handle a policy 0xF CDL timeout. For Command Duration Limits policy 0xD: The device shall complete the command without error with the additional sense code set to DATA CURRENTLY UNAVAILABLE. Since a CDL timeout for policy 0xD is not an error, we cannot use the NCQ Command Error log (10h). Instead, we need to read the Sense Data for Successful NCQ Commands log (0Fh). In the success case, just like in the error case, we cannot simply read a log page from the interrupt handler itself, since reading a log page involves sending a READ LOG DMA EXT or READ LOG EXT command. Therefore, we add a new EH action ATA_EH_GET_SUCCESS_SENSE. When a command completes without error, and when the ATA_SENSE bit is set, this new action is set as pending, and EH is scheduled. This way, similar to the NCQ error case, the log page will be read from EH context. An alternative would have been to add a new kthread or workqueue to handle this. However, extending EH can be done with minimal changes and avoids the need to synchronize a new kthread/workqueue with EH. Co-developed-by: Damien Le Moal Signed-off-by: Damien Le Moal Signed-off-by: Niklas Cassel Reviewed-by: Hannes Reinecke --- drivers/ata/libata-core.c | 88 +++++++++++++++++++++++++++++++- drivers/ata/libata-eh.c | 105 +++++++++++++++++++++++++++++++++++++- drivers/ata/libata-sata.c | 92 +++++++++++++++++++++++++++++++++ include/linux/ata.h | 3 ++ include/linux/libata.h | 11 +++- 5 files changed, 295 insertions(+), 4 deletions(-) diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c index 2c1531ef169d..b4761c3c4b91 100644 --- a/drivers/ata/libata-core.c +++ b/drivers/ata/libata-core.c @@ -685,8 +685,12 @@ static inline void ata_set_tf_cdl(struct ata_queued_cmd *qc, int ioprio) else tf->feature |= cdl; - /* Mark this command as having a CDL */ - qc->flags |= ATA_QCFLAG_HAS_CDL; + /* + * Mark this command as having a CDL and request the result + * task file so that we can inspect the sense data available + * bit on completion. + */ + qc->flags |= ATA_QCFLAG_HAS_CDL | ATA_QCFLAG_RESULT_TF; } /** @@ -2431,6 +2435,24 @@ static void ata_dev_config_cdl(struct ata_device *dev) ata_dev_warn(dev, "Command duration guideline is not supported\n"); + /* + * We must have support for the sense data for successful NCQ commands + * log indicated by the successful NCQ command sense data supported bit. + */ + val = get_unaligned_le64(&ap->sector_buf[8]); + if (!(val & BIT_ULL(63)) || !(val & BIT_ULL(47))) { + ata_dev_warn(dev, + "CDL supported but Successful NCQ Command Sense Data is not supported\n"); + goto not_supported; + } + + /* Without NCQ autosense, the successful NCQ commands log is useless. */ + if (!ata_id_has_ncq_autosense(dev->id)) { + ata_dev_warn(dev, + "CDL supported but NCQ autosense is not supported\n"); + goto not_supported; + } + /* * If CDL is marked as enabled, make sure the feature is enabled too. * Conversely, if CDL is disabled, make sure the feature is turned off. @@ -2465,6 +2487,35 @@ static void ata_dev_config_cdl(struct ata_device *dev) } } + /* + * While CDL itself has to be enabled using sysfs, CDL requires that + * sense data for successful NCQ commands is enabled to work properly. + * Just like ata_dev_config_sense_reporting(), enable it unconditionally + * if supported. + */ + if (!(val & BIT_ULL(63)) || !(val & BIT_ULL(18))) { + err_mask = ata_dev_set_feature(dev, + SETFEATURE_SENSE_DATA_SUCC_NCQ, 0x1); + if (err_mask) { + ata_dev_warn(dev, + "failed to enable Sense Data for successful NCQ commands, Emask 0x%x\n", + err_mask); + goto not_supported; + } + } + + /* + * Allocate a buffer to handle reading the sense data for successful + * NCQ Commands log page for commands using a CDL with one of the limit + * policy set to 0xD (successful completion with sense data available + * bit set). + */ + if (!ap->ncq_sense_buf) { + ap->ncq_sense_buf = kmalloc(ATA_LOG_SENSE_NCQ_SIZE, GFP_KERNEL); + if (!ap->ncq_sense_buf) + goto not_supported; + } + /* * Command duration limits is supported: cache the CDL log page 18h * (command duration descriptors). @@ -2482,6 +2533,8 @@ static void ata_dev_config_cdl(struct ata_device *dev) not_supported: dev->flags &= ~(ATA_DFLAG_CDL | ATA_DFLAG_CDL_ENABLED); + kfree(ap->ncq_sense_buf); + ap->ncq_sense_buf = NULL; } static int ata_dev_config_lba(struct ata_device *dev) @@ -4882,6 +4935,36 @@ void ata_qc_complete(struct ata_queued_cmd *qc) fill_result_tf(qc); trace_ata_qc_complete_done(qc); + + /* + * For CDL commands that completed without an error, check if + * we have sense data (ATA_SENSE is set). If we do, then the + * command may have been aborted by the device due to a limit + * timeout using the policy 0xD. For these commands, invoke EH + * to get the command sense data. + */ + if (qc->result_tf.status & ATA_SENSE && + ((ata_is_ncq(qc->tf.protocol) && + dev->flags & ATA_DFLAG_CDL_ENABLED) || + (!(ata_is_ncq(qc->tf.protocol) && + ata_id_sense_reporting_enabled(dev->id))))) { + /* + * Tell SCSI EH to not overwrite scmd->result even if + * this command is finished with result SAM_STAT_GOOD. + */ + qc->scsicmd->flags |= SCMD_FORCE_EH_SUCCESS; + qc->flags |= ATA_QCFLAG_EH_SUCCESS_CMD; + ehi->dev_action[dev->devno] |= ATA_EH_GET_SUCCESS_SENSE; + + /* + * set pending so that ata_qc_schedule_eh() does not + * trigger fast drain, and freeze the port. + */ + ap->pflags |= ATA_PFLAG_EH_PENDING; + ata_qc_schedule_eh(qc); + return; + } + /* Some commands need post-processing after successful * completion. */ @@ -5514,6 +5597,7 @@ static void ata_host_release(struct kref *kref) kfree(ap->pmp_link); kfree(ap->slave_link); + kfree(ap->ncq_sense_buf); kfree(ap); host->ports[i] = NULL; } diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c index 598ae07195b6..05af292eb8ce 100644 --- a/drivers/ata/libata-eh.c +++ b/drivers/ata/libata-eh.c @@ -1917,6 +1917,99 @@ static inline bool ata_eh_quiet(struct ata_queued_cmd *qc) return qc->flags & ATA_QCFLAG_QUIET; } +static int ata_eh_read_sense_success_non_ncq(struct ata_link *link) +{ + struct ata_port *ap = link->ap; + struct ata_queued_cmd *qc; + + qc = __ata_qc_from_tag(ap, link->active_tag); + if (!qc) + return -EIO; + + if (!(qc->flags & ATA_QCFLAG_EH) || + !(qc->flags & ATA_QCFLAG_EH_SUCCESS_CMD) || + qc->err_mask) + return -EIO; + + if (!ata_eh_request_sense(qc)) + return -EIO; + + /* + * If we have sense data, call scsi_check_sense() in order to set the + * correct SCSI ML byte (if any). No point in checking the return value, + * since the command has already completed successfully. + */ + scsi_check_sense(qc->scsicmd); + + return 0; +} + +static void ata_eh_get_success_sense(struct ata_link *link) +{ + struct ata_eh_context *ehc = &link->eh_context; + struct ata_device *dev = link->device; + struct ata_port *ap = link->ap; + struct ata_queued_cmd *qc; + int tag, ret = 0; + + if (!(ehc->i.dev_action[dev->devno] & ATA_EH_GET_SUCCESS_SENSE)) + return; + + /* if frozen, we can't do much */ + if (ata_port_is_frozen(ap)) { + ata_dev_warn(dev, + "successful sense data available but port frozen\n"); + goto out; + } + + /* + * If the link has sactive set, then we have outstanding NCQ commands + * and have to read the Successful NCQ Commands log to get the sense + * data. Otherwise, we are dealing with a non-NCQ command and use + * request sense ext command to retrieve the sense data. + */ + if (link->sactive) + ret = ata_eh_read_sense_success_ncq_log(link); + else + ret = ata_eh_read_sense_success_non_ncq(link); + if (ret) + goto out; + + ata_eh_done(link, dev, ATA_EH_GET_SUCCESS_SENSE); + return; + +out: + /* + * If we failed to get sense data for a successful command that ought to + * have sense data, we cannot simply return BLK_STS_OK to user space. + * This is because we can't know if the sense data that we couldn't get + * was actually "DATA CURRENTLY UNAVAILABLE". Reporting such a command + * as success to user space would result in a silent data corruption. + * Thus, add a bogus ABORTED_COMMAND sense data to such commands, such + * that SCSI will report these commands as BLK_STS_IOERR to user space. + */ + ata_qc_for_each_raw(ap, qc, tag) { + if (!(qc->flags & ATA_QCFLAG_EH) || + !(qc->flags & ATA_QCFLAG_EH_SUCCESS_CMD) || + qc->err_mask || + ata_dev_phys_link(qc->dev) != link) + continue; + + /* We managed to get sense for this success command, skip. */ + if (qc->flags & ATA_QCFLAG_SENSE_VALID) + continue; + + /* This success command did not have any sense data, skip. */ + if (!(qc->result_tf.status & ATA_SENSE)) + continue; + + /* This success command had sense data, but we failed to get. */ + ata_scsi_set_sense(dev, qc->scsicmd, ABORTED_COMMAND, 0, 0); + qc->flags |= ATA_QCFLAG_SENSE_VALID; + } + ata_eh_done(link, dev, ATA_EH_GET_SUCCESS_SENSE); +} + /** * ata_eh_link_autopsy - analyze error and determine recovery action * @link: host link to perform autopsy on @@ -1957,6 +2050,14 @@ static void ata_eh_link_autopsy(struct ata_link *link) /* analyze NCQ failure */ ata_eh_analyze_ncq_error(link); + /* + * Check if this was a successful command that simply needs sense data. + * Since the sense data is not part of the completion, we need to fetch + * it using an additional command. Since this can't be done from irq + * context, the sense data for successful commands are fetched by EH. + */ + ata_eh_get_success_sense(link); + /* any real error trumps AC_ERR_OTHER */ if (ehc->i.err_mask & ~AC_ERR_OTHER) ehc->i.err_mask &= ~AC_ERR_OTHER; @@ -1966,6 +2067,7 @@ static void ata_eh_link_autopsy(struct ata_link *link) ata_qc_for_each_raw(ap, qc, tag) { if (!(qc->flags & ATA_QCFLAG_EH) || qc->flags & ATA_QCFLAG_RETRY || + qc->flags & ATA_QCFLAG_EH_SUCCESS_CMD || ata_dev_phys_link(qc->dev) != link) continue; @@ -3825,7 +3927,8 @@ void ata_eh_finish(struct ata_port *ap) else ata_eh_qc_complete(qc); } else { - if (qc->flags & ATA_QCFLAG_SENSE_VALID) { + if (qc->flags & ATA_QCFLAG_SENSE_VALID || + qc->flags & ATA_QCFLAG_EH_SUCCESS_CMD) { ata_eh_qc_complete(qc); } else { /* feed zero TF to sense generation */ diff --git a/drivers/ata/libata-sata.c b/drivers/ata/libata-sata.c index 57cb33060c9d..7de4d8901fac 100644 --- a/drivers/ata/libata-sata.c +++ b/drivers/ata/libata-sata.c @@ -11,7 +11,9 @@ #include #include #include +#include #include +#include #include "libata.h" #include "libata-transport.h" @@ -1408,6 +1410,95 @@ static int ata_eh_read_log_10h(struct ata_device *dev, return 0; } +/** + * ata_eh_read_sense_success_ncq_log - Read the sense data for successful + * NCQ commands log + * @link: ATA link to get sense data for + * + * Read the sense data for successful NCQ commands log page to obtain + * sense data for all NCQ commands that completed successfully with + * the sense data available bit set. + * + * LOCKING: + * Kernel thread context (may sleep). + * + * RETURNS: + * 0 on success, -errno otherwise. + */ +int ata_eh_read_sense_success_ncq_log(struct ata_link *link) +{ + struct ata_device *dev = link->device; + struct ata_port *ap = dev->link->ap; + u8 *buf = ap->ncq_sense_buf; + struct ata_queued_cmd *qc; + unsigned int err_mask, tag; + u8 *sense, sk = 0, asc = 0, ascq = 0; + u64 sense_valid, val; + int ret = 0; + + err_mask = ata_read_log_page(dev, ATA_LOG_SENSE_NCQ, 0, buf, 2); + if (err_mask) { + ata_dev_err(dev, + "Failed to read Sense Data for Successful NCQ Commands log\n"); + return -EIO; + } + + /* Check the log header */ + val = get_unaligned_le64(&buf[0]); + if ((val & 0xffff) != 1 || ((val >> 16) & 0xff) != 0x0f) { + ata_dev_err(dev, + "Invalid Sense Data for Successful NCQ Commands log\n"); + return -EIO; + } + + sense_valid = (u64)buf[8] | ((u64)buf[9] << 8) | + ((u64)buf[10] << 16) | ((u64)buf[11] << 24); + + ata_qc_for_each_raw(ap, qc, tag) { + if (!(qc->flags & ATA_QCFLAG_EH) || + !(qc->flags & ATA_QCFLAG_EH_SUCCESS_CMD) || + qc->err_mask || + ata_dev_phys_link(qc->dev) != link) + continue; + + /* + * If the command does not have any sense data, clear ATA_SENSE. + * Keep ATA_QCFLAG_EH_SUCCESS_CMD so that command is finished. + */ + if (!(sense_valid & (1ULL << tag))) { + qc->result_tf.status &= ~ATA_SENSE; + continue; + } + + sense = &buf[32 + 24 * tag]; + sk = sense[0]; + asc = sense[1]; + ascq = sense[2]; + + if (!ata_scsi_sense_is_valid(sk, asc, ascq)) { + ret = -EIO; + continue; + } + + /* Set sense without also setting scsicmd->result */ + scsi_build_sense_buffer(dev->flags & ATA_DFLAG_D_SENSE, + qc->scsicmd->sense_buffer, sk, + asc, ascq); + qc->flags |= ATA_QCFLAG_SENSE_VALID; + + /* + * If we have sense data, call scsi_check_sense() in order to + * set the correct SCSI ML byte (if any). No point in checking + * the return value, since the command has already completed + * successfully. + */ + scsi_check_sense(qc->scsicmd); + } + + return ret; +} +EXPORT_SYMBOL_GPL(ata_eh_read_sense_success_ncq_log); + /** * ata_eh_analyze_ncq_error - analyze NCQ error * @link: ATA link to analyze NCQ error for @@ -1488,6 +1579,7 @@ void ata_eh_analyze_ncq_error(struct ata_link *link) ata_qc_for_each_raw(ap, qc, tag) { if (!(qc->flags & ATA_QCFLAG_EH) || + qc->flags & ATA_QCFLAG_EH_SUCCESS_CMD || ata_dev_phys_link(qc->dev) != link) continue; diff --git a/include/linux/ata.h b/include/linux/ata.h index a59b17d6ad11..2e2e22362096 100644 --- a/include/linux/ata.h +++ b/include/linux/ata.h @@ -326,6 +326,8 @@ enum { ATA_LOG_CDL = 0x18, ATA_LOG_CDL_SIZE = ATA_SECT_SIZE, ATA_LOG_IDENTIFY_DEVICE = 0x30, + ATA_LOG_SENSE_NCQ = 0x0F, + ATA_LOG_SENSE_NCQ_SIZE = ATA_SECT_SIZE * 2, ATA_LOG_CONCURRENT_POSITIONING_RANGES = 0x47, /* Identify device log pages: */ @@ -432,6 +434,7 @@ enum { SATA_DEVSLP = 0x09, /* Device Sleep */ SETFEATURE_SENSE_DATA = 0xC3, /* Sense Data Reporting feature */ + SETFEATURE_SENSE_DATA_SUCC_NCQ = 0xC4, /* Sense Data for successful NCQ commands */ /* feature values for SET_MAX */ ATA_SET_MAX_ADDR = 0x00, diff --git a/include/linux/libata.h b/include/linux/libata.h index ab8b62036c12..70ac635fe5d7 100644 --- a/include/linux/libata.h +++ b/include/linux/libata.h @@ -214,6 +214,7 @@ enum { ATA_QCFLAG_EH = (1 << 16), /* cmd aborted and owned by EH */ ATA_QCFLAG_SENSE_VALID = (1 << 17), /* sense data valid */ ATA_QCFLAG_EH_SCHEDULED = (1 << 18), /* EH scheduled (obsolete) */ + ATA_QCFLAG_EH_SUCCESS_CMD = (1 << 19), /* EH should fetch sense for this successful cmd */ /* host set flags */ ATA_HOST_SIMPLEX = (1 << 0), /* Host is simplex, one DMA channel per host only */ @@ -312,8 +313,10 @@ enum { ATA_EH_RESET = ATA_EH_SOFTRESET | ATA_EH_HARDRESET, ATA_EH_ENABLE_LINK = (1 << 3), ATA_EH_PARK = (1 << 5), /* unload heads and stop I/O */ + ATA_EH_GET_SUCCESS_SENSE = (1 << 6), /* Get sense data for successful cmd */ - ATA_EH_PERDEV_MASK = ATA_EH_REVALIDATE | ATA_EH_PARK, + ATA_EH_PERDEV_MASK = ATA_EH_REVALIDATE | ATA_EH_PARK | + ATA_EH_GET_SUCCESS_SENSE, ATA_EH_ALL_ACTIONS = ATA_EH_REVALIDATE | ATA_EH_RESET | ATA_EH_ENABLE_LINK, @@ -867,6 +870,7 @@ struct ata_port { struct ata_acpi_gtm __acpi_init_gtm; /* use ata_acpi_init_gtm() */ #endif /* owned by EH */ + u8 *ncq_sense_buf; u8 sector_buf[ATA_SECT_SIZE] ____cacheline_aligned; }; @@ -1185,6 +1189,7 @@ extern int sata_link_hardreset(struct ata_link *link, bool *online, int (*check_ready)(struct ata_link *)); extern int sata_link_resume(struct ata_link *link, const unsigned long *params, unsigned long deadline); +extern int ata_eh_read_sense_success_ncq_log(struct ata_link *link); extern void ata_eh_analyze_ncq_error(struct ata_link *link); #else static inline const unsigned long * @@ -1222,6 +1227,10 @@ static inline int sata_link_resume(struct ata_link *link, { return -EOPNOTSUPP; } +static inline int ata_eh_read_sense_success_ncq_log(struct ata_link *link) +{ + return -EOPNOTSUPP; +} static inline void ata_eh_analyze_ncq_error(struct ata_link *link) { } #endif extern int sata_link_debounce(struct ata_link *link, From patchwork Tue Jan 24 19:03:04 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Niklas Cassel X-Patchwork-Id: 13114610 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 92463C54E94 for ; Tue, 24 Jan 2023 19:05:48 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234443AbjAXTFr (ORCPT ); Tue, 24 Jan 2023 14:05:47 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42460 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234434AbjAXTFJ (ORCPT ); Tue, 24 Jan 2023 14:05:09 -0500 Received: from esa5.hgst.iphmx.com (esa5.hgst.iphmx.com [216.71.153.144]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2CFC34FCFD; Tue, 24 Jan 2023 11:04:12 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=simple/simple; d=wdc.com; i=@wdc.com; q=dns/txt; s=dkim.wdc.com; t=1674587052; x=1706123052; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=OOqiYKfmWDTAp+2e6ZBSGTgyOhzF068SxglszHxUP28=; b=DbQCLA43W7uZiC23d6ii0Y7/wfZEFnF7BqGYLNf2d+bH2euuRofTjk5X jKZU3QQQ8uIGMNCvW6S7+nLuhqbhDSyDN+drPlyA1tQ9NABFlUmCwn5ep kk3XrtG4PGtiGBxM3HtgTbL9xjeHamXqlfM99N9S/UouaC451nuUCtzy7 kkgWYF0Ufe8bA/z9wYO+yQzUuobCtzgoI1wGP1KqzMln1VqsSbSCRXjp1 JjrE3jBNV6uc1tLfIoOfT/XtBAa5G01qbQx7gCWJIQQ6AkC7lTdSLS1Jy AzPIGY+r/6rtNTFe6gEGbDuz2Dx91n47gBHgCiGiP4qH6HJB04svflogi w==; X-IronPort-AV: E=Sophos;i="5.97,243,1669046400"; d="scan'208";a="221472992" Received: from h199-255-45-15.hgst.com (HELO uls-op-cesaep02.wdc.com) ([199.255.45.15]) by ob1.hgst.iphmx.com with ESMTP; 25 Jan 2023 03:04:11 +0800 IronPort-SDR: xR9iu7IKWzhmLgsT9J72gZcikp0axPQQH4kDGrMikRIqGtT1T0O5eRoJU3ZtIYmd3kdp7b9he7 mBnCwOx2O+SdRhHfkOSBABpyTSTUVYUFNz/FHc6lQDvDi+2lRpE2qlK2lAtbOOym02l6oxIadO IX3tf+gSB3alA2IQq910UBprfGwL1QCd4npDy1nJtnuKUdvIoewn7aiIfC4V/IulMYM9qfVBI8 Kck0u6qPIRwSvb9bLXzdiB8NxDFc/spvEt0gbNEvZ6s2juWJrPQxJDCgIM4dW0XnhQ4umRU5fK Upc= Received: from uls-op-cesaip02.wdc.com ([10.248.3.37]) by uls-op-cesaep02.wdc.com with ESMTP/TLS/ECDHE-RSA-AES128-GCM-SHA256; 24 Jan 2023 10:16:00 -0800 IronPort-SDR: yvox5jcHKJanTm6+tqUTC5eJy6q85LJ2+66/Lv7Twnq4g5JuwnTiKLtmgSMQ/Ds14KgfO+x5kU NEEueRAcxYamWS3JJf/z10bawlgkHMmXRRzhgzdWwJHGSf+l7RekM813Zofc2XmigmgTT1401T TEm+/ivBrNW7GbIT5PKAZRMDZ0kkXea3bAOrYXGaROrG4wXxBKdQ2mbMJrA/OlVlSZukJQkcNr Ul4CbI9iSQ0vxJP+hrX50mRw/0HG2+upeh2YueMZQ6FUHF2TKDxVhpw0YPH7DRD+dwMhCSJt7n jU8= WDCIronportException: Internal Received: from unknown (HELO x1-carbon.lan) ([10.225.164.48]) by uls-op-cesaip02.wdc.com with ESMTP; 24 Jan 2023 11:04:09 -0800 From: Niklas Cassel To: linux-kernel@vger.kernel.org Cc: Christoph Hellwig , Hannes Reinecke , Damien Le Moal , linux-scsi@vger.kernel.org, linux-ide@vger.kernel.org, linux-block@vger.kernel.org, Niklas Cassel Subject: [PATCH v3 18/18] Documentation: sysfs-block-device: document command duration limits Date: Tue, 24 Jan 2023 20:03:04 +0100 Message-Id: <20230124190308.127318-19-niklas.cassel@wdc.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230124190308.127318-1-niklas.cassel@wdc.com> References: <20230124190308.127318-1-niklas.cassel@wdc.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-block@vger.kernel.org From: Damien Le Moal Document ABI/testing/sysfs-block-device the sysfs attributes present under /sys/block/*/device/duration_limits for ATA and SCSI devices supporting the command duration limits feature. Signed-off-by: Damien Le Moal Signed-off-by: Niklas Cassel Reviewed-by: Hannes Reinecke --- Documentation/ABI/testing/sysfs-block-device | 150 +++++++++++++++++++ 1 file changed, 150 insertions(+) diff --git a/Documentation/ABI/testing/sysfs-block-device b/Documentation/ABI/testing/sysfs-block-device index 7ac7b19b2f72..3a32c86942f5 100644 --- a/Documentation/ABI/testing/sysfs-block-device +++ b/Documentation/ABI/testing/sysfs-block-device @@ -95,3 +95,153 @@ Description: This file does not exist if the HBA driver does not implement support for the SATA NCQ priority feature, regardless of the device support for this feature. + + +What: /sys/block/*/device/duration_limits/enable +Date: Dec, 2022 +KernelVersion: v6.3 +Contact: linux-scsi@vger.kernel.org +Description: + (RW) For ATA and SCSI devices supporting the command duration + limits feature, write to the file to turn on or off the + feature. By default this feature is turned off. If the device + does not support the command duration limits feature, this + attribute does not exist (the directory + "/sys/block/\*/device/duration_limits" does not exist). + Writing "1" to this file enables the use of command duration + limits for read and write commands in the kernel and turns on + the feature on the device. Writing "0" disables the feature. + + +What: /sys/block/*/device/duration_limits/read/[1-7]/* +Date: Dec, 2022 +KernelVersion: v6.3 +Contact: linux-scsi@vger.kernel.org +Description: + (RO) For ATA and SCSI devices supporting the command duration + limits feature, this shows the set of 7 command duration limits + descriptors for read commands currently set on the device. For + each of the 7 descritors, the following read-only attributes + are present: + + - duration_guideline: specifies the preferred length of time + in microseconds for the completion of a command. + + - duration_guideline_policy: specifies the policy action + taken if the duration_guideline attribute specifies a + non-zero command duration guideline that the device is + unable to achieve for a command. + + Possible values are: + + - 0x0: The device will complete the command at the + earliest possible time consistent with the specified + command duration guideline. + + - 0x1: If the specified command duration guideline has not + been achieved and the command duration guideline policy + field is not in the seventh command duration limits + descriptor, then the device continues processing that + command using the command duration limits descriptor + that has the next higher number. + + - 0x2: The device will continue processing the command as + with no command duration limits descriptor being used. + + - 0xD: The device will complete the command and an IO + failure will be reported to the user with the ETIME + error code. + + - 0xF: Same as 0xD. + + - max_active_time: specifies an upper limit in microseconds + on the time that elapses from the time at which the device + initiates actions to access, transfer, or act upon the + specified data until the time the device returns status for + the command. + + - max_active_time_policy: specifies the policy action taken + if the time used to process a command exceeds a non-zero + time specified by the max_active_time attribute. + + Possible values are: + + - 0x0: The device will complete the command at the + earliest possible time (i.e, do nothing based on the max + time limit not being met). + + - 0xD: The device will complete the command and an IO + failure will be reported to the user with the ETIME + error code. + + - 0xE: Same as 0xD. + + - 0xF: Same as 0xD. + + - max_inactive_time: specifies an upper limit in microseconds + on the time that elapses from the time at which the device + receives the command until the time at which the device + initiates actions to access, transfer, or act upon the + specified data. + + - max_inactive_time_policy: specifies the policy action taken + if a non-zero max_inactive_time limit is not met. + + Possible values are: + + - 0x0: The device will complete the command at the + earliest possible time (i.e, do nothing based on the max + time limit not being met). + + - 0xD: The device will complete the command and an IO + failure will be reported to the user with the ETIME + error code. + + - 0xF: Same as 0xD. + + +What: /sys/block/*/device/duration_limits/read/page +Date: Dec, 2022 +KernelVersion: v6.3 +Contact: linux-scsi@vger.kernel.org +Description: + (RO) For ATA and SCSI devices supporting the command duration + limits feature, this shows the name of the device VPD page + specifying the set of 7 command duration limits descriptors for + read commands. Possible values are "T2A" and "T2B". + + +What: /sys/block/*/device/duration_limits/write/[1-7]/* +Date: Dec, 2022 +KernelVersion: v6.3 +Contact: linux-scsi@vger.kernel.org +Description: + (RO) For ATA and SCSI devices supporting the command duration + limits feature, this shows the set of 7 command duration limits + descriptors for write commands currently set on the device. For + each of the 7 descritors, the same set of read-only attributes + as for read commands is present. + + +What: /sys/block/*/device/duration_limits/write/page +Date: Dec, 2022 +KernelVersion: v6.3 +Contact: linux-scsi@vger.kernel.org +Description: + (RO) For ATA and SCSI devices supporting the command duration + limits feature, this shows the name of the device VPD page + specifying the set of 7 command duration limits descriptors for + write commands. Possible values are "T2A" and "T2B". + + +What: /sys/block/*/device/duration_limits/perf_vs_duration_guideline +Date: Dec, 2022 +KernelVersion: v6.3 +Contact: linux-scsi@vger.kernel.org +Description: + (RO) For ATA and SCSI devices supporting the command duration + limits feature, this specifies the maximum percentage increase + in average command completion times (reduction in IOPS) that + is allowed for the device to perform actions based on the + contents of the duration guideline field in every command + duration limit descriptor for both read and write commands.