Commit 8b60e218 authored by Martin K. Petersen's avatar Martin K. Petersen

Merge patch series "Add Command Duration Limits support"

Niklas Cassel <nks@flawful.org> says:

This series adds support for Command Duration Limits.
The series is based on linux tag: v6.4-rc1
The series can also be found in git: https://github.com/floatious/linux/commits/cdl-v7

=================
CDL in ATA / SCSI
=================
Command Duration Limits is defined in:
T13 ATA Command Set - 5 (ACS-5) and
T10 SCSI Primary Commands - 6 (SPC-6) respectively
(a simpler version of CDL is defined in T10 SPC-5).

CDL defines Duration Limits Descriptors (DLD).
7 DLDs for read commands and 7 DLDs for write commands.
Simply put, a DLD contains a limit and a policy.

A command can specify that a certain limit should be applied by setting
the DLD index field (3 bits, so 0-7) in the command itself.

The DLD index points to one of the 7 DLDs.
DLD index 0 means no descriptor, so no limit.
DLD index 1-7 means DLD 1-7.

A DLD can have a few different policies, but the two major ones are:
-Policy 0xF (abort), command will be completed with command aborted error
(ATA) or status CHECK CONDITION (SCSI), with sense data indicating that
the command timed out.
-Policy 0xD (complete-unavailable), command will be completed without
error (ATA) or status GOOD (SCSI), with sense data indicating that the
command timed out. Note that the command will not have transferred any
data to/from the device when the command timed out, even though the
command returned success.

Regardless of the CDL policy, in case of a CDL timeout, the I/O will
result in a -ETIME error to user-space.

The DLDs are defined in the CDL log page(s) and are readable and writable.
Reading and writing the CDL DLDs are outside the scope of the kernel.
If a user wants to read or write the descriptors, they can do so using a
user-space application that sends passthrough commands, such as cdl-tools:
https://github.com/westerndigitalcorporation/cdl-tools

================================
The introduction of ioprio hints
================================
What the kernel does provide, is a method to let I/O use one of the CDL DLDs
defined in the device. Note that the kernel will simply forward the DLD index
to the device, so the kernel currently does not know, nor does it need to know,
how the DLDs are defined inside the device.

The way that the CDL DLD index is supplied to the kernel is by introducing a
new 10 bit "ioprio hint" field within the existing 16 bit ioprio definition.

Currently, only 6 out of the 16 ioprio bits are in use, the remaining 10 bits
are unused, and are currently explicitly disallowed to be set by the kernel.

For now, we only add ioprio hints representing CDL DLD index 1-7. Additional
ioprio hints for other QoS features could be defined in the future.

A theoretical future work could be to make an I/O scheduler aware of these
hints. E.g. for CDL, an I/O scheduler could make use of the duration limit
in each descriptor, and take that information into account while scheduling
commands. Right now, the ioprio hints will be ignored by the I/O schedulers.

==============================
How to use CDL from user-space
==============================
Since CDL is mutually exclusive with NCQ priority
(see ncq_prio_enable and sas_ncq_prio_enable in
Documentation/ABI/testing/sysfs-block-device),
CDL has to be explicitly enabled using:
echo 1 > /sys/block/$bdev/device/cdl_enable

Since the ioprio hints are supplied through the existing I/O priority API,
it should be simple for an application to make use of the ioprio hints.

It simply has to reuse one of the new macros defined in
include/uapi/linux/ioprio.h: IOPRIO_PRIO_HINT() or IOPRIO_PRIO_VALUE_HINT(),
and supply one of the new hints defined in include/uapi/linux/ioprio.h:
IOPRIO_HINT_DEV_DURATION_LIMIT_[1-7], which indicates that the I/O should
use the corresponding CDL DLD index 1-7.

By reusing the I/O priority API, the user can both define a DLD to use per
AIO (io_uring sqe->ioprio or libaio iocb->aio_reqprio) or per-thread
(ioprio_set()).

=======
Testing
=======
With the following fio patches:
https://github.com/floatious/fio/commits/cdl

fio adds support for ioprio hints, such that CDL can be tested using e.g.:
fio --ioengine=io_uring --cmdprio_percentage=10 --cmdprio_hint=DLD_index

A simple way to test is to use a DLD with a very short duration limit,
and send large reads. Regardless of the CDL policy, in case of a CDL
timeout, the I/O will result in a -ETIME error to user-space.

We also provide a CDL test suite located in the cdl-tools repo, see:
https://github.com/westerndigitalcorporation/cdl-tools#testing-a-system-command-duration-limits-support

We have tested this patch series using:
-real hardware
-the following QEMU implementation:
https://github.com/floatious/qemu/tree/cdl
(NOTE: the QEMU implementation requires you to define the CDL policy at compile
time, so you currently need to recompile QEMU when switching between policies.)

===================
Further information
===================
For further information about CDL, see Damien's slides:

Presented at SDC 2021:
https://www.snia.org/sites/default/files/SDC/2021/pdfs/SNIA-SDC21-LeMoal-Be-On-Time-command-duration-limits-Feature-Support-in%20Linux.pdf

Presented at Lund Linux Con 2022:
https://drive.google.com/file/d/1I6ChFc0h4JY9qZdO1bY5oCAdYCSZVqWw/view?usp=sharing

================
Changes since V6
================
-Rebased series on v6.4-rc1.
-Picked up Reviewed-by tags from Hannes (Thank you Hannes!)
-Picked up Reviewed-by tag from Christoph (Thank you Christoph!)
-Changed KernelVersion from 6.4 to 6.5 for new sysfs attributes.

For older change logs, see previous patch series versions:
https://lore.kernel.org/linux-scsi/20230406113252.41211-1-nks@flawful.org/
https://lore.kernel.org/linux-scsi/20230404182428.715140-1-nks@flawful.org/
https://lore.kernel.org/linux-scsi/20230309215516.3800571-1-niklas.cassel@wdc.com/
https://lore.kernel.org/linux-scsi/20230124190308.127318-1-niklas.cassel@wdc.com/
https://lore.kernel.org/linux-scsi/20230112140412.667308-1-niklas.cassel@wdc.com/
https://lore.kernel.org/linux-scsi/20221208105947.2399894-1-niklas.cassel@wdc.com/

Link: https://lore.kernel.org/r/20230511011356.227789-1-nks@flawful.orgSigned-off-by: default avatarMartin K. Petersen <martin.petersen@oracle.com>
parents 7907ad74 18bd7718
...@@ -95,3 +95,25 @@ Description: ...@@ -95,3 +95,25 @@ Description:
This file does not exist if the HBA driver does not implement This file does not exist if the HBA driver does not implement
support for the SATA NCQ priority feature, regardless of the support for the SATA NCQ priority feature, regardless of the
device support for this feature. device support for this feature.
What: /sys/block/*/device/cdl_supported
Date: May, 2023
KernelVersion: v6.5
Contact: linux-scsi@vger.kernel.org
Description:
(RO) Indicates if the device supports the command duration
limits feature found in some ATA and SCSI devices.
What: /sys/block/*/device/cdl_enable
Date: May, 2023
KernelVersion: v6.5
Contact: linux-scsi@vger.kernel.org
Description:
(RW) For a device supporting the command duration limits
feature, write to the file to turn on or off the feature.
By default this feature is turned off.
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.
...@@ -5524,16 +5524,16 @@ bfq_set_next_ioprio_data(struct bfq_queue *bfqq, struct bfq_io_cq *bic) ...@@ -5524,16 +5524,16 @@ bfq_set_next_ioprio_data(struct bfq_queue *bfqq, struct bfq_io_cq *bic)
bfqq->new_ioprio_class = task_nice_ioclass(tsk); bfqq->new_ioprio_class = task_nice_ioclass(tsk);
break; break;
case IOPRIO_CLASS_RT: case IOPRIO_CLASS_RT:
bfqq->new_ioprio = IOPRIO_PRIO_DATA(bic->ioprio); bfqq->new_ioprio = IOPRIO_PRIO_LEVEL(bic->ioprio);
bfqq->new_ioprio_class = IOPRIO_CLASS_RT; bfqq->new_ioprio_class = IOPRIO_CLASS_RT;
break; break;
case IOPRIO_CLASS_BE: case IOPRIO_CLASS_BE:
bfqq->new_ioprio = IOPRIO_PRIO_DATA(bic->ioprio); bfqq->new_ioprio = IOPRIO_PRIO_LEVEL(bic->ioprio);
bfqq->new_ioprio_class = IOPRIO_CLASS_BE; bfqq->new_ioprio_class = IOPRIO_CLASS_BE;
break; break;
case IOPRIO_CLASS_IDLE: case IOPRIO_CLASS_IDLE:
bfqq->new_ioprio_class = IOPRIO_CLASS_IDLE; bfqq->new_ioprio_class = IOPRIO_CLASS_IDLE;
bfqq->new_ioprio = 7; bfqq->new_ioprio = IOPRIO_NR_LEVELS - 1;
break; break;
} }
...@@ -5830,7 +5830,7 @@ static struct bfq_queue *bfq_get_queue(struct bfq_data *bfqd, ...@@ -5830,7 +5830,7 @@ static struct bfq_queue *bfq_get_queue(struct bfq_data *bfqd,
struct bfq_io_cq *bic, struct bfq_io_cq *bic,
bool respawn) bool respawn)
{ {
const int ioprio = IOPRIO_PRIO_DATA(bic->ioprio); const int ioprio = IOPRIO_PRIO_LEVEL(bic->ioprio);
const int ioprio_class = IOPRIO_PRIO_CLASS(bic->ioprio); const int ioprio_class = IOPRIO_PRIO_CLASS(bic->ioprio);
struct bfq_queue **async_bfqq = NULL; struct bfq_queue **async_bfqq = NULL;
struct bfq_queue *bfqq; struct bfq_queue *bfqq;
......
...@@ -170,6 +170,9 @@ static const struct { ...@@ -170,6 +170,9 @@ static const struct {
[BLK_STS_ZONE_OPEN_RESOURCE] = { -ETOOMANYREFS, "open zones exceeded" }, [BLK_STS_ZONE_OPEN_RESOURCE] = { -ETOOMANYREFS, "open zones exceeded" },
[BLK_STS_ZONE_ACTIVE_RESOURCE] = { -EOVERFLOW, "active 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: */ /* everything else not covered above: */
[BLK_STS_IOERR] = { -EIO, "I/O" }, [BLK_STS_IOERR] = { -EIO, "I/O" },
}; };
......
...@@ -33,7 +33,7 @@ ...@@ -33,7 +33,7 @@
int ioprio_check_cap(int ioprio) int ioprio_check_cap(int ioprio)
{ {
int class = IOPRIO_PRIO_CLASS(ioprio); int class = IOPRIO_PRIO_CLASS(ioprio);
int data = IOPRIO_PRIO_DATA(ioprio); int level = IOPRIO_PRIO_LEVEL(ioprio);
switch (class) { switch (class) {
case IOPRIO_CLASS_RT: case IOPRIO_CLASS_RT:
...@@ -49,13 +49,13 @@ int ioprio_check_cap(int ioprio) ...@@ -49,13 +49,13 @@ int ioprio_check_cap(int ioprio)
fallthrough; fallthrough;
/* rt has prio field too */ /* rt has prio field too */
case IOPRIO_CLASS_BE: case IOPRIO_CLASS_BE:
if (data >= IOPRIO_NR_LEVELS || data < 0) if (level >= IOPRIO_NR_LEVELS)
return -EINVAL; return -EINVAL;
break; break;
case IOPRIO_CLASS_IDLE: case IOPRIO_CLASS_IDLE:
break; break;
case IOPRIO_CLASS_NONE: case IOPRIO_CLASS_NONE:
if (data) if (level)
return -EINVAL; return -EINVAL;
break; break;
default: default:
......
...@@ -665,12 +665,33 @@ u64 ata_tf_read_block(const struct ata_taskfile *tf, struct ata_device *dev) ...@@ -665,12 +665,33 @@ u64 ata_tf_read_block(const struct ata_taskfile *tf, struct ata_device *dev)
return block; return block;
} }
/*
* Set a taskfile command duration limit index.
*/
static inline void ata_set_tf_cdl(struct ata_queued_cmd *qc, int cdl)
{
struct ata_taskfile *tf = &qc->tf;
if (tf->protocol == ATA_PROT_NCQ)
tf->auxiliary |= cdl;
else
tf->feature |= 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;
}
/** /**
* ata_build_rw_tf - Build ATA taskfile for given read/write request * ata_build_rw_tf - Build ATA taskfile for given read/write request
* @qc: Metadata associated with the taskfile to build * @qc: Metadata associated with the taskfile to build
* @block: Block address * @block: Block address
* @n_block: Number of blocks * @n_block: Number of blocks
* @tf_flags: RW/FUA etc... * @tf_flags: RW/FUA etc...
* @cdl: Command duration limit index
* @class: IO priority class * @class: IO priority class
* *
* LOCKING: * LOCKING:
...@@ -685,7 +706,7 @@ u64 ata_tf_read_block(const struct ata_taskfile *tf, struct ata_device *dev) ...@@ -685,7 +706,7 @@ u64 ata_tf_read_block(const struct ata_taskfile *tf, struct ata_device *dev)
* -EINVAL if the request is invalid. * -EINVAL if the request is invalid.
*/ */
int ata_build_rw_tf(struct ata_queued_cmd *qc, u64 block, u32 n_block, 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 cdl, int class)
{ {
struct ata_taskfile *tf = &qc->tf; struct ata_taskfile *tf = &qc->tf;
struct ata_device *dev = qc->dev; struct ata_device *dev = qc->dev;
...@@ -724,11 +745,20 @@ int ata_build_rw_tf(struct ata_queued_cmd *qc, u64 block, u32 n_block, ...@@ -724,11 +745,20 @@ int ata_build_rw_tf(struct ata_queued_cmd *qc, u64 block, u32 n_block,
if (dev->flags & ATA_DFLAG_NCQ_PRIO_ENABLED && if (dev->flags & ATA_DFLAG_NCQ_PRIO_ENABLED &&
class == IOPRIO_CLASS_RT) class == IOPRIO_CLASS_RT)
tf->hob_nsect |= ATA_PRIO_HIGH << ATA_SHIFT_PRIO; tf->hob_nsect |= ATA_PRIO_HIGH << ATA_SHIFT_PRIO;
if ((dev->flags & ATA_DFLAG_CDL_ENABLED) && cdl)
ata_set_tf_cdl(qc, cdl);
} else if (dev->flags & ATA_DFLAG_LBA) { } else if (dev->flags & ATA_DFLAG_LBA) {
tf->flags |= ATA_TFLAG_LBA; tf->flags |= ATA_TFLAG_LBA;
/* We need LBA48 for FUA writes */ if ((dev->flags & ATA_DFLAG_CDL_ENABLED) && cdl)
if (!(tf->flags & ATA_TFLAG_FUA) && lba_28_ok(block, n_block)) { ata_set_tf_cdl(qc, cdl);
/* 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 */ /* use LBA28 */
tf->device |= (block >> 24) & 0xf; tf->device |= (block >> 24) & 0xf;
} else if (lba_48_ok(block, n_block)) { } else if (lba_48_ok(block, n_block)) {
...@@ -2367,6 +2397,139 @@ static void ata_dev_config_trusted(struct ata_device *dev) ...@@ -2367,6 +2397,139 @@ static void ata_dev_config_trusted(struct ata_device *dev)
dev->flags |= ATA_DFLAG_TRUSTED; 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;
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_CURRENT_SETTINGS))
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");
/*
* 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.
*/
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;
}
}
}
/*
* 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).
*/
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 | ATA_DFLAG_CDL_ENABLED);
kfree(ap->ncq_sense_buf);
ap->ncq_sense_buf = NULL;
}
static int ata_dev_config_lba(struct ata_device *dev) static int ata_dev_config_lba(struct ata_device *dev)
{ {
const u16 *id = dev->id; const u16 *id = dev->id;
...@@ -2534,13 +2697,14 @@ static void ata_dev_print_features(struct ata_device *dev) ...@@ -2534,13 +2697,14 @@ static void ata_dev_print_features(struct ata_device *dev)
return; return;
ata_dev_info(dev, 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_FUA ? " FUA" : "",
dev->flags & ATA_DFLAG_TRUSTED ? " Trust" : "", dev->flags & ATA_DFLAG_TRUSTED ? " Trust" : "",
dev->flags & ATA_DFLAG_DA ? " Dev-Attention" : "", dev->flags & ATA_DFLAG_DA ? " Dev-Attention" : "",
dev->flags & ATA_DFLAG_DEVSLP ? " Dev-Sleep" : "", dev->flags & ATA_DFLAG_DEVSLP ? " Dev-Sleep" : "",
dev->flags & ATA_DFLAG_NCQ_SEND_RECV ? " NCQ-sndrcv" : "", dev->flags & ATA_DFLAG_NCQ_SEND_RECV ? " NCQ-sndrcv" : "",
dev->flags & ATA_DFLAG_NCQ_PRIO ? " NCQ-prio" : "", dev->flags & ATA_DFLAG_NCQ_PRIO ? " NCQ-prio" : "",
dev->flags & ATA_DFLAG_CDL ? " CDL" : "",
dev->cpr_log ? " CPR" : ""); dev->cpr_log ? " CPR" : "");
} }
...@@ -2702,6 +2866,7 @@ int ata_dev_configure(struct ata_device *dev) ...@@ -2702,6 +2866,7 @@ int ata_dev_configure(struct ata_device *dev)
ata_dev_config_zac(dev); ata_dev_config_zac(dev);
ata_dev_config_trusted(dev); ata_dev_config_trusted(dev);
ata_dev_config_cpr(dev); ata_dev_config_cpr(dev);
ata_dev_config_cdl(dev);
dev->cdb_len = 32; dev->cdb_len = 32;
if (print_info) if (print_info)
...@@ -4766,6 +4931,36 @@ void ata_qc_complete(struct ata_queued_cmd *qc) ...@@ -4766,6 +4931,36 @@ void ata_qc_complete(struct ata_queued_cmd *qc)
fill_result_tf(qc); fill_result_tf(qc);
trace_ata_qc_complete_done(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 /* Some commands need post-processing after successful
* completion. * completion.
*/ */
...@@ -5398,6 +5593,7 @@ static void ata_host_release(struct kref *kref) ...@@ -5398,6 +5593,7 @@ static void ata_host_release(struct kref *kref)
kfree(ap->pmp_link); kfree(ap->pmp_link);
kfree(ap->slave_link); kfree(ap->slave_link);
kfree(ap->ncq_sense_buf);
kfree(ap); kfree(ap);
host->ports[i] = NULL; host->ports[i] = NULL;
} }
......
...@@ -1401,8 +1401,11 @@ unsigned int atapi_eh_tur(struct ata_device *dev, u8 *r_sense_key) ...@@ -1401,8 +1401,11 @@ unsigned int atapi_eh_tur(struct ata_device *dev, u8 *r_sense_key)
* *
* LOCKING: * LOCKING:
* Kernel thread context (may sleep). * 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 scsi_cmnd *cmd = qc->scsicmd;
struct ata_device *dev = qc->dev; struct ata_device *dev = qc->dev;
...@@ -1411,15 +1414,12 @@ static void ata_eh_request_sense(struct ata_queued_cmd *qc) ...@@ -1411,15 +1414,12 @@ static void ata_eh_request_sense(struct ata_queued_cmd *qc)
if (ata_port_is_frozen(qc->ap)) { if (ata_port_is_frozen(qc->ap)) {
ata_dev_warn(dev, "sense data available but port frozen\n"); 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)) { if (!ata_id_sense_reporting_enabled(dev->id)) {
ata_dev_warn(qc->dev, "sense data reporting disabled\n"); ata_dev_warn(qc->dev, "sense data reporting disabled\n");
return; return false;
} }
ata_tf_init(dev, &tf); ata_tf_init(dev, &tf);
...@@ -1432,13 +1432,19 @@ static void ata_eh_request_sense(struct ata_queued_cmd *qc) ...@@ -1432,13 +1432,19 @@ static void ata_eh_request_sense(struct ata_queued_cmd *qc)
/* Ignore err_mask; ATA_ERR might be set */ /* Ignore err_mask; ATA_ERR might be set */
if (tf.status & ATA_SENSE) { if (tf.status & ATA_SENSE) {
if (ata_scsi_sense_is_valid(tf.lbah, tf.lbam, tf.lbal)) { 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; qc->flags |= ATA_QCFLAG_SENSE_VALID;
return true;
} }
} else { } else {
ata_dev_warn(dev, "request sense failed stat %02x emask %x\n", ata_dev_warn(dev, "request sense failed stat %02x emask %x\n",
tf.status, err_mask); tf.status, err_mask);
} }
return false;
} }
/** /**
...@@ -1588,8 +1594,9 @@ static unsigned int ata_eh_analyze_tf(struct ata_queued_cmd *qc) ...@@ -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 * was not included in the NCQ command error log
* (i.e. NCQ autosense is not supported by the device). * (i.e. NCQ autosense is not supported by the device).
*/ */
if (!(qc->flags & ATA_QCFLAG_SENSE_VALID) && (stat & ATA_SENSE)) if (!(qc->flags & ATA_QCFLAG_SENSE_VALID) &&
ata_eh_request_sense(qc); (stat & ATA_SENSE) && ata_eh_request_sense(qc))
set_status_byte(qc->scsicmd, SAM_STAT_CHECK_CONDITION);
if (err & ATA_ICRC) if (err & ATA_ICRC)
qc->err_mask |= AC_ERR_ATA_BUS; qc->err_mask |= AC_ERR_ATA_BUS;
if (err & (ATA_UNC | ATA_AMNF)) if (err & (ATA_UNC | ATA_AMNF))
...@@ -1910,6 +1917,99 @@ static inline bool ata_eh_quiet(struct ata_queued_cmd *qc) ...@@ -1910,6 +1917,99 @@ static inline bool ata_eh_quiet(struct ata_queued_cmd *qc)
return qc->flags & ATA_QCFLAG_QUIET; 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 * ata_eh_link_autopsy - analyze error and determine recovery action
* @link: host link to perform autopsy on * @link: host link to perform autopsy on
...@@ -1950,6 +2050,14 @@ static void ata_eh_link_autopsy(struct ata_link *link) ...@@ -1950,6 +2050,14 @@ static void ata_eh_link_autopsy(struct ata_link *link)
/* analyze NCQ failure */ /* analyze NCQ failure */
ata_eh_analyze_ncq_error(link); 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 */ /* any real error trumps AC_ERR_OTHER */
if (ehc->i.err_mask & ~AC_ERR_OTHER) if (ehc->i.err_mask & ~AC_ERR_OTHER)
ehc->i.err_mask &= ~AC_ERR_OTHER; ehc->i.err_mask &= ~AC_ERR_OTHER;
...@@ -1959,6 +2067,7 @@ static void ata_eh_link_autopsy(struct ata_link *link) ...@@ -1959,6 +2067,7 @@ static void ata_eh_link_autopsy(struct ata_link *link)
ata_qc_for_each_raw(ap, qc, tag) { ata_qc_for_each_raw(ap, qc, tag) {
if (!(qc->flags & ATA_QCFLAG_EH) || if (!(qc->flags & ATA_QCFLAG_EH) ||
qc->flags & ATA_QCFLAG_RETRY || qc->flags & ATA_QCFLAG_RETRY ||
qc->flags & ATA_QCFLAG_EH_SUCCESS_CMD ||
ata_dev_phys_link(qc->dev) != link) ata_dev_phys_link(qc->dev) != link)
continue; continue;
...@@ -3818,7 +3927,8 @@ void ata_eh_finish(struct ata_port *ap) ...@@ -3818,7 +3927,8 @@ void ata_eh_finish(struct ata_port *ap)
else else
ata_eh_qc_complete(qc); ata_eh_qc_complete(qc);
} else { } 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); ata_eh_qc_complete(qc);
} else { } else {
/* feed zero TF to sense generation */ /* feed zero TF to sense generation */
......
...@@ -11,7 +11,9 @@ ...@@ -11,7 +11,9 @@
#include <linux/module.h> #include <linux/module.h>
#include <scsi/scsi_cmnd.h> #include <scsi/scsi_cmnd.h>
#include <scsi/scsi_device.h> #include <scsi/scsi_device.h>
#include <scsi/scsi_eh.h>
#include <linux/libata.h> #include <linux/libata.h>
#include <asm/unaligned.h>
#include "libata.h" #include "libata.h"
#include "libata-transport.h" #include "libata-transport.h"
...@@ -907,10 +909,17 @@ static ssize_t ata_ncq_prio_enable_store(struct device *device, ...@@ -907,10 +909,17 @@ static ssize_t ata_ncq_prio_enable_store(struct device *device,
goto unlock; 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; dev->flags |= ATA_DFLAG_NCQ_PRIO_ENABLED;
else } else {
dev->flags &= ~ATA_DFLAG_NCQ_PRIO_ENABLED; dev->flags &= ~ATA_DFLAG_NCQ_PRIO_ENABLED;
}
unlock: unlock:
spin_unlock_irq(ap->lock); spin_unlock_irq(ap->lock);
...@@ -1401,6 +1410,95 @@ static int ata_eh_read_log_10h(struct ata_device *dev, ...@@ -1401,6 +1410,95 @@ static int ata_eh_read_log_10h(struct ata_device *dev,
return 0; 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 * ata_eh_analyze_ncq_error - analyze NCQ error
* @link: ATA link to analyze NCQ error for * @link: ATA link to analyze NCQ error for
...@@ -1481,6 +1579,7 @@ void ata_eh_analyze_ncq_error(struct ata_link *link) ...@@ -1481,6 +1579,7 @@ void ata_eh_analyze_ncq_error(struct ata_link *link)
ata_qc_for_each_raw(ap, qc, tag) { ata_qc_for_each_raw(ap, qc, tag) {
if (!(qc->flags & ATA_QCFLAG_EH) || if (!(qc->flags & ATA_QCFLAG_EH) ||
qc->flags & ATA_QCFLAG_EH_SUCCESS_CMD ||
ata_dev_phys_link(qc->dev) != link) ata_dev_phys_link(qc->dev) != link)
continue; continue;
......
This diff is collapsed.
...@@ -45,7 +45,7 @@ static inline void ata_force_cbl(struct ata_port *ap) { } ...@@ -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_lba(const struct ata_taskfile *tf);
extern u64 ata_tf_to_lba48(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, 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 dld, int class);
extern u64 ata_tf_read_block(const struct ata_taskfile *tf, extern u64 ata_tf_read_block(const struct ata_taskfile *tf,
struct ata_device *dev); struct ata_device *dev);
extern unsigned ata_exec_internal(struct ata_device *dev, extern unsigned ata_exec_internal(struct ata_device *dev,
......
...@@ -504,18 +504,22 @@ void scsi_attach_vpd(struct scsi_device *sdev) ...@@ -504,18 +504,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 * @sdev: scsi device to query
* @buffer: scratch buffer (must be at least 20 bytes long) * @buffer: scratch buffer (must be at least 20 bytes long)
* @len: length of buffer * @len: length of buffer
* @opcode: opcode for command to look up * @opcode: opcode for the command to look up
* * @sa: service action for the 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 * Uses the REPORT SUPPORTED OPERATION CODES to check support for the
* unsupported and 1 if the device claims to support the command. * 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, 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]; unsigned char cmd[16];
struct scsi_sense_hdr sshdr; struct scsi_sense_hdr sshdr;
...@@ -539,8 +543,14 @@ int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer, ...@@ -539,8 +543,14 @@ int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
memset(cmd, 0, 16); memset(cmd, 0, 16);
cmd[0] = MAINTENANCE_IN; cmd[0] = MAINTENANCE_IN;
cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES; cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES;
if (!sa) {
cmd[2] = 1; /* One command format */ cmd[2] = 1; /* One command format */
cmd[3] = opcode; 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]); put_unaligned_be32(request_len, &cmd[6]);
memset(buffer, 0, len); memset(buffer, 0, len);
...@@ -560,6 +570,149 @@ int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer, ...@@ -560,6 +570,149 @@ int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
} }
EXPORT_SYMBOL(scsi_report_opcode); EXPORT_SYMBOL(scsi_report_opcode);
#define SCSI_CDL_CHECK_BUF_LEN 64
static bool scsi_cdl_check_cmd(struct scsi_device *sdev, u8 opcode, u16 sa,
unsigned char *buf)
{
int ret;
u8 cdlp;
/* Check operation code */
ret = scsi_report_opcode(sdev, buf, SCSI_CDL_CHECK_BUF_LEN, opcode, sa);
if (ret <= 0)
return false;
if ((buf[1] & 0x03) != 0x03)
return false;
/* 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:
/* T2A page */
return true;
case 0x02:
/* T2B page */
return true;
}
} else {
/* rwcdlp == 0 */
switch (cdlp) {
case 0x01:
/* A page */
return true;
case 0x02:
/* B page */
return true;
}
}
return false;
}
/**
* scsi_cdl_check - Check if a SCSI device supports Command Duration Limits
* @sdev: The device to check
*/
void scsi_cdl_check(struct scsi_device *sdev)
{
bool cdl_supported;
unsigned char *buf;
buf = kmalloc(SCSI_CDL_CHECK_BUF_LEN, GFP_KERNEL);
if (!buf) {
sdev->cdl_supported = 0;
return;
}
/* Check support for READ_16, WRITE_16, READ_32 and WRITE_32 commands */
cdl_supported =
scsi_cdl_check_cmd(sdev, READ_16, 0, buf) ||
scsi_cdl_check_cmd(sdev, WRITE_16, 0, buf) ||
scsi_cdl_check_cmd(sdev, VARIABLE_LENGTH_CMD, READ_32, buf) ||
scsi_cdl_check_cmd(sdev, VARIABLE_LENGTH_CMD, WRITE_32, buf);
if (cdl_supported) {
/*
* We have CDL support: force the use of READ16/WRITE16.
* READ32 and WRITE32 will be used for devices that support
* the T10_PI_TYPE2_PROTECTION protection type.
*/
sdev->use_16_for_rw = 1;
sdev->use_10_for_rw = 0;
sdev->cdl_supported = 1;
} else {
sdev->cdl_supported = 0;
}
kfree(buf);
}
/**
* scsi_cdl_enable - Enable or disable a SCSI device supports for Command
* Duration Limits
* @sdev: The target device
* @enable: the target state
*/
int scsi_cdl_enable(struct scsi_device *sdev, bool enable)
{
struct scsi_mode_data data;
struct scsi_sense_hdr sshdr;
struct scsi_vpd *vpd;
bool is_ata = false;
char buf[64];
int ret;
if (!sdev->cdl_supported)
return -EOPNOTSUPP;
rcu_read_lock();
vpd = rcu_dereference(sdev->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(sdev, 0x08, 0x0a, 0xf2, buf, sizeof(buf),
5 * HZ, 3, &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(sdev, 1, 0, buf_data, len, 5 * HZ, 3,
&data, &sshdr);
if (ret) {
if (scsi_sense_valid(&sshdr))
scsi_print_sense_hdr(sdev,
dev_name(&sdev->sdev_gendev), &sshdr);
return ret;
}
}
sdev->cdl_enable = enable;
return 0;
}
/** /**
* scsi_device_get - get an additional reference to a scsi_device * scsi_device_get - get an additional reference to a scsi_device
* @sdev: device to get a reference to * @sdev: device to get a reference to
......
...@@ -536,6 +536,7 @@ static inline void set_scsi_ml_byte(struct scsi_cmnd *cmd, u8 status) ...@@ -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) 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_device *sdev = scmd->device;
struct scsi_sense_hdr sshdr; struct scsi_sense_hdr sshdr;
...@@ -595,6 +596,22 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd) ...@@ -595,6 +596,22 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
if (sshdr.asc == 0x10) /* DIF */ if (sshdr.asc == 0x10) /* DIF */
return SUCCESS; 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) if (sshdr.asc == 0x44 && sdev->sdev_bflags & BLIST_RETRY_ITF)
return ADD_TO_MLQUEUE; return ADD_TO_MLQUEUE;
if (sshdr.asc == 0xc1 && sshdr.ascq == 0x01 && if (sshdr.asc == 0xc1 && sshdr.ascq == 0x01 &&
...@@ -691,6 +708,14 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd) ...@@ -691,6 +708,14 @@ enum scsi_disposition scsi_check_sense(struct scsi_cmnd *scmd)
} }
return SUCCESS; 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;
default: default:
return SUCCESS; return SUCCESS;
} }
...@@ -785,6 +810,14 @@ static enum scsi_disposition scsi_eh_completed_normally(struct scsi_cmnd *scmd) ...@@ -785,6 +810,14 @@ static enum scsi_disposition scsi_eh_completed_normally(struct scsi_cmnd *scmd)
switch (get_status_byte(scmd)) { switch (get_status_byte(scmd)) {
case SAM_STAT_GOOD: case SAM_STAT_GOOD:
scsi_handle_queue_ramp_up(scmd->device); 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; fallthrough;
case SAM_STAT_COMMAND_TERMINATED: case SAM_STAT_COMMAND_TERMINATED:
return SUCCESS; return SUCCESS;
...@@ -1807,6 +1840,10 @@ bool scsi_noretry_cmd(struct scsi_cmnd *scmd) ...@@ -1807,6 +1840,10 @@ bool scsi_noretry_cmd(struct scsi_cmnd *scmd)
return !!(req->cmd_flags & REQ_FAILFAST_DRIVER); 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)) if (!scsi_status_is_check_condition(scmd->result))
return false; return false;
...@@ -1966,6 +2003,14 @@ enum scsi_disposition scsi_decide_disposition(struct scsi_cmnd *scmd) ...@@ -1966,6 +2003,14 @@ enum scsi_disposition scsi_decide_disposition(struct scsi_cmnd *scmd)
if (scmd->cmnd[0] == REPORT_LUNS) if (scmd->cmnd[0] == REPORT_LUNS)
scmd->device->sdev_target->expecting_lun_change = 0; scmd->device->sdev_target->expecting_lun_change = 0;
scsi_handle_queue_ramp_up(scmd->device); 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; fallthrough;
case SAM_STAT_COMMAND_TERMINATED: case SAM_STAT_COMMAND_TERMINATED:
return SUCCESS; return SUCCESS;
...@@ -2165,7 +2210,8 @@ void scsi_eh_flush_done_q(struct list_head *done_q) ...@@ -2165,7 +2210,8 @@ void scsi_eh_flush_done_q(struct list_head *done_q)
* scsi_eh_get_sense), scmd->result is already * scsi_eh_get_sense), scmd->result is already
* set, do not set DID_TIME_OUT. * 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); scmd->result |= (DID_TIME_OUT << 16);
SCSI_LOG_ERROR_RECOVERY(3, SCSI_LOG_ERROR_RECOVERY(3,
scmd_printk(KERN_INFO, scmd, scmd_printk(KERN_INFO, scmd,
......
...@@ -578,11 +578,6 @@ static bool scsi_end_request(struct request *req, blk_status_t error, ...@@ -578,11 +578,6 @@ static bool scsi_end_request(struct request *req, blk_status_t error,
return false; 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 * scsi_result_to_blk_status - translate a SCSI result code into blk_status_t
* @result: scsi error code * @result: scsi error code
...@@ -595,7 +590,7 @@ static blk_status_t scsi_result_to_blk_status(int result) ...@@ -595,7 +590,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 * Check the scsi-ml byte first in case we converted a host or status
* byte. * byte.
*/ */
switch (get_scsi_ml_byte(result)) { switch (scsi_ml_byte(result)) {
case SCSIML_STAT_OK: case SCSIML_STAT_OK:
break; break;
case SCSIML_STAT_RESV_CONFLICT: case SCSIML_STAT_RESV_CONFLICT:
...@@ -606,6 +601,8 @@ static blk_status_t scsi_result_to_blk_status(int result) ...@@ -606,6 +601,8 @@ static blk_status_t scsi_result_to_blk_status(int result)
return BLK_STS_MEDIUM; return BLK_STS_MEDIUM;
case SCSIML_STAT_TGT_FAILURE: case SCSIML_STAT_TGT_FAILURE:
return BLK_STS_TARGET; return BLK_STS_TARGET;
case SCSIML_STAT_DL_TIMEOUT:
return BLK_STS_DURATION_LIMIT;
} }
switch (host_byte(result)) { switch (host_byte(result)) {
...@@ -803,6 +800,8 @@ static void scsi_io_completion_action(struct scsi_cmnd *cmd, int result) ...@@ -803,6 +800,8 @@ static void scsi_io_completion_action(struct scsi_cmnd *cmd, int result)
blk_stat = BLK_STS_ZONE_OPEN_RESOURCE; blk_stat = BLK_STS_ZONE_OPEN_RESOURCE;
} }
break; break;
case COMPLETED:
fallthrough;
default: default:
action = ACTION_FAIL; action = ACTION_FAIL;
break; break;
...@@ -2149,6 +2148,7 @@ EXPORT_SYMBOL_GPL(scsi_mode_select); ...@@ -2149,6 +2148,7 @@ EXPORT_SYMBOL_GPL(scsi_mode_select);
* @sdev: SCSI device to be queried * @sdev: SCSI device to be queried
* @dbd: set to prevent mode sense from returning block descriptors * @dbd: set to prevent mode sense from returning block descriptors
* @modepage: mode page being requested * @modepage: mode page being requested
* @subpage: sub-page of the mode page being requested
* @buffer: request buffer (may not be smaller than eight bytes) * @buffer: request buffer (may not be smaller than eight bytes)
* @len: length of request buffer. * @len: length of request buffer.
* @timeout: command timeout * @timeout: command timeout
...@@ -2160,7 +2160,7 @@ EXPORT_SYMBOL_GPL(scsi_mode_select); ...@@ -2160,7 +2160,7 @@ EXPORT_SYMBOL_GPL(scsi_mode_select);
* Returns zero if successful, or a negative error number on failure * Returns zero if successful, or a negative error number on failure
*/ */
int 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, unsigned char *buffer, int len, int timeout, int retries,
struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr) struct scsi_mode_data *data, struct scsi_sense_hdr *sshdr)
{ {
...@@ -2180,6 +2180,7 @@ scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, ...@@ -2180,6 +2180,7 @@ scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,
dbd = sdev->set_dbd_for_ms ? 8 : dbd; dbd = sdev->set_dbd_for_ms ? 8 : dbd;
cmd[1] = dbd & 0x18; /* allows DBD and LLBA bits */ cmd[1] = dbd & 0x18; /* allows DBD and LLBA bits */
cmd[2] = modepage; cmd[2] = modepage;
cmd[3] = subpage;
sshdr = exec_args.sshdr; sshdr = exec_args.sshdr;
......
...@@ -27,8 +27,14 @@ enum scsi_ml_status { ...@@ -27,8 +27,14 @@ enum scsi_ml_status {
SCSIML_STAT_NOSPC = 0x02, /* Space allocation on the dev failed */ SCSIML_STAT_NOSPC = 0x02, /* Space allocation on the dev failed */
SCSIML_STAT_MED_ERROR = 0x03, /* Medium error */ SCSIML_STAT_MED_ERROR = 0x03, /* Medium error */
SCSIML_STAT_TGT_FAILURE = 0x04, /* Permanent target failure */ 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)
{
return (result >> 8) & 0xff;
}
/* /*
* Scsi Error Handler Flags * Scsi Error Handler Flags
*/ */
......
...@@ -1087,6 +1087,8 @@ static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result, ...@@ -1087,6 +1087,8 @@ static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,
if (sdev->scsi_level >= SCSI_3) if (sdev->scsi_level >= SCSI_3)
scsi_attach_vpd(sdev); scsi_attach_vpd(sdev);
scsi_cdl_check(sdev);
sdev->max_queue_depth = sdev->queue_depth; sdev->max_queue_depth = sdev->queue_depth;
WARN_ON_ONCE(sdev->max_queue_depth > sdev->budget_map.depth); WARN_ON_ONCE(sdev->max_queue_depth > sdev->budget_map.depth);
sdev->sdev_bflags = *bflags; sdev->sdev_bflags = *bflags;
...@@ -1624,6 +1626,7 @@ void scsi_rescan_device(struct device *dev) ...@@ -1624,6 +1626,7 @@ void scsi_rescan_device(struct device *dev)
device_lock(dev); device_lock(dev);
scsi_attach_vpd(sdev); scsi_attach_vpd(sdev);
scsi_cdl_check(sdev);
if (sdev->handler && sdev->handler->rescan) if (sdev->handler && sdev->handler->rescan)
sdev->handler->rescan(sdev); sdev->handler->rescan(sdev);
......
...@@ -670,6 +670,7 @@ sdev_rd_attr (scsi_level, "%d\n"); ...@@ -670,6 +670,7 @@ sdev_rd_attr (scsi_level, "%d\n");
sdev_rd_attr (vendor, "%.8s\n"); sdev_rd_attr (vendor, "%.8s\n");
sdev_rd_attr (model, "%.16s\n"); sdev_rd_attr (model, "%.16s\n");
sdev_rd_attr (rev, "%.4s\n"); sdev_rd_attr (rev, "%.4s\n");
sdev_rd_attr (cdl_supported, "%d\n");
static ssize_t static ssize_t
sdev_show_device_busy(struct device *dev, struct device_attribute *attr, sdev_show_device_busy(struct device *dev, struct device_attribute *attr,
...@@ -1221,6 +1222,33 @@ static DEVICE_ATTR(queue_ramp_up_period, S_IRUGO | S_IWUSR, ...@@ -1221,6 +1222,33 @@ static DEVICE_ATTR(queue_ramp_up_period, S_IRUGO | S_IWUSR,
sdev_show_queue_ramp_up_period, sdev_show_queue_ramp_up_period,
sdev_store_queue_ramp_up_period); sdev_store_queue_ramp_up_period);
static ssize_t sdev_show_cdl_enable(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct scsi_device *sdev = to_scsi_device(dev);
return sysfs_emit(buf, "%d\n", (int)sdev->cdl_enable);
}
static ssize_t sdev_store_cdl_enable(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
int ret;
bool v;
if (kstrtobool(buf, &v))
return -EINVAL;
ret = scsi_cdl_enable(to_scsi_device(dev), v);
if (ret)
return ret;
return count;
}
static DEVICE_ATTR(cdl_enable, S_IRUGO | S_IWUSR,
sdev_show_cdl_enable, sdev_store_cdl_enable);
static umode_t scsi_sdev_attr_is_visible(struct kobject *kobj, static umode_t scsi_sdev_attr_is_visible(struct kobject *kobj,
struct attribute *attr, int i) struct attribute *attr, int i)
{ {
...@@ -1300,6 +1328,8 @@ static struct attribute *scsi_sdev_attrs[] = { ...@@ -1300,6 +1328,8 @@ static struct attribute *scsi_sdev_attrs[] = {
&dev_attr_preferred_path.attr, &dev_attr_preferred_path.attr,
#endif #endif
&dev_attr_queue_ramp_up_period.attr, &dev_attr_queue_ramp_up_period.attr,
&dev_attr_cdl_supported.attr,
&dev_attr_cdl_enable.attr,
REF_EVT(media_change), REF_EVT(media_change),
REF_EVT(inquiry_change_reported), REF_EVT(inquiry_change_reported),
REF_EVT(capacity_change_reported), REF_EVT(capacity_change_reported),
......
...@@ -1245,7 +1245,7 @@ int sas_read_port_mode_page(struct scsi_device *sdev) ...@@ -1245,7 +1245,7 @@ int sas_read_port_mode_page(struct scsi_device *sdev)
if (!buffer) if (!buffer)
return -ENOMEM; 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); &mode_data, NULL);
if (error) if (error)
......
...@@ -184,7 +184,7 @@ cache_type_store(struct device *dev, struct device_attribute *attr, ...@@ -184,7 +184,7 @@ cache_type_store(struct device *dev, struct device_attribute *attr,
return count; 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)) sdkp->max_retries, &data, NULL))
return -EINVAL; return -EINVAL;
len = min_t(size_t, sizeof(buffer), data.length - data.header_length - len = min_t(size_t, sizeof(buffer), data.length - data.header_length -
...@@ -1042,13 +1042,14 @@ static blk_status_t sd_setup_flush_cmnd(struct scsi_cmnd *cmd) ...@@ -1042,13 +1042,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, static blk_status_t sd_setup_rw32_cmnd(struct scsi_cmnd *cmd, bool write,
sector_t lba, unsigned int nr_blocks, sector_t lba, unsigned int nr_blocks,
unsigned char flags) unsigned char flags, unsigned int dld)
{ {
cmd->cmd_len = SD_EXT_CDB_SIZE; cmd->cmd_len = SD_EXT_CDB_SIZE;
cmd->cmnd[0] = VARIABLE_LENGTH_CMD; cmd->cmnd[0] = VARIABLE_LENGTH_CMD;
cmd->cmnd[7] = 0x18; /* Additional CDB len */ cmd->cmnd[7] = 0x18; /* Additional CDB len */
cmd->cmnd[9] = write ? WRITE_32 : READ_32; cmd->cmnd[9] = write ? WRITE_32 : READ_32;
cmd->cmnd[10] = flags; cmd->cmnd[10] = flags;
cmd->cmnd[11] = dld & 0x07;
put_unaligned_be64(lba, &cmd->cmnd[12]); put_unaligned_be64(lba, &cmd->cmnd[12]);
put_unaligned_be32(lba, &cmd->cmnd[20]); /* Expected Indirect LBA */ put_unaligned_be32(lba, &cmd->cmnd[20]); /* Expected Indirect LBA */
put_unaligned_be32(nr_blocks, &cmd->cmnd[28]); put_unaligned_be32(nr_blocks, &cmd->cmnd[28]);
...@@ -1058,12 +1059,12 @@ static blk_status_t sd_setup_rw32_cmnd(struct scsi_cmnd *cmd, bool write, ...@@ -1058,12 +1059,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, static blk_status_t sd_setup_rw16_cmnd(struct scsi_cmnd *cmd, bool write,
sector_t lba, unsigned int nr_blocks, sector_t lba, unsigned int nr_blocks,
unsigned char flags) unsigned char flags, unsigned int dld)
{ {
cmd->cmd_len = 16; cmd->cmd_len = 16;
cmd->cmnd[0] = write ? WRITE_16 : READ_16; cmd->cmnd[0] = write ? WRITE_16 : READ_16;
cmd->cmnd[1] = flags; cmd->cmnd[1] = flags | ((dld >> 2) & 0x01);
cmd->cmnd[14] = 0; cmd->cmnd[14] = (dld & 0x03) << 6;
cmd->cmnd[15] = 0; cmd->cmnd[15] = 0;
put_unaligned_be64(lba, &cmd->cmnd[2]); put_unaligned_be64(lba, &cmd->cmnd[2]);
put_unaligned_be32(nr_blocks, &cmd->cmnd[10]); put_unaligned_be32(nr_blocks, &cmd->cmnd[10]);
...@@ -1115,6 +1116,31 @@ static blk_status_t sd_setup_rw6_cmnd(struct scsi_cmnd *cmd, bool write, ...@@ -1115,6 +1116,31 @@ static blk_status_t sd_setup_rw6_cmnd(struct scsi_cmnd *cmd, bool write,
return BLK_STS_OK; return BLK_STS_OK;
} }
/*
* Check if a command has a duration limit set. If it does, and the target
* device supports CDL and the feature is enabled, return the limit
* descriptor index to use. Return 0 (no limit) otherwise.
*/
static int sd_cdl_dld(struct scsi_disk *sdkp, struct scsi_cmnd *scmd)
{
struct scsi_device *sdp = sdkp->device;
int hint;
if (!sdp->cdl_supported || !sdp->cdl_enable)
return 0;
/*
* Use "no limit" if the request ioprio does not specify a duration
* limit hint.
*/
hint = IOPRIO_PRIO_HINT(req_get_ioprio(scsi_cmd_to_rq(scmd)));
if (hint < IOPRIO_HINT_DEV_DURATION_LIMIT_1 ||
hint > IOPRIO_HINT_DEV_DURATION_LIMIT_7)
return 0;
return (hint - IOPRIO_HINT_DEV_DURATION_LIMIT_1) + 1;
}
static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd) static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd)
{ {
struct request *rq = scsi_cmd_to_rq(cmd); struct request *rq = scsi_cmd_to_rq(cmd);
...@@ -1126,6 +1152,7 @@ static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd) ...@@ -1126,6 +1152,7 @@ static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd)
unsigned int mask = logical_to_sectors(sdp, 1) - 1; unsigned int mask = logical_to_sectors(sdp, 1) - 1;
bool write = rq_data_dir(rq) == WRITE; bool write = rq_data_dir(rq) == WRITE;
unsigned char protect, fua; unsigned char protect, fua;
unsigned int dld;
blk_status_t ret; blk_status_t ret;
unsigned int dif; unsigned int dif;
bool dix; bool dix;
...@@ -1175,6 +1202,7 @@ static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd) ...@@ -1175,6 +1202,7 @@ static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd)
fua = rq->cmd_flags & REQ_FUA ? 0x8 : 0; fua = rq->cmd_flags & REQ_FUA ? 0x8 : 0;
dix = scsi_prot_sg_count(cmd); dix = scsi_prot_sg_count(cmd);
dif = scsi_host_dif_capable(cmd->device->host, sdkp->protection_type); dif = scsi_host_dif_capable(cmd->device->host, sdkp->protection_type);
dld = sd_cdl_dld(sdkp, cmd);
if (dif || dix) if (dif || dix)
protect = sd_setup_protect_cmnd(cmd, dix, dif); protect = sd_setup_protect_cmnd(cmd, dix, dif);
...@@ -1183,10 +1211,10 @@ static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd) ...@@ -1183,10 +1211,10 @@ static blk_status_t sd_setup_read_write_cmnd(struct scsi_cmnd *cmd)
if (protect && sdkp->protection_type == T10_PI_TYPE2_PROTECTION) { if (protect && sdkp->protection_type == T10_PI_TYPE2_PROTECTION) {
ret = sd_setup_rw32_cmnd(cmd, write, lba, nr_blocks, 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)) { } else if (sdp->use_16_for_rw || (nr_blocks > 0xffff)) {
ret = sd_setup_rw16_cmnd(cmd, write, lba, nr_blocks, ret = sd_setup_rw16_cmnd(cmd, write, lba, nr_blocks,
protect | fua); protect | fua, dld);
} else if ((nr_blocks > 0xff) || (lba > 0x1fffff) || } else if ((nr_blocks > 0xff) || (lba > 0x1fffff) ||
sdp->use_10_for_rw || protect) { sdp->use_10_for_rw || protect) {
ret = sd_setup_rw10_cmnd(cmd, write, lba, nr_blocks, ret = sd_setup_rw10_cmnd(cmd, write, lba, nr_blocks,
...@@ -2683,9 +2711,8 @@ sd_do_mode_sense(struct scsi_disk *sdkp, int dbd, int modepage, ...@@ -2683,9 +2711,8 @@ sd_do_mode_sense(struct scsi_disk *sdkp, int dbd, int modepage,
if (sdkp->device->use_10_for_ms && len < 8) if (sdkp->device->use_10_for_ms && len < 8)
len = 8; len = 8;
return scsi_mode_sense(sdkp->device, dbd, modepage, buffer, len, return scsi_mode_sense(sdkp->device, dbd, modepage, 0, buffer, len,
SD_TIMEOUT, sdkp->max_retries, data, SD_TIMEOUT, sdkp->max_retries, data, sshdr);
sshdr);
} }
/* /*
...@@ -2942,7 +2969,7 @@ static void sd_read_app_tag_own(struct scsi_disk *sdkp, unsigned char *buffer) ...@@ -2942,7 +2969,7 @@ static void sd_read_app_tag_own(struct scsi_disk *sdkp, unsigned char *buffer)
if (sdkp->protection_type == 0) if (sdkp->protection_type == 0)
return; 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); sdkp->max_retries, &data, &sshdr);
if (res < 0 || !data.header_length || if (res < 0 || !data.header_length ||
...@@ -3131,7 +3158,7 @@ static void sd_read_write_same(struct scsi_disk *sdkp, unsigned char *buffer) ...@@ -3131,7 +3158,7 @@ static void sd_read_write_same(struct scsi_disk *sdkp, unsigned char *buffer)
return; 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; struct scsi_vpd *vpd;
sdev->no_report_opcodes = 1; sdev->no_report_opcodes = 1;
...@@ -3147,10 +3174,10 @@ static void sd_read_write_same(struct scsi_disk *sdkp, unsigned char *buffer) ...@@ -3147,10 +3174,10 @@ static void sd_read_write_same(struct scsi_disk *sdkp, unsigned char *buffer)
rcu_read_unlock(); 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; 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; sdkp->ws10 = 1;
} }
...@@ -3162,9 +3189,9 @@ static void sd_read_security(struct scsi_disk *sdkp, unsigned char *buffer) ...@@ -3162,9 +3189,9 @@ static void sd_read_security(struct scsi_disk *sdkp, unsigned char *buffer)
return; return;
if (scsi_report_opcode(sdev, buffer, SD_BUF_SIZE, 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, scsi_report_opcode(sdev, buffer, SD_BUF_SIZE,
SECURITY_PROTOCOL_OUT) == 1) SECURITY_PROTOCOL_OUT, 0) == 1)
sdkp->security = 1; sdkp->security = 1;
} }
......
...@@ -825,7 +825,7 @@ static int get_capabilities(struct scsi_cd *cd) ...@@ -825,7 +825,7 @@ static int get_capabilities(struct scsi_cd *cd)
scsi_test_unit_ready(cd->device, SR_TIMEOUT, MAX_RETRIES, &sshdr); scsi_test_unit_ready(cd->device, SR_TIMEOUT, MAX_RETRIES, &sshdr);
/* ask for mode page 0x2a */ /* 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); SR_TIMEOUT, 3, &data, NULL);
if (rc < 0 || data.length > ms_len || if (rc < 0 || data.length > ms_len ||
......
...@@ -322,15 +322,21 @@ enum { ...@@ -322,15 +322,21 @@ enum {
ATA_LOG_SATA_NCQ = 0x10, ATA_LOG_SATA_NCQ = 0x10,
ATA_LOG_NCQ_NON_DATA = 0x12, ATA_LOG_NCQ_NON_DATA = 0x12,
ATA_LOG_NCQ_SEND_RECV = 0x13, ATA_LOG_NCQ_SEND_RECV = 0x13,
ATA_LOG_CDL = 0x18,
ATA_LOG_CDL_SIZE = ATA_SECT_SIZE,
ATA_LOG_IDENTIFY_DEVICE = 0x30, 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, ATA_LOG_CONCURRENT_POSITIONING_RANGES = 0x47,
/* Identify device log pages: */ /* Identify device log pages: */
ATA_LOG_SUPPORTED_CAPABILITIES = 0x03,
ATA_LOG_CURRENT_SETTINGS = 0x04,
ATA_LOG_SECURITY = 0x06, ATA_LOG_SECURITY = 0x06,
ATA_LOG_SATA_SETTINGS = 0x08, ATA_LOG_SATA_SETTINGS = 0x08,
ATA_LOG_ZONED_INFORMATION = 0x09, ATA_LOG_ZONED_INFORMATION = 0x09,
/* Identify device SATA settings log:*/ /* Identify device SATA settings log: */
ATA_LOG_DEVSLP_OFFSET = 0x30, ATA_LOG_DEVSLP_OFFSET = 0x30,
ATA_LOG_DEVSLP_SIZE = 0x08, ATA_LOG_DEVSLP_SIZE = 0x08,
ATA_LOG_DEVSLP_MDAT = 0x00, ATA_LOG_DEVSLP_MDAT = 0x00,
...@@ -415,6 +421,8 @@ enum { ...@@ -415,6 +421,8 @@ enum {
SETFEATURES_SATA_ENABLE = 0x10, /* Enable use of SATA feature */ SETFEATURES_SATA_ENABLE = 0x10, /* Enable use of SATA feature */
SETFEATURES_SATA_DISABLE = 0x90, /* Disable 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 */ /* SETFEATURE Sector counts for SATA features */
SATA_FPDMA_OFFSET = 0x01, /* FPDMA non-zero buffer offsets */ SATA_FPDMA_OFFSET = 0x01, /* FPDMA non-zero buffer offsets */
SATA_FPDMA_AA = 0x02, /* FPDMA Setup FIS Auto-Activate */ SATA_FPDMA_AA = 0x02, /* FPDMA Setup FIS Auto-Activate */
...@@ -425,6 +433,7 @@ enum { ...@@ -425,6 +433,7 @@ enum {
SATA_DEVSLP = 0x09, /* Device Sleep */ SATA_DEVSLP = 0x09, /* Device Sleep */
SETFEATURE_SENSE_DATA = 0xC3, /* Sense Data Reporting feature */ 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 */ /* feature values for SET_MAX */
ATA_SET_MAX_ADDR = 0x00, ATA_SET_MAX_ADDR = 0x00,
......
...@@ -171,6 +171,12 @@ typedef u16 blk_short_t; ...@@ -171,6 +171,12 @@ typedef u16 blk_short_t;
*/ */
#define BLK_STS_OFFLINE ((__force blk_status_t)17) #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 * blk_path_error - returns true if error may be path related
* @error: status the request was completed with * @error: status the request was completed with
......
...@@ -94,17 +94,19 @@ enum { ...@@ -94,17 +94,19 @@ enum {
ATA_DFLAG_DMADIR = (1 << 10), /* device requires DMADIR */ ATA_DFLAG_DMADIR = (1 << 10), /* device requires DMADIR */
ATA_DFLAG_NCQ_SEND_RECV = (1 << 11), /* device supports NCQ SEND and RECV */ 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_NCQ_PRIO = (1 << 12), /* device supports NCQ priority */
ATA_DFLAG_CFG_MASK = (1 << 13) - 1, ATA_DFLAG_CDL = (1 << 13), /* supports cmd duration limits */
ATA_DFLAG_CFG_MASK = (1 << 14) - 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_PIO = (1 << 14), /* device limited to PIO mode */
ATA_DFLAG_SLEEPING = (1 << 15), /* device is sleeping */ ATA_DFLAG_NCQ_OFF = (1 << 15), /* device limited to non-NCQ mode */
ATA_DFLAG_DUBIOUS_XFER = (1 << 16), /* data transfer not verified */ ATA_DFLAG_SLEEPING = (1 << 16), /* device is sleeping */
ATA_DFLAG_NO_UNLOAD = (1 << 17), /* device doesn't support unload */ ATA_DFLAG_DUBIOUS_XFER = (1 << 17), /* data transfer not verified */
ATA_DFLAG_UNLOCK_HPA = (1 << 18), /* unlock HPA */ ATA_DFLAG_NO_UNLOAD = (1 << 18), /* device doesn't support unload */
ATA_DFLAG_INIT_MASK = (1 << 19) - 1, ATA_DFLAG_UNLOCK_HPA = (1 << 19), /* unlock HPA */
ATA_DFLAG_INIT_MASK = (1 << 20) - 1,
ATA_DFLAG_NCQ_PRIO_ENABLED = (1 << 19), /* Priority cmds sent to dev */
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_DETACH = (1 << 24),
ATA_DFLAG_DETACHED = (1 << 25), ATA_DFLAG_DETACHED = (1 << 25),
ATA_DFLAG_DA = (1 << 26), /* device supports Device Attention */ ATA_DFLAG_DA = (1 << 26), /* device supports Device Attention */
...@@ -115,7 +117,8 @@ enum { ...@@ -115,7 +117,8 @@ enum {
ATA_DFLAG_FEATURES_MASK = (ATA_DFLAG_TRUSTED | ATA_DFLAG_DA | \ ATA_DFLAG_FEATURES_MASK = (ATA_DFLAG_TRUSTED | ATA_DFLAG_DA | \
ATA_DFLAG_DEVSLP | ATA_DFLAG_NCQ_SEND_RECV | \ 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_UNKNOWN = 0, /* unknown device */
ATA_DEV_ATA = 1, /* ATA device */ ATA_DEV_ATA = 1, /* ATA device */
...@@ -206,10 +209,12 @@ enum { ...@@ -206,10 +209,12 @@ enum {
ATA_QCFLAG_CLEAR_EXCL = (1 << 5), /* clear excl_link on completion */ ATA_QCFLAG_CLEAR_EXCL = (1 << 5), /* clear excl_link on completion */
ATA_QCFLAG_QUIET = (1 << 6), /* don't report device error */ ATA_QCFLAG_QUIET = (1 << 6), /* don't report device error */
ATA_QCFLAG_RETRY = (1 << 7), /* retry after failure */ 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_EH = (1 << 16), /* cmd aborted and owned by EH */
ATA_QCFLAG_SENSE_VALID = (1 << 17), /* sense data valid */ ATA_QCFLAG_SENSE_VALID = (1 << 17), /* sense data valid */
ATA_QCFLAG_EH_SCHEDULED = (1 << 18), /* EH scheduled (obsolete) */ 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 */ /* host set flags */
ATA_HOST_SIMPLEX = (1 << 0), /* Host is simplex, one DMA channel per host only */ ATA_HOST_SIMPLEX = (1 << 0), /* Host is simplex, one DMA channel per host only */
...@@ -308,8 +313,10 @@ enum { ...@@ -308,8 +313,10 @@ enum {
ATA_EH_RESET = ATA_EH_SOFTRESET | ATA_EH_HARDRESET, ATA_EH_RESET = ATA_EH_SOFTRESET | ATA_EH_HARDRESET,
ATA_EH_ENABLE_LINK = (1 << 3), ATA_EH_ENABLE_LINK = (1 << 3),
ATA_EH_PARK = (1 << 5), /* unload heads and stop I/O */ 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_ALL_ACTIONS = ATA_EH_REVALIDATE | ATA_EH_RESET |
ATA_EH_ENABLE_LINK, ATA_EH_ENABLE_LINK,
...@@ -709,6 +716,9 @@ struct ata_device { ...@@ -709,6 +716,9 @@ struct ata_device {
/* Concurrent positioning ranges */ /* Concurrent positioning ranges */
struct ata_cpr_log *cpr_log; struct ata_cpr_log *cpr_log;
/* Command Duration Limits log support */
u8 cdl[ATA_LOG_CDL_SIZE];
/* error history */ /* error history */
int spdn_cnt; int spdn_cnt;
/* ering is CLEAR_END, read comment above CLEAR_END */ /* ering is CLEAR_END, read comment above CLEAR_END */
...@@ -860,6 +870,7 @@ struct ata_port { ...@@ -860,6 +870,7 @@ struct ata_port {
struct ata_acpi_gtm __acpi_init_gtm; /* use ata_acpi_init_gtm() */ struct ata_acpi_gtm __acpi_init_gtm; /* use ata_acpi_init_gtm() */
#endif #endif
/* owned by EH */ /* owned by EH */
u8 *ncq_sense_buf;
u8 sector_buf[ATA_SECT_SIZE] ____cacheline_aligned; u8 sector_buf[ATA_SECT_SIZE] ____cacheline_aligned;
}; };
...@@ -1178,6 +1189,7 @@ extern int sata_link_hardreset(struct ata_link *link, ...@@ -1178,6 +1189,7 @@ extern int sata_link_hardreset(struct ata_link *link,
bool *online, int (*check_ready)(struct ata_link *)); bool *online, int (*check_ready)(struct ata_link *));
extern int sata_link_resume(struct ata_link *link, const unsigned long *params, extern int sata_link_resume(struct ata_link *link, const unsigned long *params,
unsigned long deadline); 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); extern void ata_eh_analyze_ncq_error(struct ata_link *link);
#else #else
static inline const unsigned long * static inline const unsigned long *
...@@ -1215,6 +1227,10 @@ static inline int sata_link_resume(struct ata_link *link, ...@@ -1215,6 +1227,10 @@ static inline int sata_link_resume(struct ata_link *link,
{ {
return -EOPNOTSUPP; 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) { } static inline void ata_eh_analyze_ncq_error(struct ata_link *link) { }
#endif #endif
extern int sata_link_debounce(struct ata_link *link, extern int sata_link_debounce(struct ata_link *link,
......
...@@ -52,6 +52,11 @@ struct scsi_pointer { ...@@ -52,6 +52,11 @@ struct scsi_pointer {
#define SCMD_TAGGED (1 << 0) #define SCMD_TAGGED (1 << 0)
#define SCMD_INITIALIZED (1 << 1) #define SCMD_INITIALIZED (1 << 1)
#define SCMD_LAST (1 << 2) #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) #define SCMD_FAIL_IF_RECOVERING (1 << 4)
/* flags preserved across unprep / reprep */ /* flags preserved across unprep / reprep */
#define SCMD_PRESERVED_FLAGS (SCMD_INITIALIZED | SCMD_FAIL_IF_RECOVERING) #define SCMD_PRESERVED_FLAGS (SCMD_INITIALIZED | SCMD_FAIL_IF_RECOVERING)
......
...@@ -218,6 +218,9 @@ struct scsi_device { ...@@ -218,6 +218,9 @@ struct scsi_device {
unsigned silence_suspend:1; /* Do not print runtime PM related messages */ unsigned silence_suspend:1; /* Do not print runtime PM related messages */
unsigned no_vpd_size:1; /* No VPD size reported in header */ unsigned no_vpd_size:1; /* No VPD size reported in header */
unsigned cdl_supported:1; /* Command duration limits supported */
unsigned cdl_enable:1; /* Enable/disable Command duration limits */
unsigned int queue_stopped; /* request queue is quiesced */ unsigned int queue_stopped; /* request queue is quiesced */
bool offline_already; /* Device offline message logged */ bool offline_already; /* Device offline message logged */
...@@ -364,6 +367,8 @@ extern int scsi_register_device_handler(struct scsi_device_handler *scsi_dh); ...@@ -364,6 +367,8 @@ extern int scsi_register_device_handler(struct scsi_device_handler *scsi_dh);
extern void scsi_remove_device(struct scsi_device *); extern void scsi_remove_device(struct scsi_device *);
extern int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh); extern int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh);
void scsi_attach_vpd(struct scsi_device *sdev); void scsi_attach_vpd(struct scsi_device *sdev);
void scsi_cdl_check(struct scsi_device *sdev);
int scsi_cdl_enable(struct scsi_device *sdev, bool enable);
extern struct scsi_device *scsi_device_from_queue(struct request_queue *q); extern struct scsi_device *scsi_device_from_queue(struct request_queue *q);
extern int __must_check scsi_device_get(struct scsi_device *); extern int __must_check scsi_device_get(struct scsi_device *);
...@@ -421,8 +426,8 @@ extern int scsi_track_queue_full(struct scsi_device *, int); ...@@ -421,8 +426,8 @@ extern int scsi_track_queue_full(struct scsi_device *, int);
extern int scsi_set_medium_removal(struct scsi_device *, char); extern int scsi_set_medium_removal(struct scsi_device *, char);
extern int scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage, int scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,
unsigned char *buffer, int len, int timeout, int subpage, unsigned char *buffer, int len, int timeout,
int retries, struct scsi_mode_data *data, int retries, struct scsi_mode_data *data,
struct scsi_sense_hdr *); struct scsi_sense_hdr *);
extern int scsi_mode_select(struct scsi_device *sdev, int pf, int sp, extern int scsi_mode_select(struct scsi_device *sdev, int pf, int sp,
...@@ -433,8 +438,9 @@ extern int scsi_test_unit_ready(struct scsi_device *sdev, int timeout, ...@@ -433,8 +438,9 @@ extern int scsi_test_unit_ready(struct scsi_device *sdev, int timeout,
int retries, struct scsi_sense_hdr *sshdr); int retries, struct scsi_sense_hdr *sshdr);
extern int scsi_get_vpd_page(struct scsi_device *, u8 page, unsigned char *buf, extern int scsi_get_vpd_page(struct scsi_device *, u8 page, unsigned char *buf,
int buf_len); int buf_len);
extern int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer, 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);
extern int scsi_device_set_state(struct scsi_device *sdev, extern int scsi_device_set_state(struct scsi_device *sdev,
enum scsi_device_state state); enum scsi_device_state state);
extern struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type, extern struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type,
......
...@@ -17,7 +17,7 @@ ...@@ -17,7 +17,7 @@
((data) & IOPRIO_PRIO_MASK)) ((data) & IOPRIO_PRIO_MASK))
/* /*
* These are the io priority groups as implemented by the BFQ and mq-deadline * These are the io priority classes as implemented by the BFQ and mq-deadline
* schedulers. RT is the realtime class, it always gets premium service. For * schedulers. RT is the realtime class, it always gets premium service. For
* ATA disks supporting NCQ IO priority, RT class IOs will be processed using * ATA disks supporting NCQ IO priority, RT class IOs will be processed using
* high priority NCQ commands. BE is the best-effort scheduling class, the * high priority NCQ commands. BE is the best-effort scheduling class, the
...@@ -32,11 +32,20 @@ enum { ...@@ -32,11 +32,20 @@ enum {
}; };
/* /*
* The RT and BE priority classes both support up to 8 priority levels. * The RT and BE priority classes both support up to 8 priority levels that
* can be specified using the lower 3-bits of the priority data.
*/ */
#define IOPRIO_NR_LEVELS 8 #define IOPRIO_LEVEL_NR_BITS 3
#define IOPRIO_NR_LEVELS (1 << IOPRIO_LEVEL_NR_BITS)
#define IOPRIO_LEVEL_MASK (IOPRIO_NR_LEVELS - 1)
#define IOPRIO_PRIO_LEVEL(ioprio) ((ioprio) & IOPRIO_LEVEL_MASK)
#define IOPRIO_BE_NR IOPRIO_NR_LEVELS #define IOPRIO_BE_NR IOPRIO_NR_LEVELS
/*
* Possible values for the "which" argument of the ioprio_get() and
* ioprio_set() system calls (see "man ioprio_set").
*/
enum { enum {
IOPRIO_WHO_PROCESS = 1, IOPRIO_WHO_PROCESS = 1,
IOPRIO_WHO_PGRP, IOPRIO_WHO_PGRP,
...@@ -44,9 +53,58 @@ enum { ...@@ -44,9 +53,58 @@ enum {
}; };
/* /*
* Fallback BE priority level. * Fallback BE class priority level.
*/ */
#define IOPRIO_NORM 4 #define IOPRIO_NORM 4
#define IOPRIO_BE_NORM IOPRIO_NORM #define IOPRIO_BE_NORM IOPRIO_NORM
/*
* The 10 bits between the priority class and the priority level are used to
* optionally define I/O hints for any combination of I/O priority class and
* level. Depending on the kernel configuration, I/O scheduler being used and
* the target I/O device being used, hints can influence how I/Os are processed
* without affecting the I/O scheduling ordering defined by the I/O priority
* class and level.
*/
#define IOPRIO_HINT_SHIFT IOPRIO_LEVEL_NR_BITS
#define IOPRIO_HINT_NR_BITS 10
#define IOPRIO_NR_HINTS (1 << IOPRIO_HINT_NR_BITS)
#define IOPRIO_HINT_MASK (IOPRIO_NR_HINTS - 1)
#define IOPRIO_PRIO_HINT(ioprio) \
(((ioprio) >> IOPRIO_HINT_SHIFT) & IOPRIO_HINT_MASK)
/*
* Alternate macro for IOPRIO_PRIO_VALUE() to define an I/O priority with
* a class, level and hint.
*/
#define IOPRIO_PRIO_VALUE_HINT(class, level, hint) \
((((class) & IOPRIO_CLASS_MASK) << IOPRIO_CLASS_SHIFT) | \
(((hint) & IOPRIO_HINT_MASK) << IOPRIO_HINT_SHIFT) | \
((level) & IOPRIO_LEVEL_MASK))
/*
* I/O hints.
*/
enum {
/* No hint */
IOPRIO_HINT_NONE = 0,
/*
* Device command duration limits: indicate to the device a desired
* duration limit for the commands that will be used to process an I/O.
* These will currently only be effective for SCSI and ATA devices that
* support the command duration limits feature. If this feature is
* enabled, then the commands issued to the device to process an I/O with
* one of these hints set will have the duration limit index (dld field)
* set to the value of the hint.
*/
IOPRIO_HINT_DEV_DURATION_LIMIT_1 = 1,
IOPRIO_HINT_DEV_DURATION_LIMIT_2 = 2,
IOPRIO_HINT_DEV_DURATION_LIMIT_3 = 3,
IOPRIO_HINT_DEV_DURATION_LIMIT_4 = 4,
IOPRIO_HINT_DEV_DURATION_LIMIT_5 = 5,
IOPRIO_HINT_DEV_DURATION_LIMIT_6 = 6,
IOPRIO_HINT_DEV_DURATION_LIMIT_7 = 7,
};
#endif /* _UAPI_LINUX_IOPRIO_H */ #endif /* _UAPI_LINUX_IOPRIO_H */
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment